*DECK REPLACE 
USETEXT SSTEXT
  
          PROC REPLACE; 
  
#**       REPLACE - REPLACE SOURCE TEXT PROCESSING                     #
#                                                                      #
#         CALLING FORM - REPLACE:                                      #
#                                                                      #
#         GIVEN - TKNCLASSIFIER RESULT VALUES                          #
#                                                                      #
#         DOES - REPLACE STATEMENT PROCESSING                          #
#                REPLACE PROCESSING OF SOURCE TEXT                     #
#                                                                      #
#            REPLACE HAS 7 STATES EACH ONE HANDLES A DIFFERENT CASE OF #
#            REPLACE STATEMENT OR GENERAL REPLACE PROCESSING           #
#            REPLACE IS CALLED FROM TKNCLAS (AT LABEL POLISH) TO       #
#            PROCESS REPLACE STATEMENTS AND TO EXAMINE SOURCE TOKENS   #
#            WHEN THERE IS AN ACTIVE REPLACE STATEMENT                 #
#                                                                      #
#            STATE1 - NORMAL REPLACE PROCESSING STATE (NORMAL$)        #
#                     DOES - CHECKING OF SOURCE TOKENS AGAINST THE     #
#                            FORMAL PARAMETERS OF THE ACTIVE REPLACE   #
#                            STATEMENT.                                #
#                            MANAGES THE TARGET STRING WHERE THE SOURCE#
#                            TOKENS ARE PLACED FOR COMPARISON AGAINST  #
#                            THE FORMAL PARAMETERS, BY RTARGET CALLS.  #
#                            RETURNS TO TKNCLAS WITH TKNREADY TRUE THE #
#                            NEXT TOKEN FROM THE TARGET STRING WHICH IS#
#                            READY TO BE POLISHED UP, OR IF A MATCH OF #
#                            TARGET WITH A FP HAS OCCURED SETS RSTATE  #
#                            TO AP$TRGT$MAN$ AND WE JUMP THERE.        #
#                            IF TKNCLAS IS WINDING DOWN AN ACTIVE REPLA#
#                            CE STATEMENT BECAUSE IT HAS SEEN A NEW ONE#
#                            RSTATE IS SET TO INITIALIZE$ WHEN THE OLD #
#                            TARGET STRING HAS BEEN EMPTIED.           #
#                                                                      #
#            STATE2 - REPLACE STATEMENT INITIALIZATION  (INITIALIZE$)  #
#                     DOES - TKNCLAS HAS SEEN A REPLACE VERB, IF THERE #
#                            WAS AN ACTIVE REPLACE STATEMENT IT HAS    #
#                            BEEN ENDED AND THE NEXT TOKEN AFTER THE   #
#                            REPLACE VERB HAS BEEN RETRIEVED.          #
#                            CHECK FOR RW OFF, RELEASE ALL CMM BLOCKS  #
#                            TURN REPLACEMODE OFF AND RETURN.          #
#                            IF A PERIOD WE DIAGNOSE MISSING PT"S      #
#                            IF EOD DIAGNOS THAT                       #
#                            OTHERWISE ALLOCATE CMMBLOCKS AND          #
#                            INITIALIZE VARIABLES AND SET RSTATE TO    #
#                            PSDO$TXT$1 STATE AND GO THERE             #
#                                                                      #
#            STATE3 - PROCESS PT-1 AND END OF REPLACE STMT (PSDO$TXT$1)#
#                     DOES - DIAGNOSES MISSING PSEUDO-TEXTS.           #
#                            DIAGNOSES EOD IN PT-1.                    #
#                            STORES PT-1 IN THE FP STRING AND ITS      #
#                            ATRIBUTES IN THE FP ARRAYS.               #
#                            IT NOTES WHEN PUNCS ONLY IN PT-1.         #
#                            ALLOCATES CMM BLOCKS FOR TARGET STRING AND#
#                            FINISHES UP REPLACE STATEMENT PROCESSING  #
#                            THEN SETS RSTATE TO NORMAL$ BEFORE RETURN.#
#                                                                      #
#            STATE4 - PROCESS RESERVED WORD BY  (RSVDWRD$BY$)          #
#                     DOES - SIMPLY CHECKS TO SEE IF "BY" IS THE       #
#                            CURRENT TOKEN AND SETS RSTATE TO          #
#                            PSDO$TXT$2 OR DIAGNOSES IT IF "BY" NOT    #
#                            THERE THEN RETURNS.                       #
#                                                                      #
#            STATE5 - PROCESS PSEUDO-TEXT-2  (PSDO$TXT$2)              #
#                     DOES - SAME THING AS PSDO$TXT$1 ONLY STORING     #
#                            THE TEXT IN THE ACTUAL PARAMETER STRING   #
#                            AND ARRAYS.                               #
#                            ALSO PUNCS ARE NOT NOTICED AND NO CLEAN UP#
#                            IS NECCESSARY.                            #
#                            RSTATE IS SET TO PSDO$TXT$1 UPON WRAP-UP  #
#                                                                      #
#            STATE6 - AP TOKEN PROCESSOR  (AP$TRGT$MAN)                #
#                     DOES - SENDS AP TOKENS PAIRED WITH THE TARGET    #
#                            MATCHED IN NORMAL$ STATE TO TKNCLAS       #
#                            SHIFTS THE TARGET STRING THROWING OUT THE #
#                            MATCHED TOKENS AND ADDING CURRENT TOKENS  #
#                            RETURNS WITH RSTATE = NORMAL$ WHEN DONE   #
#                                                                      #
#            STATE7 - ERROR PROCESSING STATE  (ERROR$)                 #
#                     DOES - SEARCHES FOR ENDING PERIOD OF A BAD       #
#                            REPLACE STATEMENT.                        #
#                            SOME OTHER STATE HAS FOUND AN ERROR AND   #
#                            HAS SET RSTATE TO ERROR$                  #
#                            UPON FINDING PERIOD CMM BLOCKS ARE        #
#                            RELEASED AND REPLACEMODE IS TURNED OFF    #
#                            EOD IS DIAGNOSED IF FOUND BEFORE PERIOD   #
#                                                                      #
  
          BEGIN 
          CONTROL PACK; 
  
          XREF                         # EXTERNAL PROCEDURES           #
              BEGIN 
              FUNC  CMM$AGR  I;        #  ACQUIRE GROUP-ID             #
              PROC  CMM$ALV;           #  ALLOCATE VARYING-POS. BLOCKS #
              PROC  CMM$FGR;           #  FREE GROUP OF CMM BLOCKS     #
              PROC  CMM$GLV;           #  GROW AT LAST OF VARYING BLOCK#
              PROC SSDIAGS; 
              END 
  
#       REPLACE STATE DEFS - REMEMBER TO CHECK RSTATE REFERENCES IN    #
#       REPLDON, TKNCLAS, AND INTERPRE                                 #
  
          DEF   NORMAL$      #1#;      #STATE1# 
          DEF   INITIALIZE$  #2#;      #STATE2# 
          DEF   PSDO$TXT$1$  #3#;      #STATE3# 
          DEF   RSVDWRD$BY$  #4#;      #STATE4# 
          DEF   PSDO$TXT$2$  #5#;      #STATE5# 
          DEF   AP$TRGT$MAN$ #6#;      #STATE6# 
          DEF   ERROR$       #7#;      #STATE7# 
  
#     DIAGNOSTIC DEFS                                                  #
  
          DEF D1106  #106#; 
          DEF D1118  #118#; 
          DEF D1121  #121#; 
          DEF D1124  #124#; 
          DEF D1127  #127#; 
          DEF D1130  #130#; 
          DEF D1133  #133#; 
          DEF D1136  #136#; 
          DEF D1139  #139#; 
  
  
  
  
*CALL REPLBLK 
  
          SWITCH STATE
               ,STATE1             # NORMAL REPLACE PROCESSING         #
               ,STATE2             # REPLACE STATEMENT INITIALIZATION  #
               ,STATE3             # PSEUDO-TEXT-1 PROCESSOR           #
               ,STATE4             # RESERVED WORD BY PROCESSOR        #
               ,STATE5             # PSEUDO-TEXT-2 PROCESSOR           #
               ,STATE6             # AP AND TARGET MANIPULATION PROCESS#
               ,STATE7             # ERROR PROCESSING                  #
               ;
  
          STATUS TKNTYPE
