NAM EDIT
 ORG TCA
VERSION FCB $18
DATE FCB $2,$8,$81
NAME FCC /EDIT  /
*
************************************************
*                                              *
*             CHANGE HISTORY                   *
*                                              *
************************************************
*
* ADDED 8/27/80  VER 4
* KI "KILL" AND TY "TYPE" FOR COMPATABILITY WITH
*
* ADDED 1/31/81  VER 7
* QUIT TO KILL PRESENT EDIT AND ASK FILE NAME
* ALSO NAME TYPEOUT AT END OF EDIT
*
* 2/1/81  VER 8
* CHANGED L FROM LIST TO FIND  (LOOK)
*  AND ADDED LI FOR LIST
* FOR COMPATABILITY WITH GTE'S TS EDIT.
* ALSO ADDED VT TO PRINT VERT TAB
* AND HELP PRINTS COMMANDS
*
* 2/1 81  VER 9
* ADDED WAIT 
*
* CHANGED 2/1/81  VER 10
* HELP READS 0:EDHELP.TXT
* ADDED VT5
*
* 2/2/81  VER 11 ADDED COMMENTS
*
* 2/2/81  VER 12 ADDED COMMENTS
*
* 2/2/81  VER 13 ADDED COMMENTS
*
* 2/6/81  VER 14 ADDED COMMENTS
*
* 2/8/81  VER 15 ADDED COMMENTS
*
* 2/8/81  VER 16 ADDED COMMENTS
*
************************************************
*
* INTERNAL EQUATES
*
HELPCT EQU 3
CURUP EQU $12 ^R
SPHELP EQU 20
PROMPT EQU $23
*
* EXTERNAL EQUATES
*
E011 EQU $D37A
E012 EQU $D371
NMIVEC EQU $F006
PC EQU $F048
TMPCOR EQU $F080
EDTMP EQU $F0B0
*
 ORG $10
*
STACK RMB 2
V054 RMB 1
V055 RMB 1
V050 RMB 1
CLOREX RMB 1
V05A RMB 1
V056 RMB 1
V058 RMB 1
V052 RMB 1
TEMP RMB 2
XSAVE RMB 2
BUFPNT RMB 2
BUFSAV RMB 2
CURPOS RMB 2
NEWPOS RMB 2
SRCHPT RMB 2
STRNGB RMB 2
STRNGE RMB 2
STRGB1 RMB 2
STRGE1 RMB 2
STRPNT RMB 2
SPCPT1 RMB 2
SPCPT2 RMB 2
LASTNO RMB 2
ZONE1 RMB 2
ZONE2 RMB 2
ZONBUF RMB 2
CHGPNT RMB 2
CHGEND RMB 2
OCRTMP RMB 2
NUMFLG RMB 1
VERFLG RMB 1
MSLFLG RMB 1
PSTZFL RMB 1
LPTFLG RMB 1
OCRCNT RMB 2
FNDFLG RMB 1
STRCN1 RMB 1
OVRBEG RMB 1
OVREND RMB 1
NOCURL RMB 1
LINFLG RMB 1
NXTFLG RMB 1
ALLFLG RMB 1
OCRFLG RMB 1
CHGONF RMB 1
APPCOL RMB 1
STRCNT RMB 1
INCAMT RMB 1
BMPFLG RMB 1
EQUFLG RMB 1
INLMFL RMB 1
MOVFLG RMB 1
REPFLG RMB 1
TMPCHR RMB 1
CHKFLG RMB 1
SNGLIN RMB 1
CHGFLG RMB 1
STRCN2 RMB 1
FNONFL RMB 1
LSTFLG RMB 1
DECCNT RMB 1
PRNFLG RMB 1
CPTDRC RMB 1
DRCNT RMB 1
CHRCNT RMB 2
INZFLG RMB 1
NUMBER RMB 3
TRGLIN RMB 2
DELIM RMB 1
HEDCNT RMB 1
MEMEND RMB 1
V05D RMB 1
FILBEG RMB 2
FILEND RMB 1
V057 RMB 1
TABPNT RMB 2
TABBUF RMB $14
BUFFER RMB 110
 ORG $100
ED JMP EDINI0
WARMS JMP RESTRT
MEMTOP FDB $8000
INCH JSR ZGETCH
OUTCH TST LPTFLG
 BNE LPTOUT
CTYOUT JMP ZPUTCH
LPTOUT JMP ZHCOUT
LPTINI JMP ZHCINT
 ORG $119
CNRSTR FCB $10,$16,4 ; FOR 'X' CMD
*
* COMMAND TABLE
*
TABLE FCC 'A'
 FCB 0
 FDB APPEND
 FCC 'B'
 FCB 0
 FDB BOTTOM
 FCC 'CLO'
 FCB 0
 FDB CLOSE
 FCC 'CO'
 FCB 0
 FDB COPY
 FCC 'C'
 FCB 0
 FDB CHANGE
 FCC 'DOS'
 FCB 0
 FDB DOS
 FCC 'D'
 FCB 0
 FDB DELETE
 FCC /EJ/
 FCB 0
 FDB LPTEJ
 FCC 'EXP'
 FCB 0
 FDB EXPAND
 FCC /FI/
 FCB 0
 FDB STOP
 FCC 'F'
 FCB 0
 FDB CFIND
 FCC /GO/
 FCB 0
 FDB ASMB
 FCC 'HELP'
 FCB 0
 FDB HELP
 FCC /HCON/
 FCB 0
 FDB PAPER
 FCC /HCOF/
 FCB 0
 FDB NPAPER
 FCC 'H'
 FCB 0
 FDB HEADER
 FCC /ID/
 FCB 0
 FDB IDFILE
 FCC 'I'
 FCB 0
 FDB INSERT
 FCC /J/
 FCB 0
 FDB JOIN
 FCC /KI/ ; FOR KILL
 FCB 0
 FDB DOS
 FCC 'LOG'
 FCB 0
 FDB STOP
 FCC 'LI'
 FCB 0
 FDB LIST
 FCC 'L'
 FCB 0
 FDB CFIND
 FCC 'MON'
 FCB 0
 FDB ZMON
 FCC 'MO'
 FCB 0
 FDB MOVE
 FCC 'NEW'
 FCB 0
 FDB NEW
 FCC 'NU'
 FCB 0
 FDB NUMBRS
 FCC 'N'
 FCB 0
 FDB NEXT
 FCC 'O'
 FCB 0
 FDB OVRLAY
 FCC 'P'
 FCB 0
 FDB PRINTU
 FCC /QUIT/
 FCB 0
 FDB QUITER
 FCC 'READ'
 FCB 0
 FDB READ
 FCC 'REN'
 FCB 0
 FDB RENUMB
 FCC 'RETRY'
 FCB 0
 FDB RETRY
 FCC 'R'
 FCB 0
 FDB REPLCE
 FCC 'SET'
 FCB 0
 FDB SET
 FCC /SP/
 FCB 0
 FDB SPLIT
 FCC 'STOP'
 FCB 0
 FDB STOP
 FCC 'TAB'
 FCB 0
 FDB TAB
 FCC /TY/
 FCB 0
 FDB PRINTU
 FCC 'T'
 FCB 0
 FDB TOP
 FCC /U/
 FCB 0
 FDB UPLINE
 FCC 'VT5'
 FCB 0
 FDB LPTVT5
 FCC 'VT'
 FCB 0
 FDB LPTVT
 FCC 'V'
 FCB 0
 FDB VERSET
 FCC /WA/
 FCB 0
 FDB WAIT
 FCC 'W'
 FCB 0
 FDB WRITE
 FCC 'X'
 FCB 0
 FDB XCNTRL
 FCC 'Z'
 FCB 0
 FDB SZONE
 FDB 0
*
* ASMB SETS A FLAG THAT IS TESTED BY EDEXIT
* IF FLAG NOT SET EXIT NORMAL,IF SET EXIT VIA TMPCOR
* IE. DO TMP ECT
*
ASMB INC ASMBYT
 JMP STOP
EDEXIT TST QUIT ; KI OR DOS?
 BNE QUIT1 ; BRA IF YES
 LDX #CREAST ; CREATED
 JSR PSTRNG
 INX ; "ED"
 JSR PDATAP
 LDX #RFCB+2 ; POINT TO FILE NAME
 JSR FNOUT ; PRINT IT
QUIT1 TST IQUIT ; "QUIT"?
 BNE QUIT2 ; BRA IF YES
 LDX #ZWARMS
 STX YABRTV ; RESET ^C TRAP
 LDAA PPPAS
 STAA YPPPAS ; RESET WAIT FLAG
 TST ASMBYT ; "GO"?
 BEQ EXIT ; BRA IF NOT
 LDX #TMPCOR ; POINT TO TMPCOR
 STX YLINPT ; POINT LINE POINTER TO IT
 STX YLINAD ; POINT LINE POINTER TO IT
 JSR ZEXCMD ; EXEC THE COMMAND IN TMPCOR
*
EXIT JMP ZWARMS ; EXIT TO DOS
*
QUIT2 JMP EDINIT ; "QUIT" CLOSES FILES, RE-INIT EDIT
*
ASMBYT FCB 0
*
* TABLE FOR THE SET COMMAND
*
CHRTBL FCC 'TAB'
 FCB 0
 FDB STAB
 FCC 'FILL'
 FCB 0
 FDB SFILL
 FCC 'EOL'
 FCB 0
 FDB SEOL
 FCC 'LINO'
 FCB 0
 FDB SLINO
 FCB 0
*
* ON/OFF TABLE
*
ONOFTB FCC 'ON'
 FCB 0
 FDB ON
 FCC 'OFF'
 FCB 0
 FDB OFF
 FCB $D
 FCB 0
 FDB TOGGLE
 FCB 0
*
TABCH FCB 9
FILL FCC ' '
LINO FCC '#'
EOL FCC '\'
*
* STRINGS
*
CRLFST FCB $D,$A,4
BFRSTR FCC 'BOTTOM OF FILE REACHED'
 FCB 4
ERRSTR FCC '? THAT DOES NOT COMPUTE !!'
 FCB 4
FILQU FCC 'FILE NAME: '
 FCB 4
ILLFIL FCC 'ILLEGAL FILE SPEC.'
 FCB 4
MEMFUL FCC 'BUFFER FULL - COMPLETE FILE NOT READ'
 FCB 4
NLDSTR FCC 'NO LINES DELETED'
 FCB 4
NOFSTR FCC 'NO SUCH LINE'
 FCB 4
NORMST FCC 'NOT ENOUGH ROOM'
 FCB 4
NTRCHS FCC 'TARGET NOT REACHED!'
 FCB $D,$A
 FCC 'YOU SURE? '
 FCB 4
NWFSTR FCC 'NEW FILE:'
 FCB 4
OVLPST FCC 'SOURCE OVERLAPS DESTINATION'
 FCB 4
OVRLST FCC ' OVERLAY '
 FCB 4
RENSTR FCC 'SOME LINES RENUMBERED'
 FCB 4
SYNSTR FCC 'SYNTAX ERROR'
 FCB 4
ZOKSTR FCC '...ZONES OK?'
 FCB 4
RETSTR FCB $D,$A
 FCC '   CORRECT PROBLEM AND TYPE "RETRY"'
 FCB $D,$A
 FCC 'TO ABORT AND RETURN TO DOS - TYPE "DOS"'
 FCB 4
ILLEXT FCC 'YOUR INPUT FILE EXTENSION, WITHOUT AN'
 FCB $D,$A,7,0
 FCC 'OUTPUT FILE SPECIFIED, IS NOT ALLOWED'
 FCB $D,$A,7,0,4
INFMSG FCC /  IN/
 FCB 4
OTFMSG FCC / OUT/
 FCB 4
READMG FCC /READ/
 FCB 4
VERMSG FCC / VERSION /
 FCB 4
EDMSG FCC /EDITING/
 FCB 4
CREAST FCC /CREAT/
 FCB 4
 FCC /ED/
 FCB 4
 FCC /ING/
 FCB 4
SPLERR FCC /? '%%%%' /
CFNTST FCC /NOT FOUND/
 FCB 4
EDHELP FCC /EDHELPTXT/
 FCB 0
*
* RESTART ENTRY POINT
*
RESTRT CLI
 LDX FILBEG ; POINT TO BEGIN
 STX CURPOS
 CLR MSLFLG
*
* MAIN EDIT LOOP
*
EDIT LDS STACK ; SETUP STACK POINTER
 STX TEMP ; SAVE POINTER
 LDX CURPOS ; GET CURRENT POSITION
 STX NEWPOS ; SAVE IT
 LDX #PSTZFL
 CLRA ; CLEAR ACC A
 STAA LPTFLG ; TURN LPT OFF
EDIT1 STAA 0,X ; CLEAR LOCATION
 INX ; BUMP POINTER
 CPX #CHRCNT+1 ; FINISHED?
 BNE EDIT1 ; LOOP TIL DONE
 LDX TEMP ; RESTORE POINTER
 LDAA INZFLG ; INIT?
 BEQ EDIT2
 CLR INZFLG
 JMP INSER4 ; GO INSERT LINES
EDIT2 LDAA MSLFLG ; MULTIPLE STATEMENTS PER LINE?
 BNE EDIT55
 STAA CHRCNT+1
 LDX #BUFFER ; SET POINTER
 JSR PCRLF
 LDAA #PROMPT ; SETUP PROMPT
 JSR OUTCH ; OUTPUT IT
EDIT3 JSR INCHAR
 BEQ EDIT
 STAA 0,X ; PUT CHR IN BUFFER
 CMPA #$D ; CR?
 BEQ EDIT5
 JSR BUFLIM ; IS BUFFER FULL?
 BRA EDIT3 ; REPEAT
EDIT5 LDAA #4 ; RESTORE POINTER
 STAA 1,X
 LDX #BUFFER
 STX BUFPNT
EDIT55 CLR MSLFLG
 JSR FINDL ; PROCESS LINE INFO
 CLRA 
 STAA LINFLG ; CLEAR FLAGS
 STAA DRCNT
 STX NEWPOS ; SAVE POINTER
 LDX BUFPNT
 JSR SKIPSP ; SKIP SPACES
 STX BUFPNT ; SAVE POINTER
 CMPA #'= ; IS IT '='?
 BNE EDIT56
 INX ; BUMP POINTER
 STX BUFPNT
 LDX #EQUALS
 BRA EDIT85 ; GO TO IT
EDIT56 JSR TSTEND ; TEST END
 BNE EDIT58
 LDX #PRINT ; POINT TO PRINT
 BRA EDIT85
EDIT58 STX TEMP
 LDX #TABLE ; POINT TO TABLE
EDIT6 STX TABPNT ; SAVE IT
 TST 0,X ; IS IT A NULL?
 BEQ EDIT8
 CMPA #$60 ; LOWER CASE?
 BCS EDIT61 ; NOPE
 SUBA #$20 ; CONVERT TO UPPER
EDIT61 CMPA 0,X ; CHECK CHR.
 BNE EDIT7 ; ARE THEY EQUAL?
 LDX BUFPNT ; RESTORE POINTER
 INX ; BUMP IT
