ASMB,R,Q,C
*  **************************************************************** 
      HED RTE INTERACTIVE EDITOR
*     NAME:   EDITR 
*     SOURCE: 92070-18135 
*     RELOC:  92070-16135 
*     PGMR:   HLC 
* 
* 
*  **************************************************************** 
*  * (C) COPYRIGHT HEWLETT-PACKARD COMPANY 1979.  ALL RIGHTS      * 
*  * RESERVED.  NO PART OF THIS PROGRAM MAY BE PHOTOCOPIED,       * 
*  * REPRODUCED OR TRANSLATED TO ANOTHER PROGRAM LANGUAGE WITHOUT * 
*  * THE PRIOR WRITTEN CONSENT OF HEWLETT-PACKARD COMPANY.        * 
*  **************************************************************** 
* 
* 
      NAM EDITR,3,50  92070-16135  REV.1941  800326 
* 
      EXT CREAT,READF,WRITF,CLOSE,PURGE,RWNDF 
      EXT EXEC,LIMEM,LOGLU,REIO,CNUMD,.OPSY 
      EXT NAMF,OPENF,LOCF,POST,PNAME,CRETS,GETST
      EXT KCVT,NAMR,.MVW,IFBRK,POSNT
* 
* 
* 
*     ENHANCEMENT WISH LIST:
*       1)  COMMAND TO TRANSFER TO COMMAND FILE (MACRO LIBRARY?). 
*           AT COMPLETION, OR ON ERROR, INTERACTIVE EDITING WOULD RESUME. 
*           ALLOW ECHO OF COMMAND FILE. 
*       2)  BETTER HANDLING OF UPPER/LOWER CASE.  SPECIAL CHARACTERS
*           TO CONTROL UPSHIFTING/DOWNSHIFTING.  ABILITY TO FIND A PATTERN
*           OR SUBPATTERN WHERE CASE IS A "DON'T CARE". 
*       3)  NEW COMMAND TO TERMINATE COMMAND REPITITIONS ON 'EOF'; IF NOT 
*           SPECIFIED, 'EOF' WOULD NOT AFFECT REPITITION. 
*       4)  ABILITY TO AUTOMATICALLY SET TABS ON PRINTING TERMINAL (2635).
*       5)  A BETTER WAY TO SPECIFY WHETHER THE LIST FILE IS TO 
*           REMAIN OPEN AT THE END OF LIST COMMANDS.
*       6)  'EP' COMMAND TO PURGE THE OLD COPY OF THE FILE AND CREATE A 
*           NEW VERSION WITHOUT EXTENTS.
* 
      SKP 
* 
      SUP 
* 
EDITL JSB GETST     GET 'RU' PARAMETERS 
      DEF *+4 
      DEF EBUF0 
      DEF M80 
      DEF ELNG
* 
      JSB PNAME     MOVE NAME TO ABORT MESSAGE
      DEF *+2 
      DEF ABORT 
* 
      JSB PNAME     MOVE NAME TO 'INVALID PARAMETER' MESSAGE
      DEF *+2 
      DEF MS000 
* 
      JSB PNAME     MOVE NAME TO 'INVALID COMMAND' MESSAGE
      DEF *+2 
      DEF MS001 
* 
      JSB PNAME     MOVE NAME TO 'FILE NAME MISSING' MESSAGE
      DEF *+2 
      DEF MS002 
* 
      JSB PNAME     MOVE NAME TO 'DELIMITER MISSING' MESSAGE
      DEF *+2 
      DEF MS004 
* 
      JSB PNAME     MOVE NAME TO 'NO ROOM' MESSAGE
      DEF *+2 
      DEF MS005 
* 
      JSB PNAME     MOVE NAME TO 'WRONG FILE TYPE' MESSAGE
      DEF *+2 
      DEF MS006 
* 
      JSB PNAME     MOVE NAME TO 'WAITING FOR XXXXXX' MESSAGE 
      DEF *+2 
      DEF WBUF
* 
* 
      LDB TBUFP     INITIALIZE THE BUFFER POINTERS
      STB TBUFF 
      LDB MBUFP 
      STB MBUFF 
      LDB PBUFP 
      STB PBUFF 
      LDB EBUFP 
      STB EBUFF 
      LDB XYBFP 
      STB XYBUF 
* 
      LDB M150      SET UP THE WINDOW 
      STB WIND2 
* 
      LDB ";"       INITIALIZE THE TABS 
      STB TABCR 
      LDB .7          TO COLUMNS 7 AND 21 
      STB TAB0
      LDB .21 
      STB TAB0+1
* 
* 
      LDB "/"       SET THE DEFAULT SPECIAL CHARACTERS
      STB DLMTR 
      LDB UNDEF 
      STB TERM
      STB XXXXX 
      STB NOT 
      LDB "\" 
      STB INDEF 
      LDB %R
      STB REPLA 
      LDB %B
      STB BREAK 
      LDB %X
      STB XTEND 
      LDB %C
      STB CANCL 
      LDB %S
      STB INSRT 
      LDB %T
      STB KLIP
      LDB %@
      STB ZLNG
* 
* 
      LDB M3        DEFAULT TO BELL OFF 
      STB /         (THREE-CHAR PROMPT) 
      LDB BELL
      STB /+2 
* 
      CCB 
      STB RPCNT 
      STB TTY       ASSUME NO INTERACTION 
      STB LIST      ASSUME NO LIST DEVICE 
* 
      LDB DSCR1     SET UP NAME POINTERS
      STB NAMO
      LDB DSCR2 
      STB NAMI
* 
* 
      JSB LIMEM     LOCK AVAILABLE MEMORY AFTER THE PROGRAM 
      DEF *+4 
      DEF ZERO      GET AVAILABLE MEMORY
      DEF DCBI      FIRST WORD
      DEF DCBSZ     NO. OF WORDS
* 
      LDA DCBSZ 
      ARS           DIVIDE AVAILABLE MEMORY INTO TWO DCB'S
      ADA M16 
      STA DCBSZ     LEAVE ROOM FOR DCB HEADER 
      ADA M128
      SSA 
      JMP ER005     INSUFFICIENT MEMORY FOR DCB BUFFER
      LDA DCBI
      ADA .16 
      ADA DCBSZ 
      STA DCBO      START OF OUTPUT DCB 
* 
      CLB           CLEAR SOME EDITOR FLAGS 
      STB SF1 
      STB SF2 
      STB LNAME 
      STB PASS1 
      STB ECCNT 
      STB TCCNT 
      STB TAB0+2
      STB INPUT 
      STB WIND1 
      STB CCCNT 
      STB LFLAG 
      STB CLNG
* 
      JSB MVW       ZERO THE DCB HEADERS
      DEF ZERO
      DEF DCBL        LIST DCB
.16   DEC 16
* 
      JSB MVW 
      DEF ZERO
      DEF DCBI,I      INPUT DCB 
      DEC 16
* 
      JSB MVW 
      DEF ZERO
      DEF DCBO,I      OUTPUT DCB
      DEC 16
* 
      JSB MVW 
      DEF ZERO
      DEF DCBE      COMMAND DCB 
      DEC 16
* 
      JSB MVW 
      DEF ZERO
      DEF DCBSH     SCRATCH DCB HEADER
      DEC 16
* 
      JSB MVW 
      DEF ZERO
      DEF DCBIH     INPUT DCB HEADER
      DEC 16
* 
      SKP 
* 
*     OPEN SOURCE AND COMMAND FILES 
* 
      JSB LOGLU     GET TERMINAL LU NUMBER
      DEF *+2 
      DEF RUBSH 
      STA LOG 
      IOR EBIT      ADD ECHO BIT
      STA ELOG
      IOR ZBIT      ADD Z-BIT 
      STA ZLOG
      LDA ELNG
      SZA 
      JMP STRNG     STRING PROVIDED, DO NOT PROMPT
* 
      STA TTY       TERMINAL AVAILABLE
      STA LIST      LIST DEVICE AVAILABLE 
LOGIN JSB TTYIP     REQUEST INPUT 
      DEF SORC? 
      LDA EBUFF,I 
      CPA ":."
      CLB,INB,RSS 
      JMP STRNG 
      CPB ELNG
      JMP ./AB      COLON (ONLY INPUT) MEANS ABORT
STRNG JSB SC.CR     PARSE SOURCE INPUT NAME 
      DEF INPUT 
      NOP           NULL FILE NAME
      CPA AA
      JMP ./AB      ABORT IF NAME = "A" 
      JSB SC.CR     SCRATCH FILE SIZE 
      DEF BUF10 
      NOP 
      STA SSIZE+1   (DOUBLE PRECISION VARIABLE) 
      JSB SC.CR     SCRATCH CARTRIDGE REFERENCE 
      DEF BUF10 
      NOP           (SHOULD DEFAULT TO FASTEST/LARGEST DISC)
      STA SCART 
      LDA TTY 
      SZA,RSS 
      JMP USLOG     TERMINAL IS COMMAND DEVICE
* 
      JSB SC.CR     PARSE COMMAND FILE NAME 
      DEF ENAME 
      JMP LOGON     A=0, ASSUME TERMINAL
      CPA LOG 
      JMP LOGON 
* 
      JSB OPENW     OPEN COMMAND FILE 
      DEF DCBE
      DEF RUBSH 
      DEF ENAME 
      DEF ZERO      OPTION
      DEF ESECR 
      DEF ECART 
      DEF .128
      JSB FMPER     PRINT ANY ERRORS
      DEF ENAME 
USLOG LDA INPUT 
      SZA,RSS 
      JMP NOSRC     NO SOURCE FILE NAME 
* 
      JSB OPENW     OPEN SOURCE INPUT 
      DEF DCBI,I
      DEF RUBSH 
DINPT DEF INPUT 
      DEF ZERO      STANDARD OPEN 
      DEF ISECR 
      DEF ICART 
      DEF DCBSZ 
      JSB FMPER     PRINT ANY ERRORS
      DEF INPUT 
      JSB FMP?      JUMP IF ERROR 
      DEF LOGIN     TRY AGAIN 
* 
* 
      JSB POST      CLEAR DCB BUFFER
      DEF *+2 
      DEF DCBI,I
      JSB FMPER 
      DEF INPUT 
      JSB FMP?      JUMP IF ERROR 
      DEF LOGIN     TRY AGAIN 
* 
* 
      JSB LOCF      FIND THE DISC LU
      DEF RTN12 
      DEF DCBI,I
      DEF RUBSH     (ERROR )
      DEF RUBSH     (RECORD)
      DEF RUBSH     (BLOCK )
      DEF RUBSH     (OFFSET)
      DEF ISIZE     SIZE IN SECTORS 
      DEF ICART     LU
RTN12 JSB FMPER     PRINT ANY ERRORS
      DEF INPUT 
      JSB FMP?      JUMP IF ERROR 
      DEF LOGIN     TRY AGAIN 
      LDA ICART 
      CMA,INA 
      STA ICART     NEGATIVE LU 
* 
      JSB MVW       SAVE THE DCB HEADER TEMPORARILY 
      DEF DCBI,I
      DEF DCBIH 
      DEC 16
* 
      JSB MVW       THEN ZERO IT
      DEF ZERO
      DEF DCBI,I
      DEC 16
* 
* 
      LDA ISIZE     CONVERT SECTORS TO BLOCKS 
      ARS 
* 
*     CREATE SCRATCH FILES
* 
NOSRC STA B         COMPUTE DEFAULT SIZE FOR SCRATCH FILES
      ADA M24 
      SSA 
      LDB .24       24 MINIMUM
      LDA SSIZE+1 
      SZA 
      STA B         OVERRIDE DEFAULT WITH OPERATOR INPUT
      STB SSIZE+1 
* 
      JSB CRETS     CREATE SCRATCH FILE 1 
      DEF RTN1
      DEF DCBO,I
      DEF RUBSH     ERROR CODE
      DEF .1        FILE NUMBER 
DSCR1 DEF SF1       NAME
      DEF SSIZE 
      DEF .4        TYPE
      DEF ZERO      SECR
      DEF SCART 
      DEF DCBSZ 
RTN1  JSB FMPER     PRINT ANY ERRORS
      DEF SCRAX 
      JSB FMP?      JUMP IF ERROR 
      DEF LOGIN     TRY AGAIN 
* 
* 
      JSB CRETS     CREATE SCRATCH FILE 2 
      DEF RTN2
      DEF DCBI,I
      DEF RUBSH 
      DEF .2        FILE NUMBER 
DSCR2 DEF SF2       NAME
      DEF SSIZE 
      DEF .4        TYPE
      DEF ZERO
      DEF SCART 
      DEF DCBSZ 
RTN2  JSB FMPER     PRINT ANY ERRORS
      DEF SCRAX 
      JSB FMP?      JUMP IF ERROR 
      DEF LOGIN     TRY AGAIN 
* 
      LDA INPUT 
      SZA,RSS 
      JMP RWND      NO SOURCE FILE, READY TO READ 
* 
* 
      JSB POST      CLEAR DCB BUFFER
      DEF *+2 
      DEF DCBI,I
      JSB FMPER 
      DEF SF2 
      JSB FMP?      JUMP IF ERROR 
      DEF LOGIN     TRY AGAIN 
* 
      JSB MVW       SAVE THE DCB HEADER 
      DEF DCBI,I
      DEF DCBSH 
      DEC 16
* 
      JSB MVW         AND BRING BACK THE INPUT HEADER 
      DEF DCBIH 
      DEF DCBI,I
      DEC 16
* 
      JSB MVW           THEN ZERO THE EXTRA COPY
      DEF ZERO
      DEF DCBIH 
      DEC 16
* 
* 
      LDA DINPT     SWITCH THE NAME POINTERS
      STA NAMI
      STA PASS1 
* 
      SKP 
* 
*     COMMAND INTERPRETER 
* 
* 
RWND  JSB RWNDI     REWIND INPUT FILE 
RWND2 JSB RWNDO     REWIND OUTPUT FILE
* 
READ1 JSB READ      READ IN FIRST LINE
* 
DISPL LDA TTY 
      STA LIST
      LDA CBUF0 
      ALF,ALF 
      AND LBYTE 
      CPA "<"       IF THE FIRST COMMAND IN THE SET WAS "<",
      RSS             SKIP LISTING PENDING LINE 
      JSB LSTSB     LIST PENDING LINE 
* 
NODE1 CLA 
      STA EXFLG     CLEAR THE EXCHANGE FLAG 
      LDA TTY 
      STA LIST      RESET LIST DEVICE 
* 
*     'X', 'Z', 'U', AND 'V' RETURN TO NODE2 UPON COMPLETION. 
*     SO THE EXCHANGE PATTERN REMAINS ENABLED.
* 
* 
NODE2 JSB TTYIP     INPUT COMMAND 
      DEF / 
      JSB CAPS      FETCH COMMAND CHARACTER 
      LDA "/"       NULL, DISPLAY NEXT LINE 
      CPA STAR
      JMP NODE2     COMMENT, NO ACTION
* 
      STA COMND     SAVE FOR LATER
      CPA "A" 
      JMP ./A       ABORT EDITOR
      CPA "_" 
      JMP ./_       RESCAN THIS LINE OF COMMAND INPUT 
      LDB SPACE     RESET TAB FILL
      STB TBFIL     TO SPACE
      CPA SPACE 
      JMP APEND     ADD A LINE
      CPA %G
      JMP ./CG      MUTE BELL WITH PROMPT.
      CPA "P" 
      JMP ./P       DISPLAY PENDING LINE
      CPA ">" 
      JMP ./>       ALLOW LISTING 
      CCB 
      CPA "<" 
      JMP ./<       DISALLOW LISTING
      STB TRFLG     ALLOW TRANSFER
      STB LCOMF     ALLOW LISTING 
      CPA "C" 
      JMP ./P       EDIT PENDING LINE & GOTO NEXT 
      CPA "!" 
      JMP ./!       PRINT SOURCE FILENAME 
      CPA "$" 
      JMP ./$       LIST OR CHANGE SPECIAL CHARACTERS 
      CPA "L" 
      JMP ./L       LIST SEVERAL LINES
      CLB 
      STB LCOMF     DON'T LIST
      CPA " 
      JMP ./"       DOUBLE EACH LINE
      CPA "&" 
      JMP ./&       APPEND NEXT LINE TO PENDING 
      CPA "#" 
      JMP ./#       APPEND SEQUENCE NUMBERS 
      CPA "O" 
      JMP ./O       COPY & EDIT PENDING LINE
      CPA "K" 
      JMP ./K       KILL TRAILING BLANKS
      CPA "M" 
      JMP ./M       MERGE FILE AFTER PENDING LINE 
      CPA "?" 
      JMP ./?       ANSWER A QUESTION 
      CPA "/"       SLASH AND "+" MEAN THE SAME 
      JMP NUMBR 
      CPA PLUSS 
      JMP NUMBR     GO DOWN SEVERAL LINES 
      CPA "E" 
      JMP ./E       END EDITOR
      CPA "N" 
      JMP ./N       DISPLAY PENDING LINE NUMBER 
      CPA "T" 
      JMP ./T       CHANGE TABS 
      CPA "U" 
      JMP ./U       UNCOND. REPLACE W/O LIST. 
      CPA "V" 
      JMP ./V       THIS WITH LIST. 
      CPA "W" 
      JMP ./W       SPECIFY A NEW WINDOW
      CPA "G" 
      JMP ./Z       EXCHANGE IN PENDING LINE
      CPA "X" 
      JMP ./X       EXCHANGE IN ALL LINES WITH LIST 
      CPA "Y" 
      JMP ./X       EXCHANGE IN PENDING LINE AND SEARCH FOR NEXT MATCH
      CPA "Z" 
      JMP ./Z       EXCHANGE IN ALL LINES W O LIST
      CPA "^" 
      JMP ./^       GO UP SEVERAL LINES 
      STB TRFLG     DON'T TRANSFER
      CPA MINUS 
      JMP NUMBR     DELETE SEVERAL LINES
      CPA "R" 
      JMP ./R       REPLACE PENDING LINE
      CPA "I" 
      JMP ./I       INSERT BEFORE 
      CPA "D" 
      JMP ./D       DELETE UNTIL MATCH
      CCB 
      STB TRFLG     DO TRANSFER 
      CPA "F" 
      JMP ./F       FIND MATCH
      CPA "B"       COMPLETE TRANSFER AND START SEARCH
      JMP ./B         FROM THE BEGINNING
      CPA "S" 
      JMP ./S       SEARCH AND MERGE
      CPA "@" 
      JMP ./@       FIND MATCH STARTING WITH PENDING LINE 
      CPA "H" 
      JMP ./H       PRINT HASH MARKS
      CPA TABCR 
      JMP TABAP     TAB, APPEND LINE
      ADA M58       CHECK FOR DIGIT 
      SSA,RSS 
      JMP ER001     ALPHA, ERROR
      ADA .10 
      SSA 
      JMP ER001 
* 
*     THIS ROUTINE POSITIONS TO A GIVEN LINE NUMBER.
*     LINES IN THE SOURCE CHAIN ARE SKIPPED TO
*     INSURE THAT LINE NUMBERS MATCH RECORD NUMBERS 
*     ON THE DISC.
* 
      CLA           RESET COMMAND 
      STA ECCNT       CHARACTER POINTER 
      JSB NUMIN     COMPUTE LINE NUMBER 
      CMA,INA,SZA,RSS  COMPLEMENT AND IF ZERO 
      CCA             SET TO -1 
      STA COUNT         AND SAVE
      STA TRFLG     SET TRANSFER FLAG 
      JSB NLSLU     SET UP NEW LU IF GIVEN
      LDA LINES 
      SZA,RSS       IF NULL INPUT FILE
      JMP BCKUP       BACK UP TO IT 
      ADA COUNT     SUBTRACT DESIRED LINE 
      SSA,RSS 
      JMP BCKUP 
      STA COUNT 
      JMP ./CC      FIND IT 
