*DECK QU2IO 
USETEXT TAFIT 
USETEXT TENVIRN 
USETEXT TOPTION 
      PROC QU2IO; 
#                            #
#      Q U 2 I O             #
#                            #
#  THIS IS A DUMMY PROC WHICH CONTAINS THE SYMPL ROUTINES WHICH DO ALL #
#  STANDARD INPUT/OUTPUT PROCESSING FOR QUERY UPDATE.                  #
      BEGIN #QU2IO# 
      CONTROL EJECT;
      XDEF BASED ARRAY RBUFFER[1:1]; # BUFFER FOR READ AND WRITE. THE  #
        BEGIN                        # BOUNDS OF 1:1 SET UP RBUFFER    #
        ITEM BUFFERI I(0,0,60);      # WITH 1 AS THE MINIMUM INDEX.    #
        ITEM BUFFERC C(0,0,10);      # ITEMS ARE DEFINED FOR CHARACTER #
                                   # USAGE AS WELL AS INTEGER. THE POIN#
        END                        # TER IS SET UP BY -INITIAL-.       #
      XDEF BASED ARRAY WBUFFER;;   # BUFFER FOR -WRITELN- CALL. IT IS  #
                                   # SET UP BY -INITIAL- TO BEGIN ONE  #
                                   # WORD (BLANK-FILLED) BEFORE BASED  #
                                   # ARRAY -RBUFFER-. THIS IS USED FOR #
                                   # LEADING BLANKS ON PRINTED OUTPUT. #
      XDEF ITEM LINES;             # NUMBER OF LINES ON TERMINAL       # QU3A335
      XDEF ITEM MXTRNLG I = 1030;  # MAX TANSM. LENGTH IN CHARS        # FEAT157
      XDEF ITEM QUIWLGW;           # WHOLE WORDS THAT CONTAIN MXTRNLG  # FEAT157
      XDEF ITEM PRINT B = TRUE;    # INDICATES IF WE SHOULD PRINT A    #
                                   # TRACE OF THE INPUT READ.          #
      XREF PROC CMOVE;             #PROC WHICH PERFORMS CHARACTER MOVES#
      XREF PROC DIAG;              # FOR ISSUING DIAGNOSTICS           #
      XREF PROC READLN;            # READS A CODED, ZERO-BYTE DELIMITED#
                                   # LINE FOR INPUT. DOES OTHER THINGS.#
          XREF PROC WRITEC;        # WRITE A CODED LINE IN -C- FORMAT  #
      XREF PROC RCLINP;            # ISSUE RECALL ON INPUT             #
      XREF ARRAY INPUT;            # FET FOR INPUT FILE                #
        BEGIN 
        END 
      XREF ARRAY OUTPUT;;          # FET FOR THE OUTPUT FILE           #
      XREF ARRAY TFILE;;           # FET FOR THE TRACE FILE            #
      XREF ITEM IPROCESSED B;      # TRUE IF AN -I- PARAMETER WAS PRO- #
                                   # CESSED OR IF FROM BATCH RUN       #
      XREF ITEM OPROCESSED B;      # TRUE IF AN -0- PARAMETER WAS PRO- #
                                   # CESSED OR IF FROM BATCH           #
      XREF ITEM TPROCESSED B;      # TRUE IF A -T- PARAMETER WAS PRO-  #
                                   # CESSED.                           #
      XREF ITEM INTERIN B;         # TRUE IF *WRITEBL* SHOULD CHECK    #
                                   # *OPROCESSED* TO AVOID COPYING     #
                                   # INPUT THAT WAS JUST ENTERED TO    #
                                   # TERMINAL                          #
      XREF ITEM DUMMY;                                                   QU2IO
      XREF ITEM PROMTYPE I;        # QU PROMPT/POSITION INDICATOR      #
      ITEM BIT I;                  # SCRATCH ITEM USED FOR LOOPS,ETC.  #
      ITEM CHAR I;                 # SCRATCH ITEM USED FOR LOOPS, ETC. #
      ITEM CHARPOS I;              # CHARACTER POSITION. USED BY PROC  #
                                   # -FINDLASTCHAR-.                   #
      ITEM LASTCHAR C(1);          # CONTAINS THE LAST NON-BLANK CHARAC#
                                   # TER OF INPUT LINE.                #
      ITEM WORD I;                 # SCRATCH ITEM USED FOR LOOPS, ETC. #
      ITEM WORDPOS I;              # WORD POSITION. USED BY PROC       #
                                   # -FINDLASTCHAR-.                   #
      CONTROL EJECT;
      FUNC CONTINUECHAR(CHARACTER) B; 
