.TITLE	EDI02
	.PSECT EDI02							;JUL11EL
	.IDENT	/X01/							;JUL11EL
									;JUL11EL
	.ENABL LC							;JUL31EL
;
; EDITOR (TEMP FILE VERSION)
;
; VERSION X01
;
; DAVID G. CONROY	05-JAN-78
;
;
; as modified by Eric Levy
;
	.GLOBL	ACOM
	.GLOBL	CCOM
	.GLOBL	DCOM
	.GLOBL	ECOM
	.GLOBL	FCOM
	.GLOBL	GCOM
	.GLOBL	ICOM
	.GLOBL	JCOM
	.GLOBL	KCOM
	.GLOBL	MCOM
	.GLOBL	OCOM
	.GLOBL	PCOM
	.GLOBL	PCOM1
	.GLOBL	QCOM
	.GLOBL	RCOM
	.GLOBL	SCOM
	.GLOBL	UCOM
	.GLOBL	VCOM
	.GLOBL	WCOM
	.GLOBL	XCOM
	.GLOBL	ZCOM							;JUL11EL
	.GLOBL	DEFDOT							;JUL11EL
									;JUL11EL
	.MCALL	CALL
	.MCALL	CALLR
	.MCALL	RETURN
	.MCALL	FDAT$R
 	.MCALL	OPEN$
	.MCALL	OPEN$W
	.MCALL	PUT$S
	.MCALL	EXIT$S
									;JUL11EL
	.MACRO POP A							;JUL11EL
	MOV (SP)+,A							;JUL11EL
	.ENDM								;JUL11EL
 									;JUL11EL
	.MACRO PUSH A							;JUL11EL
	MOV A,-(SP)							;JUL11EL
	.ENDM								;JUL11EL
									;JUL11EL
									;JUL11EL
;									;JUL11EL
; LOCAL DATA								;JUL11EL
;									;JUL11EL
									;JUL11EL
last.s:	.word -1		;last sub's address (seek)
last.d:	.word -1		;and the dot value at the time
ABUFR:	.BLKB	100.		;TEMP FOR APPEND CMD			;JUL11EL
ABUFRE:	.BLKB	2		;END OF BUF AND SPARE FOR SAFETY.	;JUL11EL
NOTRAIL: .ASCII /P/<12>		;P AND NEWLINE				;JUL11EL
APLINE:	.ASCII	<1>/$/<1>	;CONTROL A AS A DELIMETER		;JUL11EL
INLINE:	.ASCII	<1>/^/<1>	;LIKEWISE				;JUL11EL
	.EVEN								;JUL11EL
FUDGE:	.BLKW	1		;DELTA ADDRESS FOR K
VFLAG:	.BLKW	1		;GLOBAL/EXCLUDE FLAG
SANY:	.BLKW	1		;ANYTHING AT ALL FOR SUBSTITUTE
FP:	.BLKW	1		;FILE I/O POINTER
SFLAG:	.BLKW	1		;ONCE FLAG FOR SUBSTITUTE
FC:	.BLKW	1		;RECORD COUNT
SNUM:	.BLKW	1		;NUMBER IN S#
SWNUM:	.BLKW	1		;PER LINE COPY OF SNUM
P1FLAG:	.WORD	0		;MARK ON LINE PRINT			;JUL11EL
									;JUL11EL
;+
; ** COMMAND PROCESSORS
;
; THESE ROUTINES ARE CALLED BY THE COMMAND DISPATCHER TO EXECUTE THE
; USER'S COMMANDS. THEY EITHER RETURN TO THE DISPATCHER SUCCESSFULLY
; OR JUMP DIRECTLY TO ERROR.
;-
									;JUL11EL
;
; APPEND
;

ACOM:									;JUL11EL
	CALL	DEFDOT		;DEFAULTS				;JUL11EL
	CALL GETC		;ANY THING ON THE LINE			;JUL11EL
	CMP R0,#NL		;NOT IF NL				;JUL11EL
	BEQ 10$			;SO CONTINUE AS USUAL			;JUL11EL
	MOV R0,PEEK		;PUT IT BACK FOR LATER			;JUL11EL
	MOV #APLINE,R0		;ELSE CONSTRUCT A SUB CMD		;JUL11EL
	CALLR ONLINE		;AND GO DO IT.				;JUL11EL
10$:	CLR	OLDCMD		;CLEAR COMMAND ON LINE FLAG		;JUL11EL
	MOV	#GETTY,R4	;ROUTINE				;JUL11EL
	MOV	ADR2,R5		;WHERE TO APPEND			;JUL11EL
	CALLR	APPEND		;GO APPEND				;JUL11EL
;									;JUL11EL
; ONLINE -- ON LINE APPEND OR INSERT, CONSTRUCT THE SUB COMMAND.	;JUL11EL
;           R0=ADDR OF STRING TO PUT BACK				;JUL11EL
;	       THE LENGTH IS 3. USED ONLY BY INSERT AND APPEND		;JUL11EL
;									;JUL11EL
ONLINE:									;JUL11EL
	MOV #ABUFR,R1		;ADDR OF TEMP BUFFER			;JUL11EL
	MOVB (R0)+,(R1)+	;MOVE A CHAR				;JUL11EL
	MOVB (R0)+,(R1)+	;MOVE A CHAR				;JUL11EL
	MOVB (R0)+,(R1)+	;MOVE A CHAR				;JUL11EL