*** 
AA    ASC 1,A 
":."  ASC 1,: 
M24   DEC -24 
M58   DEC -58 
ZBIT  OCT 10000     Z-BIT 
EBIT  OCT 400       ECHO BIT
LOG   NOP           TERMINAL LU 
ZLOG  NOP           TERMINAL LU + Z-BIT 
ELOG  NOP           TERMINAL LU + ECHO BIT
* 
BUF10 BSS 10        PARSE BUFFER
* 
ENAME BSS 3         COMMAND FILE NAME 
      BSS 1 
ESECR BSS 1 
ECART BSS 1 
      BSS 4 
* 
* 
PASS1 BSS 1 
* 
.8    EQU * 
SORC? DEC 8 
      ASC 6,SOURCE FILE?
      OCT 6412      CARRIAGE RETURN, LINE FEED
      ASC 1,/_      PROMPT
* 
* 
* 
* 
SCRAX ASC 3,-SCR- 
      OCT 3         ASCII 
      REP 6 
      NOP 
* 
LOGON CLA 
      STA TTY 
      STA LIST
      JMP USLOG     NO COMMAND FILE, USE LOG DEVICE 
* 
* 
ER005 JSB REIO      PRINT 'NO ROOM' MESSAGE AND ABORT 
      DEF *+5 
      DEF .2
      DEF LOG 
      DEF MS005 
      DEF .8
      JMP STOP      ABORT EDIT
* 
MS005 ASC 8,XXXXX 5-NO ROOM 
* 
"!"   OCT 41
"     OCT 42
"#"   OCT 43
"$"   OCT 44
"&"   OCT 46
STAR  OCT 52        ASTERISK
"/"   OCT 57
";"   OCT 73        TAB CHARACTER 
"="   OCT 75
"<"   OCT 74
">"   OCT 76
"?"   OCT 77
"@"   OCT 100 
"A"   OCT 101 
"B"   OCT 102 
"C"   OCT 103 
"D"   OCT 104 
"E"   OCT 105 
"F"   OCT 106 
"G"   OCT 107 
"H"   OCT 110 
"I"   OCT 111 
"K"   OCT 113 
"L"   OCT 114 
"M"   OCT 115 
"N"   OCT 116 
"O"   OCT 117 
"P"   OCT 120 
"R"   OCT 122 
"S"   OCT 123 
"T"   OCT 124 
"U"   OCT 125 
"V"   OCT 126 
"W"   OCT 127 
"X"   OCT 130 
"Y"   OCT 131 
"Z"   OCT 132 
"\"   OCT 134 
"^"   OCT 136 
"_"   OCT 137 
%B    OCT 2 
%C    OCT 3 
%G    OCT 7 
%R    OCT 22
%S    OCT 23
%T    OCT 24
%X    OCT 30
.1    DEC 1 
.100  DEC 100 
.1000 DEC 1000
.10K  DEC 10000 
.128  DEC 128 
.13   DEC 13
.15   DEC 15
.2    EQU %B
.21   DEC 21
.24   EQU %X
.6    DEC 6 
/     OCT -4,6457,0 EDITOR PROMPT 
A     EQU 0 
B     EQU 1 
B133  OCT 133 
B1640 OCT 16400 
B77   EQU "?" 
BELL  OCT 57407     UNDERSCORE,BELL 
CCCNT BSS 1         CURRENT POSITION IN COMMAND STRING
CLNG  BSS 1         LENGTH OF COMMAND STRING
COMND BSS 1         CURRENT COMMAND 
COUNT BSS 1         RECORD COUNT FOR '+', '-', ETC. 
DCBI  BSS 1         POINTER TO CURRENT INPUT DCB
DCBO  BSS 1         POINTER TO CURRENT OUTPUT DCB 
DCBSZ BSS 1         SIZE OF BOTH MAIN DCB'S 
ELNG  BSS 1         LENGTH OF CURRENT COMMAND 
EBUFF BSS 1         POINTER TO CURRENT COMMAND
EBUFP DEF EBUF0 
ECCNT BSS 1         POSITION IN COMMAND BUFFER
EXFLG BSS 1         EXCHANGE FLAG 
* 
* 
FNAME BSS 3         FILE NAME FOR MERGE, LIST 
FCODE BSS 1 
FSECR BSS 1 
FCART BSS 1 
FTYPE BSS 1 
FSIZE BSS 1 
      BSS 2 
* 
* 
* 
* 
HLPNM ASC 3,&LHELP  HELP FILE NAME FOR '?' COMMAND
      OCT 3 
      REP 6 
      NOP 
* 
* 
* 
* 
INPUT ASC 3,INPUT   SOURCE FILE NAME
ICODE BSS 1 
ISECR BSS 1 
ICART BSS 1 
      BSS 1 
ISIZE BSS 1 
      BSS 2 
* 
* 
LINES BSS 1         LINE COUNTER
LIST  BSS 1         TYPE OF LIST FILE 
LFLAG BSS 1         LISTING ALLOWED IF ZERO 
LCOMF BSS 1         -1 FOR LIST COMMANDS, 0 OTHERWISE 
M1    DEC -1
M10   DEC -10 
M128  DEC -128
M150  DEC -150
M16   DEC -16 
M2    DEC -2
M3    DEC -3
M80   DEC -80 
MBUFF BSS 1         POINTER TO CURRENT MATCH BUFFER 
MBUFP DEF MBUF0 
MINUS OCT 55
NAMI  BSS 1         ADDRESS OF THE INPUT FILE NAME
NAMO  BSS 1         ADDRESS OF THE OUTPUT FILE NAME 
* 
PBUFF BSS 1         POINTER TO THE PENDING LINE BUFFER
PBUFP DEF PBUF0 
PLNG  BSS 1         LENGTH OF PENDING LINE
PCCNT BSS 1         CURRENT POSITION IN PENDING LINE
PLUSS OCT 53
RPCNT BSS 1         REPEAT COUNT FOR COMMAND INPUT
RUBSH BSS 1         ANYTHING I DON'T WANT GOES HERE 
* 
SF1   ASC 3,SF1     SCRATCH FILE NAME 
      OCT 3 
      REP 6 
      NOP 
* 
SF2   ASC 3,SF2     SCRATCH FILE NAME 
      OCT 3 
      REP 6 
      NOP 
* 
SCART NOP           SCRATCH FILE CARTRIDGE REFERENCE
* 
SLNG  NOP           NUMBER OF RECORDS ON THE STACK
SPACE OCT 40
SSIZE DEC 0,0,0,0   DOUBLE INTEGER SCRATCH FILE SIZE
T#WDS OCT 0,0       CURRENT # OF WORDS IN DEST. FILE
T#REC BSS 1         CURRENT # OF REC IN DEST FILE 
* 
TAB0  BSS 10        ARRAY OF TAB STOPS
      DEC 0           ARRAY TERMINATOR
TABUF DEF TAB0      POINTER TO THE TAB SETTINGS BUFFER
TBFIL BSS 1         FILL CHARACTER FOR WHEN TAB IS USED 
TBPNT BSS 1         INDEX TO WHICH TAB SETTING
* 
TBUFF BSS 1         POINTER TO TEMPORARY BUFFER 
TTY   BSS 1         INTERACTIVE COMMAND INPUT DEVICE IF 0 
TCCNT BSS 1         NUMBER OF CHARACTERS ACTUALLY IN TBUFF
TBUFP DEF TBUF0 
TRFLG BSS 1         TRANSFER ENABLED IF -1
TRUNC BSS 1 
UNDEF ASC 1,??
WIND1 BSS 1         STARTING COLUMN OF THE WINDOW::DEFAULT=0
WIND2 BSS 1         END COLUMN OF THE WINDOW::DEFAULT=150 
* 
* 
* 
XYBUF BSS 1         POINTER TO EXCHANGE BUFFER
XYBFP DEF XYBF0 
%@    EQU *         ZERO-LENGTH-LINE CONSTANT 
ZERO  REP 16
      OCT 0 
* 
      SKP 
* 
*     DOUBLE PENDING LINE 
* 
* 
./"   JSB NUMIN     GET COUNT 
      CMA,INA,SZA,RSS 
      CCA           DEFAULT TO PENDING LINE ONLY
      STA COUNT 
      LDA PLNG
      SSA 
      JMP DISPL     END OF FILE - NO ACTION 
./"1  CLA 
      STA TCCNT     RESET OUTPUT BUFFER COUNT 
      JSB PCH       GET PENDING LINE CHARACTER
      JMP *+3       END OF LINE 
      JSB OUTCR     OUTPUT TO TBUF
      JMP *-3       ALL OF LINE 
* 
      CLA 
      STA PCCNT     RESET PENDING LINE CHAR COUNT 
      JSB PCH 
      JMP *+3       END OF PENDING LINE 
      JSB OUTCR     OUTPUT TO TBUF AGAIN
      JMP *-3       ALL OF LINE 
* 
      JSB ./R$      REPLACE PENDING LINE WITH TBUF
      ISZ COUNT 
      RSS 
      JMP DISPL     DONE, DISPLAY PENDING LINE
      JSB TR        COPY TO OUTPUT FILE 
      JMP ./"1      NEXT LINE 
      SKP 
* 
*     '&' COMMAND --  APPEND NEXT LINE TO PENDING LINE
* 
./&   LDA PLNG
      SSA 
      JMP DISPL     END OF FILE, NO ACTION
      JSB PCH       MOVE PENDING LINE TO TBUFF
      JMP *+3 
      JSB OUTCR 
      JMP *-3 
* 
      JSB READ      READ NEXT LINE
      SSA 
      JMP ./&1      END OF FILE, RESTORE PREVIOUS LINE
      JSB PCH       ADD TO PREVIOUS PENDING LINE
      JMP *+3 
      JSB OUTCR 
      JMP *-3 
* 
./&1  JSB ./R$      MOVE TBUFF TO PENDING LINE
      JMP DISPL     DISPLAY RESULT
      SKP 
* 
*     'L' COMMAND -- LIST N LINES 
* 
./L   CLA 
      STA LIST
* 
*     '-', '/', AND '+' COMMANDS
* 
NUMBR JSB NUMIN     READ NUMERIC PARAMETER
      CMA,INA,SZA,RSS COMPLEMENT NUMBER 
      CCA           IF NUMBER IS ZERO SET 
      STA COUNT      TO -1
      JSB NLSLU     SET UP NEW LU IF GIVEN
./CC  JSB TR
FNUM2 ISZ COUNT     FOUND LINE NUMBER?
      JMP ./CC      NO, FETCH NEXT LINE 
      JMP DISPL     YES, DISPLAY IT 
*** 
* 
*     'F' COMMAND 
* 
./F   JSB TAB       EXPAND TABS 
SERCH JSB M.T       MOVE PATTERN TO MATCH BUFFER
NEXT  JSB TR        WRITE PENDING LINE & READ NEXT
COMP@ JSB MACH?     COMPARE PENDING LINE TO MATCH BUFFER
      JMP NEXT      PATTERN NOT FOUND - CONTINUE
      JMP DISPL     FOUND - DISPLAY IT
* 
* 
*     '@' COMMAND 
* 
./@   JSB TAB       EXPAND ANY TABS 
      JSB M.T       MOVE PATTERN TO MATCH BUFFER
      LDA PLNG
      SSA 
      JMP DISPL     END OF FILE, NO MATCH 
      JMP COMP@     COMPARE STARTING WITH PENDING LINE
* 
* 
*     'D' COMMAND -- DELETE TO PATTERN
* 
./D   JSB TAB       EXPAND TABS 
      JSB M.T       MOVE PATTERN TO MATCH BUFFER
      JSB TTYIP     ASK FOR LIMIT 
      DEF MAXDL 
      JSB NUMIN 
      CMA,INA,SZA,RSS 
      JMP DISPL     ZERO, NO LINES LOST 
      STA COUNT 
      JSB NLSLU     SET UP NEW LIST FILE
./D1  JSB TR        TRANSFER RECORD 
      JSB MACH?     CHECK FOR MATCH 
      RSS 
      JMP DISPL     FOUND IT
      ISZ COUNT 
      JMP ./D1      CONTINUE
      JMP DISPL     LINE LIMIT EXCEDED
* 
* 
MAXDL DEC 10
      ASC 10,MAX. NO. OF LINES? _     FOR DELETE
* 
* 
* 
* 
* 
*     '<'  AND  '>'  COMMANDS 
* 
./>   JSB NLSLU     OPEN NEW LIST FILE
      JSB NLSLU     (ALLOW FOR COMMA BEFORE FILE NAME)
      CLB             AND ALLOW LISTING 
./<   STB LFLAG     LIST FLAG 
      JMP NODE1     FETCH NEXT COMMAND
* 
* 
* 
* 
*     REPEAT BLOCK OF COMMANDS
* 
* 
* 
./_   JSB NUMIN     GET REPEAT COUNT
      CMA,INA,SZA,RSS 
      CCA           DEFAULT TO ONE
      LDB TRUNC 
      STB CLNG
      STB CCCNT     RESET COMMAND BUFFER POINTERS 
      SZB,RSS 
      ADA M1        NULL COMMAND HAS NOT YET EXECUTED 
      STA RPCNT 
      JMP NODE1     FETCH FIRST COMMAND IN LINE 
* 
      SKP 
* 
* 
*     BACK UP 'N' LINES 
*     LINES ARE RE-NUMBERED IF ADDITIONS OR DELETIONS HAVE BEEN MADE
* 
* 
./^   JSB NUMIN     BACK UP 'N' LINES 
      CMA,INA,SZA,RSS 
      CCA           DEFAULT TO ONE LINE 
      ADA T#REC 
      SSA,RSS 
      CMA,SZA,RSS   COMPUTE LINE NUMBER IN OUTPUT FILE
      CCA 
      STA COUNT 
      JSB NLSLU     CHECK FOR LIST DEVICE 
* 
* 
BCKUP LDA EXFLG 
      SZA,RSS 
      JMP NOEXC     EXCHANGE NOT ENABLED
* 
FNUM3 JSB ./B1      ROLL OVER FILE
      JSB READE     READ FIRST LINE 
      JMP FNUM2 
* 
NOEXC STA LCOMF     INHIBIT LISTING 
      LDB T#REC 
      ADB COUNT     LINE NUMBER IN OUTPUT FILE
      CMB,SZB,RSS 
      JMP DISPL     ALREADY AT THE LINE 
      STB BKUPC     BACK-UP LINE COUNT
* 
      JSB POSTI     FREE UP THE INPUT BUFFER
* 
PUSHM JSB PUSH      PUSH A LINE ONTO THE STACK
      JMP FNUM3     STACK OVERFLOW
* 
      JSB GET       GET A LINE FROM THE OUTPUT FILE 
      JMP RWND2     START OF FILE, DONE 
* 
      JSB FMP?      CHECK FOR FMP ERRORS
      DEF WE
      JSB BRK?      CHECK BREAK FLAG
      DEF WE        JMP OUT 
      ISZ BKUPC 
      JMP PUSHM 
* 
WE    JSB WEOF      WRITE AN END OF FILE
      JMP DISPL     DISPLAY THE NEW PENDING LINE
* 
BKUPC NOP 
* 
      SKP 
* 
*     APPEND SEQUENCE NUMBERS 
*** 
./#   JSB ECH       SKIP OVER 
      NOP           ALPHA COMMENT.
      JSB ECH 
      NOP 
      JSB ECH 
      NOP 
      JSB NUMIN     FETCH START NUMBER
      STA BASE       AND SAVE AS BASE 
      JSB NUMIN     FETCH 2ND NUMBER
      SZA,RSS       IF ZERO SET 
      LDA .10        TO 10 AND
      STA INCR        SAVE AS INCREMENT 
      JSB NUMIN     FETCH STARTING COLUMN 
      CMA,INA,SZA,RSS 
      LDA M73       DEFAULT TO COLUMN 73
      STA COLMN 
      JSB ./B1       GO TO BEGINNING OF FILE
      JSB READE     READ A LINE 
*** 
./#1  CLA           RESET CHARACTER OUTPUT
      STA TCCNT      COUNTER
      LDA COLMN     MOVE
      INA,SZA,RSS 
      JMP ./#3      START IN COLUMN ONE 
      STA COUNT      FIRST PART OF SOURCE 
./#2  JSB PCH         CHARACTERS
      LDA SPACE        OF SOURCE
      JSB OUTCR         TO OUTPUT 
      ISZ COUNT          BUFFER 
      JMP ./#2
* 
./#3  CLA,INA       SET UP COMMAND
      STA ECCNT      BUFFER COUNTER 
      LDA M3        SET UP LOOP 
      STA COUNT      COUNTER FOR 3 CHARACTERS 
./#4  JSB ECH       FETCH NEXT ALPHA COMMENT
      LDA SPACE     LOAD BLANKS IF NO COMMENT 
      JSB OUTCR     OUTPUT CHARACTER
      ISZ COUNT     THIRD CHARACTER?
      JMP ./#4      NO, FETCH NEXT CHARACTER
*** 
      LDA BASE      OUTPUT LINE NUMBER
      CLB 
      JSB DEC        IN ASCII 
      LDA BASE      UPDATE
      ADA INCR       LINE 
      STA BASE        NUMBER
      JSB ./R$      SWAP TBUFF AND PBUFF
      JSB TR        WRITE PENDING LINE AND READ NEXT
      JMP ./#1      CONTINUE
*** 
BASE  NOP 
INCR  NOP 
COLMN NOP 
M73   DEC -73 
      SKP 
* 
*     SET UP WINDOW FOR SEARCH AND EXCHANGE COMMANDS
* 
./W   JSB CHKN      CHECK PARAMETERS
      JSB NUMIN     FETCH 
      SZA            START OF 
      ADA M1          WINDOW
      STA CHKN         POINTER
      JSB NUMIN     FETCH 
      CMA,INA,SZA,RSS  END OF 
      LDA M150        WINDOW
      STA B            POINTER
      ADA CHKN      TEST THAT START IS BEFORE END 
      SSA,RSS 
      JMP ER000 
      LDA CHKN
      STA WIND1     STORE NEW VALUES
      STB WIND2 
      JMP NODE1     GET NEXT COMMAND
* 
      SKP 
* 
*     DELETE TRAILING BLANKS FROM THE FILE
* 
./K   JSB ./B1      ROLL-OVER FILE
      JSB READE     READ FIRST LINE 
./K1  LDA PLNG
      INA           ROUND UP
      CLE,ERA       CONVERT TO WORD COUNT 
./K2  ADA M1        BACK UP ONE WORD
      SZA,RSS 
      JMP ./K3      DO NOT DELETE LAST WORD 
      LDB PBUFF 
      ADB A 
      LDB B,I 
      CPB SPSP      CHECK FOR 2 BLANKS
      JMP ./K2      YES, DECREMENT LINE LENGTH
./K3  INA 
      ALR           CONVERT TO CHARACTER COUNT
      STA PLNG      STORE NEW RECORD LENGTH 
      JSB TR        MOVE NEW RECORD TO DEST. FILE 
      JMP ./K1      AND FIX IT
* 
      SKP 
* 
*     SET UP TAB CHARACTER AND TAB STOPS
* 
./T   JSB ECH       STEP PAST TAB CHAR. 
      JMP ./T1       NONE, SO DISABLE TAB 
      JSB CHKN        OTHERWISE CHECK PARAMETERS
      JSB ECH       GET TAB CHARACTER 
./T1  LDA UNDEF     DISABLE TABS
      STA TABCR     STORE TAB CHARACTER 
      LDA TABUF     RESET TAB ADDRESS 
      STA TBPNT      POINTER
      LDA M10       10 TAB STOPS MAX. 
      STA TR
      STA TABSV     TERMINAL TABS NEED TO BE SET
      LDA ECCNT     IF ONLY TAB CHARACTER 
      CPA ELNG         GIVEN, THEN RETURN 
      JMP ./$1          WITH TABS UNCHANGED 
NXTNM JSB NUMIN     GET NEXT NUMBER 
      STA TBPNT,I   STORE TAB NUMBER
      ISZ TBPNT     BUMP POINTER
      ISZ TR      LAST TAB? 
      JMP NXTNM     NO, CONTINUE
      JMP ./$1      GO PRINT SPECIAL CHARACTERS 
* 
      SKP 