*CALL TKNTYPE 
  
          XDEF
              BEGIN 
              ITEM  EODREPL      B;    # TRUE IF EOD FND IN REPLACE PRC#
              ITEM  FSTPTDELIM   B;    # FIRST PSEUDO-TEXT-DELIM FLAG  #
              ITEM  LSTPTDELIM   B;    # LAST  PSEUDO-TEXT-DELIM FLAG  #
              ITEM  LSTTKNP      B=FALSE; #LAST TARGET TOKEN WAS PERIOD#
              ITEM  REPLAC$MODE  B=FALSE; # TRUE - REPLACE STMT ACTIVE #
              ITEM  RPLGRPNOTFRE B=TRUE; # TRUE IF REPLACE GROUP ACTIVE#
              ITEM  RGROUP$REPL  I;    # GRP-ID FOR REPLACE STMT BLKS  #
              ITEM  RSTATE       I=INITIALIZE$;  # REPLACE STATE       #
              ITEM  SVCURCSTATE  I;    # SAVED TOKENCLASSIFIER STATE   #
              ITEM  TKNREADY     B;    # TRU IF RPLC HAS TKN FOR POLISH#
              END 
CONTROL EJECT;
  
          ITEM  C            I;        # SCRATCH CHARACTER POINTER     #
          ITEM  CHKPUNC      B;        # TRUE IFF REPLACE PUNCS        #
          ITEM  FIRSTAP      B;        # FIRST ACTUAL PARAMETER FLAG   #
          ITEM  FIRSTFP      B;        # FIRST FORMAL PARAMETER FLAG   #
          ITEM  FSTMATCHLINE I;        # LINE NO. FOR REPLACE TOKENS   #
          ITEM  I            I;        # SCRATCH                       #
          ITEM  IFCOL        B;        # FLAGS AP"S HAVING PREFERED COL#
          ITEM  J            I;        # SCRATCH                       #
          ITEM  L            I;        # SCRATCH                       #
          ITEM  MATCH        B;        # FLAG USED IN MATCHING ATTEMPTS#
          ITEM  MAXRFPTKNS   I;        # MAX. OF ALL REPLACE PF TOKENS #
          ITEM  NEWW         I;        # SCRATCH WORD POINTER          #
          ITEM  NONSRCFPTKNS I;        # NO. OF 0 TKNS IN RPLC T$STRING#
          ITEM  NWORDS       I;        # SCRATCH - WORD COUNTER        #
          ITEM  NXTMAYBEPSTX B;        # FLAG FOR HANDLING PUNC REPLACE#
          ITEM  NXTMAYBEPUNC B;        # FLAG FOR HANDLING PUNC REPLACE#
          ITEM  OFFSET       I;        # SCRATCH                       #
          ITEM  OLDW         I;        # SCRATCH WORD POINTER          #
          ITEM  PSEUDOLINE   I;        # SCRATCH                       #
          ITEM  PUNCSVSAREA  C(10);    # SAVE A FORMAL PARAM OF A PUNC #
          ITEM  RAPMATCHCOL  I;        # COL. NO. FOR REPLACE TOKENS   #
          ITEM  RAPOFFSET    I;        # SCRATCH AP$STRING POINTER     #
          ITEM  REPLACEOFF   B=FALSE;  # TRUE - IF REPLACE OFF SEEN    #
          ITEM  RFP          I;        # SCRATCH FORMAL PARAM POINTER  #
          ITEM  RFPC         I;        # SCRATCH                       #
          ITEM  RFPL         I;        # SCRATCH                       #
          ITEM  RFPOFFSET    I;        # SCRATCH FP$STRING POINTER     #
          ITEM  RFPTKNLIM    I;        # T$STRING WORD SHIFT COUNT     #
          ITEM  RFPW         I;        # SCRATCH                       #
          ITEM  RNPAIRS      I;        # NO. FRML/ACTL SEQS FOR REPLACE#
          ITEM  RT           I;        # SCRATCH                       #
          ITEM  RTKN         I;        # TEMP TKN COUNTER              #
          ITEM  RTKNLIM      I;        # SCRATCH TOKEN COUNT           #
          ITEM  SVCSTATE     I;        # HOLDS CSTATE DURING STATE-6   #
          ITEM  W            I;        # SCRATCH WORD POINTER          #
  
CONTROL EJECT;
  
*CALL BUG020C$
  
*CALL LISTCTL 
  
          $BEGIN
          XREF
              BEGIN 
              PROC  CBLIST; 
              FUNC  DEC          C(10); 
              FUNC  OCT          C(20); 
              END 
  
          ARRAY  BUG$ [0:17]; 
              ITEM  BUG$TKNTYPE  C(0, 0, 7) = 
                [ "NULL   ",
                  "ILIT   ",
                  "NLIT   ",
                  "FLIT   ",
                  "QLIT   ",
                  "AW     ",
                  "OP     ",
                  "PUNC   ",
                  "RP     ",
                  "LP     ",
                  "REWD   ",
                  "PIC    ",
                  "EOD    ",
                  "PNDEF  ",
                  "PNREF  ",
                  "FIGCON ",
                  "SPECREG",
                  "PTDELIM"]; 
  
          ITEM  LINE         C(140);   # DEBUG PRINT LINE              #
          ITEM  C10          C(10);    # DEBUG SCRATCH                 #
  
          $END
  
          DEF  MATCHED  #$BEGIN IF BUG020C$CPY THEN BEGIN LINE =
"REPLACE - MATCH FOUND WITH FP=99"; C10 = DEC(RFP); C<30,27>LINE =
C<0,2>C10; CBLIST(LISTCTL"LINE", LINE, 33); END $END#;
CONTROL EJECT;
  
          PROC   RTARGET; 
  
#**       RTARGET - REPLACE TARGET MANAGEMENT ROUTINE                  #
#                                                                      #
#         GIVEN-                                                       #
#                TOKEN DESCRIBED BY CLA-VARIABLES OR EODREPL ON        #
#                RT$ INFORMATION                                       #
#                                                                      #
#         DOES-                                                        #
#                THROWS AWAY FIRST RT$ ENTRY                           #
#                SHIFTS REMAING RT$ ENTRIES OVER                       #
#                APPENDS GIVEN TOKEN TO END OF RT$STRING OR            #
#                NULL TOKEN IF EODREPL ON.                             #
#                                                                      #
  
          ITEM   C240        C(240);   # SCRATCH                       #
          ITEM   TL          I;        # SCRATCH                       #
  
          BEGIN 
          TKNREADY = FALSE; 
          IF MAXRFPTKNS NQ 1
          THEN
              BEGIN  # MAXRFPTKNS " 1 # 
              W = RT$WO[2];            # WORD OFFSET OF OLD 2ND TOKEN  #
              C = RT$CO[2];            # CHAR OFFSET OF OLD 2ND TOKEN  #
              RT$LSTRING = RT$LSTRING - 10*W - C ;
              TL = RT$LSTRING;
              IF TL LQ 230             # MOVE TARGET STRING OVER 1 TKN #
              THEN
                  BEGIN                # WITHIN POWER OF BEAD FUNCTION #
                  C240 = C<C,240>RT$STRING[W];
                  C<0,TL>RT$STRING[0] = C<0,TL>C240;
                  END 
              ELSE                     # BEYOND POWER OF BEAD FUNCTION #
                  BEGIN 
                  OLDW = W; 
                  NEWW = 0; 
                  FOR I=I WHILE TL GR 0 DO
                      BEGIN 
                      IF TL LS 230
                      THEN
                          L = TL; 
                      ELSE
                          L = 230;
                      C<0,L>RT$STRING[NEWW] = C<C,L>RT$STRING[OLDW];
                      OLDW = OLDW + 23; 
                      NEWW = NEWW + 23; 
                      TL = TL - L;
                      END 
                  END 
  
              FOR I=1 STEP 1 UNTIL RTI$MAXARRAY - 1 DO
                  BEGIN                # MOVE RT$ DOWN BY 1 TOKEN      #
                  RT$WORD0[I] = RT$WORD0[I+1];
                  RT$WORD1[I] = RT$WORD1[I+1];
                  RT$WO[I] = RT$WO[I+1] - W;
                  J = RT$CO[I+1] - C; 
                  IF J LS 0 
                  THEN
                      BEGIN 
                      RT$WO[I] = RT$WO[I] - 1;
                      J = J + 10; 
                      END 
                  RT$CO[I] = J; 
                  END #LOOP#
  
