*DECK USETEXT 
USETEXT   TSOURCE 
USETEXT   TSYMCNS 
USETEXT   TCEXECQ 
USETEXT   TSYMC5Q 
USETEXT   TCEXEC
USETEXT   TSYMC5
      PROC USETEXT; 
  
      BEGIN 
  
  
#----------------------------------------------------------------------#
#                                                                      #
#     P R O C   U S E T E X T                                          #
#                                                                      #
#     OBTAIN SYMPL TEXTS AS SPECIFIED IN THE USETEXT TABLE (UTT IN     #
#     INIT15) AND COMBINE THEM ONE AT A TIME WITH THE EXISTING SYMBOL  #
#     TABLE.                                                           #
#                                                                      #
#----------------------------------------------------------------------#
  
  
  
*CALL COMEX 
*CALL TXTCOM
*CALL HASHCOM 
  
      DEF BPC #6#;                 # BITS PER CHARACTER                #
      DEF CPW #10#;                # CHARACTERS PER WORD               #
      DEF NULL #0#;                # FOR NULLIFYING SYM TAB ENTRIES    #
  
      $BEGIN
      DEF STDUMP #35#;             # INTOPS BIT FOR *=9 SYM TAB DUMP   #
      $END
  
      XREF PROC DIAG;              # ISSUE DIAGNOSTIC WITH SYMBOL      #
      XREF PROC GST;               # GET SYMPL TEXT (IN INIT15)        #
      XREF PROC PTLSTV;            # PRINT A LINE ON L=FILE            #
  
      $BEGIN
      XREF PROC BINOCT;            # BINARY TO OCTAL DISPLAY CODE CONV #
      $END
  
      ITEM DONE         B = FALSE; # GST PARAM (TRUE = NO MORE TEXTS)  #
      ITEM EQUIVALENT   B;         # TRUE = ENTRIES OR FIELDS ARE DUPS #
      ITEM H            I;         # TEMP                              #
      ITEM I            I;         # TEMP                              #
      ITEM INDX         I;         # TEMP FOR INDEX INTO SYM TAB AREA  #
      ITEM J            I;         # TEMP                              #
      ITEM K            I;         # TEMP                              #
      ITEM L            I;         # TEMP                              #
      ITEM M            I;         # TEMP                              #
      ITEM RELOC        I;         # TEXT TABLE RELOCATION FACTOR      #
      ITEM STI          I;         # TEMP FOR SYMBOL TABLE INDEX       #
      ITEM STN          I;         # TEMP FOR SYM TABLE S"NAME" INDEX  #
      ITEM TNNOTPRNTD   B;         # TRUE = TEXT NAME NOT PRINTED YET  #
      ITEM TTI          I;         # TEMP FOR TEXT TABLE INDEX         #
      ITEM TTN          I;         # TEMP FOR TEXT TABLE S"NAME" INDEX #
      ITEM TTSI         I;         # TEXT TABLE STARTING INDEX         #
      ITEM TUHNOTPRNTD  B = TRUE;  # TEXT USAGE HEADING NOT PRINTED YET#
  
      $BEGIN
      ITEM DBUG1 C(20) = " TTSI=              ";
      $END
  
      ARRAY STEXTNAME [0:0] S(3);  # CURRENT SYMPL TEXT NAME HEADING   #
        BEGIN 
        ITEM HEADER C(00,00,30) = [" SYMPL TEXT NAME =  "]; 
        ITEM TNAME  C(02,00,07);
        END 
      CONTROL EJECT;
  
      PROC REPLTTH; 
  
      BEGIN 
  
  
#----------------------------------------------------------------------#
#                                                                      #
#     P R O C   R E P L T T H                                          #
#                                                                      #
#     REPLACE TEXT TABLE HEADER (ASCM TABLE AND TEXT TABLE ORIGIN      #
#     AND LENGTH DESCRIPTOR) WITH S"TEXT" SYMBOL TABLE ENTRY, WHICH    #
#     DELINEATES THE SYMBOL TABLE AREA OCCUPIED BY THE CURRENT         #
#     SYMPL TEXT.                                                      #
#                                                                      #
#----------------------------------------------------------------------#
  
  
  
      CLAS[TTSI] = S"TEXT"; 
      NNAM[TTSI] = TRUE;           # S"TEXT ENTRIES ARE NOT NAMED...   #
                                   # NOR ARE THEY ON THE NONAM CHAIN   #
      IF STLC EQ 0
      THEN                         # ESTABLISH SYMPL TEXT LINK CHAIN   #
        BEGIN 
        STLC = TTSI;
        END 
      ELSE                         # OR ADD TO THE EXISTING CHAIN      #
        BEGIN 
        FOR I = STLC
          WHILE I NQ 0
        DO
          BEGIN 
          J = I;
          I = TLNK[I];
          END 
        TLNK[J] = TTSI; 
        END 
      TLNK[TTSI] = 0;              # NEW END OF SYMPL TEXT LINK CHAIN  #
      FTXT[TTSI] = TTSI;           # ST INDEX OF FIRST TEXT ENTRY      #
      TNAM[TTSI] = TCTTNAME[0];    # TEXT NAME                         #
      LTXT[TTSI] = NXTAV;          # ST INDEX OF LAST TEXT WORD+1      #
  
  
      END 
      CONTROL EJECT;
  
      PROC RESTTNC; 
  
      BEGIN 
  
  
