*DECK READIT
USETEXT CCTTEXT 
USETEXT SSTEXT
          PROC  READIT(PLINDEX);
  
#**       READIT -  READ A LINE                                        #
#                                                                      #
#     CALLING SEQUENCE-                                                #
#         READIT(PLINDEX):                                             #
#                                                                      #
#     GIVEN-                                                           #
#         PLINDEX = INDEX TO PL$ ARRAY.                                #
#         READLIB = TRUE IFF READING FROM A LIBRARY.                   #
#         LIBFET = LIBRARY FET (IF READING FROM A LIBRARY).            #
#         LIBADDR = WA ADDRESS (IF READING FROM A LIBRARY).            #
#         INFET = FET FOR SOURCE INPUT.                                #
#                                                                      #
#     DOES-                                                            #
#         IF LINE IS NOT SET UP BECAUSE OF END-OF-DATA,                #
#           EODFLAG = TRUE.                                            #
#         SETS LINE IN PL$ AS INDICATED BY DESCRIPTOR.                 #
#         PL$COMMENT[PLINDEX] = TRUE IFF LINE IS A COMMENT.            #
#         PL$LIB[PLINDEX] = TRUE IFF LINE IS FROM LIBRARY.             #
#         PL$LINE[PLINDEX] = ACTUAL LINE NUMBER.                       #
#                              (MAY NOT BE UNIQUE)                     #
#         PL$VLN[PLINDEX] = VIRTUAL LINE NUMBER.                       #
#                             (WILL BE UNIQUE)                         #
#         NEWCOL7 = CHARACTER FROM NEXT LINE-S COLUMN 7.               #
#     NOTE-                                                            #
#         DUE TO POSSIBLE ADJUSTMENT OF COMPILER-GENERATED LINE NUMBERS#
#         BY -SETCOPY-, THIS ROUTINE CANNOT DIAGNOSE AN ILLEGAL        #
#         COLUMN 7 CHARACTER.  COLUMN 7 IS CHECKED FOR LEGALITY IN     #
#         -PRINTIT-, WHEN THE LINE NUMBER HAS BEEN FINALIZED.          #
#         -READIT- CAN DIAGNOSE ERRORS IN PROGRAM SEQUENCE NUMBERS     #
#         BECAUSE -SETCOPY- CHANGES ONLY COMPILER-GENERATED LINE       #
#         NUMBERS.                                                     #
  
  
          BEGIN 
          ITEM  PLINDEX      I;        # INDEX TO PL$ ARRAY            #
  
  
*CALL BUG020C$
  
  
*CALL CHAR$ 
  
  
*CALL RALINE
  
*CALL RAPLUSC 
  
