*DECK  DLHASH 
USETEXT TDLSCOM 
      PROC DLHASH;
      BEGIN 
  
#**********************************************************************#
#                                                                      #
#         D L H A S H  --  DDL SCHEMA HASH INDEX BUILD.                #
#                                                                      #
# PURPOSE   BUILD A HASH INDEX TABLE AT END OF SCHEMA DIRECTORY TO     #
#         BUILD ACCESS TO ALL AREA, RECORD, SET, AND ITEM ENTRIES WITH #
#         THEIR ENTRY NAMES AS INPUT TO A HASH ROUTINE.                #
#                                                                      #
# ENTRY     EXISTING SOMEWHERE IS A SYMBOL TABLE THAT CONTAINS AN ENTRY#
#         FOR EACH AREA, RECORD, SET, AND ITEM IN THE SCHEMA. THIS     #
#         TABLE IS ACCESSED WITH ROUTINE "DDLRDSY" BY SPECIFYING LOC   #
#         RELATIVE TO START OF TABLE, AND NUMBER OF WORDS TO BE READ.  #
#           NUMNAMES = NUMBER OF ENTRIES IN SYMBOL TABLE.              #
#           NEXTPTR  = WORD ADD IN SCHEMA FOR STORING HASH INDEX.      #
#                                                                      #
# EXIT      HASH INDEX TABLE BUILT AS LAST ENTRY IN SCHEMA DIRECTORY.  #
#                                                                      #
# CALLED    DLSCHEMA - FROM THE ABORT AND ENDRUN SEMANTIC ROUTINE.     #
#                                                                      #
# CALLS     CLSEOFL - CLOSE OVERFLOW AREA.                             #
#           CLSEPRM - CLOSE PRIME AREA.                                #
#           DDLRYSY - READ SYMBOL TABLE.                               #
#           DDLRDSC - READ SCHEMA.                                     #
#           DDLRTSC - WRITE SCHEMA.                                    #
#           DLOPNWK - OPEN PRIME AREA.                                 #
#           DLOPOFL - OPEN OVERFLOW AREA.                              #
#           DLRDPRM - READ PRIME AREA.                                 #
#           DLRTPRM - WRITE PRIME AREA.                                #
#           DLRDOFL - READ OVERFLOW AREA.                              #
#           DLRTOFL - WRITE OVERFLOW AREA.                             #
#           HASHNM  - HASH NAME.                                       #
#                                                                      #
# TABLES    HASHNNTRY - 2 WORD BUFFER FOR BUILDING CURRENT PRIME ENTRY.#
#                       2ND WORD CONTAINS PTR TO SYMBOL TABLE FOR THE  #
#                       ENTRY, AND WILL BE IGNORED WHEN PRIME ENTRY IS #
#                       COPIED INTO SCHEMA IN PASS 2.                  #
#           SAVEENTRY - 2 WORD BUFFER TO HOLD EXISTING PRIME ENTRY     #
#                       THAT IS TO BE LOOKED AT OR MODIFIED.           #
#           OFLENTRY  - 4 WORD BUFFER TO HOLD OVERFLOW ENTRY, WHILE    #
#                       BUILDING IT OR READING IT.                     #
#           SYMBUFWK  - 7 WORD BUFFER FOR HOLDING CURRENT ENTRY READ   #
#                       FROM SYMBOL TABLE.                             #
#           SYMBUFDF  - 7 WORD BUFFER FOR HOLDING SYMBOL TABLE ENTRY   #
#                       OTHER THAN THE CURRENT ONE. THUS, EVERY TIME A #
#                       NEW ENTRY IS BUILT, ITS SYMBOL TABLE ENTRY WILL#
#                       BE FOUND IN "SYMBUFWK", WHILE ANY OTHER SYMBOL #
#                       TABLE ENTRY THAT IS TO BE LOOKED AT WILL BE    #
#                       PLACED IN "SYMBUFDF".                          #
#           SCCWENTRY - BUFFER FOR READING AND SETTING SCHEMA CONTROL  #
#                       WORD SECTION.                                  #
#                                                                      #
# METHOD    THE HASH INDEX, CONSISTING OF A PRIME SECTION AND AN       #
#         OVERFLOW SECTION, IS BUILT IN 2 PASSES. IN PASS 1, A         #
#         TEMPORARY PRIME AREA AND OVERFLOW AREA ARE BUILT IN 2        #
#         SEPARATE FILES. THE TEMP PRIME AREA HAS 2 WORDS PER ENTRY.   #
#         THE 1ST WORD CONTAINS THE INDEX INFO, WHILE THE 2ND WORD IS  #
#         FOR TEMPORARY HOLDING THE SYMBOL TABLE ENTRY LOC FOR THE     #
#         ENTRY. IN PASS 2, THE TEMP PRIME AREA AND OVERFLOW AREA ARE  #
#         COPIED INTO THE SCHEMA DIRECTORY, WITH THE 2ND WORD OF EACH  #
#         TEMP PRIME ENTRY IGNORED, TO BECOME THE PERMANENT HASH INDEX.#
#           WITH THE NUMBER OF ENTRIES IN THE SCHEMA, A SIZE FOR THE   #
#         PRIME AREA IS DERIVED. A HASHID WILL BE CALCULATED FOR EACH  #
#         ENTRY BASED ON THE ENTRY NAMES. THE REMAINDER ON DIVIDING    #
#         THE HASHID BY THE PRIME AREA SIZE WILL GIVE THE LOCATION IN  #
#         THE PRIME AREA FOR STORING THE INDEX INFORMATION FOR THE     #
#         PARTICULAR ENTRY.                                            #
#           THERE ARE 3 WAYS IN WHICH THE HASH LOCATION CAN BE         #
#         DUPLICATED:                                                  #
#           1. SAMENAMES  - THE ENTRIES HAVE THE SAME NAME, AND ARE OF #
#                           THE SAME TYPE.                             #
#           2. SYNONYMS   - THE ENTRIES HAVE DIFFERENT NAMES, BUT ARE  #
#                           OF THE SAME TYPE, AND THE HASHING SCHEME   #
#                           YIELDS THE SAME HASH-ID.                   #
#           3. COLLISIONS - THE HASH-IDS OR NAME TYPES OR BOTH ARE     #
#                           UNEQUAL, BUT THE DIVISION YIELDS THE SAME  #
#                           HASH LOCATION.                             #
#           COLLISIONS ARE REDISTRIBUTED TO THE NEXT NEAREST AVAILABLE #
#         LOCATIONS IN THE PRIME AREA, AND ARE CHAINED TOGETHER.       #
#           SYNONYMS ARE STORED IN THE OVERFLOW AREA SHOWING THEIR FULL#
#         NAMES. ENTRIES IN EACH SYNONYM GROUP ARE CHAINED TOGETHER,   #
#         AND THE 1ST ONE IS POINTED TO FROM THE PRIME AREA.           #
#           SAMENAMES ARE REDISTRIBUTED SAME AS COLLISIONS, BUT IF     #
#         THERE ARE SYNONYMS, THEY WOULD ALL GO INTO THE OVERFLOW AREA.#
#           DUE TO THE SIZE LIMITATION OF THE CHAIN POINTER IN THE     #
#         PRIME INDEX ENTRY, NO LINKED ENTRIES CAN BE 255 WORDS APART. #
#         IF THERE IS NO AVAILABLE SPACE WITHIN THIS 255 WORD LIMIT,   #
#         THE NEW ENTRY AND THE LAST CHAINED ENTRY WILL BE TREATED AS  #
#         SYNONYMS, AND WILL GO INTO THE OVERFLOW AREA WITH THEIR FULL #
#         NAMES. EVERY NEW COLLISION ENTRY ADDED TO THE CHAIN WILL GO  #
#         INTO THIS OVERFLOW CHAIN IN THE SAME MANNER.                 #
#           WHILE BUILDING THE HASH INDEXES, WHENEVER A PRIME ENTRY    #
#         BRANCHES INTO THE OVERFLOW AREA, A FLAG IN THE TEMPORARY     #
#         2ND WORD OF THE PRIME ENTRY WILL INDICATE WHETHER IT IS A    #
#         REAL SYNONYM CASE, OR AN OUT-OF-SPACE COLLISION CASE. THIS   #
#         WILL LET US KNOW WHERE THE NEXT COLLISION ENTRY SHOULD BE    #
#         PUT: PRIME OR OVERFLOW.                                      #
#                                                                      #
# PROC      BASED ON NUMBER OF ENTRIES IN SYMBOL TABLE, CALCULATE SIZE #
#         OF PRIME AREA, WHICH WILL ALSO BE THE MODULUS USED TO GET    #
#         HASH LOCATIONS.                                              #
#           OPEN PRIME AREA AND INITIALIZE IT TO ZEROS.                #
#           READ FIRST SYMBOL TABLE ENTRY.                             #
#           WITH THE ENTRY NAME, GET HASH-ID, AND THEN HASH LOCATION.  #
#           CHECK IF THE LOCATION IS OCCUPIED BY ANOTHER ENTRY. IF NO, #
#         BUILD PRIME ENTRY AND STORE IT. IF YES, CALL "DOCOLLISION"   #
#         FOR COLLISION PROCESSING.                                    #
#           READ NEXT SYMBOL TABLE ENTRY AND REPEAT PROCESS.           #
#           WHEN ALL ENTRIES ARE PROCESSED, COPY BOTH PRIME AND        #
#         OVERFLOW AREAS INTO SCHEMA DIRECTORY, AND SET POINTER AND    #
#         LENGTH IN CONTROL WORD SECTION.                              #
#           CLOSE ALL FILES.                                           #
#                                                                      #
#**********************************************************************#
  
      DEF CALL # #; 
      DEF XCALL # #;
  
      XREF
        BEGIN 
        PROC CLSEOFL;        #CLOSE OVERFLOW AREA.                     #
        PROC CLSEPRM;        #CLOSE PRIME AREA.                        #
        PROC DDLRDSC;        #READ FROM SCHEMA.                        #
        PROC DDLRDSY;        #READ FROM SYMBLE TABLE.                  #
        PROC DDLRTSC;        #WRITE TO SCHEMA.                         #
        PROC DLOPNWK;        #OPEN WORK AREA TO SET UP PRIME AREA.     #
        PROC DLOPOFL;        #OPEN OVERFLOW AREA.                      #
        PROC DLRDPRM;        #READ FROM PRIME AREA.                    #
        PROC DLRTPRM;        #WRITE TO PRIME AREA.                     #
        PROC DLRDOFL;        #READ FROM OVERFLOW AREA.                 #
        PROC DLRTOFL;        #WRITE TO OVERFLOW AREA.                  #
        PROC HASH20;         #HASH NAME TO GIVE A 20 BIT HASH-ID.      #
        END 
  
  
  
      ARRAY HASHNNTRY[1];    #HASH INDEX PRIME ENTRY. 1 WORD PER ENTRY. 
                              2ND WORD IS USED ONLY WHILE BUILDING IT. #
        BEGIN 
        ITEM HASHENTWORD U(0,0,60);    #HASH PRIME ENTRY WHOLE WORD.   #
        ITEM HASHENT30 U(0,0,30);      #30 BIT HASH ID.                #
        ITEM HASHNAMTYPE U(0,30,2);    #NAME TYPE:  0 - ITEM. 
                                                    1 - RECORD. 
                                                    2 - SET.
                                                    3 - AREA.          #
        ITEM HASHSAMENAME B(0,32,1);   #TRUE - ENTRY HAS SAMENAME.     #
        ITEM HASHSYN B(0,33,1);        #TRUE - ENTRY HAS SYNONYM.      #
        ITEM HASHCHAIN U(0,34,8);      #OFFSET PTR TO NEXT ENTRY IN 
                                        CHAIN.                         #
        ITEM HASHWA U(0,42,18);        #WA OF ENTRY IN SCHEMA. OR, IF 
                                        SYNONYM BIT IS SET, PTR TO
                                        ENTRY IN OVERFLOW AREA.        #
        ITEM HASHCLLSNFLG B(0,0,1);    #WHEN CHAIN-PTR IN WORD 0 IS 0,
                                        THIS WILL INDICATE IF CLOOISION 
                                        CHAIN CONTINUES IN OVERFLOW.   #
        ITEM HASHSYMLOC U(0,42,18);    #PTR TO ENTRY IN SYMBOL TABLE.  #
        END 
  
      ARRAY MOVEBUFFER[29];  # BUFFER FOR MOVING FROM PRIME HASH FILE  #
        BEGIN 
        ITEM MOVEWORD  (00,00,60);
        END 
  
      ARRAY SAVEENTRY[1];    #TO HOLD EXISTING HASH PRIME ENTRY SHEN
                              READ FROM HASH INDEX FILE.               #
        BEGIN 
        ITEM SAVEENTWORD U(0,0,60); 
        ITEM SAVEENT30 U(0,0,30); 
        ITEM SAVENAMTYPE U(0,30,2); 
        ITEM SAVESAMENAME B(0,32,1);
        ITEM SAVESYN B(0,33,1); 
        ITEM SAVECHAIN U(0,34,8); 
        ITEM SAVEWA U(0,42,18); 
        ITEM SAVECLLSNFLG B(0,0,1); 
        ITEM SAVESYMLOC U(0,42,18); 
        END 
  
      ARRAY OFLENTRY[3];     #HASH INDEX OVERFLOW ENTRY. ENTRY LENGTH 
                              AT LEAST 2 WORDS, AT MOST 4 WORDS, DEPEND 
                              ON NAME LENGTH.                          #
        BEGIN 
        ITEM OFLENTWORD U(0,0,60);     #OVERFLOW ENTRY WHOLE WORD.     #
        ITEM OFLENTNMLENW U(0,0,6);    #ENTRY NAME LENGTH IN WORDS.    #
        ITEM OFLENTTYP U(0,6,2);       #ENTRY TYPE.                    #
        ITEM OFLENTSYMLOC U(0,12,15);  # SYMBOL TABLE LOCATN           #
        ITEM OFLENTWA U(0,27,18);      # WA OF ENTRY IN SCHEMA         #
        ITEM OFLENTNXTPTR U(0,45,15);  # OFFSET PTR TO NEXT ENTRY      #
        END 
  
      ARRAY REHASHSAVE [0:19]  S(1);   # SAVE AREA FOR REHASHING  # 
        BEGIN 
        ITEM REHSHSAVWD    U(0,0,60); 
        ITEM REHSHSAV30    U(0,0,30);     # SAVEENTRY AREA, WORDS 0,1#
        ITEM REHSHNMTYPE   U(0,30,2); 
        ITEM REHSHSMNAM    B(0,32,1); 
        ITEM REHSHSYN      B(0,33,1); 
        ITEM REHSHCHAIN    U(0,34,8); 
        ITEM REHSHWA       U(0,42,18);
        ITEM REHSHCLLSN    B(1,0,1);
        ITEM REHSHSYMLOC   U(1,42,18);
        ITEM REHSHSYMWK    U(2,0,60);      # SYMBUFWK SAVE, WORDS 2-9#
        ITEM REHSHSYMDF    U(10,0,60);     # SYMBUFDF SAVE, WDS 10-17  #
        END 
  
      ARRAY ZEROED[9];
        ITEM ZEROS U(0,0,60)=[10(0)]; 
  
      BASED ARRAY HNAME;;    #DUMMY BASED ARRAY FOR HASH NAME.         #
  
      ITEM BESTMOD;          #BEST MODULUS TO DIVIDE "HASHID" BY. THIS
                              ALSO IS THE SIZE OF PRIME AREA.          #
      ITEM CURMOVE;          # NUMBER MOVED ON THIS LOOP.              #
      ITEM CUROFLCHAIN;      #CHAIN PTR IN CURRENT OVERFLOW ENTRY.     #
      ITEM CURPRMCHAIN;      #CHAIN PTR IN CURRENT PRM ENTRY.          #
      ITEM HASHID;           #HASH ID OBTAINED FROM "HASHNM" ROUTINE.  #
      ITEM I;                #SCRATCH VARIABLE.                        #
      ITEM J;                #SCRATCH VARIABLE FOR LOOPING.            #
      ITEM OFLCHNSTART;      #STARTING LOC OF O"FLOW CHAIN OF INTEREST.#
      ITEM OFLLOC;           #CURRENT LOC OF INTEREST IN OVERFLOW AREA.#
      ITEM OFLNEXTAVAIL;     #NEXT AVAILABLE LOC IN OVERFLOW AREA.
                              RELATIVE TO BEGINNING OF OVERFLOW AREA.  #
      ITEM OFLOPENED B;      #TRUE - OFL AREA OPENED FOR OUTPUT.       #
      ITEM OPENSLOTOFS;      #OFFSET FROM "PRIMELOC" TO NEXT OPEN SLOT.#
      ITEM PRIMELOC;         #CURRENT OLC OF INTEREST IN PRIME AREA.   #
      ITEM PRIMESIZE;        #LENGTH OF PRIME AREA.                    #
      ITEM PRIMESIZE2;       #TWO TIMES SIZE OF PRIME AREA. IT IS SIZE
                              OF TEMP PRIME AREA IN PASS 1.            #
      ITEM REHASHDONE B;     # FLAG TO SHOW REHASH WAS DONE # 
      ITEM REHASHFLAG B;     # TRUE IF REHASHING FOR SYNONYM CHAIN   #
      ITEM REHASHID;         # HASHID FOR REHASHED NAME                #
      ITEM REHASHPLOC;       # PRIMELOC FOR REHASHED ANAME             #
      ITEM REHASHSYMLOC;     # SAVE FOR SYMBLLOC FOR REHASHING         #
      ITEM REMAINING;        # NUMBER REMAINING TO BE MOVED            #
      ITEM SAMENAMEFLAG B=FALSE;       #FLAG TO INDICATE CURRENT PRIME
                                        ENTRY TO BE BUILT IS TO HAVE
                                        SAMENAME FLAG SET.             #
      ITEM SAVEOFLLOC;       #SAVE CURRENT LOC OF INTEREST IN OVERFLOW #
                             #AREA.                                    #
      ITEM SYMTABLOC;        #SAVE LOC WITHIN SYMBOL TABLE OF NEXT ENT #
      ITEM SYMTBLLOC;        #POINTS TO LOC WITHIN SYMBOL TABLE OF
                              CURRENT ENTRY DURING REHASHING PROCESS   #
      ITEM SVOFLNXTAV ;      #SAVE ADDR OF NEXT AVAILABLE LOCATION IN  #
                             #THE OVERFLOW AREA                        #
      CONTROL EJECT;
  