* 
*     THIS ROUTINE SETS UP THE X-Y BUFFER.  THE FIRST 
*     HALF OF THE BUFFER IS MATCHED AGAINST THE PENDING 
*     LINE.  IF THE MATCH SUCCEEDS, THE SECOND HALF 
*     OF THE X-Y BUFFER REPLACES THOSE CHARACTERS.
* 
./U   CLA 
./V   CCB,RSS 
./Z   CLA           IF "Z" RESET LIST FLAG
./X   STA XLIST     IF "X" OR "Y" SET FLAG
      STB UNCON 
      CLB,INB 
      STB EXFLG     SET EXCHANGE FLAG 
      CPB ELNG
      JMP XSET1     NULL PATTERN, USE PREVIOUS PATTERN
      LDA EBUFF,I 
      AND LBYTE 
      CPA DLMTR 
      JMP FINDP     FIRST CHAR IS DLMTR, USE 'F' PATTERN
XSET4 ALF,ALF 
      IOR DLMTR 
      ALF,ALF 
      STA EBUFF,I   INSERT WINDOW CHARACTER 
XSET2 JSB ECH       FETCH NEXT PATTERN CHARACTER
      JMP ER004     NO DELIMITER
      CPA DLMTR     IF NULL PATTERN CHARACTER 
      CCA,RSS 
      JMP XSET2 
      ADA ECCNT 
      STA XLNG      LENGTH OF MATCH FIELD 
      INA 
      STA YOFFS     OFFSET OF REPLACEMENT FIELD WITHIN BUFFER 
      CMA,INA 
      ADA ELNG
      STA YLNG      REPLACEMENT PATTERN LENGTH
      LDA EBUFF 
      LDB XYBUF 
      STB EBUFF 
      STA XYBUF 
XSET1 LDB COMND     LOAD COMMAND CHARACTER
      CPB "G"       PENDING LINE EXCHANGE?
      JMP ./G        YES - GO DO IT 
      CPB "Y"       IF "Y" COMMAND
      CLA,RSS        PERFORM SEARCH 
      JMP NODE2     ELSE, FETCH NEXT COMMAND
*** 
*     COPY PATTERN TO MBUFF AND SEARCH
      STA MX.CN     RESET EXCHANGE AND
      STA TCCNT         OUTCR CHARACTER COUNTERS
      LDA XLNG
      STA MX.LN 
      LDA XYBUF 
      STA MX.BF 
XSET5 JSB MX.CH     EXCHANGE CHARACTER
      JMP SERCH     END OF PATTERN
      JSB OUTCR 
      JMP XSET5 
* 
LBYTE OCT 377 
./G   JSB CXT       PERFORM EXCHANGE IN PENDING LINE ONLY 
      JMP DISPL      THEN DISPLAY LINE
* 
UNCON NOP 
XLIST NOP 
XLNG  NOP 
YLNG  NOP 
YOFFS NOP 
* 
* 
FINDP LDB UNCON 
      SZB 
      JMP XSET4     UNCONDITIONAL EXCHANGE
      STB MX.CN     USE PREVIOUS 'FIND' PATTERN 
      LDA MBUFF 
      STA MX.BF 
      LDA MLNG
      STA MX.LN 
      STA YOFFS 
      ISZ YOFFS 
      STA XLNG      OLD PATTERN LENGTH
      LDA ELNG
      ADA M2
      STA YLNG      NEW PATTERN LENGTH
* 
LP1   JSB MX.CH     FETCH  'FIND' CHAR
      JMP LP2 
      JSB OUTCR 
      JMP LP1 
* 
LP2   JSB ECH       FETCH NEW PATTERN CHAR
      JMP XSET3     END OF INPUT
      JSB OUTCR 
      JMP LP2 
* 
XSET3 LDA TBUFF     SWAP TBUFF AND EXCHANGE BUFFER
      LDB XYBUF 
      STB TBUFF 
      STA XYBUF 
      JMP XSET1 
* 
      SKP 
* 
*     TAB CHARACTER COMMAND -- APPEND LINE
* 
TABAP CLA 
      STA ECCNT 
* 
*     INSERT LINE OF TEXT AFTER PENDING LINE
* 
APEND LDA PLNG      IF NOT AT 
      SSA,RSS        EOF THEN 
      JSB OUTPT       OUTPUT CURRENT LINE 
* 
* 
*     REPLACE PENDING LINE WITH LINE IN OUTPUT BUFFER 
* 
./R   JSB TAB       EXPAND TABS 
      JSB ./R$      PERFORM REPLACEMENT 
      JMP NODE1        GET NEXT COMMAND 
* 
*     INSERT LINE OF TEXT BEFORE PENDING LINE 
* 
./I   JSB TAB       EXPAND TABS 
      JSB E.P       SAVE PENDING LINE 
      JSB ./R$      MOVE TABBED LINE TO PENDING LINE
      JSB OUTPT     OUTPUT PENDING LINE 
EP    JSB E.P       RESTORE PREVIOUS PENDING LINE 
      JMP NODE1 
* 
*     IF BELL (PROMPT) IS ON, TURN IT OFF.  IF OFF, RESTORE IT. 
* 
./CG  LDA /+2 
      ALF,ALF 
      STA /+2       REVERSE ORDER OF _ AND BELL.
      CLA,INA 
      XOR /         SHORTEN OR LENGTHEN 
      STA /           MESSAGE LENGTH. 
      JMP NODE1 
*** 
* 
*     'H' COMMAND -- PRINT HASH MARKS AND TAB STOPS 
* 
./H   JSB LST       PRINT HASH MARKS
      DEF HASH
      DEF .35 
* 
      LDA TABCR 
      CPA UNDEF 
      JMP NODE1     NO TABS 
* 
      LDA TABUF 
      STA TBPNT 
TBLP  LDB TBPNT,I   GET NEXT TAB STOP 
      CMB,INB,SZB,RSS 
      JMP TBDIS     LAST STOP, DISPLAY THEM 
      ISZ TBPNT 
      ADB TCCNT 
      SSB,RSS 
      JMP TBDIS     STOP OUT OF ORDER 
      INB,SZB,RSS 
      JMP TOUT      NO SPACES BEFORE 'T'
      STB TABSV 
* 
TBLP2 LDA SPACE 
      JSB OUTCR     OUTPUT SPACES 
      ISZ TABSV 
      JMP TBLP2 
* 
TOUT  LDA "T" 
      JSB OUTCR     OUTPUT A 'T' AT THE TAB POSITION
      JMP TBLP
* 
TBDIS LDA TCCNT 
      INA 
      ARS           CONVERT CHARS TO WORDS
      STA TCCNT 
      JSB LST       DISPLAY THE LINE
      DEF TBUFF,I 
      DEF TCCNT 
      JMP NODE1 
* 
* 
.35   DEC 35
* 
HASH  ASC 20,''''/''''1''''/''''2''''/''''3''''/''''4 
      ASC 15,''''/''''5''''/''''6''''/''''7 
* 
      SKP 
*     EDIT PENDING LINE 
*        SUBFUNCTIONS:
*     - INSERT CHARACTERS 
*     - DELETE CHARACTERS 
*     - REPLACE CHARACTERS (INITIAL MODE) 
*     - TRUNCATE REMAINDER OF LINE
*     - EXTEND CURRENT LINE 
*     - BREAK CURRENT LINE INTO TWO LINES 
* 
* 
*     COPY PENDING LINE AND EDIT ('P') NEW LINE 
* 
./O   LDA PLNG
      SSA 
      JMP DISPL     END OF FILE - DO NOT COPY PENDING LINE
      JSB OUTPT     OUTPUT PENDING LINE 
      CLA 
      STA PCCNT 
* 
*     EDIT PENDING LINE 
* 
./P   LDA PLNG
      SSA           IF END OF FILE
      JMP DISPL       JUST PRINT 'EOF'
      LDA DLMTR     USE DLMTR FOR TAB 
      CPA UNDEF 
      LDA SPACE       OR SPACE, IF UNDEFINED
      STA TBFIL 
      JSB TAB       TAB THE LINE
      JSB SWPET     SET UP INPUT BUFFER 
RPMOD LDA REPLA 
MODE  STA PMODE     INITIAL MODE IS REPLACE 
PNXT  JSB ECH       GET A CHARACTER 
      JMP PFIN      IF EOL THEN EXIT
      CPA REPLA 
      JMP MODE      REPLACE MODE
      CPA INSRT 
      JMP MODE      INSERT MODE 
      CPA CANCL 
      JMP MODE      DELETE MODE 
      CPA KLIP
      JMP KLIP2     TRUNCATE LINE 
      CPA XTEND 
      JMP FNDEN     EXTEND LINE 
      CPA BREAK 
      JMP BRKLN     SPLIT LINE IN TWO 
      LDB PMODE     GET THE CURRENT MODE
      CPB INSRT     IF INSERT 
      JMP PINS      GO INSERT 
      CPB CANCL     IF DELETE 
      JMP PDLS      GO DELETE 
* 
      CPA DLMTR     IS IT REALLY COPY 
      JMP PCOPY     YES GO COPY 
      JSB OUTCR     OUTPUT THE NEW CHARACTER
*** 
PDLS  JSB PCH       GET THE OLD CHARACTER 
      NOP           IGNOR EOL 
      JMP PNXT      BURN THE OLD AND GO GET THE NEXT
*** 
PCOPY JSB PCH       GET THE CURRENT CHARACTER 
      LDA SPACE     USE BLANK IF UNDEFINED
      JMP PINS2 
*** 
PINS  CPA DLMTR     INSERT SPACES FOR 
      LDA SPACE      DELIMITER
PINS2 JSB OUTCR     SEND IT OUT 
      JMP PNXT      GO PROCESS THE NEXT CHAR. 
*** 
PFIN  JSB PCH       MOVE THE REST 
      JMP ./RP      OF THE LINE 
      JSB OUTCR     TO THE OUTPUT 
      JMP PFIN      BUFFER
*** 
KLIP2 LDA PLNG
      STA PCCNT 
      JMP RPMOD 
* 
* 
PMODE NOP 
SPCNT NOP 
*** 
./RP  JSB ./R$      REPLACE PENDING LINE
      LDA COMND 
      CPA "C" 
      JSB TR        IF C COMMAND OUTPUT PENDING LINE
      JMP DISPL     DISPLAY NEW PENDING LINE
*** 
FNDEN CLA 
      STA SPCNT     NO BLANKS SO FAR
PNXT2 JSB PCH       COPY ALL CHARACTERS 
      JMP TRAIL       END OF PENDING LINE 
      CPA SPACE 
      JMP BMPSP     CHECK FOR TRAILING BLANKS 
      JSB OUTCR 
      JMP FNDEN 
BMPSP ISZ SPCNT     BUMP COUNT OF TRAILING SPACES 
      JSB OUTCR 
      JMP PNXT2 
TRAIL LDA SPCNT     SUBTRACT TRAILING BLANKS
      CMA,INA 
      ADA TCCNT       FROM THE OUTPUT CHARACTER COUNT 
      STA TCCNT 
      JMP RPMOD 
*** 
BRKLN LDA PCCNT 
      STA STLN      SAVE CURRENT LINE COUNTERS
      LDA PLNG
      STA ENLN
      CLA 
      STA EXFLG     EXCHANGE WOULD MODIFY SAVED LINE
      JSB ./R$
      JSB OUTPT     OUTPUT THE FIRST HALF 
      JSB ./R$
      LDA STLN
      STA PCCNT     RESTORE CURRENT LINE COUNTERS 
      LDA ENLN
      STA PLNG
      CLA 
      STA TCCNT 
      JMP RPMOD 
* 
      SKP 
* 
*     MERGE FILE - PARTIAL FILES MERGED BY LINE NUMBER. 
*     MAY BE USED TO RECOVER FROM ACCIDENTAL DELETE.
* 
./M   JSB SC.CR     PARSE FILENAME
      DEF FNAME 
      JMP ER002     NAME MUST BE SPECIFIED
      JSB NUMIN     GET STARTING LINE 
      SZA,RSS 
      CLA,INA       DEFAULT TO START OF FILE
      STA STLN
      JSB NUMIN     GET END LINE
      STA ENLN      DEFAULT TO END OF FILE
      JSB INSRC     OPEN MERGE FILE 
      CLA 
      STA SC.CR     SET LINE COUNT TO ZERO
.M1   JSB RDM       READ A LINE 
      JSB FMP?      CHECK FOR ERRORS
      DEF ENDM
      JSB BRK?      TEST BREAK FLAG 
      DEF ENDM
      ISZ SC.CR 
      LDA SC.CR 
      CPA STLN      START MERGE?
      RSS           YES 
      JMP .M1       NO
.M2   JSB OUTPT     COPY TO DESTINATION 
      JSB FMP?      JUMP IF ERROR 
      DEF ENDM
      JSB BRK?      TEST BREAK FLAG 
      DEF ENDM      QUIT
      LDA SC.CR 
      CPA ENLN      END MERGE?
      JMP ENDM      YES 
      JSB RDM       READ NEXT LINE
      ISZ SC.CR     BUMP LINE COUNT 
      JMP .M2 
* 
* 
ENDM  JSB CLOSE     CLOSE MERGE FILE
      DEF *+2 
      DEF DCBL
ENDER JSB FMPER 
      DEF FNAME 
      JMP READ1     READ NEXT LINE OF SOURCE
*** 
STLN  NOP 
ENLN  NOP 
* 
      SKP 
* 
*     'B' COMMAND - SEARCH FROM START OF FILE 
* 
./B   JSB TAB       EXPAND TABS 
      JSB M.T       MOVE NEW PATTERN TO MATCH BUFFER
      JSB ./B1      PERFORM TRANSFER
      JSB READE     READ FIRST LINE 
      JMP COMP@     START SEARCH
* 
*     ./A ABORTS EXECUTION
*     SOURCE FILES AND SCRATCH FILES NOT PURGED 
* 
./A   JSB ECH       IF ANY CHARACTERS 
      RSS            FOLLOWING THE "A"
      JMP ER001    RETURN TO SYNTAX INSTEAD OF ABORT
./AB  JSB ERROR     PRINT MESSAGE 
      DEF ABORT 
      DEC 7 
      JMP OUT 
ABORT ASC 7,XXXXX ABORTED 
      SKP 
* 
*./E END OF EDITOR COMMAND
*     EC CREATES A NEW FILE 
*     ER REPLACES AN EXISTING FILE (DEFAULT = ORIGINAL INPUT FILE)
*     EN RENAMES THE CURRENT OUTPUT SCRATCH FILE
* 
./E   JSB CAPS      GET NEXT CHAR OF COMMAND
      JMP ER001     NONE, ILLEGAL 
      CPA "C"       IF C
      JMP CRFIL       GO TO CREATE FILE 
      CPA "P" 
      JMP CHEKP     PURGE ORIGINAL, THEN CREATE NEW FILE
      CPA "R"       IF R
      JMP CHEKR       GO TO REPLACE FILE
      CPA "N"       IF N
      RSS             GO TO RENAME FILE 
      JMP ER001       OTHERWISE GO TO ER001 
* 
      JSB SC.CR     PARSE FILE NAME 
      DEF FNAME 
      JMP ER002     NAME MUST BE SPECIFIED
* 
      JSB ./B1      ROLL OVER FILE
      JSB CLOZE     CLOSE THE INPUT FILE
      DEF DCBI,I
      DEF NAMI,I
      JSB FMP?      JUMP IF ERROR 
      DEF DISPL 
* 
      JSB NAMF      RENAME INPUT FILE 
      DEF *+7 
      DEF DCBI,I
      DEF RUBSH 
      DEF NAMI,I    INPUT FILE NAME 
      DEF FNAME 
      DEF FSECR     SECURITY
      DEF FCART     CART. REF.
      SSA,RSS 
      JMP OUT       SUCCESSFUL RENAME 
      JMP FMPC      ERROR 
* 
CRFIL JSB SC.CR     PARSE FILE NAME 
      DEF FNAME 
      JMP ER002     NAME MUST BE SPECIFIED
* 
      JSB CRSUB     CHECK TYPE AND SIZE 
* 
* 
CRETE JSB CREAT     CREATE NEW FILE 
      DEF *+9 
      DEF DCBO,I
      DEF RUBSH 
      DEF FNAME 
      DEF FSIZE 
      DEF FTYPE 
      DEF FSECR 
      DEF FCART 
      DEF DCBSZ 
      SSA,RSS 
      JMP SW1       SWITCH THE NAME POINTER 
FMPE  JSB FMPER     PRINT THE ERROR 
      DEF FNAME 
      JMP FMPEX     ERROR 
* 
BLOKS NOP 
.4    DEC 4 
* 
CHEKP JSB SC.CR     PARSE FILE NAME 
      DEF FNAME 
      RSS 
      JMP PFILE     NAME SPECIFIED
      LDB INPUT 
      SZB,RSS 
      JMP ER002     ERROR IF NO NAME ENTERED ORIGINALLY 
* 
      JSB MVW       USE SOURCE FILE NAME
      DEF INPUT 
      DEF FNAME 
      DEC 10
* 
      CLA 
      STA FSIZE     USE DEFAULT SIZE, NOT ORIGINAL SIZE 
* 
PFILE JSB CRSUB     CHECK TYPE AND SIZE 
* 
      JSB PURGE     PURGE THE OLD FILE
      DEF PER3
      DEF DCBO,I
      DEF RUBSH 
      DEF FNAME 
      DEF FSECR 
      DEF FCART 
* 
PER3  SSA 
      CPA M6
      JMP CRETE     FILE NOT FOUND OR SUCCESSFULLY PURGED 
      JMP FMPE      PRINT ANY ERROR EXCEPT 'FILE NOT FOUND' 
* 
* 
* 
* 
CRSUB NOP           CHECK FILE TYPE AND SIZE
      LDA FCODE 
      RAR 
      SLA,RSS 
      JMP RPFIL     NUMERIC NAMR, STORE ON LU 
* 
      LDA FTYPE 
      CPA .1
      JMP ER006     WRONG FILE TYPE 
      CPA .2
      JMP ER006     WRONG FILE TYPE 
* 
      JSB ./B1      COMPLETE TRANSFER TO OUTPUT FILE
      LDA FSIZE 
      SZA           IF NO. OF BLOCKS REQUESTED IS ZERO
      SSA             OR NEGATIVE 
      LDA BLOKS         DEFAULT TO ACTUAL SIZE OF FILE
      STA FSIZE 
* 
      LDA FTYPE 
      SZA,RSS 
      LDA .4        DEFAULT TO TYPE 4 
      STA FTYPE 
* 
      JSB CLOZE     CLOSE THE OUTPUT FILE 
      DEF DCBO,I
      DEF NAMO,I
      JSB FMP?      JUMP IF ERROR 
      DEF DISPL 
      JMP CRSUB,I 
* 
* 
* 
* 
CHEKR JSB SC.CR     PARSE FILE NAME 
      DEF FNAME 
      RSS           NO NAME SPECIFIED 
      JMP RPFIL 
      LDB INPUT     DEFAULT TO INPUT FILE NAME
      SZB,RSS       ERROR IF NO NAME ENTERED ORIGINALLY 
      JMP ER002 
      JSB MVW       MOVE NAME TO FNAME
      DEF INPUT 
DFNAM DEF FNAME 
.10   DEC 10
* 
RPFIL JSB ./B1      COMPLETE TRANSFER TO OUTPUT FILE
      JSB CLOZE     CLOSE THE OUTPUT SCRATCH FILE 
      DEF DCBO,I
      DEF NAMO,I
      JSB FMP?      JUMP IF ERROR 
      DEF DISPL 
* 
      JSB OPENW     OPEN REPLACE FILE 
      DEF DCBO,I
      DEF RUBSH 
      DEF FNAME 
      DEF ZERO
      DEF FSECR 
      DEF FCART 
      DEF DCBSZ 
      SSA           TEST FOR ERRORS DURING CALL 
      JMP FMPE
* 
SW1   LDA NAMO      SAVE THE OUTPUT NAME POINTER
      STA BLOKS 
      LDA DFNAM 
      STA NAMO      SET UP NEW POINTER