#----------------------------------------------------------------------#
#                                                                      #
#     P R O C   R E S T T N C                                          #
#                                                                      #
#     RESOLVE TEXT TABLE NAME CONFLICTS AND COMBINE TCT HASH TABLE     #
#     WITH COM08 HASH TABLE.                                           #
#                                                                      #
#----------------------------------------------------------------------#
  
  
      DEF D057 #57#;               # DIAGNOSTIC 57                     #
  
      ITEM DUPDECL B;              # TRUE = POSSIBLE DUP DECLARATION   #
  
  
  
      FOR I = 0 STEP 1             # FOR EACH HASH TABLE ENTRY         #
        UNTIL L$HASH
      DO
  
        BEGIN 
        IF HLNK[I] NQ 0            # IF ST HASH AND TCT HASH           #
          AND TCTHASH[I] NQ 0      # ARE BOTH NON-ZERO                 #
        THEN
          BEGIN 
          FOR TTI = TCTHASH[I]     # COMPARE EACH S"NAME" ENTRY        #
            WHILE TTI NQ 0         # ON THE TCT HASH CHAIN             #
          DO
            BEGIN 
            K = HLNK[TTI];         # (TEMP NEXT VALUE OF TTI)          #
            EQUIVALENT = FALSE; 
            FOR STI = HLNK[I]      # WITH EACH S"NAME" ENTRY           #
              WHILE STI NQ 0       # ON THE ST HASH CHAIN              #
                AND NOT EQUIVALENT # OR UNTIL A DUPLICATE IS FOUND     #
            DO
  
              BEGIN 
              EQUIVALENT = TRUE;
              FOR J = 0 STEP 1     # IF A NAME DUPLICATION OCCURS..... #
                UNTIL (NCHR[TTI] - 1) / CPW 
              DO
                BEGIN 
                IF INAM[TTI + J] NQ INAM[STI + J] 
                THEN
                  BEGIN 
                  EQUIVALENT = FALSE; 
                  J = (NCHR[TTI] - 1) / CPW + 1;
                  END 
                END 
              IF EQUIVALENT 
                AND CLAS[TTI] NQ S"DTXT"  # EXCLUDE DTXTS              #
              THEN
  
                BEGIN 
                IF CLAS[NLNK[TTI]] EQ S"CONS" 
                THEN               # IF S"NAME" OF S"CONS"             #
                  BEGIN 
                  H = NLNK[TTI];
                  NLNK[H] = NLNK[STI];  # LINK CONS TO OLD NAME        #
                  NLNK[STI] = H;
                  END 
  
                ELSE
  
                  BEGIN 
                  DUPDECL = FALSE;
                  FOR J = NLNK[TTI]  # IF NLNK[TTI] CHAIN CONTAINS     #
                    WHILE J NQ TTI   # ATTRIBUTE ENTRIES OTHER         #
                  DO                 # THAN STATUS CONSTANTS           #
                    BEGIN 
                    IF CLAS[J] NQ S"SCON" 
                    THEN
                      BEGIN 
                      DUPDECL = TRUE;  # SET DUPDECL = TRUE            #
                      J = TTI;         # (POSSIBLE DUP DECL)           #
                      END 
                    ELSE
                      BEGIN 
                      J = NLNK[J];
                      END 
                    END 
  
                  IF DUPDECL       # IF POSSIBLE DUP DECL              #
                  THEN
                    BEGIN 
                    FOR J = NLNK[STI]  # IF NLNK[STI] CHAIN CONTAINS   #
                      WHILE J NQ STI   # ATTRIBUTE ENTRIES OTHER       #
                    DO                 # THAN STATUS CONSTANTS         #
                      BEGIN 
                      IF CLAS[J] NQ S"SCON" 
                      THEN
                        BEGIN 
                        J = STI;        # ISSUE DIAGNOSTIC 57.....     #
                        IF TUHNOTPRNTD  # IF TEXT USAGE HEADING HAS NOT#
                        THEN            # BEEN PRINTED YET, PRINT IT   #
                          BEGIN 
                          PTLSTV (" SYMPL TEXT USAGE",2); 
                          TUHNOTPRNTD = FALSE;  # AND INDICATE SAME    #
                          END 
                        IF TNNOTPRNTD   # IF TEXT NAME HAS NOT         #
                        THEN            # BEEN PRINTED YET, PRINT IT   #
                          BEGIN 
                          PTLSTV (STEXTNAME,3); 
                          TNNOTPRNTD = FALSE;  # AND INDICATE SAME     #
                          END 
                        DIAG (D057,TTI);
                        END 
                      ELSE
                        BEGIN 
                        J = NLNK[J];
                        END 
                      END 
                    END 
  
                  FOR J = NLNK[TTI]        # COMBINE ST AND TT         #
                    WHILE NLNK[J] NQ TTI   # NLNK CHAINS               #
                  DO
                    BEGIN 
                    J = NLNK[J];
                    END 
                  NLNK[J] = NLNK[STI];
                  NLNK[STI] = NLNK[TTI];
                  END 
  
                J = INAM[TTI];
                H = STHASH( J );
                IF TCTHASH[H] EQ TTI     # REMOVE S"NAME"[TTI]         #
                THEN                     # FROM ITS HLNK CHAIN         #
                  BEGIN 
                  TCTHASH[H] = HLNK[TTI]; 
                  END 
                ELSE
                  BEGIN 
                  FOR J = TCTHASH[H]
                    WHILE HLNK[J] NQ TTI
                  DO
                    BEGIN 
                    J = HLNK[J];
                    END 
                  HLNK[J] = HLNK[HLNK[J]];
                  END 
  
                FOR J = 0 STEP 1   # NULLIFY S"NAME"[TTI]              #
                  UNTIL (NCHR[TTI] - 1) / CPW + 1 
                DO
                  BEGIN 
                  SYM0[TTI + J] = NULL; 
                  CLAS[TTI + J] = S"EMPT";
                  END 
  
                END 
  
              STI = HLNK[STI];     # UPDATE ST S"NAME" POINTER         #
              END 
  
            TTI = K;               # UPDATE TT S"NAME" POINTER         #
            END 
  
          IF TCTHASH[I] NQ 0       # UNLESS TCTHASH[I] WAS ZEROED      #
          THEN                     # IN PREVIOUS PROCESS               #
            BEGIN 
            FOR J = HLNK[I]        # APPEND TCT HASH CHAIN             #
              WHILE HLNK[J] NQ 0   # TO ST HASH CHAIN                  #
            DO
              BEGIN 
              J = HLNK[J];
              END 
            HLNK[J] = TCTHASH[I]; 
            END 
  
          END 
  
        ELSE
  
          BEGIN 
          IF HLNK[I] EQ 0          # IF ST HASH IS ZERO                #
          THEN                     # SET ST HASH TO TCT HASH           #
            BEGIN 
            HLNK[I] = TCTHASH[I]; 
            END 
          END 
  
        END 
  
  
      END 
      CONTROL EJECT;
  
  
      PROC TTLINK;
  
      BEGIN 
  
  