EDIT65 LDAA 0,X ; GET NEXT CHR
 STX BUFPNT ; SAVE POINTER
 LDX TABPNT
 INX ; BUMP TABLE POINTER
 BRA EDIT6
EDIT7 INX ; BUMP POINTER
 TST 0,X ; IS IT A NULL?
 BNE EDIT7
 INX ; BUMP POINTER 3 TIMES
 INX
 INX
 TST 0,X ; END OF TABLE?
 BEQ ERROR ; REPORT ERROR
 DEX
 STX TABPNT ; SAVE POINTER
 LDX TEMP
 BRA EDIT65 ; REPEAT
EDIT8 INX ; BUMP POINTER
 LDX 0,X ; GET ADDRESS
 CPX #INSERT ; IS IT INSERT?
 BNE EDIT85
 LDAA INLMFL
 BNE EDIT88
EDIT85 JSR TSTOVR ; LIMITS
 BNE NOTFND
 CLRA ; CLEAR FLAGS
 STAA OVRBEG
 STAA OVREND
EDIT88 JMP 0,X ; GO TO IT
*
* ERROR ROUTINE
*
ERROR LDX #ERRSTR ; POINT TO ERROR MESSAGE
*
* PRINT ERROR MESSAGE
*
PREROR BSR PSTRNG
 CLR MSLFLG ; CLEAR FLAG
 JMP EDIT ; RETURN
*
* PRINT CRLF
*
PCRLF STX XSAVE ; SAVE POINTER
 LDX #CRLFST ; POINT TO CRLF
 JSR PDATAP ; PRINT IT
 LDX XSAVE ; RESTORE POINTER
 RTS ; RETURN
*
* REPORT LINE NOT FOUND
*
NOTFND LDX #NOFSTR ; POINT TO STRING
 BRA PREROR
*
* REPORT SYNTAX ERROR
*
SYNERR LDX #SYNSTR ; POINT TO STRING
 CLR LPTFLG ; TURN OFF LPT (EXCEPT ECHO)
 BRA PREROR
*
* PRINT STRING ROUTINE
*
PSTRNG BSR PCRLF ; CRLF
PDATAP LDAA 0,X ; GET CHR
 CMPA #4 ; END OF STRING?
 BEQ SKIPS2
 JSR OUTCH ; OUTPUT IT
 INX ; BUMP POINTER
 BRA PDATAP ; LOOP
*
* SKIP ALL SPACES
*
SKIPSA INX ; BUMP POINTER
SKIPSP LDAA 0,X ; GET CHR
 CMPA #$20 ; SPACE?
 BEQ SKIPSA ; LOOP IF IT IS
SKIPS2 RTS ; RETURN
*
* INPUT AND CHECK CHR.
*
INCHAR JSR INCH ; GET CHR
 CMPA #4 ; REPEAT LINE
 BNE INCHR1
 BSR PDATAP ; PRINT LINE
 LDAA #$D ; GET CR
 RTS ; RETURN
INCHR1 CMPA #8 ; IS IT A BS?
 BNE INCHR3
 CPX #BUFFER ; START OF BUFFER?
 BEQ INCHR4 ; YES
 BSR DECBUF ; NO, GO DO YOUR THING
 BRA INCHAR ; AND GET ANOTHER CHR
INCHR3 CMPA #$18 ; DEL LINE?
 BEQ INCHR4 ; YES
 CMPA #$1F ; IS IT A CTRL CHR?
 BHI INCH35 ; NO.
 CMPA #$D ; YES, CR?
 BEQ INCH35 ; YES
 CMPA #9 ; IS IT A TAB
 BEQ EXPTAB ; YES
 CMPA #$1B ; ESC?
 BNE INCHAR ; NO,FORGET IT. GO GET ANOTHER CHR.
 LDAA LINO ; SUBISTUTE LINO FOR ESC
 JSR OUTCH ; PRINT IT
INCH35 INC CHRCNT+1 ; BUMP COUNTER
INCHR4 RTS ; RETURN
*
* EXPAND HORIZ TAB CHR
*
EXPTAB CPX #BUFFER+110 ; END OF BUFFER?
 BEQ INCHAR ; YES, FORGET IT.
 INC CHRCNT+1 ; BUMP COUNTER
 LDAA #$20 ; GET SPACE
 STAA 0,X ; PUT IT IN BUFFER
 JSR OUTCH ; AND OUTPUT IT
 INX ; BUMP POINTER
 LDAA CHRCNT+1 ; GET COUNTER
 SUBA #3 ; ADJUST
 BITA #7 ; TAB BOUNDARY
 BEQ INCHAR ; YES.
 BRA EXPTAB ; LOOP TILL DONE.
*
* CHECK FOR BUFFER OVERFLOW
*
BUFLIM INX ; BUMP THE POINTER
 CPX #BUFFER+110 ; AT END?
 BNE INCHR4
OVER LDAA #BELL ; LOAD BELL
 JSR OUTCH ; OUTPUT IT
 LDAA #'?
 JSR OUTCH ; OUTPUT 3 ???
 JSR OUTCH
 JSR OUTCH
 JSR INCH ; GET CHR
 CMPA #8 ; BS?
 BNE OVER
DECBUF DEX ; FIX POINTER
 DEC CHRCNT+1 ; AND COUNTER
 JSR OUTSPC ; OUTPUT A SPACE
 LDAA #8 ; BS
 JMP OUTCH ; OUTPUT IT
*
* PROCESS LINE ROUTINE
*
FINDL JSR SKIPSP ; SKIP SPACES
 CMPA #'= ; =?
 BEQ FINDL0
 INC LINFLG ; SET FLAG
 JSR CLASS ; CLASSIFY CHR
 CMPB #1 ; IS IT A LETTER?
 BLS FINDL2
FINDL0 LDX NEWPOS ; SET POSITION
FINDL1 RTS ; RETURN
FINDL2 BEQ FIND1
*
* TARGET ENTRY POINT
*
FINDT BSR FINDT0
 STX TRGLIN ; SAVE TARGET POS.
 RTS ; RETURN
FINDT0 CLR DRCNT
 JSR SKPCLS
 CMPB #1 ; IS IT A LETTER
 BLS FINDT2
FINDT1 JMP SYNERR ; REPORT SYNTAX ERROR
FINDT2 BEQ FIND62
FIND CLR DRCNT ; CLEAR DIRECTION
 CMPA LINO ; IS IT LINE NUMBER
 BNE FIND2
 INX ; BUMP THE POINTER
 JSR SKIPSP
 STX BUFPNT
FIND1 JSR BCDCON
 STX TEMP ; SAVE THE POINTER
 LDX NEWPOS
 LDAA NUMBER ; GET NUMBER
 CMPA 0,X ; COMPAR IT
 BNE FIND14
 LDAA NUMBER+1 ; GET NEXT NUMBER
 CMPA 1,X ; COMPARE
 BNE FIND14
 LDAA NUMBER+2
 CMPA 2,X
FIND14 BCC FIND16
 DEC DRCNT ; SET DIRECTION
FIND16 LDX TEMP ; RESTORE POINTER
 JSR FNDNUM ; FIND LINE NUMBER
 BEQ FINDL1
 STAB NOCURL
 JMP BAKONE
FIND2 JSR TSTEND
 BNE FIND3
 TST NXTFLG ; CHECK FLAG
 BEQ FINDL0
 LDX NEWPOS ; SET POINTER
 JMP UPONE ; UP ONE LINE
FIND3 CMPA #'! ; IS IT "!"?
 BNE FIND4
 INX ; BUMP POINTER
 STX BUFPNT
 LDX FILEND ; SET POINTER
 JMP BAKONE ; BACKUP ONE LINE
FIND4 CMPA #'^ ; IS IT "^"?
 BNE FIND5
 DEC DRCNT ; SET DIRECTION
 INX ; BUMP POINTER
 STX BUFPNT
 LDX FILBEG ; SET POINTER TO BEGIN
 RTS ; RETURN
FIND5 CMPA #'+ ; IS IT "+"?
 BEQ FIND6
 CMPA #'- ; IS IT "-"?
 BNE FIND7
 DEC DRCNT ; DEC DIRECTION
FIND6 INX ; BUMP THE POINTER
 JSR SKPCLS ; SKIP SPACES
 CMPB #1 ; IS IT A NUMBER
 BEQ FIND62
 BLS FIND7
 LDAB LINFLG ; TEST FLAG
 BEQ FINDT1
 JSR CLRNUM
 LDX NEWPOS ; SET POINTER
 BRA FIND66
FIND62 JSR BCDCON ; CONVERT NUMBER
 LDX NEWPOS ; SET POINTER
 TST LINFLG ; CHECK FLAG
 BNE FIND65
 JSR TSTNUM ; IS IT ZERO?
 BEQ FIND67
 JSR DECNUM ; DEC NUMBER
FIND65 JSR TSTNUM ; TEST NUMBER
 BEQ FIND67
 JSR DECNUM
FIND66 JSR NXTLIN ; GO TO NEXT LINE
 JSR TSTOVR ; CHECK LIMITS
 BEQ FIND65
 LDAA OVREND ; BEGINING?
 BNE FIND67
 JSR TSTNUM
 BNE FIND67
 INC INLMFL
FIND67 RTS ; RETURN
FIND7 BSR SETDEL ; SET DELIMITER
 BSR ZONE ; SET ZONE
 LDX NEWPOS ; SET POINTER
 JSR NXTLIN ; GO TO NEXT
FIND71 INX ; BUMP POINTER 3 TIMES
 INX
 INX
 JSR FIXZON ; CHECK FOR POSTZONE
FIND72 JSR DECNUM ; DEC COLUMN COUNT
 BEQ FIND75
 LDAB #$D
 CMPB 0,X ; CHECK FOR CR
 BEQ FIND73
 INX ; BUMP POINTER
 BRA FIND72 ; REPEAT
FIND73 LDAA CHGFLG ; CHECK IF CHANGE
 BNE FIND67
 INX ; BUMP POINTER
 CPX FILEND ; END OF FILE?
 BEQ FIND76
 DEX 
FIND74 LDAA CHGFLG
 BNE FIND67
 DEX  ; DEC THE POINTER
 JSR NXTLIN
 JSR TSTOVR ; CHECK LIMITS
 BNE FIND77
 BRA FIND71
FIND75 JSR FIXZON ; FIX UP ZONE
 JSR STRING ; PROCESS THE STRING
 TST FNDFLG ; FIND IT?
 BEQ FIND74
 CLRB 
 LDAA CHGFLG
 BNE FIND77
 JSR BAKON2
 STX TRGLIN ; SAVE TARGET PONTER
FIND77 RTS ; RETURN
FIND76 LDAA #1 ; SET FLAG
 STAA OVREND
 RTS
*
* SETUP DELIMITERS
*
SETDEL STAA DELIM ; SAVE DELIMITER
 CLRB
 INX ; BUMP POINTER
 STX STRNGB ; SAVE BEGINING
SETDE2 LDAA 0,X ; GET A CHR
 BSR TSTEND
 BEQ SETDE4
 CMPA DELIM ; IS IT DELIMITER
 BEQ SETDE4
 INX ; BUMP THE POINTER
 INCB ; BUMP THE COUNTER
 BRA SETDE2 ; REPEAT
SETDE4 STX STRNGE ; SAVE END OF STRING
 STAB STRCNT
 BSR TSTEND
 BEQ SETDE5
 INX ; BUMP THE POINTER
SETDE5 STX BUFPNT
 RTS ; RETURN
*
* SETUP ZONE
*
ZONE JSR CLASS ; GO CLASSIFY CHR
 CLR PSTZFL ; CLEAR FLAG
 CMPB #1 ; IS IT A NUMBER?
 BNE ZONE3
 JSR BCDCON ; CONVERT NUMBER
 BSR CMPZN1 ; CHECK ZONE 1
 BCS ZONE3
 BSR CMPZN2 ; CHECK ZONE 2
 BHI ZONE3
 INC PSTZFL ; SET FLAG
 LDAA NUMBER ; PUT NUMBER IN ZONE BUFFER
 STAA ZONBUF
 LDAA NUMBER+1
 STAA ZONBUF+1
 RTS  ; RETURN
ZONE3 LDAA ZONE1 ; PUT ZONE 1 IN BUFFER
 STAA ZONBUF
 LDAA ZONE1+1
 STAA ZONBUF+1
 RTS  ; RETURN
*
* COMPARE ZONE 1 TO NUMBER
*
CMPZN1 LDAB NUMBER ; GET NUMBER
 CMPB ZONE1 ; CHECK
 BNE CMPZ14
 LDAB NUMBER+1
 CMPB ZONE1+1
CMPZ14 RTS ; RETURN
*
* COMPARE ZONE 2 TO NUMBER
*
CMPZN2 LDAB NUMBER ; GET NUMBER
 CMPB ZONE2 ; CHECK
 BNE CMPZ24
 LDAB NUMBER+1
 CMPB ZONE2+1
CMPZ24 RTS ; RETURN
*
* PUT CORRECT ZONE IN BUFFER
*
FIXZON LDAA ZONBUF ; GET ZONE
 STAA NUMBER ; PUT IN NUMBER
 LDAA ZONBUF+1
 STAA NUMBER+1
 RTS ; RETURN
*
* TEST TERMINATOR (CR OR EOL)
*
TSTEND CMPA #$D ; IS IT CR?
 BEQ TSTEN2
 CMPA EOL ; IS IT EOL?
TSTEN2 RTS ; RETURN
*
* BUMP NUMBER BY 1,0.1, OR 0.01
*
BMPNUM LDAA #1
 LDAB INCAMT ; CHECK AMOUNT
 BEQ INCNUM
 BPL BMPNU4
 LDAA #$10 ; SET BUMP
BMPNU4 ADDA NUMBER+2 ; ADD IN
 DAA ; ADJUST IT
 STAA NUMBER+2 ; SAVE IT
 BCS INCNUM
 RTS ; RETURN
*
* INCREMENT NUMBER BY ONE
*
INCNUM LDAA #1 ; SET UP ONE
 CLRB
 ADDA NUMBER+1 ; ADD IN ONE
 DAA ; ADJUST IT
 STAA NUMBER+1 ; SAVE IT
 TBA 
 ADCA NUMBER
 DAA  ; ADJUST IT
 STAA NUMBER
 RTS ; RETURN
*
* PUT NUMBER AT X
*
PUTNUM LDAA NUMBER ; GET NUMBER
 STAA 0,X ; SAVE IT
 LDAA NUMBER+1
 STAA 1,X
 LDAA NUMBER+2
 STAA 2,X
 RTS ; RETURN
*
* GET NUMBER FROM X
*
GETNUM LDAA 0,X ; GET NUMBER
 STAA NUMBER ; SAVE IT
 LDAA 1,X
 STAA NUMBER+1
 LDAA 2,X
 STAA NUMBER+2
 RTS ; RETURN
*
* RENUMBER FILE
*
RENUMB JSR TFORCR
 LDX FILBEG ; SET POINTER
 CLR INCAMT
 JSR CLRNUM ; CLEAR NUMBER