#**********************************************************************#
#                                                                      #
#     S A M E N M W K D F  --  SAME NAME "SYMBUFWK" AND "SYMBUFDF".    #
#                                                                      #
# PURPOSE   CHECK IF THE SYMBOL TABLE ENTRIES IN "SYMBUFWK" AND        #
#         "SYMBUFDF" HAVE IDENTICAL NAMES.                             #
#                                                                      #
# ENTRY     ARRAY "SYMBUFWK" CONTAINS CURRENT SYMBOL TABLE ENTRY.      #
#           ARRAY "SYMBUFDF" CONTAINS A PRIOR SYMBOL TABLE ENTRY.      #
#                                                                      #
# EXIT      SAMENMWKDF = TRUE  IF THE 2 ENTRY NAMES ARE IDENTICAL.     #
#                      = FALSE IF THE 2 ENTRY NAMES ARE DIFFERENT.     #
#                                                                      #
# PROC      CHECK THE 2 NAME-LENGTHS, AND THEN THE NAMES WORD BY WORD. #
#         RETURN TRUE IF THEY ARE IDENTICAL, FALSE IF NOT.             #
#                                                                      #
#**********************************************************************#
  
      FUNC SAMENMWKDF B;     #SAME NAME IN "SYMBUFWK" AND "SYMBUFDF".  #
      BEGIN 
      SAMENMWKDF=FALSE;      #INITIALIZE TO FALSE.                     #
      IF SYMNAMLENWK[1] NQ SYMNAMLENDF[1] THEN   #NAME LENTHS DIFF.    #
        RETURN; 
      FOR I=1 STEP 1 UNTIL SYMNAMLENWK[1] DO     #CHECK NAMES WD BY WD.#
        BEGIN 
        IF SYMNAMEWK[I+3] NQ SYMNAMEDF[I+3] THEN
          RETURN; 
        END 
      SAMENMWKDF=TRUE;
      END 
      CONTROL EJECT;
  