WRITR JSB READ      READ FIRST RECORD 
      JSB WRITE     MOVE INPUT FILE TO OUTPUT FILE
      JSB FMP?      JUMP IF ERROR 
      DEF SW2 
      LDA PLNG
      SSA,RSS 
      JMP WRITR 
      JSB CLOZE     CLOSE THE OUTPUT FILE 
      DEF DCBO,I
      DEF NAMO,I
      JSB FMP?      JUMP IF ERROR 
      DEF SW2 
* 
* 
OUT   CLA 
      STA TTY 
      JSB CLOZE     CLOSE OUTPUT DCB
      DEF DCBO,I
      DEF NAMO,I
      JSB CLOZE     CLOSE INPUT DCB 
      DEF DCBI,I
      DEF NAMI,I
      JSB CLOZE     CLOSE COMMAND FILE
      DEF DCBE
      DEF ENAME 
* 
      JSB LCLOZ     CLOSE LIST FILE 
* 
      JSB CLOZE     CLOSE SCRATCH DCB HEADER
      DEF DCBSH 
      DEF SF2 
      JSB CLOZE     CLOSE INPUT DCB HEADER
      DEF DCBIH 
      DEF INPUT 
      JSB FMP?      JUMP IF ERROR 
      DEF NOPRG 
* 
      JSB PURGE              PURGE THE INPUT FILE 
      DEF PER1
      DEF DCBE
      DEF RUBSH 
      DEF SF1 
      DEF ZERO
      DEF SCART 
* 
PER1  CPA M6
      JMP *+3 
      JSB FMPER     PRINT ANY ERRORS
      DEF SF1 
* 
      JSB PURGE              PURGE THE OUTPUT SCRATCH FILE
      DEF PER2
      DEF DCBE
      DEF RUBSH 
      DEF SF2 
      DEF ZERO
      DEF SCART 
* 
PER2  CPA M6
      JMP *+3 
      JSB FMPER     PRINT ANY ERRORS
      DEF SF2 
* 
NOPRG JSB LIMEM 
      DEF *+2 
      DEF M1        RELEASE MEMORY
* 
      JSB REIO      WRITE TERMINATION MESSAGE 
      DEF *+5 
      DEF .2
      DEF LOG 
      DEF END 
      DEF .6
* 
STOP  JSB EXEC      TERMINATE THE PROGRAM 
      DEF *+2 
      DEF .6
* 
END   ASC 6,END OF EDIT 
* 
* 
CLOZE NOP           CLOSE FILE & PRINT SERIOUS ERRORS 
      LDA CLOZE,I 
      ISZ CLOZE 
      STA CLDCB 
      LDA CLOZE,I 
      ISZ CLOZE 
      STA CLNAM 
      JSB CLOSE     CLOSE THE FILE
      DEF *+2 
CLDCB NOP 
      CPA M11 
      CLA           FILE ALREADY CLOSED 
      JSB FMPER     PRINT ANY OTHER ERRORS
CLNAM NOP 
      JMP CLOZE,I 
* 
M11   DEC -11 
* 
SW2   LDA BLOKS     RESTORE THE OUTPUT FILE NAME POINTER
      STA NAMO
      JMP FMPEX 
* 
      SKP 
* 
*     '!' COMMAND - PRINT NAMES OF INPUT AND SCRATCH FILES
* 
./!   CLA 
      STA LIST
      JSB NLSLU     CHECK FOR NEW LIST DEVICE 
      JSB NLSLU     (ALLOW FOR COMMA BEFORE FILE NAME)
      LDA INPUT 
      SZA,RSS 
      JMP DEF       NO INPUT FILE - DO NOT PRINT
* 
      JSB NAME      MOVE THE FILE NAME
      DEF INPUT 
      DEF SFIL+4
      JSB LST       PRINT INPUT FILE NAME 
      DEF SFIL
      DEF .7
* 
DEF   JSB NAME      MOVE INFILE NAME TO MESSAGE 
      DEF NAMI,I
      DEF MSG+4 
      JSB NAME      MOVE OUTFILE NAME TO MESSAGE
      DEF NAMO,I
      DEF MSG+12
      JSB LST       PRINT MESSAGE 
      DEF MSG 
      DEF .15 
      JMP NODE1 
* 
SFIL  ASC 7,SOURCE= XXXXXX
MSG   ASC 15,INFILE= XXXXXX OUTFILE= XXXXXX 
* 
* 
      SKP 
* 
*     '$' COMMAND - DISPLAY OR CHANGE SPECIAL CHARACTERS
* 
./$   LDA TABCR 
      STA TABSV     SAVE THE OLD TAB CHARACTER
* 
./$0  JSB CAPS      FETCH THE NAME
      JMP ./$1      NO NAMES, PRINT VALUES
      STA B         MOVE NAME TO B-REG
      JSB NXCHR     FETCH THE VALUE 
      LDA UNDEF       NO VALUE FOR NAME 
      CPB "T" 
      STA TABCR     'TAB' CHARACTER 
      CPB "W" 
      STA DLMTR     'WINDOW' CHARACTER
      CPB "F" 
      STA INDEF     'FREE FIELD' CHARACTER
      CPB "X" 
      STA XXXXX     'DON'T CARE' CHARACTER
      CPB "N" 
      STA NOT       'NOT' CHARACTER 
      CPB "Z" 
      STA ZLNG      'ZERO LENGTH' CHARACTER 
      CPB "C" 
      STA TERM      'COMMAND TERMINATOR' CHARACTER
      CPB "I" 
      STA INSRT     'INSERT' CHARACTER
      CPB "D" 
      STA CANCL     'DELETE' CHARACTER
      CPB "R" 
      STA REPLA     'REPLACE' CHARACTER 
      CPB "K" 
      STA KLIP      'TRUNCATE' CHARACTER
      CPB "B" 
      STA BREAK     'BREAK' CHARACTER 
      CPB "E" 
      STA XTEND     'EXTEND' CHARACTER
      CPA UNDEF 
      JMP ./$0      COMMA ALREADY READ
      JSB NXCHR     BY-PASS THE COMMA 
      JMP ./$0      CONTINUE WITH NEXT CHARACTER
      JMP *-2 
* 
./$1  LDA D./$2 
      STA BASE
      JSB SPECL 
TABCR NOP           'TAB' CHARACTER 
      JSB SPECL 
DLMTR NOP           'WINDOW' CHARACTER
      JSB SPECL 
INDEF NOP           'FREE FIELD' CHARACTER
      JSB SPECL 
XXXXX NOP           'DONT CARE' CHARACTER 
      JSB SPECL 
NOT   NOP           'NOT' CHARACTER 
      JSB SPECL 
ZLNG  NOP           'ZERO-LENGTH RECORD' CHARACTER
      JSB SPECL 
TERM  NOP           'COMMAND TERMINATOR' CHARACTER
* 
      JSB LST       PRINT FIRST LINE
D./$2 DEF ./$2
      DEF .15 
* 
* 
* 
      LDA D./$3 
      STA BASE
      JSB SPECL 
INSRT NOP           'INSERT' CHARACTER
      JSB SPECL 
CANCL NOP           'DELETE' CHARACTER
      JSB SPECL 
REPLA NOP           'REPLACE' CHARACTER 
      JSB SPECL 
KLIP  NOP           'TRUNCATE' CHARACTER
      JSB SPECL 
BREAK NOP           'BREAK' CHARACTER 
      JSB SPECL 
XTEND NOP           'EXTEND' CHARACTER
      JSB LST       PRINT THE LINE
D./$3 DEF ./$3
      DEF .13 
* 
* 
      LDA TABCR 
      CPA TABSV     CHECK FOR [T] CHARACTER CHANGED 
      JMP NODE1     NO NEED TO CHANGE TERMINAL TAB STOPS
* 
      LDB TTY       CHECK FOR INTERACTIVE INPUT 
      CPA %I        CHECK FOR [T]=<TAB> 
      SZB 
      JMP NODE1     NO NEED TO CHANGE TERMINAL TAB STOPS
* 
      JSB REIO      CLEAR ALL TERMINAL TAB STOPS
      DEF RTN21 
      DEF .2
      DEF LOG 
      DEF CLRTB 
      DEF M3
RTN21 LDA TABUF 
      STA TBPNT 
TSTLP LDA TBPNT,I   GET NEXT TAB STOP 
      SZA,RSS 
      JMP NODE1     END OF LIST 
* 
      ISZ TBPNT 
      INA           BUMP TO PHYSICAL COLUMN # 
      STA TABSV 
* 
      JSB KCVT      CONVERT COLUMN NUMBER TO ASCII
      DEF *+2 
      DEF TABSV 
      STA SETTB+2 
* 
      JSB REIO      SET THE TAB 
      DEF RTN22 
      DEF .2
      DEF LOG 
      DEF SETTB 
      DEF M11 
RTN22 JMP TSTLP 
* 
CLRTB OCT 15463     <ESC>3
      ASC 1,_       NO CR-LF
* 
SETTB OCT 15446     <ESC>&
      OCT 60440     <SMALL A><SPACE>
      ASC 1,XX      COLUMN NUMBER 
      OCT 41433     C<ESC>
      OCT 30415     1<CR> 
      ASC 1,_       NO CR-LF
* 
* 
* 
TABSV NOP 
%I    OCT 11
"=."  OCT 36400 
"%@"  ASC 1,%@
* 
./$2  ASC 15, T=; W=/ F=\ X?? N?? Z%@ C?? 
./$3  ASC 13, I%S D%C R%R K%T B%B E%X 
* 
* 
SPECL NOP           SET TO DISPLAY SPECIAL CHARACTER
      ISZ BASE
      LDA SPECL,I 
      AND B37 
      CPA SPECL,I 
      JMP CNTRL     CONTROL CHARACTER 
      LDA SPECL,I 
      IOR "=."
SPEX  STA BASE,I
      ISZ BASE
      ISZ SPECL 
      JMP SPECL,I 
* 
CNTRL IOR "%@"
      JMP SPEX
* 
B37   OCT 37
* 
* 
      SKP 
* 
*     DISPLAY THE CURRENT LINE NUMBER IN THE INPUT & OUTPUT FILES,
*     THE NO. OF BLOCKS IN OUTPUT FILE, & NO. OF CHARACTERS IN PENDING LINE . 
* 
./N   CLA 
      STA LIST
      STA TCCNT 
      JSB NLSLU     SET UP LIST DEVICE
      JSB NLSLU     (ALLOW FOR COMMA BEFORE FILE NAME)
      LDA "N" 
      JSB OUTCR     OUTPUT N
      LDA "=" 
      JSB OUTCR     OUTPUT =
      LDA LINES 
      CLB 
      JSB DEC       CONVERT LINE NUMBER TO ASCII
      LDA SPACE 
      JSB OUTCR     OUTPUT SPACE
      LDA "O" 
      JSB OUTCR     OUTPUT O
      LDA "=" 
      JSB OUTCR     OUTPUT =
      LDA T#REC 
      JSB STATO     OUTPUT STATUS LINE
* 
      CLA           RESET TBUFF TO ACCEPT THE NEXT LINE OF OUTPUT 
      STA TCCNT 
      LDA "B" 
      JSB OUTCR     OUTPUT B
      LDA "=" 
      JSB OUTCR     OUTPUT =
      JSB BLKS?     COMPUTE THE SIZE OF THE OUTPUT FILE 
      CLB 
      JSB DEC       CONVERT TO AN ASCII STRING IN TBUFF 
      LDA SPACE 
      JSB OUTCR     OUTPUT SPACE
      LDA "C" 
      JSB OUTCR     OUTPUT C
      LDA "=" 
      JSB OUTCR     OUTPUT =
      LDA PLNG      LOAD # CHARACTERS IN PENDING LINE 
      SSA           IF EOF, THEN PRINT "0"
      CLA 
      JSB STATO     OUTPUT STATUS LINE
* 
      CLA 
      STA TCCNT     ZERO THE COUNT
      LDA "W" 
      JSB OUTCR     OUTPUT W
      LDA "=" 
      JSB OUTCR     OUTPUT =
      LDA WIND1 
      INA 
      CLB 
      JSB DEC       CONVERT WINDOW TO ASCII 
      LDA SPACE 
      JSB OUTCR     OUTPUT SPACE
      LDA SPACE 
      JSB OUTCR     OUTPUT SPACE
      LDA SPACE 
      JSB OUTCR     OUTPUT SPACE
      LDA WIND2 
      CMA,INA 
      JSB STATO     OUTPUT STATUS LINE
      JMP NODE1 
* 
* 
* 
STATO NOP 
      CLB 
      JSB DEC       CONVERT TO ASCII
      LDA TCCNT 
      INA 
      ARS           CONVERT CHARACTER COUNT TO WORDS
      STA TCCNT 
      JSB LST       PRINT LINE
      DEF TBUFF,I 
      DEF TCCNT 
      JMP STATO,I 
* 
      SKP 
* 
*     MERGE FILE - SEARCH FOR FIRST & LAST LINES BY PATTERN 
* 
./S   JSB SC.CR     PARSE FILE NAME 
      DEF FNAME 
      JMP ER002     NAME MUST BE ENTERED
      JSB TTYIP     ASK FOR FIRST PATTERN 
      DEF FROM
      JSB TAB       EXPAND TABS 
      JSB M.T       MOVE TO MATCH BUFFER
      JSB TTYIP     ASK FOR SECOND PATTERN
      DEF TO
      JSB INSRC     OPEN MERGE FILE 
./S2  JSB RDM       READ A LINE 
      JSB MACH?     COMPARE PENDING LINE TO MATCH BUFFER
      JMP ./S2      NO MATCH - CONTINUE SEARCH
      JSB LSTSB     LIST MATCH
      JSB TAB       EXPAND TABS FOR SECOND PATTERN
      JSB M.T       MOVE TBUFF TO MATCH BUFFER
./S4  JSB OUTPT     OUTPUT THE LINE 
      JSB FMP?      JUMP IF ERROR 
      DEF ENDM
      JSB BRK?      TEST BREAK FLAG 
      DEF ENDM      QUIT
      JSB RDM       READ NEXT LINE
      JSB MACH?     COMPARE PENDING LINE AND MATCH BUFFER 
      JMP ./S4      NO MATCH - CONTINUE 
      JSB LSTSB     LIST MATCH
      JSB OUTPT     WRITE LAST LINE 
      JMP ENDM      CLOSE MERGE FILE
* 
* 
FROM  DEC -3
      ASC 2,1>_     STARTING PATTERN
* 
TO    DEC -3
      ASC 2,2>_     ENDING PATTERN
* 
      SKP 
* 
*     READ IN SPECIFIED LINES FROM HELP FILE. 
*     ALL LINES STARTING WITH FIRST TWO CHARS OF COMMAND ARE DISPLAYED. 
* 
./?   LDA TTY 
      SZA 
      JMP NODE1     NOT INTERACTIVE, CANNOT USE DCBE
      JSB CAPS      FETCH SECOND KEY CHARACTER
      LDA COMMA     NO SECOND CHAR GIVEN ASSUME SUMMARY 
      IOR "?."      ADD "?" IN HIGH BYTE
      STA KEY 
      CLA,INA 
      STA ECCNT 
      JSB NXCHR     BYPASS COMMA
      RSS 
      JMP *-2       NOT A COMMA, TRY AGAIN
      JSB NLSLU     CHECK FOR NEW LIST DEVICE 
      JSB E.P       SAVE PENDING LINE 
      JSB OPENW     OPEN HELP FILE
      DEF DCBE
      DEF RUBSH 
      DEF HLPNM 
      DEF ZERO      OPTION
      DEF ZERO      SEC 
      DEF ZERO      CR
      DEF .128      SIZE
      CPA M6
      JMP EP        NOT FOUND, IGNORE COMMAND 
      SSA 
      JMP ER? 
./?1  JSB READF     READ FROM HELP FILE 
      DEF RTN5
      DEF DCBE
      DEF RUBSH 
      DEF PBUFF,I 
      DEF .75 
      DEF PLNG
RTN5  JSB FMPER     PRINT ANY ERRORS
      DEF HLPNM 
      IOR PLNG
      SSA 
      JMP END?      ERROR OR END OF FILE
      CLB 
      STB PCCNT 
      LDA PLNG
      ALS 
      STA PLNG      MAKE CHARACTER COUNT
* 
      LDA PBUFF,I   TEST KEY
      LDB SPSP
      STB PBUFF,I   SUPPRESS PRINTING OF THE KEYWORD
      CPA KEY 
      JSB LSTSB     PRINT PENDING LINE
      JSB FMP?      JUMP IF ERROR 
      DEF END?
      JSB BRK?      TEST BREAK FLAG 
      DEF END?
      JMP ./?1
* 
"?."  OCT 37400 
KEY   NOP 
COMMA OCT 54
* 
END?  JSB CLOSE     CLOSE HELP FILE 
      DEF *+2 
      DEF DCBE
ER?   JSB FMPER 
      DEF HLPNM 
      JMP EP        RESTORE PENDING LINE
* 
M6    DEC -6
.75   DEC 75
* 
      HED  RTE EDITOR  -  SUBROUTINES 
* 
*     NAME:./B1 
*     THIS ROUTINE POSITIONS TO THE FIRST LINE
*     IN THE OUTPUT FILE AND THEN DISABLES EXCHANGES. 
*     CALLING SEQUENCE: 
*          JSB ./B1 
* 
./B1  NOP 
      LDA COMND 
      CPA "E" 
      JMP ./B2      PASS OVER ENTIRE SOURCE BEFORE EXIT 
      CPA "M" 
      JMP ./B2       IF "E", "M", OR "S" COMMAND
      CPA "S" 
      JMP ./B2
* 
      LDA EXFLG       OR IF THE EXCHANGE FLAG IS SET
      SZA,RSS 
      JMP BACK      SIMPLY BACK UP
* 
./B2  JSB BRK?      TEST BREAK FLAG 
      DEF DISPL 
      JSB OUTPT     WRITE PENDING LINE TO OUTPUT FILE 
      JSB FMP?      JUMP IF ERROR 
      DEF DISPL 
      LDA PLNG
      SSA 
      JMP RESET       EOF 
      JSB READ      READ NEXT INPUT RECORD
      JMP ./B2
* 
RESET LDA PASS1     FIRST PASS? 
      SZA 
      JMP OPNS2     SET UP SECOND SCRATCH FILE
PAS2  STA EXFLG     DISABLE EXCHANGE
      STA LCOMF       AND LIST
* 
      LDA DCBI      SWAP INPUT-OUTPUT POINTERS
      LDB DCBO
      STA DCBO
      STB DCBI
      LDA NAMI
      LDB NAMO
      STA NAMO
      STB NAMI
      JSB RWNDI     REWIND INPUT FILE 
BKOUT JSB BLKS?     COMPUTE SIZE OF OUTPUT FILE 
      STA BLOKS 
      JSB RWNDO     REWIND OUTPUT FILE
      JMP ./B1,I
* 
* 
* 
BACK  DLD T#WDS 
      SZB,RSS 
      SSA 
      JMP ./B2      MORE THAN 77777B WORDS
* 
      LDB SLNG      TRY TO BACK UP
      LDA DCBSZ 
      CMA,INA 
      SZB 
      LDA SCNT      AVAILABLE SPACE ON STACK
      CLO           CLEAR OVERFLOW FLAG 
      ADA T#WDS     SEE IF THE ENTIRE OUTPUT FILE 
      LDB PLNG        WILL FIT IN THE INPUT DCB 
      SSB 
      JMP SKEOF 
      INB 
      BRS               INCLUDING THE PENDING LINE
      ADA B 
SKEOF ADA T#REC           AND ONE WORD PER RECORD 
      SOS 
      SSA,RSS 
      JMP ./B2      WILL NOT FIT
* 
      JSB POSTI     FREE UP THE INPUT BUFFER
PUSHB JSB BRK?      CHECK THE BREAK FLAG
      DEF WE        WRITE AN EOF
      JSB PUSH      PUSH THE PENDING LINE ONTO THE STACK
      JMP ./B2      STACK OVERFLOW (SHOULD NEVER GET HERE)
      JSB FMP?      CHECK FOR FMP ERRORS
      DEF WE
* 
      JSB GET       BACK UP ONE LINE
      JMP BKOUT     START OF FILE, DONE 
      JMP PUSHB 
