*DECK TKNCLAS 
USETEXT CCTTEXT 
USETEXT SSTEXT
          PROC TKNCLASSIFY; 
  
#**       TKNCLASSIFY -  EXTRACT AND CLASSIFY A TOKEN                  #
#                                                                      #
#     CALLING FORM-                                                    #
#         TKNCLASSIFY:                                                 #
#                                                                      #
#     GIVEN-                                                           #
#         AWISPNREF = TRUE IFF AW IS PNREF.                            #
#         CURRENTDIV = CURRENT DIVISION.                               #
#         CURSIGN = CURRENCY SIGN CHARACTER.                           #
#         DECPOINT = DECIMAL POINT CHARACTER  (. OR ,)                 #
#         ILITISPNREF = TRUE IFF ILIT IS PNREF.                        #
#         QUOTE = CHARACTER DELIMITING NON NUMERIC LITERALS.           #
#                                                                      #
#     DOES-                                                            #
#         CLACOLUMN = NUMBER OF COLUMN CONTAINING FIRST CHARACTER.     #
#         CLALINE = NUMBER OF LINE CONTAINING FIRST CHARACTER.         #
#         CLATYPE = TYPE OF TOKEN (STATUS LIST TKNTYPE)                #
#         CLAVALUE = AUXILIARY VALUE (E.G. RESERVED WORD ORDINAL).     #
#         SAREA = 26-WORD AREA CONTAINING PACKED CHARACTERS,           #
#           BLANK-FILLED.                                              #
#         SAREALENGTH = NUMBER OF CHARACTERS IN *SAREA*.               #
#         SIGNSW = TRUE IFF NUMERIC LITERAL WAS PRECEDED BY *-*.       #
  
  
          BEGIN 
          CONTROL PACK; 
  
          XDEF  ITEM  STCOPY B=FALSE; 
          XREF               # INPUT VARIABLES                         #
              BEGIN 
              ITEM  CURRENTDIV   U;    # CURRENT SOURCE DIVISION       #
              ITEM  CURSIGN      C(1); # CURRENCY SIGN CHARACTER       #
              ITEM  DECPOINT     C(1); # DECIMAL-POINT CHARACTER       #
              ITEM  EODREPL      B;    # TRUE IF EOD FND IN REPLACEMODE#
              ITEM  FSTPTDELIM   B;    # LEFT HAND PSEUDO-TXT DELIM FLG#
              ITEM  ILITISPNREF  B;    # ILIT IS PNREF                 #
              ITEM  LSTPTDELIM   B;    # RIGT HAND PSEUDO-TXT DELIM FLG#
              ITEM  LSTTKNP      B;    # LST REPL TRGT TKN WAS PERIOD  #
              ITEM  QUOTE        C(1); # CHARACTER FOR NON-NUM LITS    #
              ITEM  REPLAC$MODE  B;    # TRUE IF A REPLACE STMT ACTIVE #
              ITEM  RSTATE       I;    # REPLACE STATE                 #
              ITEM  SVCURCSTATE  I;    # SAVED STATE - USED BY REPLACE #
              ITEM  TKNREADY     B;    # TRU IF RPLC HAS TKN FOR POLISH#
              END 
  
          XREF               # EXTERNAL PROCEDURES                     #
              BEGIN 
              PROC  ABORTSS;           # COMPILER ERROR                #
              PROC  CBLIST;            # COBOL LISTING ROUTINE         #
              PROC  CMM$FGR;           # FREE GROUP OF CMM BLOCKS      #
              PROC  DBDIAG;            # DEBUG DIAGNOS                 #
              FUNC  DEC      C(10);    # DECIMAL DISPLAY VALUE         #
              PROC  GETPIC;            # GET A PICTURE CHARACTER-STRING#
              PROC  INTERCEPTOR;       # ISSUE DIAGNOSTIC              #
              FUNC  OCT      C(20);    # OCTAL DISPLAY VALUE           #
              PROC  RELPLINDEX;        # RELEASE PL INDEX              #
              PROC  SETCOPY;           # SET UP *COPY* INFO            #
              PROC  SSDIAGS;
              PROC  CHKRW;             # CHECK FOR RESERVED WORD       #
              PROC  GETSTR;            # GET A CHARACTER STRING        #
              PROC   GETPLINDEX;
              PROC REPLACE;            # REPLACE PROCESSOR             #
  
  
              END 
  
  
*CALL BUG020C$
  
  
*CALL LISTCTL 
  
          SWITCH  STATE 
               ,  STATE1               # NORMAL PROCESSING             #
               ,  STATE2               # READ LIBRARY WITH REPLACING   #
               ,  STATE3               # READ LIBRARY WITH REPLACING FP#
               ,  STATE4               # WRITE ACTUAL PARAMETERS       #
               ,  STATE5               # FLUSH TARGET STRING           #
               ,  STATE6               # WIND DOWN REPLACE PROCESSING  #
               ;
  
          SWITCH  TKNSWITCH 
*CALL TKNTYPE 
  
          STATUS  TKNTYPE 
*CALL TKNTYPE 
  
CONTROL EJECT;
  
          ITEM  APC          I;        # SETAP+STATE4- AP CHAR. OFFSET #
          ITEM  APL          I;        # SETAP- LENGTH OF ACTUAL PARAMS#
          ITEM  APLTKN       I;        # SETAP- AP$L[TKN]              #
          ITEM  APOFFSET     I;        # SETAP+STATE4- APARRAY OFFSET  #
          ITEM  APW          I;        # SETAP+STATE4- AP WORD OFFSET  #
          ITEM  CHAR         C(1);     # SCRATCH                       #
          ITEM  C            I;        # SCRATCH- CHARACTER COUNT      #
          ITEM  EASY         B;        # SETAP- IFF EASY LISTING       #
          ITEM  EXP          I;        # VALUE OF EXPONENT             #
          ITEM  EXPSIGN      I;        # SIGN OF EXPONENT              #
          ITEM  F            I;        # SETAP- FIRST PRINT LINE       #
          ITEM  FIRSTNOTPIC  B=TRUE;   # IFF FIRST TARGET TOKEN IS PIC #
          ITEM  FLAG         B;        # SCRATCH                       #
          ITEM  FP           I;        # INDEX TO FORMAL PARAMS.       #
          ITEM  FPC          I; 
          ITEM  FPOFFSET     I; 
          ITEM  FPW          I; 
          ITEM  I            I;        # SCRATCH                       #
          ITEM  J            I;        # SCRATCH                       #
          ITEM  K            I;       # SCRATCH                       # 
          ITEM  L            I;        # SCRATCH                       #
          ITEM  LEADZERO     B;        # TRUE IFF ONLY ZEROS YET       #
          ITEM  LIBTKNISPIC  B=FALSE;  # WHETHER LIB TKN IS PIC STRING #
          ITEM  M            I;        # SCRATCH     #
          ITEM  MANTISSA     C(18);    # VALUE OF MANTISSA             #
          ITEM  MATCH        B;        # IF FP TOKEN MATCHES TARGET    #
          ITEM  N            I;        # SCRATCH                       #
          ITEM  NEWW         I;        # NEW WORD OFFSET               #
          ITEM  OLDW         I;        # OLD WORD OFFSET               #
          ITEM OLDVLN I;     #VLN OF PREVIOUS WORD# 
          ITEM  PLACE        I;        # PLACE OF DECIMAL POINT        #
          ITEM  POINT        B;        # TRUE IFF DECIMAL POINT FOUND  #
         ITEM  PUNCNXT      B=FALSE;
          ITEM  REPLALLOWED  B=TRUE;   # TRUE - REPLACE STMT ALLOWED   #
 ITEM   SEENIS       B=FALSE; 
          ITEM  TCOLUMN      I;        # SETAP- TARGET COLUMN          #
          ITEM  TEMPLINE     C(72);    # TEMP FOR SHIFT IN REPLACE     #
          ITEM  TKN          I;        # STATE5- INDEX TO TOKEN        #
          ITEM  TKNLIM       I;        # STATE5- LIMIT FOR TKN         #
          ITEM  TL           I;        # TOTAL LENGTH OF TARGET        #
          ITEM  TLCOLUMN     I;        # SETAP- LAST COLUMN OF TARGET  #
          ITEM  TLVLN        I;        # SETAP- LAST VLN OF TARGET     #
          ITEM  TVLN         I;        # SETAP- VLN OF TARGET          #
          ITEM  W            I;        # SCRATCH-  WORD COUNT          #
  
  
#     VALUES FOR -CURRENTDIV-                                          #
          DEF  IDENTDIV      #1#;      # IDENTIFICATION DIVISION       #
          DEF  ENVIRDIV      #2#;      # ENVIRONMENT DIVISION          #
          DEF  DATADIV       #3#;      # DATA DIVISION                 #
          DEF  REPORTSEC     #4#;      # REPORT SECTION                #
          DEF  PROCDIV       #5#;      # PROCEDURE DIVISION            #
  
#      DIAGNOSTIC DEFS                                                 #
  
          DEF D1046 #046#;
          DEF D1075 #075#;
          DEF D1076 #076#;
          DEF D1092 #092#;
          DEF D1100 #100#;
          DEF  D1101  #101#;
          DEF D1103 #103#;
          DEF D1106 #106#;
          DEF D1109 #109#;
          DEF D1112 #112#;
          DEF D1115 #115#;
          DEF D1140 #140#;
          DEF D1601 #601#;
  
          $BEGIN
          ITEM  C10          C(10);    # SCRATCH                       #
          ITEM  LINE         C(140);   # DEBUG PRINT LINE              #
  
          ARRAY  BUG$ [1:17]; 
              ITEM  BUG$TKNTYPE  C(0, 0, 7) = 
                [ "ILIT   ",
                  "NLIT   ",
                  "FLIT   ",
                  "QLIT   ",
                  "AW     ",
                  "OP     ",
                  "PUNC   ",
                  "RP     ",
                  "LP     ",
                  "REWD   ",
                  "PIC    ",
                  "EOD    ",
                  "PNDEF  ",
                  "PNREF  ",
                  "FIGCON ",
                  "SPECREG",
                  "PTDELIM"]; 
          $END