#----------------------------------------------------------------------#
#                                                                      #
#     P R O C   T T L I N K                                            #
#                                                                      #
#     LINK A TEXT TABLE INTO THE EXISTING SYMBOL TABLE.                #
#                                                                      #
#----------------------------------------------------------------------#
  
  
      DEF D055 #55#;               # DIAGNOSTIC 55                     #
      DEF D217 #217#;              # DIAGNOSTIC 217                    #
      DEF J868 #868#;              # SYMABT 868, BAD CLAS              #
  
      XREF PROC FIND;              # FIND SYMBOL TABLE S"NAME"         #
      XREF PROC SDUMPE;            # DUMP A SINGLE SYMBOL TABLE ENTRY  #
      XREF PROC SYMABT;            # ABORT WITH A CATASTROPHIC ERROR   #
  
      ITEM ENDPLC I;               # TEMP FOR ESPLC                    #
      ITEM FOUND        B;         # FLAG FOR NAME SEARCHING           #
      ITEM N            I;         # TEMP                              #
  
  
      SWITCH USESCAN:QCLAS
        USE10: NAME,
        USE08: DATA,
        USE06: TABL,
        USE09: CONS,
        USE09: PROC,
        USE09: FUNC,
        USE11: EMPT,
        USE09: PROG,
        USE02: DEF ,
        USE05: SLC ,
        USE03: BPAR,
        USE04: TITM,
        USE01: SCON,
        USE09: COMM,
        USE10: STSL,
        USE10: DTXT,
  
        USERR: LABL,               # BAD CLASSES                       #
        USERR: SWCH,
        USERR: INSC,
        USERR: DUMY,
        USERR: ADCN,
        USERR: FPAR;
  
      CONTROL EJECT;
  
#     T T L I N K   E N T R Y                                          #
  
  
  
  
      IF TCTSPLC[0] NQ 0           # ADJUST NON-ZERO TEXT CONTROL      #
      THEN                         # TABLE SLC AND NONAM POINTERS      #
        BEGIN 
        TCTSPLC[0] = TCTSPLC[0] + RELOC;
        END 
      IF TCTXPLC[0] NQ 0
      THEN
        BEGIN 
        TCTXPLC[0] = TCTXPLC[0] + RELOC;
        END 
      IF TCTESPLC[0] NQ 0 
      THEN
        BEGIN 
        TCTESPLC[0] = TCTESPLC[0] + RELOC;
        END 
      IF TCTNONAM[0] NQ 0 
      THEN
        BEGIN 
        TCTNONAM[0] = TCTNONAM[0] + RELOC;
        END 
  
      IF TCTLENT[0] NQ 0           # ADJUST NON-ZERO TEXT CONTROL      #
      THEN                         # TABLE BABY AND LENT POINTERS      #
        BEGIN 
        TCTLENT[0] = TCTLENT[0] + RELOC;
        END 
      IF TCTBABY[0] NQ 0
      THEN
        BEGIN 
        TCTBABY[0] = TCTBABY[0] + RELOC;
        END 
  
  
      IF RELOC NQ 0                # UNLESS RELOC = 0                  #
      THEN
        BEGIN 
        FOR I = 0 STEP 1           # ADJUST NON-ZERO TEXT CONTROL TABLE#
          UNTIL L$HASH             # HASH LINKS                        #
        DO                         # (NEWLINK = OLDLINK + RELOC)       #
          BEGIN 
          IF TCTHASH[I] NQ 0
          THEN
            BEGIN 
            TCTHASH[I] = TCTHASH[I] + RELOC;
            FOR STI = TCTHASH[I]   # ADJUST ALL NON-ZERO TEXT TABLE    #
              WHILE HLNK[STI] NQ 0   # HLNKS ON THE CURRENT HLNK CHAIN #
            DO
              BEGIN 
              HLNK[STI] = HLNK[STI] + RELOC;
              STI = HLNK[STI];
              END 
            END 
          END 
        END 
  
  