RENUM2 BSR BMPNUM ; BUMP NUMBER
 BSR PUTNUM ; SAVE IT
 JSR UPONE
 LDAA OVREND ; HIT LIMIT?
 BEQ RENUM2 ; REPEAT
 LDAA CHKFLG ; CHECK FLAG
 BEQ RENUM4
 RTS ; RETURN
RENUM4 JMP PRINT6 ; RETURN
*
* GO TO NEXT LINE
*
NXTLIN LDAA DRCNT ; CHECK DIRECTION
 BMI NXTLI2
 JMP UPONE ; MOVE UP ONE
NXTLI2 JMP BAKONE ; MOVE BACK ONE
*
* PROCESS STRING ROUTINE
*
STRING CLR FNDFLG ; CLEAR FLAG
 LDAB STRCNT
 BNE STRIN1
 INC FNDFLG ; FOUND NULL STRING
 STX LASTNO ; SAVE POINTER
 RTS ; RETURN
STRIN1 LDAB #$D
 STX SRCHPT ; SAVE POINTER
 STX LASTNO ; SAVE POINTER
 LDX STRNGB ; POINT TO BEGIN
STRIN2 STX STRPNT ; SAVE POINTER
 LDAA 0,X ; GET A CHR
 LDX SRCHPT ; RESTORE POINTER
STRIN3 CMPB 0,X ; CR?
 BEQ STRIN4
 CMPA 0,X ; COMPARE CHR
 BEQ STRIN5
 TST PSTZFL ; POST ZONE?
 BNE STRIN4
 TST FNDFLG ; FOUND
 BNE STRIN6
 INX ; BUMP POINTER
 STX LASTNO ; SAVE IT
 PSHA ; SAVE ACC
 PSHB
 JSR INCNUM ; INC NUMBER
 JSR CMPZN2 ; CHECK ZONE 2
 PULB ; RESTORE ACC
 PULA
 BLS STRIN3
STRIN4 CLR FNDFLG ; CLEAR FLAG
 RTS ; RETURN
STRIN5 INX
 STX SRCHPT ; SAVE IT
 INC FNDFLG ; SET FLAG
 LDX STRPNT ; BUMP POINTER
 INX ; BUMP POINTER
 CPX STRNGE ; END OF STRING?
 BEQ STRIN7
 BRA STRIN2
STRIN6 LDX LASTNO ; RESTORE POINTER
 INX
 JSR INCNUM ; BUMP NUMBER
 JSR CMPZN2 ; CHECK ZONE
 BLS STRING
 BRA STRIN4
STRIN7 LDAB STRCNT ; GET COUNT
STRIN8 BEQ STRIN9
 PSHB ; SAVE
 JSR INCNUM ; FIX COL
 PULB
 DECB ; DEC COUNT
 BNE STRIN8
STRIN9 LDX LASTNO
 RTS ; RETURN
*
* SKIP AND CLASSIFY
*
SKPCLS JSR SKIPSP
*
* CLASSIFY CHR
*
CLASS STX BUFPNT ; SAVE POINTER
 LDAA 0,X ; GET CHR
 CMPA #$60 ; LOWER CASE?
 BCS CLASS0
 SUBA #$20 ; FORCE UPPER
CLASS0 CLRB
 CMPA #$2F ; CHECK IF NUMBER
 BLS CLASS4
 CMPA #'9
 BHI CLASS2
 INCB ; SHOW NUMBER
 RTS ; RETURN
CLASS2 CMPA #$40 ; CHECK IF LETTER
 BLS CLASS4
 CMPA #'Z
 BHI CLASS4
 LDAB #2 ; SHOW LETTER
CLASS4 RTS ; RETURN
*
* CONVERT ASCII TO BCD
*
BCDCON BSR CLRNUM ; CLEAR NUMBER
BCDCO1 BSR CLASS ; GO CLASSIFY CHR
 CMPB #1 ; IS IT A NUMBER?
 BEQ BCDCO2
 CMPA #'. ; IS IT A "."?
 BEQ BCDCO5
BCDC15 STX BUFPNT ; SAVE POINTER
 RTS ; RETURN
BCDCO2 INX ; BUMP POINTER
 ANDA #$F ; MASK ASCII
 LDAB #4 ; SET COUNTER
BCDCO4 ASL NUMBER+1
 ROL NUMBER ; SHIFT EVERYTHING LEFT
 DECB ; DEC THE COUNTER
 BNE BCDCO4
 ADDA NUMBER+1 ; ADD IN NUMBER
 STAA NUMBER+1
 BRA BCDCO1
BCDCO5 LDAB #2 ; SET COUNTER
 STAB DECCNT
BCDCO6 INX ; BUMP THE POINTER
 BSR CLASS ; GO CLASSIFY CHR
 CMPB #1 ; IS IT A NUMBER?
 BEQ BCDC65
 CLRA 
 DEX ; DEC THE POINTER
 BRA BCDC67
BCDC65 ANDA #$F ; MASK ASCII
BCDC67 LDAB #4 ; SET COUNTER
BCDCO7 ASL NUMBER+2
 DECB 
 BNE BCDCO7
 ADDA NUMBER+2
 STAA NUMBER+2
 DEC DECCNT ; DEC COUNTER
 BNE BCDCO6
BCDCO8 INX ; BUMP THE POINTER
 BSR CLASS ; GO CLASSIFY CHR
 CMPB #1 ; IS IT A NUMBER?
 BEQ BCDCO8
 BRA BCDC15
*
* CLEAR NUMBER ROUTINE
*
CLRNUM CLRA ; CLEAR ACC
 STAA NUMBER
 STAA NUMBER+1 ; CLEAR ALL OUT
 STAA NUMBER+2
 RTS ; RETURN
*
* FIND NUMBERED LINE
*
FNDNUM LDAB NUMBER ; GET DIGIT
 LDAA NUMBER+1
 LDX FILBEG ; SET POINTER TO BEGIN
FNDNU1 CPX FILEND ; END OF FILE?
 BNE FNDNU4
 INC OVREND ; SET ERROR FLAG
FNDNU2 INCB
 RTS ; RETURN
FNDNU4 CMPB 0,X ; COMPARE DIGIT
 BHI FNDNU5
 BNE FNDNU2
 CMPA 1,X ; COMPARE NEXT DIGIT
 BHI FNDNU5
 BNE FNDNU2
 LDAB NUMBER+2 ; NEXT DIGIT
 CMPB 2,X ; CHECK DIGIT
 BHI FNDNU5
 BNE FNDNU2
 TST SNGLIN
 BNE FNDN45
 TST CHKFLG
 BNE FNDNU2
FNDN45 CLRB
 RTS ; RETURN
FNDNU5 TST CHKFLG
 BNE FNDN45
 BSR FNDCRT ; FIND CR
 LDAB NUMBER ; RESTORE NUMBER
 INX ; BUMP THE POINTER
 BRA FNDNU1 ; REPEAT
*
* FIND THE NEXT CR
*
FNDCRT PSHA ; SAVE ACC
 LDAA #$D
FNDCR2 INX ; BUMP THE POINTER
 CMPA 0,X ; CHECK FOR CR
 BNE FNDCR2
 PULA  ; RESTORE ACC
 RTS ; RETURN
*
* MOVE BACK ONE LINE
*
BAKONE CPX FILBEG
 BEQ BAKON6
 LDAB #1 ; SET COUNTER
BAKON2 DEX ; DEC THE POINTER
 CPX FILBEG ; BEGINNING?
 BEQ BAKON5
 LDAA 0,X ; GET CHR
 CMPA #$D ; CR?
 BNE BAKON2
 DECB 
 BPL BAKON2
 INX ; BUMP THE POINTER
 LDAB #1
BAKON4 RTS ; RETURN
BAKON5 TSTB
 BEQ BAKON4
BAKON6 INC OVRBEG ; SET ERROR FLAG
 RTS ; RETURN
*
* MOVE UP ONE LINE
*
UPONE CPX FILEND ; END OF FILE?
 BNE UPONE2
UPONE1 LDAB #1 ; SET ERROR FLAG
 STAB OVREND
 BRA BAKONE
UPONE2 BSR FNDCRT ; FIND NEXT CR
 INX ; BUMP THE POINTER
 CPX FILEND ; END?
 BEQ UPONE1
 RTS ; RETURN
*
* TEST FOR OVER END LIMITS
*
TSTOVR TST OVRBEG ; BEGINNING?
 BNE TSTOV2
 TST OVREND ; END?
TSTOV2 RTS ; RETURN
*
* DECREMENT NUMBER BY ONE
*
DECNUM LDAA #$99
 TAB ; SETUP $9999
 ADDA NUMBER+1 ; ADD IN
 DAA ; ADJUST IT
 STAA NUMBER+1 ; SAVE IT
 TBA
 ADCA NUMBER
 DAA 
 STAA NUMBER
*
* TEST NUMBER FOR ZERO
*
TSTNUM LDAA NUMBER ; CHECK IF ZERO
 BNE TSTNU2
 LDAA NUMBER+1
TSTNU2 RTS ; RETURN
*
* VERIFY LINE ROUTINE
*
VERLIN STX NEWPOS ; SAVE POINTER
 JSR FNDCRT
 STX SPCPT2 ; SAVE POSITION
 CLRA
 STAA CHRCNT
 DEX ; DEC THE POINTER
 DEX
 DEX
VERL12 DEX ; DEC THE POINTER
 LDAB 0,X ; CHECK CHR
 CMPB #$D ; CR?
 BEQ VERL15
 LDAB 3,X ; CHECK
 CMPB #$20 ; IS IT A SPACE?
 BNE VERL15
 INCA 
 BRA VERL12
VERL15 STAA CHRCNT+1 ; SAVE COUNT
 INX ; BUMP THE POINTER
 INX
 INX
 INX
 STX SPCPT1
 JSR DELCHR ; DELETE SPACES
 LDX NEWPOS
 LDAA VERFLG ; CHECK FLAG
 BEQ VERLI2
 BSR OUTLIN ; OUTPUT LINE
 JSR BAKONE ; BACKUP ONE LINE
VERLI2 STX CURPOS ; SAVE POINTER
 STX NEWPOS
 RTS ; RETURN
*
* LIST ROUTINE (LPT)
*
LIST INC LPTFLG ; SET LPT FLAG
 JSR LPTINI ; INIT LPT
 BRA PRINT
*
* MOVE CURSOR UP AND PRINT
*
PRINTU JSR CURUP1 ; MOVE CURSOR UP
 JSR CURUP1 ; TWICE
*
* PRINT ROUTINE
*
PRINT BSR TSTEMP
 LDX BUFPNT ; SET POINTER
 JSR FINDT ; FIND TARGET
 LDX NEWPOS ; SET POINTER
 INC PRNFLG ; SET FLAG
 STX CURPOS ; SAVE IT
PRINT1 CPX TRGLIN ; TARGET LINE?
 BNE PRIN12
 CLR PRNFLG ; CLEAR FLAG
PRIN12 BSR OUTLIN
 LDAA PRNFLG ; CHECK FLAG
 BEQ PRINT5
 LDAA DRCNT ; CHECK DIRECTION
 BEQ PRINT1
 DEX ; DEC THE POINTER
 DEX ; DEC THE POINTER
 JSR BAKONE ; MOVE BACK ONE
 BRA PRINT1
PRINT5 JSR BAKONE ; MOVE BACK ONE
 STX CURPOS
PRINT6 TST LPTFLG ; CHECK IF LPT OUTPUT
 BEQ PRIN65
 JSR PCRLF ; PRINT CRLF
PRIN65 JSR TSTMSL
 JMP EDIT ; RETURN
*
* TEST IF FILE EMPTY
*
TSTEMP LDX FILBEG
 CPX FILEND
 BEQ PRINT6
 RTS ; RETURN
*
* OUTPUT ONE LINE
*
OUTLIN JSR PCRLF ; CRLF
 LDAA NUMFLG
 BNE OUTL15
 BSR OUTSPC ; OUTPUT SPACE
 INX ; BUMP THE POINTER
 INX
 BRA OUTLI2
OUTL15 BSR OUTBCD ; OUTPUT THE LINE NUMBER
 DEX ; DEC THE POINTER
OUTLI2 INX ; BUMP THE POINTER
 LDAA 0,X ; GET CHR
 CMPA #$D ; CR?
 BEQ OUTLI4
 JSR OUTCH ; OUTPUT CHR
 BRA OUTLI2 ; REPEAT
OUTLI4 INX ; BUMP THE POINTER
 RTS ; RETURN
*
* OUTPUT A SPACE
*
OUTSPC LDAA #$20 ; LOAD A SPACE
 JSR OUTCH ; OUTPUT IT
 CLC
 RTS ; RETURN
*
* OUTPUT A BCD NUMBER
*
OUTBCD LDAA NUMFLG ; CHECK FLAG
 BEQ OUTB75
 BSR OUTSPC ; OUTPUT A SPACE
 LDAB #2 ; SET COUNTER
 CLC
OUTBC2 LDAA 0,X ; GET CHR
 BITA #$F0 ; MASK
 BCS OUTBC3
 BEQ OUTB35
OUTBC3 JSR OUTHL ; OUTPUT DIGIT
 SEC ; SET FLAG
 BRA OUTBC4
OUTB35 BSR OUTSPC ; OUTPUT A SPACE
OUTBC4 LDAA 0,X ; GET CHR
 BITB #$FE ; CHECK IF DONE
 BEQ OUTBC6
 BITA #$F ; MASK
 BCS OUTBC6
 BEQ OUTB65
OUTBC6 BSR OUTHR ; OUTPUT DIGIT
 SEC
 BRA OUTBC7
OUTB65 BSR OUTSPC ; OUTPUT A SPACE
OUTBC7 INX ; BUMP THE POINTER
 DECB  ; DEC THE COUNTER
 BEQ OUTBC8
 BPL OUTBC2
OUTB75 LDAA #'=
OUTB78 JMP OUTCH ; OUTPUT THE "="
OUTBC8 LDAA #'. ; OUTPUT THE "."
 JSR OUTCH
 SEC 
 BRA OUTBC2 ; GO FINISH
*
* OUTPUT DIGITS ROUTINE
*
OUTHL LSRA ; SHIFT LEFT 4 TIMES
 LSRA 
 LSRA 
 LSRA 
OUTHR ANDA #$F ; MASK
 ADDA #'0 ; MAKE ASCII
 BRA OUTB78 ; OUTPUT IT
*
* SET NUMBERS ON OR OFF
*
NUMBRS BSR ONOFF ; GET ON OFF
 BEQ NUMBE2
 BMI NUMSE4
 CLR NUMFLG ; CLEAR FLAG
 BRA NUMSE6
NUMBE2 COMA ; COM FLAG
 STAA NUMFLG ; SAVE IN FLAG
 BRA NUMSE6
NUMSE4 COM NUMFLG ; COM FLAG
NUMSE6 LDX NEWPOS
 STX CURPOS ; SET POINTER
 JMP PRINT6
*
* CHECK FOR ON OR OFF
*
ONOFF LDX BUFPNT ; SET POINTER
 JSR SKIPSP ; SKIP SPACES
 STX BUFPNT ; SAVE POINTER
 STX TEMP
 LDX #ONOFTB ; POINT TO TABLE
 JMP EDIT6