#         INSERT TEXT WORD DELIMITER AND APPEND A TOKEN                #
  
              W = RT$LSTRING/10;
              C = RT$LSTRING - 10*W;
              C<C,1>RT$STRING[W] = "?"; 
              RT$LSTRING = RT$LSTRING + 1;
              C = C + 1;
              IF C EQ 10
              THEN
                  BEGIN 
                  W = W + 1;
                  C = 0;
                  END 
              LSTTKNP = FALSE;
              IF EODREPL
              THEN  # EOD TOKEN SEEN OR NEW REPLACE STMT ENCOUNTERED   #
                  BEGIN                # MOVE NULL TOKEN TO TARGET     #
                  NONSRCFPTKNS = NONSRCFPTKNS + 1;
                  RT$WO[RTI$MAXARRAY] = W;
                  RT$CO[RTI$MAXARRAY] = C;
                  RT$L[RTI$MAXARRAY] = 0; 
                  END 
              ELSE   # APPEND TOKEN                                    #
                  BEGIN 
                  IF CLATYPE EQ TKNTYPE"EOD"
                  THEN
                      BEGIN 
                      EODREPL = TRUE; 
                      SVCURCSTATE = CSTATE; 
                      END 
                  IF CLATYPE EQ TKNTYPE"PUNC" 
                  AND (C<9,1>CLAVALUE EQ "," OR C<9,1>CLAVALUE EQ ";")
                  THEN  # RETURN IF WE ARE NOT REPLACING PUNCTUATION   #
                      BEGIN 
                      IF NOT CHKPUNC
                      THEN
                          BEGIN 
                          RETURN; 
                          END 
                      END 
                  IF CLATYPE EQ TKNTYPE"PUNC" 
                     AND C<9,1>CLAVALUE EQ "."
                  THEN   # SIGNAL TKNCLAS THAT RELACE STMT NOW LEGAL   #
                      BEGIN 
                      LSTTKNP = TRUE; 
                      END 
                  IF SAREALENGTH LS 230 
                  THEN                 # WITHIN BEAD FUNCTION LIMITS   #
                      BEGIN 
                      C<C,SAREALENGTH>RT$STRING[W] =
                          C<0,SAREALENGTH>SAREA[0]; 
                      END 
                  ELSE                 # BEYOND BEAD FUNCTION LIMITS   #
                      BEGIN 
                      C<C,30>RT$STRING[W] = C<0,30>SAREA[0];
                      C<C,SAREALENGTH-30>RT$STRING[W+3] = 
                          C<0,SAREALENGTH-30>SAREA[3];
                      END 
  
                  RT$LSTRING = RT$LSTRING + SAREALENGTH;
                  I = RTI$MAXARRAY; 
                  RT$L[I] = SAREALENGTH;
                  RT$WO[I] = W; 
                  RT$CO[I] = C; 
                  RT$COLUMN[I] = CLACOLUMN; 
                  RT$COMMENT[I] = CLACOMMENT; 
                  RT$LCOLUMN[I] = CLACOLUMN;
                  RT$LINE[I] = CLALINE; 
                  RT$LVLN[I] = CLALVLN; 
                  RT$MOD[I] = CLAMOD; 
                  RT$SIGNSW[I] = SIGNSW;
                  RT$TYPE[I] = CLATYPE; 
                  RT$VALUE[I] = CLAVALUE; 
                  RT$VLN[I] = CLAVLN; 
                  TKNREADY = TRUE;
                  END 
  
              IF (RT$LSTRING + 9)/10 GQ RTI$MAXSTRGW
              THEN                     # MAY NOT BE ENOUGH ROOM FOR    #
                  BEGIN                # NEXT TARGET TOKEN SO          #
                  CMM$GLV(RTSTRNG,26); # GROW THE TARGET STRING        #
                  RTI$MAXSTRGW = RTI$MAXSTRGW + 26; 
                  C<0,20>RT$STRING[RTI$MAXSTRGW] = " "; 
                  C<0,240>RT$STRING[RTI$MAXSTRGW+2] = " ";
                  END 
  
              END    # MAXRFPTKNS " 1 # 
          RETURN; 
          END 
CONTROL EJECT;
  
          PROC   SETRFPTKN; 
  
#**       SETRFPTKN - SET UP FORMAL PARAMETER TOKENS                   #
#                                                                      #
#         GIVEN-                                                       #
#                TOKEN IN SAREA WITH ITS ASSOCIATED CLAVARIABLES       #
#                                                                      #
#         DOES-                                                        #
#                PLACES THIS TOKEN IN RFP$STRING WITH TOKEN DELIMITERS #
#                MANAGES RFP$ ARRAYS                                   #
#                GROWS RFP$STRING AS NECESSARY                         #
#                                                                      #
  
          BEGIN 
  
          RTKN = RTKN + 1;
          RFPI$NXTARAY = RFPI$NXTARAY + 1;
          OFFSET = RFP$INDEX[RNPAIRS+1];
          CMM$GLV(RFPARAY, 1);         # GROW RFPARAY                  #
  
#     IF NOT FIRST TOKEN, SET UP TOKEN DELIMITER                       #
  
          IF NOT FIRSTFP
          THEN
              BEGIN 
              C<RFPI$NXSTRGC,1>RFP$STRING[RFPI$NXSTRGW] = "?";
              RFPI$NXSTRGC = RFPI$NXSTRGC + 1;
              IF RFPI$NXSTRGC EQ 10 
              THEN
                  BEGIN 
                  RFPI$NXSTRGC = 0; 
                  RFPI$NXSTRGW = RFPI$NXSTRGW + 1;
                  END 
              END 
          ELSE
              BEGIN 
              FIRSTFP = FALSE;
              END 
  
#     SET UP RFP$ VALUES                                               #
  
          RFP$L[OFFSET+RTKN] = SAREALENGTH; 
          RFP$WO[OFFSET+RTKN] = RFPI$NXSTRGW; 
          RFP$CO[OFFSET+RTKN] = RFPI$NXSTRGC; 
          IF CLATYPE EQ TKNTYPE"PIC"
          THEN
              BEGIN 
              RFP$MAYBEPIC[OFFSET+RTKN] = TRUE; 
              END 
          ELSE
              BEGIN 
              RFP$MAYBEPIC[OFFSET+RTKN] = FALSE;
              END 
          C<RFPI$NXSTRGC,30>RFP$STRING[RFPI$NXSTRGW] = C<0,30>SAREA[0]; 
          C<RFPI$NXSTRGC,230>RFP$STRING[RFPI$NXSTRGW+3] = 
              C<0,230>SAREA[3]; 
  
#     POINT WORD AND CHAR TO JUST BEYOND THE END OF THIS TOKEN         #
  
          NWORDS = (RFPI$NXSTRGC + SAREALENGTH)/10; 
          RFPI$NXSTRGW = RFPI$NXSTRGW + NWORDS; 
          RFPI$NXSTRGC = RFPI$NXSTRGC + SAREALENGTH - 10*NWORDS;
          IF RFPI$NXSTRGW GQ RFPI$MXSTRGW 
          THEN                         # GROW RFP$STRING               #
              BEGIN 
              CMM$GLV(RFPSTRNG, 26);
              RFPI$MXSTRGW = RFPI$MXSTRGW + 26; 
              C<0,20>RFP$STRING[RFPI$MXSTRGW] = " ";
              C<0,240>RFP$STRING[RFPI$MXSTRGW+2] = " "; 
              END 
  
          RETURN; 
          END 
CONTROL EJECT;
  
          PROC SETRAPTKN; 
  
#**       SETRAPTKN - SET UP ACTUAL PARAMETER TOKENS                   #
#                                                                      #
#         GIVEN-                                                       #
#                TOKEN IN SAREA WITH ITS ASSOCIATED CLAVARIABLES       #
#                                                                      #
#         DOES-                                                        #
#                PLACES THIS TOKEN IN RAP$STRING WITH TOKEN DELIMITERS #
#                MANAGES RAP$ ARRAYS                                   #
#                GROWS RAP$STRING AS NECCESSARY                        #
#                                                                      #
  
          BEGIN 
          RTKN = RTKN + 1;
          RAPI$NXTARAY = RAPI$NXTARAY + 1;
          OFFSET = RAP$INDEX[RNPAIRS+1];
          CMM$GLV(RAPARAY, 2);         # GROW RAPARAY                  #
  
#     IF NOT FIRST TOKEN SET UP TOKEN DELIMITER                        #
  
          IF NOT FIRSTAP
          THEN
              BEGIN 
              C<RAPI$NXSTRGC,1>RAP$STRING[RAPI$NXSTRGW] = "?";
              RAPI$NXSTRGC = RAPI$NXSTRGC + 1;
              IF RAPI$NXSTRGC EQ 10 
              THEN
                  BEGIN 
                  RAPI$NXSTRGC = 0; 
                  RAPI$NXSTRGW = RAPI$NXSTRGW + 1;
                  END 
              END 
          ELSE
              BEGIN 
              FIRSTAP = FALSE;
              END 
  