#     TTLINK CONTINUES ON THE FOLLOWING PAGE                           #
      CONTROL EJECT;
  
  
#----------------------------------------------------------------------#
#                                                                      #
#     THE NEXT PROCESS SECTION (THRU USE11), WHICH IS CONTROLLED       #
#     BY A STATUS SWITCH BASED ON QCLAS, SCANS THE TEXT TABLE          #
#     ENTRY-BY-ENTRY, ADJUSTING ALL APPROPRIATE NON-ZERO LINK FIELDS   #
#     (NEWLINK = OLDLINK + RELOC).  DEF PARAMETER NAMES ARE ALTERED,   #
#     IF NECESSARY, TO AVOID DEF PARAMETER NAME DUPLICATES.            #
#                                                                      #
#----------------------------------------------------------------------#
  
  
      FOR INDX = TTSI + 2          # (TTSI+2 = SYMBOL TABLE OFFSET OF  #
        WHILE INDX LS NXTAV        # FIRST TEXT TABLE ENTRY EXCLUDING  #
      DO                           # THE ASCM AND TTOL WORDS           #
        BEGIN                      # SYMBOL TABLE SCAN                 #
  
        GOTO USESCAN[CLAS[INDX]];  # SELECT PROCESS BASED ON CLAS      #
                                   # OF CURRENT TEXT TABLE ENTRY       #
          BEGIN 
  
USE01:  
                                   # QCLAS SCON                        #
          SMOM[INDX] = SMOM[INDX] + RELOC;
          GOTO USE10; 
  
USE02:  
                                   # QCLAS DEF                         #
          FOR I = NLNK[INDX] + RELOC  # LOCATE S"NAME" OF S"DEF"       #
            WHILE CLAS[I] NQ S"NAME"  # SET I = INDEX OF S"NAME"       #
          DO
  
            BEGIN 
            IF I GR INDX
            THEN
              BEGIN 
              I = NLNK[I] + RELOC;
              END 
            ELSE
              BEGIN 
              I = NLNK[I];
              END 
            END 
  
          IF B<BPC*4,BPC>INAM[I] NQ DEFPARCHAR
          THEN                     # IF NOT DEF PARAMETER ENTRY        #
  
            BEGIN                  # (DEF PARAM PROCESSING)            #
            TTI = PARLNK[INDX]; 
            FOR  N= 1  STEP 1      # PROCESS ALL DEF PARAMS ON         #
              UNTIL  NPMC[INDX]    # PARLNK CHAIN                      #
            DO
  
              BEGIN 
              STI = TTI + RELOC;   # STI = ST INDEX OF DEF PARAM       #
              STN = NLNK[STI] + RELOC;  # STN = INDEX OF DEF PARAM NAME#
  
              IF INAM[STN] NQ NADPN  # IF DEF PARAM NAME NQ NADPN      #
              THEN                   # REPLACE DEF PARAM NAME BY NADPN #
  
                BEGIN 
                I = INAM[STN];
                H = STHASH( I );
                FOR I = TCTHASH[H]   # REMOVE DEF PARAM NAME           #
                  WHILE I NQ STN     # FROM ITS HLNK CHAIM             #
                DO
                  BEGIN 
                  H = I;
                  I = HLNK[I];
                  END 
                IF H LQ L$HASH
                THEN
                  BEGIN 
                  TCTHASH[H] = HLNK[TCTHASH[H]];
                  END 
                ELSE
                  BEGIN 
                  HLNK[H] = HLNK[HLNK[H]];
                  END 
  
                I = NADPN;
                H = STHASH( I );
                FOR I = TCTHASH[H]
                  WHILE I NQ 0     # EXTEND APPROPRIATE HLNK CHAIN (OR #
                DO                 # TCTHASH ENTRY) TO INCLUDE NADPN   #
                  BEGIN 
                  H = I;
                  I = HLNK[I];
                  END 
                IF H LQ L$HASH
                THEN
                  BEGIN 
                  TCTHASH[H] = STN; 
                  END 
                ELSE
                  BEGIN 
                  HLNK[H] = STN;
                  END 
  
                HLNK[STN] = 0;     # HLNK OF DEF PARAM NAME = 0        #
  
                EQUIVALENT = FALSE;  # REPLACE PARAM NAME IN DTXT      #
                STI = SPTR[INDX] + RELOC;  # STI = ST INDEX OF         #
                                           # DTXT OF DEF               #
                FOR I = 0 STEP 1   # SEARCH INAM[STI] FOR PARAM NAME   #
                  UNTIL  ( NCHR[STI] - 1) / BYTNDEFWD 
                DO                      # (INAM[STN])                  #
                  BEGIN     # DTXT WORD LOOP #
  
                  FOR J = 0 STEP 1   # I = DTXT WORD POINTER           #
                    WHILE J LS BYTNDEFWD  # J = DTXT CHAR POINTER      #
                      AND NOT EQUIVALENT
                  DO
                    BEGIN     # DTXT CHAR LOOP #
  
                    IF B<J*12,12>INAM[STI + I] EQ ENDPARAM
                    THEN           # IF END OF PARAM FOUND             #
                      BEGIN     # PARAM FOUND # 
  
                      K = I;       # K = DTXT WORD POINTER             #
                      L = J;       # L = DTXT CHAR POINTER             #
                      M = 4;       # M = DEF PARAM NAME CHAR POINTER   #
                      EQUIVALENT = TRUE;  # ASSUME EQUIVALENCE         #
                      FOR J = J    # SEARCH BACKWARD CHAR BY CHAR      #
                        WHILE M GR 0   # FOR EQUIVALENT NAMES          #
                      DO
                        BEGIN     # SEARCH BACKWARDS #
                        L = L - 1;   # DECREMENT CHAR POINTERS         #
                        M = M - 1;
                        IF L LS 0    # IF WORD BOUNDARY CROSSED        #
                        THEN
                          BEGIN 
                          L = BYTNDEFWD - 1;  # RESET L TO RMOST CHAR  #
                          K = K - 1;   # AND DECREMENT WORD POINTER    #
                          END 
                        IF B<L*12+6,6>INAM[STI+K] NQ B<M*6,6>INAM[STN]
                        THEN       # IF CHARS NOT EQUIVALENT           #
                          BEGIN 
                          EQUIVALENT = FALSE;  # SET NON-EQUIVALENCE   #
                          M = -1;              # AND STOP SEARCHING    #
                          END 
                        END       # SEARCH BACKWARDS #
  