CONTROL EJECT;
  
          PROC  SETTARG;
  
#**       SETTARG -  SET TARGET SEQUENCE WITH TOKEN                    #
#                                                                      #
#     GIVEN-                                                           #
#         TOKEN DESCRIBED BY CLA-VARIABLES.                            #
#         T$ INFORMATION.                                              #
#                                                                      #
#     DOES-                                                            #
#         THROWS AWAY THE FIRST T$ ENTRY.                              #
#         SHIFTS REMAINING T$ ENTRIES DOWN.                            #
#         APPENDS THE FIVEN TOKEN AT THE END.                          #
  
  
          ITEM  C240         C(240);   # SCRATCH                       #
  
          BEGIN 
          IF MAXFPTKNS NQ 1  THEN 
              BEGIN 
         IF T$VLN[1] NQ T$VLN[2] THEN 
             RADDR = 0; 
              W = T$WO[2];             # WORD OFFSET OF OLD 2ND TOKEN  #
              C = T$CO[2];             # CHARACTER OFFSET OF OLD 2ND   #
              T$LSTRING = T$LSTRING - 10*W - C; 
              TL = T$LSTRING; 
              IF TL LQ 230  THEN
                  BEGIN                # WITHIN POWER OF BEAD FUNCTION #
                  C240 = C<C,240>T$STRING[W]; 
                  C<0,TL>T$STRING[0] = C<0,TL>C240; 
                  END 
              ELSE
                  BEGIN 
                  OLDW = W; 
                  NEWW = 0; 
                  FOR I=I WHILE TL GR 0  DO 
                      BEGIN 
                      IF TL LS 230  THEN         # L = MIN(TL, 230)    #
                          L = TL; 
                      ELSE
                          L = 230;
                      C<0,L>T$STRING[NEWW] = C<C,L>T$STRING[OLDW];
                      OLDW = OLDW + 23; 
                      NEWW = NEWW + 23; 
                      TL = TL - L;
                      END 
                  END 
  
              FOR I = 1 STEP 1 UNTIL MAXFPTKNS-1  DO
                  BEGIN 
                  T$WORD0[I] = T$WORD0[I+1];
                  T$WORD1[I] = T$WORD1[I+1];
                  T$WO[I] = T$WO[I+1] - W;
                  J = T$CO[I+1] - C;
                  IF J LS 0  THEN 
                      BEGIN 
                      T$WO[I] = T$WO[I] - 1;
                      J = J + 10; 
                      END 
                  T$CO[I] = J;
                  END 
  
#     INSERT TEXT-WORD DELIMITER                                       #
  
              W = T$LSTRING/10; 
              C = T$LSTRING - 10*W; 
              C<C,1>T$STRING[W] = "?";
              T$LSTRING = T$LSTRING + 1;
  
#     APPEND NEW TOKEN                                                 #
  
          IF NONLIBFPTKNS NQ 0 THEN 
              T$L[MAXFPTKNS] = 0;     #NULL TOKEN   # 
          ELSE
              BEGIN 
              C = C + 1;
              IF C EQ 10  THEN
                  BEGIN 
                  W = W + 1;
                  C = 0;
                  END 
              IF SAREALENGTH LQ 230  THEN 
                  BEGIN 
                  C<C,SAREALENGTH>T$STRING[W] =C<0,SAREALENGTH>SAREA[0];
                  END 
              ELSE
                  BEGIN 
                  C<C,30>T$STRING[W] = C<0,30>SAREA[0]; 
                  C<C,SAREALENGTH-30>T$STRING[W+3]
                                          = C<0,SAREALENGTH-30>SAREA[3];
                  END 
  
          T$LSTRING = T$LSTRING + SAREALENGTH;
          T$L[MAXFPTKNS] = SAREALENGTH; 
          T$WO[MAXFPTKNS] = W;         # WORD OFFSET                   #
          T$CO[MAXFPTKNS] = C;         # CHARACTER OFFSET              #
          T$COLUMN[MAXFPTKNS] = CLACOLUMN;
          T$COMMENT[MAXFPTKNS] = CLACOMMENT;
          T$LCOLUMN[MAXFPTKNS] = CLALCOLUMN;
          T$LINE[MAXFPTKNS] = CLALINE;
          T$LVLN[MAXFPTKNS] = CLALVLN;
          T$MOD[MAXFPTKNS] = CLAMOD;
          T$SIGNSW[MAXFPTKNS] = SIGNSW; 
          T$TYPE[MAXFPTKNS] = CLATYPE;
          T$VALUE[MAXFPTKNS] = CLAVALUE;
          T$VLN[MAXFPTKNS] = CLAVLN;
              END 
  
#     IF DEBUG, LIST NEW TARGET                                        #
  
              $BEGIN
              IF BUG020C$CPY  THEN
                  BEGIN 
                  FOR I = 1 STEP 1 UNTIL MAXFPTKNS  DO
                      BEGIN 
                     LINE = " T$WO[*]=***CO=**L=***TYPE=*******VALUE=***
*** SIGNSW=FALSE LINE=*****COLUMN=***VLN=******LCOLUMN=***LVLN=******MOD
=FALSE";
                      C10 = DEC(I); 
                      C<6,1>LINE = C<0,1>C10; 
                      C10 = DEC(T$WO[I]); 
                      C<9,3>LINE = C<0,3>C10; 
                      C10 = DEC(T$CO[I]); 
                      C<15,2>LINE = C<0,2>C10;
                      C10 = DEC(T$L[I]);
                      C<19,3>LINE = C<0,3>C10;
                      C<27,7>LINE = BUG$TKNTYPE[T$TYPE[I]]; 
                      C<40,6>LINE = OCT(B<42,18>T$VALUE[I], 14, 6); 
                      IF T$SIGNSW[I]  THEN
                          C<54,5>LINE = "TRUE ";
                      C10 = DEC(T$LINE[I]); 
                      C<65,5>LINE = C<0,5>C10;
                      C10 = DEC(T$COLUMN[I]); 
                      C<77,3>LINE = C<0,3>C10;
                      C10 = DEC(T$VLN[I]);
                      C<84,6>LINE = C<0,6>C10;
                      C10 = DEC(T$LCOLUMN[I]);
                      C<98,3>LINE = C<0,3>C10;
                      C10 = DEC(T$LVLN[I]); 
                      C<106,6>LINE = C<0,6>C10; 
                      IF T$MOD[I]  THEN 
                          C<116,5>LINE = "TRUE "; 
                      CBLIST(LISTCTL"LINE", LINE, 121); 
                      END 
                  LINE = C<0,130>T$STRING[0]; 
                  CBLIST(LISTCTL"LINE", LINE, 120); 
                  END 
              $END
  
              END 
          ELSE
              IF OLDVLN NQ CLAVLN THEN
                  RADDR = 0;
              OLDVLN = CLAVLN;
          END 
CONTROL EJECT;
          PROC  CREATELINE; 
#**       CREATELINE - INSERTS NEW LINE FOR REPLACING                 # 
#         GIVEN -                                                     # 
#                 F = INDEX TO CURRENT LINE                           # 
#                                                                     # 
#         RETURNS -                                                   # 
#                 K = INDEX TO NEW LINE                               # 
          BEGIN 
              LN = LN + 1;
          GETPLINDEX(K);
          PL$COMMENT[K] = TRUE; 
          PL$FLAGP[F] = TRUE; 
          PL$FLAGI[K] = FALSE;
          PL$FLAGN[K] = FALSE;
          PL$FLAGP[K] = FALSE;
          PL$FLAGR[K] = FALSE;
          PL$FLAG7[K] = FALSE;
          PL$NOLIST[K] = FALSE; 
          PL$VLN[K] = PL$VLN[F];
          PL$NEXT[K] = PL$NEXT[F];
          PL$NEXT[F] = K; 
          PL$LIB[K] = TRUE; 
          PL$READY[K] = FALSE;
          PL$LINE[K] = PL$LINE[F];
          C<0,72>PL$10CHARS[K] = " ";  # BLANK NEW LINE         # 
          C<72,28>PL$10CHARS [K]
           = C<72,28>PL$10CHARS[F];    # ADD IDENT OF OLD LINE         #
          END 
CONTROL EJECT;
  
#  BEGIN TKNCLASSIFY                                                   #
  
RESTART:  # (HERE FROM PTDELIM)                                        #
  
          $BEGIN
          IF CSTATE LS 1
             OR CSTATE GR 6 THEN
              ABORTSS("TKNCLAS-3"); 
          $END
          GOTO STATE[CSTATE]; 
CONTROL EJECT;
  
#     STATE 1 -  NORMAL PROCESSING                                     #
  
