*DECK SETPAIR 
USETEXT SSTEXT
          PROC  SETPAIR;
  
#**       SETPAIR -  SET UP PAIR OF FORMAL/ACTUAL PARAMETER SEQUENCES  #
#                                                                      #
#     CALLING SEQUENCE-                                                #
#         SETPAIR:                                                     #
#                                                                      #
#     GIVEN-                                                           #
#         CURRENT TOKEN IS FIRST OF SPECIFICATION.                     #
#         NPAIRS = NUMBER OF PAIRS SET UP SO FAR.                      #
#                                                                      #
#     DOES-                                                            #
#         IF NO ERRORS,                                                #
#           INCREMENTS MAXFPTKNS                                       #
#           SET AP$ AND FP$ SEQUENCES FOR THIS PAIR                    #
#         ELSE                                                         #
#           ISSUES APPROPRIATE DIAGNOSTIC(S)                           #
#           SET ERROR = TRUE.                                          #
  
  
          BEGIN 
  
  
  
          STATUS  TKNTYPE 
*CALL TKNTYPE 
  
          XREF
              BEGIN 
              PROC  ABORTSS;           # COMPILER ABORT                #
              PROC  CBLIST;            # COBOL LISTING ROUTINE         #
              PROC  CMM$GLV;           # INCREASE SIZE OF TABLES       #
              PROC  DBDIAG;            # DEBUG DIAGNOS LISTER          #
              FUNC  DEC      C(10);    # DECIMAL DISPLAY VALUE         #
              PROC  GETPIC;            # GET PICTURE CHARACTER-STRING  #
              PROC  GETSTR;            # GET STRING OF CHARACTERS      #
              PROC  INTERCEPTOR;       # ISSUE DIAGNOSTIC              #
              FUNC  OCT      C(20);    # OCTAL DISPLAY VALUE           #
              END 
  
          XDEF   ITEM  PTPOSS  B=FALSE;#TRUE WHEN GETPIC MAY RECOGNIZE
                                        A PSUEDO-TEXT DELIMITER        #
  
          DEF  DIAGNOS(SEV,NUM,LIN,COL) 
#$BEGIN DBDIAG(SEV,NUM,LIN,COL);$END INTERCEPTOR(COL,LIN,NUM-1000,SEV)#;
          DEF  F             #0#;      # FATAL SEVERITY   (IGNORED)    #
  
          ITEM  C            I;        # CHARACTER INDEX TO FP$STRING  #
          ITEM  FIRST        B;        # IFF FIRST TOKEN IN PARAMETER  #
          ITEM  I            I;        # SCRATCH                       #
          ITEM  IFCOL        B;        # IFF USE AP$COL ON SUBST.      #
          ITEM  MAYBEPIC     B;        # IFF FORMAL PARAM. MAY BE PIC  #
          ITEM  NWORDS       I;        # SCRATCH                       #
          ITEM  OFFSET       I;        # OFFSET FOR APARRAY, FPARRAY   #
          ITEM  TKN          I;        # INDEX TO CURRENT TOKEN IN PAIR#
          ITEM  TKNISPIC     B;        # IFF NEXT TOKEN IS PIC STRING  #
          ITEM  TKNMAYBEIS   B;        # IFF NEXT TOKEN MAY BE -IS-    #
          ITEM  W            I;        # WORD INDEX TO FP$STRING       #
                                       # ALSO, WARNING SEVERITY        #
CONTROL EJECT;
  
*CALL BUG020C$
  
*CALL LISTCTL 
  
          $BEGIN
  
          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"]; 
  
          ITEM  LINE         C(140);
          ITEM  C10          C(10); 
  
          $END
CONTROL EJECT;
  
          PROC  GETTKN; 
  