15$:									;JUL11EL
	PUSH R1								;JUL11EL
	CALL GETC							;JUL11EL
	POP R1								;JUL11EL
	MOVB R0,(R1)+		;MOVE USER STRING TO TEMP BUFFER TOO.	;JUL11EL
	CMP R0,#EOF		;TEST FOR GLOBAL EOF			;JUL11EL
	BNE 16$			;SKIP IF NOT				;JUL11EL
	MOV #NL,R0		;ELSE USE NL				;JUL11EL
16$:	CMP R0,#NL		;LAST CHAR TO MOVE?			;JUL11EL
	BEQ 17$			;YEP IF EQ				;JUL11EL
	CMP R1,#ABUFRE		;TOO LONG A STRING TO FIT IN TEMP BUFF?	;JUL11EL
	BHI 20$			;YES IF HI				;JUL11EL
	BR 15$			;ELSE BACK FOR MORE			;JUL11EL
17$:									;JUL11EL
	SUB #ABUFR,R1		;COMPUTE LENGTH OF LINE			;JUL11EL
	MOV #ABUFR,R0		;SET UP PUTBACK PARMS			;JUL11EL
	CALL PUTBAK							;JUL11EL
	CALLR SCOM		;NOW GO DO THE SUB CMD			;JUL11EL
20$:	CLR R1			;ERROR 0				;JUL11EL
	JMP ERROR							;JUL11EL
;									;JUL11EL
; PUTR0 -- PUTBACK R0							;JUL11EL
;									;JUL11EL
PUTR0:									;JUL11EL
	PUSH R1								;JUL11EL
	PUSH R0								;JUL11EL
	MOV SP,R0		;ADDRESS OF THE CHAR			;JUL11EL
	MOV #1,R1		;LENGTH					;JUL11EL
	CALL PUTBAK		;GO DO IT				;JUL11EL
	POP R0								;JUL11EL
	POP R1								;JUL11EL
	RETURN								;JUL11EL
									;JUL11EL
									;JUL11EL
;
; CHANGE
;

CCOM:	CALL	NONZER		;DEFAULTS
	CALL	TDELIM		;
	CLR	OLDCMD		;CLEAR COMMAND ON LINE FLAG
	CALL	DELETE		;MAKE TEXT GO AWAY
	MOV	#GETTY,R4	;ROUTINE
	MOV	ADR1,R5		;APPEND PLACE
	TST	-(R5)		;
	CALLR	APPEND		;
									;JUL11EL
;
; DELETE
;

DCOM:	CALL	NONZER		;DEFAULTS
	CALLR	DELETE		;
									;JUL11EL
;
; EDIT
;

ECOM:	CALL	NOADDR		;NO ADDRESS IS LEGAL
	MOV	ZERO,DOL	;CLEAR TEXT
	MOV	ZERO,DOT	;
	CLR	TPTR		;START AT TEMPFILE BLOCK 0
	MOV	ZERO,R5		;READ IN STUFF FROM FILE
	CALL FILE
	CALL SAVEFN	;SAVE THE NAME IF SYNTAX OK
	CALL READN2	;GO DO THE INPUT NOW
	MOV ZERO,DOT		;GO TO LINE 1				;JUL11EL
	ADD #2,DOT							;JUL11EL
	CMP DOT,DOL		;MAKE SURE NOT ZERO FILE		;JUL11EL
	BLOS 10$							;JUL11EL
	MOV DOL,DOT		;IF SO, SET DOL TO DOT			;JUL11EL
10$:									;JUL11EL
	RETURN
									;JUL11EL
;
; FACTS
;

FCOM:	CALL	NOADDR		;NO ADDRESS IS ALLOWED
10$:	CALL	GETC		;SKIP OVER BLANKS
	CMP	R0,#' 		;
	BEQ	10$		;
	CMP	R0,#NL		;BR IF NO FILENAME
	BEQ	50$		;
	CMP	R0,#EOF		;
	BEQ	50$		;
	MOV	#SFN,R1		;GET POINTER TO SAVE FILE BUFFER
20$:	CMP	R1,#SFN+FNS-1	;DOES IT FIT
	BHIS	30$		;NO, IGNORE
	MOVB	R0,(R1)+	;SAVE THE CHARACTER
30$:	CALL	GETC		;CONTINUE TILL NEWLINE
	CMP	R0,#NL		;
	BEQ	40$		;
	CMP	R0,#EOF		;
	BNE	20$		;
40$:	CLRB	(R1)		;THEN APPEND A NULL
50$:	TSTB	SFN		;IS THERE A FILE NAME
	BEQ	80$		;NO
	MOV	#SFN,R1		;YES, POINT AT IT
60$:	MOVB	(R1)+,R0	;PRINT TILL THE NULL
	BEQ	70$		;
	CALL	TTYC		;
	BR	60$		;
70$:	CALL	TTYNL		;APPEND A NEWLINE, AND
80$:	RETURN			;DONE
									;JUL11EL
;
; GLOBAL
; EXCLUDE
;

GCOM:	CLR	VFLAG		;GLOBAL
	BR	GV		;
									;JUL11EL
VCOM:	MOV	#1,VFLAG	;EXCLUDE
GV:	CALL	DEFALL		;DEFAULT TO 1,$
	TST	GUPTR		;IN A GLOBAL
	BEQ	20$		;NO
	MOV	#9.,R1		;CANNOT NEST GLOBALS
	JMP	ERROR		;
									;JUL11EL