#                                  #
#      C O N T I N U E C H A R     #
#                                  #
# THIS RETURNS TRUE IF -CHARACTER- IS A LEGAL CONTINUATION CHARACTER.  #
# -CHARACTER- SHOULD BE IN C(1) FORMAT. USES THE INSTALLATION OPTION   #
# -CONTINUE- FOR CHECKING. CHECKS UP TO 10 CHARACTERS OF -CONTINUE-    #
      BEGIN 
      ITEM CHARACTER C(1);
      ITEM CONTCHAR C(10) = CONTINUE;  # CONTAINS A STRING OF ALL      #
                                       # LEGAL CONTINUATION CHARACTERS #
      CONTINUECHAR = FALSE;        # ASSUME NOT A CONTINUATION CHAR    #
      FOR CHAR = 0 STEP 1 UNTIL 9 DO  # FOR EACH POSSIBLE CHARACTER    #
        BEGIN 
        IF C<CHAR,1>CONTCHAR EQ " " THEN  # NO MORE CONTIN CHARS       #
          CHAR = 9;                # FORCE OUT OF THE LOOP             #
        ELSE
          IF CHARACTER EQ C<CHAR,1>CONTCHAR THEN   # ITS A MATCH.      #
            BEGIN 
            CONTINUECHAR = TRUE;   # YES IT IS A CONTINUATION CHAR     #
            CHAR = 9;              # FORCE OUT OF LOOP                 #
            END 
        END 
      RETURN; 
      END 
      CONTROL EJECT;
      PROC FINDLASTCHAR(COLUMN);
#                                  #
#     F I N D L A S T C H A R      #
#                                  #
# THIS PROCEDURE FINDS THE LAST NON-BLANK CHARACTER IN THE WORKING     #
# BUFFER -ABUFFER-. -COLUMN- IS THE CARD COLUMN AT WHICH THE BACKWARD  #
# SEARCH STARTS. THE CHARACTER AND WORD POSITIONS ARE SAVED IN         #
# -CHARPOS- AND -WORDPOS- RESPECTIVELY. THE LAST NON-BLANK CHARACTER   #
# IS RETURNED IN -LASTCHAR-. IF THERE WERE ONLY BLANKS, -LASTCHAR- WILL#
# CONTAIN A BLANK. -COLUMN- WILL NOT BE CHANGED.                       #
      BEGIN 
      ITEM COLUMN;                 # THE SIZE FIELD WE MUST SEARCH FOR #
                                   # LAST NON-BLANK CHARACTER.         #
      CHARPOS = 0;                 # NULL CHAR POSITION                #
      WORDPOS = 1;                 # NULL WORD POSITION                #
      BIT = 0;                     # NULL BIT  POSITION                #
      WORD = 1 + COLUMN / 10;      # INDEX OF LAST WORD OF FIELD       #
      CHAR = COLUMN - ((WORD - 1) * 10);  # NUMBER OF CHARS IN LAST WD #
                                          # OF THE FIELD               #
      LASTCHAR = " ";              # PRESET WITH A BLANK               #
      FOR WORD = WORD STEP -1 UNTIL 1 DO # FOR EACH WORD OF THE FIELD  #
        BEGIN 
        FOR CHAR = CHAR - 1 STEP -1 UNTIL 0 DO # FOR EACH CHAR IN WORD #
          IF C<CHAR,1>BUFFERC[WORD] NQ " " THEN  # IF NON-BLANK CHAR   #
            BEGIN 
            LASTCHAR = C<CHAR,1>BUFFERC[WORD];   # SAVE THE CHARACTER  #
            WORDPOS = WORD;        # SAVE THE WORD POSITION OF IT      #
            CHARPOS = CHAR;        # SAVE THE CHAR POSITION OF IT      #
            BIT = CHARPOS * 6;     # SAVE THE BIT  POSITION OF IT      #
            WORD = 1;              # SIMULATE LAST PASS OF LOOP        #
            TEST WORD;             # FORCE OUT OF LOOP                 #
            END 
        CHAR = 10;                 # RESET- 10 CHARS TO TEST IN NEXT WD#
        END 
      RETURN; 
      END 
      CONTROL EJECT;
      XDEF PROC READ; 
      PROC READ(WSTORAGE, LENGTH, (LIMIT), RC); 