STATE1: 
          IF LIBTKNISPIC  THEN         # IF LIBRARY TOKEN IS PICTURE   #
              BEGIN 
              GETPIC; 
              IF NOT SEENIS AND SAREALENGTH EQ 2
                 AND C<0,2>SAREA[0] EQ "IS" 
              THEN   # IGNORE IS FOLLOWING PIC                         #
                  BEGIN 
                  SEENIS = TRUE;
                  END 
              ELSE
                  BEGIN 
              IF C<0,5> SAREA[0] EQ "COPY " THEN
                  BEGIN 
              IF NOT STCOPY THEN
                  STCOPY = TRUE;
              ELSE
                  BEGIN 
                  SSDIAGS(D1101); 
                  GOTO SKPER; 
                  END 
                  IF CCTFIPSLEVEL LS 2
                  THEN BEGIN
                       # FIPS=2 SUPPORTS THE COPY STATEMENT # 
                       SSDIAGS(D1601);
                       END
                  IF REPLAC$MODE AND RSTATE GR 2 AND RSTATE NQ 6
                  THEN
                      BEGIN 
                      IF RSTATE EQ 4 OR RSTATE GR 5 
                      THEN   #IGNORE COPY WHILE IN THESE REPLACE STATES#
                          BEGIN 
                          GOTO POLISH;
                          END 
                      ELSE
                          BEGIN 
                          IF FSTPTDELIM AND NOT LSTPTDELIM
                          THEN
                              BEGIN   # ILLEGAL COPY WITHIN A PSUDO-TXT#
                              SSDIAGS(D1115); 
                              RSTATE = 7; 
                              GOTO POLISH;
                              END 
                          END 
                      END 
                  SETCOPY;
                  GOTO STATE[CSTATE]; 
                  END 
              LIBTKNISPIC = FALSE;     # NEXT LIB. TOKEN IS NOT PIC    #
              SEENIS = FALSE;   # NEXT TOKEN NOT IS FOLLOWING PIC      #
                  END 
              END 
          ELSE                         # LIBRARY TOKEN IS NOT PIC      #
              BEGIN 
              GETSTR; 
              IF CLATYPE EQ TKNTYPE"AW" 
               AND (C<0,8>SAREA[0] EQ "PICTURE "
                    OR C<0,4>SAREA[0] EQ "PIC ")  THEN
                  LIBTKNISPIC = TRUE;            #   NEXT MUST BE PIC  #
              END 
  
          IF CLATYPE EQ TKNTYPE"AW" 
           AND C<0,5>SAREA[0] EQ "COPY "  THEN
              BEGIN 
              IF NOT STCOPY THEN
                  STCOPY = TRUE;
              ELSE
                  BEGIN 
                  SSDIAGS(D1101); 
                  GOTO SKPER; 
                  END 
              IF CCTFIPSLEVEL LS 2
              THEN BEGIN
                   # FIPS=2 SUPPORTS THE COPY STATEMENT # 
                   SSDIAGS(D1601);
                   END
              IF REPLAC$MODE AND RSTATE GR 2 AND RSTATE NQ 6
              THEN
                  BEGIN 
                  IF RSTATE EQ 4 OR RSTATE GR 5 
                  THEN   # IGNORE COPY WHILE IN THESE REPLACE STATES   #
                      BEGIN 
                      GOTO POLISH;
                      END 
                  ELSE
                      BEGIN 
                      IF FSTPTDELIM AND NOT LSTPTDELIM
                      THEN
                          BEGIN   # ILLEGAL COPY WITHIN A PSEUDO-TEXT  #
                          SSDIAGS(D1115); 
                          RSTATE = 7; 
                          GOTO POLISH;
                          END 
                      END 
                  END 
              SETCOPY;                 # SET COPY INFORMATION          #
#***#         GOTO STATE[CSTATE];      # 1, 2 OR 3                     #
              END 
  
          IF CLACOMMENT  THEN          # IF REALLY COMMENT TOKEN,      #
#***#         GOTO STATE1;             #   IGNORE THIS TOKEN           #
  
#***#     GOTO POLISH;                 # POLISH UP TOKEN AND EXIT      #
 SKPER: 
          GETSTR; 
           IF C<9,1>CLAVALUE NQ "." THEN
              GOTO SKPER; 
           RETURN;
CONTROL EJECT;
  
#     STATE 2 -  READ FROM LIBRARY WITH REPLACING (NO FP PUNCS)        #
  
STATE2: 
  
#     GET NEXT TARGET TOKEN                                            #
  
          IF NONLIBFPTKNS EQ 0 AND CLATYPE NQ TKNTYPE"EOD" THEN 
              BEGIN 
          IF LIBTKNISPIC  THEN
              BEGIN 
              GETPIC; 
              IF SEENIS 
              THEN   # NEXT TOKEN IS NOT A PICTURE                     #
                  BEGIN 
                  LIBTKNISPIC = FALSE;
                  SEENIS = FALSE; 
                  END 
              ELSE   # NEXT TOKEN MAY BE PICTURE                       #
                  BEGIN 
                  IF SAREALENGTH NQ 2 OR  C<0,2>SAREA[0] NQ "IS"
                  THEN   # NEXT TOKEN IS NOT A PICTURE                 #
                      BEGIN 
                      LIBTKNISPIC = FALSE;  # NEXT TOKEN IS NOT PIC    #
                      SEENIS = FALSE;   # NEXT TKN NOT IS FOLLOWING PIC#
                      END 
                  ELSE   # NEXT TOKEN IS A PICTURE                     #
                      BEGIN 
                      SEENIS = TRUE;
                      END 
                  END 
              END 
          ELSE
              BEGIN 
              GETSTR; 
              IF C<0,8>SAREA[0] EQ "PICTURE " 
               OR C<0,4>SAREA[0] EQ "PIC "  THEN
                  LIBTKNISPIC = TRUE; 
              END 
              END 
  
#     SET UP TARGET TOKEN                                              #
#         (AND BE PREPARED FOR UNWINDING TARGET TOKENS)                #
  
          SETTARG;                     # SHIFT TARGET AND APPEND TOKEN #
  
#     IF TOKEN WAS NOT FROM LIBRARY, WIND DOWN COPY...REPLACING        #
  
          IF NOT TKNFROMLIB  THEN 
              BEGIN 
              NONLIBFPTKNS = NONLIBFPTKNS + 1;
              IF NONLIBFPTKNS GQ NTARGETS  THEN 
                  BEGIN 
                  $BEGIN
                  IF BUG020C$CPY  THEN
                      BEGIN 
                      CBLIST(LISTCTL"LINE", 
              "TKNCLAS-  CANNOT MATCH ANY MORE DUE TO END OF TEXT", 50);
                      END 
                  $END
                  CSTATE = 5;          # AT LEAST RETURN SPACE         #
                  IF MAXFPTKNS EQ 1  THEN 
                      BEGIN            # TARGET IS IN CLA-VARIABLES    #
                      TKN = 1;         # FLAG STATE5 TO RELEASE SPACE  #
              GOTO STATE5;
                      END 
                  ELSE
                      BEGIN            # TARGET IS IN T$ ARRAY         #
                      TKN = 0;         # INDEX TO T$ ARRAY             #
#***#                 GOTO STATE5;     # GO FLUSH TARGET STRING        #
                      END 
                  END 
              END 
  
#     IF TOKEN WAS NULL (FROM -SETCOPY- OR -SKIPCLA-),  LOOP           #
  
          IF MAXFPTKNS NQ 1 
          AND T$L[1] EQ 0 THEN         # IF FIRST TOKEN IS NULL # 
#***#         GOTO STATE2;             #   SHIFT AND APPEND AGAIN      #
  
#     COMPARE FORMAL PARAMETER SEQUENCES WITH TARGET SEQUENCE          #
  
          FOR FP = 1 STEP 1 UNTIL NPAIRS DO 
              BEGIN                    # EXAMINE FORMAL PARAM. SEQUENCE#
              FPOFFSET = FP$INDEX[FP]; # FPARRAY OFFSET FOR PAIR FP    #
              W = FP$WO[FPOFFSET+1];   # WORD INDEX TO TOKEN 1 OF PAIR #
              C = FP$CO[FPOFFSET+1];   # CHAR INDEX TO TOKEN 1 OF PAIR #
              IF FP$NTKNS[FP] EQ 1  THEN
                  BEGIN                # FP SEQUENCE HAS ONLY 1 TOKEN  #
                  IF MAXFPTKNS EQ 1  THEN 
                      BEGIN 
                          IF FP$L[FPOFFSET+1] EQ SAREALENGTH
                           AND FP$TYPE[FPOFFSET+1] EQ CLATYPE THEN
                          BEGIN 
                          IF SAREALENGTH LQ 230  THEN 
                              BEGIN 
                              IF C<C,SAREALENGTH>FP$STRING[W] 
                                             EQ C<0,SAREALENGTH>SAREA[0]
                               AND NOT CLAMOD 
                               AND (CLATYPE NQ TKNTYPE"PIC" 
                                    OR FP$MAYBEPIC[FPOFFSET+1])  THEN 
#***#                             GOTO SETAP;    # SET ACTUAL PARAMS   #
                              END 
                          ELSE
                              BEGIN    # CANNOT USE SINGLE BEAD FUNC.  #
                              IF C<C,30>FP$STRING[W] EQ C<0,30>SAREA[0] 
                               AND C<C,SAREALENGTH-30>FP$STRING[W+3]
                                          EQ C<0,SAREALENGTH-30>SAREA[3]
                               AND NOT CLAMOD 
                               AND (CLATYPE NQ TKNTYPE"PIC" 
                                    OR FP$MAYBEPIC[FPOFFSET+1])  THEN 