#**       GETTKN -  GET TOKEN (INCLUDING PICTURE CHARACTER-STRING)     #
#                                                                      #
#     CALLING SEQUENCE-                                                #
#         GETTKN:                                                      #
#                                                                      #
#     GIVEN-                                                           #
#         TKNISPIC = TRUE IFF A PICTURE CHARACTER-STRING IS EXPECTED.  #
#         WHEN TKNISPIC IS TRUE,                                       #
#           TKNMAYBEIS = TRUE IFF -IS- MAY PRECEDE PICTURE STRING      #
#                                                                      #
#     DOES-                                                            #
#         SETS CLA-VARIABLES FOR TOKEN.                                #
#         ADJUSTS TKNISPIC AND TKNMAYBEIS APPROPRIATELY.               #
  
  
          BEGIN 
          IF TKNISPIC  THEN 
              BEGIN 
              GETPIC;                  # GET PICTURE CHARACTER-STRING  #
              IF TKNMAYBEIS            # IF TOKEN MAY BE -IS-          #
               AND C<0,3>SAREA[0] EQ "IS "  THEN #   AND IT IS -IS-    #
                  BEGIN 
                  TKNMAYBEIS = FALSE;  # ALLOW ONLY ONE -IS-           #
                  # TKNISPIC = TRUE #  # STILL WANT PICTURE STRING     #
                  END 
              ELSE
                  TKNISPIC = FALSE;    # NEXT IS NOT PICTURE STRING    #
              END 
          ELSE
              BEGIN 
              GETSTR;                  # GET TOKEN                     #
              IF C<0,8>SAREA[0] EQ "PICTURE " 
               OR C<0,4>SAREA[0] EQ "PIC "  THEN
                  BEGIN 
                  TKNISPIC = TRUE;     # LOOK FOR PICTURE STRING       #
                  TKNMAYBEIS = TRUE;   # ALLOW -IS-                    #
                  END 
              END 
          END # GETTKN #
CONTROL EJECT;
  
          PROC  SETAPTKN; 
  
#**       SETAPTKN -  SET UP ACTUAL PARAMETER TOKEN                    #
#                                                                      #
#     CALLING SEQUENCE-                                                #
#         SETAPTKN:                                                    #
#                                                                      #
#     GIVEN-                                                           #
#         IFCOL INDICATES WHETHER SUBSTITUTED TOKEN SHOULD BE ALIGNED  #
#           STARTING AT COLUMN AP$COL.                                 #
#         NPAIRS = NUMBER OF PAIRS SET UP SO FAR.                      #
#         TKN = NUMBER OF CURRENT TOKEN WITHIN THIS SEQUENCE.          #
#         W = WORD INDEX TO NEXT AVAILABLE CHARACTER IN AP$STRING.     #
#         C = CHARACTER INDEX TO NEXT AVAIL. CHARACTER IN AP$STRING[W] #
#         CLA-VARIABLES.                                               #
#                                                                      #
#     DOES-                                                            #
#         INCREMENTS TKN.                                              #
#         SETS AP$ INFORMATION.                                        #
  
  
          BEGIN 
          TKN = TKN + 1;               # INCREMENT INDEX TO AP$        #
          CMM$GLV(APARRAY, 2);         # MAKE ROOM FOR DESCRIPTOR      #
          API$NXTARRAY = API$NXTARRAY + 1;
          OFFSET = AP$INDEX[NPAIRS+1];
  
#     IF NOT FIRST TOKEN, SET UP TOKEN DELIMITER                       #
  
          IF NOT FIRST  THEN
              BEGIN 
              C<API$NXTSTRGC,1>AP$STRING[API$NXTSTRGW] = "?"; 
              API$NXTSTRGC = API$NXTSTRGC + 1;
              IF API$NXTSTRGC EQ 10  THEN 
                  BEGIN 
                  API$NXTSTRGW = API$NXTSTRGW + 1;
                  API$NXTSTRGC = 0; 
                  END 
              END 
          FIRST = FALSE;               # NEXT IS NOT FIRST TOEKN       #
  
#     SET UP AP$ VALUES                                                #
  
          AP$TYPE[OFFSET+TKN] = CLATYPE;
          AP$VALUE[OFFSET+TKN] = CLAVALUE;
          AP$IFCOL[OFFSET+TKN] = IFCOL; 
          AP$SIGNSW[OFFSET+TKN] = SIGNSW; 
          IF IFCOL  THEN
              AP$COL[OFFSET+TKN] = CLACOLUMN; 
          AP$L[OFFSET+TKN] = SAREALENGTH; 
          AP$WO[OFFSET+TKN] = API$NXTSTRGW; 
          AP$CO[OFFSET+TKN] = API$NXTSTRGC; 
          C<API$NXTSTRGC,30>AP$STRING[API$NXTSTRGW] = C<0,30>SAREA[0];
          C<API$NXTSTRGC,230>AP$STRING[API$NXTSTRGW+3]=C<0,230>SAREA[3];
  