#     SET UP AP VALUES                                                 #
  
          RAP$TYPE[OFFSET+RTKN] = CLATYPE;
          RAP$VALUE[OFFSET+RTKN] = CLAVALUE;
          RAP$IFCOL[OFFSET+RTKN] = IFCOL; 
          RAP$SIGNSW[OFFSET+RTKN] = SIGNSW; 
          RAP$L[OFFSET+RTKN] = SAREALENGTH; 
          RAP$WO[OFFSET+RTKN] = RAPI$NXSTRGW; 
          RAP$CO[OFFSET+RTKN] = RAPI$NXSTRGC; 
          IF IFCOL
          THEN
              BEGIN 
              RAP$COL[OFFSET+RTKN] = CLACOLUMN; 
              END 
          C<RAPI$NXSTRGC,30>RAP$STRING[RAPI$NXSTRGW] = C<0,30>SAREA[0]; 
          C<RAPI$NXSTRGC,230>RAP$STRING[RAPI$NXSTRGW+3] = 
              C<0,230>SAREA[3]; 
  
#     POINT WORD AND CHAR TO JUST BEYOND THE END OF THIS TOKEN         #
  
          NWORDS = (RAPI$NXSTRGC + SAREALENGTH)/10; 
          RAPI$NXSTRGW = RAPI$NXSTRGW + NWORDS; 
          RAPI$NXSTRGC = RAPI$NXSTRGC + SAREALENGTH - 10*NWORDS;
          IF RAPI$NXSTRGW GQ RAPI$MXSTRGW 
          THEN                         # GROW RAP$STRING               #
              BEGIN 
              CMM$GLV(RAPSTRNG, 26);
              RAPI$MXSTRGW = RAPI$MXSTRGW + 26; 
              C<0,20>RAP$STRING[RAPI$MXSTRGW] = " ";
              C<0,240>RAP$STRING[RAPI$MXSTRGW+2] = " "; 
              END 
  
          RETURN; 
          END 
CONTROL EJECT;
 #     START OF REPLACE MAIN PROCEDURE   #
  
          GOTO STATE[RSTATE]; 
CONTROL EJECT;
  
#     STATE 1 - NORMAL REPLACE PROCESSING                              #
  
STATE1: 
  
          RTARGET;  # GO PLACE NEW TOKEN IN THE TARGET STRING          #
          IF EODREPL
          THEN   # END OF DATA ENCOUNTERED OR WINDING DOWN REPLACE PROC#
              BEGIN 
              IF NONSRCFPTKNS GQ RTI$MAXARRAY 
              THEN   # NO SOURCE TOKENS REMAINING IN TARGET            #
                  BEGIN 
                  RSTATE = INITIALIZE$; 
                  CSTATE = SVCURCSTATE; 
                  FREE$CMMBLKS
                  RETURN;  # TO TKNCLAS # 
                  END 
              END 
          ELSE
              BEGIN 
              IF MAXRFPTKNS NQ 1 AND RT$L[1] EQ 0 
              THEN   # STILL BUILDING TARGET STRING                    #
                  BEGIN 
                  TKNREADY = FALSE; 
                  RETURN;  # TO TKNCLAS # 
                  END 
              END 
  
#     LOOP THRU RFPS ATTEMPTING TO MATCH TARGET AGAINST THEM           #
  
          FOR RFP = 1 STEP 1 UNTIL RNPAIRS DO 
              BEGIN 
              RFPOFFSET = RFP$INDEX[RFP]; 
              W = RFP$WO[RFPOFFSET+1];
              C = RFP$CO[RFPOFFSET+1];
  
  
              IF RFP$NTKNS[RFP] EQ 1
  
              THEN   # FP SEQUENCE OF ONLY 1 TOKEN                  ***#
  
                  BEGIN 
                  IF MAXRFPTKNS EQ 1
                  THEN   # TARGET IN CLAVARIABLES                   ***#
                      BEGIN 
                      IF RFP$L[RFPOFFSET+1] EQ SAREALENGTH
                      THEN   # TARGET IS SAME LENGTH AS FP TOKEN       #
                          BEGIN 
                          IF # WITHIN BEAD FUNC AND STRINGS MATCH      #
                             (SAREALENGTH LQ 230 AND
                              C<C,SAREALENGTH>RFP$STRING[W] EQ
                              C<0,SAREALENGTH>SAREA[0]
                          OR # BEYOND BEAD FUNC AND STRINGS MATCH      #
                              C<C,30>RFP$STRING[W] EQ 
                              C<C,30>SAREA[0] AND 
                              C<C,SAREALENGTH-30>RFP$STRING[W+3] EQ 
                              C<0,SAREALENGTH-30>SAREA[3])
                          AND NOT CLAMOD
                          AND (CLATYPE NQ TKNTYPE"PIC"
                               OR RFP$MAYBEPIC[RFPOFFSET+1])
                          THEN   # WE HAVE A MATCH EXIT TO RSTATE6     #
                              BEGIN 
                              RAPMATCHCOL = CLACOLUMN;
                              FSTMATCHLINE = CLALINE; 
                              RFPTKNLIM = 1;
                              RSTATE = AP$TRGT$MAN$;
                              RTKN = 0; 
                              RTKNLIM = RAP$NTKNS[RFP]; 
                              SVCSTATE = 0; 
                              RAPOFFSET = RAP$INDEX[RFP]; 
                              MATCHED  # DEBUG PRINT LINES             #
                              GOTO STATE[RSTATE]; 
                              END   # MATCH                            #
                          END 
                      END 
                  ELSE   # TARGET IN RT$STRING                      ***#
                      BEGIN 
                      L = RT$L[1];
                      IF RFP$L[RFPOFFSET + 1] EQ L
                      THEN   # TARGET AND FP TOKEN SAME LENGTH         #
                          BEGIN 
                          IF # WITHIN BEAD FUNC AND STRINGS MATCH      #
                             (SAREALENGTH LQ 230 AND
                              C<C,L>RFP$STRING[W] EQ
                              C<0,L>RT$STRING[0]
                          OR # BEYOND BEAD FUNC AND STRINGS MATCH      #
                              C<C,30>RFP$STRING[W] EQ 
                              C<C,30>RT$STRING[0] AND 
                              C<C,L-30>RFP$STRING[W+3] EQ 
                              C<0,L-30>RT$STRING[3])
                          AND NOT CLAMOD
                          AND (RT$TYPE[RFPOFFSET+1 ]NQ TKNTYPE"PIC" 
                               OR RFP$MAYBEPIC[RFPOFFSET+1])
                          THEN   # WE HAVE A MATCH EXIT TO RSTATE6     #
                              BEGIN 
                              RFPTKNLIM = 1;
                              RAPMATCHCOL = RT$COLUMN[1]; 
                              FSTMATCHLINE = RT$LINE[1];
                              RSTATE = AP$TRGT$MAN$;
                              RTKN =0;
                              RTKNLIM = RAP$NTKNS[RFP]; 
                              SVCSTATE = 0; 
                              RAPOFFSET = RAP$INDEX[RFP]; 
                              MATCHED  # DEBUG PRINT LINES             #
                              GOTO STATE[RSTATE]; 
                              END 
                          END 
                      END   # TARGET IN RT$STRING                      #
  
                  END   # FP SEQUENCE OF ONLY 1 TOKEN                  #
  
              ELSE   # MULTI-TOKEN FORMAL PARAMETER                 ***#
                  BEGIN 
                  MATCH = TRUE; 
  
                  IF CHKPUNC
                  THEN   # PUNC TOKENS IN TARGET NEED TO SKIP THEM  ***#
                      BEGIN 
                      RT = 0; 
                      FOR I=1 STEP 1
                        WHILE I LQ RFP$NTKNS[RFP] AND MATCH DO
                          BEGIN   # LOOP THRU TOKENS                   #
                          RT = RT + 1;
                          J = RFPOFFSET + I;
                          RFPW = RFP$WO[J]; 
                          RFPC = RFP$CO[J]; 
                          RFPL = RFP$L[J];
                          FOR RT = RT 
                            WHILE RT$TYPE[RT] EQ TKNTYPE"PUNC"
                                  AND (RT$VALUE[RT] EQ ","
                                       OR RT$VALUE[RT] EQ ";") DO 
                              BEGIN 
                              RT = RT + 1;
                              END 
                          IF RFPL NQ RT$L[RT] 
                          THEN   # LENGTHS DIFFER FOR THESE TOKENS     #
                              BEGIN 
                              MATCH = FALSE;
                              END 
                          ELSE   # LENGTHS SAME FOR THESE TOKENS       #
                              BEGIN 
                              W = RT$WO[RT];
                              C = RT$CO[RT];
                              IF RFPL LQ 230
                              THEN   # WITHIN BEAD FUNC LIMITS         #
                                  BEGIN 
                                  IF C<RFPC,RFPL>RFP$STRING[RFPW] NQ
                                     C<C,RFPL>RT$STRING[W]
                                  THEN
                                      BEGIN 
                                      MATCH = FALSE;
                                      END 
                                  END 
                              ELSE   # BEYOND BEAD FUNC LIMITS         #
                                  BEGIN 
                                  IF C<RFPC,30>RFP$STRING[RFPW] NQ
                                     C<C,30>RT$STRING[W]
                                    OR
                                     C<RFPC,RFPL-30>RFP$STRING[RFPW+3]
                                     NQ C<C,RFPL-30>RT$STRING[W+3]
                                  THEN
                                      BEGIN 
                                      MATCH = FALSE;
                                      END 
                                  END 
                              IF (RT$TYPE[RT] EQ TKNTYPE"PIC" AND 
                                  NOT RFP$MAYBEPIC[J])
                                  OR RT$MOD[RT] 
                              THEN
                                  BEGIN 
                                  MATCH = FALSE;
                                  END 
                              END  # LENGTHS SAME FOR THESE TOKENS     #
                          END  # LOOP THRU TOKENS                      #
                      END   # SKIPING OF PUNC TOKENS                   #
                  ELSE   # NO PUNC TOKENS IN TARGET TO SKIP         ***#
                      BEGIN 
                      I = RFPOFFSET + RFP$NTKNS[RFP]; 
                      L = (10*RFP$WO[I] + RFP$CO[I] + 
                           RFP$L[I]) - (10*W + C);
                      RFPW = RFP$WO[RFPOFFSET+1]; 
                      RFPC = RFP$CO[RFPOFFSET+1]; 
                      W = 0;
                      FOR L=L WHILE L NQ 0 AND MATCH DO 
                         BEGIN   # LOOP THRU TARGET AND FP STRING      #
                         IF L GR 230
                         THEN   # MORE THAN 230 CHRS YET TO COMPARE    #
                             BEGIN
                             IF C<RFPC,230>RFP$STRING[RFPW] NQ
                                C<0,230>RT$STRING[W]
                             THEN 
                                 BEGIN
                                 MATCH = FALSE; 
                                 END
                             L = L - 230; 
                             RFPW = RFPW + 23;
                             W = W + 23;
                             END
                         ELSE   # LESS THAN 230 CHRS YET TO COMPARE    #
                             BEGIN
                             IF C<RFPC,L>RFP$STRING[RFPW] NQ
                                C<0,L>RT$STRING[W]
                             THEN 
                                 BEGIN
                                 MATCH = FALSE; 
                                 END
                             END
                             L = 0; 
                         END   # LOOP THRU TARGET AND FP STRING        #
                     FOR I = 1 STEP 1 
                       WHILE I LQ RFP$NTKNS[RFP] AND MATCH DO 
                         BEGIN
                         IF (RT$TYPE[I] EQ TKNTYPE"PIC" AND 
                             NOT RFP$MAYBEPIC[RFPOFFSET+I]) 
                             OR RT$MOD[I] 
                         THEN 
                             BEGIN
                             MATCH = FALSE; 
                             END
                         END
                     RT = RFP$NTKNS[RFP]; 
                     END   # NO PUNC TOKENS IN TARGET STRING           #
  
                  IF MATCH
                  THEN
                      BEGIN 
                      RAPMATCHCOL = RT$COLUMN[1]; 
                      FSTMATCHLINE = RT$LINE[1];
                      RFPTKNLIM = RT; 
                      RSTATE = AP$TRGT$MAN$;
                      RTKN = 0; 
                      RTKNLIM = RAP$NTKNS[RFP]; 
                      SVCSTATE = 0; 
                      RAPOFFSET = RAP$INDEX[RFP]; 
                      MATCHED          # DEBUG PRINT LINES             #
                      GOTO STATE[RSTATE]; 
                      END 
                  END   # MULTI-TOKEN FORMAL PARAMETER                 #
              END   # LOOP THRU FPS IN ATTEMPT TO MATCH TARGET         #
  
