*DECK NEWLINE 
USETEXT CCTTEXT 
USETEXT SSTEXT
          PROC  NEWLINE;
  
#**       NEWLINE -  SET UP A NEW LINE                                 #
#                                                                      #
#     CALLING SEQUENCE-                                                #
#         CALL   NEWLINE                         (FROM COMPASS)        #
#                                                                      #
#     GIVEN-                                                           #
#         BETWEEN = TRUE IFF BETWEEN TOKENS.                           #
#         CCTPSQ = TRUE IFF USER SEQUENCE NUMBERS.                     #
#         CCTSOURCLIST = TRUE IFF SOURCE LISTING DESIRED.              #
#         LIBFET = FET FOR LIBRARY.                                    #
#         INFET = FET FOR SOURCE INPUT.                                #
#         READLIB = TRUE IFF READING VIA LIBFET.                       #
#                                                                      #
#     DOES-                                                            #
#         IF CCTSOURCLIST THEN PRINTS APPROPRIATE SOURCE LINES.        #
#         IF SOURCE LINE CANNOT BE RETURNED TO CALLER  THEN            #
#           SETS ENDCHRS = TRUE                                        #
#         ELSE                                                         #
#           PLI$CURRENT = INDEX TO CURRENT LINE                        #
#           TKNFROMLIB = TRUE IFF LINE IS FROM LIBRARY                 #
#           LINENO = CURRENT USER LINE NUMBER (FOR DIAGNOSTICS)        #
#           ADDRLIN = ADDRESS OF CURRENT PACKED SOURCE LINE            #
#           NEWCOL7 = NEXT LINE-S COLUMN 7 CHARACTER.                  #
#                                                                      #
#     METHOD-                                                          #
#         THE PHILOSPHY OF FORMATTING THE PRINT LINE IS THAT IT SHOULD #
#         CLOSELY REFLECT THE ORIGINAL LINE, WHETHER FROM SOURCE INPUT #
#         OR A LIBRARY.  THE FOLLOWING MODIFICATIONS ARE POSSIBLE AND  #
#         ARE FLAGGED-                                                 #
#             7 = COLUMN 7 HAS BEEN MODIFIED.                          #
#                   (A TOKEN ORIGINALLY ON THE PREVIOUS LINE WAS       #
#                   CONTINUED WITH A HYPHEN IN THIS LINE-S COLUMN 7,   #
#                   BUT AFTER REPLACEMENT THE HYPHEN IS NOT NEEDED.)   #
#                                                                      #
#             R = ONE OR MORE TOKENS HAVE BEEN REPLACED.               #
#                                                                      #
#            -- = THIS NON-BLANK, NON-COMMENT LINE IS IGNORED.         #
#                   (IT CONTAINS ALL OR PART OF A COPY STATEMENT       #
#                   WHICH GENERATES SUBSEQUENT LINES.)                 #
#                                                                      #
#             + = THIS LINE, NOT FROM SOURCE INPUT OR A LIBRARY, HAS   #
#                   BEEN GENERATED.   (IT IS NEEDED TO CONTINUE A      #
#                   REPLACING TOKEN, OR TO LIST TOKENS THAT OCURRED    #
#                   ON A LINE BEFORE OR AFTER A COPY STATEMENT.)       #
#                                                                      #
#         LINES READ FROM THE LIBRARY ARE DISTINGUISHED BY PRINTING    #
#         THE UPDATE REFERENCE AS <IDENT>.<NUMBER>, AND STARTING IN    #
#         COLUMN 75 INSTEAD OF 74.                                     #
#                                                                      #
#         THE CHARACTER IN COLUMN 7 OF THE NEXT REAL SOURCE LINE       #
#         MUST BE KNOWN IN ORDER TO DETERMINE THE STATUS OF TRAILING   #
#         BLANKS ON THE CURRENT REAL SOURCE LINE,  SO TWO REAL SOURCE  #
#         LINES MUST BE STACKED.   THE SITUATION IS COMPLICATED BECAUSE#
#         THE USER CAN INSERT INDEFINITELY MANY BLANK OR COMMENT       #
#         LINES BETWEEN THE TWO REAL SOURCE LINES.                     #
#                                                                      #
#         MORE PROBLEMS ARISE WHEN *COPY ... REPLACING ...* HAS        #
#         CAUSED READING FROM THE LIBRARY.   THE LISTING MUST SHOW     #
#         THE LINE AFTER REPLACEMENT.   HOWEVER, THE LAST TOKEN ON     #
#         THE LINE MIGHT NOT BE COMPLETED AND REPLACED UNTIL           #
#         CHARACTERS FROM ONE OR MORE SUBSEQUENT LINES HAVE BEEN       #
#         ANALYZED WITH INDEFINITELY MANY BLANK OR COMMENT LINES       #
#         BETWEEN EACH SUBSEQUENT LINE).   NOTE THAT A REPLACEABLE     #
#         TOKEN COULD BE A LONG NON-NUMERIC LITERAL SPANNING SEVERAL   #
#         LINES.   ALSO, CONSISTENT HANDLING OF THE LAST CONTINUATION  #
#         LINE REQUIRES THE COLUMN 7 CHARACTER OF THE NEXT REAL SOURCE #
#         LINE.                                                        #
#                                                                      #
#         CONSEQUENTLY, PRINT LINES WILL BE STACKED IN AN EXPANDABLE   #
#         BUFFER FROM THE TIME THEY ARE SET UP UNTIL THEY ARE PRINTED. #
#         LINES MAY BE ALTERED, DELETED OR ADDED IN THIS BUFFER BY THE #
#         *REPLACING* OR *COPY* PROCESSORS.                            #
#                                                                      #
#         AFTER ALL CHARACTERS FROM A PRINT LINE HAVE BEEN PROCESSED   #
#         AND MODIFICATION OF THE PRINT LINE IS NOT EVEN POTENTIALLY   #
#         POSSIBLE THEN THAT PRINT LINE IS READY TO BE PRINTED.        #
#         THIS HAPPENS WHEN READING FROM SOURCE  (WITHOUT *COMPILE     #
#         REPLACING ...*) OR READING FROM A LIBRARY WITHOUT            #
#         *COPY ... REPLACING ...*.  THIS CRITERION IS VALID EVEN WHEN #
#         THE LINE CONTAINS A COPY STATEMENT (THE *IGNORE* FLAG WILL   #
#         HAVE BEEN SET) OR WHEN THE NEXT LINE-S COLUMN 7 IS A HYPHEN. #
#                                                                      #
#         WHEN REPLACEMENT IS POSSIBLE ALL TOKENS TAKEN FROM A PRINT   #
#         MUST BE FINALIZED BEFORE THE LINE IS READY TO BE PRINTED.    #
#         THE EXCEPTION IS A LINE WITH A COPY STATEMENT, WHICH IS      #
#         IMMEDIATELY READY  (WITH THE *IGNORE* FLAG) EVEN IF TOKENS   #
#         FOLLOW THE COPY STATEMENT ON THE SAME LINE.                  #
#                                                                      #
#         VIRTUAL LINE NUMBERS (LOCAL TO THE TOKEN EXTRACTION ROUTINES)#
#         ARE ASSOCIATED WITH EACH TOKEN.   WHEN A TOKEN HAS BEEN      #
#         FINALIZED WITH A V.L.N. GREATER THAN THE V.L.N. O FTHE       #
#         EARLIEST NOT-READY LINE THEN THAT LINE HAS HAD ALL POSSIBLE  #
#         REPLACEMENT MODIFICATIONS AND IS READY TO BE PRINTED.        #
CONTROL EJECT;
  
          BEGIN 
  
          XREF               # INPUT PARAMETERS                        #
              BEGIN 
          ITEM HOLDDATECMP B; #TRUE IFF PARSING DATE-COMPILED # 
              ITEM  BETWEEN      B;    # IF BETWEEN TOKENS             #
              ITEM LISTID        C(10);   # LISTING HEADER ID          #
              ITEM LISTHED       C(10);   # LISTING HEADER             #
          ITEM STCOPY B;
              END 
  
          XREF               # EXTERNAL PROCEDURES                     #
              BEGIN 
              PROC  ABORTSS;           # ABORT SSCANNER                #
              PROC CBLIST;             # COBOL LISTER                  #
              PROC  GETPLINDEX;        # GET PRINT LINE INDEX          #
              PROC  PRINTIT;           # PRINT A LINE                  #
              PROC  READIT;            # READ A LINE                   #
              PROC  RELPLINDEX;        # RELEASE PRINT LINE INDEX      #
              END 
  
          ITEM  DEBUGCHAR    I;        # TO CHECK FOR COMMENTS         #
            ITEM  CARD         C(80);    # STATIC CARD BUFFER          #
          ITEM  FIRSTTIME    B = TRUE; # FIRST-TIME FLAG               #
          ITEM  FOUND        B;        #                               #
          ITEM  I            I;        # SCRATCH                       #
          ITEM  PREVPLILAST  I;        # PREVIOUS VALUE OF PLI$LAST    #
  
  
  
  
  