*CALL SYSFET
*CALL LISTOBJ 
*CALL TABLETYP
  
          XREF
              BEGIN 
              PROC  ABORTSS;           # ABORT SOURCE SCANNER          #
              FUNC  DEC  C(10);        # R.J.B.F. DECIMAL DISPLAY VALUE#
              PROC  GETWA;             # GET WORD-ADDRESSABLE          #
              PROC  GETSQ;             # GET SEQUENTIAL                #
              PROC  DBDIAG;            # DEBUG DIAGNOS                 #
              PROC  INTERCEPTOR;       # ISSUE DIAGNOSTIC              #
              PROC  RETRN;             # RETURN A FILE AND RELEASE BUFF#
          PROC  SETLINE;
                  FUNC  VIRTUAL;
              END 
  
          XREF
              BEGIN 
              ITEM  INDEBUG  B;        # IFF NOW DEBUGGING INTERPRETTER#
              ITEM  DDLDEBUG B;        # IFF NOW DEBUGGING DDL         #
              ITEM  SRCLINE      I;    # 1 CHR/WORD SOURCE LINE        #
              END 
  
          ITEM  ACTIVE       B;        # IFF CARD IS ACTIVE            #
          ITEM  CARD         C(100);   # LOCAL CARD BUFFER             #
          ITEM  CHAR         I;        # CURRENT CHARACTER             #
          ITEM  CHAR$COLON   C(1) = ":";  # COLON CHARACTER            #
          ITEM  C10          C(10);    # 10-CHARACTER SCRATCH WORD     #
          ITEM  EOTFLAG      B=FALSE;  # IFF END-OF-TEXT               #
          ITEM  FIRSTSEQ     B=FALSE;  # FIRST GOOD SEQUENCE NUMBER FND#
          ITEM  GC$BP        I;        # GETCHAR- BIT POSITION         #
          ITEM  GC$WC        I;        # GETCHAR- WORD COUNT           #
          ITEM  GC$WORD      C(10);    # GETCHAR- CURRENT WORD         #
          ITEM  I            I;        # SCRATCH                       #
          ITEM  IDENT        C(10);    # IDENT OF LAST CARD            #
          ITEM  IDENTNO      I;        # INDEX TO UPDATE IDENTIFIER    #
          ITEM  ILIM         I;        # LIMIT FOR COUNTER I           #
          ITEM  K            I;             # SCRATCH # 
          ITEM  LASTLN       I;        # LAST LINE NUMBER              #
          ITEM  LISTWORD     C(10); 
          ITEM  NUMERIC      B;        # IFF USER SEQ. NUM. IS NUMERIC #
          ITEM  N            I;        # TENTATIVE LINE NUMBER         #
          ITEM  PC$CP        I;        # PURCHAR- CHARACTER POSITION   #
          ITEM  PREVIDENTNO  I=-1;     # NUMBER OF IDENT FROM PREV CARD#
          ITEM  RL           I;        # ACTUAL SEQUENTIAL RECORD LEN. #
          ITEM  SEQNUM       I;        # SEQUENCE NUMBER OF LINE       #
          ITEM  VLN          I=0;      # VIRTUAL LINE NUMBER           #
          ITEM  WC           I;        # WORD COUNT FOR TEXT           #
          ITEM C1            C(1);
  
          BASED ARRAY ZEROARRAY[0:0]; 
              ITEM  ZERO         U(0, 0,60);
  
          ARRAY  [0:3]; 
              ITEM  LISTOPTION C(0,0,10) = ["ONOBJLIST ", 
                    "ONALLLIST ", "OFFOBJLIST", 
                    "OFFALLLIST"];
          DEF  DIAGNOS(SEV, NUM, LIN, COL)
#$BEGIN DBDIAG(SEV,NUM,LIN,COL);$END INTERCEPTOR(COL,LIN,NUM-1000,SEV)#;
CONTROL EJECT;
  
*CALL LISTCTL 
  
          $BEGIN
  
          XREF
              BEGIN 
              PROC  CBLIST;            # COBOL LISTING ROUTINE         #
              END 
  
          ITEM  LINE         C(140);   # DEBUG PRINT LINE              #
  
          $END
CONTROL EJECT;
  
          PROC  GETCHAR;
  
#**       GETCHAR -  GET CHARACTER FROM A LIBRARY                      #
#                                                                      #
#     GIVEN-                                                           #
#         GC$BP = BIT POSITION.                                        #
#         GC$WC = COUND OF USED WORDS.                                 #
#         WC = COUNT OF AVAILABLE WORDS.                               #
#         LIBFET = FET FOR LIBRARY.                                    #
#         LIBADDR = ADDRESS IN LIBRARY.                                #
#                                                                      #
#     DOES-                                                            #
#         CHAR = NEXT CHARACTER  (INTEGER).                            #
#                  (-1 IFF END-OF-CARD)                                #
  
  
          BEGIN 
          IF GC$BP EQ 60  THEN
              BEGIN                    # JUST USED UP WORD             #
              IF GC$WC EQ WC  THEN
                  BEGIN                # JUST USED UP LAST WORD        #
                  CHAR = -1;