* 
* 
OPNS2 JSB CLOSE     CLOSE THE ORIGINAL FILE 
      DEF *+2 
      DEF DCBI,I
      JSB FMPER     PRINT ANY ERRORS
      DEF NAMI,I
      LDA DSCR2     SWITCH THE NAME POINTER 
      STA NAMI
      JSB MVW         AND MOVE THE DCB HEADER 
      DEF DCBSH 
      DEF DCBI,I
      DEC 16
      JSB MVW       ZERO THE SECOND COPY
      DEF ZERO
      DEF DCBSH 
      DEC 16
      CLA 
      STA PASS1 
      JMP PAS2
      SKP 
* 
*     NAME:./R$ 
*     SUBROUTINE TO REPLACE THE PENDING LINE
*      WITH THE LINE IN THE TERMINAL OUTPUT BUFFER. 
*      BY SWAPPING THE BUFFER POINTERS. 
*     CALLING SEQUENCE: 
*          JSB ./R$ 
* 
./R$  NOP 
      LDB TCCNT     MOVE NUMBER OF CHARACTERS IN TBUFF
      STB PLNG       TO PENDING LINE LENGTH WORD
      LDA TBUFF 
      LDB PBUFF     SWAP
      STA PBUFF     POINTERS
      STB TBUFF 
      JMP ./R$,I
      SKP 
* 
*     NAME:BLKS?
*     SUBROUTINE TO COMPUTE THE NUMBER OF BLOCKS IN 
*     THE OUTPUT FILE.
*     CALLING SEQUENCE: 
*          JSB BLKS?
* 
* 
* 
BLKS? NOP           COMPUTE NUMBER OF BLOCKS IN OUTPUT FILE 
      LDA T#REC     NUMBER OF RECORDS 
      MPY .2        TWO LENGTH WORDS PER RECORD 
      CLE,INA 
      LDB T#WDS+1 
      ADA T#WDS     ADD # OF DATA WORDS IN DESTINATION FILE 
      SEZ 
      INB           CARRY INTO MSB
      DIV .128      DIVIDE INTO BLOCKS
      SZB 
      INA           PARTIAL BLOCK 
      JMP BLKS?,I 
* 
* 
      SKP 
* 
*     NAME:BRK? 
*     SUBROUTINE TO CHECK THE BREAK FLAG AND SAVE IT
*     FOR CHECKING BY THE COMMAND LOOP. 
*     CALLING SEQUENCE: 
*         JSB BRK?
*         DEF TRAP  JUMPS HERE IF BREAK FLAG WAS SET
* 
BRK?  NOP           CHECK THE BREAK FLAG
      JSB IFBRK 
      DEF *+1 
      SZA 
      JMP BRSET     BREAK FLAG SET
      ISZ BRK?
      JMP BRK?,I
* 
BRSET STA BRKFL     SET THE EDITOR BREAK FLAG 
      LDA BRK?,I
      JMP A,I 
* 
BRKFL NOP 
* 
      SKP 
* 
* 
*     NAME:CAPS 
*     SUBROUTINE TO CONVERT COMMAND CHAR TO UPPER CASE. 
*     CHARACTER UNCHANGED IF NOT LETTER (A-Z).
*     CALLING SEQUENCE: 
*         JSB CAPS
*         >END OF BUFFER
*         >COMMAND CHAR IN A
* 
CAPS  NOP           CONVERT COMMAND CHAR TO UPPER CASE
      JSB ECH       GET NEXT CHAR 
      JMP CAPS,I    NONE
      ISZ CAPS      BUMP RETURN 
      STA SAVL      SAVE IT 
      ADA N141      MAKE AN "A" A ZERO
      SSA           OUT OF RANGE? 
      JMP CAPSO     YES 
      ADA N32       MAKE A "Z" A MINUS ONE
      SSA,RSS       OUT OF RANGE? 
      JMP CAPSO     YES 
      ADA B133      CONVERT TO UPPER CASE 
      STA SAVL
CAPSO LDA SAVL
      JMP CAPS,I
N141  OCT -141
N32   OCT -32 
SAVL  NOP 
* 
      SKP 
* 
*     NAME:CCH
*     THIS ROUTINE FETCHES ONE CHARACTER FROM THE COMMAND STRING
*     CALLING SEQUENCE: 
*       JSB CCH 
*       >END OF LINE
*       >CHARACTER FOUND IN A 
* 
CCH   NOP           INPUT A CHARACTER FROM COMMAND BUFFER 
      LDA CCCNT 
      CPA CLNG
      JMP CCH,I     NO MORE CHARACTERS
      ISZ CCCNT 
      CLE,ERA 
      ADA CBUFF 
      JSB CH
      CPA TERM      END OF COMMAND? 
      JMP CCH,I     YES 
      ISZ CCH 
      JMP CCH,I 
* 
      SKP 
* 
*     NAME:CH 
*     SUBROUTINE TO FETCH A CHARACTER FROM A BUFFER 
*     CALLING SEQUENCE: 
*          LDA ADDRESS
*          SET E (0=HIGH BYTE 1=LOW BYTE) 
*          JSB CH 
*          >NEXT CHARACTER FROM BUFFER IN A 
* 
CH    NOP 
      LDA A,I       FETCH WORD CONTAINING CHARACTER 
      SEZ,RSS       MOVE WANTED CHARACTER 
      ALF,ALF       TO LOWER BYTE 
      AND LBYTE     AND DELETE OTHER CHARACTER
      JMP CH,I
      SKP 
* 
*     NAME:CHKN 
*     SUBROUTINE TO CHECK THAT ALL PARAMETERS 
*      OF A COMMAND ARE NUMERIC AND POSITIVE. 
*      NUMIN PRINTS ER001 IF NOT ALL OKAY.
*     CALLING SEQUENCE: 
*          JSB CHKN 
* 
CHKN  NOP 
NPARA JSB NUMIN     FETCH NEXT PARAM
      LDA ELNG      IF END OF COMMAND 
      CPA ECCNT      THEN, ALL PARAMETERS 
      CLA,INA,RSS     WERE NUMERIC
      JMP NPARA     ELSE, FETCH NEXT PARAM
      STA ECCNT     RESET COUNT AND RETURN
      JMP CHKN,I
* 
      SKP 
*     NAME: COMP
*     SUBROUTINE TO COMPARE PENDING LINE
*     TO ANY OTHER BUFFER.
*     CALLING SEQUENCE: 
*         LDA BUFFER LENGTH 
*         LDB BUFFER ADDRESS
*         JSB COMPR 
*         >NO MATCH RETURN HERE 
*         >MATCH RETURN HERE
* 
COMPR NOP           COMPARE PENDING LINE TO MATCH BUFFER
      STA MX.LN 
      STB MX.BF 
      CCB 
      STB RSCN1 
      LDB PCCNT 
      STB PCRST     SAVE STARTING POSITION IN SOURCE
      CLB           CLEAR 
      STB WINDF      WINDOW FLAG
      STB MX.CN 
      STB FIRST 
      STB RESCN 
      STB NCNT
      STB NCNT$ 
      STB PCCN$ 
      STB MCCN$ 
CMPR0 STB MMCNT 
CMPR1 JSB MX.CH 
      JMP EOM       END OF MATCH BUFFER 
      CPA INDEF 
      JMP CMPR6     INDEFINITE CHARACTER
      CPA DLMTR     WINDOW SPECIFIED
      JMP CMPR5      ON SEARCH
CMPR7 ISZ RSCN1     CHECK FOR FIRST POSSIBLE RESCAN POINT 
      JMP CMPR2     NO
      CCB 
      ADB MX.CN     YES, BACK UP ONE
      STB MXRST 
CMPR2 CPA NOT 
      JMP NCHAR     'NOT' MODE
      STA B         SAVE THE CHARACTER
      JSB PCH       GET SOURCE CHARACTER. 
      JMP ZCHK      CHECK FOR ZERO LENGTH RECORD
      CPB XXXXX 
      JMP CMPR3     'DONT CARE' CHAR MATCHES ANYTHING 
      CPA B         COMPARE WITH PATTERN
      JMP CMPR3     COMPARES
      LDA NCNT
      SLA 
      JMP BMPMM     'NOT' MODE, NO MATCH
      ISZ FIRST     FIRST CHARACTER AFTER [F] OR [W]? 
      JMP IDEF      NO, CHECK FOR RETRY ALLOWED 
* 
      LDA PCCNT 
      STA PCCN$ 
      CCB 
      ADB MX.CN     BACK UP TO PREVIOUS MATCH CHARACTER 
IDEF2 CPA PLNG
      JMP COMPR,I   END OF SOURCE 
      STB MX.CN 
      CPB MXRST 
      STA PCRST     RETRY FROM BEGINNING OF MATCH BUFFER
      LDB WINDF 
      SZB,RSS 
      JMP CMPR9     SKIP WINDOW CHECK 
      ADA BWIND     ADJUST WINDOW FOR PREVIOUS EXCHANGES
      ADA WIND2 
      SSA,RSS       DO NOT RESCAN IF FLAG SET AND 
      JMP COMPR,I     NEXT CHAR PAST WINDOW 
      CLB,INB,RSS   SET FLAG AGAIN
*** 
CMPR6 CLB 
* 
CMPR8 STB WINDF      WINDOW FLAG
* 
CMPR9 LDA MX.CN     SET UP FOR INDEFINITE 
      STA MCCN$     CHARACTER 
      LDA NCNT      SAVE 'NOT' CHARACTER COUNT
      STA NCNT$       FOR RESCAN
      CCA           SAVE THE PATTERN LOCATION AND 
      STA FIRST     SET THE FIRST CHAR. FLAG
      STA RESCN     ALLOW RESCAN
      JMP CMPR1     GO GET THE FIRST PATTERN CHARACTER. 
*** 
BMPMM ISZ MMCNT     COUNT MISMATCHES IN 'NOT' MODE
CMPR3 ISZ FIRST     FIRST CHAR FOUND AFTER INDEF CHAR?
      JMP CMPR1     NO CONTINUE 
      LDA PCCNT 
      STA PCCN$     SAVE RESCAN POINTER 
      LDB WINDF     GET WINDOW FLAG AND 
      SLB,RSS       IF ONE SET TO TWO 
      JMP CMPR1 
      ISZ WINDF 
      ADA BWIND     ADJUST WINDOW FOR PREVIOUS EXCHANGES
      ADA WIND2 
      ADA M1        SEE IF THE LAST CHAR
      SSA             WAS IN THE WINDOW 
      JMP CMPR1     WITHIN WINDOW 
      JMP COMPR,I   OUTSIDE WINDOW
*** 
CMPR5 CLB,INB       IS WINDOW CHARACTER 
      CPB MX.CN      THE FIRST CHAR. OF COMMAND?
      RSS           YES -- CONTINUE 
      JMP CMPR7     NO, IGNORE
      LDA PCCNT 
      SZA 
      JMP CMPR8     NOT FIRST CALL TO COMPR 
      LDA WIND1     START SEARCH AT 
      STA PCCNT      BEGINNING OF WINDOW
      STA PCRST 
      CMA,INA       IF WINDOW 
      ADA PLNG       STARTS BEYOND
      SSA,RSS         END OF LINE 
      JMP CMPR8 
      LDA PLNG
      STA PCCNT           SET TO END OF LINE
      STA PCRST 
      JMP CMPR8 
*** 
ZCHK  CPB XXXXX     IF 'DONT CARE'
      JMP CMPR3       THEN CONTINUE 
      LDA NCNT
      SLA 
      JMP BMPMM     BUMP MISMATCH COUNTER 
* 
      LDA PLNG      CHECK FOR ZERO LENGTH RECORD
      SZA 
      JMP COMPR,I     NO
      CPB ZLNG      IF LOOKING FOR ZERO-LENGTH RECORD,
CMPR4 ISZ COMPR     BUMP TO GOOD RETURN 
      JMP COMPR,I 
* 
FIRST NOP 
* 
NCHAR LDB NCNT
      ISZ NCNT
      LDA MMCNT 
      SLB           IF 'NOT' MODE 
      SZA             AND ALL CHARACTERS MATCHED, 
      CLB,RSS 
      JMP IDEF            THEN RESCAN THE SOURCE BUFFER 
      JMP CMPR0     ELSE, CONTINUE SEARCH 
* 
* 
EOM   LDB NCNT
      LDA MMCNT 
      SLB           IF 'NOT' MODE 
      SZA             AND ALL CHARACTERS MATCHED, 
      JMP CMPR4 
      ISZ NCNT
* 
IDEF  ISZ RESCN 
      JMP COMPR,I   NO RETRY ALLOWED
* 
      LDA PCCN$     ANY CHARACTERS READ SO FAR? 
      CPA PCCNT 
      JMP CMPR1     NO, IGNORE 'MISMATCH' 
* 
      STA PCCNT 
      LDB NCNT$ 
      STB NCNT      RESET COUNTERS
      LDB MCCN$ 
      JMP IDEF2           THEN RESCAN THE SOURCE BUFFER 
* 
MCCN$ NOP 
RESCN NOP 
MX.BF NOP 
MX.CN NOP 
MX.LN NOP 
MXRST NOP 
MMCNT NOP 
BWIND NOP 
WINDF NOP 
NCNT  NOP 
RSCN1 NOP 
PCCN$ NOP 
NCNT$ NOP 
PCRST NOP 
* 
      SKP 
*     NAME:CONVT
*     SUBROUTINE TO CONVERT THE DECIMAL DIGIT IN THE
*      A-REGISTER TO ASCII AND OUTPUT TO TBUFF. 
*      ONLY SUPPRESS LEADING ZEROES IF PUT AT START OF TBUFF
*     CALLING SEQUENCE: 
*          LDA DIGIT FOR THIS DECIMAL PLACE 
*          LDB VALUE OF NUMBER LESS THAN THIS PLACE 
*          JSB CONVT
*     REGISTERS ON RETURN:
*          A:REMAINDER FROM LAST DIVIDE 
*          B:ZERO 
* 
CONVT NOP 
      STB DIRCT     SAVE REMAINDER
      SZA           IF
      JMP CONV1      LEADING
      CPA TCCNT       ZERO
      JMP CONV2        DO NOT OUTPUT IT 
CONV1 IOR B60       CONVERT NUMBER TO ASCII 
      JSB OUTCR     MOVE CHARACTER TO BUFFER
CONV2 CLB           SET REGISTERS UP
      LDA DIRCT      FOR NEXT DIVIDE
      JMP CONVT,I 
B60   OCT 60
* 
      SKP 
* 
*     NAME:CXT
*     COMPARES THE PENDING LINE TO AN OLD PATTERN AND 
*     EXCHANGES IT FOR A NEW PATTERN, IF A MATCH IS FOUND.
*     CALLING SEQUENCE: 
*          JSB CXT
* 
CXT   NOP           THIS ROUTINE DOES ALL THE 
      CLA            MATCHING IN THE SOURCE BUFFER
      STA PCCNT 
      CPA UNCON 
      JMP CXT0      CONDITIONAL EXCHANGE
      JMP CXTUC 
CXT0  STA MATCH     NO MATCH SO FAR 
      LDB PLNG
      STB PSAVE     SAVE ORIGINAL LENGTH
CXT1  STA BWIND     RESET WINDOW BIAS 
      LDA XLNG
      LDB XYBUF     USE EXCHANGE BUFFER 
      JSB COMPR     COMPARE TO PENDING LINE 
      JMP CXT,I     NO MATCH
      LDA XLIST     SET LIST
      STA MATCH      FLAG 
      LDA PCCNT     SAVE CURRENT
      STA RSCN1      POSITION IN SOURCE 
      CLA           RESET 
      STA PCCNT       SOURCE CHARACTER COUNTER
      STA TCCNT       OUTPUT CHARACTER COUNTER
      STA YCCNT       REPLACE CHARACTER COUNTER 
* 
      LDA PCRST     MOVE ANY CHARACTERS BEFORE THE MATCH
      CMA,INA,SZA,RSS 
      JMP RPC1
      STA T2
RPC0  JSB PCH       GET CHARACTERS
      JMP RPC1      (SHOULD NEVER GET HERE) 
      JSB OUTCR     OUTPUT TO TEMPORARY BUFFER
      ISZ T2
      JMP RPC0
* 
RPC1  LDA PCRST 
      CMA,INA 
      ADA RSCN1 
      CMA,INA,SZA,RSS 
      JMP RPC3      NULL MATCH PATTERN
      STA T2
RPC2  JSB PCH       MOVE
      LDA SPACE     DEFAULT TO SPACE
      STA B 
      JSB YCH       REPLACE PENDING CHARACTER 
      JMP RPC6      WITH REPLACEMENT CHARACTERS 
      CPA XXXXX         UNLESS "DON'T CHANGE" WAS SPECIFIED 
      LDA B 
      JSB OUTCR       TO OUTPUT 
RPC6  ISZ T2
      JMP RPC2
RPC3  JSB YCH       MOVE EXTRA CHARACTERS TO OUTPUT BUFFER
      JMP RPC4
      CPA XXXXX 
      JMP RPC3      'DONT CHANGE' 
      JSB OUTCR 
      JMP RPC3
* 
RPC4  LDA TCCNT     SAVE POSITION 
      STA T2         FOR CONTINUATION OF SEARCH 
* 
RPC5  JSB PCH       MOVE REMAINDER
      JMP ENDRP      OF SOURCE LINE 
      JSB OUTCR       TO OUTPUT 
      JMP RPC5
* 
ENDRP LDA RSCN1 
      SZA           IF NULL MATCH PATTERN 
      CPA PLNG        OR AT END OF SOURCE 
      JMP ENDCX         END THE EXCHANGE OPERATION
      JSB ./R$      REPLACE OLD SOURCE LINE 
      LDA T2
      STA PCCNT 
      LDA PLNG      COMPUTE 
      CMA,INA        BIAS FOR 
      ADA PSAVE       UPPER BOUND 
      JMP CXT1       CONTINUE SEARCH
* 
ENDCX JSB ./R$      REPLACE LINE
      JMP CXT,I      AND RETURN 
* 
PSAVE NOP 
* 
*     CODE FOR UNCONDITIONAL REPLACE. 
* 
CXTUC STA YCCNT 
      STA TCCNT     ZERO BUFFER COUNTERS
      LDA XLIST     TO LIST OR NOT
      STA MATCH       TO LIST?
      LDA WIND1 
      CMA,INA,SZA,RSS 
      JMP CXTU5 
      STA T1
CXTU1 JSB PCH       MOVE SOURCE CHARACTERS
      LDA SPACE      PRECEEDING WINDOW
      JSB OUTCR       TO OUTPUT.
      ISZ T1
      JMP CXTU1 
* 
CXTU5 CCA 
      ADA XLNG      DO NOT COUNT WINDOW CHARACTER 
      CMA,INA,SZA,RSS 
      JMP CXTU3     NULL MATCH FIELD
      STA T1
CXTU2 JSB PCH 
      LDA SPACE     DEFAULT TO SPACE
      STA B 
      JSB YCH       GET REPLACEMENT CHARACTER 
      JMP CXTU6     NO MORE 
      CPA XXXXX 
      LDA B         "DON'T CHANGE"
      JSB OUTCR     OUTPUT TO BUFFER
CXTU6 ISZ T1
      JMP CXTU2 
* 
CXTU3 JSB YCH       MOVE REPLACEMENT CHARACTERS 
      JMP CXTU4      TO OUTPUT. 
      CPA XXXXX 
      JMP CXTU3     'DONT CHANGE' 
      JSB OUTCR 
      JMP CXTU3 
* 
CXTU4 JSB PCH       MOVE REMAINDER OF RECORD
      JMP ENDCX      TO OUTPUT
      JSB OUTCR 
      JMP CXTU4 
* 
MATCH NOP 
YCCNT NOP 
T1    NOP 
T2    NOP 
* 
      SKP 
* 
*     NAME:DEC
*      SUBROUTINE TO CONVERT A DOUBLE PRECISION 
*     INTEGER TO A CHARACTER STRING IN TBUFF. 
*     CALLING SEQUENCE: 
*          DLD NUMBER TO BE CONVERTED 
*          JSB DEC
* 
DEC   NOP 
      CLE,SZB,RSS   >65K? 
      JMP SNGLP 
      DIV .10K      WORK ON EXCESS FIRST
      STB READ      SAVE REMAINDER FOR NEXT PASS. 
      CLB 
      JSB DEC4
      LDA READ
      CCE           SKIP DIV .10K THIS TIME 