#**********************************************************************#
#                                                                      #
#     S M N M T Y O F L D F  --  SAME NAME AND TYPE IN "OFLENTRY" AND  #
#                                "SYMBUFDF".                           #
#                                                                      #
# PURPOSE   CHECK IF ENTRIES IN "OFLENTRY" AND "SYMBUFDF" ARE OF SAME  #
#         TYPE AND HAVE SAME NAME.                                     #
#                                                                      #
# ENTRY     ARRAY "OFLENTRY" CONTAINS OVERFLOW ENTRY.                  #
#           ARRAY "SYMBUFDF" CONTAINS SYMBOL TABLE ENTRY.              #
#                                                                      #
# EXIT      SMNMTYOFLDF = TRUE  IF ENTRIES ARE SAME TYPE AND SAME NAME.#
#                       = FALSE IF NOT.                                #
#                                                                      #
# PROC      CHECK THE 2 ENTRY TYPES. RETURN FALSE IF DIFFERENT.        #
#           CHECK THE 2 ENTRY NAME-LENGTHS. RETURN FALSE IF DIFFERENT. #
#           CHECK THE 2 ENTRY NAMES WORD BY WORD. RETURN FALSE IF      #
#         DIFFERENT. IF IDENTICAL, RETURN TRUE.                        #
#                                                                      #
#**********************************************************************#
  
      FUNC SMNMTYOFLDF B;    #ENTRIES IN "OFLENTRY" AND "SYMBUFDF"
                              HAVE SAME NAME AND SAME TYPE.            #
      BEGIN 
      SMNMTYOFLDF=FALSE;
      IF OFLENTTYP[0] NQ (SYMNAMTYPEDF[0]-1) THEN #YES- TYPE DIFFERENT.#
        RETURN; 
      IF OFLENTNMLENW[0] NQ SYMNAMLENDF[1] THEN  #YES - NAME LENG DIFF.#
        RETURN; 
      FOR I=1 STEP 1 UNTIL OFLENTNMLENW[0] DO    #CHECK NAMES WD BY WD.#
        BEGIN 
        IF OFLENTWORD[I] NQ SYMNAMEDF[I+3] THEN 
          RETURN; 
        END 
      SMNMTYOFLDF=TRUE; 
      END 
       CONTROL EJECT; 
  
# INITIALIZE A FEW ITEMS AND FLAGS......                               #
  
      OFLOPENED=FALSE;       #INDICATES OVERFLOW AREA NOT YET OPENED.  #
      OFLNEXTAVAIL=0;        #NEXT AVAILABLE LOC IN O"FLOW. START AT 0.#
      SYMTABLOC=0;           #NEXT SYMBOL TABLE ENTRY LOC. START AT 0. #
      SYMTBLLOC=0;
      REHASHFLAG = FALSE; 
  
# FIND THE BEST MODULUS FOR OUR HASHING SCHEME. THIS WILL EQUAL SIZE   #
# OF FINAL PRIME AREA.                                                 #
  
      CALL FINDBESTMOD;      #FIND BEST MODULUS.                       #
      PRIMESIZE=BESTMOD;
      PRIMESIZE2=PRIMESIZE*2; 
  
# OPEN AND INITIALIZE PRIME AREA TO ZEROS.                             #
  
      XCALL DLOPNWK;
      FOR I=0 STEP 10 UNTIL PRIMESIZE2 DO 
        XCALL DLRTPRM(ZEROED,10,I); 
  
# START BUILDING HASH TABLE ENTRY BY ENTRY.                            #
  
      FOR J=1 STEP 1 UNTIL NUMNAMES DO
        BEGIN 
  
# READ SYMBLE TABLE ENTRY INTO BUFFER.                                 #
  
 RDSY:  XCALL DDLRDSY( SYMBUFWK, 3, SYMTABLOC );
        IF SYMREFWK [0] EQ 1
          THEN
          BEGIN 
          SYMTABLOC = SYMTABLOC + 1;
          GOTO RDSY;       # SKIP 1 WORD REFERENCE ENTRIES #
          END 
        IF SYMDEFWK [0] EQ 0
          THEN
          BEGIN 
          SYMTABLOC = SYMNEXTWK [0];
          GOTO RDSY;       # SKIP UNDEFINED NAMES          #
          END 
        IF SYMKCONFLGWK[2]
        THEN
          BEGIN 
          SYMTABLOC = SYMNEXTWK[0]; 
          TEST J; 
          END 
        XCALL DDLRDSY(SYMBUFWK,SYMNAMLENWK[1]+4,SYMTABLOC); 
  
# CALCULATE LOCATION IN PRIME AREA.                                    #
  
        P<HNAME>=LOC(SYMNAMEWK[4]); 
        XCALL HASH20(HNAME,SYMNAMLENWK[1],HASHID);
  
# SET SYMTABLOC TO LOC OF NEXT ENTRY IN THE SYMBOL TABLE, AND SYMTBLLOC#
# TO THE LOC OF CURRENT ENTRY.                                         #
  
        SYMTBLLOC = SYMTABLOC;
        SYMTABLOC = SYMNEXTWK[0]; 
  
# COMPUTE PRIMELOC, READ ENTRY. EMPTY - STORE NEW PRIME ENTRY.         #
#                            FULL - DO COLLISION PROCESSING.           #
  
        CALL MAKEPRMENT;
MAKEPRETURN:     # THIS LABEL USED TO RETURN FROM MAKEPRMENT           #
  
        END 
  
# NOW WE HAVE BUILT THE PRIME AREA AND OVERFLOW AREA IN 2 FILES. WE 
  WILL NOW COPY THEM ONTO THE SCHEMA FILE.                             #
  
# SET HASH TABLE WORD ADDR AND LENGTH IN SCHEMA CONTROL WORDS.         #
  
      SCCWHASHADDR[0]=NEXTPTR;
      SCCWHSHTBLEN[0]=PRIMESIZE;
      SCCWHASH20[0]=TRUE;          # FLAG THAT A 20 BIT HASH WAS USED. #
  
# COPY PRIME AREA INTO SCHEMA.                                         #
  
      PRIMELOC=0; 
      CURMOVE = 15; 
      FOR REMAINING = PRIMESIZE STEP - CURMOVE UNTIL 1
      DO
        BEGIN 
        IF CURMOVE GR REMAINING 
        THEN
          BEGIN 
          CURMOVE = REMAINING;
          END 
        XCALL DLRDPRM(MOVEBUFFER,CURMOVE*2,PRIMELOC); 
        PRIMELOC = PRIMELOC + (CURMOVE*2);
        FOR I=1 STEP 1 UNTIL CURMOVE-1
        DO
          BEGIN 
          MOVEWORD[I] = MOVEWORD[I*2];
          END 
        XCALL DDLRTSC(MOVEBUFFER,CURMOVE,NEXTPTR);
        NEXTPTR = NEXTPTR + CURMOVE;
        END 
  
# COPY OVERFLOW AREA INTO SCHEMA WORD BY WORD.                         #
  
      OFLLOC=0; 
      FOR I=1 STEP 1 UNTIL OFLNEXTAVAIL DO
        BEGIN 
        XCALL DLRDOFL(OFLENTRY,1,OFLLOC); 
        XCALL DDLRTSC(OFLENTRY,1,NEXTPTR);
        OFLLOC=OFLLOC+1;
        NEXTPTR=NEXTPTR+1;
        END 
  
# CLOSE PRIME AND OVERFLOW AREAS.                                      #
  
      XCALL CLSEPRM;
      IF OFLOPENED THEN      #YES - OVERFLOW AREA EXISTS AND OPENED.   #
        XCALL CLSEOFL;
       CONTROL EJECT; 
  
#**********************************************************************#
#                                                                      #
#     B U I L D O F L D F  --  BUILD OVERFLOW ENTRY FROM "SYMBUFDF".   #
#                                                                      #
# PURPOSE   BUILD OVERFLOW ENTRY FOR SYMBOL TABLE ENTRY CURRENTLY IN   #
#         BUFFER "SYMBUFDF".                                           #
#                                                                      #
# ENTRY     ARRAY "SYMBUFDF" CONTAINS SYMBOL TABLE ENTRY.              #
#                                                                      #
# EXIT      ARRAY "OFLENTRY" CONTAINS OVERFLOW ENTRY JUST BUILT WITH   #
#         INFO FROM "SYMBUFDF".                                        #
#                                                                      #
# PROC      SET ENTRY TYPE, ENTRY WORD ADDRESS IN SCHEMA, ENTRY NAME   #
#         LENGTH, AND ENTRY NAME IN "OFLENTRY" TO VALUES FOUND IN      #
#         "SYMBUFDF".                                                  #
#           SET NEXT-PTR TO POINT TO LOCATION RIGHT AFTER CURRENT      #
#         ENTRY, BECAUSE THERE WILL BE ANOTHER ENTRY (OR MORE) OF THE  #
#         SAME CHAIN TO BE BUILT NEXT.                                 #
#                                                                      #
#**********************************************************************#
  
      PROC BUILDOFLDF;       #BUILD OVERFLOW ENTRY FROM "SYMBUFDF".    #
      BEGIN 
      OFLENTWORD[0]=0;
      OFLENTTYP[0]=SYMNAMTYPEDF[0]-1; 
      OFLENTWA[0]=SYMWRDADDRDF[1];
      OFLENTNMLENW[0]=SYMNAMLENDF[1]; 
      OFLENTSYMLOC [0] = SAVESYMLOC [1];
      OFLENTNXTPTR[0]=OFLENTNMLENW[0]+1;
      FOR I=1 STEP 1 UNTIL OFLENTNMLENW[0] DO 
        OFLENTWORD[I]=SYMNAMEDF[I+3]; 
      END 
       CONTROL EJECT; 
  