20$:	CALL	GETC		;GET PATTERN				;JUL11EL
	CALL	COMPIL		;					;JUL11EL
									;JUL11EL
;
; MARK ALL LINES FOR WHICH THE COMMAND LINE
; WILL BE EXECUTED.
;

	MOV	ZERO,R1		;MARK THE LINES
30$:	TST	(R1)+		;
	CMP	R1,DOL		;SEE IF DONE
	BHI	60$		;YES
	BIC	#1,(R1)		;REMOVE OLD MARK
	CMP	R1,ADR1		;DUCK OUT IF NOT IN RANGE
	BLO	30$		;
	CMP	R1,ADR2		;
	BHI	30$		;
	MOV	(R1),R0		;MATCH HERE
	CALL	GETLIN		;
	MOV	#LBUF1,R0	;
	CALL	AMATCH		;
	BCS	40$		;BR IF NOT
	TST	VFLAG		;MARK LINE IF GLOBAL
	BNE	30$		;
	INC	(R1)		;
	BR	30$		;
40$:	TST	VFLAG		;NO MATCH, MARK IF EXCLUDE
	BEQ	30$		;
	INC	(R1)		;
	BR	30$		;
									;JUL11EL
;
; COLLECT UP COMMAND LINE
;

60$:	MOV	#GUBUF,R1	;COLLECT UP THE LINE
70$:	CALL	GETC		;UNTIL NEWLINE
	CMP	R0,#'\		;ESCAPE
	BNE	72$		;NO
	CALL	GETC		;GET ACTUAL CHARACTER
	BR	74$		;
72$:	CMP	R0,#NL		;
	BEQ	80$		;
74$:	CMP	R1,#GUBUF+GUBS-1;GIVE ?0 IF THE LINE IS TOO LONG
	BHIS	90$		;
	MOVB	R0,(R1)+	;
	BR	70$		;
									;JUL11EL
;
; SET GLOBAL I/O
; RETURN TO COMMAND SCANNER
;

80$:	CLRB	(R1)		;MARK END
	MOV	R1,GUPTR	;WILL GET EOF IMMEDIATELY
	RETURN			;
									;JUL11EL
90$:	CLR	R1		;?0					;JUL11EL
	JMP	ERROR		;					;JUL11EL
									;JUL11EL
;
; INSERT
;

ICOM:									;JUL11EL
	CALL GETC		;SEE IF ANYTHING ON LINE		;JUL11EL
	CMP R0,#NL		;IS IT A NEW LINE			;JUL11EL
	BEQ 5$			;IF IT IS, CONTINUE AS USUAL		;JUL11EL
	MOV R0,PEEK		;PUT IT BACK FOR LATER			;JUL11EL
	MOV #INLINE,R0		;ELSE MAKE UP A SUB CMD			;JUL11EL
	CALLR ONLINE		;GO DO IT				;JUL11EL
5$:	MOV R0,PEEK		;PUT BACK THE TERMINATOR		;JUL11EL
	CMP	ZERO,DOL	;EMPTY BUFFER				;JUL11EL
	BNE	10$		;NO
	MOV	ZERO,ADR2	;ITS JUST A 0A
	BR	20$		;
10$:	CALL	NONZER		;DEFAULTS
	SUB	#2,ADR2		;
20$:	CALL	TDELIM		;
	CLR	OLDCMD		;CLEAR OLD COMMAND FLAG
	MOV	#GETTY,R4	;ROUTINE
	MOV	ADR2,R5		;INSERT TEXT
	CALLR	APPEND		;
									;JUL11EL
;
; COPY (KOPY)
;

KCOM:	CALL	NONZER		;DEFAULTS
	CALL	ADDRES		;GET THE COPY DESTINATION
	MOV	R0,PEEK		;PUT THE DELIMITER BACK
	TST	R2		;MUST GET AN ADDRESS
	BEQ	20$		;OR ?9
	CLR	FUDGE		;ADDRESS ADJUSTMENT FUDGE
	CMP	R2,ADR2		;EASY
	BHIS	10$		;YES					;JUL11EL
	CMP	R2,ADR1		;IMBEDDED
	BHIS	20$		;YES, ?9
	MOV	#2,FUDGE	;MUST FUDGE ADDRESSES
10$:	MOV	#30$,R4		;GET ROUTINE
	MOV	R2,R5		;APPEND PLACE
	CALLR	APPEND		;APPEND TEXT AND RETURN
20$:	MOV	#9.,R1		;?9
	JMP	ERROR		;
									;JUL11EL
30$:	CMP	ADR1,ADR2	;ANY MORE
	BHI	40$		;NO
	MOV	ADR1,R1		;GET SOURCE
	ADD	#2,ADR1		;FIX
	ADD	FUDGE,ADR1	;THE
	ADD	FUDGE,ADR2	;ADDRESSES
	MOV	(R1),R0		;PICK UP SEEK ADDRESS
	CALL	GETLIN		;PULL LINE
	CLC			;GOT ONE
	RETURN			;

40$:	SEC			;NO MORE LINES
	RETURN			;
									;JUL11EL
;
; MOVE
;