*
* ON OFF ROUTINE
*
ON CLRA
 RTS ; RETURN
OFF LDAA #1 ; SET FLAG
 RTS ; RETURN
TOGGLE LDX BUFPNT
 DEX ; DEC THE POINTER
 STX BUFPNT ; SAVE POINTER
 LDAA #$FF ; SET FLAG
 RTS ; RETURN
*
* SET VERIFY FLAG
*
VERSET BSR ONOFF ; CHECK ON OFF
 BEQ VERSE2
 BMI VERSE4
 CLR VERFLG ; CLEAR FLAG
 BRA VERSE6
VERSE2 COMA
 STAA VERFLG
 BRA VERSE6
VERSE4 COM VERFLG ; COM. FLAG
VERSE6 BRA NUMSE6
*
* CURSOR CONTROL COMMAND "X"
*
XCNTRL BSR TFORCR
 LDX #CNRSTR ; POINT TO STRING
 JSR PDATAP ; PRINT IT
 BRA NUMSE6
*
* CLOSE COMMAND
*
CLOSE BSR TFORCR
 JMP CLOFIL
*
* STOP,LOG, OR FILE COMMAND
*
STOP BSR TFORCR
 JMP DEXIT
*
* SET POINTER TO BOTTOM
*
BOTTOM BSR TFORCR
BOTTO1 JSR TSTEMP
 LDX FILEND
 JSR BAKONE ; MOVE BACK ONE
BOTTO2 STX CURPOS ; SAVE POINTER
 JMP PRINT6
*
* SET POINTER TO TOP
*
TOP BSR TFORCR
 JSR TSTEMP
 BRA BOTTO2
*
* TEST FOR CR
*
TFORCR LDX BUFPNT ; SET POINTER
 JSR SKIPSP
 CMPA #$D ; CR?
 BEQ TFORC2
 CMPA EOL
 BNE TFORC3
TFORC2 RTS ; RETURN
TFORC3 JMP SYNERR
*
* TEST FOR MULTIPLE STATEMENTS PER LINE
*
TSTMSL LDX BUFPNT ; GET POINTER
 LDAA #$D ; GET CR
 LDAB EOL ; GET EOL CHR
TSTMS2 CMPA 0,X ; CHECK CHR
 BEQ TSTMS5
 CMPB 0,X
 BEQ TSTMS4
 INX ; BUMP THE POINTER
 BRA TSTMS2 ; REPEAT
TSTMS4 INX ; BUMP THE POINTER
 STX BUFPNT ; SAVE POINTER
 STAA MSLFLG ; SET FLAG
TSTMS5 RTS ; RETURN
*
* PROCESS THE "NEXT" COMMAND
*
NEXT INC NXTFLG
 JSR CURUP1
*
* "FIND" COMMAND
*
CFIND JSR TSTEMP
 INC LINFLG ; SET FLAG
 BSR OCCURR ; CHECK OCCURRENCE
 LDX TRGLIN ; SET POINTER
 JSR TSTOVR ; CHECK LIMITS
 BEQ CFIND2
 LDAB NXTFLG ; CHECK FLAG
 BNE CFIND5
 BRA CFIN12
CFIND1 LDAA ALLFLG ; CHECK IF ALL
 BNE CFIND6
CFIN12 LDX #CFNTST 9 POINT TO QTRILG
 JSR PSTRNG ; OUTPUT IT
 LDX ZONE1 ; CHECK ZONE 1
 CPX #1
 BNE CFIN13
 LDX ZONE2 ; CHECK ZONE 2
 CPX #$110 ; IS 110 IN EDIT0, IS 136 IN LISTING
 BEQ CFIN14
CFIN13 LDX #ZOKSTR ; POINT TO STRING
 JSR PDATAP ; OUTPUT IT
CFIN14 CLR MSLFLG
 JMP EDIT ; RETURN
CFIND2 LDX TRGLIN ; POINT TO TARGET
 CPX NEWPOS ; SAME ONE?
 BEQ CFIND6
 STX NEWPOS ; SAVE IT
 LDAB OCRFLG ; CHECK FLAG
 BEQ CFIND5
 LDAB NXTFLG ; CHECK FLAG
 BNE CFIND4
 JSR VERLIN ; VERIFY FLAG
CFIND4 JSR NXTOCR ; CHECK NEXT OCCUR.
 JSR TSTOVR ; CHECK LIMITS
 BEQ CFIND2
 BRA CFIND9
CFIND5 JSR VERLIN ; VERIFY LINE
CFIND6 JMP PRINT6
CFIND9 LDAB NXTFLG ; CHECK FLAG
 BNE CFIND5
 BRA CFIND1
*
* CHECK FOR OCCURRENCE
*
OCCURR LDX BUFPNT ; SET POINTER
 STX BUFSAV ; SAVE POINTER
 CLR ALLFLG
 CLR OCRFLG
 JSR FINDT ; FIND TARGET
 LDX BUFPNT ; RESTORE POINTER
 JSR SKPCLS
 CMPB #1 ; IS IT NUMBER
 BEQ OCCUR3
 CMPA #'* ; IS IT A "*"?
 BNE OCCUR5
 INC ALLFLG ; SET FOR ALL OCCURRENCES
 BRA OCCUR4
OCCUR3 JSR BCDCON ; GET AND CONVERT NUMBER
 JSR TSTNUM ; ZERO?
 BEQ OCCUR5
 JSR DECNUM ; DEC NUMBER
 BEQ OCCUR5
 BSR SAVOCR ; SAVE OCCURRENCE
OCCUR4 INC OCRFLG ; SET FLAG
OCCUR5 RTS ; RETURN
*
* SAVE PRESENT OCCURRENCE COUNT
*
SAVOCR LDAA NUMBER ; GET NUMBER
 STAA OCRCNT ; SAVE IT
 LDAA NUMBER+1
 STAA OCRCNT+1
 RTS ; RETURN
*
* PROCESS NEXT OCCURRENCE
*
NXTOCR LDAA ALLFLG ; CHECK FOR ALL
 BNE NXTOC1
NXTOC0 LDAA OCRCNT ; GET COUNT
 STAA NUMBER ; PUT IN NUMBER
 LDAA OCRCNT+1
 STAA NUMBER+1
 JSR DECNUM ; DEC NUMBER
 BEQ NXTOC2
 BSR SAVOCR ; SAVE OCCURRENCE
NXTOC1 LDAA CHGFLG
 BNE NXTOC3
 LDX BUFSAV ; RESTORE POINTER
 JMP FINDT ; FIND TARGET AND RETURN
NXTOC2 CLR OCRFLG ; CLEAR FLAG
 BRA NXTOC1
NXTOC3 RTS ; RETURN
*
* EQUALS COMMAND
*
EQUALS JSR TSTEMP
 LDX BUFPNT ; SET POINTER
 CLR BMPFLG
 INC SNGLIN
 INC EQUFLG
 LDAA NOCURL ; CURRENT LINE?
 BNE INSER1
 LDX NEWPOS
 STX TRGLIN ; FIX TARGET
 JSR GETNUM ; GET NUMBER
 INC REPFLG ; SET FLAG
 LDAA CHRCNT+1
 STAA TMPCHR
 JMP DELET0
*
* INSERT COMMAND
*
INSERT LDX BUFPNT ; SET POINTER
 CLR BMPFLG ; CLEAR FLAG
 LDAA 0,X ; GET CHR
 CMPA #$D
 BEQ INSER4
 INC SNGLIN ; SET FLAG
 INX ; BUMP THE POINTER
INSER1 STX BUFPNT ; SAVE POINTER
 LDX #BUFFER
 LDAA CHRCNT+1 ; GET COUNT
INSER2 CPX BUFPNT ; CHECK POINTER
 BEQ INSER3
 DECA  ; DEC COUNTER
 INX ; BUMP THE POINTER
 BRA INSER2
INSER3 ADDA #3 ; FIX COUNT
 STAA CHRCNT+1
INSER4 LDX NEWPOS ; SET POINTER
 STX CURPOS ; SAVE POINTER
 LDAA EQUFLG
 BEQ INSE42
 LDAA OVRBEG ; CHECK LIMIT
 BEQ INSE43
 BRA INSER5
INSE42 JSR GETNUM
 LDAA INLMFL ; CHECK FLAG
 BEQ INSE43
 CPX FILEND ; EMPTY?
 BEQ INSE43
 CLRB ; CLR ACC
 STAB NUMBER ; CLEAR NUMBER
 STAB NUMBER+1
 BRA INSER5
INSE43 JSR UPONE ; UP ONE LINE
 LDAB 2,X ; GET DIGIT
 LDAA OVREND ; LIMIT?
 BEQ INSER5
 CLRB 
 LDX FILEND
 CPX FILBEG
 BNE INSER5
 JSR CLRNUM ; CLEAR OUT NUMBER
*
* CALCULATE LINE NUMBER INCREMENT
*
INSER5 STX SPCPT1 ; SAVE POINTER
 LDAA EQUFLG
 BNE INSE60
 LDAA OVREND ; LIMIT?
 BEQ INSE51
 CLR NUMBER+2
 BRA INSER6
INSE51 LDAA BMPFLG
 BNE INSER6
 LDAA NUMBER+2 ; GET NUMBER
 STAB TMPCHR
 ORAA TMPCHR
 BEQ INSE55
 LDAA INLMFL ; CHECK FLAG
 BEQ INSE52
 CLR NUMBER+2
INSE52 LDAA #1
 STAA INCAMT ; SET AMOUNT
 BRA INSER6
INSE55 DEC INCAMT
INSER6 JSR BMPNUM ; BUMP NUMBER
 LDAA SNGLIN ; CHECK IF SINGLE IN
 BEQ INSE61
*
* ENTER BUFFERED INPUT MODE
*
INSE60 LDX BUFPNT ; SET POINTER
 BRA INSE71
INSE61 CLR INLMFL
 JSR PCRLF
 LDX #NUMBER ; POINT TO NUMBER
 JSR OUTBCD ; OUTPUT IT
 CLR CHRCNT
 LDAA #3 ; SET COUNTER
 STAA CHRCNT+1
 STAA BMPFLG ; SET FLAG
 LDX #BUFFER ; SET POINTER
INSE62 JSR INCHAR ; GET A CHR
 BEQ INSE61
 CMPA #$D ; CR?
 BEQ INSER7
 STAA 0,X
 JSR BUFLIM ; CHECK LIMIT
 BRA INSE62 ; REPEAT
INSER7 STAA 0,X
 LDX #BUFFER ; SET POINTER
INSE71 STX BUFPNT ; SAVE POINTER
 LDAA 0,X ; GET CHR
 CMPA LINO ; ESC?
 BNE INSE72
 LDAA CHRCNT+1
 SUBA #3 ; FIX COUNT
 STAA CHRCNT+1
 INX ; BUMP THE POINTER
*
* CHECK IF RENUMBERING NECESSARY
*
INS710 STX TEMP ; SAVE POINTER
 LDX NEWPOS
 JSR UPONE ; UP ONE LINE
 TST OVREND ; LIMIT?
 BNE INS711
 INC CHKFLG ; SET FLAG
 LDAB NUMBER ; GET NUMBER
 LDAA NUMBER+1
 JSR FNDNU4 ; CHECK NUMBER
 BNE INS711
 CLRA 
 STAA INCAMT ; SET INC AMOUNT
 STAA NUMBER+2
 JSR RENUM2 ; RENUMBER FILE
 LDX #RENSTR ; POINT TO STRING
 JSR PSTRNG ; OUTPUT IT
INS711 LDX TEMP ; RESTORE POINTER
 TST SNGLIN
 BEQ INS712
 LDX NEWPOS ; FIX POINTER
 STX CURPOS
 BRA INS713
INS712 INC MSLFLG ; SET FLAG
INS713 JMP EDIT
*
* ACTUAL LINE INSERT
*
INSE72 BSR MAKSPC ; MAKE SOME SPACE
 LDX TEMP ; RESTORE POINTER
 STX NEWPOS
 JSR PUTNUM ; PUT NUMBER
 INX ; BUMP THE POINTER
 INX ; BUMP THE POINTER
 INX ; BUMP THE POINTER
 STX TEMP ; SAVE POINTER
INSE75 LDX BUFPNT ; SET POINTER
 LDAA 0,X ; GET CHR
 INX ; BUMP THE POINTER
 STX BUFPNT ; SAVE POINTER
 LDX TEMP
 STAA 0,X ; PUT CHR
 INX ; BUMP THE POINTER
 STX TEMP ; SAVE IT
 CMPA #$D ; CR?
 BNE INSE75 ; REPEAT
 JSR EXPLIN ; EXPAND TABS
 LDAA SNGLIN
 BNE INS710
 JMP INSER4
*
* MAKE ROOM FOR INSERT
*
MAKSPC CLR DECCNT ; CLEAR COUNT
 LDX SPCPT1 ; SET POINTER
 STX TEMP ; SAVE IT
 CPX FILEND ; END OF FILE?
 BNE MAKSP1
 INC DECCNT
MAKSP1 LDX FILEND ; SET POINTER
 STX SPCPT1 ; SAVE IT
 LDAB CHRCNT
 LDAA CHRCNT+1
 BNE MAKS21
MAKS18 TSTB
 BEQ MAKSP4
MAKS21 CPX MEMEND ; END OF MEMORY?
 BEQ MAKSP3
 INX ; BUMP THE POINTER
 TST DRCNT ; WHICH DIRECTION?
 BNE MAKS22
 STX XSAVE ; SAVE POINTER
 BRA MAK222
MAKS22 TST CPTDRC
 BEQ MAKS23
 STX XSAVE ; SAVE POINTER
 LDX NEWPOS ; GET POSITION
 INX ; BUMP THE POINTER
 STX NEWPOS ; SAVE IT
MAK222 LDX TRGLIN ; GET TARGET
 INX ; BUMP THE POINTER
 STX TRGLIN
 LDX XSAVE ; RESTORE POINTER
MAKS23 TSTA ; TEST ACC
 BNE MAKS24
 DECB
MAKS24 DECA
 BNE MAKS21
 BRA MAKS18 ; REPEAT
MAKSP3 LDX #NORMST ; POINT TO STRING
 JSR PSTRNG ; OUTPUT IT
 CLR MSLFLG
 JMP EDIT ; RETURN
MAKSP4 STX FILEND ; SAVE POINTER
 STX SPCPT2 ; SAVE POINTER
 LDAA DECCNT ; CHECK
 BNE MAKSP6
MAKSP5 STX SPCPT2 ; SAVE POINTER
MAKS55 LDX SPCPT1
 CPX TEMP ; DONE?
 BEQ MAKSP6
 DEX ; DEC THE POINTER
 LDAA 0,X ; GET CHR
 STX SPCPT1
 LDX SPCPT2
 DEX ; DEC THE POINTER
 STAA 0,X ; PUT CHR
 BRA MAKSP5 ; REPEAT