#***#                             GOTO SETAP;    # SET ACTUAL PARAMS   #
                              END 
                          END 
                      END 
                  ELSE
                      BEGIN            # TARGET IS T$ SEQUENCE         #
                      L = T$L[1]; 
                          IF FP$L[FPOFFSET+1] EQ L
                           AND FP$TYPE[FPOFFSET+1] EQ T$TYPE[1] THEN
                          BEGIN                  # SAME LENGTH         #
                          IF L LQ 230  THEN 
                              BEGIN 
                              IF C<C,L>FP$STRING[W] EQ C<0,L>T$STRING[0]
                               AND NOT T$MOD[1] 
                               AND (T$TYPE[1] NQ TKNTYPE"PIC" 
                                    OR FP$MAYBEPIC[FPOFFSET+1])  THEN 
#***#                             GOTO SETAP;    # SET ACTUAL PARAMS   #
                              END 
                          ELSE
                              BEGIN 
                              IF C<C,30>FP$STRING[W]
                                                   EQ C<0,30>T$STRING[0]
                               AND C<C,L-30>FP$STRING[W+3]
                                               EQ C<0,L-30>T$STRING[W+3]
                               AND NOT T$MOD[1] 
                               AND (T$TYPE[1] NQ TKNTYPE"PIC" 
                                    OR FP$MAYBEPIC[FPOFFSET+1])  THEN 
#***#                             GOTO SETAP;    # SET ACTUAL PARAMS   #
                              END 
                          END 
                      END 
                  END 
              ELSE
                  BEGIN                # MULTI-TOKEN FORMAL PARAMETER  #
                  I = FPOFFSET + FP$NTKNS[FP];   # LAST TOKEN OF PAIR  #
                  L = (10*FP$WO[I] + FP$CO[I] + FP$L[I]) - (10*W + C);
                  IF L LQ T$LSTRING THEN
                      BEGIN            # TARGET MIGHT MATCH THIS FP    #
                      MATCH = TRUE;    # GUESS THAT WE HAVE A MATCH    #
                      FPW = FP$WO[FPOFFSET+1];
                      FPC = FP$CO[FPOFFSET+1];
                      W = 0;
                      FOR L=L WHILE L NQ 0
                       AND MATCH  DO
                          BEGIN 
                          IF L GR 230  THEN 
                              BEGIN    # NOT WITHIN POWER OF BEAD FUNC #
                              IF C<FPC,230>FP$STRING[FPW] 
                               NQ C<0,230>T$STRING[W]  THEN 
                                  MATCH = FALSE;
                              L = L - 230;
                              FPW = FPW + 23;    # INDEX TO FP$STRING  #
                              W = W + 23;        # INDEX TO T$STRING   #
                              END 
                          ELSE
                              BEGIN    # WITHIN POWER OF BEAD FUNCTION #
                              IF C<FPC,L>FP$STRING[FPW] 
                               NQ C<0,L>T$STRING[W]  THEN 
                                  MATCH = FALSE;
                              L = 0;             # COMPARED ALL CHARS. #
                              END 
                          END 
                      FOR I = 1 STEP 1 UNTIL FP$NTKNS[FP]  DO 
                          BEGIN 
                          IF T$TYPE[I] EQ TKNTYPE"PIC"
                          AND NOT FP$MAYBEPIC[FPOFFSET+I]  THEN 
                              MATCH = FALSE;
                          IF T$MOD[I]  THEN 
                              MATCH = FALSE;     # DIAG MODIFIED TOKEN #
                          END 
                      IF MATCH  THEN
#***#                     GOTO SETAP;            # SET UP ACTUAL PARAMS#
                      END 
                  END 
              END            # THIS SEQUENCE DOES NOT MATCH            #
  
#     NO FORMAL PARAMETER SEQUENCE MATCHES TARGET SEQUENCE             #
  
          IF MAXFPTKNS NQ 1  THEN 
              BEGIN                    # MUST SET CLA-VARIABLES        #
              SAREALENGTH = T$L[1]; 
  
              FOR I = 0 STEP 1 UNTIL 25 DO
                  C<0,10>SAREA[I] = " ";
              IF SAREALENGTH LQ 230  THEN 
                  C<0,SAREALENGTH>SAREA[0] =C<0,SAREALENGTH>T$STRING[0];
              ELSE
                  BEGIN 
                  C<0,30>SAREA[0] = C<0,30>T$STRING[0]; 
                  C<0,SAREALENGTH-30>SAREA[3] 
                                       = C<0,SAREALENGTH-30>T$STRING[3];
                  END 
              CLATYPE = T$TYPE[1];
              CLAVALUE = T$VALUE[1];
              CLACOLUMN = T$COLUMN[1] + RADDR;   #ADJUST COLS FOR#
              CLALCOLUMN = T$LCOLUMN[1] + RADDR; # REPLACE SHIFT #
              CLALINE = T$LINE[1];
              CLAVLN = T$VLN[1];
              CLALVLN = T$LVLN[1];
              SIGNSW = T$SIGNSW[1]; 
              FLAG = T$COMMENT[1];
              END 
          ELSE
              FLAG = CLACOMMENT;
              CLACOLUMN = CLACOLUMN + RADDR;
              CLALCOLUMN = CLALCOLUMN + RADDR;
          IF FLAG  THEN          # IF REALLY COMMENT FROM LIB    #
#***#         GOTO STATE2;             #   IGNORE THIS TOKEN           #
          GOTO POLISH;                 # POLISH UP TOKEN AND EXIT      #
CONTROL EJECT;
  
#     A FORMAL PARAMETER SEQUENCE MATCHED THE TARGET SEQUENCE, SO      #
#     SET UP ACTUAL PARAMETERS FOR OUTPUT                              #
  
SETAP:  
          $BEGIN
          IF BUG020C$CPY  THEN
              BEGIN 
              LINE = "TKNCLAS- MATCH FOUND WITH FP=99"; 
              C10 = DEC(FP);
              C<29,2>LINE = C<0,2>C10;
              CBLIST(LISTCTL"LINE", LINE, 31);
              END 
          $END
  
#     NOTE THE FIRST AND LAST CHARACTERS OF THE MATCHED TARGET STRING  #
  
          APOFFSET = AP$INDEX[FP];
          IF MAXFPTKNS EQ 1  THEN 
              BEGIN 
              TCOLUMN = CLACOLUMN;
              TLCOLUMN = CLALCOLUMN;
              TVLN = CLAVLN;
              TLVLN = CLALVLN;
              END 
          ELSE
              BEGIN 
              TCOLUMN = T$COLUMN[1];
              TLCOLUMN = T$LCOLUMN[FP$NTKNS[FP]]; 
              TVLN = T$VLN[1];
              TLVLN = T$LVLN[FP$NTKNS[FP]]; 
              END 
  
#     FIND THE LINE WITH THE FIRST CHARACTER                           #
  
          FOR F = PLI$FIRST WHILE PL$VLN[F] NQ TVLN  DO 
              F = PL$NEXT[F]; 
               FOR I = I WHILE PL$FLAGP[F] DO 
                   F = PL$NEXT[F];
  
#     DIAGNOSE COMMA OR SEMICOLON USED TO ATTEMPT CONCATENATION        #
  
          IF ( FP$L[FPOFFSET+1] EQ 1 AND (C<C,1>FP$STRING[W] EQ "," OR
                          C<C,1>FP$STRING[W] EQ ";")) 
               AND (C<TCOLUMN-RADDR-2,1>PL$10CHARS[F] NQ " " AND
                      TCOLUMN GR 8) 
          THEN
              INTERCEPTOR (0,PL$LINE[F],D1140,0); 
  
#     BLANK OUT THE FORMAL PARAMETER                                   #
  
          PL$FLAGR[F] = TRUE;          # FIRST LINE HAS REPLACEMENT    #
          IF TVLN EQ TLVLN  THEN       # IF FP WAS ON JUST ONE LINE    #
              BEGIN 
              I = TLCOLUMN - TCOLUMN + 1;        # LENGTH OF FP        #
              C<TCOLUMN+RADDR-1,I>PL$10CHARS[F] = " ";
              END 
          ELSE
              BEGIN 
              C<TCOLUMN+RADDR-1,73+RADDR-TCOLUMN>PL$10CHARS[F] = " "; 
              FOR L = PL$NEXT[F] WHILE PL$VLN[L] NQ TLVLN  DO 
                  BEGIN                # DELETE EACH LINE              #
PL$NEXT[F] = PL$NEXT[L];
                  I = L;               # INDEX OF LINE TO RELEASE      #
                  L = PL$NEXT[L];      # ADVANCE TO THE NEXT LINE      #
                  RELPLINDEX(I);       # RELEASE THE PRINT LINE        #
                  END 
              IF C<6,1>PL$10CHARS[L] NQ " "  THEN 
                  PL$FLAG7[L] = TRUE; 
              C<6,TLCOLUMN-6>PL$10CHARS[L] = " "; 
              PL$FLAGR[L] = TRUE; 
              END 
#     DETERMINE THE LENGTH OF THE ACTUAL PARAMETERS                    #
  
          I = TCOLUMN - 1 + RADDR;     # BEGINNING OF REPLACE          #
          IF TVLN NQ TLVLN THEN 
              L = 72 - (TCOLUMN + RADDR); 
          ELSE                        # L = AVAILABLE SPACE FOR REPLACE#
              L = TLCOLUMN - TCOLUMN + 1; # FOR FIRST LINE          # 
          FOR TKN = 1 STEP 1 UNTIL AP$NTKNS[FP]  DO 
              BEGIN 
              APL = AP$L[APOFFSET+TKN];# SIZE - ACTUAL RARAMETER       #
          IF AP$TYPE[APOFFSET+TKN] EQ TKNTYPE"QLIT" THEN
               APL = APL + 2;        # ADD 2 FOR QUOTES              #
                  IF L LQ 0 AND C<I-1,1>PL$10CHARS[F] NQ " " THEN 
                     BEGIN
                     I= I - 1;
                     PUNCNXT = TRUE;  #FLAG - PUNC FOLLOWS REPLACE #
                    END 