#**********************************************************************#
#                                                                      #
#     B U I L D O F L W K  --  BUILD OVERFLOW ENTRY FROM "SYMBUFWK".   #
#                                                                      #
# PURPOSE   BUILD OVERFLOW ENTRY FOR SYMBOL TABLE ENTRY CURRENTLY IN   #
#         BUFFER "SYMBUFWK".                                           #
#                                                                      #
# ENTRY     ARRAY "SYMBUFWK" CONTAINS CURRENT SYMBOL TABLE ENTRY.      #
#                                                                      #
# EXIT      ARRAY "OFLENTRY" CONTAINS OVERFLOW ENTRY JUST BUILT WITH   #
#         INFO FROM "SYMBUFWK".                                        #
#                                                                      #
# PROC      SET ENTRY TYPE, ENTRY WORD ADDRESS IN SCHEMA, ENTRY NAME   #
#         LENGTH, AND ENTRY NAME IN "OFLENTRY" TO VALUES FOUND IN      #
#         "SYMBUFWK".                                                  #
#           SET NEXT-PTR TO 0, BECAUSE THIS WILL ALWAYS BE THE CURRENT #
#         LAST ENTRY IN CURRENT OVERFLOW CHAIN.                        #
#                                                                      #
#**********************************************************************#
  
      PROC BUILDOFLWK;       #BUILD OVERFLOW ENTRY FROM "SYMBUFWK".    #
      BEGIN 
  
# THIS IS ALWAYS THE CURRENT LAST ENTRY IN THE OVERFLOW CHAIN.         #
  
      OFLENTWORD[0]=0;
      OFLENTTYP[0]=SYMNAMTYPEWK[0]-1; 
      OFLENTWA[0]=SYMWRDADDRWK[1];
      OFLENTNMLENW[0]=SYMNAMLENWK[1]; 
      OFLENTSYMLOC [0] = SYMTBLLOC; 
      FOR I=1 STEP 1 UNTIL OFLENTNMLENW[0] DO 
        OFLENTWORD[I]=SYMNAMEWK[I+3]; 
      END 
       CONTROL EJECT; 
  
#**********************************************************************#
#                                                                      #
#     B U S T O R P R M E N T  --  BUILD-STORE PRIME ENTRY.            #
#                                                                      #
# PURPOSE   BUILD CURRENT PRIME ENTRY AND STORE IT INTO PRIME AREA.    #
#                                                                      #
# ENTRY     ARRAY "SYMBUFWK" CONTAINS CURRENT SYMBOL TABLE ENTRY.      #
#           SAMENAMEFLAG = TRUE IF SAME NAME BIT IS TO BE SET.         #
#                                                                      #
# EXIT      ARRAY "HASHENTRY" CONTAINS PRIME ENTRY JUST BUILT, AND IT  #
#         HAS BEEN WRITTEN OUT TO PRIME AREA.                          #
#                                                                      #
# PROC      WITH INFO FROM "SYMBUFWK", SET HASHID, ENTRY TYPE, WORD    #
#         ADDRESS IN SCHEMA, AND SYMBOL TABLE LOCATION.                #
#           IF "SAMENAMEFLAG" IS TRUE, SET SAMENAME BIT AND SET        #
#         "SAMENAMEFLAG" TO FALSE.                                     #
#           SET SYNONYM BIT TO FALSE, AND CHAIN-PTR TO 0.              #
#           CALL "DLRTPRM" TO WRITE ENTRY ONTO PRIME AREA.             #
#                                                                      #
#**********************************************************************#
  
      PROC BUSTORPRMENT;     #BUILD AND STORE PRIME ENTRY.             #
      BEGIN 
      HASHENTWORD[0]=0;      #INITIALIZE TO 0.                         #
      HASHENTWORD[1]=0; 
      HASHENT30[0]=HASHID;
      HASHNAMTYPE[0]=SYMNAMTYPEWK[0]-1; #-1 DUE TO DIFFERENT NAMING IN
                                         SYMBOL TABLE AND HASH TABLE.  #
      HASHWA[0]=SYMWRDADDRWK[1];
      HASHSYMLOC[1]=SYMTBLLOC;         #SAVE ENTRY LOC IN SYMBOL TABLE.#
      IF SAMENAMEFLAG THEN   #YES - SET SAMENAME BIT.                  #
        BEGIN 
        HASHSAMENAME[0]=TRUE; 
        SAMENAMEFLAG=FALSE; 
        END 
 # IF DOINT A REHASH, CHECK IF OVERFLOW POINTER MUST BE SAVED.        # 
      IF REHASHFLAG 
        THEN
        BEGIN 
        IF REHSHSYN [0] 
          THEN
          BEGIN 
          HASHSYN [0] = TRUE; 
          HASHWA [0] = REHSHWA [0]; 
          END 
        END 
  
# WRITE OUT TO PRIME AREA.                                             #
  
      XCALL DLRTPRM(HASHNNTRY,2,PRIMELOC);
  
      END 
      CONTROL EJECT;
  
#**********************************************************************#
#                                                                      #
#     D O C O L L I S I O N  --  DO COLLISION.                         #
#                                                                      #
# PURPOSE   IDENTIFY CURRENT COLLISION CASE AND FIND SPOT TO STORE     #
#         CURRENT ENTRY.                                               #
#                                                                      #
# ENTRY     HASHED LOCATION FOR CURRENT ENTRY IS OCCUPIED.             #
#           ARRAY "SYMBUFWK" CONTAINS CURRENT SYMBOL TABLE ENTRY.      #
#           ARRAY "SAVEENTRY" CONTAINS EXISTING PRIME ENTRY AT         #
#         LOCATION "PRIMELOC".                                         #
#           HASHID = HASH-ID OF CURRENT ENTRY.                         #
#                                                                      #
# EXIT      CURRENT INDEX ENTRY HAS BEEN BUILT AND STORED INTO EITHER  #
#         PRIME OR OVERFLOW, AND LINKED WITH OTHER ENTRIES WHERE       #
#         NECESSARY.                                                   #
#                                                                      #
# PROC      BY CHECKING HASH-ID, ENTRY TYPE, AND ENTRY NAME, IDENTIFY  #
#         COLLISION, SYNONYM, OR SAMENAME.                             #
#           IF COLLISION, FOLLOW CHAIN-PTR TO NEXT ENTRY IN CHAIN AND  #
#         REPEAT PROCESS.  IF CHAIN-PTR IS 0, CHECK IF CHAIN CONTINUES #
#         IN OVERFLOW AREA. IF YES, CALL "STORENDOFL" TO STORE NEW     #
#         ENTRY AT END OF OVERFLOW CHAIN. IF NO, CALL "STORENDCHAIN"   #
#         TO FIND AN OPEN SLOT AND ADD NEW ENTRY TO CURRENT CHAIN IN   #
#         PRIME AREA.                                                  #
#           IF SAMENAME, CALL "DOSAMENAME" FOR SAMENAME PROCESSING.    #
#           IF SYNONYM, CALL "DOSYNONYM" FOR SYNONYM PROCESSING.       #
#                                                                      #
#**********************************************************************#
  
      PROC DOCOLLISION;      #COLLISION PROCESSING.                    #
      BEGIN 
  
# CHECK IF BOTH HASHID AND NAMETYPE MATCH.                             #
  
CHECKSAVEENT:                #CHECK THE EXISTING PRIME ENTRY.          #
      IF HASHID EQ SAVEENT30[0] 
        AND (SYMNAMTYPEWK[0]-1) EQ SAVENAMTYPE[0] THEN
                             #YES - EITHER SYNONYM OR SAMENAME.        #
        BEGIN 
        IF SAVESYN[0] THEN   #SYNONYMS EXIST FOR CURRENT ENTRY.        #
          CALL STORENDOFL;   #STORE AT END OF CURRENT OVERFLOW CHAIN.  #
        ELSE
  
# CHECK FOR SAMENAME.                                                  #
  
          BEGIN 
          XCALL DDLRDSY(SYMBUFDF,2,SAVESYMLOC[1]);
          XCALL DDLRDSY(SYMBUFDF,SYMNAMLENDF[1]+4,SAVESYMLOC[1]); 
                             #READ SYMBOL TABLE ENTRY.                 #
          IF SAMENMWKDF THEN           #YES - SAMENAME.                #
            CALL DOSAMENAME;           #SAMENAME PROCESSING.           #
          ELSE
            CALL DOSYNONYM;            #SYNONYM PROCESSING.            #
          END 
        RETURN; 
        END 
  
# NOT SAMENAME AND NOT SYNONYM. CONTINUE WITH COLLISION CHAIN.         #
  
      IF SAVECHAIN[0] EQ 0 THEN        #END OF CHAIN REACHED.          #
        BEGIN 
        IF SAVECLLSNFLG[1] THEN        #YES - COLLISION CHAIN CONTINUES 
                                              IN OVERFLOW AREA.        #
          CALL STORENDOFL;             #STORE AT END OF OVERFLOW CHAIN.#
        ELSE
          CALL STORENDCHAIN; #EXTEND CURRENT CHAIN BY STORING NEW ENTRY 
                              AT THE END.                              #
        END 
      ELSE
  
# WILL FOLLOW CHAIN TO NEXT ENTRY IN PRIME AREA.                       #
  
        BEGIN 
        CALL GETNEXTPRM;     #GET NEXT PRIME ENTRY INTO "SAVEENTRY".   #
        GOTO CHECKSAVEENT;   #GO BACK TO START OF PROC AND REPEAT 
                              PROCESS WITH NEW PRIME ENTRY.            #
        END 
      END  #DOCOLLISION#
      CONTROL EJECT;
  