*CALL RALINE
  
*CALL SYSFET
  
CONTROL EJECT;
  
*CALL BUG020C$
  
*CALL LISTCTL 
  
          $BEGIN
  
          XREF
              BEGIN 
              FUNC  DEC      C(10);    # L.J.B.F. DECIMAL DISPLAY      #
              END 
  
          ITEM  C            I;        # COLUMN INDEX TO -LINE-        #
          ITEM  C10          C(10);    # SCRATCH                       #
          ITEM  LINE         C(150);   # DEBUG PRINT LINE              #
  
          $END
CONTROL EJECT;
  
#     IF FIRST TIME, THE INITIALIZE                                    #
  
          IF FIRSTTIME  THEN
              BEGIN 
              FOR I = 1 STEP 1 UNTIL PLN$UNUSED  DO 
                  BEGIN 
                  PL$INIT[I] = 0;      # INITIALIZE THE ENTRY          #
                  PL$NEXT[I] = I + 1;  # LINK TO NEXT LINE             #
                  END 
              PL$INIT[PLN$UNUSED] = 0; # INITIALIZE LAST ENTRY         #
  
              REPLACING = FALSE;
  
              PLI$FIRST = 1;
              PLI$LAST = 1; 
              PL$NEXT[1] = 0; 
              READIT(PLI$FIRST);       # READ A LINE INTO BUFFER       #
  
              IF EODFLAG  THEN
                  BEGIN                # NO LINE, JUST END-OF-DATA     #
                  ENDCHRS = TRUE;      # TELL *SETLINE*                #