#     IF EQUIVALENT, THEN THE PARAM NAME FOUND IS THE ONE BEING        #
#     SEARCHED FOR.  K = INAM OFFSET TO THE DTXT WORD WITHIN WHICH     #
#     THE PARAM NAME BEGINS.  L = POINTER TO LEFTMOST CHAR OF NAME     #
#     WITHIN THAT WORD.  NOW REPLACE THE PARAM NAME WITH NADPN.        #
  
                      IF  EQUIVALENT
                      THEN
                        BEGIN     # REPLACE # 
                        EQUIVALENT = FALSE; 
                        FOR  M = 0  STEP 1
                          UNTIL  L$DPN - 2
                        DO
                          BEGIN 
                          B<L*12+CL,CL>INAM[STI+K] = B<M*CL,CL>NADPN; 
                          L = L + 1;
                          IF  L EQ BYTNDEFWD
                          THEN
                            BEGIN 
                            L = 0;
                            K = K + 1;
                            END 
  
                          END 
                        END       # REPLACE # 
  
                      END       # PARAM FOUND # 
  
                    END       # DTXT CHAR LOOP #
  
                  END       # DTXT WORD LOOP #
  
  
                INAM[STN] = NADPN;   # DEF PARAM NAME = NADPN          #
  
                END 
  
              FOR I = 3 STEP -1    # INCREMENT NADPN                   #
                WHILE I GQ 0
              DO
                BEGIN 
                IF B<I*6,6>NADPN EQ CHNINE
                THEN
                  BEGIN 
                  B<I*6,6>NADPN = "A";
                  END 
                ELSE
                  BEGIN 
                  B<I*6,6>NADPN = B<I*6,6>NADPN + 1;
                  I = -1; 
                  END 
                END 
              TTI = PARLNK[TTI + RELOC];   # UPDATE DEF PARAM POINTER  #
              END 
  
            END 
  
          IF SPTR[INDX] GR 1
          THEN
            BEGIN 
            SPTR[INDX] = SPTR[INDX] + RELOC;
            END 
          IF PARLNK[INDX] NQ 0
          THEN
            BEGIN 
            PARLNK[INDX] = PARLNK[INDX] + RELOC;
            END 
          GOTO USE10; 
  
USE03:  
                                   # QCLAS BPAR                        #
          IF BCOR[INDX] NQ 0
          THEN
            BEGIN 
            BCOR[INDX] = BCOR[INDX] + RELOC;
            END 
          IF BPLK[INDX] NQ 0
          THEN
            BEGIN 
            BPLK[INDX] = BPLK[INDX] + RELOC;
            END 
          IF  DMPY[INDX] NQ 0 
          THEN
            BEGIN 
            DMPY[INDX] = DMPY[INDX] + RELOC;
            END 
          GOTO USE10; 
  
USE04:  
                                   # QCLAS TITM                        #
          MAMA[INDX] = MAMA[INDX] + RELOC;
          GOTO USE08; 
  
USE05:  
                                   # QCLAS SLC                         #
          LENT[INDX] = LENT[INDX] + RELOC;
          GOTO USE07; 
  