#**********************************************************************#
#                                                                      #
#     D O S A M E N A M E  --  DO SAMENAME.                            #
#                                                                      #
# PURPOSE   BUILD, STORE, AND LINK CURRENT SAMENAME ENTRIES.           #
#                                                                      #
# ENTRY     CURRENT NEW ENTRY IS FOUND TO HAVE SAME NAME AS AN         #
#         EXISTING PRIME ENTRY.                                        #
#           ARRAY "SYMBUFWK" CONTAINS CURRENT SYMBOL TABLE ENTRY.      #
#           ARRAY "SAVEENTRY" CONTAINS THE EXISTING PRIME ENTRY THAT   #
#         ARE OF SAME NAME.                                            #
#                                                                      #
# EXIT      NEW SAMENAME ENTRY HAS BEEN ADDED TO INDEX TABLE, EITHER   #
#         IN PRIME OR OVERFLOW, LINKED WITH OTHER ENTRIES WHERE        #
#         NECESSARY.                                                   #
#                                                                      #
# PROC      SET SAMENAME BIT IN "SAVEENTRY" AND WRITE IT BACK TO PRIME #
#         AREA.                                                        #
#           FOLLOW PRIME CHAIN TO IT"S END. CHECK IF IT CONTINUES IN   #
#         OVERFLOW AREA. IF YES, CALL "STORENDOFL" TO STORE CURRENT    #
#         ENTRY INTO OVERFLOW. IF NO, CALL "STORENDCHAIN" TO ADD IT    #
#         TO CURRENT PRIME CHAIN.                                      #
#                                                                      #
#**********************************************************************#
  
      PROC DOSAMENAME;       #SAMENAME PROCESSING.                     #
      BEGIN 
      SAVESAMENAME[0]=TRUE;  #SET SAMENAME FLAG IN HASH TABLE ENTRY.   #
      XCALL DLRTPRM(SAVEENTRY,1,PRIMELOC);
  
# LOCATE END OF CHAIN.                                                 #
  
      FOR I=I WHILE SAVECHAIN[0] NQ 0 DO
        CALL GETNEXTPRM;     #GET NEXT PRIME ENTRY INTO "SAVEENTRY".   #
  
# CHECK IF CHAIN CONTINUES IN OVERFLOW.                                #
  
      IF SAVECLLSNFLG[1] THEN          #YES - IT CONTINUES IN OVERFLOW.#
        CALL STORENDOFL;     #STORE AT END OF OVERFLOW.                #
      ELSE
        BEGIN 
        SAMENAMEFLAG=TRUE;
        CALL STORENDCHAIN;
        END 
      END 
      CONTROL EJECT;
  
#**********************************************************************#
#                                                                      #
#     D O S Y N O N Y M  --  DO SYNONYM.                               #
#                                                                      #
# PURPOSE   BUILD, STORE, AND LINK CURRENT SYNONYM ENTRIES.            #
#                                                                      #
# ENTRY     CURRENT NEW ENTRY IS FOUND TO BE A SYNONYM OF AN EXISTING  #
#         ENTRY.                                                       #
#           ARRAY "SYMBUFWK" CONTAINS CURRENT SYMBOL TABLE ENTRY.      #
#           ARRAY "SAVEENTRY" CONTAINS THE EXISTING SYNONYM PRIME      #
#         ENTRY.                                                       #
#                                                                      #
# EXIT      CURRENT SYNONYM ENTRIES HAVE BEEN SET UP IN OVERFLOW AREA, #
#         POINTED TO FROM THE PRIME AREA ENTRY. OF THE ORIGINAL ENTRY. #
#         HAS SAMENAME ENTRIES, THEY ARE ALSO PUT INTO THE OVERFLOW,   #
#         AND THEIR PRIME LOCATIONS ARE RETURNED FOR USE BY OTHER      #
#         PRIME ENTRIES.                                               #
#                                                                      #
# PROC      SET POINTER IN "SAVEENTRY" TO POINT TO OVERFLOW CHAIN, AND #
#         WRITE IT BACK ONTO PRIME AREA.                               #
#           SET UP OVERFLOW ENTRY FOR CURRENT EXISTING PRIME ENTRY.    #
#           IF OTHER SAMENAME ENTRIES EXIST, SEARCH THRU CURRENT PRIME #
#         CHAIN FOR THEM, SET UP AND LINK ENTRIES FOR THEM IN OVERFLOW #
#         AREA, AND RETURN THEIR LOCATIONS FOR USE BY OTHER PRIME      #
#         ENTRIES.  IF PRIME CHAIN CONTINUES IN OVERFLOW, SEARCH THRU  #
#         THE OVERFLOW CHAIN FOR THE SAMENAME ENTRIES, AND SET UP A    #
#         SEPARATE ENTRY FOR THEM IN THE CURRENT SYNONYM CHAIN. THESE  #
#         OLD OVERFLOW SAMENAME ENTRIES WILL HAVE NO MORE SIGNIFICANCE #
#         BUT FOR THEIR KEEPING THE OLD CHAIN LINKED.                  #
#           IF SYNONUM AND COLLISION ENTRIES EXIST IN CHAIN (IN        #
#           PRIME OR OVERFLOW AREA) ALONG WITH SAMENAME ENTRIES,       #
#           THESE ENTRIES ARE REHASHED AND STORED IN THE INDEX AGAIN.  #
#           BEFORE REHASHING THE OLD ENTRIES ARE ZEROED.               #
#           SET UP OVERFLOW ENTRY FOR NEW ENTRY, LINKED WITH THE ABOVE #
#         SYNONYM ENTRIES.                                             #
#                                                                      #
#**********************************************************************#
  
      PROC DOSYNONYM;        #SYNONYM PROCESSING.                      #
      BEGIN 
  
      SAVESYN [0] = TRUE; 
      IF REHASHFLAG        # IF ENTRY IS BEING REHASHED, OVERFLOW      #
        THEN               # CHAIN ALREADY EXISTS.  PUT POINTER        #
        BEGIN              # IN PRIME ENTRY AND LEABE.                 #
        SAVEWA [0] = REHSHWA [0]; 
        CALL DLRTPRM (SAVEENTRY, 1, PRIMELOC);
        RETURN; 
        END 
# SET PRIME ENTRY TO POINT TO OVERFLOW CHAIN.                          #
  
      SAVEWA[0]=OFLNEXTAVAIL; 
      XCALL DLRTPRM(SAVEENTRY,1,PRIMELOC);
  
# CREATE OVERFLOW ENTRY FOR THE PRIME ENTRY.                           #
  
      CALL OFLCURPRMENT;
  
      IF SAVESAMENAME[0] THEN          #YES - SAMENAME ENTRIES EXIST.  #
        BEGIN 
  
 # SET LINK IN SAVECHAIN TO ZERO FOR THIS ENTRY.  IN THE EXISTING      #
 # CHAIN, SAMENAMES WILL GO TO OVERFLOW AND OTHERS WILL BE REHASHED.   #
        I = SAVECHAIN [0];
        SAVECHAIN [0] = 0;
        XCALL DLRTPRM (SAVEENTRY, 1, PRIMELOC); 
        SAVECHAIN [0] = I;
  
# SEARCH FOR OTHER SAMENAME ENTRIES, AND PUT THEM INTO OVERFLOW.       #
  
        FOR I=I WHILE SAVECHAIN[0] NQ 0 DO
          BEGIN 
          CALL GETNEXTPRM;       #GET NEXT PRIME ENTRY INTO "SAVEENTRY"#
          IF SAVESYN[0] AND SAVECLLSNFLG[1] 
          THEN
            BEGIN 
            TEST; 
            END 
          IF SAVEENT30[0] EQ HASHID AND SAVESAMENAME[0] 
          THEN               #YES - SAMENAME ENTRY WITH CURRENT ENTRY. #
            BEGIN 
            CALL OFLCURPRMENT;         #CREATE OVERFLOW ENTRY.         #
            CALL RETURNPRM;            # ZERO PRIME ENTRY              #
            END 
          ELSE               # NO - NOT SAME NAME WITH CURRENT ENTRY   #
            BEGIN            # REHASH IT                               #
            REHASHSAV;                 # SAVE PARMS BEFORE REHASH PROC.#
            CALL RETURNPRM;            # ZERO PRIME ENTRY              #
            HASHID = SAVEENT30 [0]; 
            SYMTBLLOC = SAVESYMLOC [1]; 
            XCALL DDLRDSY (SYMBUFWK, 7, SYMTBLLOC); 
            CALL MAKEPRMENT;
            REHASHRESTOR; 
            END 
          END 
  
# END OF PRIME CHAIN REACHED. CHECK IF CONTINUES IN OVERFLOW.          #
  
        IF SAVECLLSNFLG[1] THEN        #YES - IT CONTINUES IN OVERFLOW.#
          BEGIN 
          OFLLOC=SAVEWA[0]; 
          SAVEOFLLOC = OFLLOC;         #SAVE CURRENT LOC OF INTEREST IN#
                                       #OVERFLOW.                      #
          CUROFLCHAIN=1;
  
# FOLLOW OVERFLOW CHAIN TO ITS END.                                    #
  
          SVOFLNXTAV = OFLNEXTAVAIL;
          FOR I=I WHILE CUROFLCHAIN NQ 0 AND
                        OFLLOC LS SVOFLNXTAV DO 
            BEGIN 
            SAVEOFLLOC = OFLLOC;
            XCALL DLRDOFL (OFLENTRY, 4, OFLLOC);
            CUROFLCHAIN=OFLENTNXTPTR[0];
            IF SMNMTYOFLDF THEN        #SAMENAME AND SAME TYPE.        #
              CALL OFLCUROFLENT;
            ELSE             # IF NOT SAME NAME, AND TYPE - REHASH     #
              BEGIN          # NAME TO GET NEW ENTRY                   #
              REHASHSAV;
              SYMTBLLOC = OFLENTSYMLOC [0]; 
              XCALL DDLRDSY (SYMBUFWK, 7, SYMTBLLOC); 
              P<HNAME> = LOC (SYMNAMEWK [4]); 
              XCALL HASH20(HNAME, SYMNAMLENWK[1], HASHID);
              CALL MAKEPRMENT;
              CALL REHASHRESTOR;
              END 
            OFLLOC = SAVEOFLLOC + CUROFLCHAIN;
            END 
          IF SVOFLNXTAV NQ 0 AND
             OFLLOC NQ 0
          THEN
            BEGIN 
            IF OFLLOC GQ SVOFLNXTAV THEN
              BEGIN 
              OFLENTNXTPTR[0] = 0;
              XCALL DLRTOFL (OFLENTRY,1,SAVEOFLLOC);
              END 
            END 
          END 
        END 
  