#***#             RETURN; 
                  END 
  
              PLN$USED = 1; 
              PLN$UNUSED = PLN$UNUSED - 1;
              PLI$UNUSED = 2; 
  
              FOR I=I WHILE PL$COMMENT[PLI$LAST]
              DO
                  BEGIN 
                  PREVPLILAST = PLI$LAST; 
                  GETPLINDEX(PLI$LAST);     # GET INDEX TO PRINT LINE  #
                  PL$NEXT[PREVPLILAST] = PLI$LAST;
                  PL$INIT[PLI$LAST] = 0;
                  READIT(PLI$LAST);         # READ AGAIN               #
  
                  IF EODFLAG
                  THEN                 # NO DATA ALL COMMENT LINES     #
                      BEGIN 
                      PLI$LAST = 0; 
                      PL$NEXT[PREVPLILAST] = 0; 
                          $BEGIN
                          RETURN; # RETURN PAGE HEADINGS PRINTED       #
                          $END
                      LISTID = "NO-NAME";       # PLACE NO-NAME        #
                      CBLIST(4, LISTHED, 110);  # IN PAGE HEADINGS     #
                      IF CCTSOURCLIST 
                      THEN   # PRINT LINES REQUESTED                   #
                          BEGIN 
                          CBLIST(3," ",1);  # PAGE EJECT AND PRINT HEAD#
                          END 
                      RETURN; 
                      END 
                  END 
  
              PL$NEXT[PLI$LAST] = 0;        # LAST USED BUFFER         #
              PLI$NOTREADY = PLI$LAST;
              PLI$CURRENT = PLI$LAST;       # FIRST UNUSED BUFFER      #
              FIRSTTIME = FALSE;       # DONE WITH INITALIZING         #
              FOUND = FALSE;           # GET PLI$LAST LINE FOR NEWCOL7 #
#***#         GOTO INIT;
              END 
CONTROL EJECT;
  