MCOM:	CALL	NONZER		;CHECK OUT ADDRESES
	CALL	ADDRES		;GET WHERE TO MOVE TO
	MOV	R0,PEEK		;
	TST	R2		;MUST GET ONE
	BEQ	50$		;
									;JUL11EL
	CMP	R2,ADR2		;MOVING UP
	BHI	10$		;BR IF YES
	CMP	R2,ADR1		;MOVING INTO THE MIDDLE
	BHIS	50$		;NOT LEGAL
									;JUL11EL
	MOV	R2,R1		;SET UP FOR THE MOVE
	TST	(R1)+		;
	MOV	ADR2,R2		;
	MOV	ADR1,R5		;
	MOV	ADR2,DOT	;RESET CURRENT LINE
	SUB	R5,DOT		;
	ADD	R1,DOT		;
									;JUL11EL
	CMP	R5,R1		;QUICK CHECK FOR NO WORK
	BEQ	40$		;EXIT
	TST	-(R5)		;
	BR	20$		;GO DO THE MOVE
									;JUL11EL
10$:	MOV	ADR1,R1		;UPWARDS MOVE				;JUL11EL
	MOV	ADR2,R5		;					;JUL11EL
	MOV	R2,DOT		;RESET CURRENT LINE			;JUL11EL
									;JUL11EL
20$:	MOV	R5,R3		;DO THE MOVE
	TST	(R3)+		;
	MOV	R3,R4		;
	TST	(R4)+		;
	MOV	(R3),R0		;SAVE BOUNDRY
30$:	MOV	-(R3),-(R4)	;MOVE
	CMP	R3,R1		;
	BHI	30$		;
	MOV	R0,(R3)		;PUT DOWN THE BOUNDRY LINE
	TST	(R1)+		;MOVE FORWARD
	TST	(R5)+		;
	CMP	R5,R2		;DONE
	BLO	20$		;NO
40$:	RETURN			;DONE
									;JUL11EL
50$:	MOV	#9.,R1		;?9 FOR FUNNY STUFF			;JUL11EL
	JMP	ERROR		;					;JUL11EL
									;JUL11EL
;
; OPTIONS
;

OCOM:	CALL	NOADDR		;NO ADDRESS FOR OPTIONS COMMAND

10$:	CALL	GETC		;GET OPTION CHARACTER
	CMP	R0,#NL		;NEWLINE
	BEQ	60$		;YES, DONE
	CMP R0,#'?		;PRINT TEMP FILE POINTER VALUE
	BNE 15$			;NOPE
	MOV $TPTR,R1		;GET IT
	CALL TTYNUM		;PRINT IT
	CALL TTYNL		;AND A NEWLINE
	BR 10$			;THATS ALL

15$:	BIC	#' ,R0		;FORCE UPPER CASE
	CMP	R0,#'T		;OT
	BNE	20$		;NO
	CLR	OV		;CLEAR OPTIONS VERBOSE
	BR	10$		;

20$:	CMP	R0,#'V		;OV
	BNE	30$		;NO
	INC	OV		;SET OPTIONS VERBOSE
	BR	10$		;

30$:	CMP	R0,#'S		;OS
	BNE	40$		;NO
	INC	OS		;SET OPTIONS SENSITIVE
	CALL	REKILL		;KILL OFF SAVED R.E.
	BR	10$		;

40$:	CMP	R0,#'I		;OI
	BNE	45$		;NO
	CLR	OS		;SET OPTIONS INSENSITIVE
	BR	10$		;NEXT OPTION				;JUL11EL
45$:	CMP R0,#'E		;EDI OPTION				;JUL11EL
	BNE 48$								;JUL11EL
	TST OE			;ALLREADY DID IT?			;JUL11EL
	BLT 47$			;YES IF LT, SO NO NEED TO DO AGAIN	;JUL11EL
	DEC OE			;ELSE SET FLAG				;JUL11EL
	MOV S100,-(SP)							;JUL11EL
	MOV C100,S100		;SWAP C AND S COMMANDS			;JUL11EL
	MOV (SP)+,C100							;JUL11EL
47$:									;JUL11EL
	BR	10$		;					;JUL11EL
									;JUL11EL
48$:	CMP R0,#'F		;OFF LINE NUM OPTION?			;JUL11EL
	BNE 49$								;JUL11EL
	CLR ONUM		;ELSE TURN OFF OPTION			;JUL11EL
	BR 10$								;JUL11EL
49$:	CMP R0,#'N		;ON LINE NUM OPT			;JUL11EL
	BNE 50$								;JUL11EL
	MOV #-1,ONUM		;TURN ON OPTION				;JUL11EL
	BR 10$								;JUL11EL
50$:	MOV	#9.,R1		;?9 IF BAD OPTION			;JUL11EL
	JMP	ERROR		;					;JUL11EL
									;JUL11EL
60$:	MOV #NL,PEEK			;DONE				;JUL11EL
	RETURN								;JUL11EL

;
; PRINT
;