#     POINT W AND C TO JUST BEYOND THE END OF THIS TOKEN               #
  
          NWORDS = (API$NXTSTRGC + SAREALENGTH)/10; 
          API$NXTSTRGW = API$NXTSTRGW + NWORDS; 
          API$NXTSTRGC = API$NXTSTRGC + SAREALENGTH - 10*NWORDS;
          IF API$NXTSTRGW GQ API$MAXSTRGW THEN
              BEGIN 
              CMM$GLV(APSTRING, 26);
              API$MAXSTRGW = API$MAXSTRGW + 26; 
              C<0,20>AP$STRING[API$MAXSTRGW] = " "; 
              C<0,240>AP$STRING[API$MAXSTRGW+2] = " ";
              END 
  
          END # OF SETAPTKN # 
CONTROL EJECT;
  
          PROC  SETAPIDWORD;
  
#**       SETAPIDWORD -  SET FP IDENTIFIER OR COBOL WORD               #
#                                                                      #
#     CALLING SEQUENCE-                                                #
#         SETAPIDWORD:                                                 #
#                                                                      #
#     GIVEN-                                                           #
#         NPAIRS = NUMBER OF PAIRS SET UP SO FAR.                      #
#         TKN = NUMBER OF CURRENT TOKEN WITHIN THIS SEQUENCE.          #
#         W = WORD INDEX TO NEXT AVAILABLE CHARACTER IN AP$STRING.     #
#         C = CHARACTER INDEX TO NEXT AVAIL. CHARACTER IN AP$STRING[W] #
  
  
          BEGIN 
          IFCOL = FALSE;               # IGNORE ORIGINAL COL. ON SUBST.#
          SETAPTKN;                    # SET UP FIRST TOKEN            #
          GETSTR;                      # GET NEXT TOKEN                #
  
#     PROCESS ( (OF/IN) <WORD> )...                                    #
  
          FOR I=I WHILE C<0,3>SAREA[0] EQ "OF " 
           OR C<0,3>SAREA[0] EQ "IN "  DO 
              BEGIN 
              SETAPTKN; 
              GETSTR; 
              IF CLATYPE NQ TKNTYPE"AW"  THEN 
                  BEGIN 
                  DIAGNOS(F, 1008, CLALINE, CLACOLUMN); 
                  ERROR = TRUE; 
#***#             RETURN; 
                  END 
              SETAPTKN; 
              GETSTR; 
              END 
  
#     PROCESS POSSIBLE SUBSCRIPT                                       #
  
          IF CLATYPE EQ TKNTYPE"LP"  THEN 
              BEGIN 
              FOR I=I WHILE CLATYPE NQ TKNTYPE"RP"
               AND CLATYPE NQ TKNTYPE"EOD"  DO
                  BEGIN 
                  SETAPTKN; 
                  GETSTR; 
                  END 
                  SETAPTKN;            # SE0 UP RIGHT PARENTHESIS      #
                  GETSTR;              # SKIP RIGHT PARENTHESIS        #
              END 
          END # OF SETAPIDWORD #
CONTROL EJECT;
  
          PROC  SETAPPSEUDO;
  
#**       SETAPPSEUDO -  SET AP PSEUDO-TEXT                            #
#                                                                      #
#     CALLING SEQUENCE-                                                #
#         SETAPPSEUDO:                                                 #
#                                                                      #
#     GIVEN-                                                           #
#         NPAIRS = NUMBER OF PAIRS SET UP SO FAR.                      #
#         TKN = NUMBER OF CURRENT TOKEN WITHIN THIS SEQUENCE.          #
#         W = WORD INDEX TO NEXT AVAILABLE CHARACTER IN AP$STRING.     #
#         C = CHARACTER INDEX TO NEXT AVAIL. CHARACTER IN AP$STRING[W] #
  
  
          BEGIN 
          IFCOL = FALSE;               # IGNORE ORIGINAL COL. ON SUBST.#
          TKNISPIC = FALSE;            # NEXT TOKEN IS NOT PIC STRING  #
          ITEM  PSEUDOLINE   I;        # LINE NUMBER OF ==             #
          PSEUDOLINE = CLALINE; 
          GETTKN;                     # SKIP THE == # 
          PTPOSS = TRUE;
  
          FOR I=I WHILE CLATYPE NQ TKNTYPE"PTDELIM" 
           AND CLATYPE NQ TKNTYPE"EOD"  DO
              BEGIN 
              IF NOT IFCOL  THEN       # IF LAST WAS ON SAME LINE AS ==#
                  BEGIN 
                  IF CLALINE NQ PSEUDOLINE  THEN
                      IFCOL = TRUE; 
                  END 
              SETAPTKN;                # SET UP TOKEN                  #
              GETTKN; 
              END 
  
          PTPOSS = FALSE; 
  
          IF CLATYPE EQ TKNTYPE"EOD"  THEN
              BEGIN 
              DIAGNOS(F, 1   , CLALINE, CLACOLUMN); 
              ERROR = TRUE; 