SNGLP JSB DEC4
      JMP DEC,I 
      SKP 
* 
*     NAME:DEC4 
*     SUBROUTINE TO CONVERT THE DECIMAL NUMBER IN THE 
*      A-REGISTER TO A CHARACTER STRING IN THE TERMINAL 
*      OUTPUT BUFFER.  IF E-REG=0, THE NUMBER IS ASSUMED
*      TO BE A SINGLE PRECISION INTEGER OR THE MOST 
*      SIGNIFICANT BITS OF A DOUBLE PRECISION INTEGER.
*      IF E-REG=1, THE NUMBER IS ASSUMED TO BE THE
*      SECOND WORD OF A DOUBLE PRECISION INTEGER. 
*     CALLING SEQUENCE: 
*          SET E-REG
*          LDA NUMBER TO BE CONVERTED 
*          JSB DEC4 
*     REGISTERS ON RETURN:
*          A:ZERO 
*          B:ZERO 
* 
DEC4  NOP 
      SEZ           IF NUMBER >65K, SKIP
      JMP THOU       FIRST DIVIDE, PASS 2.
      DIV .10K      OUTPUT TEN THOUSANDS
      JSB CONVT      DIGIT
THOU  DIV .1000     OUTPUT THOUSANDS
      JSB CONVT      DIGIT
      DIV .100      OUTPUT HUNDREDS 
      JSB CONVT      DIGIT
      DIV .10       OUTPUT TENS 
      JSB CONVT      DIGIT AND
      JSB CONVT       ONES DIGIT
      JMP DEC4,I
* 
      SKP 
*     NAME:DIRCT
*     SUBROUTINE TO FIND A DIRECT ADDRESS 
*     CALLING SEQUENCE: 
*          LDB ADDRESS
*          JSB DIRCT
*     REGISTERS ON RETURN:
*          A:UNCHANGED
*          B:DIRECT ADDRESS 
* 
DIRCT NOP 
      SSB,RSS 
      JMP DIRCT,I   DONE
      ELB,CLE,ERB   MASK OFF INDIRECT BIT 
      LDB B,I 
      JMP DIRCT+1 
      SKP 
* 
*     NAME:ECH
*     SUBROUTINE TO RETURN NEXT COMMAND CHARACTER 
*     CALLING SEQUENCE: 
*          JSB ECH
*          >END OF BUFFER RETURN HERE 
*          >CHARACTER RETURNED IN A 
* 
ECH   NOP 
      LDA ECCNT     # CHARACTERS ALREADY READ 
      CPA ELNG      # CHARACTERS IN BUFFER
      JMP ECH,I     END OF VALID DATA 
      ISZ ECCNT 
      ISZ ECH       BUMP TO NORMAL RETURN 
      CLE,ERA       CONVERT TO WORDS
      ADA EBUFF     ADD BASE ADDRESS
      JSB CH        FETCH CHARACTER FROM BUFFER 
      JMP ECH,I 
* 
      SKP 
* 
*     NAME: E.P 
*     SUBROUTINE TO EXCHANGE EBUFF AND PBUFF BY 
*      SWAPPING BUFFER POINTERS AND LENGTHS.
*     CALLING SEQUENCE: 
*          JSB E.P
* 
E.P   NOP           SWAP COMMAND BUFFER AND PENDING LINE
      LDA EBUFF 
      LDB PBUFF 
      STA PBUFF 
      STB EBUFF 
      LDA ELNG
      LDB PLNG
      STA PLNG
      STB ELNG
      JMP E.P,I 
* 
      SKP 
* 
* 
* 
ER006 JSB ERROR     PRINT 'WRONG FILE TYPE' 
      DEF MS006 
      DEC 12
      JMP NODE1 
* 
ER004 JSB ERROR     PRINT 'DELIMITER MISSING' 
      DEF MS004 
      DEC 13
      JMP NODE1 
* 
* 
ER002 JSB ERROR     PRINT 'FILE NAME MISSING' 
      DEF MS002 
      DEC 13
      JMP NODE1 
* 
* 
ER001 JSB ERROR     PRINT 'INVALID COMMAND' 
      DEF MS001 
      DEC 12
      JMP NODE1 
* 
* 
ER000 JSB ERROR     PRINT 'INVALID PARAMETER' 
      DEF MS000 
      DEC 13
      JMP NODE1 
* 
* 
MS000 ASC 13,XXXXX 0-INVALID PARAMETER
MS001 ASC 12,XXXXX 1-INVALID COMMAND
MS002 ASC 13,XXXXX 2-FILE NAME MISSING
MS004 ASC 13,XXXXX 4-DELIMITER MISSING
MS006 ASC 12,XXXXX 6-WRONG FILE TYPE
* 
      SKP 
* 
*     NAME:ERROR
*     SUBROUTINE TO PRINT AN ERROR MESSAGE ON THE CONSOLE.
*      PROGRAM IS ABORTED IF COMMAND INPUT
*      IS NOT FROM A TERMINAL.
*     CALLING SEQUENCE: 
*          JSB ERROR
*          DEF BUFFER 
*          MESSAGE LENGTH IN WORDS
* 
ERROR NOP 
      LDA ERROR,I 
      ISZ ERROR 
      STA ERMEQ 
* 
      JSB REIO      PRINT ERROR ON SESSION CONSOLE
      DEF *+5 
      DEF .2
      DEF LOG 
ERMEQ NOP           ADDRESS 
      DEF ERROR,I   COUNT 
* 
      LDA TTY 
      SZA 
      JMP OUT       NON-INTERACTIVE, ABORT EDIT 
      STA CCCNT 
      STA LFLAG 
      STA CLNG      SET TO READ NEXT COMMAND
      CCA 
      STA RPCNT     SET TO JUMP OUT OF REPEAT LOOP
      ISZ ERROR 
      JMP ERROR,I 
* 
      SKP 
* 
* 
*     NAME:EXCH 
*     THIS ROUTINE EXCHANGES AN OLD PATTERN FOR A 
*     NEW PATTERN IF THE EXCHANGE FLAG IS SET.
*     CHANGES ARE LISTED. 
*     CALLING SEQUENCE: 
*       JSB EXCH
* 
EXCH  NOP           EXCHANGE AND LIST CHANGES 
      LDA EXFLG 
      SZA,RSS 
      JMP EXCH,I    EXCHANGE NOT ENABLED
      JSB CXT       DO THE EXCHANGE 
      LDA MATCH 
      SZA,RSS 
      JMP EXCH,I    NO MATCH
* 
      LDA LCOMF 
      SZA,RSS       AVOID DUPLICATE LISTING 
      JSB LSTSB     LIST THE NEW LINE 
      JMP EXCH,I
* 
      SKP 
* 
*     NAME:FMP? 
*     THIS ROUTINE CHECKS THE FMP ERROR ACCUMULATOR.
*     IF AN FMP ERROR HAS OCCURED SINCE THIS ROUTINE
*     WAS LAST CALLED, THE PASSED ENTRY POINT IS USED 
*     AS AN ERROR RECOVERY ROUTINE. 
*     CALLING SEQUENCE: 
*       JSB FMP?
*       DEF ENTRY 
*     >RETURNS HERE IF NO ERROR 
*       OTHERWISE JUMPS TO <ENTRY>
* 
* 
FMP?  NOP           CHECK FMP ERROR ACCUMULATOR 
      CLA 
      LDB FMP?,I
      ISZ FMP?
      CPA FMP 
      JMP FMP?,I    NO ERROR, RETURN
      STA FMP       CLEAR THE ACCUMULATOR 
      JMP B,I       JUMP TO ERROR RETURN
* 
      SKP 
* 
*     NAME:FMPER
*     SUBROUTINE TO PRINT OUT ALL FILE MANAGER ERRORS.
*     ANY ERROR SETS THE ERROR ACCUMULATOR FLAG.
*     CALLING SEQUENCE: 
*          LDA ERROR CODE 
*          JSB FMPER
*          DEF FILE NAME
*          >ERROR CODE IN A 
* 
FMPER NOP 
      SSA,RSS 
      JMP FMPOK     NO ERROR, RETURN
      STA FMP       ERROR ACCUMULATOR 
      CPA SIGN
      JMP FMPOK     DO NOT PRINT ERROR MESSAGE
      CLB,INB 
      STB TCCNT     SET UP OUTPUT BUFFER COUNT
      CMA,INA       COMPLEMENT ERROR NUMBER 
      CLB 
      JSB DEC       CONVERT TO ASCII
      LDB TBUFF 
      INB 
      LDA B,I       GET FIRST DIGIT 
      XOR B1640     CHANGE '0' TO '-' 
      STA MSGP+5
      INB 
      LDA B,I 
      STA MSGP+6    PUT LAST TWO DIGITS IN MESSAGE
* 
      LDA FMPER,I 
      STA FMPNM 
      JSB NAME      MOVE THE NAME TO THE MESSAGE
FMPNM NOP 
      DEF MSGP+9
      JSB ERROR     PRINT ERROR MESSAGE 
      DEF MSGP
.12   DEC 12
      LDA FMP       FETCH ERROR CODE
FMPOK ISZ FMPER 
      JMP FMPER,I 
* 
* 
* 
FMP   NOP 
LU    ASC 1,LU
SPSP  ASC 1,
* 
* 
* 
MSGP  ASC 12,FMP ERROR -XXX ON XXXXXX 
* 
FMPC  JSB FMPER     PRINT FILE MANAGER ERROR
      DEF FNAME 
      JSB OPENW     RE-OPEN INPUT FILE
      DEF DCBI,I
      DEF RUBSH 
      DEF NAMI,I
      DEF ZERO
      DEF ZERO
      DEF SCART 
      DEF DCBSZ 
      JSB FMPER     PRINT ANY ERRORS
      DEF NAMI,I
      JMP READ1      THEN GET NEXT COMMAND
* 
FMPEX JSB OPENW     RE-OPEN THE OUTPUT SCRATCH FILE 
      DEF DCBO,I
      DEF RUBSH 
      DEF NAMO,I
      DEF ZERO
      DEF ZERO
      DEF SCART 
      DEF DCBSZ 
      JSB FMPER 
      DEF NAMO,I
      JMP RWND      READ FIRST LINE 
* 
      SKP 
* 
*     NAME:GET
*     SUBROUTINE TO READ A RECORD FROM THE OUTPUT FILE
*     TO THE PENDING LINE BUFFER. 
*     CALLING SEQUENCE: 
*       JSB GET 
*     >START OF FILE, NO RECORD INPUT 
*     >RECORD AVAILABLE 
* 
GET   NOP           GET A LINE FROM THE OUTPUT FILE 
      LDA T#REC     ADJUST CURRENT LINE NUMBER
      STA LINES 
      JSB POSNT     BACKSPACE ONE RECORD
      DEF RTN16 
      DEF DCBO,I
      DEF RUBSH 
      DEF M1
RTN16 CPA M12 
      JMP GET,I     START OF FILE, EXIT 
* 
      JSB FMPER     PRINT ERRORS
      DEF NAMO,I
* 
* 
      JSB READF     READ FROM THE OUTPUT FILE 
      DEF RTN17 
      DEF DCBO,I
      DEF RUBSH 
      DEF PBUFF,I 
      DEF .75 
      DEF PLNG
RTN17 JSB FMPER     PRINT ANY ERRORS
      DEF NAMO,I
* 
* 
      JSB POSNT     BACKSPACE AGAIN 
      DEF RTN18 
      DEF DCBO,I
      DEF RUBSH 
      DEF M1
RTN18 JSB FMPER     PRINT ERRORS
      DEF NAMO,I
* 
      LDA PLNG
      RAL           CONVERT LENGTH TO CHARACTERS
      STA PLNG
      CLE,RAR         AND BACK TO WORDS 
      CMA,INA 
      ADA T#WDS     SUBTRACT FROM OUTPUT FILE SIZE
      LDB T#WDS+1 
      SEZ,RSS 
      ADB M1        (DOUBLE INTEGER)
      DST T#WDS 
      LDA T#REC     ADJUST CURRENT LINE NUMBER
      ADA M1
      STA T#REC 
* 
      ISZ GET 
      JMP GET,I 
* 
      SKP 
* 
*     NAME:INSRC
*     SUBROUTINE TO OPEN THE MERGE FILE.
*     CALLING SEQUENCE: 
*          JSB INSRC
* 
*          JUMPS TO 'ENDER' IF ERROR OCCURS 
*            (ERROR CODE IN A)
* 
INSRC NOP 
      LDA EXFLG 
      STA EXSAV     SAVE THE EXCHANGE FLAG
      CLA 
      STA EXFLG 
      JSB LCLOZ     CLOSE THE LIST FILE IF OPEN 
      LDA TTY 
      STA LIST      ALLOW LISTING IF INTERACTIVE
* 
* 
      LDA PASS1     IS THE SOURCE FILE OPEN?
      SZA,RSS 
      JMP INS2      NO
      LDA FNAME     YES 
      CPA INPUT     IS THE SOURCE FILE BEING MERGED?
      RSS           MAYBE 
      JMP INS2      NO
      LDA FNAME+1 
      CPA INPUT+1 
      RSS           MAYBE 
      JMP INS2      NO
      LDA FNAME+2 
      CPA INPUT+2 
      JMP CLOSS     YES, CLOSE THE SOURCE FILE
* 
INS2  LDA PLNG
      SSA,RSS 
      JSB OUTPT     OUTPUT PENDING LINE 
INS3  JSB OPENW     OPEN MERGE FILE 
      DEF DCBL      DCB ADDRESS 
      DEF RUBSH     ERROR 
      DEF FNAME     FILE NAME 
      DEF ZERO
      DEF FSECR     SECURITY
      DEF FCART     CART. REF.
      DEF .128
      SSA 
      JMP ENDER     ERROR, PRINT MESSAGE
      LDA EXSAV 
      STA EXFLG     RESTORE THE EXCHANGE FLAG 
      JMP INSRC,I 
* 
* 
CLOSS LDA T#REC     SAVE THE CURRENT RECORD NO. 
      LDB PLNG
      SSB,RSS 
      INA           ADD ONE FOR THE PENDING LINE
      CMA,INA 
      STA COUNT 
* 
      JSB ./B1      ROLL OVER THE SOURCE FILE, THEN CLOSE IT
* 
      LDA COUNT 
      SZA,RSS 
      JMP INS3      NULL INPUT FILE 
* 
      JSB READ      READ THE FIRST LINE 
      RSS 
INSLP JSB TR        WRITE A LINE, THEN READ THE NEXT
      ISZ COUNT     BACK TO WHERE WE STARTED? 
      JMP INSLP 
      JMP INS2      YES 
* 
EXSAV NOP 
* 
      SKP 
* 
*     NAME:LCLOZ
*     SUBROUTINE TO WRITE AN END OF FILE ON THE 
*     LIST DEVICE AND CLOSE IT. 
* 
LCLOZ NOP           CLOSE THE LIST FILE 
      LDA LNAME 
      CPA LOG 
      JMP LCLZ      LISTING TO TERMINAL 
* 
      JSB WRITF     WRITE AN END OF FILE ON THE LIST DEVICE 
      DEF RTN3
      DEF DCBL
      DEF RUBSH 
      DEF RUBSH 
      DEF M1
RTN3  CPA M11       DON'T CARE IF FILE IS CLOSED
      JMP LCLZX 
      JSB FMPER     PRINT ANY OTHER ERRORS
      DEF LNAME 
* 
LCLZ  JSB CLOZE     CLOSE THE LIST FILE 
      DEF DCBL
      DEF LNAME 
* 
LCLZX CLA 
      STA LNAME 
      JMP LCLOZ,I 
* 
      SKP 
* 
*     NAME:LOC
*     SUBROUTINE TO CALL 'LOCF' AND DETERMINE THE DISC LU 
*     AND SIZE OF THE CURRENT OUTPUT FILE.  ALSO PRINTS 
*     'WAITING FOR LU  XX'. 
* 
*     CALLING SEQUENCE: 
*       LDA ERCOD 
*       JSB LOC 
* 
* 
LOC   NOP 
      STA ERCOD     SAVE MOST RECENT ERROR CODE 
      JSB LOCF      GET FILE LU AND SIZE
      DEF RTN26 
      DEF DCBO,I
      DEF RUBSH     ERROR CODE
      DEF RUBSH     RECORD NO.
      DEF RUBSH     BLOCK 
      DEF RUBSH     OFFSET
      DEF WSIZE     SIZE IN SECTORS 
      DEF WLU       DISC LU 
RTN26 JSB FMPER     PRINT ANY ERRORS
      DEF NAMO,I
* 
      JSB NAME      MOVE THE LU NO. TO THE MESSAGE
      DEF WLU 
      DEF DLU 
* 
      JSB NAME      MOVE THE FILE NAME TO THE MESSAGE 
      DEF NAMO,I
      DEF FILE
* 
* 
      JSB REIO      PRINT 'NO ROOM FOR FILEXX ON LU  YY'
      DEF *+5 
      DEF .2
      DEF LOG 
      DEF FBUF
      DEF .14 
      JMP LOC,I 
* 
FBUF  ASC 6,NO ROOM FOR 
FILE  ASC 5,XXXXXX ON 
DLU   ASC 3,YYYYYY
* 
.14   DEC 14
* 
      SKP 
* 
*     NAME:LST
*     SUBROUTINE TO LIST A BUFFER ON
*      THE CURRENT LIST FILE. 
*     CALLING SEQUENCE: 
*          JSB LST
*          DEF BUFFER 
*          DEF COUNT
* 
LST   NOP 
      LDB LST,I     GET ADDRESS 
      ISZ LST 
      STB LSTB1 
      LDA LST,I     GET COUNT 
      ISZ LST 
      LDA A,I 
      STA LSTB2     WORD COUNT
      LDA LFLAG 
      IOR LIST
      SSA 
      JMP LST,I     NO LISTING ALLOWED
      LDA LIST
      CPA .2
      JMP WF        FILE, DO NOT ADD SPACES 
* 
      ISZ LSTB2     BUMP COUNT
      JSB DIRCT 
      ADB M1        BACK UP ADDRESS 
      STB LSTB1 
      LDB LSTB1,I   SAVE WORD PRECEDING MESSAGE 
      STB LSTB3 
      LDB SPSP      REPLACE WITH 2 SPACES 
      STB LSTB1,I 
      SZA,RSS 
      JMP IMS       PRINT MESSAGE ON CONSOLE
WF    JSB WRITF     PRINT MESSAGE 
      DEF *+5 
      DEF DCBL      DCB OF LIST DEVICE
      DEF RUBSH     ERROR 
LSTB1 NOP           BUFFER ADDRESS
      DEF LSTB2     COUNT 
      JSB FMPER     PRINT ANY ERRORS
      DEF LNAME 
      LDA LIST
      CPA .2
      JMP LST,I 
* 
RSTR  LDB LSTB3 
      STB LSTB1,I   RESTORE WORD PRECEDING MESSAGE
      JMP LST,I 
* 
LSTB2 NOP 
LSTB3 NOP 
* 
* 
LNAME BSS 3         LIST FILE NAME
      BSS 1 
LSECR BSS 1 
LCART BSS 1 
LTYPE BSS 1 
LSIZE BSS 1 
      BSS 2 
* 
* 
* 
* 
IMS   JSB REIO      LIST ON TERMINAL
      DEF *+5 
      DEF .2
      DEF LOG 
      DEF LSTB1,I 
      DEF LSTB2 
      JMP RSTR
      SKP 
* 
*     NAME:LSTSB
*     SUBROUTINES TO LIST THE PENDING LINE
*     CALLING SEQUENCE: 
*          JSB LSTSB
* 
LSTSB NOP 
      LDB PLNG
      SSB,INB 
      JMP EOFPR 
      BRS           CONVERT TO WORD COUNT 
      STB MX.CH 
      JSB LST       PERFORM LIST
      DEF PBUFF,I 
      DEF MX.CH 
      JMP LSTSB,I 