USE06:  
                                   # QCLAS TABL                        #
          SBSC[INDX] = SBSC[INDX] + RELOC;
          IF  MCNS[INDX] NQ 0 
          THEN
            BEGIN 
            MCNS[INDX] = MCNS[INDX] + RELOC;
            END 
          GOTO USE07; 
  
USE07:  
                                   # QCLAS SLC, TABL                   #
          IF BABY[INDX] NQ 0
          THEN
            BEGIN 
            BABY[INDX] = BABY[INDX] + RELOC;
            END 
          GOTO USE09; 
  
USE08:  
                                   # QCLAS DATA, TITM                  #
          IF SLLK[INDX] NQ 0
          THEN
            BEGIN 
            J = SLLK[ INDX ] + RELOC; 
            IF CLAS[J] EQ S"STSL" 
            THEN                   # STATUS LIST IN SAME TEXT          #
              BEGIN 
              SLLK[ INDX ] = J;    # RELOCATE SLLK                     #
              END 
            ELSE
              BEGIN 
              IF CLAS[J] EQ S"SNAM" 
              THEN                 # LOOK FOR STATUS LIST              #
                BEGIN 
                I = INAM[J];       # NAME OF STATUS LIST               #
                H = STHASH( I );
                FOUND = FALSE;
                FOR  I = HLNK[H]
                  WHILE  I NQ 0 
                    AND  NOT FOUND
                DO
                  BEGIN 
                  FOR  K = 1  STEP 1
                    UNTIL  (NCHR[J] - 1)/CPW + 1
                  DO
                    BEGIN 
                    FOUND = SYM0[ I + K ] EQ SYM0[ J + K ]; 
                    END 
  
                  IF NOT FOUND
                  THEN
                    BEGIN 
                    I = HLNK[I];
                    END 
  
                  END 
#           IF FOUND = TRUE, WE'VE FOUND A MATCHING NAME               #
                IF  FOUND 
                THEN               # LOOK FOR A STATUS LIST            #
                  BEGIN 
                  FOUND = FALSE;
                  FOR  K = NLNK[I]
                    WHILE  K NQ I 
                      AND  NOT FOUND
                  DO
                    BEGIN 
                    FOUND = CLAS[K] EQ S"STSL"; 
                    IF  NOT FOUND 
                    THEN
                      BEGIN 
                      K = NLNK[K];
                      END 
                    END 
                  END 
  
                IF  NOT FOUND 
                THEN
                  BEGIN 
                  CLAS[J] = S"NAME";  # TRICK DIAG INTO PRINTING NAME  #
                  DIAG( D217, J );    # STATUS LIST NOT FOUND          #
                  SLLK[INDX] = INDX;
                  K = 0;
                  END 
                ELSE
                  BEGIN 
                  SLLK[INDX] = K; 
                  END 
                L = (NCHR[J] - 1)/CW + 1; 
                FOR  I = 0  STEP 1
                  UNTIL  L
                DO
                  BEGIN 
                  SYM0[ J + I ] = 0;
                  CLAS[ J + I ] = S"EMPT";
                  END 
                NLNK[J] = K;
                END 
              ELSE                 # ALREADY AN EMPTY                  #
                BEGIN 
                IF  NLNK[J] EQ 0
                THEN               # ALREADY LOOKED, CANT FIND         #
                  BEGIN 
                  SLLK[INDX] = INDX;
                  END 
                ELSE
                  BEGIN 
                  SLLK[INDX] = NLNK[J]; 
                  END 
                END 
              END 
            END 
          GOTO USE09; 
  
USE09:  
                                   # QCLAS CONS, PROC, FUNC            #
                                   # PROG, COMM, DATA, SLC, TABL, TITM #
          IF ASEQ[INDX] NQ 0
          THEN
            BEGIN 
            ASEQ[INDX] = ASEQ[INDX] + RELOC;
            END 
          GOTO USE10; 
  
USE10:  
                                   # QCLAS (ALL EXCEPT EMPT)           #
          NLNK[INDX] = NLNK[INDX] + RELOC;
          GOTO USE11; 
USERR:                             # BAD QCLAS                         #
          $BEGIN
          SDUMPE(3,INDX); 
          $END
          SYMABT(J868,"BAD CLASS IN TEXT (USETEXT)", 27); 
  
  
USE11:  
                                   # QCLAS (ALL)                       #
          IF CLAS[INDX] EQ S"NAME" # UPDATE INDX AND LOOP BACK         #
          THEN                     # TO PROCESS ANOTHER ENTRY          #
            BEGIN 
            INDX = INDX + (NCHR[INDX] - 1) / CPW + 2; 
            END 
          ELSE
            BEGIN 
            IF CLAS[INDX] EQ S"DTXT"
            THEN
              BEGIN 
              INDX = INDX + (NCHR[INDX] - 1) / BYTNDEFWD + 2; 
              END 
            ELSE
              BEGIN 
              INDX = INDX + ENTRY$W[CLAS[INDX]];
              END 
            END 
  
          END 
  
        END                        # SYMBOL TABLE SCAN                 #
  
  