#     IF THE CURRENT LINE IS READY TO BE PRINTED,  FLAG IT             #
  
          IF NOT CHECKINGCOPY          # MUST NOT BE IN COPY STMT      #
           AND (NOT REPLACING 
                OR PL$FLAGI[PLI$CURRENT])  THEN 
              BEGIN 
              PL$READY[PLI$CURRENT] = TRUE; 
              IF PLI$NOTREADY EQ PLI$CURRENT  THEN
                  BEGIN 
                  PL$READY[PLI$NOTREADY] = TRUE;
                  FOR I=I WHILE PLI$NOTREADY NQ 0 
                   AND PL$READY[PLI$NOTREADY]  DO 
                      PLI$NOTREADY = PL$NEXT[PLI$NOTREADY]; 
                  END 
              END 
  
#     ADVANCE THE CURRENT LINE TO THE NEXT REAL SOURCE LINE            #
#       (THIS IS NORMALLY THE LINE THE CURRENT NEWCOL7 CAME FROM       #
#       (I.E. PLI$LAST).   HOWEVER IF THE CURRENT LINE WAS THE LAST    #
#       LINE FROM A LIBRARY TEXT AND IF THE COPY STATEMENT HAD         #
#       CHARACTERS FOLLOWING IT ON THE SAME LINE, THEN -READIT- WILL   #
#       HAVE CREATED A LINE WITH JUST THOSE CHARACTERS AND APPENDED    #
#       THE ORIGINAL LINE(S).)                                         #
  
          PLI$CURRENT = PL$NEXT[PLI$CURRENT]; 
          FOR I=I WHILE PLI$CURRENT NQ 0         # WHILE NOT EOD       #
           AND PL$COMMENT[PLI$CURRENT]  DO       #   AND COMMENT LINE  #
              PLI$CURRENT = PL$NEXT[PLI$CURRENT];       # SKIP COMMENT #
  
          $BEGIN
          IF PLI$CURRENT NQ 0 
           AND NOT PL$FLAGN[PLI$CURRENT]       # IF NOT GENERATED LINE #
           AND PLI$CURRENT NQ PLI$LAST  THEN     # MUST BE LAST LINE   #
              ABORTSS("NEWLINE-1");              # ELSE, ERROR         #
          $END
  
#     IF ANY LINES ARE READY TO BE PRINTED,  PRINT THEM                #
  
          FOR I=I WHILE PLI$FIRST NQ 0
           AND LISTID NQ "          "   #  PROGRAM NAME DETERMINED     #
           AND NOT HOLDDATECMP
           AND PL$READY[PLI$FIRST]  DO
              BEGIN 
              $BEGIN
              IF PLI$FIRST EQ PLI$NOTREADY  THEN
                  ABORTSS("NEWLINE-2"); 
              $END
              PRINTIT(PLI$FIRST); 
              I = PL$NEXT[PLI$FIRST];  # SAVE NEXT VALUE OF PLI$FIRST  #
              RELPLINDEX(PLI$FIRST);   # RELEASE PRINT LINE ENTRY      #
              PLI$FIRST = I;
              END 
  
#     READ SOURCE LINES UNTIL A NON-COMMENT, NON-BLANK LINE            #
  
          IF PLI$CURRENT EQ 0  THEN 
              BEGIN 
              ENDCHRS = TRUE;          # TELL CALLER NO LINE           #
              $BEGIN
              IF BUG020C$CPY  THEN
                  CBLIST(LISTCTL"LINE", 
                           "  NEWLINE- PLI$CURRENT NOW FOUND ZERO", 37);
              $END
#***#         RETURN; # FROM NEWLINE #
              END 
          ELSE
              BEGIN 
              IF PLI$CURRENT EQ PLI$LAST  THEN
                  FOUND = FALSE;
              ELSE
                  BEGIN 
                  FOUND = TRUE; 
                  NEWCOL7 = B<36,6>PL$10CHARS[PLI$LAST];
                  END 
              END 