# SET UP OVERFLOW ENTRY FOR NEW ENTRY.                                 #
  
      CALL OFLCURNEWENT;
      END 
      CONTROL EJECT;
  
#**********************************************************************#
#                                                                      #
#     F I N D B E S T M O D  --  FIND BEST MODULUS.                    #
#                                                                      #
# PURPOSE   FIND BEST MODULUS FOR HASH INDEX, BASED ON NUMBER OF       #
#         ENTRIES IN SCHEMA.                                           #
#                                                                      #
# ENTRY     NUMNAMES = NUMBER OF ENTRIES IN SCHEMA.                    #
#                                                                      #
# EXIT      BESTMOD = MODULUS THAT WILL BE USED FOR HASHING.           #
#                                                                      #
# METHOD    FOR CURRENT RELEASE, THE VALUE CHOSEN FOR THE MODULUS IS   #
#         THE SMALLEST ODD NUMBER GREATER THAN OR EQUAL TO "NUMNAMES". #
#         IF THIS TURNS OUT UNSATISFACTORY, IT COULD BE REPLACED.      #
#                            ( IT HAS BEEN REPLACED. )                 #
#                                                                      #
#**********************************************************************#
  
      PROC FINDBESTMOD;      #FIND BEST MODULUS.                       #
      BEGIN 
                             # THE BEST MODULUS IS AT LEAST TWICE THE  #
                             # NUMBER OF NAMES.                        #
                             # IT IS NOT A MULTIPLE OF 2, 3 OR 5.      #
      BESTMOD = ((NUMNAMES*2 +30) / 30 * 30) - 1; 
  
      END 
      CONTROL EJECT;
  
#**********************************************************************#
#                                                                      #
#     F I N D O P E N S L O T  --  FIND OPEN SLOT.                     #
#                                                                      #
# PURPOSE   FIND OPEN SLOT IN PRIME AREA FOR NEW PRIME ENTRY.          #
#                                                                      #
# ENTRY     PRIMELOC = PRIME LOCATION NEAREST TO WHICH AN OPEN SLOT IS #
#                      TO BE FOUND GOING DOWNWARD.                     #
#                                                                      #
# EXIT      OPENSLOTOFS = OPEN SLOT OFFSET FROM LOCATION "PRIMELOC".   #
#           IF OPENSLOTOFS = 0, OPEN SLOT NOT FOUND.                   #
#                                                                      #
# PROC      STARTING AT "PRIMELOC", CHECK EVERY OTHER WORD FOR VALUE 0.#
#         IF END OF PRIME AREA REACHED, WRAP AROUND AND CONTINUE FROM  #
#         TOP. SET "OPENSLOTOFS" WHEN OPEN SLOT FOUND.                 #
#           IF OPEN SLOT STILL NOT FOUND WITHIN 255 (OR 510 IN OUR     #
#         CASE) LOCATIONS, SET "OPENSLOTOFS" TO 0.                     #
#                                                                      #
#**********************************************************************#
  
      PROC FINDOPENSLOT;     #FIND OPEN SLOT.                          #
      BEGIN 
      ITEM CHECKSLOT;        #CURRENTLY CHECKING SLOT.                 #
      CHECKSLOT=PRIMELOC; 
      FOR I=1 STEP 1 UNTIL 255 DO      #FIND OPEN SLOT WITHIN 255 LOC. #
        BEGIN 
        CHECKSLOT=CHECKSLOT+2;
        IF CHECKSLOT GQ PRIMESIZE2 THEN #YES - END OF PRIME AREA.      #
          CHECKSLOT=0;                 #WRAP AROUND.                   #
        XCALL DLRDPRM(HASHNNTRY,1,CHECKSLOT);    #READ INTO BUFFER.    #
        IF HASHENTWORD[0] EQ 0 THEN    #YES - SLOT OPEN.               #
          BEGIN 
          OPENSLOTOFS=I;
          RETURN; 
          END 
        END 
        OPENSLOTOFS=0;       #OPEN SLOT NOT FOUND.                     #
      END 
      CONTROL EJECT;
  
#**********************************************************************#
#                                                                      #
#     G E T N E X T P R M  --  GET NEXT PRIME ENTRY.                   #
#                                                                      #
# PURPOSE   GET NEXT PRIME ENTRY IN CURRENT CHAIN.                     #
#                                                                      #
# ENTRY     PRIMELOC = CURRENT PRIME ENTRY LOCATION.                   #
#                                                                      #
# EXIT      PRIMELOC = LOCATION OF THE NEXT PRIME ENTRY IN CHAIN.      #
#           ARRAY "SAVEENTRY" CONTAINS THIS NEXT PRIME ENTRY.          #
#                                                                      #
# PROC      SET "PRIMELOC" TO LOCATION OF THE NEXT ENTRY IN CHAIN, AND #
#         CALL "DLRDPRM" TO READ IT IN.                                #
#                                                                      #
#**********************************************************************#
  
      PROC GETNEXTPRM;       #GET NEXT PRIME ENTRY.                    #
      BEGIN 
      PRIMELOC=PRIMELOC+SAVECHAIN[0]*2; 
      IF PRIMELOC GQ PRIMESIZE2 THEN   #GOING OVER END OF PRIME AREA.  #
        PRIMELOC=PRIMELOC-PRIMESIZE2;  #WRAP AROUND.                   #
      XCALL DLRDPRM(SAVEENTRY,2,PRIMELOC);
      END 
      CONTROL EJECT;
#**********************************************************************#
  
#             M A K E P R M E N T  -  MAKE PRIME ENTRY                 #
#     PURPOSE    COMPUTE PRIMELOC, READ THE ENTRY AT THAT LOCATION.    #
#                CALL BUSTORPRMENT IF ENTRY IS ZERO, ELSE CALL         #
#                DOCOLLISION TO FIND A NEW ENTRY, CHAINED TO THIS ONE. #
#     ENTRY      HASHID AND BESTMOD ARE SET.  SYMBUFWK CONTAINS THE    #
#                SYMBOL TABLE ENTRY FOR THE NAME.                      #
#     EXIT       ENTRY HAS BEEN MADE IN HASH INDEX - PRIME OR          #
#                OVERFLOW FILE - FOR THIS NAME.                        #
#     PROC       AFTER PROCESSING, IF THE REHASHDONE FLAG WAS SET THEN #
#                RESET IT AND GO TO LABEL MAKERPRETURN, ELSE RETURN TO #
#                WHERE IT WAS CALLED.                                  #
#**********************************************************************#
  
      PROC MAKEPRMENT;
      BEGIN 
      PRIMELOC = (HASHID - HASHID/BESTMOD * BESTMOD) * 2; 
      XCALL DLRDPRM (SAVEENTRY, 2, PRIMELOC); 
      IF SAVEENTWORD [0] EQ 0 
        THEN CALL BUSTORPRMENT; 
        ELSE CALL DOCOLLISION;
      IF REHASHDONE 
      THEN
        BEGIN 
        REHASHDONE = FALSE; 
        GOTO MAKEPRETURN;       # BACK TO MAIN DLHASH PROCESSING       #
        END 
      RETURN; 
      END 
      CONTROL EJECT;
  
#**********************************************************************#
#                                                                      #
#     O F L C U R N E W E N T  --  OVERFLOW CURRENT NEW ENTRY.         #
#                                                                      #
# PURPOSE   SET UP OVERFLOW ENTRY FOR CURRENT NEW ENTRY AND STORE IT   #
#         INTO OVERFLOW AREA.                                          #
#                                                                      #
# ENTRY     ARRAY "SYMBUFWK" CONTAINS CURRENT SYMBOL TABLE ENTRY.      #
#           OFLNEXTAVAIL = NEXT AVAILABLE LOCATION IN OVERFLOW AREA.   #
#                                                                      #
# EXIT      THE NEW OVERFLOW ENTRY HAS BEEN BUILT AND STORED INTO THE  #
#         OVERFLOW AREA.                                               #
#           OFLNEXTAVAIL = NEXT AVAILABLE LOCATION IN OVERFLOW AREA.   #
#                                                                      #
# PROC      BUILD OVERFLOW ENTRY WITH INFO FROM "SYMBUFWK".            #
#           STORE IT INTO OVERFLOW AREA.                               #
#           UPDATE "OFLNEXTAVAIL".                                     #
#                                                                      #
#**********************************************************************#
  
      PROC OFLCURNEWENT;     #OVERFLOW CURRENT NEW ENTRY.              #
      BEGIN 
      CALL BUILDOFLWK;
      IF REHASHFLAG THEN
        BEGIN 
        OFLENTNXTPTR[0] = OFLENTNMLENW[0] + 1;
        END 
      CALL STOREOFL;
      OFLNEXTAVAIL=OFLNEXTAVAIL+OFLENTNMLENW[0] +1; 
      END 
      CONTROL EJECT;
  
#**********************************************************************#
#                                                                      #
#     O F L C U R O F L E N T  --  OVERFLOW CURRENT OVERFLOW ENTRY.    #
#                                                                      #
# PURPOSE   SET UP A SEPARATE OVERFLOW ENTRY FOR CURRENT OVERFLOW      #
#         ENTRY IN SEPARATE CHAIN.                                     #
#                                                                      #
# ENTRY     ARRAY "OFLENTRY" CONTAINS CURRENT OVERFLOW ENTRY.          #
#           OFLNEXTAVAIL = NEXT AVAILABLE LOCATION IN OVERFLOW AREA.   #
#                                                                      #
# EXIT      DESIRED OVERFLOW ENTRY HAS BEEN SET UP IN OVERFLOW AREA.   #
#           OFLNEXTAVAIL = NEXT AVAILABLE LOCATION IN OVERFLOW AREA.   #
#                                                                      #
# PROC      SET NEXT-PTR IN "OFLENTRY" TO RIGHT FOLLOWING THE CURRENT  #
#         ENTRY.                                                       #
#           STORE IT INTO OVERFLOW AREA.                               #
#           UPDATE "OFLNEXTAVAIL".                                     #
#                                                                      #
#**********************************************************************#
  
      PROC OFLCUROFLENT;     #OVERFLOW CURRENT OVERFLOW ENTRY.         #
      BEGIN 
      OFLENTNXTPTR[0]=OFLENTNMLENW[0]+1;
      CALL STOREOFL;
      OFLNEXTAVAIL=OFLNEXTAVAIL+OFLENTNXTPTR[0];
      END 
      CONTROL EJECT;
  