#     TTLINK CONTINUES ON THE FOLLOWING PAGE                           #
      CONTROL EJECT;
  
  
      ENDPLC = ESPLC;              # TEMP ESPLC                        #
  
      FOR TTI = TCTSPLC[0]         # PROCESS EACH TEXT TABLE S"SLC"    #
        WHILE TTI NQ 0
      DO
        BEGIN 
  
        FIND (TTI,TTN);            # TTN = TT S"NAME" OF S"SLC"        #
        EQUIVALENT = FALSE;        # TT SLC ASSUMED TO BE UNIQUE       #
  
        FOR STI = SPLC             # COMPARE TT S"SLC" TO EACH ST      #
          WHILE STI NQ 0           # S"SLC" OR UNTIL A DUP IS FOUND    #
        DO
          BEGIN 
  
          IF ESDC[TTI] EQ ESDC[STI]  # IF TT S"SLC" TYPE DUPS ST S"SLC"#
          THEN
            BEGIN 
  
            EQUIVALENT = TRUE;     # SLCS ARE NOW ASSUMED TO BE DUPS   #
            IF ESDC[TTI] EQ S"COMM"  # IF COMMON BLOCK SLCS, COMPARE   #
            THEN                     # THEIR NAMES                     #
              BEGIN 
              FIND (STI,STN);      # STN = S"NAME" OF ST S"SLC"        #
              FOR I = 0 STEP 1
                WHILE I LQ (NCHR[STN] - 1) / CPW
              DO
                BEGIN 
                IF INAM[TTN + I] NQ INAM[STN + I] 
                THEN               # COMMON BLOCK NAMES ARE DIFFERENT  #
                  BEGIN 
                  EQUIVALENT = FALSE;  # SO SLCS ARE NOT DUPLICATES    #
                  I = (NCHR[STN] - 1) / CPW + 1;  # END NAME COMPARISON#
                  END 
                END 
              IF EQUIVALENT        # IF DUPLICATE COMMON SLCS          #
              THEN
                BEGIN 
                IF TUHNOTPRNTD     # IF TEXT USAGE HEADING HAS NOT     #
                THEN               # BEEN PRINTED YET, PRINT IT        #
                  BEGIN 
                  PTLSTV (" SYMPL TEXT USAGE",2); 
                  TUHNOTPRNTD = FALSE;  # AND INDICATE SAME            #
                  END 
                IF TNNOTPRNTD      # IF TEXT NAME HAS NOT              #
                THEN               # BEEN PRINTED YET, PRINT IT        #
                  BEGIN 
                  PTLSTV (STEXTNAME,3); 
                  TNNOTPRNTD = FALSE;  # AND INDICATE SAME             #
                  END 
                DIAG (D055,TTN);   # ISSUE DIAGNOSTIC 55               #
                END 
  
              END 
  
            IF EQUIVALENT          # IF DUPLICATE SLCS                 #
            THEN                   # (COMMON OR NON-COMMON             #
              BEGIN 
  
              ASEQ[LENT[STI]] = BABY[TTI];  # LINK TEXT TABLE SLC      #
              LENT[STI] = LENT[TTI];        # TO SYMBOL TABLE SLC      #
  
              IF (NLNK[TTN] EQ TTI       # IF S"NAME"[TTN] IS UNIQUE   #
                AND NLNK[TTI] EQ TTN)    # TO S"SLC"[TTI]              #
                OR
                  (CLAS[NLNK[TTN]] EQ S"COMM" 
                  AND NLNK[TTI] EQ TTN) 
              THEN
                BEGIN 
                I = INAM[TTN];
                H = STHASH( I );
                IF TCTHASH[H] EQ TTN     # REMOVE S"NAME"[TTN]         #
                THEN                     # FROM ITS HLNK CHAIN         #
                  BEGIN 
                  TCTHASH[H] = HLNK[TTN]; 
                  END 
                ELSE
                  BEGIN 
                  FOR I = TCTHASH[H]
                    WHILE HLNK[I] NQ TTN
                  DO
                    BEGIN 
                    I = HLNK[I];
                    END 
                  HLNK[I] = HLNK[HLNK[I]];
                  END 
                CONTROL FASTLOOP; 
                FOR I = 0 STEP 1   # AND NULLIFY S"NAME"[TTN]          #
                  UNTIL (NCHR[TTN] - 1) / CPW + 1 
                DO
                  BEGIN 
                  SYM0[TTN + I] = NULL; 
                  CLAS[TTN + I] = S"EMPT";
                  END 
                CONTROL SLOWLOOP; 
                END 
              ELSE
                BEGIN 
                FOR I = TTN        # ELSE REMOVE S"SLC"[TTI]           #
                  WHILE NLNK[I] NQ TTI  # FROM ITS NLNK CHAIN          #
                DO
                  BEGIN 
                  I = NLNK[I];
                  END 
                NLNK[I] = NLNK[TTI];
                END 
  
              J = ASEQ[TTI];       # TEMP POINTER TO NEXT TT S"SLC"    #
              CONTROL FASTLOOP; 
              FOR I = 0 STEP 1     # NULLIFY DUPLICATE TEXT TABLE      #
                UNTIL SLC$W - 1    # S"SLC" ENTRY                      #
              DO
                BEGIN 
                SYM0[TTI + I] = NULL; 
                CLAS[TTI + I] = S"EMPT";
                END 
              CONTROL SLOWLOOP; 
  
              STI = ENDPLC;        # SET STI TO TERMINATE COMPARISONS  #
                                   # FOR CURRENT TEXT TABLE S"SLC"     #
              END 
  
            END 
  
          IF STI LS ENDPLC         # IF MORE COMPARISONS REMAIN        #
          THEN                     # AND ARE NEEDED                    #
            BEGIN 
            STI = ASEQ[STI];       # SET STI = INDEX OF NEXT ST S"SLC" #
            END 
          ELSE
            BEGIN 
            STI = 0;               # ELSE STI = 0 TO TERMINATE LOOP    #
            END 
  
          END 
  
        IF NOT EQUIVALENT          # IF TT S"SLC" NOT DUPLICATED       #
        THEN
          BEGIN 
  
          ASEQ[ESPLC] = TTI;       # LINK TT S"SLC" INTO ST S"SLC"     #
          ESPLC = TTI;             # ASEQ CHAIN AND RESET ESPLC        #
          J = ASEQ[TTI];           # TEMP POINTER TO NEXT TT S"SLC"    #
  
          END 
  
        TTI = J;                   # SET TTI = INDEX OF NEXT TT S"SLC" #
  
        END 
  
  
      IF TCTBABY[0] NQ 0           # IF TEXT TABLE DATA SLC EXISTS     #
      THEN                         # LINK TT DATA SLC TO ST DATA SLC   #
        BEGIN 
        ASEQ[LENT[DPLC]] = TCTBABY[0];
        LENT[DPLC] = TCTLENT[0];
        END 
  
      IF XPLC EQ 0                 # IF ST EXT SLC DOES NOT EXIST      #
      THEN                         # SET ST XPLC TO TCT XPLC           #
        BEGIN 
        XPLC = TCTXPLC[0];         # (TCTXPLC = 0 IF NO TT EXT SLC)    #
        END 
  
      IF TCTNONAM[0] NQ 0          # LINK ANY TT NONAM CHAIN INTO      #
      THEN                         # THE ST NONAM CHAIN                #
        BEGIN 
        NLNK[NONAM] == NLNK[TCTNONAM[0]]; 
        END 
  
  
      END 
      CONTROL EJECT;
  
  