MAKSP6 RTS ; RETURN
*
* REPLACE LINES ROUTINE
*
REPLCE INC REPFLG ; SET FLAG
*
* DELETE LINES ROUTINE
*
DELETE LDX BUFPNT ; SET POINTER
 JSR FINDT ; FIND TARGET
 JSR TSTOVR ; LIMITS?
 BEQ DELET0
DELE02 LDX #NTRCHS ; POINT TO STRING
 JSR PSTRNG  ; OUTPUT IT
 LDX #BUFFER ; POINT TO BUFFER
DELE04 JSR INCHAR ; GET A CHR
 BEQ DELE02
 STAA 0,X ; SAVE IT
 INX ; BUMP THE POINTER
 CMPA #$D ; CR?
 BNE DELE04 ; REPEAT
 LDX #BUFFER ; POINT TO BUFFER
 JSR SKIPSP ; SKIP SPACES
 CMPA #'Y ; WAS IT 'Y'ES?
 BEQ DELET0
 LDX #NLDSTR ; POINT TO STRING
 JSR PSTRNG ; OUTPUT IT
 BRA DELET5 ; RETURN
DELET0 LDX NEWPOS ; SET POINTER
 LDAA DRCNT ; CHECK DIRECTION
 BEQ DELET1
 JSR UPONE ; MOVE UP ONE
 LDAA OVREND ; LIMIT?
 BEQ DELE15
 LDX FILEND
DELE15 STX SPCPT2
 LDX TRGLIN ; POINT TO TARGET
 STX CURPOS ; MAKE CURRENT
 STX SPCPT1
 LDX SPCPT2 ; GET POINTER
 BRA DELE25
DELET1 STX SPCPT1 ; SAVE
 STX CURPOS
 LDX TRGLIN ; POINT TO TARGET
 JSR UPONE ; MOVE UP ONE
 LDAA OVREND ; LIMIT?
 BEQ DELET2
 LDX FILEND ; POINT TO END
DELET2 STX SPCPT2 ; SAVE POINTER
DELE25 CLRA
 CLRB 
DELET3 CPX SPCPT1
 BEQ DELET4
 INCA 
 BNE DELE35
 INCB  ; BUMP THE COUNTER
DELE35 DEX ; DEC THE POINTER
 BRA DELET3
DELET4 STAA CHRCNT+1 ; SAVE COUNT
 STAB CHRCNT
 BSR DELCHR ; DEL THE CHRS
 LDAA REPFLG ; REPLACE?
 BEQ DELET5
 LDX CURPOS ; SET THE POINTER
 JSR BAKONE ; BACKUP ONE LINE
 LDAA EQUFLG
 BNE DELET7
 LDAA OVRBEG ; CHECK LIMIT
 BEQ DELE45
 JSR CLRNUM ; CLEAR NUMBER
 STX NEWPOS ; SAVE NEW POSITION
 JMP INSER5
DELE45 STX NEWPOS ; SAVE NEW POSITION
 CLR BMPFLG
 JMP INSER4 ; GO INSERT
DELET5 LDX CURPOS ; CHECK POSITION
 CPX FILEND ; END?
 BNE DELET6
 JSR BAKONE ; BACKUP ONE LINE
 STX TEMP ; SAVE POINTER
 LDX #BFRSTR ; POINT TO STRING
 JSR PSTRNG ; OUTPUT IT
 LDX TEMP ; RESTORE POINTER
DELET6 STX CURPOS
 JMP PRINT6
DELET7 STX NEWPOS ; SAVE POINTER
 LDAA TMPCHR ; GET CHR COUNT
 STAA CHRCNT+1
 CLRA
 STAA BMPFLG ; CLEAR FLAG
 STAA CHRCNT ; AND COUNTER
 LDX BUFPNT ; SET POINTER
 JMP INSER1 ; GO INSERT IT
*
* DELETE CHR BLOCK
*
DELCHR LDX SPCPT2 ; SET POINTER
 CPX SPCPT1 ; EQUAL?
 BEQ DELCH5
 CPX FILEND ; END OF FILE?
 BEQ DELCH2
 LDAA 0,X ; GET CHR
 INX ; BUMP THE POINTER
 STX SPCPT2 ; SAVE POINTER
 LDX SPCPT1 ; GET POINTER
 STAA 0,X ; PUT CHR
 INX ; BUMP THE POINTER
 STX SPCPT1 ; SAVE POINTER
 BRA DELCHR ; REPEAT
DELCH2 LDAB CHRCNT ; GET COUNT
 LDAA CHRCNT+1
 BNE DELC31
DELC21 TSTB ; CHECK COUNT
 BEQ DELCH4
DELC31 DEX ; DEC THE POINTER
 TST DRCNT ; WHICH DIRECTION
 BNE DELC32
 STX XSAVE
 LDX TRGLIN ; POINT TO TARGET
 DEX ; DEC THE POINTER
 STX TRGLIN ; PUT IT BACK
 LDX XSAVE ; RESTORE THE POINTER
DELC32 TSTA ; TEST COUNT
 BNE DELC34
 DECB ; DEC THE COUNTER
DELC34 DECA
 BNE DELC31
 BRA DELC21
DELCH4 STX FILEND ; SET NEW END
DELCH5 RTS ; RETURN
*
* CHANGE COMMAND ROUTINE
*
CHANGE JSR TSTEMP
 LDX BUFPNT ; SET POINTER
 JSR SKPCLS
 JSR TSTEND
 BEQ CHAN12 ; ERROR
 TSTB
 BEQ CHAN15 ; ERROR
CHAN12 JMP CHANG9
CHAN15 INC CHGFLG ; SET FLAG
 JSR SETDEL ; SET DELIMITERS
 CLRB ; CLEAR COUNT
CHANG2 LDAA 0,X ; GET CHR
 JSR TSTEND
 BEQ CHANG3
 CMPA DELIM ; IS IT DELIMITER?
 BEQ CHANG3
 INX ; BUMP THE POINTER
 INCB ; BUMP THE COUNT
 BRA CHANG2
CHANG3 STX CHGEND ; SAVE THE POINTER
 STAB STRCN2 ; SAVE COUNT
 JSR TSTEND
 BEQ CHAN35
 INX ; BUMP THE POINTER
CHAN35 STX BUFPNT ; SAVE POINTER
 LDX NEWPOS ; SET POINTER
 INX ; BUMP THE POINTER
 INX ; BUMP THE POINTER
 INX ; BUMP THE POINTER
 STX CHGPNT ; SAVE POINTER
 JSR SVSTPT ; SAVE STRING POINTER
 CLR CHGFLG
 JSR OCCURR ; GET TARGET & OCCUR.
 INC CHGFLG
 JSR RSTSPT ; RESTORE STRING
 CLR PSTZFL
 LDX OCRCNT ; GET COUNT
 STX OCRTMP ; SAVE
 LDAA OCRFLG
 BEQ CHANG4
 LDAA STRCNT ; CHECK COUNT
 BNE CHANG4
 JMP CHANG9
CHANG4 LDX NEWPOS ; SET POINTER
 CPX TRGLIN ; AT TARGET?
 BNE CHANG5
 INC LSTFLG ; SET FLAG IF SO
CHANG5 JSR ZONE3 ; SET ZONE
 CLR CHGONF ; CLEAR FLAG
 LDX CHGPNT
 JSR FIXZON ; SET ZONE
 JSR FIND72
 BRA CHA510
*
* LOOP THRU OCCURRENCES
*
CHAN50 CLR CHGONF
CHAN51 LDX CHGPNT ; SET POINTER
 JSR FIXZON
 JSR CMPZN2 ; SET ZONE
 BHI CHANG8
 JSR FIND75
CHA510 LDAA NUMBER ; GET NUMBER
 STAA ZONBUF ; PUT IN BUFFER
 LDAA NUMBER+1
 STAA ZONBUF+1
 TSTB 
 BNE CHANG8
 INCB ; BUMP THE COUNTER
 STAB FNONFL ; SET FLAG
 LDAA OCRFLG ; ANY OCCURR.?
 BEQ CHANG6
 LDAA ALLFLG ; CHANGE ALL?
 BNE CHANG6
 JSR NXTOC0
 LDX LASTNO ; SET POINTER
 INX ; BUMP THE POINTER
 STX CHGPNT
 BRA CHAN50
*
* DELETE STRING ONE
*
CHANG6 INC CHGONF ; SET FLAG
 LDX OCRTMP ; CHECK COUNT
 BEQ CHAN61
 LDAA #1
 STAA OCRFLG
CHAN61 STX OCRCNT ; FIX COUNT
 LDX LASTNO ; GET STRING LOCATION
 STX SPCPT1 ; SAVE POINTER
 LDAB STRCNT
 BEQ CHAN66
 CLR CHRCNT ; CLEAR COUNT
 STAB CHRCNT+1
CHAN62 BEQ CHAN65
 INX ; BUMP THE POINTER
 DECB ; DEC THE COUNTER
 BRA CHAN62 ; REPEAT
CHAN65 STX SPCPT2 ; SAVE POINTER
 JSR DELCHR ; GO DELETE
*
* INSERT STRING TWO
*
CHAN66 LDAB STRCN2 ; GET COUNT
 BEQ CHA675
 CLR CHRCNT ; CLEAR OUT COUNT
 STAB CHRCNT+1 ; SET COUNTER
 LDX LASTNO ; SET POINTER
 STX SPCPT1 ; SAVE POINTER
 JSR MAKSPC ; GO MAKE SPACE
 LDAB CHRCNT+1
 LDX STRNGE ; POINT TO END OF STRING
CHAN67 INX ; BUMP THE POINTER
 LDAA 0,X ; GET CHR
 STX TEMP
 LDX LASTNO
 STAA 0,X ; PUT CHR
 INX ; BUMP THE POINTER
 STX LASTNO ; SAVE POINTER
 STX CHGPNT
 LDX TEMP ; RESTORE
 DECB ; DEC THE COUNTER
 BNE CHAN67
CHA675 LDAA ALLFLG ; DO ALL?
 BEQ CHAN81
 LDX LASTNO
 STX CHGPNT ; SAVE POINTER
 JMP CHAN51 ; REPEAT
*
* CHANGE CLEANUP AND FINISH
*
CHANG8 CLR OCRFLG ; CLEAR FLAG
 LDX OCRTMP ; GET COUNT
 BEQ CHAN80
 LDAA #1 ; SET FLAG
 STAA OCRFLG
CHAN80 STX OCRCNT ; SET OCCUR. COUNT
 LDAA FNONFL ; CHECK FLAG
 BNE CHAN81
 LDAA LSTFLG
 BNE CHANG9
CHAN81 LDX NEWPOS ; SET POINTER
 LDAA CHGONF
 BEQ CHAN82
 JSR VERLIN ; VERIFY CHANGE
CHAN82 LDAA LSTFLG
 BEQ CHAN84
 CLR CHGONF ; CLEAR FLAG
 JMP PRINT6
CHAN84 JSR NXTLIN ; FIND NEXT LINE
 STX NEWPOS ; SAVE NEW POSITION
 CPX TRGLIN ; TARGET LINE?
 BNE CHAN86
 INC LSTFLG ; SET LAST FLAG
CHAN86 INX ; BUMP THE POINTER
 INX ; BUMP THE POINTER
 INX ; BUMP THE POINTER
 STX CHGPNT ; SAVE POINTER
 JMP CHANG5 ; REPEAT
CHANG9 JMP ERROR ; REPORT ERROR
*
* SAVE STRING POINTER INFO
*
SVSTPT LDX STRNGB ; GET POINTER
 STX STRGB1 ; SAVE IT
 LDX STRNGE
 STX STRGE1
 LDAA STRCNT ; GET COUNT
 STAA STRCN1 ; SAVE IT
 RTS ; RETURN
*
* RESTORE STRING POINTER INFO
RSTSPT LDX STRGB1 ; GET POINTER
 STX STRNGB ; RESTORE
 LDX STRGE1
 STX STRNGE
 LDAA STRCN1 ; GET COUNT
 STAA STRCNT ; RESTORE IT
 RTS ; RETURN
*
* OVERLAY ROUTINE
*
OVRLAY JSR TSTEMP
 LDAA #$20 ; SETUP SPACE
 STAA DELIM ; AS DELIMITER
 CLR DRCNT
 LDX BUFPNT ; SET POINTER TO BUFFER
 LDAA 0,X ; GET CHR
 CMPA #$D ; CR?
 BEQ OVRLA1
 JSR CLASS ; GO CLASSIFY CHR
 TSTB 
 BEQ OVRLA0
 JMP SYNERR ; REPORT ERROR
OVRLA0 STAA DELIM ; SET DELIMITER
 INX ; BUMP THE POINTER
 LDAA 0,X ; GET CHR
 CMPA #$D ; CR?
 BNE OVRL35
OVRLA1 LDX NEWPOS ; SET POINTER
 JSR OUTLIN ; OUTPUT THE CURRENT LINE
 LDAA NUMFLG
 BNE OVRL12
 LDX #OVRLST+8 ; POINT TO STRING
 BRA OVRL16
OVRL12 LDX #OVRLST ; POINT TO STRING
OVRL16 JSR PSTRNG ; OUTPUT IT
 LDX #BUFFER ; POINT TO BUFFER
OVRLA2 JSR INCHAR ; GET A CHR
 BEQ OVRLA1
 CMPA #$D ; CR?
 BEQ OVRLA3
 STAA 0,X ; PUT CHR
 JSR BUFLIM
 BRA OVRLA2
OVRLA3 STAA 0,X ; PUT CHR
 LDX #BUFFER ; POINT TO BUFFER
OVRL35 STX BUFPNT ; SAVE POINTER
 LDAB #$D ; CR
 LDX NEWPOS ; SET POINTER
 INX ; BUMP THE POINTER
 INX ; BUMP THE POINTER
 INX ; BUMP THE POINTER
 STX TEMP ; SAVE POINTER
OVRLA4 LDX BUFPNT ; SET POINTER
OVRL41 LDAA 0,X ; GET CHR
 INX ; BUMP THE POINTER
 STX BUFPNT ; SAVE POINTER
 CMPA #$D ; CR?
 BEQ OVRLA7
 LDX TEMP ; SET POINTER
 TST DRCNT ; WHICH DIRECTION
 BNE OVRL43
 CMPB 0,X ; CHECK IT
 BEQ OVRLA5
 CMPA DELIM ; IS IT DELIMITER?
 BEQ OVRL45
OVRL43 STAA 0,X ; PUT CHR
OVRL45 INX ; BUMP THE POINTER
 STX TEMP ; SAVE POINTER
 BRA OVRLA4
OVRLA5 LDAA DRCNT ; CHECK DIRECTION
 BNE OVRLA7
 CLRA 
 STAA CHRCNT ; CLEAR COUNT
 LDX BUFPNT ; SET POINTER
OVRL55 INCA
 CMPB 0,X ; CHECK CHR
 BEQ OVRLA6
 INX ; BUMP THE POINTER
 BRA OVRL55 ; REPEAT