#                            #
#        R E A D             #
#                            #
# THIS PROC READS A TRANSMISSION INTO THE BUFFER DEFINED BY -WSTORAGE-.#
# THE CHARACTER LENGTH OF THE TRANSMISSION MOVED INTO THE  BUFFER IS   #
# RETURNED IN -LENGTH-.                                                #
# -LIMIT- IS THE MAXIMUM NUMBER OF CHARACTERS TO BE TRANSFERRED. IT IS #
# A PARAMETER -BY VALUE- SO YOU MAY USE AN INTEGER CONSTANT IN THE CALL#
# AND NOT FEAR IT BEING CLOBBERED.                                     #
# THE RETURN CODE IS PLACED IN -RC-. THE VALUES ARE:                   #
#     RC > 0  EOR OR EOF ON PREVIOUS -READ-                            #
#     RC = 0  ALL WENT WELL                                            #
#     RC < 0  -READ- DISCARDED EXCESS DATA. LENGTH SHOWS WHAT WAS MOVED#
      BEGIN 
      ARRAY WSTORAGE;;             # ARRAY TO RECEIVE THE LINE         #
      ITEM  LENGTH;                # LENGTH OF TRANSMISSION IN CHARS   #
      ITEM  LIMIT;                 # LIMIT OF CHARS TO BE MOVED TO BFR #
      ITEM  RC;                    # RETURN CODE TO BE PASSED TO CALLER#
      BASED ARRAY AFIRSTCHAR;      # ARRAY FOR FIRST CHAR              #
        BEGIN 
        ITEM FIRSTCHAR C(0,0,1);   # FIRST CHARACTER OF NEXT CARD WHEN #
                                   # POINTER IS SET TO -INPUTOUT-      #
        END 
      ITEM CHARLENGTH I;           # CHARACTER LENGTH OF CURRENT PART  #
                                   # OF INPUT STRING. ALSO LENGTH TO BE#
                                   # MOVED BY -CMOVE-.                 #
      ITEM FIRSTCONT B;            # TRUE IF FIRST CHAR ON NEXT CARD IS#
                                   # A CONTINUATION CHARACTER (BATCH)  #
      ITEM FROMCHAR I;             # CHARACTER POSITION FROM WHICH     #
                                   # -CMOVE- WILL DO ITS THING.        #
      ITEM LASTCONT B;             # TRUE IF LAST CHARACTER OF THIS    #
                                   # LINE IS A CONTINUATION CHARACTER  #
      ITEM LTDLENGTH I;            # LIMITED LENGTH-  LENGTH ALLOWABLE #
                                   # BEFORE -LIMIT- IS REACHED         #
      ITEM READING B;              # CONTROL VARIABLE FOR THE MAIN LOOP#
                                   # TRUE IF STILL READING             #
      ITEM RT;                     # RETURN CODE FOR -READLN- CALL     #
      ITEM TOCHAR I;               # CHARACTER POSITION AT WHICH       #
                                   # -CMOVE- WILL DO ITS THING.        #
      ITEM WORDLENGTH I;           # LENGTH OF INPUT LINE IN WORDS.    #
      XDEF ITEM CONCTED B;         # CONNECTED FILE INPUT FLAG         #
                                   # SET BY USINGEX ROUTINE            #