* 
EOFPR CCA 
      STA RPCNT     SET TO JUMP OUT OF REPEAT LOOP
      CLA 
      STA CLNG
      STA CCCNT     START OF COMMAND BUFFER 
      LDA LIST
      IOR LFLAG 
      SZA 
      JMP NODE1     ONLY PRINT IF LISTING TO TERMINAL 
* 
      JSB REIO      PRINT 'EOF' 
      DEF *+5 
      DEF .2
      DEF LOG 
      DEF EOF 
      DEF .2        WORD COUNT
      JMP NODE1 
* 
EOF   ASC 2,EOF 
      SKP 
* 
*     NAME:MACH?
*     SUBROUTINE TO COMPARE THE PENDING LINE TO 
*     THE MATCH BUFFER. 
*     CALLING SEQUENCE: 
*       JSB MACH? 
*       >NO MATCH 
*       >MATCH
* 
MACH? NOP           COMPARE PENDING LINE TO MATCH BUFFER
      CLA 
      STA BWIND 
      LDA MLNG
      LDB MBUFF 
      JSB COMPR 
      JMP MACH?,I   NO MATCH
      ISZ MACH? 
      JMP MACH?,I   MATCH 
* 
MLNG  NOP 
* 
      SKP 
* 
*     NAME: M.T 
*     SUBROUTINE TO EXCHANGE MBUFF AND TBUFF
*      BY SWAPPING POINTERS 
*     CALLING SEQUENCE: 
*          JSB M.T
* 
* 
M.T   NOP           SWAP TBUFF AND MATCH BUFFER 
      LDA TCCNT 
      SZA,RSS 
      JMP M.T,I     TBUFF EMPTY - DO NOT SWAP 
      STA MLNG
      CLA 
      STA TCCNT 
      LDA MBUFF 
      LDB TBUFF 
      STA TBUFF 
      STB MBUFF 
      JMP M.T,I 
      SKP 
* 
*     NAME:MX.CH
*     SUBROUTINE TO RETURN NEXT MATCH CHARACTER . 
*     CALLING SEQUENCE: 
*          JSB MX.CH
*     >END OF BUFFER
*     >CHARACTER IN A 
* 
MX.CH NOP 
      LDA MX.CN     # CHARACTERS ALREADY READ 
      CPA MX.LN     # CHARACTERS IN BUFFER
      JMP MX.CH,I     END OF VALID DATA 
      ISZ MX.CN 
      ISZ MX.CH       BUMP TO NORMAL RETURN 
      CLE,ERA       CONVERT TO WORDS
      ADA MX.BF     ADD BASE ADDRESS
      JSB CH        FETCH CHARACTER FROM BUFFER 
      JMP MX.CH,I 
      SKP 
* 
*     NAME:MVW
*     SUBROUTINE TO MOVE WORDS FROM ONE BUFFER
*      TO ANOTHER.
*     CALLING SEQUENCE: 
*          JSB MVW
*          DEF FROM ADDRESS 
*          DEF TO ADDRESS 
*          DEC # OF WORDS 
*          >'FROM ADDRESS' + N IN A-REG 
*           'TO ADDRESS' + N IN B-REG 
* 
MVW   NOP 
      CLA 
      STA REMAN     CLEAR REMAINDER 
      LDB MVW,I 
      ISZ MVW 
      JSB DIRCT     MAKE ADDRESS DIRECT 
      LDA B           AND COPY TO A 
      LDB MVW,I 
      ISZ MVW 
      JSB DIRCT 
* 
      JSB .MVW      MOVE WORDS
      DEF MVW,I 
REMAN NOP 
      ISZ MVW 
      JMP MVW,I 
      SKP 
* 
*     NAME:NAME 
*     SUBROUTINE TO MOVE A FILE NAME TO A BUFFER. 
*     IF THE PARAMETER IS NUMERIC, THE MESSAGE
*     'LU  XX' IS MOVED.
* 
*     CALLING SEQUENCE: 
*          JSB NAME 
*          DEF NAMBF  (MUST BE IN 'NAMR' PARSED FORMAT) 
*          DEF BUFFER (3-WORD DESTINATION BUFFER) 
* 
* 
NAME  NOP           MOVE A FILE NAME
      DLD NAME,I
      DST NAMBF 
      ISZ NAME
      ISZ NAME
      JSB MVW       MOVE THE FILE NAME
NAMBF NOP 
BUFFR NOP 
      DEC 3 
      LDA A,I 
      RAR,SLA 
      JMP NAME,I    ASCII FILE NAME, DONE 
* 
      LDA BUFFR,I   NUMERIC (LU)
      AND B77 
      STA NAMBF 
      JSB KCVT      CONVERT LU TO DECIMAL 
      DEF *+2 
      DEF NAMBF 
      LDB BUFFR 
      ADB .2
      STA B,I 
      DLD LU        MOVE ASCII PREFIX 
      DST BUFFR,I 
      JMP NAME,I    DONE
* 
      SKP 
*     NAME:NLSLU
*     SUBROUTINE TO SET UP A NEW LIST FILE
*     AND POSITION TO A GIVEN RECORD NUMBER.
*     THE FILE NAME 'L' IS TAKEN TO MEAN THE CURRENTLY
*     OPEN LIST FILE. 
*     CALLING SEQUENCE: 
*          JSB NLSLU
* 
*     LISTING IS CONTROLLED BY THE FOLLOWING FLAGS: 
*       LCOMF:  -1 IF COMMAND NORMALLY OUTPUTS A LISTING
*                0 OTHERWISE
* 
*       LFLAG:  <0 IF "<" COMMAND HAS BEEN ENTERED TO SUPPRESS LISTING
*                0 OTHERWISE
* 
*       LIST :  <0 IF NO LIST DEVICE IS AVAILABLE 
*               =0 IF LISTING IS TO GO TO THE SESSION CONSOLE 
*               =1 IF LISTING IS TO GO TO A DEVICE
*               =2 IF LISTING IS TO GO TO A FILE
* 
* 
* 
NLSLU NOP 
      JSB SC.CR     GET FILE NAME 
      DEF FNAME 
      JMP NLSLU,I   NO NAME ENTERED 
      CPA "L."
      JMP L.OPN     USE CURRENT OPEN LIST FILE
* 
      LDA FTYPE 
      CPA .1
      JMP ER006     WRONG FILE TYPE 
      CPA .2
      JMP ER006     WRONG FILE TYPE 
* 
      JSB LCLOZ     CLOSE THE PREVIOUS LIST FILE
* 
      JSB MVW       SAVE LIST FILE NAME 
      DEF FNAME 
      DEF LNAME 
      DEC 10
* 
      JSB OPENW     OPEN THE NEW LIST FILE
      DEF DCBL
      DEF RUBSH     ERROR CODE
      DEF LNAME     NAME
      DEF ZERO
      DEF LSECR 
      DEF LCART 
      DEF .128
      CPA M6
      JMP CRETL     CREATE A LIST FILE
      SSA 
      JMP NOLST 
      STA LTYPE 
* 
NLSEX LDB LTYPE 
      SZB 
TYPE4 CLB,INB 
      INB           DEVICE=1, FILE=2
      STB LIST
      CLB 
      STB LFLAG 
      CCB 
      LDA EXFLG 
      SZA,RSS 
      STB LCOMF     ALLOW LISTING 
* 
      LDA LIST
      CPA .2
      RSS           ALLOW RECORD NUMBER IF LISTING TO A FILE
      JMP NLSLU,I 
      JSB NUMIN     GET THE ABSOLUTE RECORD NUMBER
      SZA,RSS 
      JMP NLSLU,I   NO POSITIONING DESIRED
      STA REC 
* 
      JSB POSNT     POSITION THE LIST FILE
      DEF RTN20 
      DEF DCBL
      DEF RUBSH 
      DEF REC 
      DEF REC 
RTN20 SSA 
      CPA M12       IF PAST EOF, IGNORE THE ERROR 
      JMP NLSLU,I 
      JMP NOLST     PRINT ANY OTHER ERROR 
      JMP NLSLU,I 
* 
* 
CRETL LDA LSIZE 
      SZA,RSS 
      LDA .24 
      STA LSIZE 
      LDA LTYPE 
      SZA,RSS 
      LDA .4        DEFAULT TO TYPE 4 
      STA LTYPE 
      JSB CREAT     CREATE THE LIST FILE
      DEF RTN11 
      DEF DCBL
      DEF RUBSH 
      DEF LNAME 
      DEF LSIZE 
      DEF LTYPE 
      DEF LSECR 
      DEF LCART 
RTN11 SSA,RSS 
      JMP TYPE4     LIST FILE AVAILABLE 
NOLST JSB FMPER     PRINT ERROR 
      DEF LNAME 
      JSB LCLOZ     CLOSE THE LIST DCB
      JMP NODE1 
* 
"L."  ASC 1,L 
REC   NOP 
* 
L.OPN LDA LNAME 
      SZA 
      JMP NLSEX 
      JMP ER000     NO LIST FILE OPEN, ERROR
* 
      SKP 
* 
*     NAME:NUMIN
*     SUBROUTINE TO PARSE A NUMERIC PARAMETER FROM
*      THE COMMAND BUFFER.  PRINTS 'ER000' IF THE PARAMETER 
*     IS ASCII OR NEGATIVE. 
*     CALLING SEQUENCE: 
*          JSB NUMIN
*          > NUMBER IN A
* 
NUMIN NOP 
      JSB SC.CR     PARSE INPUT 
      DEF BUF10 
      JMP NUMIN,I   DEFAULT 
      LDB BUF10+3 
      SSA,RSS 
      RBR,SLB 
      JMP ER000     NEGATIVE OR ALPHA IS INVALID
      JMP NUMIN,I 
      SKP 
* 
*     NAME:NXCHR
*     SUBROUTINE TO FETCH NEXT COMMAND CHARACTER. 
*     SKIPS ALL BLANKS. 
*     CALLING SEQUENCE: 
*          JSB NXCHR
*          >COMMA OR END OF BUFFER RETURN HERE
*          >ANY OTHER CHARACTER IN A
* 
NXCHR NOP 
      JSB ECH       FETCH NEXT COMMAND CHAR.
      JMP NXCHR,I   NO MORE CHARS, RETURN 
      CPA COMMA 
      JMP NXCHR,I   COMMA, EXIT 
      ISZ NXCHR     BUMP RETURN ADDRESS 
      JMP NXCHR,I 
* 
      SKP 
*     NAME:OPENW
*     SUBROUTINE TO OPEN A FILE OR LU WITH WAIT.
*     IF THE FILE IS OPEN OR THE LU IS LOCKED TO
*     ANOTHER PROGRAM, THE EDITOR PRINTS
*     THE MESSAGE 'WAITING FOR XXXXXX', AND THEN
*     RETRIES THE OPEN REQUEST FOREVER AT 6 SECOND
*     INTERVALS.  RETRIES MAY BE STOPPED BY AN OPERATOR BREAK.
* 
* 
*     CALLING SEQUENCE: 
*          JSB OPENW
*          DEF DCB
*          DEF ERROR
*          DEF NAME 
*          DEF OPTION 
*          DEF SECR 
*          DEF CR 
*          DEF DCB SIZE 
*          >ERROR CODE IN A 
* 
* 
OPENW NOP           OPEN WITH WAIT
      CLA 
      STA ERCOD 
      JSB MVW       MOVE THE PARAMETERS TO THE CALL 
      DEF OPENW,I 
      DEF OPEND 
.7    DEC 7 
      LDA OPENW 
      ADA .7        ADJUST THE RETURN ADDRESS 
      STA OPENW 
* 
* 
OPNLP JSB OPENF     OPEN THE FILE OR LU 
      DEF *+8 
OPEND NOP           DCB 
OPENE NOP           ERROR CODE
OPENN NOP           NAME
      NOP           OPTION
      NOP           SECR
      NOP           CARTRIDGE 
      NOP           DCB SIZE
      CPA .1
      JMP BADTY     WRONG FILE TYPE 
      CPA .2
      JMP BADTY     WRONG FILE TYPE 
      SSA,RSS 
      JMP OPENW,I   SUCCESS!
* 
* 
      CPA M8
      RSS           FILE OPEN 
      CPA M36 
      RSS           LU LOCKED 
      JMP OPENW,I   FAILURE 
* 
* 
* 
      CPA ERCOD 
      JMP WAITO     MESSAGE ALREADY PRINTED 
* 
      STA ERCOD 
      JSB NAME      MOVE FILE NAME TO MESSAGE 
      DEF OPENN,I 
      DEF WBUF+9
* 
      JSB REIO      PRINT 'WAITING FOR XXXXXX'
      DEF *+5 
      DEF .2
      DEF LOG 
      DEF WBUF
      DEF .12 
* 
* 
WAITO JSB WAIT      WAIT 6 SECONDS
      JMP OPNLP     TRY AGAIN 
      LDA OPENE,I   NO MORE RETRIES, BREAK FLAG SET 
      JMP OPENW,I   FAILURE 
* 
* 
BADTY JSB CLOZE     CLOSE THE FILE
      DEF OPEND,I 
      DEF OPENN,I 
      JSB ERROR     'WRONG FILE TYPE' 
      DEF MS006 
      DEC 12
      LDA SIGN
      JMP OPENW,I 
* 
WBUF  ASC 12,XXXXX WAITING FOR XXXXXX 
M8    DEC -8
M36   DEC -36 
M100  DEC -100
SIGN  OCT 100000
* 
* 
      SKP 
* 
*     NAME:OUTPT
*     SUBROUTINE TO EXCHANGE IN THE PENDING LINE
*     AND OUTPUT IT TO THE FILE.
*     CALLING SEQUENCE: 
*          JSB OUTPT
* 
OUTPT NOP 
      LDA PLNG      IF EOF-NO PATTERNS
      SSA,RSS 
      JSB EXCH      EXCHANGE IF ENABLED 
      JSB WRITE     CALL OUTPUT ROUTINE 
      JMP OUTPT,I 
      SKP 
* 
*     NAME:OUTCR
*     SUBROUTINE TO STORE CHARACTER IN LOWER BYTE 
*      OF A-REGISTER INTO TBUFF.  BLANKS LOWER
*      BYTE OF WORD IN TBUFF IF A-REGISTER IS TO
*      BE STORED IN HIGH BYTE.
*      NO ACTION IF TBUFF IS FULL.
*     CALLING SEQUENCE: 
*          LDA CHARACTER
*          JSB OUTCR
* 
OUTCR NOP 
      LDB TCCNT     # CHARACTERS ALREADY IN BUFFER
      CPB .150      MAX ALLOWED IN BUFFER 
      JMP OUTCR,I   BUFFER ALREADY FULL 
      CLE,ERB       CONVERT TO WORDS
      ADB TBUFF     ADD BASE ADDRESS
      SEZ,RSS       MOVE CHARACTER TO PROPER BYTE 
      ALF,SLA,ALF   FOR INSERTION 
      XOR B,I       IF LOW BYTE, OR-TIE HIGH BYTE FROM BUFFER 
      XOR SPACE     FORCE LOWER BYTE TO SPACE IF NOT PROVIDED 
      STA B,I       MOVE CREATED WORD TO BUFFER 
      ISZ TCCNT     BUMP COUNTER
      JMP OUTCR,I 
* 
.150  DEC 150 
      SKP 
* 
*     NAME:PCH
*     SUBROUTINE TO FETCH NEXT PENDING LINE CHARACTER 
*     CALLING SEQUENCE: 
*          JSB PCH
*          >END OF BUFFER 
*          >CHARACTER IN A
* 
PCH   NOP           ENTER WITH CHARACTER COUNT IN 
      LDA PCCNT      PCCNT AND SOURCE BUFFER START
      CPA PLNG        ADDRESS IN PBUFF. 
      JMP PCH,I 
      ISZ PCCNT     IF AT END OF SOURCE RECORD, 
      ISZ PCH        EXIT TO P+1. 
      CLE,ERA 
      ADA PBUFF     IF NOT AT END OF SOURCE RECORD, 
      JSB CH        FETCH CHARACTER FROM BUFFER 
      JMP PCH,I 
* 
      SKP 
* 
*     NAME:POSTI
*     THIS ROUTINE POSTS THE INPUT DCB TO MAKE
*     IT AVAILABLE FOR A BACK-UP STACK. 
*     THE STACK POINTERS ARE INITIALIZED. 
*     CALLING SEQUENCE: 
*     JSB POSTI 
* 
* 
POSTI NOP           POST THE INPUT BUFFER 
      LDA SLNG
      SZA 
      JMP POSTI,I   ALREADY POSTED
* 
      JSB POST      FREE UP THE BUFFER
      DEF *+2 
      DEF DCBI,I
      JSB FMPER     PRINT ANY ERRORS
      DEF NAMI,I
* 
      LDA DCBI
      ADA .16 
      STA SPTR      POINTER TO BUFFER 
* 
      LDA DCBSZ 
      CMA,INA 
      STA SCNT      NEG. NO. OF WORDS AVAILABLE 
      JMP POSTI,I 
* 
SCNT  NOP 
* 
      SKP 
* 
*     NAME:PUSH 
*     THIS ROUTINE PUSHES THE PENDING LINE ONTO 
*     THE BACK-UP STACK IN THE INPUT DCB. 
* 
*     THE THE RECORD LENGTH IN CHARACTERS IS STORED 
*     IN THE WORD FOLLOWING THE DATA. 
*     CALLING SEQUENCE: 
*     JSB PUSH
*     >STACK OVERFLOW 
*     >DATA ACCEPTED
* 
PUSH  NOP           MOVE A RECORD TO THE STACK
      LDA PLNG
      SSA 
      JMP POUT      END OF FILE, SKIP IT
      INA 
      ARS           CONVERT TO WORD COUNT 
      STA CNT 
      ADA SCNT      CHECK FOR ROOM ON STACK 
      SSA,RSS 
      JMP PUSH,I    OVERFLOW
* 
      INA           LENGTH WORD 
      STA SCNT
      ISZ SLNG      BUMP STACK RECORD COUNT 
      JSB MVW 
      DEF PBUFF,I 
      DEF SPTR,I
CNT   NOP 
      LDA PLNG
      STA B,I       TOP OF STACK GETS RECORD LENGTH 
      INB 
      STB SPTR      NEW STACK POINTER VALUE 
* 
POUT  ISZ PUSH
      JMP PUSH,I
* 
      SKP 
* 
*     NAME:READ 
*     SUBROUTINE TO READ A RECORD FROM THE
*      CURRENT INPUT FILE AND STORE IT IN 
*      THE PENDING LINE BUFFER.  THE RECORD IS POPPED OFF THE STACK 
*     IF THE BACK-UP STACK IS NOT EMPTY.
*     CALLING SEQUENCE: 
*          JSB READ 
*          >PLNG IN A (-1 IF END OF FILE) 
* 
READ  NOP 
      CLB 
      STB PCCNT 
      LDA SLNG
      SZA 
      JMP POP       READ IT FROM THE STACK
* 
      JSB READF     READ FROM THE INPUT FILE
      DEF *+6 
      DEF DCBI,I             READ 
      DEF RUBSH              SOURCE 
      DEF PBUFF,I            RECORD 
      DEF .75 
      DEF PLNG
* 
      CPA M12 
      JMP OKEOF     END OF FILE 
      JSB FMPER     PRINT ANY OTHER ERRORS
      DEF NAMI,I
OKEOF CCB 
      SSA 
      STB PLNG      SET LINE LENGTH TO -1 
      LDA PLNG
      SSA 
      JMP READ,I      END OF FILE 
      ALR           CONVERT COUNT TO CHARS
      STA PLNG
RDOUT ISZ LINES     BUMP LINE COUNT 
      JMP READ,I
* 
* 
POP   ADA M1
      STA SLNG      ONE LESS RECORD ON STACK
      CCB 
      ADB SPTR
      LDA B,I       SIZE OF RECORD
      STA PLNG
      INA 
      ARS           CONVERT TO WORD COUNT 
      STA RDCNT 
      CMA,INA 
      ADB A 
      STB SPTR      NEW STACK POINTER 
      ADA M1
      ADA SCNT
      STA SCNT      UPDATE NO. OF WORDS AVAILABLE ON STACK