OVRLA6 STAA CHRCNT+1 ; SAVE COUNT
 LDX TEMP ; SET POINTER
 STX SPCPT1 ; SAVE POINTER
 LDAA #1
 STAA DRCNT ; SET DIRECTION
 JSR MAKSPC ; GO MAKE SPACE
 LDAB #$D
 LDX BUFPNT ; SET POINTER
 DEX ; DEC THE POINTER
 BRA OVRL41
OVRLA7 LDX NEWPOS ; SET POINTER
ODONE JSR VERLIN ; VERIFY LINE
 JMP EDIT ; RETURN
*
* MOVE COMMAND
*
MOVE INC MOVFLG ; SET FLAG
 BSR COPY ; GO DO COPY
 LDAA CPTDRC ; WHICH DIRECTION
 STAA DRCNT
 LDX TRGLIN ; POINT TO TARGET
 STX SPCPT2 ; SAVE POINTER
 LDX NEWPOS ; SET POINTER
 STX SPCPT1 ; SAVE POINTER
 LDX CURPOS ; SET THE POINTER TO CURRENT POSITION
 STX TRGLIN ; MAKE IT TARGET
 JSR DELCHR ; DELETE LINES
 LDX TRGLIN ; POINT TO TARGET
 STX CURPOS ; FIX POSITION
 JMP PRINT6
*
* COPY LINES COMMAND
*
COPY LDX BUFPNT ; SET POINTER
 INC NXTFLG ; SET FLAG
 INC LINFLG ; SET FLAG
 JSR FINDT ; FIND TARGET
 CPX FILEND ; END OF FILE?
 BEQ COPY0
 CLR LINFLG ; CLEAR FLAG
 CLR NXTFLG ; CLEAR FLAG
 CPX FILBEG ; BEGINNING?
 BNE COPY02
 CPX NEWPOS
 BEQ COPY05
COPY02 LDAA DRCNT ; CHECK DIRECTION
 STAA CPTDRC
COPY05 CLR DRCNT
 JSR TSTOVR ; LIMITS?
 BEQ COPY1
COPY0 JMP NOTFND ; REPORT NOT FOUND
COPY1 JSR FNDCRT ; GET NEXT CR
 INX ; BUMP THE POINTER
 STX SPCPT1 ; SAVE POINTER
 LDX BUFPNT ; SET POINTER
 JSR FINDT ; FIND TARGET
 JSR TSTOVR ; LIMITS?
 BNE COPY0
 TST DRCNT ; WHICH DIRECTION
 BNE COPY15
 LDX NEWPOS ; SET POINTER
 STX TEMP ; SAVE POINTER
 LDX TRGLIN ; POINT TO TARGET
 BRA COPY18
COPY15 LDX TRGLIN ; POINT TO TARGET
 STX TEMP ; SAVE POINTER
 LDX NEWPOS ; SET POINTER
COPY18 JSR FNDCRT ; GET NEXT CR
 INX ; BUMP THE POINTER
 STX TRGLIN ; SET TARGET
 LDX TEMP ; SET POINTER
 STX NEWPOS ; SAVE NEW POSITION
 CLRA ; CLEAR ACC
 CLRB
COPY2 INX ; BUMP THE POINTER
 INCA ; BUMP THE COUNTER
 BNE COPY25
 INCB ; BUMP THE COUNTER
COPY25 CPX TRGLIN ; TARGET LINE? (FINISHED?)
 BEQ COPY3
 CPX SPCPT1 ; OVERLAP?
 BNE COPY2
 LDX #OVLPST ; POINT TO STRING
 JSR PSTRNG ; OUTPUT IT
 CLR MSLFLG
 JMP EDIT ; RETURN
COPY3 STAA CHRCNT+1 ; SAVE COUNT
 STAB CHRCNT
 LDAA #1 ; SET DIRECTION
 STAA DRCNT
 JSR MAKSPC ; GO MAKE SPACE
 LDX SPCPT2 ; SET POINTER
 STX CURPOS ; SET CURRENT POSITION
 LDX SPCPT1 ; GET POINTER
 STX XSAVE
 LDX TRGLIN ; POINT TO TARGET
 STX SPCPT1 ; SAVE POINTER
 LDX NEWPOS ; SET POINTER
 STX TEMP ; SAVE POINTER
 JSR MAKS55 ; MOVE LINES
 LDX XSAVE ; RESTORE POINTER
 CLR OVRBEG
 JSR BAKONE ; BACKUP ONE LINE
 LDAA OVRBEG ; CHECK LIMIT
 BEQ COPY5
 JSR CLRNUM ; CLEAR NUMBER
COPY4 INC CHKFLG ; SET FLAG
 JSR RENUM2 ; GO RENUMBER
 LDX CURPOS ; SET THE POINTER
 JSR BAKONE ; BACKUP ONE LINE
 STX CURPOS ; SET CURRENT POSITION
 LDAA MOVFLG ; MOVE?
 BEQ COPY45
 RTS ; RETURN
COPY45 JMP PRINT6
COPY5 JSR GETNUM ; GET LINE NUMBER
 CLRA
 STAA NUMBER+2
 JSR UPONE ; MOVE UP ONE
 BRA COPY4
*
* TAB SET COMMAND
*
TAB LDX #TABBUF ; SET POINTER
 STX TABPNT
TAB2 LDX BUFPNT ; SET POINTER
 JSR SKIPSP ; SKIP SPACES
 STX BUFPNT ; SAVE POINTER
 JSR TSTEND
 BEQ TAB6
 JSR CLASS ; GO CLASSIFY CHR
 CMPB #1 ; IS IT A NUMBER?
 BEQ TAB4
 BHI TAB8
 INX ; BUMP THE POINTER
 STX BUFPNT ; SAVE POINTER
 BRA TAB2
TAB4 JSR BCDCON ; CONVERT NUMBER (GET COLUMN)
 STX BUFPNT ; SAVE POINTER
 CLRB
 JSR TSTNUM ; IS IT ZERO?
 BEQ TAB6
TAB5 INCB ; BUMP THE COUNTER
 PSHB
 JSR DECNUM ; DEC NUMBER
 PULB
 BNE TAB5
 LDX TABPNT ; POINT TO TABS
 STAB 0,X ; SAVE COUNT
 INX ; BUMP THE POINTER
 STX TABPNT ; FIX TAB POINTER
 CPX #BUFFER ; #TABEND
 BEQ TAB6
 BRA TAB2
TAB6 CLRA
 LDX TABPNT
 STAA 0,X ; CLEAR TAB
 JMP NUMSE6
TAB8 JMP SYNERR ; REPORT ERROR
*
* PRINT HEADER COMMAND
*
HEADER LDX #TABBUF ; SET POINTER
 STX TABPNT
 LDX BUFPNT ; SET POINTER
 JSR SKIPSP ; SKIP SPACES
 JSR TSTEND
 BEQ HEAD42
 JSR CLASS ; GO CLASSIFY CHR
 CMPB #1 ; IS IT A NUMBER?
 BNE TAB8
 JSR BCDCON ; CONVERT NUMBER
 STX BUFPNT ; SAVE POINTER
 JSR TSTNUM ; IS IT ZERO?
 BEQ HEADE7
 CLRB 
HEADE3 INCB ; BUMP THE COUNTER
 PSHB 
 JSR DECNUM ; DEC NUMBER
 PULB 
 BNE HEADE3
 STAB HEDCNT ; SAVE COUNT
HEAD42 JSR CLRNUM ; CLEAR NUMBER
 JSR PCRLF ; PRINT CRLF
 LDAA NUMFLG ; LINE NUMBERS ON?
 BEQ HEADE5
 LDAB #8 ; SET COUNT
HEAD45 JSR OUTSPC ; OUTPUT A SPACE
 DECB ; DEC THE COUNTER
 BNE HEAD45
HEADE5 JSR OUTSPC ; OUTPUT A SPACE
 CLRB  ; CLEAR COUNT
HEAD55 PSHB
 JSR INCNUM ; INC NUMBER
 PULB
 INCB ; BUMP THE COUNTER
 LDX TABPNT ; GET TAB COL.
 CMPB 0,X ; THERE?
 BNE HEAD57
 LDAA #'- ; SET UP THE '-'
 JSR OUTCH ; OUTPUT IT
 INX ; BUMP THE POINTER
 STX TABPNT
 BRA HEAD58
HEAD57 LDAA NUMBER+1 ; GET NUMBER
 JSR OUTHR ; OUTPUT IT
HEAD58 CMPB HEDCNT
 BNE HEAD55 ; REPEAT TIL DONE
HEADE7 JMP NUMSE6
*
* SET UP ZONE COLUMN COMMAND
*
SZONE LDX BUFPNT ; SET POINTER
 JSR SKIPSP ; SKIP SPACES
 JSR TSTEND
 BEQ SZONE2
 JSR CLASS ; GO CLASSIFY CHR
 CMPB #1 ; IS IT A NUMBER?
 BEQ SZONE3
 BHI SZONE8
 INX ; BUMP THE POINTER
SZONE2 STX BUFPNT ; SAVE POINTER
 LDX #1 ; SET COLUMN 1
 BRA SZONE4
SZONE3 JSR BCDCON ; GET AND CONVERT NUMBER
 STX BUFPNT ; SAVE POINTER
 LDX NUMBER
SZONE4 STX ZONE1 ; FIX ZONE1
 LDX BUFPNT ; SET POINTER
SZONE5 JSR SKIPSP ; SKIP SPACES
 JSR TSTEND
 BEQ SZONE6
 JSR CLASS ; GO CLASSIFY CHR
 CMPB #1 ; IS IT A NUMBER?
 BEQ SZONE7
 BHI SZONE8 ; ERROR
 INX ; BUMP THE POINTER
 BRA SZONE5
SZONE6 LDX #$110 ; SET COLUMN 110
 BRA SZON75
SZONE7 JSR BCDCON ; GET AND CONVERT NUMBER
 STX BUFPNT ; SAVE POINTER
 LDX NUMBER
SZON75 STX ZONE2 ; SET ZONE2
 JMP NUMSE6
SZONE8 JMP ERROR ; REPORT ERROR
*
* SET SPECIAL CHR COMMAND
*
SET LDX BUFPNT ; SET POINTER
 JSR SKIPSP ; SKIP SPACES
 STX BUFPNT ; SAVE POINTER
 STX TEMP ; SAVE POINTER
 LDX #CHRTBL ; POINT TO TABLE
 JMP EDIT6 ; GO FIND NAME
*
* SET SPECIALS HERE
*
* TAB
*
STAB LDX #TABCH ; POINT TO TAB CHR
 BRA SETC
*
* FILL
*
SFILL LDX #FILL ; POINT TO FILL CHR
 BRA SETC
*
* EOL
*
SEOL LDX #EOL ; POINT TO EOL CHR
 BRA SETC
*
* LINO
*
SLINO LDX #LINO ; POINT TO LINO CHR
*
* SET THE CHR
*
SETC STX TEMP ; SAVE POINTER
 LDX BUFPNT ; SET POINTER
 JSR SKIPSP ; SKIP SPACES
 CMPA #'= ; IS IT '='?
 BNE SETC8 ; ERROR
 BSR CHFRQU
 BNE SETC8 ; ERROR
 BSR CHFRQU
 BNE SETC2
 CLRA ; SET NULL CHR
 PSHA
 BRA SETC4
SETC2 JSR CLASS ; GO CLASSIFY CHR
 TSTB
 BNE SETC8 ; ERROR
 CMPA #$D ; CR?
 BEQ SETC8
 PSHA ; SAVE CHR
 BSR CHFRQU
 BNE SETC8 ; ERROR
SETC4 INX ; BUMP THE POINTER
 STX BUFPNT ; SAVE POINTER
 JSR TFORCR ; TEST FOR END
 PULA ; GET CHR
 LDX TEMP ; SET POINTER
 CPX #FILL ; IS IT FILL?
 BNE SETC5
 TSTA
 BNE SETC6
 LDAA #$20 ; SETUP SPACE
 BRA SETC6
SETC5 CPX #LINO ; IS IT LINO?
 BNE SETC6
 TSTA 
 BNE SETC6
 LDAA #'# ; SET IT
SETC6 STAA 0,X ; PUT CHR
 JMP NUMSE6 ; RETURN
SETC8 JMP SYNERR ; REPORT ERROR
*
* CHECK FOR QUOTE
*
CHFRQU INX ; BUMP THE POINTER
 JSR SKIPSP ; SKIP SPACES
 CMPA #'' ; IS IT A "'"?
 RTS ; RETURN
*
* EXPAND TABS COMMAND
*
EXPAND JSR TSTEMP
 LDX BUFPNT ; SET POINTER
 JSR FINDT ; FIND TARGET
 LDX NEWPOS ; SET POINTER
 LDAA #1
 STAA PRNFLG ; SET FLAG
EXPAN1 STX CURPOS ; SET CURRENT POSITION
 CPX TRGLIN ; TARGET LINE? (LAST LINE)
 BNE EXPAN2
 CLR PRNFLG ; CLEAR FLAG
EXPAN2 BSR EXPLIN ; GO DO LINE
 LDAA PRNFLG ; DONE?
 BEQ EXPAN5
 LDX NEWPOS ; SET POINTER
 JSR NXTLIN ; FIND NEXT LINE
 STX NEWPOS ; SAVE NEW POSITION
 BRA EXPAN1
EXPAN5 JMP PRINT6
*
* EXPAND TABS IN ONE LINE
*
EXPLIN LDAA TABCH
 CMPA FILL ; CHECK IF FILL = TAB
 BEQ EXPLI7
 LDX #TABBUF ; POINT TO TABS
 STX TABPNT
 LDAB 0,X ; GET COLUMN
 BEQ EXPLI7
 CLRB ; CLEAR COUNT
 STAB CHRCNT
 LDX NEWPOS ; POINT TO LINE
 CPX FILEND ; END OF FILE?
 BNE EXPLI1
 JMP EDIT ; RETURN
EXPLI1 INX ; BUMP THE POINTER
 INX ; BUMP THE POINTER
 INX ; BUMP THE POINTER
EXPLI2 INCB ; BUMP THE COUNTER
 LDAA 0,X ; CHECK FOR TAB
 CMPA #$D ; CR?
 BEQ EXPLI7
 CMPA TABCH ; IS IT A TAB
 BEQ EXPLI3
 INX ; BUMP THE POINTER
 BRA EXPLI2
EXPLI3 STX TEMP ; SAVE POINTER
 LDX TABPNT
EXPL35 CMPB 0,X ; CHECK COLUMN
 BCC EXPLI6
 LDAA #$FF ; SET COUNT
EXPLI4 INCA
 INCB ; BUMP THE COUNTER
 CMPB 0,X ; TAB COL. YET?
 BNE EXPLI4
 STAA CHRCNT+1 ; SAVE COUNT
 LDX TEMP ; SET POINTER
 STX SPCPT1 ; SET SPACE POINTER
 JSR MAKSPC ; GO MAKE SPACE
 LDAB CHRCNT+1
 INCB ; BUMP THE COUNTER
 LDAA FILL ; GET FILL CHR
EXPLI5 STAA 0,X ; PUT CHR
 INX ; BUMP THE POINTER
 DECB ; DEC THE COUNTER
 BNE EXPLI5
 BRA EXPLIN ; REPEAT