#     NO. MATCHES RETURN A TOKEN TO TKNCLASS                           #
  
          IF MAXRFPTKNS NQ 1
          THEN   # RETURN A TOKEN FROM TARGET                          #
              BEGIN 
              SAREALENGTH = RT$L[1];
              FOR I=0 STEP 1 UNTIL 25 DO
                  BEGIN 
                  C<0,10>SAREA[I] = " ";
                  END 
              IF SAREALENGTH LQ 230 
              THEN   # WITHIN BEAD FUNCTION                            #
                  BEGIN 
                  C<0,SAREALENGTH>SAREA[0] =
                    C<0,SAREALENGTH>RT$STRING[0]; 
                  END 
              ELSE   # BEYOND BEAD FUNCTION                            #
                  BEGIN 
                  C<0,30>SAREA[0] = C<0,30>RT$STRING[0];
                  C<0,SAREALENGTH>SAREA[3] =
                    C<0,SAREALENGTH>RT$STRING[3]; 
                  END 
              CLACOLUMN = RT$COLUMN[1]; 
              CLACOMMENT = RT$COMMENT[1]; 
              CLALCOLUMN = RT$LCOLUMN[1]; 
              CLALINE = RT$LINE[1]; 
              CLALVLN = RT$LVLN[1]; 
              CLAMOD = RT$MOD[1]; 
              SIGNSW = RT$SIGNSW[1];
              CLATYPE = RT$TYPE[1]; 
              CLAVALUE = RT$VALUE[1]; 
              CLAVLN = RT$VLN[1]; 
              END 
  
              TKNREADY = TRUE;
              RETURN; 
CONTROL EJECT;
  
#     STATE 2 - REPLACE STATEMENT INITIALIZATION                       #
  
STATE2: 
  
#     REPLACE STATEMENT IS NON-STANDARD COBOL                          #
  
          SSDIAGS(D1139); 
  
#     EXAMINE CURRENT TOKEN                                            #
  
          TKNREADY = FALSE; 
          IF CLATYPE EQ TKNTYPE"AW" AND C<0,4>SAREA[0] EQ "OFF" 
          THEN
              BEGIN 
              REPLACEOFF = TRUE;
              RETURN; 
              END 
  
          IF REPLACEOFF 
          THEN
              BEGIN 
              REPLAC$MODE = FALSE;
              REPLACEOFF = FALSE; 
              IF CLATYPE EQ TKNTYPE"PUNC" AND C<9,1>CLAVALUE EQ "." 
              THEN
                  BEGIN 
                      $BEGIN
                      IF BUG020C$CPY
                      THEN
                          BEGIN 
                          LINE =
                          "??? REPLACE OFF SEEN REPLACE TURNED OFF ???";
                          CBLIST(1,LINE,43);
                          END 
                      $END
                  RETURN; 
                  END 
              END 
  
#     CHECK FOR ILLEGAL PERIOD                                         #
  
          IF CLATYPE EQ TKNTYPE"PUNC" AND C<9,1>CLAVALUE EQ "." 
          THEN   # PERIOD IN MIDDLE OF REPLACE STMT NO OFF OR TEXTS    #
              BEGIN 
              SSDIAGS(D1118); 
              REPLAC$MODE = FALSE;
              RSTATE = ERROR$;
              RETURN;                  # RETURN                        #
              END 
  
#     CHECK FOR END OF DATA                                            #
  
          IF CLATYPE EQ TKNTYPE"EOD"
          THEN   # END OF DATA OCCURED WHILE PROCESSING REPLACE STMT   #
              BEGIN 
              SSDIAGS(D1121); 
              TKNREADY = TRUE;
              REPLAC$MODE = FALSE;
              RSTATE = ERROR$;
              RETURN; 
              END 
  
  
#     ALLOCATE REPLACE FORMAL AND ACTUAL PARAMETER CMM BLOCKS          #
  
          RGROUP$REPL = CMM$AGR(1);    # ALLOCATE BELOW HHA            #
  
          CMM$ALV(1,1,3,RGROUP$REPL,P<RAPNTKS>,0);
  
          CMM$ALV(1,1,3,RGROUP$REPL,P<RAPARAY>,0);
  
          CMM$ALV(4+26,1,3,RGROUP$REPL,P<RAPSTRNG>,0);
  
          CMM$ALV(1,1,3,RGROUP$REPL,P<RFPNTKS>,0);
  
          CMM$ALV(1,1,3,RGROUP$REPL,P<RFPARAY>,0);
  
          CMM$ALV(4+26,1,3,RGROUP$REPL,P<RFPSTRNG>,0);
  
  