#     IF THIS ACTUAL PARAMETER HAS BEEN DESIGNATED TO BEGIN IN A       #
#      SPECIFIC COLUMN, ADJUSTMENT MUST BE MADE TO ALLOW FOR IT       # 
              IF AP$IFCOL[APOFFSET+TKN] THEN
                  BEGIN 
MJ01: 
                  IF AP$TYPE[APOFFSET+TKN] EQ TKNTYPE"PUNC" THEN
                      BEGIN 
                      IF L EQ 0 THEN
                          BEGIN 
                          C<I-1,72-I>PL$10CHARS[F] =
                              C<I,72-I>PL$10CHARS[F]; 
                          RADDR = RADDR - 1;
                          END 
                       ELSE 
                          L = L + 1;
                      I = I-1;    #PUNC DOESNT REQUIRE PRECEEDING SPACE#
                       END
#     IF THE SPECIFIC COLUMN IS GREATER THAN THE CURRENT COLUMN AND    #
#      THERE IS SUFFICIENT ROOM ON CURRENT LINE, THE COLUMN POINTER(I) #
#      NEED ONLY TO BE ADJUSTED                                        #
                  PUNCNXT = FALSE;
                  IF I LQ (AP$COL[APOFFSET+TKN]-1) THEN 
                      BEGIN 
                      J = AP$COL[APOFFSET+TKN] - (I+1); 
                      L = L - J;
                               # L REDUCED BY COL DIFFERENCE           #
                      IF L GQ 1 OR J EQ 0 THEN #THERE IS ROOM#
                          I = AP$COL[APOFFSET+TKN] - 1; 
                     ELSE 
#     THERE IS NOT ENOUGH ROOM AVAILABLE, SO DATA FOLLOWING REPLACE   # 
#      MUST BE SHIFTED TO MAKE ROOM                                   # 
                          BEGIN 
                          FOR M = 71 WHILE C<M,1>PL$10CHARS[F]
                           EQ " " AND M NQ I DO M = M-1;
#     M = LIST NON-BLANK COLUMN THIS LINE, IF 72-M (AMOUNT THIS LINE   #
#      CAN BE SHIFTED) IS GQ J(AMOUNT OF SHIFT NEEDED) ALL IS WELL     #
#      OTHERWISE A NEW CARD MUST BE CREATED                            #
                          IF 71-M GQ J THEN 
                              BEGIN 
                                  K = TLCOLUMN + RADDR; #DAT AFT ITM# 
                                  I = (M-K) + 1;#SZ OF DATA AFT REPLACE#
                                  C<0,72>TEMPLINE = " ";
                                  C<K+J,I>TEMPLINE
                                   = C<K,I>PL$10CHARS[F]; 
                                        # SHIFT DATA FOLLOWING REPLACE #
                                        # TO TEMPLINE AND BACK         #
                                  C<K,72-K>PL$10CHARS[F]
                                   = C<K,72-K>TEMPLINE; 
                              I = AP$COL[APOFFSET+TKN]-1;#NEW POINTER#
                              RADDR = RADDR + J; #INCREMENT RADDR      #
                              L = 0;
                              END 
                          ELSE
#     A NEW LINE IS NEEDED - THE ACTUAL PARAMETER MAY BEGIN ON THIS    #
#      LINE BUT THE DATA FOLLOWING THE REPLACE WILL BE ON A NEW LINE   #
                              BEGIN 
                              CREATELINE; 
                              IF I NQ M THEN
                                  BEGIN 
                                  J = TLCOLUMN+RADDR;#PTR FOLLOWING DAT#
                                  C<TLCOLUMN,72-J>PL$10CHARS[K] 
                                   = C<J,72-J>PL$10CHARS[F];
                                        # MOVE FOLLOWING DATA TO NEW LN#
                                  END 
                              I = AP$COL[APOFFSET+TKN] - 1; 
                              TLVLN = TVLN+1; 
                              L = 72 - I; # NEW AMOUNT AVAILABLE       #
                              END 
                          END 
                      END 
                  ELSE
                      BEGIN 
#     I IS GREATER THAN AP$COL SO PARAMETER MUST BEGIN ON NEXT LINE    #
                      IF TVLN NQ TLVLN THEN # THERE MAY BE ROOM ON     #
                          BEGIN             #  NEXT CARD               #
                          F = PL$NEXT[F]; 
                          L = TLCOLUMN - 12;# AVAILABLE SPACE          #
                          RADDR = 0;
                          TCOLUMN = 12; 
                          I = 11;           # NEW POINTER              #
                          TVLN = TLVLN; 
                          GOTO MJ01;
                          END 
                      ELSE
                          BEGIN     # NEW CARD MUST BE CREATED# 
                          CREATELINE; 
                          J = I;     #PTR FOLLOWING DATA     #
                          I = AP$COL[APOFFSET+TKN] - 1; #SET NEW I #
                          IF C<J,72-J>PL$10CHARS[F] NQ " " THEN 
                              BEGIN 
                              IF TLCOLUMN GQ AP$COL[APOFFSET+TKN] THEN
                                  BEGIN  # I IS OK ON NEXT LINE#
                                  C<TLCOLUMN,72-J>PL$10CHARS[K] 
                                   = C<J,72-J>PL$10CHARS[F];
                                            # MOVE FOLLOWING DATA TO   #
                                            # NEW LINE                 #
                                  C<J,72-J>PL$10CHARS[F] = " "; 
                                  L = TLCOLUMN-I;# AVAIL ON NEW LINE# 
                                  RADDR = 0;
                                  END 
                              ELSE
                                  BEGIN 
                                  C<I,72-J>PL$10CHARS[K]
                                   = C<J,72-J>PL$10CHARS[F];
                                     #MOVE DATA FOLLOWING COPY TO NEW#
                                     # LINE SHIFTED TO AP$COL # 
                                  C<J,72-J>PL$10CHARS[F] = " "; 
                                  RADDR = I - TLCOLUMN; 
                                   L = 0; 
                                 END
                             END
                         ELSE 
                             BEGIN
                             L = 72 - I; #AMT ON NEW LINE # 
                             RADDR = 0; 
                             END
                         F = K; 
                          END 
                      END 
                  END 
#     NOW WE ARE READY TO MOVE THE ACTUAL PARAMETER TO THE LINE       # 
              AP$COL[APOFFSET+TKN] = I + 1; 
              AP$LINE[APOFFSET+TKN] = PL$LINE[F]; 
              APW = AP$WO[APOFFSET+TKN];
              APC = AP$CO[APOFFSET+TKN];
#     IF ACTUAL PARAMETER WILL FIT, IT CAN BE MOVE WITHOUT SHIFTING    #
MJ02: 
              IF L GQ APL THEN              # NO SHIFTING NEEDED   #
                  BEGIN 
                  IF L EQ APL THEN
                       L = 0; 
                  ELSE
                  L = L - (APL+1);
                  IF AP$TYPE[APOFFSET+TKN] EQ TKNTYPE"QLIT" THEN
                      BEGIN 
                      APL = APL - 2;
                      C<I,1>PL$10CHARS[F] = QUOTE;
                      I = I+1;
                      END 
                  C<I,APL>PL$10CHARS[F]   # MOVE ACTUAL PARAMETER      #
                   = C<APC,APL>AP$STRING[APW]; # TO LINE               #
                  I = I + APL + 1;
                  IF AP$TYPE[APOFFSET+TKN] EQ TKNTYPE"QLIT" THEN
                      BEGIN 
                      C<I-1,1>PL$10CHARS[F] = QUOTE;
                      I = I+1;
                      END 
                  END 
              ELSE
#     ACTUAL PARAMETER WILL NOT FIT, DATA FOLLOWING REPLACE MUST BE    #
#      SHIFTED TO FIT OR A NEW CARD CREATED # 
                     IF TVLN NQ TLVLN THEN
#     ANOTHER CARD FOLLOWS THIS, PUT AS MUCH OF ACTUAL PARAMETER AS    #
#      POSSIBLE ON OLD CARD, THEN SHIFT TO NEXT LINE AND ANALYZE IT    #
                         BEGIN
                         IF AP$TYPE[APOFFSET+TKN] EQ TKNTYPE"QLIT" THEN 
                             BEGIN
                             C<I,1>PL$10CHARS[F] = QUOTE; 
                             I = I+1; 
                             L = L-1; 
                             END
                         IF L GR 0 THEN# WILL ANY PART FIT ON THIS LINE#
                             BEGIN      # MOVE AS MUCH AS POSSIBLE TO  #
                             C<I,L>PL$10CHARS[F] # OLD LINE            #
                              = C<APC,L>AP$STRING[APW]; 
                             APL = APL-L;  # NEW SIZE FOR PARAMETER # 
                             APC = APC+L;  # NEW LOC FOR PARAMETER  # 
                             END
                         F = PL$NEXT[F];   # SHIFT TO NEXT CARD        #
                         C<6,1>PL$10CHARS[F] = "-"; 
                         PL$FLAG7[F] = TRUE;
                         I = 11;     # START COL 12 # 
                         RADDR = 0; 
                         L = TLCOLUMN - 12;#AVAILABLE ON NEW LINE # 
                         TVLN = TLVLN;
                         GOTO MJ02; 
                         END
                     ELSE 