PCOM:	CALL	NONZER		;DEFAULTS
PCOM1:	MOV	ADR1,R1		;GET POINTER TO
	MOV	(R1),R0		;TEXT
	CALL	GETLIN		;
	TST ONUM		;LINE NUM OPTION?			;JUL11EL
	BEQ 10$			;NOT IF ZERO				;JUL11EL
	PUSH R0			;PLAY IT SAFE				;JUL11EL
	PUSH R1								;JUL11EL
	MOV ADR1,R1		;GET THIS LINE #			;JUL11EL
	SUB ZERO,R1		;COMPUTE ACTUAL LINE #			;JUL11EL
	ASR R1								;JUL11EL
	CALL TTYNUM		;OUTPUT LINE #				;JUL11EL
	MOV #'),R0		;MAKE LISTING NICE			;JUL11EL
	CALL TTYC		;OUTPUT ) AND TAB			;JUL11EL
	CMP ADR1,DOT							;JUL11EL
	BNE 5$			;SEE IF WE CAN MARK LINE 'DOT'		;JUL11EL
	TST P1FLAG		;BUT ONLY IF FROM THE Z COMMAND		;JUL11EL
	BEQ 5$								;JUL11EL
	MOV #'-,R0		; 					;JUL11EL
	CALL TTYC							;JUL11EL
	MOV #'-,R0		;MARK WITH -- 				;JUL11EL
	CALL TTYC							;JUL11EL
5$:	MOV #11,R0		; A TAB					;JUL11EL
	CALL TTYC		;TYPE IT OUT				;JUL11EL
	POP R1								;JUL11EL
	POP R0								;JUL11EL
10$:									;JUL11EL
	MOV	#LBUF1,R0	;PUT OUT TO THE TTY
	CALL	TTYSTR		;
	ADD	#2,ADR1		;GET NEXT LINE
	CMP	ADR1,ADR2	;
	BLOS	PCOM1		;STILL MORE TO DO
	MOV	ADR2,DOT	;RESET CURRENT LINE
	RETURN			;
									;JUL11EL
;
; QUIT
;

QCOM:	TST WDONE		;DID HE W YET
	BEQ NOTYET
	CALL	NOADDR		;NO ADDRESS ALLOWED
	EXIT$S			;
NOTYET: INC WDONE		;IF HE WANTS, HE MAY RE-ISSUE Q.
	MOV #13.,R1		;DID NOT WRITE YET ERROR.
	JMP ERROR
									;JUL11EL
;
; READ
;

RCOM:	CALL	DEFDOT		;DEFAULTS
	MOV	ADR2,R5		;READ STUFF FROM FILE
	CALL	READIN		;
	TSTB	SFN		;IF NO SAVED NAME
	BNE	10$		;THEN
	CALL	SAVEFN		;SAVE THE NAME
10$:	RETURN			;
									;JUL11EL
;
; SUBSTITUTE
;

SCOM:	CALL	NONZER		;DEFAULTS
									;JUL11EL
;	CLR	SNUM		;SET WHICH ONE TO DO
	MOV #1,SNUM		;USE DEFAULT OF 1
	CALL	GETC		;ZERO MEANS ALL
	CMP	R0,#'0		;
	BLO	10$		;
	CMP	R0,#'9		;
	BHI	10$		;
	CALL	GETNUM		;
	MOV	R1,SNUM		;
	CALL	GETC		;
									;JUL11EL
10$:	MOV	R0,R2		;SAVE R.E. DELIMITER			;JUL11EL
	CALL	COMPIL		;THE PATTERN				;JUL11EL
									;JUL11EL
;
; COPY RHS TO BUFFER 2.
;

	MOV	#LBUF2,R1	;COPY OVER R.H.S.
20$:	CALL	GETC		;GET CHARACTER
	CMP	R0,#NL		;ERROR FOR NEWLINE
	BEQ	37$		;
	CMP	R0,#EOF		;OR GLOBAL EOF
	BEQ	37$		;					;JUL11EL
	CMP	R0,#'\		;ESCAPE
	BNE	30$		;NO
	CALL	RSTORE		;SAVE THE ESCAPE
	CALL	GETC		;GET THE ACTUAL CHARACTER
	CMP	R0,#EOF		;CANNOT BE GLOBAL EOF
	BEQ	35$		;
	CALL	RSTORE		;
	BR	20$		;
									;JUL11EL
30$:	CMP	R0,R2		;END OF R.H.S.
	BEQ	40$		;YES
	CALL	RSTORE		;SAVE THE CHARACTER
	BR	20$		;
									;JUL11EL
35$:	MOV	#9.,R1		;?9 IS HERE SO IT REACHES		;JUL11EL
	JMP	ERROR		;					;JUL11EL
37$:									;JUL11EL
	PUSH R0			;PUT BACK THE P AND <NL>		;JUL11EL
	PUSH R1								;JUL11EL
	MOV #NOTRAIL,R0		;ADDR OF PUTBACK STRING			;JUL11EL
	MOV #2,R1			;LEN OF PUTBACK STRING		;JUL11EL
	CALL PUTBAK							;JUL11EL
	POP R1								;JUL11EL
	POP R0								;JUL11EL
;	BR 40$			;CONTINUE				;JUL11EL
									;JUL11EL
40$:
	push r0
	call getc	;SEE IF NEXt char is a g
	mov r0,peek	;put back if its not
	bic #40,r0	;map to upper
	cmp r0,#'G	;is it a global substitute the old way
	bne 44$		;not if ne
	clr snum	;else make it global
	mov #-1,peek	;and kill the putback
44$:	pop r0
	CLRB	(R1)		;PUT NULL ON R.H.S. END			;JUL11EL
	CLR	SANY		;SET NO MATCHES AT ALL			;JUL11EL
									;JUL11EL
;
; TOP OF THE ONCE PER LINE LOOP.
;