#***#         RETURN; 
              END 
  
          GETSTR;                      # SKIP THE RIGHT ==             #
          END # OF SETAPPSEUDO #
CONTROL EJECT;
  
          PROC  SETFPTKN; 
  
#**       SETFPTKN -  SET UP FORMAL PARAMETER TOKEN                    #
#                                                                      #
#     CALLING SEQUENCE-                                                #
#         SETFPTKN:                                                    #
#                                                                      #
#     GIVEN-                                                           #
#         MAYBEPIC INDICATES WHETHER TOKEN MAY MATCH A PICTURE.        #
#         NPAIRS = NUMBER OF PAIRS SET UP SO FAR.                      #
#         TKN = NUMBER OF CURRENT TOKEN WITHIN THIS SEQUENCE.          #
#         W = WORD INDEX TO NEXT AVAILABLE CHARACTER IN FP$STRING.     #
#         C = CHARACTER INDEX TO NEXT AVAIL. CHARACTER IN FP$STRING[W] #
#         CLA-VARIABLES.                                               #
#                                                                      #
#     DOES-                                                            #
#         INCREMENTS TKN.                                              #
#         SETS FP$ INFORMATION.                                        #
  
  
          BEGIN 
          TKN = TKN + 1;               # INCREMENT INDEX TO FP$        #
          CMM$GLV(FPARRAY, 1);         # MAKE ROOM FOR DESCRIPTOR      #
          FPI$NXTARRAY = FPI$NXTARRAY + 1;
          OFFSET = FP$INDEX[NPAIRS+1];
  
#     IF NOT FIRST TOKEN, SET UP TOKEN DELIMITER                       #
  
          IF NOT FIRST  THEN
              BEGIN 
              C<FPI$NXTSTRGC,1>FP$STRING[FPI$NXTSTRGW] = "?"; 
              FPI$NXTSTRGC = FPI$NXTSTRGC + 1;
              IF FPI$NXTSTRGC EQ 10  THEN 
                  BEGIN 
                  FPI$NXTSTRGW = FPI$NXTSTRGW + 1;
                  FPI$NXTSTRGC = 0; 
                  END 
              END 
          FIRST = FALSE;               # NEXT IS NOT FIRST TOKEN       #
  
#     SET UP FP$ VALUES                                                #
  
               FP$TYPE[OFFSET+TKN] = CLATYPE; 
          FP$MAYBEPIC[OFFSET+TKN] = MAYBEPIC; 
          FP$L[OFFSET+TKN] = SAREALENGTH; 
          FP$WO[OFFSET+TKN] = FPI$NXTSTRGW; 
          FP$CO[OFFSET+TKN] = FPI$NXTSTRGC; 
          C<FPI$NXTSTRGC,30>FP$STRING[FPI$NXTSTRGW] = C<0,30>SAREA[0];
          C<FPI$NXTSTRGC,230>FP$STRING[FPI$NXTSTRGW+3]=C<0,230>SAREA[3];
  
#     POINT W AND C TO JUST BEYOND THE END OF THIS TOKEN               #
  
          NWORDS = (FPI$NXTSTRGC + SAREALENGTH)/10; 
          FPI$NXTSTRGW = FPI$NXTSTRGW + NWORDS; 
          FPI$NXTSTRGC = FPI$NXTSTRGC + SAREALENGTH - 10*NWORDS;
          IF FPI$NXTSTRGW GQ FPI$MAXSTRGW THEN
              BEGIN 
              CMM$GLV(FPSTRING, 26);
              FPI$MAXSTRGW = FPI$MAXSTRGW + 26; 
              C<0,20>FP$STRING[FPI$MAXSTRGW] = " "; 
              C<0,240>FP$STRING[FPI$MAXSTRGW+2] = " ";
              END 
  
          END # OF SETFPTKN # 