CONTROL EJECT;
#**********************************************************************#
#                                                                      #
#  HERE BEGINS THE EXECUTABLE CODE FOR PROC -READ-.                    #
#                                                                      #
#**********************************************************************#
      RC = 0; 
      IF LIMIT LQ 0 OR LIMIT GR MXTRNLG THEN  # IF BAD LIMIT REQUEST   #
        LIMIT = MXTRNLG;                      # DEFAULT TO MAXIMUM     #
      READING = TRUE; 
      LENGTH = 0; 
      FIRSTCONT = FALSE;
      FOR DUMMY=DUMMY                                                    QU2IO
        WHILE READING                                                    QU2IO
      DO                                                                 QU2IO
        BEGIN  # READING LOOP # 
        READLN(RBUFFER, WORDLENGTH, RT);  #READ A LINE                 # QU2IO
        IF IPROCESSED              # IF INPUT FILE NQ DEFAULT (INPUT)  #
          OR CONCTED               # OR INPUT FILE CONNECTED TO THE    #
                                   # TERMINAL                          #
        THEN
          IF RT NQ 0 THEN          # IF EOR/EOF/EOI ON THIS READ       #
            BEGIN 
            READING = FALSE;       # TO TERMINATE READING              #
                                   # IF EOF AND FIRSTCONT IS TRUE      #
                                   # THEN ASSUME THAT THE CONTINUATION #
                                   # CHARACTER IS LEFT OVER FROM A     #
                                   # PREVIOUS DIRECTIVE.   LEAVE RC    #
                                   # AS ZERO SO THAT THIS DIRECTIVE    #
                                   # WILL BE PROCESSED.                #
            IF FIRSTCONT
            THEN
              BEGIN 
              TEST DUMMY; 
              END 
            RC = 1;                # RETURN CODE FOR EOR/EOF/EOI TERM. #
            LENGTH = 0;            # ZERO LENGTH IF EOR/EOF/EOI        #
            TEST;                  # FORCE END OF LOOP                 #
            END 
        IF FIRSTCONT THEN          # IF FIRST CHAR IS A CONTINUE CHAR  #
          FROMCHAR = 1;            # AVOID FIRST CHAR FOR -CMOVE-      #
        ELSE FROMCHAR = 0;         # INCLUDE FIRST CHAR FOR -CMOVE-    #
        FIRSTCONT = FALSE;         # RESET FLAG FOR CONT.CHAR AS FIRST #
        LASTCONT = FALSE;          # RESET FLAG FOR CONT.CHAR AS LAST  #
        IF PRINT THEN              # IF SHOULD PRINT TRACE OF INPUT    #
          BEGIN 
          IF OPROCESSED THEN       # BATCH STYLE OUTPUT..PRINT TRACE   #
            WRITEC(OUTPUT,WBUFFER); 
          IF TPROCESSED THEN       # TRACE FILE REQUESTED..PRINT TRACE #
            WRITEC(TFILE,WBUFFER);
          END 
        IF BUFFERI[WORDLENGTH] EQ 0 THEN # IF FULL WORD OF ZERO-BYTES  #
          WORDLENGTH = WORDLENGTH - 1;    # ELIMINATE ZERO-BYTE WORD   #
  
        IF WORDLENGTH EQ 0         # IF NOTHING BUT ZERO-BYTE          #
        THEN
          BEGIN 
          WORDLENGTH = 1;          # MAKE IT ONE WORD OF BLANKS        #
          BUFFERC[WORDLENGTH] = " ";
          END 
  
        FOR BIT = 54 STEP -6 UNTIL 0 DO   #CHECK FOR TRAILING ZEROBYTES#
          BEGIN 
          IF B<BIT,6>BUFFERI[WORDLENGTH] NQ 0 THEN  # IF NOT A ZERO-BYT#
            BEGIN 
            CHARLENGTH = BIT/6 + 1 + (WORDLENGTH - 1) * 10; 
            BIT = 0;               # FORCE OUT OF THE LOOP             #
            END 
          END 
        IF IPROCESSED THEN         # INPUT IS BATCH STYLE              #
          BEGIN 
          RCLINP;                  #IF BUFFER EMPTY, ISSUE RCL ON INPUT#
          P<AFIT> = LOC(INPUT);                                          QU2IO
          P<AFIRSTCHAR> = AFITOUT;  #POINT TO THE NEXT CARD            # QU2IO
          IF CONTINUECHAR(FIRSTCHAR[0]) THEN   # THIS IS A FUNCTION CAL#
            BEGIN 
            FIRSTCONT = TRUE;      # FIRST CHAR OF NEXT CARD IS CONTINU#
            IF CHARLENGTH LS CARDSIZE THEN  # BLANK FILL TO CARDSIZE   #
              BEGIN 
              WORD = CHARLENGTH / 10 + 1; 
              CHAR = CHARLENGTH - 10*(WORD - 1);
              C<CHAR, 10-CHAR>BUFFERC[WORD] = " ";
              FOR WORD = WORD + 1 STEP 1 UNTIL CARDSIZE/10 + 1 DO 
                BUFFERC[WORD] = " " ; 
              CHARLENGTH = CARDSIZE;   # USE THE PADDED OUT LENGTH.    #
              END 
            END 
                                   # IF THIS CARD WAS LONGER THAN THE  #
                                   # SIZE WE LOOK AT, CALL IT SHORTER. #
          IF CHARLENGTH GR CARDSIZE THEN CHARLENGTH = CARDSIZE; 
          END 
        IF NOT FIRSTCONT THEN  # MUST DO CHACKING FOR LASTCONT         #
          BEGIN 
          FINDLASTCHAR(CHARLENGTH);                                      QU2IO
          CHARLENGTH = (WORDPOS - 1) * 10 + CHARPOS; # TRUNCATED LNGTH #
          CHARLENGTH = CHARLENGTH + 1; # INCLUDE LAST CHAR..  NOT SURE #
                                       # IF IT IS A LAST CONT. IF IT   #
                                       # IS WE SHOULD IGNORE IT. LATER.#
          IF CONTINUECHAR(LASTCHAR) THEN   # THIS IS A FUNCTION CALL   #
            BEGIN 
            LASTCONT = TRUE;
            CHARLENGTH = CHARLENGTH - 1;   # DONT INCLUDE CHAR AT END  #
            IF FROMCHAR EQ 1 AND CHARLENGTH EQ 0 THEN 
              BEGIN 
              CHARLENGTH = CARDSIZE;   # CARD HAS ONLY A CONT. CHAR. IN#
                                       # COLUMN 1. DOES NOT COUNT AS   #
                                       # LASTCONT, ONLY AS FIRSTCONT.  #
                                       # PAD OUT TO FULL CARD SIZE.    #
              END 
            END 
          END 
        TOCHAR = LENGTH;           # NEXT MOVE CONCATENATES STRINGS    #
        CHARLENGTH = CHARLENGTH - FROMCHAR; 
        LENGTH = LENGTH + CHARLENGTH; 
        READING = FIRSTCONT OR LASTCONT;
        LTDLENGTH = LIMIT - TOCHAR;  # LIMITED LENGTH IS MAX WE CAN MOV#
        IF LTDLENGTH GR 0 THEN      # IF WE CAN MOVE ANY CHARACTERS    #
          BEGIN 
          IF CHARLENGTH GR LTDLENGTH THEN  # IF EXCESS CHARACTERS      #
            BEGIN 
            CHARLENGTH = LTDLENGTH;        # TRUNCATE TO WHAT CAN MOVE #
            RC = -1;                       # RETURN CODE FOR TRUNCATION#
            END 
          CMOVE(RBUFFER, FROMCHAR, CHARLENGTH,                           QU2IO
                      WSTORAGE, TOCHAR);   # MOVE WHAT CAN BE MOVED    #
          END 
        END # READING LOOP #
      IF LENGTH GR MXTRNLG THEN    # IF EXCEEDED MAX TRANSMISSION LNGTH#
        DIAG(78, MXTRNLG, LENGTH); #DIAGNOSE LENGTH GR MAXIMUM         # QU2IO
      IF LENGTH GR LIMIT THEN      # IF EXCEEDED LIMIT OF THIS READ    #
        LENGTH = LIMIT;            #LIMIT IS THE MAXIMUM LENGTH CAN RTN#
      RETURN; 
      END 
      CONTROL EJECT;
      XDEF PROC WRITEBL;
      PROC WRITEBL(WSTORAGE, (LENGTH), RC); 