#**********************************************************************#
#                                                                      #
#     O F L C U R P R M E N T  --  OVERFLOW CURRENT PRIME ENTRY.       #
#                                                                      #
# PURPOSE   SET UP OVERFLOW ENTRY FOR CURRENT PRIME ENTRY.             #
#                                                                      #
# ENTRY     ARRAY "SAVEENTRY" CONTAINS PRIME ENTRY TO BE OVERFLOWED.   #
#           OFLNEXTAVAIL = NEXT AVAILABLE LOCATION IN OVERFLOW AREA.   #
#                                                                      #
# EXIT      AN OVERFLOW ENTRY HAS BEEN SET UP FOR CURRENT PRIME ENTRY  #
#         IN THE OVERFLOW AREA.                                        #
#           OFLNEXTAVAIL = NEXT AVAILABLE LOCATION IN OVERFLOW AREA.   #
#                                                                      #
# PROC      OPEN OVERFLOW AREA IF IT HAS NOT BEEN OPENED.              #
#           READ SYMBOL TABLE ENTRY FOR CURRENT PRIME ENTRY INTO       #
#         "SYMBUFDF", AND FROM IT BUILD OVERFLOW ENTRY IN "OFLENTRY".  #
#           STORE ENTRY INTO OVERFLOW AREA.                            #
#           UPDATE "OFLNEXTAVAIL".                                     #
#                                                                      #
#**********************************************************************#
  
      PROC OFLCURPRMENT;     #OVERFLOW CURRENT PRIME ENTRY.            #
      BEGIN 
  
# OPEN OVERFLOW AREA IF NOT YET OPENED.                                #
  
      IF NOT OFLOPENED THEN 
        BEGIN 
        XCALL DLOPOFL;
        OFLOPENED=TRUE; 
        END 
  
# READ SYMBLE TABLE ENTRY FOR CURRENT PRIME ENTRY.                     #
  
       XCALL DDLRDSY(SYMBUFDF,2,SAVESYMLOC[1]); 
       XCALL DDLRDSY(SYMBUFDF,SYMNAMLENDF[1]+4,SAVESYMLOC[1]);
  
# BUILD OVERFLOW ENTRY AND WRITE IT ONTO OVERFLOW AREA.                #
  
      CALL BUILDOFLDF;
      CALL STOREOFL;
      OFLNEXTAVAIL=OFLNEXTAVAIL+OFLENTNXTPTR[0];
  
      END 
      CONTROL EJECT;
#**********************************************************************#
#                                                                      #
#                  R E H A S H O F L C U R - STORE AT END OF OVERFLOW  #
#                                      CHAIN DURING REHASHING PROCESS. #
#                                                                      #
#     PURPOSE    START A NEW OVERFLOW CHAIN FROM THE CURRENT PRIME     #
#                LOCATION.                                             #
#                                                                      #
#     ENTRY      THERE IS NO LOCATION IN PRIME AREA WITHIN 255 WORDS   #
#                OF CURRENT PRIME ENTRY TO STORE THE REHASHED ENTRY,   #
#                AND THE PRIME CHAIN WILL HAVE TO CONTINUE IN OVER-    #
#                FLOW AREA.  AFTER BUILDING THE OVERFLOW ENTRIES FOR   #
#                THE CURRENT PRIME ENTRY AND THE REHASHED ENTRY, IF    #
#                THE SAVESYN FLAG OF THE REHASHED ENTRY IS SET THEN    #
#                THE WHOLE OVERFLOW CHAIN THAT LINKS TO THE REHASHED   #
#                ENTRY WILL BE RELINKED AFTER THE REHASHED ENTRY AT    #
#                THE NEW LOCATION IN THE OVERFLOW AREA.                #
#                                                                      #
#     EXIT       CURRENT PRIME CHAIN IS SET TO CONTINUE IN OVERFLOW    #
#                AREA AS IN THE CASE OF SYNONYMS.  THE OVERFLOW CHAIN  #
#                CONTAINS THE CURRENT PRIME ENTRY, THE REHASHED ENTRY  #
#                AND ITS CHAINED ENTRIES.                              #
#                                                                      #
#     PROC       CALL STARTNEWOFL TO BUILD AND STORE OVERFLOW ENTRIES  #
#                OF THE CURRENT PRIME AND REHASHED ENTRY.              #
#                IF SAVESYN OF REHASHED ENTRY IS SET THEN CALL STOREOFL#
#                TO BUILD EVERY ENTRY THAT LINKS TO THE REHASHED ENTRY.#
#                                                                      #
#**********************************************************************#
  
      PROC REHASHOFLCUR;
      BEGIN 
  
      CALL STARTNEWOFL; 
      CALL REHASHRESTOR;
      REHASHDONE = FALSE; 
      REHASHFLAG = TRUE;
  
  
      IF SAVESYN[0] THEN
        BEGIN 
        OFLLOC = SAVEWA[0]; 
        XCALL DLRDOFL(OFLENTRY,1,OFLLOC);  # READ THE REHASHED ENTRY   #
        CUROFLCHAIN = OFLENTNXTPTR[0];
  
        FOR I=I WHILE CUROFLCHAIN NQ 0
        DO
          BEGIN 
          OFLLOC=OFLLOC+CUROFLCHAIN;       # SKIP THE REHASHED ENTRY   #
          XCALL DLRDOFL(OFLENTRY,4,OFLLOC); 
          CUROFLCHAIN = OFLENTNXTPTR[0];
          OFLENTNXTPTR[0] = OFLENTNMLENW[0] + 1;
          CALL STOREOFL;                   # STORE THE LINKED ENTRY    #
          OFLNEXTAVAIL = OFLNEXTAVAIL + OFLENTNXTPTR[0];
          END 
  
         END
      END 
  
      CONTROL EJECT;
#**********************************************************************#
  
#                  R E H A S H R E S T O R - RESTORE REHASH SAVE AREA  #
#     PURPOSE    ON COMPLETION OF REHASHING A NAME RESTORE VALUES      #
#                THAT WERE SAVED IN THE ARRAY REHASHSAVE.              #
# ENTRY          REHASHSAVE CONTAINS VALUES FOR SAVEENTRY AND SYMBOL   #
#                TABLE BUFFERS.   REHASHID CONTAINS SAVED VALUE FOR    #
#                HASHID, REHASHPLOC CONTAINS SAVED PRIMELOC VALUE.     #
#     EXIT       VALUES ARE MOVED FROM SAVE AREAS TO ORIGINAL LOCNS.   #
#     PROC       IN ADDITION TO RESTORING VALUES, REHASHFLAG IS        #
#                SET TO FALSE.                                         #
#**********************************************************************#
  
      PROC REHASHRESTOR;
      BEGIN 
      SAVEENTWORD [0] = REHSHSAVWD [0]; 
      SAVEENTWORD [1] = REHSHSAVWD [1]; 
      FOR I = 0  STEP 1  UNTIL 7  DO
        BEGIN 
        SYMBUFWORDWK [I] = REHSHSYMWK [ I]; 
        SYMBUFWORDDF [I] = REHSHSYMDF [ I]; 
        END 
      REHASHDONE = TRUE;
      SYMTBLLOC = REHASHSYMLOC; 
      PRIMELOC = REHASHPLOC;
      HASHID = REHASHID;
      REHASHFLAG = FALSE; 
      RETURN; 
      END 
      CONTROL EJECT;
#**********************************************************************#
  
#             R E H A S H S A V - SAVE VALUES WHILE REHASHING NAME     #
  
#     PURPOSE    SAVE VALUES WHILE A NAME IS BEING REHASHED IN DOSYNONY#
#     ENTRY      PRIMELOC, HASHID, SAVEENTRY, AND THE SYMBOL TABLE     #
#                BUFFERS CONTAIN VALUES THAT ARE SAVED.                #
#     EXIT       THE ABOVE VALUES ARE SAVED IN REHASHPLOC, REHASHID,   #
#                AND THE REHASHSAVE ARRAY, RESPECTIVELY.               #
#     PROC       IN ADDITION TO SAVE OF VALUES, REHASHFLAG IS SET TRUE #
#**********************************************************************#
  
      PROC REHASHSAV; 
      BEGIN 
      REHSHSAVWD [0] = SAVEENTWORD [0]; 
      REHSHSAVWD [1] = SAVEENTWORD [1]; 
      FOR I = 0  STEP 1 UNTIL 7  DO 
        BEGIN 
        REHSHSYMWK[I] = SYMBUFWORDWK [I]; 
        REHSHSYMDF[I] = SYMBUFWORDDF [I]; 
        END 
       REHASHDONE = FALSE;
      REHASHSYMLOC = SYMTBLLOC; 
      REHASHPLOC = PRIMELOC;
      REHASHID = HASHID;
      REHASHFLAG = TRUE;
      RETURN; 
      END 
  
  
  
  
  
#**********************************************************************#
#                                                                      #
#     R E T U R N P R M   - RETURN PRIME ENTRY                         #
#                                                                      #
# PURPOSE   RETURN A PREVIOUSLY OCCUPIED LOCATION IN PRIME AREA AND    #
#                                                                      #
# ENTRY     PRIMELOC = PRIME LOCATION TO BE RETURNED                   #
#                                                                      #
# EXIT      RETURNED LOCATION INPRIME AREA IS ZERO-FILLED.             #
#                                                                      #
#**********************************************************************#
  
      PROC RETURNPRM; 
      BEGIN 
  
      XCALL DLRTPRM(ZEROED,2,PRIMELOC); #RETURN SLOTS BY ZEROING THEM. #
      END 
      CONTROL EJECT;
  