* 
      JSB MVW 
SPTR  NOP 
      DEF PBUFF,I 
RDCNT NOP 
      JMP RDOUT 
* 
M12   DEC -12 
* 
      SKP 
* 
*     NAME:RDM
*     THIS ROUTINE READS A RECORD FROM THE MERGE FILE 
*     INTO PBUFF.   <RDM> JUMPS TO <ENDM> IF AN 
*      ERROR OCCURS OF IF END OF FILE IS READ.
*     CALLING SEQUENCE: 
*     JSB RDM 
*     >LINE LENGTH IN A 
* 
RDM   NOP           READ MERGE FILE 
      JSB READF     READ MERGE FILE 
      DEF *+6 
      DEF DCBL
      DEF RUBSH 
      DEF PBUFF,I 
      DEF .75 
      DEF PLNG
      JSB FMPER     PRINT ANY ERRORS
      DEF FNAME 
      IOR PLNG
      SSA 
      JMP ENDM      ERROR OR END OF FILE
      CLB 
      STB PCCNT 
      LDA PLNG
      ALS 
      STA PLNG      MULTIPLY BY TWO FOR CHARACTERS
      JMP RDM,I 
* 
      SKP 
* 
*     NAME:READE
*     THIS ROUTINE READS A LINE FROM THE INPUT FILE 
*     AND JUMPS TO <DISPL> IF END OF FILE IS READ.
*     CALLING SEQUENCE: 
*     JSB READE 
*     >PLNG IN A
* 
* 
READE NOP           READ AND CHECK FOR END OF FILE
      JSB READ      READ NEXT RECORD
      SSA 
      JMP DISPL     END OF FILE - PRINT MESSAGE 
      JMP READE,I 
* 
      SKP 
* 
*     NAME:RWNDI
*     SUBROUTINE TO REWIND THE CURRENT INPUT FILE 
*      AND RESET THE CURRENT LINE COUNTER TO ZERO.
*     CALLING SEQUENCE: 
*          JSB RWNDI
* 
RWNDI NOP 
* 
      JSB RWNDF             ! REWIND
      DEF *+2               ! THE INPUT 
      DEF DCBI,I            ! FILE
* 
      JSB FMPER    PRINT ERRORS IF ANY
      DEF NAMI,I
      CLA           RESET THE LINE COUNTER
      STA LINES 
      STA SLNG      CLEAR THE STACK 
      JMP RWNDI,I 
      SKP 
* 
*     NAME:RWNDO
*     SUBROUTINE TO REWIND THE CURRENT
*      OUTPUT FILE. 
*     CALLING SEQUENCE: 
*          JSB RWNDO
* 
RWNDO NOP 
* 
      JSB RWNDF             ! 
      DEF *+2               ! 
      DEF DCBO,I            ! 
* 
      JSB FMPER    PRINT ERRORS IF ANY
      DEF NAMO,I
* 
      JSB WEOF      WRITE AN END OF FILE
* 
      CLA           RESET DESTINATION FILE RECORD COUNTERS
      STA T#REC 
      STA T#WDS 
      STA T#WDS+1 
      JMP RWNDO,I   NONE
      SKP 
* 
*     NAME:SC.CR
*     SUBROUTINE TO PARSE A FILE NAME .  THE RETURNED 
*     BUFFER IS TEN WORDS LONG: 
*       WORDS 1-3 :  FILE NAME (OR LU IN WORD 1)
*       WORD    4 :  PARAMETER TYPES (SEE <NAMR> SUBROUTINE)
*       WORD    5 :  SECURITY CODE
*       WORD    6 :  CARTRIDGE REFERENCE
*       WORD    7 :  FILE TYPE
*       WORD    8 :  FILE SIZE
*       WORD    9 :  RESERVED 
*       WORD   10 :  RESERVED 
* 
*     CALLING SEQUENCE: 
*          JSB SC.CR
*          DEF BUFFER 
*          >NULL OR ZERO
*          >WORD 1 IN A 
* 
* 
SC.CR NOP 
      LDA SC.CR,I 
      ISZ SC.CR 
      STA PRSBF 
      ISZ ECCNT     ADJUST CHAR COUNT 
* 
      JSB NAMR      PARSE THE INPUT 
      DEF *+5 
PRSBF NOP 
      DEF EBUFF,I 
      DEF ELNG
      DEF ECCNT 
* 
      CCB 
      ADB ECCNT     RESET THE CHAR COUNT
      STB ECCNT 
      LDA PRSBF,I 
      SZA 
      ISZ SC.CR     BUMP UNLESS DEFAULTED 
      JMP SC.CR,I 
* 
      SKP 
* 
* 
*     NAME:SWPET
*     SUBROUTINE TO EXCHANGE TBUFF AND EBUFF BY 
*      SWAPPING BUFFER POINTERS.
*     CALLING SEQUENCE: 
*          JSB SWPET
* 
SWPET NOP 
      LDA TBUFF     SWAP
      LDB EBUFF      EBUFF
      STA EBUFF       AND 
      STB TBUFF        TBUFF
      LDA TCCNT     STORE OUTPUT CHARACTER
      STA ELNG       LENGTH IN COMMAND LENGTH 
      CLB           RESET COMMAND 
      STB ECCNT      AND OUTPUT 
      STB TCCNT       CHARACTER POINTERS
      JMP SWPET,I 
* 
      SKP 
* 
*     NAME:TAB
*     SUBROUTINE TO SCAN TEXT LINE IN EBUFF 
*      MOVING IT TO TBUFF 
*      REPLACING TAB CHARACTERS WITH THE CORRECT NUMBER 
*      OF TAB FILLER CHARACTERS (USUALLY SPACES)
*     CALLING SEQUENCE: 
*          JSB TAB
* 
TAB   NOP 
      CLA           RESET OUTPUT
      STA TCCNT      CHARACTER COUNTER AND
      STA SWPET       NON-CONTROL CHARACTER COUNTER 
      LDA TABUF     RESET 
      STA TBPNT      TAB POINTER
TAB1  JSB ECH      GET NEXT COMMAND CHARACTER 
      JMP TAB,I    END OF COMMAND 
      CPA TABCR    TAB CHARACTER ?
      JMP TBFND    YES, GO TO TAB FOUND 
      LDB A         IS CHARACTER
      CMB            CONTROL
      ADB SPACE       CHARACTER 
      SSB           IF YES DO NOT INCREMENT 
      ISZ SWPET      NON-CONTROL CHARACTER COUNTER
      JSB OUTCR    NO, OUTPUT CHARACTER 
      JMP TAB1
TBFND CCB          SET FILL COUNTER 
      STB TR
TBFLP LDB TBPNT,I    TAB POINTER
      CMB,INB,SZB,RSS 
      JMP TABIT     END OF LIST, OUTPUT SINGLE FILL CHAR
      INB 
      ISZ TBPNT    BUMP TAB POINTER ADDRESS 
      ADB SWPET      PAST 
      SSB,RSS         TAB?
      JMP TBFLP    YES, GET NEXT TAB
      STB TR     STORE FILL COUNTER 
TABIT LDA TBFIL    OUTPUT FILL CHAR 
      JSB OUTCR 
      ISZ SWPET     BUMP NON-CONTROL CHAR. CNTR.
      ISZ TR     LAST FILL? 
      JMP TABIT    NO, CONTINUE FILLING 
      JMP TAB1     GET NEXT CHARACTER 
      SKP 
* 
*     NAME:TR 
*     SUBROUTINE TO CONTROL PENDING LINE MOVES TO THE 
*      DESTINATION FILE OPTIONALLY LISTING LINE DURING
*      MOVE.  FETCHES NEXT LINE AFTER MOVE.  ALSO 
*      CHECKS FOR OPERATOR INTERRUPTS.
*     CALLING SEQUENCE: 
*          JSB TR 
*          >LENGTH OF NEW LINE IN A 
* 
TR    NOP 
      LDA PLNG      IF AT 
      SSA            EOF, 
      JMP DISPL        PRINT MESSAGE
      JSB BRK?      TEST BREAK FLAG 
      DEF DISPL     BREAK FLAG SET
      JSB EXCH      EXCHANGE IF ENABLED 
      LDB LCOMF     LIST CURRENT
      SZB           RECORD? 
      JSB LSTSB      YES, PERFORM LIST
      LDB TRFLG     TRANSFER RECORD TO
      SZB           DESTINATION FILE? 
      JSB WRITE     YES-OUTPUT RECORD 
      JSB FMP?      JUMP IF ERROR 
      DEF DISPL 
      JSB READE     READ NEXT INPUT 
      JMP TR,I
      SKP 
*     NAME:RDCOM
*     SUBROUTINE TO PRINT PROMPT CHARACTER
*      RING BELL, INPUT COMMAND, AND RESET
*      CHARACTER COUNTERS.
*     CALLING SEQUENCE: 
*          JSB RDCOM
*          >A=ZERO
* 
RDCOM NOP 
      STB PRMLN     ADDRESS OF PROMPT LENGTH
      INB 
      STB PRMPT       AND PROMPT
* 
      JSB BRK?      TEST THE BREAK FLAG 
      DEF *+1 
      LDA BRKFL 
      IOR FMP 
      SZA 
      JMP RDCM1     BREAK HAS OCCURRED
      ISZ RPCNT 
      JMP ZCNT      SKIP READ, RESET POINTER
RDCM1 LDB TTY 
      SZB           INTERACTIVE INPUT DEVICE? 
      JMP NOTY      NO
      STB BRKFL     CLEAR THE BREAK FLAG
      STB FMP       CLEAR THE FMP ERROR ACCUMULATOR 
* 
      JSB .OPSY     L-SERIES OP SYSTEM? 
      CPA M31 
      JMP ZEIO      YES 
      CPA M29 
      JMP ZEIO      YES, L/20 
* 
      JSB REIO      WRITE THE PROMPT
      DEF *+5 
      DEF .2
      DEF LOG 
      DEF PRMPT,I 
      DEF PRMLN,I 
* 
      JSB REIO      READ THE RESPONSE 
      DEF *+5 
      DEF .1
      DEF ELOG      LOG LU, ECHO BIT SET
      DEF CBUF0 
      DEF M150
      JMP RDEX      PROCESS COMMAND 
* 
* 
ZEIO  JSB REIO      WRITE/READ FROM TERMINAL
      DEF RTN14 
      DEF .1
      DEF ZLOG      LOG LU, Z-BIT & E-BIT SET 
      DEF CBUF0 
      DEF M150
PRMPT NOP 
PRMLN NOP 
RTN14 JMP RDEX
* 
NOTY  SZA 
      JMP ./AB      BREAK, ABORT EDIT 
* 
      JSB READF     READ A RECORD FROM COMMAND INPUT DEVICE 
      DEF *+6 
      DEF DCBE
      DEF RUBSH 
CBUFF DEF CBUF0 
      DEF .75       WORD COUNT
      DEF CLNG      ACTUAL TRANSMISSION 
      JSB FMPER     PRINT ANY ERRORS
      DEF ENAME 
      LDB CLNG
      SSB 
      CLB,RSS       IF EOF, SET TO ZERO 
      BLS           CONVERT TO CHARACTER COUNT
RDEX  STB CLNG
      CCA 
      STA RPCNT     DEFAULT REPEAT COUNT
ZCNT  CLA 
      STA CCCNT     CLEAR COMMAND CHAR COUNTER
      STA LFLAG 
      JMP RDCOM,I 
* 
* 
M29   DEC -29 
M31   DEC -31 
* 
      SKP 
* 
*     NAME:TTYIP
*     THIS ROUTINE EXTRACTS A COMMAND FROM CBUFF
*     AND MOVES IT TO EBUFF.  IF THE REPEAT COUNT 
*     IS EXCEDED, A NEW COMMAND IS READ INTO CBUFF. 
*     CALLING SEQUENCE: 
*     JSB TTYIP 
*     DEF PROMPT (IGNORED IF NON-INTERACTIVE
*                 OR IF COMMAND BUFFER STILL VALID) 
* 
* 
TTYIP NOP           FETCH A COMMAND 
      LDB TTYIP,I 
      ISZ TTYIP 
      LDA CCCNT 
      CPA CLNG      IF LINE IS EXHAUSTED
      JSB RDCOM        READ NEXT
      STA TRUNC     SAVE CURRENT CHARACTER COUNT
      CLA 
      STA PCCNT     RESET PENDING LINE POINTER
      STA TCCNT        AND OUTPUT BUFFER POINTER
      JSB CCH       FETCH A COMMAND CHARACTER 
      JMP *+3       END OF COMMAND
      JSB OUTCR     COPY TO TBUFF 
      JMP *-3 
      JSB SWPET     SWAP TBUFF AND EBUFF
      JMP TTYIP,I 
* 
      SKP 
* 
*     NAME:WAIT 
*     SUBROUTINE TO WAIT 6 SECONDS AND CHECK THE BREAK FLAG.
* 
*     CALLING SEQUENCE: 
*       JSB WAIT
*       >NORMAL RETURN
*       >BREAK FLAG SET 
* 
WAIT  NOP           WAIT 6 SECONDS
      JSB BRK?      CHECK THE BREAK FLAG
      DEF RTN23     RETURN +2 
* 
      JSB EXEC      TIME SUSPEND THE EDITOR 
      DEF RTN23 
      DEF TIME      CODE 12 
      DEF ZERO      NAME
      DEF .2        CODE 2=SECONDS
      DEF ZERO      MULTIPLE
      DEF M6        6 SECONDS 
* 
RTN23 ISZ WAIT      BREAK, OR ABORT RETURN FROM EXEC 12 
      JMP WAIT,I
* 
TIME  DEF 12,I      TIME SUSPEND, NO ABORT
* 
      SKP 
* 
*     NAME:WEOF 
*     THIS ROUTINE WRITES AN END OF FILE TO 
*     THE OUTPUT FILE AND THEN BACKSPACES OVER IT.
*     IT IS VERY IMPORTANT TO WRITE AN END OF FILE
*     WHENEVER THE OUTPUT FILE IS RE-POSITIONED BECAUSE 
*     IT IS NORMALLY IN UPDATE MODE.  IF THE EOF IS 
*     NOT WRITTEN, THEN AN FMP -5 ERROR MAY BE REPORTED.
*     CALLING SEQUENCE: 
*     JSB WEOF
* 
* 
WEOF  NOP           WRITE END OF FILE 
      JSB WRITF     WRITE END OF FILE 
      DEF RTN13 
      DEF DCBO,I
      DEF RUBSH 
      DEF RUBSH     (BUFFER)
      DEF M1
RTN13 JSB FMPER 
      DEF NAMO,I
* 
      JSB POSNT     BACKSPACE OVER 'EOF'
      DEF RTN19 
      DEF DCBO,I
      DEF RUBSH 
      DEF M1
RTN19 CPA M3
      JMP WEOF,I    'BACKSPACE ILLEGAL', IGNORE IT
      JSB FMPER     PRINT ANY OTHER ERRORS
      DEF NAMO,I
      JMP WEOF,I
* 
      SKP 
* 
*     NAME:WRITE
*     SUBROUTINE TO WRITE THE PENDING LINE
*      AND TRACK THE NUMBER OF RECORDS AND WORDS IN THE 
*      DESTINATION FILE.
*     CALLING SEQUENCE: 
*          JSB WRITE
* 
WRITE NOP 
      LDA PLNG      FETCH NUMBER OF CHARACTERS IN LINE
      SSA 
      JMP WREOF     WRITE END OF FILE 
      STA ERCOD     SET FLAG POSITIVE 
      INA 
      CLE,ARS       CONVERT TO WORDS
      STA TEMP
      ADA T#WDS     UPDATE # OF WORDS IN DEST CHAIN/FILE
      SEZ 
      ISZ T#WDS+1 
      STA T#WDS 
      ISZ T#REC     BUMP RECORD COUNT 
* 
WRLP  JSB WRITF     WRITE THE RECORD
      DEF RTN15 
      DEF DCBO,I
      DEF WERR
      DEF PBUFF,I 
      DEF TEMP
RTN15 CPA M33 
      JMP WFILE     NO FILE SPACE FOR EXTENT
      CPA M14 
      JMP WDIRC     NO DIRECTORY SPACE FOR EXTENT 
      JSB FMPER     PRINT ANY ERRORS
      DEF NAMO,I
      JMP WRITE,I 
* 
TEMP  NOP 
M33   DEC -33 
M14   DEC -14 
ERCOD NOP 
* 
WLU   NOP           THERE MUST BE A ZERO AT 'WLU+3' 
WERR  NOP 
WSIZE NOP 
WZERO OCT 0 
* 
WFILE CPA ERCOD 
      JMP WAITW     ERROR MESSAGE ALREADY PRINTED 
* 
      JSB LOC       GET THE DISC LU AND #OF BLOCKS REQUIRED 
* 
      LDA WSIZE 
      ARS           DIVIDE SECTORS BY TWO 
      STA WSIZE       TO GET BLOCKS 
* 
      JSB CNUMD     CONVERT BLOCKS TO ASCII 
      DEF *+3 
      DEF WSIZE 
      DEF WFMSG+2 
* 
      JSB REIO      PRINT 'NEED XXXXX BLOCK EXTENT' 
      DEF *+5 
      DEF .2
      DEF LOG 
      DEF WFMSG 
      DEF .12 
* 
WAITW JSB WAIT      WAIT 6 SECONDS
      JMP WRLP      TRY AGAIN 
* 
      LDA WERR      BREAK FLAG SET, NO MORE RETRIES 
      JSB FMPER     PRINT FMP ERROR CODE
      DEF NAMO,I
* 
* 
      JSB REIO      PRINT 'ENTER "-77777B,FILEXX" COMMAND'
      DEF *+5 
      DEF .2
      DEF LOG 
      DEF ENTER 
      DEF .15 
      JMP WRITE,I   FAILURE 
* 
* 
WDIRC CPA ERCOD 
      JMP WAITW     MESSAGE ALREADY PRINTED, WAIT 6 SECONDS 
* 
      JSB LOC       GET THE DISC LU 
* 
      JSB REIO      PRINT 'NEED DIRECTORY SPACE'
      DEF *+5 
      DEF .2
      DEF LOG 
      DEF WDMSG 
      DEF .10 
      JMP WAITW     WAIT 6 SECONDS AND TRY AGAIN
* 
* 
WREOF JSB WEOF      WRITE THE END OF FILE 
      JMP WRITE,I 
* 
* 
* 
* 
WFMSG ASC 12,NEEDXXXXXX BLOCK EXTENT
WDMSG ASC 10,NEED DIRECTORY SPACE 
ENTER ASC 15,ENTER "-77777B,FILEXX" COMMAND 
* 
      SKP 
* 
*     NAME:YCH
*     SUBROUTINE TO FETCH THE NEXT CHARACTER
*      FROM THE REPLACEMENT STRING. 
*     CALLING SEQUENCE: 
*          JSB YCH
*          >END OF BUFFER 
*          >CHARACTER IN A
* 
YCH   NOP 
      LDA YCCNT     # CHARACTERS ALREADY READ 
      CPA YLNG      # CHARACTERS IN BUFFER
      JMP YCH,I     END OF VALID DATA 
      ISZ YCCNT 
      ISZ YCH       BUMP TO NORMAL RETURN 
      ADA YOFFS     BUMP TO CHARACTER WANTED
      CLE,ERA       CONVERT TO WORDS
      ADA XYBUF     ADD BASE ADDRESS
      JSB CH        FETCH CHARACTER FROM BUFFER 
      JMP YCH,I     RETURN
      SKP 
* 
*     BUFFERS 
* 
CBUF0 BSS 75
DCBE  BSS 144 
DCBL  BSS 144 
DCBIH BSS 16
DCBSH BSS 16
* 
* 
EBUF0 EQU *+3 
      BSS 78
* 
MBUF0 EQU *+3 
      BSS 78
* 
PBUF0 EQU *+3 
      BSS 78
* 
TBUF0 EQU *+3 
      BSS 78
* 
XYBF0 EQU *+3 
      BSS 78
* 
SIZE  EQU * 
      END EDITL 
                                                                                                                      