#     SEE IF DATA FOLLOWING REPLACE CAN BE SHIFTED ON THIS CARD TO    # 
#      ALLOW FOR ACTUAL PARAMETER                                     # 
                         BEGIN
                         K = TLCOLUMN + RADDR - 1; # PTR TO DAT FOLLOW #
                         J = (APL + 1) - L; 
                         FOR M=71 WHILE C<M,1>PL$10CHARS[F] 
                          EQ " " AND I NQ M DO M = M-1; 
                         IF 71-M GQ J THEN #ROOM FOR SHIFT ON THIS LINE#
                             BEGIN
                             K = I;    # PTR TO DATA AFTER TOKEN       #
                             M = (M-K) + 1;#AMT DAT FOLLOWING TKN     # 
                             C<0,72>TEMPLINE = " "; 
#     SHIFT DATA FOLLOWING REPLACE TO TEMPLINE AND BACK AGAIN          #
                             C<K+J,M>TEMPLINE 
                              = C<K,M>PL$10CHARS[F];
                             C<K,72-K>PL$10CHARS[F] 
                              = C<K,72-K>TEMPLINE;
                             IF PUNCNXT THEN
                                 BEGIN
                                 I = I + 1;#RESTORE I                #
                                 PUNCNXT = FALSE; 
                                 END
#     INSERT ACTUAL PARAMETER INTO LINE                                #
                             IF AP$TYPE[APOFFSET+TKN] EQ TKNTYPE"QLIT"
                              THEN
                                 BEGIN
                                 C<I,1>PL$10CHARS[F] = QUOTE; 
                                 I = I+1; 
                                 APL = APL-2; 
                                 END
                           C<I,APL>PL$10CHARS[F]
                              = C<APC,APL>AP$STRING[APW]; 
                             I = APL + I + 1; 
                            L = 0;
                             IF AP$TYPE[APOFFSET+TKN] EQ TKNTYPE"QLIT"
                              THEN
                                 BEGIN
                                 C<I-1,1>PL$10CHARS[F] = QUOTE; 
                                 I = I+1; 
                                 END
                             RADDR = RADDR + J; 
                             END
                         ELSE 
#     SHIFT ON SAME LINE WONT WORK - NEW LINE MUST BE CREATED          #
                             BEGIN
                         IF PUNCNXT THEN
                             BEGIN
                             I = I + 1; #RESTORE I# 
                             PUNCNXT = FALSE; #RESTORE PUNCNXT# 
                             END
                             J = TLCOLUMN + RADDR;#PTR TO DATA AFTR TKN#
                             CREATELINE;
                               IF M NQ (J-1) THEN 
                                 BEGIN
                                 C<TLCOLUMN,72-J>PL$10CHARS[K]
                                  = C<J,72-J>PL$10CHARS[F]; 
                                      # MOVE DATA FOLLOWING REPLACE # 
                                       # TO NEW LINE                 #
                                 C<J,72-J>PL$10CHARS[F] = " ";
                                 END
                             L = L + (72-J);#AMT NOW AVAIL ON OLD LINE# 
                             IF L GQ APL THEN 
                                 BEGIN  # ENTIRE TKN WILL FIT NOW#
                                 IF AP$TYPE[APOFFSET+TKN] EQ
                                  TKNTYPE"QLIT" THEN
                                     BEGIN
                                     C<I,1>PL$10CHARS[F] = QUOTE; 
                                     APL = APL - 2; 
                                     I = I + 1; 
                                     END
                                 C<I,APL>PL$10CHARS[F]     #MOVE TKN   #
                                  = C<APC,APL>AP$STRING[APW]; 
                                 I = I + APL + 1; 
                                 IF AP$TYPE[APOFFSET+TKN] EQ
                                  TKNTYPE"QLIT" THEN
                                     BEGIN
                                     C<I-1,1>PL$10CHARS[F] = QUOTE; 
                                     I = I+1; 
                                 END
                                 I = 11; # PTR FOR NEW LINE = COL 12 #
                                 RADDR = 0; 
                                 F = K; 
                                 L = TLCOLUMN - 12; 
                                 END
                             ELSE      # ONLY PART OF TKN WILL FIT ON  #
                                 BEGIN #  OLD LINE               #
                                 IF AP$TYPE[APOFFSET+TKN] EQ
                                  TKNTYPE"QLIT" THEN
                                     BEGIN
                                     C<I>PL$10CHARS[F] = QUOTE; 
                                     I = I+1; 
                                     L = L-1; 
                                     END
                                  APL = APL - L; #AMT TO GO ON NEW LINE#
                                  C<I,L>PL$10CHARS[F] 
                                    = C<APC,L>AP$STRING[APW]; 
                                      # MOVE AS MUCH OF ACTUAL PARAM# 
                                      #  AS POSSIBLE TO OLD LINE    # 
                                  C<6,1>PL$10CHARS[K]="-";   # COL 7   #
                                  PL$FLAG7[K] = TRUE; 
                                  APC = APC+L;  #NEW PTR - ACT PARAM #
                                  I = 11; 
                                  RADDR = 0;
                                  F = K;
                                  L = TLCOLUMN - 12;
                                  GOTO MJ02;
                                  END 
                              END 
                          END 
                      END 
  
#     PREPARE TARGET STRING FOR NEXT MATCH                             #
  
          FOR TKN = 1 STEP 1 WHILE TKN LQ FP$NTKNS[FP]-1
           AND TKNFROMLIB  DO 
              BEGIN 
              IF LIBTKNISPIC  THEN
                  BEGIN 
                  GETPIC; 
                  IF NOT SEENIS AND SAREALENGTH EQ 2
                     AND C<0,2>SAREALENGTH EQ "IS"
                  THEN   # RETRIEVE PICTURE STRING                     #
                      BEGIN 
                      SEENIS = TRUE;
                      END 
                  ELSE
                      BEGIN 
                      LIBTKNISPIC = FALSE;
                      SEENIS = FALSE; 
                      END 
                  END 
              ELSE
                  BEGIN 
                  GETSTR; 
                  IF CLATYPE EQ TKNTYPE"AW" 
                   AND (C<0,8>SAREA[0] EQ "PICTURE "
                        OR C<0,4>SAREA[0] EQ "PIC ")  THEN
                      LIBTKNISPIC = TRUE; 
                  END 
              SETTARG;                 # SET TARGET SEQUENCE WITH TOKEN#
              IF NOT TKNFROMLIB THEN
                  NONLIBFPTKNS = NONLIBFPTKNS + 1;
              END 
  
          IF NOT TKNFROMLIB  THEN 
              BEGIN                    # PROPERLY WIND DOWN TARGET SEQ #
              SAREALENGTH = 0;         # APPEND NULL TOKENS TO TARGET  #
              FOR TKN = TKN STEP 1 UNTIL FP$NTKNS[FP]-1 DO
                  BEGIN 
                  SETTARG;             # DELETE LEADING TARGET TOKEN   #
                  NONLIBFPTKNS = NONLIBFPTKNS + 1;
                  END 
              END 
  
#     GO WRITE ACTUAL PARAMETERS                                       #
  
          TKN = 0;
          TKNLIM = AP$NTKNS[FP];
          CSTATE = 4;                  # 4 = WRITE ACTUAL PARAMETERS   #
          GOTO STATE4;
CONTROL EJECT;
  
#     STATE 3 -  READ FROM LIBRARY WITH REPLACING (HAVE FP PUNCS)      #
  
STATE3: 
CONTROL EJECT;
  
#     STATE 4 -  WRITE ACTUAL PARAMETERS                               #
  
STATE4: 
          TKN = TKN + 1;               # INCREMENT INDEX TO TOKENS     #
          IF TKN GR TKNLIM  THEN
              BEGIN                    # ALL ACTUAL PARAMS ARE DONE    #
              IF NFPPUNCS EQ 0  THEN
                  CSTATE = 2;          # REPLACING WITHOUT FP PUNCS    #
              ELSE
                  CSTATE = 3;          # REPLACING WITH FP PUNCS       #
#***#         GOTO STATE[CSTATE];      # RESUME REPLACING              #
              END 
  
          SAREALENGTH = AP$L[APOFFSET+TKN]; 
  
          FOR I = 0 STEP 1 UNTIL 25  DO 
              C<0,10>SAREA[I] = " ";
          APC = AP$CO[APOFFSET+TKN];
          APW = AP$WO[APOFFSET+TKN];
          IF SAREALENGTH LQ 230  THEN 
              BEGIN                    # WITHIN POWER OF BEAD FUNCTION #
              C<0,SAREALENGTH>SAREA[0]=C<APC,SAREALENGTH>AP$STRING[APW];
              END 
          ELSE
              BEGIN                    # CANNOT USE JUST ONE BEAD FUNC #
              C<0,30>SAREA[0] = C<APC,30>AP$STRING[APW];
              C<0,SAREALENGTH-30>SAREA[3] 
                                  = C<APC,SAREALENGTH-30>AP$STRING[W+3];
              END 
  
          CLATYPE = AP$TYPE[APOFFSET+TKN];
          CLAVALUE = AP$VALUE[APOFFSET+TKN];
          CLALINE = AP$LINE[APOFFSET+TKN];
          CLACOLUMN = AP$COL[APOFFSET+TKN]; 
          CLAVLN = 0;        # ENSURE THIS TOKEN DOES NOT AFFECT PRT L #
          SIGNSW = AP$SIGNSW[APOFFSET+TKN]; 
  
  