CONTROL EJECT;
  
          PROC  SETFPIDWORD;
  
#**       SETFPIDWORD -  SET FP IDENTIFIER OR COBOL WORD               #
#                                                                      #
#     CALLING SEQUENCE-                                                #
#         SETFPIDWORD:                                                 #
#                                                                      #
#     GIVEN-                                                           #
#         NPAIRS = NUMBER OF PAIRS SET UP SO FAR.                      #
#         TKN = NUMBER OF CURRENT TOKEN WITHIN THIS SEQUENCE.          #
#         W = WORD INDEX TO NEXT AVAILABLE CHARACTER IN FP$STRING.     #
#         C = CHARACTER INDEX TO NEXT AVAIL. CHARACTER IN FP$STRING[W] #
  
  
          BEGIN 
          MAYBEPIC = FALSE;            # ID OR COBOL WORD CANNOT BE PIC#
          SETFPTKN;                    # SET UP FIRST TOKEN            #
          GETSTR;                      # GET NEXT TOKEN                #
  
#     PROCESS ( (OF/IN) <WORD> )...                                    #
  
          FOR I=I WHILE C<0,3>SAREA[0] EQ "OF " 
           OR C<0,3>SAREA[0] EQ "IN "  DO 
              BEGIN 
              SETFPTKN; 
              GETSTR; 
              IF CLATYPE NQ TKNTYPE"AW"  THEN 
                  BEGIN 
                  DIAGNOS(F, 1008, CLALINE, CLACOLUMN); 
                  ERROR = TRUE; 
#***#             RETURN; 
                  END 
              SETFPTKN; 
              GETSTR; 
              END 
  
#     PROCESS POSSIBLE SUBSCRIPT                                       #
  
          IF CLATYPE EQ TKNTYPE"LP"  THEN 
              BEGIN 
              FOR I=I WHILE CLATYPE NQ TKNTYPE"RP"
               AND CLATYPE NQ TKNTYPE"EOD"  DO
                  BEGIN 
                  SETFPTKN; 
                  GETSTR; 
                  END 
              SETFPTKN;                # SET UP RIGHT PARENTHESIS      #
              GETSTR;                  # SKIP RIGHT PARENTHESIS        #
              END 
          END # OF SETFPIDWORD #
CONTROL EJECT;
  
          PROC  SETFPPSEUDO;
  
#**       SETFPPSEUDO -  SET FP PSEUDO-TEXT                            #
#                                                                      #
#     CALLING SEQUENCE-                                                #
#         SETFPPSEUDO:                                                 #
#                                                                      #
#     GIVEN-                                                           #
#         NPAIRS = NUMBER OF PAIRS SET UP SO FAR.                      #
#         TKN = NUMBER OF CURRENT TOKEN WITHIN THIS SEQUENCE.          #
#         W = WORD INDEX TO NEXT AVAILABLE CHARACTER IN FP$STRING.     #
#         C = CHARACTER INDEX TO NEXT AVAIL. CHARACTER IN FP$STRING[W] #
  
  
          BEGIN 
          MAYBEPIC = TRUE;
          TKNISPIC = FALSE; 
          GETTKN;                     # SKIP THE == # 
          PTPOSS = TRUE;
  
          FOR I=I WHILE CLATYPE NQ TKNTYPE"PTDELIM" 
           AND CLATYPE NQ TKNTYPE"EOD"  DO
              BEGIN 
              SETFPTKN;                # SET UP TOKEN                  #
              GETTKN; 
              END 
  
          PTPOSS = FALSE; 
  
          IF CLATYPE EQ TKNTYPE"EOD"  THEN
              BEGIN 
              DIAGNOS(F, 1087, CLALINE, CLACOLUMN); 
              ERROR = TRUE; 
#***#         RETURN; 
              END 
  
          IF TKN EQ 0 THEN
              BEGIN 
              DIAGNOS(F, 1110, CLALINE, CLACOLUMN); 
              ERROR = TRUE; 
              RETURN; 
              END 
  
          GETSTR;                      # SKIP THE RIGHT ==             #
          END # OF SETFPPSEUDO #