50$:	MOV	SNUM,SWNUM	;RESET SOME VARIABLES
	CLR	SFLAG		;
	MOV	@ADR1,R0	;GET SOURCE LINE
	CALL	GETLIN		;
	MOV	#LBUF1,R2	;POINT AT ORIGINAL TEXT
	MOV	R2,ORG		;FOR MATCH
	MOV	#PBUF,R1	;FOR MATCH
	MOV	#LBUF3,R3	;DESTINATION POINTER
									;JUL11EL
;
; TOP OF THE NEXT MATCH LOOP.
;

60$:	TSTB	(R2)		;ANY MORE
	BEQ	160$		;NO
	MOV	R2,R0		;TRY FOR A MATCH
	CALL	MATCH		;
	BCS	85$		;NO
									;JUL11EL
	TST	SNUM		;DO THEM ALL
	BEQ	80$		;YES
	DEC	SWNUM		;NO, DO THIS ONE
	BNE	85$		;BR IF NO
80$:	CMP	R0,R2		;IS THIS A ZERO LENGTH MATCH
	BNE	90$		;NO
	TST	SFLAG		;DO IT
	BEQ	90$		;BR IF YES
									;JUL11EL
85$:	MOVB	(R2)+,R5	;JUST MOVE ALONG			;JUL11EL
	CALL	SSTORE		;					;JUL11EL
	BR	60$		;					;JUL11EL
									;JUL11EL
90$:	MOV	#LBUF2,R4	;GET POINTER TO R.H.S.
100$:	MOVB	(R4)+,R5	;PICK UP CHARACTER
	BEQ	150$		;DONE
	CMP	R5,#'\		;ESCAPE
	BNE	110$		;NO
	MOVB	(R4)+,R5	;MOVE NEXT CHARACTER
	BR	140$		;
									;JUL11EL
110$:	CMP	R5,#'&		;REPLACE TEXT
	BNE	140$		;NO
	MOV	R4,-(SP)	;SAVE R.H.S. POINTER
	MOV	R2,R4		;GET POINTER TO WHAT GOT MATCHES
120$:	CMP	R4,R0		;COPY OVER
	BHIS	130$		;
	MOVB	(R4)+,R5	;
	CALL	SSTORE		;
	BR	120$		;
130$:	MOV	(SP)+,R4	;RESTORE R.H.S.
	BR	100$		;
									;JUL11EL
140$:	CALL	SSTORE		;STORE DOWN THE CHARACTER		;JUL11EL
	BR	100$		;					;JUL11EL
									;JUL11EL
150$:	INC	SFLAG		;SET WE DID ONE
	INC	SANY		;SET WE DID ONE AT ALL
	MOV	R0,R2		;MOVE ALONG
	BR	60$		;
									;JUL11EL
;
; END OF LINE.
;

160$:	TST	SFLAG		;ANY CHANGES ON THIS LINE
	BEQ	165$		;NO, GO ON
									;JUL11EL
	CLR	R5		;APPEND A NULL
	CALL	SSTORE		;

	MOV	#LBUF1,R0	;COPY BUF3 TO BUF1
	MOV	#LBUF3,R1	;
162$:	MOVB	(R1)+,(R0)+	;
	BNE	162$		;

	CALL	PUTLIN		;WRITE NEW LINE TO TEMPFILE
	mov @adr1,last.s	;save for the undo command
	MOV	R0,@ADR1	;AND UPDATE THE POINTER TO IT
	MOV	ADR1,DOT	;MOVE DOT TO LAST LINE CHANGED
	mov dot,last.d		;save dot too
									;JUL11EL
;
; ADVANCE TO NEXT LINE.
;

165$:	ADD	#2,ADR1		;ANY MORE
	CMP	ADR1,ADR2	;
	BHI	170$		;NO
	JMP	50$		;GO DO ANOTHER LINE
									;JUL11EL
170$:	TST	GUPTR		;IN A GLOBAL
	BNE	180$		;YES
	TST	SANY		;NO, DID ANYTHING CHANGE
	BNE	180$		;YES, OK
	MOV	#1,R1		;?1
	JMP	ERROR		;
									;JUL11EL
180$:	RETURN			;DONE					;JUL11EL
;
; undo
;
ucom:
	call noaddr	;no addresses
	cmp last.s,#-1		;is it setup yet
	beq 10$		;skip if not
	cmp dot,last.d	;compare dot's
	bne 10$
	mov last.s,@dot	;restore it
	return
10$:	mov #4.,r1
	jmp error	;bad address error is good enuf

									;JUL11EL
;
; WRITE
; JOIN
; NEW VERSION (X COMMAND)
;
	.ENABL LSB
XCOM:	INC WDONE		;INDICATE DONE
	MOV #FO.WRT,R5		;FOR WRITE NEW FILE
	CALL DEFALL		;DEF TO ENT FILE NAME
	CALL FILE		;GET NAME
	OPEN$ #FDB,R5		;OPEN WITH NEW VERSION
	BCC W5$			;IF NO ERROR FINISH UP IN "W" CODE
	MOV #8.,R1		;ELSE OPEN ERROR
	JMP ERROR

WCOM:	MOV	#FO.UPD,R5	;WRITE, FIRST TEST IS UPDATE
	INC WDONE		;INDICATE A WRITE HAS BEEN DONE
	BR	WJ		;

JCOM:	MOV	#FO.APD,R5	;JOIN, FIRST TEST IS APPEND