#***#             RETURN; 
                  END 
              GETWA(LIBFET, LOC(GC$WORD), 1, LIBADDR, SETEOTFLAG);
              $BEGIN
              IF EOTFLAG  THEN
                  ABORTSS("READIT-7");
              $END
              LIBADDR = LIBADDR + 1;
              GC$WC = GC$WC + 1;
              GC$BP = 0;               # RESET BIT POSITION            #
              END 
          CHAR = B<GC$BP,6>GC$WORD; 
          GC$BP = GC$BP + 6;
          END # OF GETCHAR #
          CONTROL  EJECT; 
          PROC  LISTPROC(I);
          ITEM  I;
          ITEM  VLISTINDEX   I;        #VIRTUAL INDEX TO LISTOBJ       #
               SWITCH  LISTCONTROL  ONOBJLIST, ONALLLIST, 
                                    OFFOBJLIST, OFFALLLIST; 
          BEGIN 
              PL$COMMENT[PLINDEX] = TRUE; 
          GOTO  LISTCONTROL[I]; 
 ONOBJLIST: 
          CCTOBJLSTLEN = CCTOBJLSTLEN + 1;
          VLISTINDEX = VIRTUAL(TABLETYPE"OBJLST$",CCTOBJLSTLEN);
          OBJLISTFLAG[VLISTINDEX] = TRUE; 
          OBJLISTLINE[VLISTINDEX] = LN; 
          RETURN; 
 ONALLLIST: 
          CCTOBJLSTLEN = CCTOBJLSTLEN + 1;
          VLISTINDEX = VIRTUAL(TABLETYPE"OBJLST$",CCTOBJLSTLEN);
          OBJLISTFLAG[VLISTINDEX] = TRUE; 
          OBJLISTLINE[VLISTINDEX] = LN; 
          RETURN; 
 OFFOBJLIST:  
          IF C<17>PL$10CHARS[PLINDEX] NQ " " THEN RETURN; 
          CCTOBJLSTLEN = CCTOBJLSTLEN + 1;
          VLISTINDEX = VIRTUAL(TABLETYPE"OBJLST$",CCTOBJLSTLEN);
          OBJLISTFLAG[VLISTINDEX] = FALSE;
          OBJLISTLINE[VLISTINDEX] = LN; 
          RETURN; 
 OFFALLLIST:  
          IF C<17>PL$10CHARS[PLINDEX] NQ " " THEN RETURN; 
          CCTOBJLSTLEN = CCTOBJLSTLEN + 1;
          VLISTINDEX = VIRTUAL(TABLETYPE"OBJLST$",CCTOBJLSTLEN);
          OBJLISTFLAG[VLISTINDEX] = FALSE;
          OBJLISTLINE[VLISTINDEX] = LN; 
          RETURN; 
          RETURN; 
          END 
CONTROL EJECT;
  
          PROC  PUTCHAR;
  
#**       PUTCHAR -  PUT CHARACTER INTO CARD BUFFER                    #
#                                                                      #
#     CALLING SEQUENCE-                                                #
#         PUTCHAR:                                                     #
#                                                                      #
#     GIVEN-                                                           #
#         CHAR = CHARACTER (INTEGER).                                  #
#         PC$CP = NEXT AVAILABLE CHARACTER POSITION.                   #
#                                                                      #
#     DOES-                                                            #
#         ADDS CHAR TO CARDBUF.                                        #
  
  
          BEGIN 
          C<PC$CP,1>CARD = C<9,1>CHAR;
          PC$CP = PC$CP + 1;
          $BEGIN
          IF PC$CP GQ 100  THEN 
              ABORTSS("READIT-6");
          $END
          END # OF PUTCHAR #
CONTROL EJECT;
  
#     END-OF-DATA EXITS                                                #
  
          PROC  SETEOTFLAG; 
          EOTFLAG = TRUE; 
CONTROL EJECT;
  
#     READ THE LINE                                                    #
  
          IF READLIB  THEN
              BEGIN                    # READ FROM A LIBRARY           #
NEWCARD:                               # (HERE AFTER INACTIVE CARD)    #
              GETWA(LIBFET, LOC(UP$), 1, LIBADDR, SETEOTFLAG);
              IF EOTFLAG  THEN
                  GOTO ENDOFTEXT; 
              LIBADDR = LIBADDR + 1;
              ACTIVE = UP$ACTIVE; 
              WC = UP$WC; 
              SEQNUM = UP$SEQNUM; 
              IDENTNO = UP$IDENTNO; 
              $BEGIN
              IF UP$Y                  # IF FIRST IDENT YANKED CARD    #
               OR NOT UP$A  THEN       #  OR IDENT DEACTIVATED CARD    #
                  ABORTSS("READIT-4");
              $END
  
              FOR I=I WHILE NOT UP$CHBFLAG  DO
                  BEGIN                # SKIP REMAINING CHB-S          #
                  GETWA(LIBFET, LOC(UP$), 1, LIBADDR, SETEOTFLAG);
                  $BEGIN
                  IF EOTFLAG  THEN
                      ABORTSS("READIT-5");
                  $END
                  LIBADDR = LIBADDR + 1;
                  END 
  
              GC$BP = 60;              # INITIALIZE GETCHAR            #
              GC$WC = 0;
              PC$CP = 0;               # INITIALIZE PUTCHAR            #
              CARD = " ";              # BLANK LOCAL CARD BUFFER       #
  
              GETCHAR;                 # GET FIRST CHARACTER           #
              FOR I=I WHILE CHAR GQ 0  DO 
                  BEGIN 
                  IF CHAR EQ 0  THEN
                      BEGIN            # END-OF-CARD, COLON OR SPACES  #
                      GETCHAR;         # GET COUNT                     #
                      IF CHAR EQ 0  THEN         # 0000 IS END-OF-CARD #