#                           # 
#     W R I T E B L         # 
#                           # 
# THIS PROC DOES ALL THE WORK FOR -WRITE- AND -WRITEBL-. IT MOVES THE  #
# TEXT TO THE PROPER BUFFERS ONE LINE AT A TIME. LINE LENGTH AND NUMBER#
# OF LINES PER SCREENFUL ARE USED TO FORMAT PRETTY OUTPUT.             #
      BEGIN #WRITE# 
      XREF ARRAY MOREBE;;          # NOS/BE -MORE- QUERY               #
      XREF ARRAY MORENOS;;         # NOS -MORE- QUERY                  #
      XREF ITEM CONCTED B;         # CONNECTED FILE INPUT FLAG         #
      ARRAY WSTORAGE;;             # USER BUFFER CONTAINING LINE       #
      ITEM  LENGTH;                # LENGTH OF LINE IN -WSTORAGE-      #
      ITEM  RC;                    # RETURN CODE, 0-OK, 1-USER SAID NO #
      ITEM CARRCONTROL C(6) = " 0123+-"; # LEGAL CARRIAGE CONTROL CHAR-#
                                   # ACTERS.                           #
      ITEM NCCCHAR    I;           # NUMBER OF VALID CC CHARACTERS     #
                                   # MUST BE ALTERED WITH CARRCONTROL  #
      ITEM CCOK B;                 # TRUE IF THE FIRST CHAR IS A LEGAL #
                                   # CARRIAGE CONTROL CHARACTER.       #
      ITEM DONTCONT B;             # TRUE IF USER DID NOT WANT WRITING #
                                   # TO CONTINUE                       #
      ITEM LINELENGTH I;           # LENGTH OF THIS LINE SO FAR.       #
      ITEM MOVELENGTH I;           # NUMBER OF CHARS TO BE MOVED BY    #
                                   # -CMOVE- TO THE BUFFER.            #
      ITEM NUMBERMOVED I;          # NUMBER OF CHARACTERS MOVED TO     #
                                   # -OUTPUT- SO FAR.                  #
      ITEM REPLY C(10);            # REPLY FROM -MORE- MSG             #
      ITEM RESETPROM B;            # IF TRUE, RESET 0013 TO 0000       #
                                   # IN BUFFER FOR TRACE FILE.         #
      RC= 0;
      NUMBERMOVED = 0;             # TOTAL CHARS OF REQUEST WRITTEN    #
      LINELENGTH = 0;              # OUTPUT LINE STARTS AS NULL LINE   #
      FOR DUMMY=DUMMY                                                    QU2IO
        WHILE LENGTH GR 0          #WHILE STILL MORE TO WRITE          # QU2IO
      DO                                                                 QU2IO
        BEGIN 
        IF LINELENGTH + LENGTH LQ CHPLINE - 1 THEN #IF FIT IN THIS LINE#
          MOVELENGTH = LENGTH;                    #THEN MOVE ALL OF IT #
        ELSE MOVELENGTH = CHPLINE - LINELENGTH - 1;# E. MOVE WHAT FITS #
        LENGTH = LENGTH - MOVELENGTH;  # CROSS OFF THOSE TO BE MOVED   #
        CMOVE(WSTORAGE, NUMBERMOVED, MOVELENGTH,                         QU2IO
                    RBUFFER, LINELENGTH);     # MOVE THEM              #
        NUMBERMOVED = NUMBERMOVED + MOVELENGTH; 
        LINELENGTH = LINELENGTH + MOVELENGTH; # ADD THOSE MOVED        #
        FINDLASTCHAR(LINELENGTH);  #GET CHARPOS, BIT, AND WORDPOS      # QU2IO
                                        # OF LAST NON-BLANK CHARACTER  #
        IF CHARPOS EQ 9 THEN       # IF WAS IN LAST CHAR POSITION      #
          BEGIN 
          CHARPOS = 0;             # IS FIRST CHAR POS OF NEXT WORD    #
          BIT = 0;
          WORDPOS = WORDPOS + 1;   # NEXT WORD                         #
          END 
        ELSE
          BEGIN 
          CHARPOS = CHARPOS + 1;   # JUST NEXT CHAR POSITION           #
          BIT = BIT + 6;
          END 
        C<CHARPOS,1>BUFFERC[WORDPOS] = " ";  # ADD ONE BLANK TO LINE   #
        IF CHARPOS LQ 8 THEN       # HAVE PART WORD TO ZERO-BYTE FILL  #
          BEGIN 
          B<BIT+6, 54-BIT>BUFFERI[WORDPOS] = 0;  # ZERO-BYTES TO PAD IT#
          END 
        BUFFERI[WORDPOS + 1] = 0;  #ZERO-BYTES FOR AN EXTRA TRAILING WD#
        CCOK = FALSE;              # ASSUME BAD CARRIAGE CONTROL CHAR  #
        FOR CHARPOS = 0 STEP 1     # FOR EACH OF THE VALID CHAR CONTROL#
          UNTIL NCCCHAR            # CHARACTERS                        #
        DO
          BEGIN                    # COMPARE TO THE FIRST CHAR OF LINE #
          IF C<0,1>BUFFERC[1] EQ C<CHARPOS,1>CARRCONTROL
          THEN
            BEGIN 
            CCOK = TRUE;           # CARRIAGE CONTROL OK AFTER ALL     #
            CHARPOS = 5;           # SIMULATE LAST PASS FOR TERMINATION#
            END 
          END 
        IF NOT CCOK                # IF FIRST CHAR IS INVALID CC CHAR  #
        THEN
          BEGIN 
          C<0,1>BUFFERC[1] = " ";  # INSERT A BLANK AS CARRIAGE CONTROL#
          END 
        FOR WORD = 1 STEP 1        # FOR EACH WORD TO WRITE            #
          UNTIL WORDPOS - 1        # UP TO BUT NOT INCLUDING THE WORD  #
                                   # WITH THE REAL ZERO BYTE.          #
        DO
          BEGIN 
          IF B<48,12>BUFFERI[WORD] EQ 0  # IF EMBEDDED ZERO BYTE       #
          THEN
            BEGIN 
            B<48,12>BUFFERI[WORD] = O"0055";  # INSERT A BLANK TO      #
                                              # ELIMINATE ZERO BYTE    #
            END 
          END 
  
                                   # THE FOLLOWING CODES INSERTS OCTAL #
                                   # VALUE 0013 ONTO THE EVEN BYTE OF  #
                                   # A QU PROMPT.  UNDER NOS, IT WILL  #
                                   # CAUSE QU TO WAIT FOR USER INPUT   #
                                   # RIGHT AFTER THE PROMPT.  THEN IT  #
                                   # RESETS FOR TRACE FILE OUTPUT.     #
  
        RESETPROM = FALSE;