#***#     GOTO POLISH;                 # GO POLISH UP TOKEN AND RETURN #
CONTROL EJECT;
  
#     STATE 5 -  FLUSH TARGET STRING                                   #
  
STATE5: 
          TKN = TKN + 1;
          IF TKN EQ 1 THEN
              BEGIN 
              SAREALENGTH = T$L[1]; 
              FOR I = 0 STEP 1 UNTIL 25 DO
                  C<0,10>SAREA[I] = " ";
              W = T$WO[1];
              C = T$CO[1];
              IF SAREALENGTH LQ 230 THEN
                 C<0,SAREALENGTH>SAREA[0] = C<C,SAREALENGTH>T$STRING[W];
              ELSE
                 BEGIN
                 C<0,30>SAREA[0] = C<C,30>T$STRING[W];
                 C<0,SAREALENGTH-30>SAREA[3]
                     = C<C+30,SAREALENGTH-30>T$STRING[W]; 
                 END
              CLATYPE = T$TYPE[1];
              CLAVALUE = T$VALUE[1];
              CLACOLUMN = T$COLUMN[1];
               CLALCOLUMN = T$LCOLUMN[1]; 
          CLALINE = T$LINE[1];
               CLAVLN = T$VLN[1]; 
               CLALVLN = T$LVLN[1]; 
               SIGNSW = T$SIGNSW[1];
               CLAMOD = T$MOD[1]; 
               END
          IF REPLACING THEN 
               BEGIN
              CMM$FGR(GROUP$REPL);
              $BEGIN
              P<APNTKNS> = 0; 
              P<APARRAY> = 0; 
              P<APSTRING> = 0;
              P<FPNTKNS> = 0; 
              P<FPARRAY> = 0; 
              P<FPSTRING> = 0;
              P<TARRAY> = 0;
              $END
              P<TSTRING> = 0; 
              REPLACING = FALSE;
              END 
          CSTATE = 1; 
          NONLIBFPTKNS = 0; 
          IF CLATYPE EQ TKNTYPE"AW" 
              AND C<0,5>SAREA[0] EQ "COPY " THEN
             BEGIN
             SETCOPY; 
             GOTO STATE[CSTATE];
             END
#***#     GOTO POLISH;                 # POLISH UP TOKEN AND EXIT      #
CONTROL EJECT;
  
#     STATE 6 - WINDING DOWN REPLACE PROCESSING                        #
  
STATE6: 
  
          REPLACE;
          IF NOT TKNREADY 
          THEN
              GOTO STATE[CSTATE]; 
          GOTO POLISH1; 
CONTROL EJECT;
          $BEGIN
  
DEBUG:  
          IF NOT BUG020C$TKN  THEN
#***#         RETURN; 
          LINE =
        "TOKEN= *******  777777     99999+99 TO 99999+99 99999   999=(";
  
          IF CLATYPE LQ 0  THEN 
              BEGIN 
              C<7,1>LINE = "-"; 
              C10 = DEC(-CLATYPE);
              C<8,5>LINE = C<0,5>C10; 
              END 
          ELSE
          IF CLATYPE GR TKNTYPE"PTDELIM"  THEN
              BEGIN 
              C10 = DEC(CLATYPE); 
              C<7,6>LINE = C<0,6>C10; 
              END 
          ELSE
              C<7,7>LINE = BUG$TKNTYPE[CLATYPE];
  
          C<16,6>LINE = OCT(B<42,18>CLAVALUE, 14, 6); 
  
          IF SIGNSW  THEN 
              C<23,1>LINE = "S";
  
          IF CLAMOD  THEN 
              C<25,1>LINE = "M";
  
          C10 = DEC(CLAVLN);
          C<27,5>LINE = C<0,5>C10;
          C10 = DEC(100+CLACOLUMN); 
          C<33,2>LINE = C<1,2>C10;
  
          IF READLIB  THEN
              BEGIN 
              C10 = DEC(CLAVLN);
              C<39,5>LINE = C<0,5>C10;
              C10 = DEC(100+CLALCOLUMN);
              C<45,2>LINE = C<1,2>C10;
              END 
          ELSE
              C<36,11>LINE = "           "; 
  
          C10 = DEC(CLALINE); 
          C<48,5>LINE = C<0,5>C10;
  
          C10 = DEC(SAREALENGTH); 
          C<56,3>LINE = C<0,3>C10;
  
          IF SAREALENGTH LQ 70  THEN
              BEGIN 
              C<61,SAREALENGTH>LINE = C<0,SAREALENGTH>SAREA[0]; 
              C<61+SAREALENGTH,1>LINE = ")";
              END 
          ELSE
              BEGIN 
              C<61,53>LINE = C<0,53>SAREA[0]; 
              C<114,5>LINE = ")...("; 
              C<119,12>LINE = C<SAREALENGTH-41,12>SAREA[3]; 
              C<131,1>LINE = ")"; 
              END 
  
          CBLIST(LISTCTL"LINE", LINE, 132); 
          RETURN;                      # EXIT FROM TKNCLASSIFIER       #
  
          $END
CONTROL EJECT;
  
#       PERFORM FURTHER CHECKS AND PERHAPS ALTER CLATYPE.              #
  
POLISH:                                # POLISH UP TOKEN AND EXIT      #
  
#      FIRST CHECK FOR REPLACE STATEMENT OR REPLACE PROCESSING         #
  
          IF CLATYPE EQ TKNTYPE"AW" 
          AND C<0,8>SAREA[0] EQ "REPLACE "
          AND  CCTANSIDIAG EQ 0 
          THEN
              BEGIN # REPLACE STATEMENT SEEN #
              IF REPLAC$MODE
              THEN
                  BEGIN 
                  IF RSTATE EQ 2       # INITIALIZE$ RSTATE 2          #
                  THEN                 # 2 REPLACE STMTS IN A ROW W/NO #
                      BEGIN            # SEPERATOR PERIOD BETWEEN THEM #
                      SSDIAGS(D1100); 
                      GOTO BADREPL; 
                      END 
                  IF RSTATE EQ 3       # PSDO$TXT$1 RSTATE 3           #
                  THEN                 # RW REPLACE ENCOUNTERED WHILE  #
                      BEGIN            # PROCESSING PSEUDO-TXT-1       #
                      SSDIAGS(D1103); 
                      GOTO BADREPL; 
                      END 
                  IF RSTATE EQ 4       # RSVDWRD$BY$ RSTATE 4          #
                  THEN                 # RW BY EXPECTED AT THIS PNT IN #
                      BEGIN            # REPLACE STMT RW REPLACE FOUND #
                      SSDIAGS(D1106); 
                      GOTO BADREPL; 
                      END 
                  IF RSTATE EQ 5       # PSDO$TXT$2 RSTATE 5           #
                  THEN                 # RW REPLACE ENCOUNTERED WHILE  #
                      BEGIN            # PROCESSING PSEUDO-TEXT-2      #
                      SSDIAGS(D1109); 
                      GOTO BADREPL; 
                      END 
                  IF RSTATE EQ 7       # ERROR$ RSTATE 7               #
                  THEN                 # REPLACE FOUND WHILE SKIPPING  #
                      BEGIN            # TO PERIOD OF AN ILLG. REPLACE #
                      GOTO BADREPL;                           # STMT   #
                      END 
                  IF REPLALLOWED OR LSTTKNP 
                  THEN                 # LEGAL REPLACE STMT GO WIND    #
                      BEGIN            # DOWN PREVIOUS REPLACE STMT    #
                      SVCURCSTATE = CSTATE; 
                      CSTATE = 6; 
                      EODREPL = TRUE; 
                      GOTO STATE[CSTATE]; 
                      END 
                  ELSE                 # REPLACE STMT NOT PRECEEDED BY #
                      BEGIN            # SEPERATOR PERIOD              #
                      SSDIAGS(D1112); 
                      END 
BADREPL:  
              RSTATE = 7;          # ERROR$ RSTATE 7                   #
              END 
  
              ELSE # NOT REPLAC$MODE AND A LEGAL REPLACE STMT FND      #
                  BEGIN 
                  IF REPLALLOWED
                  THEN
                      BEGIN 
                      REPLAC$MODE = TRUE; 
                      RSTATE = 2;      # INITIALIZE$ RSTATE 2          #
                      GOTO STATE[CSTATE]; 
                      END 
                  ELSE
                      BEGIN 
                      SSDIAGS(D1112); 
                      REPLAC$MODE = TRUE; 
                      RSTATE = 7;   # ERROR$ RSTATE 7                  #
                      TKNREADY = FALSE; 
                      END 
                  END 
              END   # REPLACE STATEMENT SEEN                           #
  
          IF REPLAC$MODE
          THEN
              BEGIN 
              REPLACE;
              IF NOT TKNREADY 
              THEN     # NO TOKEN FOR POLISH DUE TO REPLACE PROCESSING #
                  BEGIN 
                  GOTO STATE[CSTATE]; 
                  END 
              END 
  
POLISH1:                               # GO POLISH UP TOKEN AND EXIT #
  
          IF CLAVLN GR PL$VLN[PLI$NOTREADY] 
          AND CLAVLN NQ 0 THEN
              BEGIN                    # A PRINT LINE IS READY         #
              PL$READY[PLI$NOTREADY] = TRUE;
              # THE BELOW LOOP COULD ONLY BE INFINITE IF               #
              # PL$READY[PLI$LAST] WERE TRUE.  BUT THIS IS POSSIBLE    #
              # ONLY AT END-OF-DATA, AND THEN -GETSTR- SETS CLAVLN ZERO#
              # SO THIS PATH IS NOT TAKEN.                             #
              FOR I=I WHILE PL$READY[PLI$NOTREADY]  DO
                  PLI$NOTREADY = PL$NEXT[PLI$NOTREADY]; 
              END 
  
          FIRSTNOTPIC = TRUE; 
  
          $BEGIN
          IF CLATYPE LQ 0 
            OR  CLATYPE GR TKNTYPE"BLIT"  THEN
              ABORTSS("TKNCLAS-4"); 
          $END
          REPLALLOWED = FALSE;
  
          GOTO TKNSWITCH[CLATYPE];
  
  
  
  