#***#                     GOTO ENDOFCARD; 
                      IF CHAR EQ 1  THEN
                          CHAR = B<0,6>CHAR$COLON;
                      ELSE
                          BEGIN        # BLANKS                        #
                          ILIM = CHAR;           # NO. BLANKS - 1      #
                          CHAR = CHAR$BLANK;
                          FOR I = 1 STEP 1 UNTIL ILIM DO
                              PUTCHAR;
                          END 
                      END 
                  PUTCHAR;
                  GETCHAR;
                  END 
ENDOFCARD:                             # (HERE FOR 0000)               #
  
              IF NOT ACTIVE  THEN 
#***#             GOTO NEWCARD; 
  
              IF B<0,6>CARD EQ MCC  THEN         # MASTER CONTROL CHAR #
                  BEGIN 
                  IF  (B<30,6>CARD GQ O"55" 
                       AND C<1,4>CARD EQ "DECK")
                   OR (B<18,6>CARD GQ O"55" 
                       AND C<1,2>CARD EQ "DK")
                   OR (B<48,6>CARD GQ O"55" 
                       AND C<1,7>CARD EQ "COMDECK") 
                   OR (B<24,6>CARD GQ O"55" 
                       AND C<1,3>CARD EQ "CDK") 
         #
                   OR (B<30,6>CARD GQ O"55" 
# THEN BEGIN READLIB=FALSE; GOTO ENDOFTEXT; END IF (B<30,6>CARD GQ O"55"
                       AND C<1,4>CARD EQ "WEOR")
                   OR (B<12,6>CARD GQ O"55" 
                       AND C<1,1>CARD EQ "W") 
                   OR (B<36,6>CARD GQ O"55" 
                       AND C<1,5>CARD EQ "CWEOR") 
                   OR (B<18,6>CARD GQ O"55" 
                       AND C<1,2>CARD EQ "CW")  THEN
                      BEGIN 
                      READLIB = FALSE;
#***#                 GOTO ENDOFTEXT; 
                      END 
                  END 
              IF IDENTNO NQ PREVIDENTNO 
              THEN
                  BEGIN   # NEW IDENT - GO READ IT #
                  PREVIDENTNO = IDENTNO;
                  I = UPI$IDENTS + IDENTNO;  # WA OF IDENT #
                  GETWA(LIBFET, LOC(IDENT), 1, I, SETEOTFLAG);
                  END 
              $BEGIN
              IF C<0,9>IDENT EQ " " 
              THEN
                  IDENT = "--------- "; 
              $END
              C<72,2>CARD = "  ";      # CLEAR COLS 73 AND 74 # 
              C<74,9>CARD = IDENT;     # PUT IDENT IN PRT LINE #
              FOR I = 82 WHILE B<6*I,6>CARD EQ O"00" DO 
                  I = I - 1;
              C<I+1,1>CARD = "."; 
              C<I+2,10>CARD = DEC(SEQNUM);
              C<0,100>PL$10CHARS[PLINDEX] = C<0,100>CARD; 
              END 
          ELSE
              BEGIN                    # READ FROM SOURCE INPUT        #
              P<ZEROARRAY> = 0;        # (TO TERMINATE LIST)           #
              GETSQ(INFET,                       # INPUT FET           #
                    LOC(PL$10CHARS[PLINDEX]),           #FWA           #
                    100,                         # MAX. RECORD LENGTH  #
                    ENDOFSOURCE,                 # END-OF-DATA LABEL   #
                    RL,                          # ACTUAL RECORD LENGTH#
                    ZERO);                       #(END VARIABLE APLIST)#
              END 
  