CONTROL EJECT;
  
  
#     SKIP POSSIBLE PUNCTUATION                                        #
  
          IF CLATYPE EQ TKNTYPE"PUNC" 
           AND (C<9,1>CLAVALUE EQ "," 
                OR C<9,1>CLAVALUE EQ ";")  THEN 
              GETSTR; 
  
#     SET UP THE FORMAL PARAMETER                                      #
  
          TKN = 0;                     # INITIALIZE TOKEN INDEX        #
          FP$INDEX[NPAIRS+1] = FPI$NXTARRAY;
          FIRST = TRUE; 
  
          IF CLATYPE EQ TKNTYPE"ILIT" 
           OR CLATYPE EQ TKNTYPE"NLIT"
           OR CLATYPE EQ TKNTYPE"FLIT"
           OR CLATYPE EQ TKNTYPE"QLIT"  THEN
              BEGIN 
              MAYBEPIC = FALSE; 
              SETFPTKN; 
              GETSTR;                  # GET TOKEN AFTER X-LIT         #
              END 
          ELSE
          IF CLATYPE EQ TKNTYPE"PTDELIM"  THEN
              SETFPPSEUDO;
          ELSE
          IF CLATYPE EQ TKNTYPE"AW"  THEN 
              SETFPIDWORD;
          ELSE
              BEGIN 
              DIAGNOS(F, 1003, CLALINE, CLACOLUMN); 
              ERROR = TRUE; 
              END 
  
          IF ERROR  THEN
#***#         RETURN; 
  
          FP$NTKNS[NPAIRS+1] = TKN; 
  
#     SKIP THE -BY-                                                    #
  
          IF C<0,3>SAREA[0] NQ "BY "  THEN
              BEGIN 
              DIAGNOS(F, 1078,CLALINE, CLACOLUMN);
              ERROR = TRUE; 
#***#         RETURN; 
              END 
          GETSTR;                      # SKIP THE -BY-                 #
  
#     SET UP THE ACTUAL PARAMETER                                      #
  
          TKN = 0;                     # INITIALIZE TOKEN INDEX        #
          AP$INDEX[NPAIRS+1] = API$NXTARRAY;
          FIRST = TRUE; 
  
          IF CLATYPE EQ TKNTYPE"ILIT" 
           OR CLATYPE EQ TKNTYPE"NLIT"
           OR CLATYPE EQ TKNTYPE"FLIT"
           OR CLATYPE EQ TKNTYPE"QLIT"  THEN
              BEGIN 
              IFCOL = FALSE;
              SETAPTKN; 
              GETSTR;                  # GET TOKEN AFTER X-LIT         #
              END 
          ELSE
          IF CLATYPE EQ TKNTYPE"PTDELIM"  THEN
              SETAPPSEUDO;
          ELSE
          IF CLATYPE EQ TKNTYPE"AW"  THEN 
              SETAPIDWORD;
          ELSE
              BEGIN 
              DIAGNOS(F, 1003, CLALINE, CLACOLUMN); 
              ERROR = TRUE; 
              END 
  
          IF ERROR  THEN
#***#         RETURN; 
  
          AP$NTKNS[NPAIRS+1] = TKN; 
  
#     INCREMENT NUMBER OF PAIRS, AND ADJUST MAXFPTKNS                  #
  
          NPAIRS = NPAIRS + 1;
          IF MAXFPTKNS LS FP$NTKNS[NPAIRS]  THEN
              MAXFPTKNS = FP$NTKNS[NPAIRS]; 
  