#     U S E T E X T   E N T R Y                                        #
  
  
      IF B<59-"L">OPTION NQ 0      # IF LIST OPTION NQ ZERO            #
      THEN                         # PRINT TEXT USAGE HEADING          #
        BEGIN 
        PTLSTV (" SYMPL TEXT USAGE",2); 
        TUHNOTPRNTD = FALSE;       # INDICATE THAT IT HAS BEEN PRINTED #
        END 
  
      FOR I = I                    # USETEXT LOOP COMPLETES WHEN       #
      DO                           # GST SETS DONE = TRUE              #
        BEGIN 
  
        GST (DONE);                # GET SYMPL TEXT                    #
  
        IF DONE                    # IF NO MORE TEXTS                  #
        THEN
  
          BEGIN 
  
            $BEGIN
            IF B<STDUMP>INTOPS NQ 0  # DUMP SYMBOL TABLE IF *=9        #
            THEN
              BEGIN 
              SDUMP (3);
              END 
            $END
  
          TTORIGIN = NXTAV;        # UPDATE TTORIGIN                   #
          RETURN;                  # RETURN TO INIT15                  #
  
          END 
  
        ELSE
  
          BEGIN 
  
          TTSI = NXTAV;            # SET TEXT TABLE STARTING INDEX     #
          TTOL = SYM0[NXTAV + 1];  # SET TEXT TAB ORIG AND LENGTH DESC #
          NXTAV = NXTAV + TTLEN[0];  # RESET NXTAV                     #
          RELOC = TTSI - TTORIG[0];  # ESTABLISH TEXT TAB RELOC FACTOR #
  
          TNAME = TCTTNAME[0];     # TEXT NAME FROM TEXT CONTROL TABLE #
          TNNOTPRNTD = TRUE;       # INDICATE TEXT NAME NOT PRINTED YET#
          IF B<59-"L">OPTION NQ 0  # IF LIST OPTION NQ ZERO            #
          THEN                     # PRINT TEXT NAME HEADING           #
            BEGIN 
            PTLSTV (STEXTNAME,3); 
            TNNOTPRNTD = FALSE;    # AND INDICATE SAME                 #
            END 
  
          TTLINK;                  # LINK TEXT TABLE INTO SYMBOL TABLE #
  
          RESTTNC;                 # RESOLVE TEXT TABLE NAME CONFLICTS #
  
          REPLTTH;                 # REPLACE TEXT TABLE HEADER         #
  
            $BEGIN
            IF B<STDUMP>INTOPS NQ 0  # PRINT DEBUG INFO FOR CURRENT    #
            THEN                     # TEXT IF *=9                     #
              BEGIN 
              BINOCT (DBUG1,6,TTSI,6);
              PTLSTV (DBUG1,2); 
              END 
            $END
  
          END 
  
        END 
  
  
      END 
  
  
      TERM