EXPLI6 INX ; BUMP THE POINTER
 LDAA 0,X ; GET CHR
 BNE EXPL35
EXPLI7 RTS ; RETURN
*
* APPEND COMMAND
*
APPEND JSR TSTEMP
 LDX BUFPNT ; SET POINTER
 JSR SKIPSP ; SKIP SPACES
 JSR TSTEND ; END?
 BNE APPEN1
APPEN0 JMP SYNERR
APPEN1 JSR CLASS ; GO CLASSIFY CHR
 TSTB
 BNE APPEN0
 JSR SETDEL ; SET DELIMITERS
 JSR CLASS ; GO CLASSIFY CHR
 CMPB #1 ; IS IT A NUMBER?
 BNE APPEN3
 JSR BCDCON ; GET COL NUMBER
 JSR TSTNUM ; IS IT ZERO?
 BEQ APPEN3
 CLRA
APPEN2 INCA ; BUMP COUNTER
 PSHA  ; SAVE COUNT
 JSR DECNUM ; DEC NUMBER
 PULA  ; RESTORE COUNT
 BNE APPEN2
 STAA APPCOL ; SAVE COUNT
APPEN3 JSR SVSTPT ; SAVE DEL INFO
 LDX BUFPNT ; SET POINTER
 JSR FINDT ; FIND TARGET
 JSR RSTSPT ; RESTORE DEL INFO
 CLR CHRCNT
 INC PRNFLG ; SET FLAG
 LDX NEWPOS ; SET POINTER
APPE35 CPX TRGLIN ; TARGET LINE?
 BNE APPEN4
 CLR PRNFLG ; CLEAR FLAG
APPEN4 INX ; BUMP THE POINTER
 INX ; BUMP THE POINTER
 INX ; BUMP THE POINTER
 LDAA APPCOL ; GET COL. NUMBER
 BNE APPEN5
 DEX ; DEC THE POINTER
 JSR FNDCRT ; GET NEXT CR
 BRA APPEN7
APPEN5 TAB
APPE53 DECB ; DEC THE COUNTER
 BEQ APPE65
 LDAA 0,X ; GET CHR
 CMPA #$D ; CR?
 BEQ APPEN6
 INX ; BUMP THE POINTER
 BRA APPE53
APPEN6 STX SPCPT1 ; SAVE POINTER
 STAB CHRCNT+1
 PSHB 
 JSR MAKSPC ; GO MAKE SPACE
 PULB 
 LDAA #$20 ; SET UP SPACE
APPE63 STAA 0,X ; PUT CHR
 INX ; BUMP THE POINTER
 DECB ; DEC THE COUNTER
 BNE APPE63
 BRA APPEN7
APPE65 STX SPCPT1 ; SAVE POINTER
 STX TEMP ; SAVE POINTER
APPE66 LDAA 0,X ; GET CHR
 CMPA #$D ; CR?
 BEQ APPE67
 INX ; BUMP THE POINTER
 INCB ; BUMP THE COUNTER
 BRA APPE66
APPE67 STAB CHRCNT+1
 STX SPCPT2 ; SAVE POINTER
 JSR DELCHR ; DELETE REST OF LINE
 LDX TEMP ; SET POINTER
APPEN7 STX SPCPT1 ; SAVE POINTER
 LDAA STRCNT ; GET COUNT
 BEQ APPE78
 STAA CHRCNT+1
 JSR MAKSPC ; GO MAKE SPACE
 LDX STRNGE ; POINT TO STRING
 STX SPCPT1 ; SAVE POINTER
 LDX STRNGB
 STX TEMP ; SET END
 JSR MAKS55 ; PUT IT IN STRING
 LDX SPCPT2 ; SET POINTER
APPE78 CLRB
 JSR BAKON2
 JSR VERLIN ; VERIFY LINE
 LDAA PRNFLG ; DONE?
 BEQ APPEN8
 JSR NXTLIN ; FIND NEXT LINE
 STX NEWPOS ; SAVE NEW POSITION
 BRA APPE35 ; REPEAT
APPEN8 STX CURPOS ; SET CURRENT POSITION
 JMP PRINT6
*
* WRITE PART OF FILE TO DSK
*
WRITE JSR TSTEMP
 LDX BUFPNT ; SET POINTER
 JSR FINDT ; FIND TARGET
 LDAA DRCNT ; CHECK DIRECTION
 BNE WRITE2
 JSR FNDCRT ; GET NEXT CR
 INX ; BUMP THE POINTER
 STX SPCPT2 ; SAVE POINTER
 LDX NEWPOS ; SET POINTER
 STX SPCPT1 ; SAVE POINTER
 BRA WRITE4
WRITE2 STX SPCPT1 ; SAVE POINTER
 LDX NEWPOS ; SET POINTER
 JSR FNDCRT ; GET NEXT CR
 INX ; BUMP THE POINTER
 STX SPCPT2 ; SAVE POINTER
WRITE4 BSR RECORD ; GO WRITE IT
WRITE5 JMP NUMSE6
*
* WRITE TO DSK
*
RECORD BSR AGFIL ; GET FILE NAME
 BCS WRITE5
 LDX #FCB ; GET FILE CONTROL BLOCK
 LDAA #QSO4W ; OPEN FOR WRITE
 STAA 0,X ; PUT CHR
 JSR DFM ; OPEN FILE
 BEQ WFILOP
 JSR ZTYPDE ; OH-OH! NO GO !!
 BRA WRITE5
WFILOP LDAA #QSWRIT
 STAA 0,X ; PUT CHR
 CLR V050
L19E LDX SPCPT1 ; GET POINTER
L181 CPX SPCPT2
 BEQ L17D
 INX ; BUMP THE POINTER
 INX ; BUMP THE POINTER
 INX ; BUMP THE POINTER
WRTLOP LDAA 0,X ; GET CHR
 CMPA #$D ; CR?
 BEQ L17E
 BSR L17F
 INX ; BUMP THE POINTER
 BRA WRTLOP
L17E BSR L17F
 INX ; BUMP THE POINTER
 BRA L181
L17D TST V050
 BNE L182
L187 STX XSAVE
 LDX #FCB
 LDAA #QSWC ; CLOSE WRITE SEQ FILE
 STAA 0,X ; PUT CHR
 JSR DFM
 BEQ L183
 JSR ZTYPDE
L183 LDX XSAVE
L182 RTS ; RETURN
L184 LDX #ILLFIL
 JSR PSTRNG ; OUTPUT IT
 SEC 
 RTS ; RETURN
AGFIL LDX #FILQU
 JSR PSTRNG ; OUTPUT IT
 JSR ZLINEI ; GET A LINE (FILE NAME)
 LDX #FCB
 JSR ZFLSPC ; GET FILE SPEC
 BCS L184
 RTS ; RETURN
L17F TST V050
 BNE L185
 STX XSAVE
 LDX #FCB
 JSR DFM
 BNE L186
 LDX XSAVE
 RTS ; RETURN
*
* ERROR
*
L186 JSR ZTYPDE
 INS ; FIX THE STACK
 INS
 LDX XSAVE
 BRA L187
L185 STX XSAVE
 LDX #WFCB
 JSR DFM
 BNE L188
 LDX XSAVE
 RTS ; RETURN
L188 STX XSAVE
 JSR ZTYPDE
 LDX XSAVE
 INC 0,X
 JSR DFM
 BEQ L189
 JMP TYPDE
L189 CLR V052
 LDX #RETSTR
 JMP PREROR
READ JSR AGFIL
 BCS L18B
 CLR V050
 LDX #FCB
 LDAB #1 ; SET EXT= TXT
 JSR ZSTEXT
 LDAA #QSO4R
 STAA 0,X ; PUT CHR
 JSR DFM
 BEQ L18C
 JSR ZTYPDE
L18B JMP NUMSE6
L18C INC 0,X
L1A5 JSR CLRNUM ; CLEAR NUMBER
 LDX FILEND ; POINT TO END
 STX TEMP ; SAVE POINTER
 CPX FILBEG ; BEGINNING?
 BEQ L18D
 JSR BAKONE ; BACKUP ONE LINE
 JSR GETNUM
 LDX FILEND ; POINT TO END
L18D JSR L18E
 JSR L18E
 JSR L18E
L195 TST V050
 BEQ L18F
 STX XSAVE
 LDX #RFCB
 JSR DFM
 BEQ L190
 LDAA 1,X
 CMPA #6
 BNE L188
 STAA V054
 BRA L191
L18F STX XSAVE
 LDX #FCB
 JSR DFM
 BEQ L190
 LDAA 1,X
 CMPA #6
 BEQ L191
 JSR ZTYPDE
L191 LDX XSAVE
 BRA L192
L190 LDX XSAVE
 CMPA #$D ; CR?
 BEQ L193
 CMPA #$1A
 BNE L194
 STAA V054
 BRA L192
L194 CMPA #$1F
 BLS L195
 BSR L196
 BRA L195
L193 BSR L196
 TST V055
 BNE L197
 BRA L18D
L192 CLRB
 JSR BAKON2
L197 STX FILEND
 INC CHKFLG
 TST V050
 BNE L198
 LDX #FCB
 LDAA #6
 STAA 0,X ; PUT CHR
 JSR DFM
 BEQ L199
 JSR ZTYPDE
L199 LDX XSAVE
L198 CPX TEMP
 BEQ L19A
 LDX TEMP ; SET POINTER
 JSR RENUM2
L19A TST V050
 BEQ L19B
 RTS ; RETURN
L19B JMP BOTTO1
L18E CLRA
L196 CPX V056
 BEQ L19D
 STAA 0,X ; PUT CHR
 INX ; BUMP THE POINTER
 RTS ; RETURN
L19D INC V055
 STAA 0,X ; PUT CHR
 INX ; BUMP THE POINTER
 STX SRCHPT
 LDX #MEMFUL
 JSR PSTRNG ; OUTPUT IT
 LDX SRCHPT
 RTS ; RETURN
*
NEW JSR TFORCR
 LDX FILBEG
 STX SPCPT1 ; SAVE POINTER
 LDX CURPOS ; SET THE POINTER
 STX SPCPT2 ; SAVE POINTER
 CLR V055
 INC V050
 JSR L19E
 CLR V050
 LDX FILBEG
 STX CURPOS ; SET CURRENT POSITION
 BSR L19F
 JMP RESTRT
L19F LDX SPCPT2 ; SET POINTER
 CLRA 
 CLRB 
 STAA V055
L1A2 CPX SPCPT1
 BEQ L1A0
 INCA 
 BNE L1A1
 INCB ; BUMP THE COUNTER
L1A1 DEX ; DEC THE POINTER
 BRA L1A2
L1A0 STAA CHRCNT+1
 STAB CHRCNT
 JSR DELCHR
 LDAA V054
 BNE L1A3
 LDAA FILEND
 LDAB V057
 CMPA V056
 BHI L1A3
 BCS L1A4
 CMPB V058
 BCC L1A3
L1A4 INC V050
 JSR L1A5
L1A3 CLR V050
 RTS ; RETURN
L1AB STX SPCPT2 ; SAVE POINTER
 LDAB #'*
L1A6 CLR 0,X
 INX ; BUMP THE POINTER
 DECB ; DEC THE COUNTER
 BNE L1A6
 LDAB #$C
L1A7 LDX SPCPT1 ; GET POINTER
 LDAA 0,X ; GET CHR
 INX ; BUMP THE POINTER
 STX SPCPT1 ; SAVE POINTER
 LDX SPCPT2 ; SET POINTER
 STAA 0,X ; PUT CHR
 INX ; BUMP THE POINTER
 STX SPCPT2 ; SAVE POINTER
 DECB ; DEC THE COUNTER
 BNE L1A7
 RTS ; RETURN
CLOFIL INC CLOREX
 BRA L1A8
DEXIT CLR CLOREX
L1A8 LDX FILBEG
 STX SPCPT1 ; SAVE POINTER
 LDX FILEND ; POINT TO END
 STX SPCPT2 ; SAVE POINTER
 INC V050
 JSR L19E
 CLR V050
 LDAA V054
 BNE L1A9
 BSR L19F
 BRA L1A8
L1A9 JSR CDFM
 BNE TYPDE
 TST V05A
 BEQ L1AA
 LDX #RFCB
 STX SPCPT1 ; SAVE POINTER
 LDX #V05B
 BSR L1AB
 LDX #RFCB
 STX SPCPT1 ; SAVE POINTER
 LDX #V05C
 BSR L1AB
 LDX #V05B
 STX SPCPT1 ; SAVE POINTER
 CLR 9,X
 LDAB #5
 JSR ZSTEXT
 LDX #FCB
 BSR L1AB
 LDX #FCB
 LDAA #7
 STAA 0,X ; PUT CHR
 JSR DFM
 BEQ L1AC
 LDAA 1,X
 CMPA #5
 BNE TYPDE
L1AC LDX #RFCB
 LDAA #8
 STAA 0,X ; PUT CHR
 JSR DFM
 BNE TYPDE
 LDX #WFCB
 LDAA #8
 STAA 0,X ; PUT CHR
 JSR DFM
 BNE TYPDE
L1AA TST CLOREX
 BEQ L1AD
L1B2 LDX #FILQU
 JSR PSTRNG ; OUTPUT IT
 JSR ZLINEI
 LDS STACK
 BRA EDINIT
TYPDE JSR ZTYPDE
L1AD JMP EDEXIT
 STX YABRTV
 JMP 0,X
GETFIL JSR ZFLSPC
 BCS TYPDE
 RTS ; RETURN
*
* INIT EDITOR
*
EDINI0 LDAA YPPPAS ; SAVE WAIT FLAG
 STAA PPPAS
EDINIT LDX #WARMS ; POINT TO WARM START
 STX YABRTV ; SET ^C TRAP
 STX NMIVEC ; SET NMI VECTOR
 STX PC ; SET PC
 LDX #STACK
 CLR FCB+3 ; FOR IDFILE
 CLR IQUIT
* CLEAR BUFFER
CRLBUF CLR 0,X
 INX ; BUMP THE POINTER
 CPX #BUFFER+110 ; DONE?
 BNE CRLBUF
 STS STACK
 JSR PGMID ; PRINT PROGRAM ID
 JSR L1B1
 LDAA MEMEND
 LSRA
 LSRA
 LSRA
 LSRA
 TAB
 LDAA MEMEND
 SBA
 STAA V056
 LDAB V05D
 STAB V058
 LDX #BEGPNT
 STX FILBEG
 STX FILEND
* SET UP ZONES
 LDX #1
 STX ZONE1
 LDX #$110 ; $136
 STX ZONE2
* SET DEFAULT HEADER COUNT
 LDAA #53
 STAA HEDCNT
* SET FLAGS
 LDAA #$FF
 STAA NUMFLG
 STAA VERFLG
 STAA QUIT
 LDX YLINPT
 LDAA 0,X ; GET CHR
 CMPA #$D ; CR?
 BNE EDINI1
 JMP L1B2
EDINI1 INX ; BUMP THE POINTER
 LDAA 0,X ; GET CHR
 JSR ZANCHK
 BCC L1B3
 STX YLINPT
 BRA L1B4