#     SET LINE NUMBER                                                  #
  
          IF CCTPSQ  THEN 
              BEGIN                    # USER SEQUENCE NUMBERS         #
              NUMERIC = TRUE; 
              C10 = C<0,10>PL$10CHARS[PLINDEX]; 
              N = 0;
              FOR I = 0 STEP 6 UNTIL 30  DO 
                  BEGIN 
                  CHAR = B<I,6>C10; 
                  IF CHAR GQ CHAR$ZERO AND CHAR LQ CHAR$NINE
                  THEN
                      N = N * 10 + CHAR - CHAR$ZERO;
                  ELSE
                      IF CHAR NQ CHAR$BLANK   # IGNORE BLANKS # 
                      THEN
                          NUMERIC = FALSE;
                  END 
              IF N EQ 0 
              THEN
                  NUMERIC = FALSE;    # NO VALID DIGITS FOUND # 
  
              IF NOT NUMERIC  THEN
                  BEGIN 
                  IF FIRSTSEQ THEN
                      BEGIN 
                      # (A LINE FOLLOWING THIS LINE HAS NON-DIGITS     #
                      #  IN COLUMNS 1 TO 6.  THIS LINE-S PROGRAM       #
                      #  SEQUENCE NUMBER IS ASSUMED.)                  #
                      DIAGNOS("W", 1052, LN, 1);
                      END 
                  ELSE
                      BEGIN 
                      # (A LINE AT THE BEGINNING OF THE PROGRAM HAS    #
                      #  NON-DIGITS IN COLUMNS 1 TO 6.  THIS LINE-S    #
                      #  PROGRAM SEQUENCE NUMBER IS ASSUMED.)          #
                      LN = LN + 1;
                      DIAGNOS("W", 1089, LN, 1);
                      END 
                  END 
              ELSE
                  BEGIN                # SEQUENCE NUMBER IS NUMERIC    #
                  IF N GR 65535  THEN 
                      BEGIN 
                      IF FIRSTSEQ THEN
                          BEGIN 
                          # (A LINE FOLLOWING THIS LINE HAS A PROGRAM  #
                          #  SEQUENCE NUMBER IN COLUMNS 1 TO 6 THAT    #
                          #  IS LARGER THAN 65535.  THIS LINE-S NUMBER #
                          #  IS ASSUMED.)                              #
                        DIAGNOS("W", 1090, LN, 1);
                          END 
                      ELSE
                          BEGIN 
                          # (A LINE AT THE BEGINNING OF THE PROGRAM    #
                          # HAS A PROGRAM SEQUENCE NUMBER IN COLUMNS   #
                          #  1 TO 6 THAT IS LARGER THAN 65535.         #
                          #  THIS LINE-S PROGRAM SEQUENCE NUMBER IS    #
                          #  ASSUMED.)                                 #
                          LN = LN + 1;
                          DIAGNOS("W", 1091, LN, 1);
                          END 
                      END 
                  ELSE
                      BEGIN            # LEGAL PROGRAM SEQUENCE NUMBER #
                      LN = N; 
                      FIRSTSEQ = TRUE;
                      END 
                  END 
              END 
          ELSE
              BEGIN                    #COMPILER-GENERATED LINE NUMBERS#
              LN = LN + 1;
              END 
  
          PL$LINE[PLINDEX] = LN;
  
          $BEGIN
          B<0,30>RA$LINE = LN;         # SET LOOK-AHEAD LINE NUMBER    #
          $END                         #   IN LOW CORE                 #
  
#     ADJUST DEBUG FLAGS                                               #
  
          $BEGIN
          IF LN GQ BUG020C$BEGL 
           AND LN LQ BUG020C$ENDL  THEN 
              BEGIN 
              INDEBUG = INDEBUG$; 
              DDLDEBUG = DDLDEBUG$; 
              BUG020C$TKN = BUG020C$TKN$; 
              BUG020C$CPY = BUG020C$CPY$; 
              BUG020C$LIN = BUG020C$LIN$; 
              END 
          ELSE
              BEGIN 
              INDEBUG = FALSE;
              DDLDEBUG = FALSE; 
              BUG020C$TKN = FALSE;
              BUG020C$CPY = FALSE;
              BUG020C$LIN = FALSE;
              END 
          $END
  