*IF DEF,NOS 
  
        IF PROMTYPE NQ 0           # SET 0013 FOR TERMINAL DISPLAY     #
          AND (NOT IPROCESSED 
            OR (IPROCESSED AND CONCTED))
          AND NOT OPROCESSED
        THEN
          BEGIN 
          B<PROMTYPE,6>BUFFERI[1] = O"13";
          RESETPROM = TRUE; 
          END 
*ENDIF
                                   # CHECK IF OUTPUT SHOULD BE WRITTEN #
        IF NOT (INTERIN AND (NOT OPROCESSED)) 
        THEN
          BEGIN 
          WRITEC(OUTPUT, RBUFFER);  # WRITE LINE TO OUTPUT FILE        #
          END 
  
*IF DEF,NOS 
      IF RESETPROM
      THEN
        BEGIN 
        B<PROMTYPE,6>BUFFERI[1] = O"00";
        PROMTYPE = 0;              # NOT PROMPTING ANY MORE            #
        END 
*ENDIF
  
  
        IF TPROCESSED              # IF TRACE FILE REQUESTED           #
          AND NOT CONCTED          # AND *FROM* FILE NOT TERMINAL      #
        THEN
          BEGIN 
          WRITEC(TFILE,RBUFFER);   # WRITE THE LINE TO TRACE FILE      #
          END 
        LINES = LINES + 1;         # ONE MORE LINE PRINTED             #
        C<0,1>BUFFERC[0] = " ";    # FORCE BLANK CC FOR CONTINUATION LN#
        LINELENGTH = 1;            # LINE CONSISTS OF CC SO FAR        #
        IF NOT (OPROCESSED         # IF NO OUTPUT OR INPUT FILE        #
          OR IPROCESSED)           # AND -MORE- QUERY NOT DISABLED     #
            AND NBLINES NQ 0
        THEN
          BEGIN 
          IF LINES + 2 GQ NBLINES THEN   # HAVE A SCREENFUL, MORE QQQ  #
            BEGIN 
            LINES = 0;             # SCREEN WILL START FRESH           #
  