#**********************************************************************#
#                                                                      #
#     S T A R T N E W O F L  --  START NEW OVERFLOW CHAIN.             #
#                                                                      #
# PURPOSE   START A NEW OVERFLOW CHAIN FROM CURRENT PRIME LOCATION.    #
#                                                                      #
# ENTRY     THERE IS NO LOCATION IN PRIME AREA WITHIN 255 WORDS OF     #
#         CURRENT PRIME ENTRY TO STORE NEW ENTRY, AND THE PRIME CHAIN  #
#         WILL HAVE TO CONTINUE IN OVERFLOW AREA.                      #
#           ARRAY "SAVEENTRY" CONTAINS CURRENT PRIME ENTRY.            #
#           OFLNEXTAVAIL = NEXT AVAILABLE LOCATION IN OVERFLOW AREA.   #
#                                                                      #
# EXIT      CURRENT PRIME CHAIN IS SET TO CONTINUE IN OVERFLOW AREA AS #
#         IN THE CASE OF SYNONYMS. THE OVERFLOW CHAIN WILL AT THIS     #
#         STAGE CONTAIN THE CURRENT PRIME ENTRY AND THE NEW ENTRY.     #
#           OFLNEXTAVAIL = NEXT AVAILABLE LOCATION IN OVERFLOW AREA.   #
#                                                                      #
# PROC      IN "SAVEENTRY", SET SYNONYM BIT AND SET POINTER TO POINT   #
#         TO CHAIN IN OVERFLOW AREA. IF SAMENAME BIT IS ON, TURN IT    #
#         OFF. WRITE "SAVEENTRY" BACK ONTO PRIME AREA.                 #
#           BUILD AND STORE OVERFLOW ENTRY FOR THE PRIME ENTRY.        #
#           BUILD AND STORE OVERFLOW ENTRY FOR THE NEW ENTRY.          #
#                                                                      #
#**********************************************************************#
  
      PROC STARTNEWOFL;      #START NEW OVERFLOW CHAIN.                #
      BEGIN 
  
# SET LAST ENTRY IN PRIME CHAIN.                                       #
  
      SAVESYN[0]=TRUE;
      SAVESAMENAME[0]=FALSE; #SET TO FALSE IN CASE IT ORIGINALLY IS ON.#
      SAVEWA[0]=OFLNEXTAVAIL; 
      XCALL DLRTPRM(SAVEENTRY,2,PRIMELOC);
  
# STORE CURRENT PRIME ENTRY INTO OVERFLOW.                             #
  
      CALL OFLCURPRMENT;
  
# STORE CURRENT NEW ENTRY INTO OVERFLOW.                               #
  
      CALL OFLCURNEWENT;
      END 
      CONTROL EJECT;
  
#**********************************************************************#
#                                                                      #
#     S T O R E N D C H A I N  --  STORE AT END OF CHAIN.              #
#                                                                      #
# PURPOSE   STORE CURRENT NEW ENTRY AT END OF CURRENT PRIME CHAIN.     #
#                                                                      #
# ENTRY     ARRAY "SYMBUFWK" CONTAINS NEW SYMBOL TABLE ENTRY.          #
#           ARRAY "SAVEENTRY" CONTAINS LAST ENTRY IN CURRENT CHAIN.    #
#           PRIMELOC = LOCATION OF THIS LAST ENTRY.                    #
#                                                                      #
# EXIT      CURRENT NEW ENTRY HAS BEEN ADDED TO END OF CURRENT CHAIN,  #
#         EITHER IN PRIME AREA OR, WHEN NO AVAILABLE LOCATION COULD BE #
#         FOUND, IN OVERFLOW AREA.                                     #
#                                                                      #
# PROC      FIND AN OPEN SLOT WITHIN 255 LOCATIONS OF "PRIMELOC".      #
#           IF OPEN SLOT IS FOUND, SET UP NEW ENTRY IN IT AND LINK IT  #
#         TO END OF CURRENT CHAIN.                                     #
#           IF OPEN SLOT NOT FOUND, CREATE OVERFLOW CHAIN POINTED TO   #
#         FROM "PRIMELOC", AND STORE CURRENT NEW ENTRY, AND CURRENT    #
#         PRIME ENTRY IF NECESSARY, INTO THE OVERFLOW AREA.            #
#                                                                      #
#**********************************************************************#
  
      PROC STORENDCHAIN;               #STORE AT END OF CHAIN.         #
      BEGIN 
      CALL FINDOPENSLOT;             #FIND AN OPEN SLOT WITHIN 255 LOCS#
      IF OPENSLOTOFS NQ 0 THEN         #YES I OPEN SLOT FOUND.         #
        BEGIN 
        SAVECHAIN[0]=OPENSLOTOFS;      #SET CHAIN PTR IN CURRENT ENTRY.#
        XCALL DLRTPRM(SAVEENTRY,1,PRIMELOC);
                                       #WRITE IT BACK ONTO PRIME AREA. #
        PRIMELOC=PRIMELOC+OPENSLOTOFS*2;
        IF PRIMELOC GQ PRIMESIZE2 THEN #GOING OVER END OF PRIME AREA.  #
          PRIMELOC=PRIMELOC-PRIMESIZE2; #WRAP AROUND.                  #
        CALL BUSTORPRMENT;
        END 
      ELSE                            # CANNOT FINE AN OPEN SLOT WITHIN#
        BEGIN                         # 255 LOCATIONS.                 #
        SAVECLLSNFLG[1]=TRUE;         # SET SAVECLLSNFLG TO INDICATE   #
                                      # CHAIN WILL CONTINUE IN OVERFLOW#
        SAMENAMEFLAG = FALSE;         # RESET IF IT WAS SET IN DOSAMENM#
  
        IF SAVESYN[0] THEN            # YES - SYNONYM OVERFLOW EXISTING#
          BEGIN 
          XCALL DLRTPRM(SAVEENTRY,2,PRIMELOC);
          CALL STORENDOFL;            # STORE NEW ENTRY AT END OF OFL  #
          END 
        ELSE
          BEGIN 
          IF REHASHFLAG THEN          # IN REHASHING PROCESS           #
            BEGIN 
            CALL REHASHOFLCUR;        # STORE CURRENT PRIME ENTRY TO   #
            END                       # END OF THE OVERFLOW CHAIN      #
          ELSE
            BEGIN 
            CALL STARTNEWOFL;         # ELSE START NEW OVERFLOW CHAIN  #
            END 
          END 
        END 
      END 
      CONTROL EJECT;
  
#**********************************************************************#
#                                                                      #
#     S T O R E N D O F L --  STORE AT END OF OVERFLOW CHAIN.          #
#                                                                      #
# PURPOSE   BUILD OVERFLOW ENTRY FOR CURRENT NEW ENTRY AND ADD IT TO   #
#         END OF CURRENT OVERFLOW CHAIN.                               #
#                                                                      #
# ENTRY     ARRAY "SYMBUFWK" CONTAINS CURRENT SYMBOL TABLE ENTRY.      #
#           ARRAY "SAVEENTRY" CONTAINS PRIME ENTRY WITH POINTER INTO   #
#         OVERFLOW AREA.                                               #
#           OFLNEXTAVAIL = NEXT AVAILABLE LOCATION IN OVERFLOW AREA.   #
#                                                                      #
# EXIT      CURRENT NEW ENTRY HAS BEEN ADDED TO HASH INDEX AT END OF   #
#         CURRENT OVERFLOW CHAIN.                                      #
#           OFLNEXTAVAIL = NEXT AVAILABLE LOCATION IN OVERFLOW AREA.   #
#                                                                      #
# PROC      FROM POINTER IN "SAVEENTRY", LOCATE CHAIN IN OVERFLOW      #
#         AREA.                                                        #
#           FOLLOW THE OVERFLOW CHAIN TO ITS END. BUILD AND LINK NEW   #
#         OVERFLOW ENTRY TO IT.                                        #
#                                                                      #
#**********************************************************************#
  
      PROC STORENDOFL;       #STORE END OF OVERFLOW.                   #
      BEGIN 
      OFLLOC=SAVEWA[0];      #LOC OF INTEREST IN OVERFLOW.             #
      XCALL DLRDOFL(OFLENTRY,1,OFLLOC); 
                             #READ 1ST ENTRY IN OVERFLOW CHAIN.        #
  
# LOCATE END OF CHAIN.                                                 #
  
      FOR I=I WHILE OFLENTNXTPTR[0] NQ 0 AND
                    OFLLOC NQ OFLNEXTAVAIL
      DO
        BEGIN 
        OFLLOC=OFLLOC+OFLENTNXTPTR[0];
        IF OFLLOC EQ OFLNEXTAVAIL THEN
          BEGIN 
          TEST; 
          END 
        XCALL DLRDOFL(OFLENTRY,1,OFLLOC); 
        END 
  
# LINK AND STORE NEW ENTRY INTO OVERFLOW AREA.                         #
  
      IF OFLLOC NQ OFLNEXTAVAIL 
      THEN
        BEGIN 
        OFLENTNXTPTR[0]=OFLNEXTAVAIL-OFLLOC;
        XCALL DLRTOFL(OFLENTRY,1,OFLLOC); 
        END 
      CALL OFLCURNEWENT;
      END 
      CONTROL EJECT;
  
#**********************************************************************#
#                                                                      #
#     S T O R E O F L  --  STORE OVERFLOW ENTRY.                       #
#                                                                      #
# PURPOSE   STORE "OFLENTRY" INTO OVERFLOW AREA.                       #
#                                                                      #
# ENTRY     ARRAY "OFLENTRY" CONTAINS NEWLY BUILT OVERFLOW ENTRY.      #
#           OFLNEXTAVAIL = NEXT AVAILABLE LOCATION IN OVERFLOW AREA.   #
#                                                                      #
# EXIT      "OFLENTRY" HAS BEEN WRITTEN OUT TO OVERFLOW AREA.          #
#                                                                      #
# PROC      CALL "DLRTOFL" TO WRITE "OFLENTRY" ONTO OVERFLOW AREA      #
#         STARTING AT LOCATION "OFLNEXTAVAIL".                         #
#                                                                      #
#**********************************************************************#
  
      PROC STOREOFL;         #STORE "OFLENTRY" INTO OVERFLOW AREA.     #
      BEGIN 
      XCALL DLRTOFL(OFLENTRY,OFLENTNMLENW[0]+1,OFLNEXTAVAIL); 
      END 
  
  
  
      END  #DLHASH# 
      TERM