#     SET REST OF INFORMATION                                          #
  
          NEWCOL7 = B<36,6>PL$10CHARS[PLINDEX]; 
  
          IF CCTFIPSLEVEL LS 2 AND NEWCOL7 EQ CHAR$D
          THEN BEGIN
               # FIPS=2 SUPPORTS DEBUGGING LINES #
               DIAGNOS("W",1604,LN,7);
               END
          IF CCTFIPSLEVEL LS 3 AND NEWCOL7 EQ CHAR$MINUS
          THEN BEGIN
               # FIRST NON-BLANK CHARACTER MUST BE QUOTE #
               FOR I = 7 STEP 1 UNTIL 71
               DO BEGIN 
                  C1 = C<I,1>PL$10CHARS[PLINDEX]; 
                  IF C1 EQ " "
                  THEN BEGIN
                       TEST I;
                       END
                  IF C1 EQ """" 
                  THEN BEGIN
                       I = 72;
                       TEST I;
                       END
                  # FIPS = 3 SUPPORTS CONTINUATION OF COBOL WORDS # 
                  # AND NUMERIC LITERALS #
                  DIAGNOS("W",1600,LN,7); 
                  I = 72; 
                  END 
               END
  
            IF (NEWCOL7 EQ CHAR$STAR OR NEWCOL7 EQ CHAR$SLASH) AND
                  C<7,1>PL$10CHARS[PLINDEX] EQ "O" THEN 
              BEGIN 
                   FOR I=7 STEP 1  WHILE     # FIND 1ST BLANK#
                        C<I,1>PL$10CHARS[PLINDEX] NQ " " DO 
                      K = I + 1;
                   I = K - 7;                      # SIZE OF OPTION # 
                   IF I LS 11 THEN
                      BEGIN 
                      C<0,I>LISTWORD = C<7,I>PL$10CHARS[PLINDEX]; 
                      IF I NQ 10 THEN 
                          C<I,10-I>LISTWORD = " "; #BLANK FILL LISTWORD#
                      FOR I = 0 STEP 1 UNTIL 3 DO 
                         IF LISTWORD EQ LISTOPTION[I] THEN LISTPROC(I); 
                      IF LISTWORD EQ "ONSOURCE" 
                       OR LISTWORD EQ "OFFSOURCE" 
                        THEN PL$COMMENT[PLINDEX] = TRUE;
                      END 
              END 
          IF NEWCOL7 EQ CHAR$STAR 
           OR NEWCOL7 EQ CHAR$SLASH 
           OR (NEWCOL7 EQ CHAR$D
               AND NOT READLIB
               AND NOT (CCTDEBUGLINE OR CCTDEBUGMODE)) THEN 
              PL$COMMENT[PLINDEX] = TRUE; 
          ELSE
              BEGIN                    # CHECK FOR BLANK LINE          #
              IF C<7,65>PL$10CHARS[PLINDEX] EQ " "
              THEN  PL$COMMENT[PLINDEX] = TRUE; 
              ELSE
                  PL$COMMENT[PLINDEX] = FALSE;
              END 
  
          PL$LIB[PLINDEX] = READLIB;
          PL$READY[PLINDEX] = PL$COMMENT[PLINDEX];
          VLN = VLN + 1;               # VIRTUAL LINE NUMBER           #
          PL$VLN[PLINDEX] = VLN;
  
          $BEGIN
DEBUGIT:  
          IF BUG020C$LIN  THEN
              BEGIN 
              C<0,31>LINE = "PLINDEX=99 VLN=99999 LN=99999 (";
              C<121,1>LINE = ")"; 
  
              C10 = DEC(PLINDEX); 
              C<8,2>LINE = C<0,2>C10; 
  
              C10 = DEC(VLN); 
              C<15,5>LINE = C<0,5>C10;
  
              C10 = DEC(LN);
              C<24,5>LINE = C<0,5>C10;
  
              C<31,90>LINE = C<0,90>PL$10CHARS[PLINDEX];
  
              IF PL$COMMENT[PLINDEX]  THEN
                  BEGIN 
                  C<30,1>LINE = "*";
                  C<121,1>LINE = "*"; 
                  END 
  
              CBLIST(LISTCTL"LINE", LINE, 122); 
              END 
          $END
  
          RETURN;                      # RETURN FROM READIT            #
  
  
  
  
ENDOFSOURCE:                           # (HERE FROM GETSQ END-OF-DATA) #
          EODFLAG = TRUE; 
          FOR I = PLI$FIRST WHILE PL$NEXT[I] NQ PLI$LAST
                                  AND I NQ PLI$LAST  DO 
              BEGIN 
              $BEGIN
              IF I EQ 0 THEN
                  ABORTSS ("READIT-4"); 
              $END
              I = PL$NEXT[I]; 
              END 
          PL$NEXT[I] = 0; 
          RETRN(INFET);    #RETURN THE INPUT FILE AND RELEASE THE BUFF #
          RETURN;                      # RETURN FROM READIT            #
CONTROL EJECT;
  
#     HANDLE END-OF-TEXT                                               #
#       (IF CHARACTERS FOLLOWED THE COPY STATEMENT ON THE SAME LINE    #
#       THEN A NEW LINE WITH JUST THOSE CHARACTERS MUST BE GENERATED.  #
#       ALSO,  THE LINES SEPARATED BY -SETCOPY- MUST BE RE-APPENDED.   #
#       THIS IS NOT REALLY THE PURPOSE OF -READIT-, BUT IT IS POSSIBLE #
#       BECAUSE THIS SITUATION CAN OCCUR ONLY WHEN -NEWLINE- OR        #
#       -SETCOPY- IS READING INTO PLI$LAST.  -READIT- CHANGES PLI$LAST #
#       TO POINT TO THE LAST REAL SOURCE LINE AND SETS -NEWCOL7- TO ITS#
#       ASSOCIATED COLUMN 7 CHARACTER.)                                #
# THE LINE DESCRIBED ABOVE IS NO LONGER CREATED HERE IT IS DONE IN     #
# SETCOPY AND LINKED IN BEFORE THE COPY TO THE PRINT LINE CHAIN        #
  
ENDOFTEXT:  
          $BEGIN
          IF PLINDEX NQ PLI$LAST  THEN
              ABORTSS("READIT-1");
          $END
          READLIB = FALSE;             # NO LONGER READING FROM LIBRARY#
          EOTFLAG = FALSE;             # CLEAR FLAG FOR NEXT COPY      #
  
              FOR I = PLI$FIRST WHILE PL$NEXT[I] NQ PLI$LAST  DO
                  BEGIN 
                  $BEGIN
                  IF I EQ 0  THEN 
                      ABORTSS("READIT-3");
                  $END
                  I = PL$NEXT[I]; 
                  END 
              PL$NEXT[I] = PLI$NEXTSRC; 
              PLI$LAST = PLI$LASTSRC; 
              IF PLI$LAST EQ 0  THEN
                  BEGIN 
                  EODFLAG = TRUE;      # RESET TO BEFORE -SETCOPY-     #
                  $BEGIN
                  IF BUG020C$LIN  THEN
                      CBLIST(LISTCTL"LINE", 
                                  "READIT- PLI$NEXTSRC FOUND ZERO", 30);
                  $END
                  END 
  
#     SET NEWCOL7                                                      #
  
          IF PLI$LAST NQ 0  THEN
              NEWCOL7 = B<36,6>PL$10CHARS[PLI$LAST];
          ELSE
              NEWCOL7 = CHAR$BLANK; 
  
#     ENSURE THAT LINE NUMBERS ON APPENDED LINES ARE SEQUENTIAL        #
  
          FOR I = PLI$NEXTSRC WHILE I NQ 0  DO
              BEGIN 
              LN = LN + 1;
              VLN = VLN + 1;
              PL$VLN[I] = VLN;
              PL$LINE[I] = LN;
              I = PL$NEXT[I]; 
              END 
          PREVIDENTNO = -1;   #FORCE NEW IDENT ON ANY SUBSEQUENT COPIES#
  
          $BEGIN
          IF PLI$LAST NQ 0  THEN
              GOTO DEBUGIT;            # GO PRINT TRACE IF DESIRED     #
          $END
          RETURN; # FROM READIT # 
  
          END 
          TERM