INIT:                        # (HERE TO FINISH INITIALIZING            #
  
          FOR I=I  WHILE NOT FOUND  DO
              BEGIN 
              PREVPLILAST = PLI$LAST; 
              GETPLINDEX(PLI$LAST);    # GET INDEX TO PRINT LINE ENTRY #
              PL$NEXT[PREVPLILAST] = PLI$LAST;
              PL$INIT[PLI$LAST] = 0;
          IF NOT READLIB THEN 
              STCOPY = FALSE; 
              READIT(PLI$LAST); 
  
              IF EODFLAG  THEN
                  BEGIN 
                  PLI$LAST = 0; 
                  FOUND = TRUE; 
                  END 
              ELSE
                  FOUND = NOT PL$COMMENT[PLI$LAST]; 
              END # OF FOR LOOP # 
  
          C<0,80>CARD = C<0,80>PL$10CHARS[PLI$CURRENT]; 
          ADDRLIN = LOC(CARD);         # (CARD IS STATIC, NOT VARYING) #
          TKNFROMLIB = PL$LIB[PLI$CURRENT]; 
          LINENO = PL$LINE[PLI$CURRENT];
          CURRVLN = PL$VLN[PLI$CURRENT];
  
#         IF THE CURRENT LINE IS A DEBUG LINE IN NON-DEBUG MODE FROM   #
#         LIBRARY TEXT (I.E. WHAT WOULD NORMALLY BE A DE FACTO COMMENT #
#         LINE),  TOKENS MUST STILL BE EXTRACTED BECAUSE THEY MIGHT    #
#         MATCH A -REPLACING- COMPARISON.  UNMATCHED TOKENS SHOULD BE  #
#         IGNORED.  THIS IS IMPLEMENTED BY SETTING -CLACOMMENT- FOR    #
#         EACH SUCH TOKEN, AND CHECKING -CLACOMMENT- IN -TKNCLAS-      #
#         AFTER A COMPARISON FAILS.                                    #
  
          IF PL$LIB[PLI$CURRENT]
           AND C<6,1>CARD EQ "D"
         AND NOT (CCTDEBUGLINE OR CCTDEBUGMODE) THEN
              CLACOMMENT = TRUE;
          ELSE
              CLACOMMENT = FALSE; 
  
          B<30,30>RA$LINE = LINENO;    # SET LINE NUMBER IN LOW CORE   #
CONTROL EJECT;
  
          $BEGIN
          IF BUG020C$LIN  THEN
              BEGIN 
              LINE
               = "PLI$FIRST=99 99 99 99   99   NEWCOL7=(X)   LINKS ARE";
              C10 = DEC(PLI$FIRST); 
              C<10,2>LINE = C<0,2>C10;
              C10 = DEC(PLI$NOTREADY);
              C<13,2>LINE = C<0,2>C10;
              C10 = DEC(PLI$CURRENT); 
              C<16,2>LINE = C<0,2>C10;
              C10 = DEC(PLI$LAST);
              C<19,2>LINE = C<0,2>C10;
              IF EODFLAG  THEN
                  C<22,1>LINE = "E";
              C10 = DEC(PLI$UNUSED);
              C<24,2>LINE = C<0,2>C10;
  
              C<38,1>LINE = C<9,1>NEWCOL7;
  
              C = 52; 
              FOR I = PLI$FIRST WHILE I NQ 0  DO
                  BEGIN 
                  C<C,1>LINE = " "; 
                  C = C + 1;
                  C<C,10>LINE = DEC(I); 
                  C = C + 1;
                  IF I GQ 10  THEN
                      C = C + 1;
                  C<C,1>LINE = "_"; 
                  C = C + 1;
                  I = PL$NEXT[I]; 
                  C<C,10>LINE = DEC(I); 
                  C = C + 1;
                  IF I GQ 10  THEN
                      C = C + 1;
                  IF C GQ 132-6  THEN 
                      I = 0;
                  END 
              FOR I = PLI$UNUSED WHILE I NQ 0  DO 
                  BEGIN 
                  C<C,1>LINE = " "; 
                  C = C + 1;
                  C<C,10>LINE = DEC(I); 
                  C = C + 1;
                  IF I GQ 10  THEN
                      C = C + 1;
                  C<C,1>LINE = "_"; 
                  C = C + 1;
                  I = PL$NEXT[I]; 
                  C<C,10>LINE = DEC(I); 
                  C = C + 1;
                  IF I GQ 10  THEN
                      C = C + 1;
                  IF C GQ 132-6  THEN 
                      I = 0;
                  END 
              CBLIST(LISTCTL"LINE", LINE, 132); 
              END # OF DEBUG PRINTOUT # 
          $END
          END # OF NEWLINE #
          TERM