AW:                          # AW, RW, FIGCON, SPECREG, PNREF OR PNDEF #
          CHKRW;                       # MAYBE SET CLATYPE             #
          $BEGIN
          GOTO DEBUG; 
          $END
          RETURN; 
  
 BLIT:  
          $BEGIN
          GOTO DEBUG; 
          $END
          RETURN; 
  
EOD:                         # END-OF-DATA                             #
          IF REPLACING THEN 
              BEGIN 
              CMM$FGR(GROUP$REPL);
              $BEGIN
              P<APNTKNS> = 0; 
              P<APARRAY> = 0; 
              P<APSTRING> = 0;
              P<FPNTKNS> = 0; 
              P<FPARRAY> = 0; 
              P<FPSTRING> = 0;
              P<TARRAY> = 0;
              $END
              P<TSTRING> = 0; 
              REPLACING = FALSE;
              END 
          $BEGIN
          GOTO DEBUG; 
          $END
          RETURN; 
  
FIGCON:                      # FIGURATIVE CONSTNAT                     #
          $BEGIN                       # *** ILLEGAL HERE ***          #
          GOTO DEBUG;                  # *** SET BY CHKRW ***          #
          $END
  
FLIT:                        # FLOATING-POINT LITERAL                  #
  
#      VERIFY THAT FLOATING POINT LITERAL IS IN RANGE                  #
  
          J = 0;                       # NUMBER OF DIGITS IN MANTISSA  #
          MANTISSA = "000000000000000000";
          PLACE = 0;                   # NO DIGITS TO RIGHT OF DECPOINT#
          POINT = FALSE;               # NO DECIMAL POINT YET          #
          LEADZERO = TRUE;             # MAY HAVE LEADING ZEROS        #
  
          CHAR = C<0,1>SAREA[0];
          IF CHAR EQ "+"
           OR CHAR EQ "-"  THEN 
              I = 1;                             # SKIP THE SIGN       #
          ELSE
              I = 0;
  
          FOR I = I STEP 1 UNTIL 100  DO
              BEGIN 
              CHAR = C<I-(I/10)*10,1>SAREA[I/10]; 
  
  
              IF CHAR EQ "E"  THEN
                  GOTO CLFLIT2;        # IF END OF MANTISSA            #
  
              IF LEADZERO  THEN 
                  BEGIN                # CHAR PRECEDED BY LEADING ZEROS#
                  IF CHAR EQ "0"  THEN
                      BEGIN            # CHAR IS LEADING ZERO          #
                      IF POINT THEN 
                          PLACE = PLACE + 1;
#***#                 TEST;            # DONE WITH THIS CHARACTER      #
                      END 
                  ELSE
                      BEGIN            # MUST BE DIGIT OR DECPOINT     #
                      IF CHAR EQ DECPOINT  THEN 
                          POINT = TRUE; 
                      ELSE
                          LEADZERO = FALSE;      # FIRST NON-ZERO DIGIT#
                      END 
                  END 
  
              IF NOT LEADZERO 
               AND CHAR NQ DECPOINT  THEN 
                  BEGIN 
                  C<J,1>MANTISSA = CHAR;       # ADD DIGIT TO MANTISSA #
                  J = J + 1;
                  IF NOT POINT  THEN
                      PLACE = PLACE - 1;
                  END 
  
              END 
          # SHOULD NOT FALL THROUGH BECAUSE OF THE *E*                 #
  
 CLFLIT2:                              # MANTISSA HAS BEEN EXTRACTED   #
          EXPSIGN = +1;                # ASSUME EXPONENT SIGN = +      #
          EXP = 0;
          I = I + 1;                   # SKIP THE *E*                  #
  
          FOR I = I STEP 1 UNTIL SAREALENGTH-1  DO
              BEGIN 
              CHAR = C<I-(I/10)*10>SAREA[I/10]; 
  
              IF CHAR EQ "+"  THEN
#***#             TEST;                # DONE WITH THIS CHARACTER      #
  
          IF CHAR EQ "-"  THEN
                  EXPSIGN = -1; 
              ELSE
                  EXP = 10*EXP + B<0,6>CHAR - O"33";
              END 
  
          EXP = EXPSIGN*EXP - PLACE;
  
          IF EXP GR 323  THEN 
              GOTO CLFLIT3;            # TOO LARGE                     #
  
          IF EXP EQ 323 
           AND MANTISSA GR "126501408317068600"  THEN 
              GOTO CLFLIT3;            # TOO LARGE                     #
  
          IF EXP LS -293  THEN
              GOTO CLFLIT4;            # TOO SMALL                     #
  
          IF EXP EQ -293
           AND MANTISSA LS "313151306251402000"  THEN 
              GOTO CLFLIT4;            # TOO SMALL                     #
  
          GOTO CLFLIT5;                # VALUE IS IN RANGE             #
  
 CLFLIT3:                              # TOO LARGE                     #
          # (THE UNSIGNED VALUE OF THIS FLOATING POINT LITERAL IS      #
          #  LARGER THAN 0.1265014083170686E+323.                      #
          #  A VALUE OF 0.0E+0 IS ASSUMED.)                            #
          SSDIAGS(D1075); 
          SAREA[0] = "0.0E+00000";
          SAREALENGTH = 7;
          GOTO CLFLIT5; 
  
 CLFLIT4:                              # TOO SMALL                     #
          # (THE UNSIGNED VALUE OF THIS FLOATING POINT LITERAL IS      #
          #  SMALLER THAN 0.3131513062514020E-293.                     #
          #  A VALUE OF 0.0E+0 IS ASSUMED.)                            #
          SSDIAGS(D1076); 
          SAREA[0] = "0.0E+00000";
          SAREALENGTH = 7;
 CLFLIT5:                              # LITERAL IS READY              #
  
          # (A FLOATING POINT LITERAL IS NON-STANDARD.)                #
          SSDIAGS(D1046); 
          $BEGIN
          GOTO DEBUG; 
          $END
          RETURN; 
  
ILIT:                        # INTEGER LITERAL OR PROC NAME REFERENCE  #
          IF CURRENTDIV EQ PROCDIV
           AND NOT SIGNSW  THEN 
              BEGIN                    # ILIT MAY BE PNDEF OR PNREF    #
              IF CLACOLUMN LS 12  THEN
                  CLATYPE = TKNTYPE"PNDEF"; 
              ELSE
                  BEGIN 
                  IF ILITISPNREF  THEN
                      CLATYPE = TKNTYPE"PNREF"; 
                  END 
              END 
          $BEGIN
          GOTO DEBUG; 
          $END
          RETURN; 
  
LP:                          # LEFT PARENTHESIS                        #
          $BEGIN
          GOTO DEBUG; 
          $END
          RETURN; 
  
NLIT:                        # NUMERIC LITERAL                         #
          $BEGIN
          GOTO DEBUG; 
          $END
          RETURN; 
  
OP:                          # OPERATOR  (E.G. + - * /)                #
          $BEGIN
          GOTO DEBUG; 
          $END
          RETURN; 
  
PIC:                         # PICTURE STRING                          #
          FIRSTNOTPIC = FALSE;
          $BEGIN
          GOTO DEBUG; 
          $END
          RETURN; 
  
PNDEF:                       # PROCEDURE NAME DEFINITION               #
          $BEGIN                       # *** ILLEGAL HERE ***          #
          GOTO DEBUG;                  # *** SET BY CHKRW ***          #
          $END
  
PNREF:                       # PROCEDURE NAME REFERENCE                #
          $BEGIN                       # *** ILLEGAL HERE ***          #
          GOTO DEBUG;                  # *** SET BY CHKRW ***          #
          $END
  
PTDELIM:                     # PSEUDO-TEXT DELIMITER                   #
          # (THIS PSEUDO-TEXT DELIMITER IS ILLEGAL HERE.               #
          #  IT IS IGNORED.)                                           #
          SSDIAGS(D1092); 
          GOTO RESTART; 
  
PUNC:                        # PUNCTUATION                             #
          IF C<9,1>CLAVALUE EQ "."
          THEN
              BEGIN 
              REPLALLOWED = TRUE; 
              END 
          $BEGIN
          GOTO DEBUG; 
          $END
          RETURN; 
  
QLIT:                        # QUOTED LITERAL                          #
          $BEGIN
          GOTO DEBUG; 
          $END
          RETURN; 
  
REWD:                        # RESERVED WORD                           #
          $BEGIN                       # *** ILLEGAL HERE ***          #
          GOTO DEBUG;                  # *** SET BY CHKRW ***          #
          $END
  
RP:                          # RIGHT PARENTHESIS                       #
          $BEGIN
          GOTO DEBUG; 
          $END
          RETURN; 
  
SPECREG:                     # SPECIAL REGISTER                        #
          $BEGIN                       # *** ILLEGAL HERE ***          #
          GOTO DEBUG;                  # *** SET BY CHKRW ***          #
          $END
  
  
  
          END # TKNCLAS # 
          TERM
