*DECK DHASH1
PROC DHASH1;
#     DUMMY PROCEDURE TO CAPTURE THE COMMON DECK DHASH AND GIVE THE 
      FUNCTION DHASH A NAME UNIQUE TO OVERLAY 1-0 - DHASH1. 
      THE FOLLOWING CARD IS    *CALL DHASH       #
           BEGIN
      XDEF FUNC DHASH  I; 
      FUNC DHASH(NAME,NAMELG,HASHTBL);
  
        # TOGETHER WITH THE COMPASS ROUTINE HASHDL, THIS FUNCTION WILL
          DO A HASHING OF THE NAME GIVEN AS 1ST PARAMETER AND FIND IN 
          THE HASH TABLE GIVEN AS 3RD PARAMETER THE WORD ADDRESS IN THE 
          SUBSCHEMA DIRECTORY WHERE TO FIND THE ATTRIBUTES OF THE DATA
          ITEM CORRESPONDING TO THE NAME.  #
  
        # IF THE HASHING FAILS TO LOCATE THE NAME, THE FUNCTION RETURNS 
          A ZERO.    #
      BEGIN 
          ARRAY NAME[0:2];  ITEM INAME; 
                             #1 TO 30 CHARACTERS NAME, BLANK FILLED.
                              ONLY 1 OR 2 WORDS ARE CONSIDERED BY 
                              HASHING ALGORITHM.    # 
          ITEM NAMELG;  #LENGTH OF NAME IN WORDS, 1, 2 OR 3#
          ARRAY HASHTBL[9];  #HASHING TABLE.  ACTUAL LENGTH IS 10+N  #
                 #THE HASHING TABLE CONSISTS OF 10 WORDS HEADER FOLLOWED
                  BY A VARIABLE NUMBER OF WORDS (ABOUT HALF THE NUMBER
                  OF NAMES IN THE CURRENT AREA DESCRIPTION).  # 
               BEGIN
                  ITEM HINDXRORL      U(0,0,1); 
                  ITEM  HINDXCOUNT    U(0,30,12); 
                  ITEM  HINDXPARTLOC  U(0,42,18); 
               END
  
  
  
          XREF BEGIN
                 PROC HASHDL;      #COMPASS ROUTINE PERFORMING HASHING# 
                 ITEM HASHNAM;     #ITEM NAME TREATED AS INTEGER# 
                 ITEM HRSLT1, HRSLT2;  #HASH RESULTS RETURNED BY DHASH #
                END 
  
  
             BASED ARRAY HASHRESULT[0]; 
               BEGIN
                  ITEM  HRSLTLVLL    U(0,0,2);
                  ITEM  HRSLTL       U(0,2,10); 
                  ITEM  HRSLTBIASL   U(0,12,18);
                  ITEM  HRSLTLVLR    U(0,30,2); 
                  ITEM  HRSLTR       U(0,32,10);
                  ITEM  HRSLTBIASR   U(0,42,18);
               END
           ITEM IY U; 
           ITEM NY  U;
           ITEM KY U; 
           ITEM LY U; 
           ITEM CHKWORD  U; 
           ITEM EY; 
          CONTROL EJECT;
  
          HASHNAM=INAME[0];  #PASS 1ST 10 CHARACTERS OF NAME AS IF IT 
                              WAS AN INTEGER NUMBER.  # 
          IF NAMELG NQ 1 THEN HASHNAM=HASHNAM+INAME[1]; 
                             #IF MORE THAN 10 CHARACTERS, ADD FOLLOWING 
                              10 CHARACTERS TO PREVIOUS ONES.    #
          HASHDL;            # HASH THE NAME  # 
          P<HASHRESULT>=LOC(HASHTBL)+10;
           IY=B<50,3>HRSLT1;               #PARTITION NUMBER# 
           EY=1;                            #ENTRY COUNTER# 
           NY=HINDXCOUNT[IY+2];             #NO OF ENTRIES IN PARTITION#
           KY=HINDXPARTLOC[IY+2];          #BEGINNING ADDR OF PARTITION#
               LY=HINDXPARTLOC[0];                #LENGTH OF HASH TABLE#
           IF HINDXRORL[IY+2] EQ 1 THEN GOTO  HALF2;
           H10: 
               CHKWORD=HRSLTBIASL[KY];
               IF HRSLTL[KY] NQ HRSLT1 OR HRSLTLVLL[KY] NQ 0 THEN 
                 BEGIN
                   EY=EY+1; 
                   IF EY GR NY THEN GOTO  HFAILED;
                   KY=KY+1; 
                   IF KY GQ LY THEN 
                     BEGIN
                       KY=0;
                       GOTO  HALF2; 
                     END
                   GOTO  H10; 
                 END
               EY=EY+1; 
               IF EY GR NY THEN GOTO  HOKAY;
               KY=KY+1; 
               IF KY GQ LY THEN 
                 BEGIN
                   KY=0;
                   GOTO  H20; 
                 END
               IF HRSLTLVLL[KY] EQ 0 THEN GOTO  HOKAY;
           H15: 
               IF HRSLT2 EQ HRSLTL[KY] THEN 
                 BEGIN
                   CHKWORD=HRSLTBIASL[KY];
                   GOTO  HOKAY; 
                 END
               EY=EY+1; 
               IF EY GR NY THEN GOTO  HFAILED;
               KY=KY+1; 
               IF KY GQ LY THEN 
                 BEGIN
                   KY=0;
                   GOTO  H30; 
                 END
               IF HRSLTLVLL[KY] EQ 0 THEN GOTO  HFAILED;
               GOTO  H15; 
           HALF2: 
               CHKWORD=HRSLTBIASR[KY];
               IF HRSLTR[KY] NQ HRSLT1 OR HRSLTLVLR[KY] NQ 0 THEN 
                 BEGIN
                   EY=EY+1; 
                   IF EY GR NY THEN GOTO  HFAILED;
                   KY=KY+1; 
                   IF KY GQ LY THEN GOTO  HFAILED;
                   GOTO  HALF2; 
                 END
               EY=EY+1; 
               IF EY GR NY THEN GOTO  HOKAY;
               KY=KY+1; 
               IF KY GQ LY THEN GOTO  HFAILED;
           H20: 
               IF HRSLTLVLR[KY] EQ 0 THEN GOTO  HOKAY;
           H25: 
               IF HRSLT2 EQ HRSLTR[KY] THEN 
                 BEGIN
                   CHKWORD=HRSLTBIASR[KY];
                   GOTO  HOKAY; 
                 END
               EY=EY+1; 
               KY=KY+1; 
               IF EY GR NY OR KY GQ LY THEN GOTO  HFAILED;
           H30: 
               IF HRSLTLVLR[KY] NQ 0 THEN GOTO  H25;
           HFAILED: 
                DHASH = 0;
               RETURN;
           HOKAY: 
                DHASH = HINDXPARTLOC[1] + CHKWORD;
               RETURN;
           END
      END 
          TERM