CONTROL IFEQ OS$NAME,NOS;          # IF NOS OPERATING SYSTEM           #
            WRITEC(OUTPUT,MORENOS);  # WRITE THE -MORE- QUERY WITHOUT  #
CONTROL ENDIF;                       # CC CHARACTER TO THE CONSOLE     #
  
CONTROL IFEQ OS$NAME,SCOPE;        # IF NOS/BE OPERATING SYSTEM        #
            WRITEC (OUTPUT,MOREBE);  # WRITE THE -MORE- QUERY WITH CC  #
CONTROL ENDIF;                       # CHARACTER TO THE CONSOLE        #
  
            IF TPROCESSED THEN
              BEGIN 
              WRITEC(TFILE,MOREBE);   # WRITE -MORE- MESSAGE WITH CC   #
                                      # CHAR TO TRACE FILE             #
              END 
            READ(REPLY, DUMMY, 10, DUMMY);  #READ USERS REPLY          # QU2IO
            DONTCONT = TRUE;       # ASSUME WE DONT CONTINUE           #
            IF C<0,1>REPLY EQ "Y" THEN DONTCONT = FALSE;
            IF DONTCONT THEN       # IF SHOULD NOT CONTINUE WRITING    #
              BEGIN 
              RC = 1;              # RC FOR -USER REPLIED NO-          #
              LENGTH = 0;          # FORCE TERMINATION OF LOOP         #
              TEST;                # TEST IN CASE MORE CODE GETS ADDED #
              END 
            END 
          END 
        END 
      END #WRITE# 
      CONTROL EJECT;
      XDEF PROC WRITE;
      PROC WRITE(WSTORAGE, (LENGTH), RC); 
#                           # 
#         W R I T E         # 
#                           # 
# WRITES -LENGTH- CHARACTERS FROM -WSTORAGE- TO -OUTPUT-. DOES NOT HAVE#
# A MEMORY OF HOW MANY LINES WERE SENT SO FAR. CALLS -WRITEBL- TO DO   #
# THE REAL WORK.                                                       #
      BEGIN 
      ITEM WSTORAGE;               # USER BUFFER-  ADDRESS TO -WRITEBL-#
      ITEM LENGTH;                 # LINE LENGTH-    VALUE TO -WRITEBL-#
      ITEM RC;                     # RETURN CODE-  ADDRESS TO -WRITEBL-#
      LINES = 0;
      WRITEBL(WSTORAGE, LENGTH, RC);                                     QU2IO
      LINES = 0;
      RETURN; 
      END 
      END   #QU2IO# 
      TERM