L1B3 LDX #RFCB
 JSR GETFIL
 LDAB #1 ; SET EXT=TXT
 JSR ZSTEXT
 LDAA #4
 STAA 0,X ; PUT CHR
 JSR DFM
 BEQ L1B6
L1BA JMP TYPDE
L1B6 INC 0,X
 STX XTEMPX
 CLR QUIT
 LDX #EDMSG
 JSR PSTRNG ; OUTPUT IT
 LDX #RFCB+2
 JSR FNOUT
 LDX XTEMPX
 JSR ZGCHAR
 CMPA #$D ; CR?
 BNE L1B7
 STX SPCPT1 ; SAVE POINTER
 JMP L1B8
L1C0 LDX #WFCB
 JSR L1AB
 LDX #WFCB
 CLR 9,X
 LDAB #8
 JSR ZSTEXT
 INC V05A
 BRA L1B9
L1B4 COM V054
L1B7 LDX #WFCB
 JSR GETFIL
 LDAB #1 ; SET COUNTER
 JSR ZSTEXT
L1B9 LDX #WFCB
 LDAA #1
 STAA XFT,X
 LDAA #QSO4W
 STAA XFC,X
 JSR DFM
 BNE L1BA
 INC 0,X ; SET TO QSWRIT
 CLR QUIT
 LDAA V052
 BNE L1BB
 LDAA V054
 BEQ L1BC
 LDX #NWFSTR
 JSR PSTRNG ; OUTPUT IT
 INC INZFLG
 BRA L1BB
L1BC JSR L1A4
L1BB JMP RESTRT
*
* RETRY COMMAND
*
RETRY COM V052
 BRA L1B9
*
* QUIT COMMAND
*
* DELETE OUTPUT FILE AND RESTART EDITOR
*
QUITER INC IQUIT ; SET FLAG
*
* DOS OR KI COMMAND
*
* DELETE OUTPUT FILE AND EXIT TO DOS
*
DOS JSR CDFM ; CLOSE ALL FILES
 INC QUIT ; SET FLAG
 LDX #WFCB ; GET WFCB
 LDAA #QDEL ; DELETE CODE
 STAA 0,X ; PUT CHR
 JSR DFM ; TRY TO DELETE FILE
 BNE DFMER1
 JMP L1AD
DFMER1 JMP L1BA
L1B8 LDX #E011
 BSR L1BD
 BCS L1BE
 LDX #E012
 BSR L1BD
 BCC L1BF
*
* ILLEGAL FILE EXT (BAK OR TMP) FOR NO OUTPUT FILE GIVEN
*
L1BE LDX #ILLEXT ; POINT TO STRING
 JSR PSTRNG ; OUTPUT IT
 JMP L1AD
L1BF JMP L1C0
L1BD LDAA V05F
 LDAB 0,X
 CBA 
 BNE L1C1
 LDAA V060
 LDAB 1,X
 CBA 
 BNE L1C1
 LDAA V061
 LDAB 2,X
 CBA 
 BNE L1C1
 SEC 
 RTS ; RETURN
L1C1 CLC 
 RTS ; RETURN
L1B1 LDX YMEMAX
 LDAA YMEMAX
 CMPA #$30
 BHI L1C2
 LDX #BEGPNT
 DEX ; DEC THE POINTER
 LDAA #$55
L1C3 INX ; BUMP THE POINTER
 CPX MEMTOP
 BEQ L1C2
 STAA 0,X ; PUT CHR
 CMPA 0,X
 BNE L1C2
 CLR 0,X
 BRA L1C3
L1C2 DEX ; DEC THE POINTER
 STX MEMEND
 RTS ; RETURN
OUTCH4 JMP ZPUTCH
*
* PRINT FILE NAME FROM FCB
*
FNOUT JSR OUTSPC ; OUTPUT A SPACE
 LDAA 0,X ; GET UNIT NUMBER
 ADDA #$30 ; CHANGE TO ASCII
 BSR OUTCH4 ; OUTPUT IT
 LDAA #': ; SET UP ':'
 BSR OUTCH4 ; OUTPUT IT
 LDAB #6 ; LOAD COUNTER
FNOUT1 INX ; BUMP THE POINTER
 LDAA 0,X ; GET CHR
 BSR OUTCH4 ; OUTPUT IT
 DECB ; DEC THE COUNTER
 BNE FNOUT1
 LDAB #3 ; RESET COUNTER
 INX ; BUMP THE POINTER
 LDAA #'. ; SET UP '.'
 BSR OUTCH4 ; OUTPUT IT
FXOUT LDAA 0,X ; GET CHR
 BSR OUTCH4 ; OUTPUT IT
 INX ; BUMP THE POINTER
 DECB ; DEC THE COUNTER
 BNE FXOUT
 RTS ; RETURN
*
* ID FILES FROM FCB'S
*
IDFILE LDX #INFMSG ; POINT TO STRING
 JSR PSTRNG ; OUTPUT IT
 LDX #RFCB+2 ; POINT TO READ FCB
 BSR FNOUT ; PRINT FILE NAME FROM IT
 LDX #OTFMSG ; POINT TO STRING
 JSR PSTRNG ; OUTPUT IT
 LDX #WFCB+2 ; POINT TO WRITE FCB
 BSR FNOUT ; PRINT FILE NAME FROM IT
 TST FCB+3 ; CHECK IF READ FCB WAS USED
 BEQ IDFIN
 LDX #READMG ; POINT TO STRING
 JSR PSTRNG ; OUTPUT IT
 LDX #FCB+2 ; POINT TO READ FCB
 BSR FNOUT ; PRINT FILE NAME FROM IT
IDFIN JMP EDIT ; RETURN
*
* PRINT HEADING (NAME AND VERSION)
*
PGMID LDX #NAME ; POINT TO NAME
 LDAB #6 ; SET COUNTER
NAMLP2 LDAA 0,X ; GET CHR
 CMPA #$20
 BEQ NAMLP3
 JSR OUTCH
NAMLP3 INX ; BUMP THE POINTER
 DECB ; DEC THE COUNTER
 BNE NAMLP2
 LDX #VERMSG ; POINT TO STRING
 JSR PDATAP ; PRINT IT
 LDAA VERSION ; GET VERSION
 PSHA ; SAVE IT
 JSR OUTHL ; OUTPUT LEFT HALF
 PULA ; GET VERSION
 JSR OUTHR ; OUTPUT RIGHT HALF
 RTS ; RETURN
*
* VT5 COMMAND (OUTPUT 5 VERT TABS TO LPT)
*
LPTVT5 LDAB #5 ; SET COUNTER
 BRA LPTVT1
*
* VT COMMAND (OUTPUT  VERT TAB TO PRINTER)
*
LPTVT LDAB #1 ; SET COUNTER
LPTVT1 LDAA #$B ; SET UP VERT TAB
 BRA LPTEJ1
*
* EJECT PAGE ON LPT
*
LPTEJ LDAA #$C ; SET UP EJECT
 LDAB #1 ; SET COUNTER
LPTEJ1 JSR ZHCOUT ; OUTPUT TO LPT
 DECB ; DEC THE COUNTER
 BNE LPTEJ1
 JMP EDIT ; RETURN
*
* MOVE CURSOR UP 
*
CURUP1 LDAA #CURUP ; GET CURSOR UP CHR
 JMP OUTCH ; OUTPUT IT
*
* UP LINE
*
UPLINE BSR CURUP1 ; MOVE CURSOR UP ONE
 LDX BUFPNT ; SET POINTER
 JSR SKIPSP ; SKIP SPACES
 CMPA #$D ; CR?
 BNE UPLIN1
 LDAA #1
 STAA 0,X ; PUT CHR
 LDAA #$D
 STAA 1,X
UPLIN1 LDX BUFPNT ; SET POINTER
 DEX ; DEC THE POINTER
 LDAA #'-
 STAA 0,X ; PUT CHR
 STX BUFPNT ; SAVE POINTER
 JMP EDIT55
*
* JOIN COMMAND 
*
* JOIN TWO LINES (CHANGE CR AND NUMBER TO SPACES)
*
JOIN LDX CURPOS ; SET THE POINTER
* BUMP PAST THE LINE NUMBER IN FIRST LINE
 INX ; BUMP THE POINTER
 INX ; BUMP THE POINTER
 INX ; BUMP THE POINTER
* FIND CR IN FIRST LINE
JOIN1 INX ; BUMP THE POINTER
 LDAA 0,X ; GET CHR
 CMPA #$D ; CR?
 BNE JOIN1
 INX ; BUMP THE POINTER
 CPX FILEND ; END OF FILE?
 BEQ JOINER ; ERROR
 DEX ; DEC THE POINTER
 LDAA #$20 ; SET UP SPACE
 STAA 0,X ; PUT CHR
 STAA 1,X ; PUT SPACE
 STAA 2,X ; PUT SPACE
 STAA 3,X ; PUT SPACE
JDONE LDX CURPOS ; SET THE POINTER
 JMP ODONE
* ERROR
*
JOINER LDX #BFRSTR
PERROR JSR PSTRNG ; OUTPUT IT
 JMP EDIT ; RETURN
SPLITE LDX #SPLERR
 BRA PERROR
*
* SPLIT LINE INTO TWO LINES AT '%%%%'
*
SPLIT LDX CURPOS ; SET THE POINTER
* BUMP PAST LINE NUMBER
 INX ; BUMP THE POINTER
 INX ; BUMP THE POINTER
 INX ; BUMP THE POINTER
SPLIT1 INX ; BUMP THE POINTER
 LDAA 0,X ; GET CHR
 CMPA #$D ; ERROR IF CR
 BEQ SPLITE
 CMPA #'% ; IF % MAYBE WE FOUND IT
 BNE SPLIT1
 LDAA 1,X ; NEXT CHR
 CMPA #'%
 BNE SPLIT1
 LDAA 2,X ; NEXT CHR
 CMPA #'%
 BNE SPLIT1
 LDAA 3,X ; NEXT CHR
 CMPA #'%
 BNE SPLIT1
* WE FOUND '%%%%'
* NOW PUT CR AND NEW NUMBER IN IT
 LDAA #$D ; SET UP CR
 STAA 0,X ; PUT CHR
 STX NEWPOS ; SAVE NEW POSITION
 LDX CURPOS ; SET THE POINTER
 LDAA 0,X ; GET CHR (LINE NUMBER)
 LDAB 1,X
 LDX NEWPOS ; SET POINTER
 STAA 1,X
 STAB 2,X
 LDX CURPOS ; SET THE POINTER
 LDAA 2,X
 LDX NEWPOS ; SET POINTER
 INCA ; GENERATE NEW NUMBER
 STAA 3,X
 BRA JDONE
* FLIP WAIT FLAG IN DOS
*
WAIT TST YPPPAS ; CHECK FLAG
 BEQ WAIT1
 CLR YPPPAS ; RESET FLAG
 BRA HELP1
WAIT1 INC YPPPAS ; SET FLAG
 BRA HELP1
*
* HELP COMMAND
*
HELP JSR TFORCR
 LDX #CNRSTR ; CLEAR SCREEN STRING
 JSR PDATAP ; PRINT IT
 LDAA #$FF ; MAKE IT MINUS
 STAA HELPSP
FREAD LDX #FCB ; OPEN FILE
FREAD0 CLR 0,X
 INX ; BUMP THE POINTER
 CPX #FCB+100
 BNE FREAD0
 LDX #FCB+XFN
 STX XHELP2
 LDX #EDHELP
FREAD1 LDAA 0,X ; GET CHR
 BEQ FREAD2
 INX ; BUMP THE POINTER
 STX XHELP1
 LDX XHELP2
 STAA 0,X ; PUT CHR
 INX ; BUMP THE POINTER
 STX XHELP2
 LDX XHELP1
 BRA FREAD1
FREAD2 LDX #FCB ; FILE NAME OK
 LDAB #QSO4R ; TRY TO OPEN FILE
 STAB XFC,X
 JSR DFM ; TRY IT
 BEQ FREAD3 ; BRA IF FILE DID OPEN
 JSR ZTYPDE
HELP1 JMP NUMSE6
* TRY TO READ FILE 'EDHELP.TXT'
FREAD3 INC XFC,X ; SO FAR SO GOOD, SET FCB FOR READ
FREAD4 TST HELPSP
 BMI FREADA
 BEQ FREAD5
 LDAA #$20
FREADS JSR ZPUTCH
 DEC HELPSP
 BNE FREADS
FREAD5 DEC FREADC
 BNE FREADB
 JSR ZCRLF ; CR-LF
FREADA LDAA #HELPCT
 STAA FREADC
FREADB LDAA #SPHELP
 STAA HELPSP
FREAD6 LDX #FCB ; SET X TO GET A BYTE
 JSR DFM ; GET IT
 BEQ FREAD7 ; BRA IF OK
 LDAB XES,X ; GET ERROR CODE
 CMPB #EEOF ; EOF?
 BEQ DSKOUT ; YEP, SO MAKE LIKE WE ARE FINISHED
 BRA DSKERR ; OH-OH !!
FREAD7 TSTA ; NULL
 BEQ FREAD6 ; BRA IF NULL
 CMPA #$1F ; CTRL CHR?
 BHI FREAD9 ; BRA IF NOT CTRL CHR
 CMPA #$D ; CR?
 BEQ FREAD4 ; BRA IF IT IS A CR
 BRA FREAD6 ; CTRL CHR GO IN BIT BUCKET
FREAD9
 JSR ZPUTCH ; PUT IT OUT
 DEC HELPSP
 BRA FREAD6 ; AND GO GUT ANOTHER BYTE
DSKERR JSR ZTYPDE ; GIVE UP
DSKOUT LDX #FCB ; FCB
 LDAA #QSRC ; CLOSE FILE
 STAA XFC,X ; PUT IT IN FCB
 JSR DFM ; CLOSE IT
 BEQ CLOSED ; BRA IF OK.
 JSR ZTYPDE ; YELL FOR HELP
CLOSED JMP NUMSE6 ; AND EXIT
*
* COMMAND TO ECHO CTY OUTPUT TO LPT
*
PAPER LDX #PAPER2 ; OK. SETUP FOR ECHO
PAPER1 STX CTYOUT+1
 JMP NUMSE6
*
* COMMAND TO DISCONTINUE ECHO CTY OUTPUT TO LPT
NPAPER LDX #ZPUTCH ;GET ADDRESS OF CTY OUTPUT ROUTINE
 BRA PAPER1 ; STORE IT IN ZOUTEE+1, AND DONE
*
PAPER2 JSR LPTOUT ; OUTPUT TO LPT
 JMP ZPUTCH ; AND CTY
*
* VARIABLES
*
FREADC RMB 1
HELPSP RMB 1
XHELP1 RMB 2
XHELP2 RMB 2
PPPAS RMB 1
XTEMPX RMB 2
QUIT RMB 1
IQUIT RMB 1
FCB RMB $140
RFCB RMB 9
V05F RMB 1
V060 RMB 1
V061 RMB $1F
V05B RMB $116
WFCB RMB $2A
V05C RMB $116
BEGPNT EQU *
 END ED