#     INITIALIZATION FOR PROCESSING NEW REPLACE STATEMENT              #
  
          CHKPUNC = FALSE;
          EODREPL = FALSE;
          FIRSTAP = TRUE; 
          FIRSTFP = TRUE; 
          FSTPTDELIM = FALSE; 
          LSTPTDELIM = FALSE; 
          LSTTKNP = FALSE;
          MAXRFPTKNS =0;
          NXTMAYBEPSTX = FALSE; 
          NONSRCFPTKNS = 0; 
          RAPI$MXSTRGW = 4; 
          RAPI$NXSTRGC = 0; 
          RAPI$NXSTRGW = 0; 
          RAPI$NXTARAY = 0; 
          C<0,240>RAP$STRING[0] = " "; # CLEAR ACTUAL PARAMETER STRING #
          C<0,60>RAP$STRING[24] = " "; # CLEAR ACTUAL PARAMETER STRING #
          RFPI$MXSTRGW = 4; 
          RFPI$NXSTRGC = 0; 
          RFPI$NXSTRGW = 0; 
          RFPI$NXTARAY = 0; 
          C<0,240>RFP$STRING[0] = " ";
          C<0,60>RFP$STRING[24] = " ";
          RNPAIRS = 0;
          RPLGRPNOTFRE = TRUE;
          RSTATE = PSDO$TXT$1$;        # INITIALIZE TO PSDO-TXT-1 MODE #
          RTKN = 0; 
  
          $BEGIN
          IF BUG020C$CPY
          THEN
              BEGIN 
              LINE =
              "????? REPLACE VERB SEEN INITIALIZATION COMPLETE?????"; 
              CBLIST(1, LINE, 52);
              LINE = "?????? CMM BLOCKS FOR AP , FP ARRAYS ALLOCATED??";
              CBLIST(1, LINE, 48);
              END 
          $END
  
#      FALL THROUGH TO PSDO$TXT$1                                      #
CONTROL EJECT;
  
#     STATE 3 - PROCESSING OF PSEUDO-TEXT-1 AND END OF REPLACE STMT    #
  
STATE3: 
  
          IF CLATYPE EQ TKNTYPE"PTDELIM"
          THEN             # PSEUDO-TEXT DELIMITER SEEN                #
  
              BEGIN  #PROCESS PSEUDO-TEXT-DELIMITER                    #
              IF FSTPTDELIM 
              THEN   # FIRST PSEUDO-TEXT DELIMITER SEEN THIS IS LAST   #
                     # PROCESS PUNCTUATION IF ANY AND EXIT             #
                  BEGIN 
                  LSTPTDELIM = TRUE;
                  IF NXTMAYBEPSTX 
                  THEN   # THIS PSEUDO-TEXT CONSISTS OF PUNC. ONLY     #
                      BEGIN   #PROCESS AS SUCH                         #
                      CHKPUNC = TRUE;  # PUNCS SHALL BE REPLACED       #
                      PUNCSVSAREA == C<0,10>SAREA[0];  # PLACE PUNC IN# 
                      SAREALENGTH = 1;
                      SETRFPTKN;             #SAREA FOR SETRFPTKN CALL# 
                      PUNCSVSAREA == C<0,10>SAREA[0];  # RESTORE SAREA# 
                      SAREALENGTH = 0;
                      $BEGIN
                      IF BUG020C$CPY
                      THEN
                          BEGIN 
                          LINE = " PUNCTUATION IS BEING REPLACED ???";
                          CBLIST(LISTCTL"LINE", LINE, 34);
                          END 
                      $END
                      END 
                  ELSE   # PSEUDO-TEXT-1 CONSISTS OF MORE THAN PUNCS   #
                      BEGIN 
                      IF RTKN EQ 0
                      THEN  # PSEUDO-TEXT-1 MISSING DIAGNOSE           #
                          BEGIN 
                          SSDIAGS(D1124); 
                          RSTATE = ERROR$;
                           FSTPTDELIM = FALSE;
                           RETURN;
                          END 
                      END 
                  RSTATE = RSVDWRD$BY$; 
                  RFP$NTKNS[RNPAIRS+1] = RTKN;
                  END   # LAST PSEUDO-TEXT DELIMITER PROCESSING        #
  
              ELSE   # THIS IS THE FIRST PSEUDO-TEXT DELIMITER FOR PT-1#
  
                  BEGIN 
                  FSTPTDELIM = TRUE;
                  NXTMAYBEPUNC = TRUE;
                  CMM$GLV(RAPNTKS, 1); # GROW RAP$ARRAY                #
                  CMM$GLV(RFPNTKS, 1); # GROW RAP$ARRAY                #
                  RFP$INDEX[RNPAIRS+1] = RFPI$NXTARAY;
                  RAP$INDEX[RNPAIRS+1] = RAPI$NXTARAY;
                  END 
  
              END   # PROCESSING OF PSEUDO-TEXT DELIMITER              #
  
          ELSE   # CLATYPE IS NOT PSEUDO-TEXT DELIMITER                #
  
              BEGIN 
  
              IF NXTMAYBEPSTX 
              THEN   # IGNORE PUNCTUATION IN THIS FP TEXT              #
                  BEGIN 
                  NXTMAYBEPSTX = FALSE; 
                  NXTMAYBEPUNC = FALSE; 
                  END 
  
  
              IF CLATYPE EQ TKNTYPE"EOD"
              THEN   # DIAG. EOD IN MIDDLE OF PT-1 AND EXIT            #
                  BEGIN 
                  SSDIAGS(D1127); 
                  FREE$CMMBLKS
                  REPLAC$MODE = FALSE;
                  RSTATE = ERROR$;
                  TKNREADY = TRUE;
                  RETURN; 
                  END 
  
              IF FSTPTDELIM 
              THEN   # WE HAVE SEEN THE FIRST PT-DELIM SO              #
  
                  BEGIN   # PROCESS THE TEXT                           #
                  IF CLATYPE EQ TKNTYPE"PUNC" 
                     AND C<9,1>CLAVALUE EQ ","
                     OR C<9,1>CLAVALUE EQ ";" 
                  THEN    # THIS TOKEN IS A PUNCTUATION TOKEN          #
                      BEGIN 
                      IF NXTMAYBEPUNC 
                      THEN         # SAVE IT                           #
                          BEGIN 
                          PUNCSVSAREA = C<9,1>CLAVALUE; 
                          NXTMAYBEPSTX = TRUE;
                          END 
                      END 
                  ELSE    # THIS IS NOT A PUNC TOKEN SO STORE IT IN    #
                      BEGIN                            # RFP$STRING    #
                      SETRFPTKN;
                      END 
                  NXTMAYBEPUNC = FALSE; 
                  END 
  
              ELSE   # WE HAVE NOT SEEN FIRST PSEUDO-TEXT DELIMITER    #
  
                  BEGIN 
                  IF CLATYPE EQ TKNTYPE"PUNC" 
                     AND C<9,1>CLAVALUE EQ "."
                  THEN   # THIS IS REPLACE STMTS CLOSING PERIOD        #
  
                      BEGIN   # WRAP UP REPLACE STMT PROCESSING        #
                                # ALLOCATE AND GROW TARGET ARRAYS      #
                      IF MAXRFPTKNS NQ 1
                      THEN
                          BEGIN 
                          IF CHKPUNC
                          THEN
                              I = 4*MAXRFPTKNS; 
                          ELSE
                              I = 2*MAXRFPTKNS; 
                          RTI$MAXARRAY = I/2; 
                          CMM$ALV(I,1,3,RGROUP$REPL,P<RTARRAY>,0);
                          RTI$MAXSTRGW = (MAXRFPTKNS+9)/10 + 3; 
                          CMM$ALV(RTI$MAXSTRGW+26,1,3,RGROUP$REPL,
                            P<RTSTRNG>,0);
                          FOR I=1 STEP 1 UNTIL RTI$MAXARRAY DO
                              BEGIN   # FILL TARGET WITH NULL TOKENS   #
                              RT$WO[I] = (I-1)/10;
                              RT$CO[I] = I - 1 - 10*RT$WO[I]; 
                              RT$L[I] = 0;
                              END 
                          RT$LSTRING = RTI$MAXARRAY - 1;
                          END 
                      ELSE
                          BEGIN 
                          RTI$MAXARRAY = 0; 
                          END 
                      NONSRCFPTKNS = 0; 
                      RSTATE = NORMAL$; 
                      END 
  
                  ELSE   # THIS TOKEN NOT CLOSING PERIOD               #
  
                      BEGIN 
                      IF NOT (CLATYPE EQ TKNTYPE"PUNC"
                              AND C<9,1>CLAVALUE EQ "," 
                              OR C<9,1>CLAVALUE EQ ";") 
                      THEN   # PSEUDO-TEXT-1 MISSING DIAGNOSE          #
                          BEGIN 
                          SSDIAGS(D1124); 
                          RSTATE = ERROR$;
                          END 
                      END 
                     #ELSE THIS TOKEN IS A SEPERATOR COMMA             #
  
                  END   # HAVING NOT SEEN FIRST PT DELIMITER           #
  
              END   # CLATYPE NOT PSEUDO-TEXT DELIMITER                #
  
          RETURN;   # TO REPLACE CALLER FROM STATE 3                   #