WJ:	CALL	DEFALL		;DEFAULT TO ENTIRE FILE
	CALL	FILE		;GET THE FILE NAME
	OPEN$	#FDB,R5		;TRY TO OPEN THE FILE
	BCC	10$		;OK
	CMPB	F.ERR(R0),#IE.NSF ;IS THE ERROR NO FILE
	BNE	60$		;NO, HARD ERROR
	OPEN$W			;OPEN FOR PLAIN WRITING
	BCS	60$		;ERROR
									;JUL11EL
W5$:				;ENTRY FOR X COMMAND
10$:	FDAT$R	,#R.VAR,#FD.CR	;MAKE SURE ATTRIBUTES ARE OK
	CLR	FC		;RECORD COUNT
	MOV	#LBUF2,FP	;WORK POINTER
									;JUL11EL
20$:	MOV	@ADR1,R0	;GET ADDRESS OF LINE			;JUL11EL
	CALL	GETLIN		;GET TEXT				;JUL11EL
	MOV	#LBUF1,R2	;					;JUL11EL
									;JUL11EL
30$:	MOVB	(R2)+,R0	;PUT OUT ALL THE CHARACTERS
	BEQ	40$		;
	CALL	70$		;
	BR	30$		;
									;JUL11EL
40$:	ADD	#2,ADR1		;BUMP TO NEXT LINE			;JUL11EL
	CMP	ADR1,ADR2	;DONE					;JUL11EL
	BLOS	20$		;BR IF NOT				;JUL11EL
									;JUL11EL
	MOV	#FDB,R0		;CLOSE FILE WITH TRUNCATION		;JUL11EL
	CALL	.TRNCL		;					;JUL11EL
									;JUL11EL
	TST	GUPTR		;IN GLOBAL
	BNE	50$		;YES
	MOV	FC,R1		;PUT OUT THE COUNT
	CALL	TTYNUM		;
	CALL	TTYNL		;
									;JUL11EL
50$:	TSTB	SFN		;IS THERE A SAVED NAME
	BNE	55$		;YES
	CALL	SAVEFN		;NO, SAVE THE NAME
55$:	RETURN			;
									;JUL11EL
60$:	MOV	#8.,R1		;FILE OPEN ERROR			;JUL11EL
	JMP	ERROR		;					;JUL11EL
									;JUL11EL
70$:	CMP	R0,#NL		;NEWLINE
	BEQ	80$		;YES
	CMP	FP,#LBUF2+LBS	;NO, DOES IT FIT
	BHIS	100$		;NO  ?10
	MOVB	R0,@FP		;PUT IN THE BUFFER
	INC	FP		;
	BR	90$		;
									;JUL11EL
80$:	MOV	FP,R1		;COMPUTE RECORD SIZE
	SUB	#LBUF2,R1	;
	PUT$S	#FDB,#LBUF2,R1	;PUT OUT THE RECORD
	BCS	100$		;ERROR
	INC	FC		;COUNT UP 1 RECORD
	MOV	#LBUF2,FP	;BACK UP POINTER
									;JUL11EL
90$:	RETURN			;DONE					;JUL11EL
									;JUL11EL
100$:	CALL	.TRNCL		;ERROR, CLOSE THE FILE
	MOV	#10.,R1		;?10
	JMP	ERROR		;
	.DSABL LSB
									;JUL11EL
;+									;JUL11EL
;									;JUL11EL
; ** ZCOM    Z COMMAND							;JUL11EL
;									;JUL11EL
;-									;JUL11EL
ZCOM:	CALL DEFDOT		;DEFAULT TO DOT				;JUL11EL
	MOV ADR2,ADR1		;USE ONLY ONE ADDRESS			;JUL11EL
	CALL GETC		;NEXT CHAR->R1				;JUL11EL
	CMP #'+,R0		;Z+N?					;JUL11EL
	BNE 20$								;JUL11EL
	CALL NCHK		;R1 = NUMBER OR 20 (DEF)		;JUL11EL
	ADD R1,ADR2		;LIST DOWN PART				;JUL11EL
	BR 50$								;JUL11EL
20$:	CMP #'-,R0		;Z-N					;JUL11EL
	BNE 30$								;JUL11EL
	CALL NCHK							;JUL11EL
	SUB R1,ADR1		;BACKWARD LIST				;JUL11EL
	BR 50$								;JUL11EL
30$:									;JUL31EL
	CMP #'Z,R0							;JUL31EL
	BEQ 32$								;JUL31EL
	CMP #'z,R0							;JUL31EL
	BEQ 32$
	BR 33$								;JUL31EL
32$:									;JUL31EL
	MOV #4000.,R1							;JUL31EL
	BR 40$								;JUL31EL
33$:	CALL NCHK1		;DON'T GET CHAR, ALLREADY HAVE IT	;JUL31EL
	ASR R1
	BIC #1,R1		;MUST BE EVEN				;JUL11EL
40$:	ADD R1,ADR2							;JUL11EL
	SUB R1,ADR1							;JUL11EL
50$:									;JUL11EL
	CMP ADR2,DOL		;CHECK ADR1,2 RANGE			;JUL11EL
	BLOS 55$							;JUL11EL
	MOV DOL,ADR2		;DON'T GO PAST END			;JUL11EL
55$:									;JUL11EL
	CMP ADR1,ZERO							;JUL11EL
	BHI 60$								;JUL11EL
	MOV ZERO,ADR1							;JUL11EL
	ADD #2,ADR1							;JUL11EL