CONTROL EJECT;
  
          $BEGIN
          IF BUG020C$CPY  THEN
              BEGIN 
              CBLIST(LISTCTL"LINE", " ", 1);
              LINE =
               "FP$NTKNS[*]=*** FP$INDEX=*** AP$NTKNS=*** AP$INDEX=***";
              C10 = DEC(NPAIRS);
              C<9,1>LINE = C<0,1>C10; 
              C10 = DEC(FP$NTKNS[NPAIRS]);
              C<12,3>LINE = C<0,3>C10;
              C10 = DEC(FP$INDEX[NPAIRS]);
              C<25,3>LINE = C<0,3>C10;
              C10 = DEC(AP$NTKNS[NPAIRS]);
              C<38,3>LINE = C<0,3>C10;
              C10 = DEC(AP$INDEX[NPAIRS]);
              C<51,3>LINE = C<0,3>C10;
              CBLIST(LISTCTL"LINE", LINE, 54);
              FOR TKN = 1 STEP 1 UNTIL FP$NTKNS[NPAIRS]  DO 
                  BEGIN 
                  OFFSET = FP$INDEX[NPAIRS];
                  LINE =
                 "FP$WO[9,9]=999  FP$CO=99  FP$L=999  FP$MAYBEPIC=TRUE";
                  C10 = DEC(OFFSET+TKN);
                  C<6,3>LINE = C<0,3>C10; 
                  C10 = DEC(FP$WO[OFFSET+TKN]); 
                  C<11,3>LINE = C<0,3>C10;
                  C10 = DEC(FP$CO[OFFSET+TKN]); 
                  C<22,2>LINE = C<0,2>C10;
                  C10 = DEC(FP$L[OFFSET+TKN]);
                  C<31,3>LINE = C<0,3>C10;
                  IF NOT FP$MAYBEPIC[OFFSET+TKN]  THEN
                      C<48,5>LINE = "FALSE";
                  CBLIST(LISTCTL"LINE", LINE, 53);
                  END 
              W = FP$WO[OFFSET+1];     # WORD INDEX TO FIRST TOKEN     #
              C = FP$CO[OFFSET+1];     # CHAR INDEX TO FIRST TOKEN     #
              I = OFFSET+FP$NTKNS[NPAIRS]; # FPARRAY INDEX TO LAST TKN #
              I = (10*FP$WO[I] + FP$CO[I] + FP$L[I]) - (10*W + C);
              IF I GR 130  THEN 
                  I = 130;
              C<0,130>LINE = C<C,I>FP$STRING[W];
              FOR I = 7 STEP 10 UNTIL 127  DO 
                  BEGIN 
                  IF C<I,2>LINE EQ 0 THEN 
                      C<I,2>LINE = "^^";
                  END 
              CBLIST(LISTCTL"LINE", LINE, 130); 
              FOR TKN = 1 STEP 1 UNTIL AP$NTKNS[NPAIRS]  DO 
                  BEGIN 
                  OFFSET = AP$INDEX[NPAIRS];
                  LINE ="AP$TYPE[9,9]=SPECREG  VALUE=777777   WO=999  CO
=99  L=999  IFCOL=FALSE  COL=99"; 
                  C10 = DEC(OFFSET+TKN);
                  C<8,3>LINE = C<0,3>C10; 
                  C<13,7>LINE = BUG$TKNTYPE[AP$TYPE[OFFSET+TKN]]; 
                  C<28,6>LINE = OCT(AP$VALUE[OFFSET+TKN], 14, 6); 
                  IF AP$SIGNSW[OFFSET+TKN]  THEN
                      C<35,1>LINE = "S";
                  C10 = DEC(AP$WO[OFFSET+TKN]); 
                  C<40,3>LINE = C<0,3>C10;
                  C10 = DEC(AP$CO[OFFSET+TKN]); 
                  C<48,2>LINE = C<0,2>C10;
                  C10 = DEC(AP$L[OFFSET+TKN]);
                  C<54,3>LINE = C<0,3>C10;
                  IF AP$IFCOL[OFFSET+TKN]  THEN 
                      C<65,5>LINE = "TRUE ";
                  C10 = DEC(AP$COL[OFFSET+TKN]);
                  C<76,2>LINE = C<0,2>C10;
                  CBLIST(LISTCTL"LINE", LINE, 78);
                  END 
              W = AP$WO[OFFSET+1];     # WORD INDEX TO FIRST TOKEN     #
              C = AP$CO[OFFSET+1];     # CHAR INDEX TO FIRST TOKEN     #
              I = OFFSET+AP$NTKNS[NPAIRS]; # APARRAY INDEX TO LAST TKN #
              I = (10*AP$WO[I] + AP$CO[I] + AP$L[I]) - (10*W + C);
              IF I GR 130  THEN 
                  I = 130;
              C<0,130>LINE = C<C,I>AP$STRING[W];
              FOR I = 7 STEP 10 UNTIL 127  DO 
                  BEGIN 
                  IF C<I,2>LINE EQ 0 THEN 
                      C<I,2>LINE = "^^";
                  END 
              CBLIST(LISTCTL"LINE", LINE, 130); 
              END 
          $END
  
          END # OF SETPAIR #
          TERM