CONTROL EJECT;
  
#     STATE 4 - RESERVED WORD BY PROCESSOR                             #
  
STATE4: 
  
#     EXAMINE CURRENT TOKEN IF ITS THE RW "BY" GREAT, IF NOT DIAGNOSE  #
  
          IF C<0,3>SAREA[0] NQ "BY " OR CLATYPE NQ TKNTYPE"AW " 
          THEN   # MISSING RW BY SEPERATING PT-1 FROM PT-2             #
              BEGIN 
              SSDIAGS(D1106); 
              RSTATE = ERROR$;
              GOTO STATE[RSTATE]; 
              END 
          ELSE  # WE HAVE SEEN THE RW "BY" INITIALIZE TO PROCESS PT-2  #
              BEGIN 
              RTKN = 0; 
              FSTPTDELIM = FALSE; 
              LSTPTDELIM = FALSE; 
              RSTATE = PSDO$TXT$2$; 
              RETURN; 
              END 
CONTROL EJECT;
  
#     STATE 5 - PSEUDO-TEXT-2 PROCESSOR                                #
  
STATE5: 
  
#     PROCESS THE CURRENT TOKEN BY DETERMINING WHAT IT IS              #
  
          IF CLATYPE EQ TKNTYPE"PTDELIM"
          THEN   # WE HAVE A PSEUDO-TEXT DELIMITER PROCESS ACCORDINGLY #
              BEGIN 
              IF FSTPTDELIM   # ALREADY SEEN THIS MUST BE TH CLOSING PT#
              THEN            # DELIM SO CLOSE DOWN AND SET UP TO      #
                  BEGIN       # PROCESS IN PSDO$TXT$1$                 #
                  RSTATE = PSDO$TXT$1$; 
                  RAP$NTKNS[RNPAIRS+1] = RTKN;
                  RNPAIRS = RNPAIRS + 1;
                  FSTPTDELIM = FALSE; 
                  LSTPTDELIM = FALSE; 
                  RTKN = 0; 
                  IF MAXRFPTKNS LQ RFP$NTKNS[RNPAIRS] 
                  THEN  #THIS FP CONTAINS MORE TOKENS THAN ANY         #
                      BEGIN   # PREVIOUS ONE STORE IT AWAY             #
                      MAXRFPTKNS = RFP$NTKNS[RNPAIRS];
                      END 
                  END 
              ELSE   # THIS MUST BE THE FIRST PTDELIM                  #
                  BEGIN 
                  FSTPTDELIM = TRUE;
                  PSEUDOLINE = CLALINE; 
                  IFCOL = FALSE;
                  RETURN; 
                  END 
              END 
  
          ELSE  # WE DO NOT HAVE A PTDELIM WHAT IS IT                  #
  
              BEGIN 
              IF CLATYPE EQ TKNTYPE"EOD"
              THEN   # WE HAVE AN EOD WHILE PROCESSING PSDO-TXT-2      #
                  BEGIN   # DIAGNOSE AND RETURN TO TKNCLAS             #
                  SSDIAGS(D1133); 
                  FREE$CMMBLKS
                  REPLAC$MODE = FALSE;
                  RSTATE = ERROR$;
                  TKNREADY = TRUE;
                  RETURN; 
                  END 
  
              IF FSTPTDELIM 
              THEN   # MUST BE LEGAL PSEUDO-TEXT PROCESS AS SUCH       #
                  BEGIN 
                  IF NOT IFCOL
                  THEN   # TKNS THUS FAR HAVE NO PREFERED COL          #
                      BEGIN 
                      IF CLALINE NQ PSEUDOLINE
                      THEN  # REPLACE TKNS MUST HAVE PREFERED COLS     #
                          BEGIN   # SO INDICATE SO                     #
                          IFCOL = TRUE; 
                          END 
                      END 
                  SETRAPTKN;
                  END   # LEGAL PSEUDO TEXT                            #
              ELSE   #   PSEUDO-TEXT-2 IS MISSING DIAGNOSE             #
                  BEGIN 
                  SSDIAGS(D1130); 
                  RSTATE = ERROR$;
                  GOTO STATE[RSTATE]; 
                  END 
  
              RETURN; 
              END  # OF NOT HAVING PTDELIM                             #
CONTROL EJECT;
  
          $BEGIN
          IF BUG020C$CPY
          THEN
              BEGIN 
              CBLIST(LISTCTL"LINE", " ", 1);
              LINE =
                "RFP$NTKNS[?]=?? RFP$INDEX=?? RAPNTKNS=?? RAP$INDEX=??";
              C10 = DEC(RNPAIRS); 
              C<10,1>LINE = C<0,1>C10;
              C10 = DEC(RFP$NTKNS[RNPAIRS]);
              C<13,2>LINE = C<0,2>C10;
              C10 = DEC(RFP$INDEX[RNPAIRS]+1);
              C<26,2>LINE = C<0,2>C10;
              C10 = DEC(RAP$NTKNS[RNPAIRS]);
              C<38,2>LINE = C<0,2>C10;
              C10 = DEC(RAP$INDEX[RNPAIRS]+1);
              C<51,2>LINE = C<0,2>C10;
              CBLIST(LISTCTL"LINE", LINE, 53);
              OFFSET = RFP$INDEX[RNPAIRS];
              FOR RTKN = 1 STEP 1 UNTIL RFP$NTKNS[RNPAIRS] DO 
                  BEGIN 
                  LINE =
             "RFP$WO[999]=999  RFP$CO=99  RFP$L=999  RFP$MAYBEPIC=TRUE";
                  C10 = DEC(OFFSET+RTKN); 
                  C<7,3>LINE = C<0,3>C10; 
                  C10 = DEC(RFP$WO[OFFSET+RTKN]); 
                  C<12,3>LINE = C<0,3>C10;
                  C10 = DEC(RFP$CO[OFFSET+RTKN]); 
                  C<24,3>LINE = C<0,2>C10;
                  C10 = DEC(RFP$L[OFFSET+RTKN]);
                  C<34,3>LINE = C<0,3>C10;
                  IF NOT RFP$MAYBEPIC[OFFSET+RTKN]
                  THEN
                      C<52,5>LINE = "FALSE";
                  CBLIST(LISTCTL"LINE", LINE, 57);
                  END 
              W = RFP$WO[OFFSET+1];    # WORK INDEX TO FIRST TOKEN     #
              C = RFP$CO[OFFSET+1];    # CHAR INDEX TO FIRST TOKEN     #
              I = OFFSET+RFP$NTKNS[RNPAIRS];# RFPARAY INDX TO LAST TKN #
              I = (10*RFP$WO[I] + RFP$CO[I] + RFP$L[I]) - (10*W + C); 
              IF I GR 130 
              THEN
                  I = 130;
              C<0,130>LINE = C<C,I>RFP$STRING[W]; 
              FOR I = 7 STEP 10 UNTIL 127 DO
                  BEGIN 
                  IF C<I,2>LINE EQ "::" 
                  THEN
                      C<I,2>LINE = "^^";
                  END 
              CBLIST(LISTCTL"LINE", LINE, 130); 
              OFFSET = RAP$INDEX[RNPAIRS];
              FOR RTKN = 1 STEP 1 UNTIL RAP$NTKNS[RNPAIRS] DO 
                  BEGIN 
                  LINE = "RAP$TYPE=[999]=SPECREG  VALUE=777777 WO=999 CO