60$:									;JUL11EL
	PUSH DOT							;JUL11EL
	MOV #-1,P1FLAG		;LET IT MARK WHERE WE ARE		;JUL11EL
	CMP ADR1,ADR2		;CHECK FOR NULL BUFFER
	BHI 65$			;THIS FIXES THE ZZ + Z HANG PROBLEM
	CALL PCOM1		;LIST IT				;JUL11EL
65$:	CLR P1FLAG		;BUT NO MORE				;JUL11EL
	POP DOT								;JUL11EL
	RETURN								;JUL11EL
									;JUL11EL
									;JUL11EL
NCHK:	CALL GETC		;GET CHAR				;JUL11EL
NCHK1:	CMP R0,#NL		;END OF LINE				;JUL11EL
	BNE 10$								;JUL11EL
	MOV #40.,R1		;USE DEFAULT				;JUL11EL
	MOV R0,PEEK		;PUT BACK TERMINATOR			;JUL11EL
	RETURN								;JUL11EL
10$:									;JUL11EL
	CMP R0,#'0		;MAKE SURE ITS A NUMBER			;JUL11EL
	BLO 20$								;JUL11EL
	CMP R0,#'9							;JUL11EL
	BHI 20$								;JUL11EL
	CALL GETNUM							;JUL11EL
	ASL R1			;TIMES 2				;JUL11EL
	RETURN								;JUL11EL
20$:									;JUL11EL
	MOV #14.,R1		;BAD NUM ERROR				;JUL11EL
	JMP ERROR							;JUL11EL
;+									;JUL11EL
; ** DEFDOT - DEFAULT TO .,.
; ** DEFALL - DEFAULT TO 1,$
; ** TDELIM - CHECK FOR LEGAL TEXT DELIMITER
; ** NONZER - DISALLOW LINE ZERO
; ** NOADDR - DISALLOW ANY ADDRESS
;
; THESE ROUTINES ARE USED TO VALIDATE THE ADDRESSES OF COMMANDS. ALL
; JUMP DIRECTLY TO ERROR ROUTINES IF THEY MUST.
;-
									;JUL11EL
DEFDOT:	TST	ADR2		;IS THERE AN ADDRESS
	BNE	10$		;YES
	MOV	DOT,ADR1	;SET BOTH TO DOT
	MOV	DOT,ADR2	;
10$:	RETURN			;
									;JUL11EL
TDELIM:	CALL	GETC		;GET CHARACTER
	CMP	R0,#NL		;IS IT A NEWLINE
	BEQ	10$		;YES, OK
	CMP	R0,#' 		;IS IT A BLANK
	BNE	ERR9		;NO, ERROR
10$:	RETURN			;
									;JUL11EL
NOADDR:	TST	ADR2		;ANY ADDRESS				;JUL11EL
	BNE	ERR9		;YES, ERROR				;JUL11EL
	RETURN			;					;JUL11EL
									;JUL11EL
	.ENABL	LSB							;JUL11EL
									;JUL11EL
DEFALL:	TST	ADR2		;IS THERE AN ADDRESS
	BNE	10$		;YES
	MOV	ZERO,ADR1	;SET 1
	ADD	#2,ADR1		;
	MOV	DOL,ADR2	;SET $
	BR	10$		;
									;JUL11EL
NONZER:	CALL	DEFDOT		;DEFAULT ADDRESS			;JUL11EL
									;JUL11EL
10$:	CMP	ADR1,ADR2	;CHECK FOR WRAPAROUND
	BLOS	20$		;
	MOV	#5,R1		;?5
	JMP	ERROR		;
20$:	CMP	ADR1,ZERO	;LINE ZERO
	BEQ	ERR9		;YES, ERROR
	RETURN			;
									;JUL11EL
	.DSABL	LSB							;JUL11EL
									;JUL11EL
ERR9:	MOV	#9.,R1		;?9					;JUL11EL
	JMP	ERROR		;					;JUL11EL
									;JUL11EL
;+
; ** RSTORE - STORE R.H.S. CHARACTER
; ** SSTORE - STORE RESULT CHARACTER
;
; THESE TWO SMALL ROUTINES ARE USED BY THE SUBSTITUTE COMMAND. THEY
; PROBABLY SHOULD HAVE BEEN PUT UP WITH IT.
;-
									;JUL11EL
RSTORE:	CMP	R1,#LBUF2+LBS-1	;WILL IT FIT
	BHIS	ERR0		;NO
	MOVB	R0,(R1)+	;YES
	RETURN			;
									;JUL11EL
SSTORE:	CMP	R3,#LBUF3+LBS-1	;WILL IT FIT
	BHIS	ERR0		;NO
	MOVB	R5,(R3)+	;YES
	RETURN			;
									;JUL11EL
ERR0:	CLR	R1		;?0 IF OVERFLOW				;JUL11EL
	JMP	ERROR		;					;JUL11EL
									;JUL11EL
;+
; ** SAVEFN - SAVE THE FILE NAME
;
; THIS LITTLE ROUTINE IS CALLED FROM THE R, E AND W COMMANDS TO SAVE
; THE FILE NAME (IN FN) IN THE SAVED NAME (SFN).
;
; USES:
;	R0, R1
;-

SAVEFN:	MOV	#FN,R0		;NAME
	MOV	#SFN,R1		;SAVED NAME
10$:	MOVB	(R0)+,(R1)+	;COPY
	BNE	10$		;
	RETURN			;

	.END