=99 L=999  IFCOL=FALSE  COL=99  ";
                  C10 = DEC(OFFSET+RTKN); 
                  C<10,3>LINE = C<0,3>C10;
                  C<15,7>LINE = BUG$TKNTYPE[RAP$TYPE[OFFSET+RTKN]]; 
                  C<30,6>LINE = OCT(RAP$VALUE[OFFSET+RTKN], 14, 6); 
                  C10 = DEC(RAP$WO[OFFSET+RTKN]); 
                  C<40,3>LINE= C<0,3>C10; 
                  C10 = DEC(RAP$CO[OFFSET+RTKN]); 
                  C<47,2>LINE = C<0,2>C10;
                  C10 = DEC(RAP$L[OFFSET+RTKN]);
                  C<52,3>LINE = C<0,3>C10;
                  IF RAP$IFCOL[OFFSET+RTKN] 
                  THEN
                      C<63,5>LINE = "TRUE ";
                  C10 = DEC(RAP$COL[OFFSET+RTKN]);
                  C<74,2>LINE = C<0,2>C10;
                  IF RAP$SIGNSW[OFFSET+RTKN]
                  THEN
                      C<77,1>LINE = "S";
                  CBLIST(LISTCTL"LINE", LINE, 78);
                  END 
              IF RAP$NTKNS[RNPAIRS] NQ 0
              THEN
                  BEGIN 
                  W = RAP$WO[OFFSET+1];    # WORD INDEX TO FIRST TOKEN #
                  C = RAP$CO[OFFSET+1];    # CHAR INDEX TO FIRST TOKEN #
                  I = OFFSET+RAP$NTKNS[RNPAIRS]; # RAP INDX TO LST TKN #
                  I = (10*RAP$WO[I] + RAP$CO[I] + RAP$L[I]) 
                      - (10*W + C); 
                  IF I GR 130 
                  THEN
                      I = 130;
                  C<0,130>LINE = C<C,I>RAP$STRING[W]; 
                  FOR I = 7 STEP 10 UNTIL 127 DO
                      BEGIN 
                      IF C<I,2>LINE EQ "::" 
                      THEN
                          C<I,2>LINE = "^^";
                      END 
                  CBLIST(LISTCTL"LINE", LINE, 130); 
                  END 
              RTKN = 0; 
              END 
          $END
  
  
          RETURN;  # TO TKNCLAS                                        #
CONTROL EJECT;
  
#     STATE 6 - SENDS AP TOKENS TO TKNCLAS AND MANIPULATES RTARGET     #
  
STATE6: 
  
          RTKN = RTKN + 1;
          IF RTKN GR RTKNLIM
          THEN   # WE HAVE EXHAUSTED THE RAP$STRING                    #
  
              BEGIN 
              IF RTKN GR RFPTKNLIM
              THEN   # ALL REPLACED TKNS SHIFTED OUT OF TARGET STRING  #
                  BEGIN   # RETURN TO NORMAL REPLACE STATE, RETURN     #
                  RSTATE = NORMAL$; 
                  IF RTKNLIM GQ RFPTKNLIM 
                  THEN   # SET TKNCLAS BACK TO PREVIOUS STATE          #
                      BEGIN 
                      CSTATE = SVCSTATE;
                      TKNREADY = FALSE; 
                      SVCSTATE = 0; 
                      RETURN; 
                      END 
                  GOTO STATE[RSTATE]; 
                  END 
              ELSE  # SHIFT TARGET STRING BY ONE AND APPEND NEW TOKEN  #
                  BEGIN 
                  RTARGET;   # SHIFT THEN ADD NEW TOKEN TO TARGET      #
                  TKNREADY = FALSE; 
                  END 
              END 
  
          ELSE   # SEND AP TOKEN TO TKNCLAS, ADD NEW TOKEN TO TARGET   #
  
              BEGIN 
              IF RTKN GQ RFPTKNLIM AND SVCSTATE EQ 0
              THEN   # RTARGET FULL STOP RETRIEVING NEW TOKENS         #
                  BEGIN 
                  SVCSTATE = CSTATE;
                  CSTATE = 6; 
                  END 
              IF RTKN NQ 1
              THEN
                  BEGIN 
                  RTARGET;   # SHIFT THEN ADD NEW TOKEN TO TARGET     # 
                  END 
  
#     BLANK OUT SAREA                                                  #
  
              FOR I=0 STEP 1 UNTIL 25 DO
                  BEGIN 
                  C<0,10>SAREA[I] = " ";
                  END 
  
#     MOVE ACTUAL PARAMETER TOKEN TO SAREA                             #
  
              C = RAP$CO[RAPOFFSET+RTKN]; 
              W = RAP$WO[RAPOFFSET+RTKN]; 
              SAREALENGTH = RAP$L[RAPOFFSET+RTKN];
              IF SAREALENGTH LQ 230 
              THEN   # WITHIN BEAD FUNCTION LIMITS                     #
                  BEGIN 
                  C<0,SAREALENGTH>SAREA[0] =
                    C<C,SAREALENGTH>RAP$STRING[W];
                  END 
              ELSE  # BEYOND BEAD FUNCTIONS LIMITS                     #
                  BEGIN 
                  C<0,30>SAREA[0] = C<0,30>RAP$STRING[W]; 
                  C<0,SAREALENGTH-30>SAREA[3]=
                    C<C,SAREALENGTH-30>RAP$STRING[W+3]; 
                  END 
  
#     SET UP CLACOLUMN                                                 #
  
              IF RAP$IFCOL[RAPOFFSET+RTKN]
              THEN   # THIS TOKEN HAS A PREFERED COLUMN                #
                  BEGIN 
                  CLACOLUMN = RAP$COL[RAPOFFSET+RTKN];
                  END 
              ELSE   # NO PREFERED COLUMN FOR THIS TOKEN               #
                  BEGIN  # ASSIGN FST REPLCED TKNS COL VALUE + LGTH    #
                  CLACOLUMN = RAPMATCHCOL;   # OF ANY PREV RAP TKNS    #
                  RAPMATCHCOL = RAPMATCHCOL + RAP$L[RAPOFFSET+RTKN];
                  END 
  
#     SET UP CLA VARIABLES                                             #
  
              CLATYPE = RAP$TYPE[RAPOFFSET+RTKN]; 
              CLAVALUE = RAP$VALUE[RAPOFFSET+RTKN]; 
              CLALINE = FSTMATCHLINE; 
              SIGNSW = RAP$SIGNSW[RAPOFFSET+RTKN];
              CLAVLN = 0;    # IGNORE THIS TOKEN DOES NOT EFFECT PLINE #
              TKNREADY = TRUE;
              END   # SENDING AP TOKEN TO TKNCLAS                      #
  
          RETURN; 
CONTROL EJECT;
  
#     STATE 7 - ERROR PROCESSING STATE -- SEARCHING FOR TERM. PERIOD   #
  
STATE7: 
  
          IF CLATYPE EQ TKNTYPE"EOD"
          THEN   # EOD FOUND BEFORE TERMINATING PERIOD OF REPLACE STMT #
  
              BEGIN 
              SSDIAGS(D1136); 
              TKNREADY = TRUE;
              END 
  
          ELSE   # NOT EOD, CONTINUE TO IDENTIFY TOKEN                 #
  
              BEGIN 
              TKNREADY = FALSE; 
              IF CLATYPE EQ TKNTYPE"PTDELIM" AND FSTPTDELIM 
              THEN    # WE JUST LEFT A PSEUDO-TEXT                     #
  
                  BEGIN 
                  FSTPTDELIM = FALSE; 
                  RETURN; 
                  END 
  
              ELSE    # WE ARE NOT LEAVING A PSEUDO-TEXT               #
  
                  BEGIN 
                  IF FSTPTDELIM 
                  THEN    # WE ARE IN A PSEUDO-TEXT                    #
                     BEGIN
                     RETURN;
                     END
  
                  ELSE    # WE ARE NOT IN A PSEUDO-TEXT                #
                      BEGIN 
                      IF CLATYPE EQ TKNTYPE"PTDELIM"
                      THEN   # WE ARE ENTERING A PSEUDO-TEXT STRING    #
                          BEGIN 
                          FSTPTDELIM = TRUE;
                          RETURN; 
                          END 
                      ELSE   # WE ARE NOT ENTERING A PSEUDO-TEXT STRING#
                          BEGIN 
                          IF NOT (CLATYPE EQ TKNTYPE"PUNC" AND
                                  C<9,1>CLAVALUE EQ ".")
                          THEN   # THIS IS NOT TERMINATING PERIOD CONT.#
                              BEGIN 
                              RETURN; 
                              END 
                          #ELSE FALLOUT OF NESTS AND TERMINATE         #
                          END 
                      END    # WE WERE NOT ENTERING A PSEUDO-TEXT STRNG#
                  END   # WE WERE NOT LEAVING A PSEUDO TEXT            #
              END   # NOT EOD TOKEN IDENTIFIED                         #
  
          FREE$CMMBLKS
          REPLAC$MODE = FALSE;
          END # OF REPLACE                                             #
  
          TERM
