.MCALL	.MODULE
.MODULE	EDIT,VERSION=06,COMMENT=<Text Editor>
.MCALL	.AUDIT
.AUDIT	.EDIT,.VTBAS,.VTMAC,.VTCL1,.VTCL4

; Copyright (c) 1998 by Mentec, Inc., Nashua, NH.
; All rights reserved
;
; This software is furnished under a license for use only on a
; single computer system and  may  be  copied  only  with  the
; inclusion of the above copyright notice.  This software,  or
; any other copies thereof, may not be provided  or  otherwise
; made available to any other person except for  use  on  such
; system and to one who agrees to these license  terms.  Title
; to  and  ownership of the software shall at all times remain
; in Mentec, Inc.
;
; The information in this document is subject to change without
; notice and should not be construed as a commitment by Digital
; Equipment Corporation, or Mentec, Inc.
;
; Digital and Mentec  assume  no  responsibility for the use or
; reliability of its software on equipment which is not supplied
; by Digital  or Mentec,  and listed  in the  Software  Product
; Description.
; Edit History:
;
; 001	11-Jan-80 15:24    Gentry, Martin (70039) [240,121]
;	EB command fix (as per SPR #11-25180)
;	Also changing references to SYSCOM locations from relative
;	to absolute.
;	(001)
;	12-FEB-85	George Thissell Jr.
;	Check for date rollover
;
; 005	02-Nov-1990	JFW
;	bracket error messages in ;+/;ERROR/.../;-
;
; 006	14-Jun-1991	WFG
;	ACTION #7479, Add .AUDIT to fix RESORC display
;
	.SBTTL	EDIT HISTORY

;	RGB

;	JANUARY 1973
; MODIFIED FOR V2B BY DAVE VELTEN AND BRUCE LEAVITT (DISPLAY ADDITIONS)
; MODIFIED FOR V03 BY RGB (MINOR CORRECTIONS AND ENHANCEMENTS)
; MODIFIED FOR V3B BY RGB
;	FIX TRAP BUG IN XM
;	INCLUDE PATCH SPACE
;	ADD SET TT SCOPE SUPPORT FOR MULTI-TERM SYSTEMS
;	REWORK DISPLAY SUPPORT SO IT WORKS UNDER ALL MONITORS
;DL04	-- PURGE CHANNEL AFTER HARD ERROR WHILE ENTERING A FILE
;DL07	-- FILE PROTECTION AND ERROR LEVEL CHANGES


;
; ASSEMBLY PARAMETERS
;
; THE EDITOR SOURCE MUST BE ASSEMBLED
; WITH VTMAC, THE GRAPHICS MACRO LIBRARY. LINKING
; IS DONE WITH VTCED1, VTCED4, AND VTBEDT,
; SMALLER VERSIONS OF THE DISPLAY FILE HANDLER
; MODULES VTCAL1, VTCAL4, AND VTBASE, RESPECTIVELY.
; LINK COMMAND STRING IS:

; EDIT=VTCED1,VTCED4,VTBEDT,EDIT
;
; DISPLAY EDITOR VERSION BY D. VELTEN

; ENHANCEMENTS TO DISPLAY EDITOR BY BRUCE LEAVITT

; THE SIZE OF THE DISPLAY FILE IS DETERMINED BY THE SYMBOL DFSIZE
; IT MUST BE AT LEAST 400(8) BYTES

	DFSIZE	= 2000
	.SBTTL	DEFINITIONS

; REGISTER ASSIGNMENTS

;	R0	= %0			;USED FOR MONITOR COMMUNICATION
;	R1	= %1			;POINTS INTO COMMAND STRINGS
;	R2	= %2			;USED FOR COMMAND ARGUMENTS
;	R3	= %3			;GENERAL USAGE
;	R4	= %4			;GENERAL USAGE
	ISTACK	= %5			;USED TO STACK ITERATION BRACKET COUNT
;	SP	= %6
;	PC	= %7

	LF	= 12
	FF	= 14
	CR	= 15
	MINUS	= 55
	PLUS	= 53
	SLASH	= 57
	SPACE	= 40
	QMARK	= 77
	ZERO	= 60
	NINE	= 71
	E	= 105
	M	= 115
	ASTRSK	= 52
	EQSIGN	= 75
	RUBOUT	= 177
	CTRLC	= 03
	CTRLU	= 25
	CTRLX	= 30

; TRAP INSTRUCTION IS USED TO PRINT ERRORS

	ERROR	= 104400
	TRAPV	= 34

; MONITOR I/O MACROS

	.MCALL	.FETCH,	.LOOKU,	.ENTER
	.MCALL	.CLOSE,	.READ,	.WRITE
	.MCALL	.EXIT,	.RENAM,	.TTYIN
	.MCALL	.TTYOU,	.CSISP,	.RELEA
	.MCALL	.SETTO,	.RCTRL,	.PRINT
	.MCALL	.LOCK,	.UNLOC,	.WAIT
	.MCALL	.QSET,	.SRESE,	.PURGE
	.MCALL	.DSTAT,	.SCCA,	.GVAL
	.MCALL	.SERR,	.TTINR,	.MTSTA
	.MCALL	..V2..,	.GTIM

	..V2..

; EDIT SOURCE HAS LOWER CASE CHARS

	.ENABL LC

; RT-11 SYSCOM LOCATIONS

	JSW	= 44			;JOB STATUS WORD
		CHAIN$	= 000400 ;CHAINED-TO BIT
		TTSPC$	= 010000 ;TERMINAL SPECIAL MODE BIT
		RSTRT$	= 020000 ;PROGRAM RE-ENTER BIT
		TTLC$	= 040000 ;LOWER-CASE BIT
	UFLOAT	= 46			;USR LOAD ADDRES
	ERRBYT	= 52			;EMT ERROR BYTE
	USERRB	= 53			;USER ERROR REPORTING BYTE
		WARN$	= 000002 ;WARNING ERROR INDICATOR
		FATAL$	= 000010 ;FATAL ERROR INDICATOR
	SYSPTR	= 54			;BASE OF RESIDENT MONITOR

; RMON FIXED OFFSETS

	$USRLC	= 266			;ADDRESS OF NORMAL USR AREA
	CONFIG	= 300			;CONFIGURATION WORD
		KT11$	= 010000 ;MAPPED SYSTEM UNDER XM MONITOR
	STATWD	= 366			;INDIRECT FILE/MONITOR STATUS WORD
	SYSGEN	= 372			;SYSGEN FEATURES WORD
		MTTY$	= 020000 ;MULTI-TERMINAL SUPPORT
	.SBTTL	LOW-CORE SETUP

;ERROR TRAP VECTOR
;ERRORS CAUSE A TRAP TO THE ERROR ROUTINE WITH ERROR NUMBER
;IN RIGHTMOST BYTE OF TRAP INSTRUCTION. ERROR NUMBER IS USED
;AS AN INDEX INTO THE ERROR MESSAGE TABLE

	.ASECT

	. = TRAPV			;TRAP VECTOR
	.WORD	ERRORT			;ADDRESS OF ERROR REPORTING ROUTINE
	.WORD	0			;ERROR PRIORITY=0

;MONITOR COMMUNICATION AREA

	. = JSW
	.WORD	0			;JOB STATUS WORD

	. = UFLOAT
	.WORD	0			;SWAP ADDRESS FOR FLOATING USR
	.SBTTL	ERROR REPORTER

;ERROR REPORTING ROUTINE. TYPES OUT ERROR MESSAGE,THEN GETS NEW
;COMMAND STRING FROM USER

	.CSECT EDIT

	.GLOBL START			;MAKE STARTING ADDR SHOW UP IN MAP

ERRORT:	.UNLOC				;UNLOCK USR IN CASE IT WAS LOCKED IN
	MOV	@SP,R3			;GET PC AT TIME OF TRAP
	MOV	-(R3),R4		;GET INSTRUCTION THAT CAUSED TRAP
	BIC	#<^C377>,R4		;STRIP TO <7:0>
	ASL	R4			;CHANGE FROM WORD TO BYTE OFFSET
	JSR	PC,CRLF			;ISSUE CR,LF TO TTY
	MOV	#EDTMSG,R3		;PRINT <FACILITY><SEVERITY> PREFIX
	JSR	PC,EPRINT		;CALL TYPE ROUTINE
	MOV	ERRTAB(R4),R3		;R3-><TEXT> MESSAGE
	JSR	PC,EPRINT		;TYPE IT
	TSTB	MACFLG			;NOW, ARE WE DOING A MACRO?
	BEQ	E64$			;NOPE, FINISH ERROR MESSAGE
	MOV	#MACMSG,R3		;YES, THEN TELL THE USER SO
	JSR	PC,EPRINT		; BY PRINTING "IN MACRO" SUFFIX
E64$:	TSTB	EPFLG			;ARE WE ON ERROR PASS?
	BEQ	NOERRP			;IF NOT,DON'T MODIFY MESSAGE
	MOV	#NCMSG,R3		;YES-ADD "NO COMMANDS EXECUTED"
	JSR	PC,EPRINT		;TYPE IT
NOERRP:	JSR	PC,CRLF			;FOLLOW THE MESSAGE WITH A CRLF
	CLRB	MACFLG			;CLEAR MACRO FLAG (IN CASE ERROR
					; OCCURRED WHILE WE WERE EXECUTING
					; A MACRO
	MOV	EDSTRT,SP		;RE-INITIALIZE THE STACK
	TSTB	DSFLG			;ARE WE USING DISPLAY?
	BEQ	1$			;NO DONT REFRESH DISPLAY
	CLRB	SCFLG			;CLEAR IMMEDIATE MODE FLAG
	JSR	PC,DUPDAT		;THEN UPDATE DISPLAY
1$:	BISB	#<FATAL$>,@#USERRB	;INDICATE A FATAL ERROR
	JMP	ASTER			;GET NEW COMMAND STRING

; PATCH SPACE
;	RESERVED FOR PUBLISHED PATCHES

PATCH::	.BLKW	64.			;RESERVE 64 WORDS
	.SBTTL	VT-11 CURSOR DISPLAY FILE

;+
;
; THIS AREA MUST NOT FALL IN 4-8K OF ADDRESS SPACE, NOR MUST USR
; BE ALLOWED TO SWAP OVER IT
;
;-

CURSOR:	SHORTV!INT7!BLKON
CUR1:	15!INTX				; 15!INTX!MISVY	FOR MINUS CURSOR
	15!MISVY			; 15		FOR MINUS CURSOR
	3200!INTX
	3200!MISVX
	CHAR!INT4!BLKOFF
	DRET
	0

; EDITOR FLAGS
; FLAGS USED BY COMMAND STRING INTERPRETER LOOP
; ORDER CANNOT CHANGE WITHOUT CHANGING FLAG CLEARING
; INSTRUCTIONS IN THE COMMAND LOOP

NEGFLG:	.BYTE 0				;ARG IS NEGATIVE
SLSFLG:	.BYTE 0				;"/" HAS BEEN SEEN
SPCFLG:	.BYTE 0				;ANY SPECIAL CHARACTER HAS BEEN SEEN
NUMFLG:	.BYTE 0				;A DIGIT HAS BEEN SEEN
EQSFLG:	.BYTE 0				;"=" HAS BEEN SEEN
MACFLG:	.BYTE 0				;WE ARE CURRENTLY EXECUTING A MACRO
ALTFLG:	.BYTE 0				;ALTMODE SEEN ON INPUT
SRCFLG:	.BYTE 0				;SEARCH IN PROGRESS
EOFFLG:	.BYTE 0				;EOF HAS BEEN SEEN IN INPUT FILE
INOFLG:	.BYTE 0				;AN INPUT FILE IS OPEN
OTOFLG:	.BYTE 0				;AN OUTPUT FILE IS OPEN
EBFLG:	.BYTE 0				;EDIT BACKUP IN PROGRESS
EFFLG:	.BYTE 0				;LAST BLOCK OF FILE HAS BEEN READ
SRFLG:	.BYTE 0				;FLAG USED BY READ TO SIGNIFY AT LEAST
					; ONE NON-NULL CHAR HAS BEEN READ
EXFLG:	.BYTE 0				;EXIT IN PROGRESS
EPFLG:	.BYTE 0				;SET TO 1 WHEN COMMAND PROCESSOR
					; IS IN ERROR PASS
MINFLG:	.BYTE 0				;SET TO 1 WHEN PROCESSING A MACRO
					; DURING ERROR PASS
DELIM:	.BYTE 0				;CURRENT MACRO DELIMITER FOR
					; ERROR PASS
SCFLG:	.BYTE 0				;SET TO 1 FOR IMMEDIATE MODE
FFFLG:	.BYTE 0				;SET TO 1 WHEN OUTPUT FILE FULL
					; ERROR CONDITION DETECTED
	.EVEN

; EDITOR COUNTERS AND MISCELLANEOUS REGISTERS

HAND1N:	.WORD 0				;NAME OF DEVICE IN HANDLER AREA 1
HAND2N:	.WORD 0				;NAME OF DEVICE IN HANDLER AREA 2

MACCNT:	.WORD 0				;CURRENT MACRO EXECUTION COUNTER
PTR:	.WORD 0				;CURRENT CHARACTER POINTER
ARG:	.WORD 0				;CURRENT COMMAND ARGUMENT
MACR1:	.WORD 0				;SAVED CS POINTER DURING MACRO
					; EXECUTION
; ***** CRITICAL ORDERING *****
OBLENG:	.WORD 0				;LENGTH OF TEXT OBJECT
OBSTRT:	.WORD 0				;START OF TEXT OBJECT
					; (RELATIVE TO START OF CIB)
; ***** END CRITICAL ORDERING *****

TMP:	.WORD 0				;TEMPORARY
TMP1:	.WORD 0				;TEMPORARY
CBASE:	.WORD 0				;ADDRESS OF CURRENT COMMAND STRING
CREL:	.WORD 0				;RELATIVE COMMAND POINTER WITHIN
					; COMMAND LINE
EQLENG:	.WORD 0				;LENGTH OF LAST TEXT OBJECT FOR "="

; ALL LOCATIONS FROM NEGFLG THROUGH EQLENG ARE CLEARED ON START OR RESTART
;
; THE FOLLOWING LOCATIONS ARE SET DURING INTITIAL STARTUP CODE, THEN
; USED TO RESET APPROPRIATE THINGS ON RESTART

TRAPPS:	.WORD 0				;MASK FOR TRAP VECTOR PS WORD
OLDTOP:	.WORD 0				;TOP OF BUFFER WHEN EDIT STARTED
SCPFLG:	.BYTE 0				;SET TO 1 WHEN SET TTY SCOPE IN EFFECT
VT11OK:	.BYTE 0				;SET TO 1 IF VT11 DISPLAY FILE SET UP
DSFLG:	.BYTE 0				;SET TO 1 IF DISPLAY IS ACTIVE
FTFLG:	.BYTE 1				;CLEARED AFTER FIRST COMMAND EXECUTED
	.EVEN

; VT11 SCROLLER PARAMETERS

SCBUF:	.WORD	4			;NUMBER OF LINES
	.WORD	140			;CHANGE IN Y POS.

; PAGE BUFFER POINTERS
; DIVIDES TEXT AREA INTO FOUR BUFFERS

BEND:	.WORD	0			;END OF MACRO BUFFER
MBSTRT:	.WORD	0			;START OF MACRO BUFFER
SBSTRT:	.WORD	0			;START OF SAVE BUFFER
CBEND:	.WORD	0			;END OF COMMAND BUFFER
CBSTRT:	.WORD	0			;START OF COMMAND BUFFER
PBSTRT:	.WORD	0			;START OF PAGE BUFFER

; LOAD MODULE UPPER AND LOWER BOUNDS
; USED TO ESTABLISH STACK AND DYNAMIC AREA START

EDSTRT:	.LIMIT				;STACK START ADDR
EDTOP:	.WORD	EDEND			;START OF BUFFER AREA

; ITERATION LOOP STACK AREA

ISTCKE:	.BLKW	20.*2			;ITERATION STACK 20 2-WORD ENTRIES
ISTCKA:					;START OF STACK

; I/O POINTERS

OBPTR:	.WORD	OBUFF1			;POINTER INTO OUTPUT BUFFER
OBLKNM:	.WORD	0			;CURRENT BLOCK IN OUTPUT FILE
IBPTR:	.WORD	0			;POINTER INTO INPUT BUFFER
IBLKNM:	.WORD	0			;CURRENT BLOCK IN INPUT FILE

; V2 EMT ARGUMENT BLOCK

AREA:	.BLKW	5

; STATUS WORD FOR CTRL C EXCEPTION

CCSTAT:	.WORD	0

; I/O QUEUE AREA

IOQ:	.WORD	0
	.BLKW	3*10.			;SPACE FOR 3 ENTRIES

; DSTATUS BLOCK FOR RELEAS SUBROUTINE

CORADD:	.BLKW	4			;ARGUMENT BLOCK FOR .DSTATUS

; CSI DEFAULT EXTENSION LIST

DEFEXT:	.WORD	0,0			;NO DEFAULT EXTENSIONS, REALLY

; CSI WORKING AREA

CSIBLK:	.BLKW	39.			;CSI WORK AREA
CSISTR:	.BLKW	11.			;CSI INPUT STRING (19. CHARS
					;+ '<' PLUS NULL TERMINATOR).

; I/O FILE NAMES

FILENG:	.WORD	0			;LENGTH OF LAST FILE SPECIFIED
					; IN FNGET

; INPUT FILE SPEC

INBLK:	.RAD50	/SY /			;DEVICE (SY IS DEFAULT)
	.WORD	0			;FILE
	.WORD	0			;NAME
	.WORD	0			;TYPE

; OUTPUT FILE SPEC

OUTBLK:	.RAD50	/SY /			;DEVICE (SY IS DEFAULT)
	.WORD	0			;FILE
	.WORD	0			;NAME
	.WORD	0			;TYPE

EBBLK:	.WORD	0			;FILE BLOCK FOR EB RENAME OPERATION
	.WORD	0
	.WORD	0
	.RAD50	/BAK/

;AREA TO HOLD THE TIME ELEMENTS

DUMMY:	.BLKW	2			;EMT AREA
DUMMY2:	.BLKW	2			;HOLD THE TIME RETURNED


; I/O BUFFERS

IBUFF1:	.BLKW	256.			;INPUT BUFFER 1
IBUFF2:					;INPUT BUFFER 2

	...TPC	= .
	.SBTTL	DISPLAY FILE TEMPLATE

;+
;
; THE FOLLOWING IS THE TEMPLATE FOR THE VT11 DISPLAY FILE,
; AND ONCE-ONLY STARTUP ROUTINES USED TO START UP THE VT11 DISPLAY.
; THIS DATA AND CODE RESIDE IN THE INPUT BUFFER BECAUSE IF THEY
; WILL BE USED AT ALL, THEY WILL BE USED EITHER DURING EDITOR
; INITIALIZATION OR THE ED COMMAND,WHICH MUST BE THE FIRST COMMAND.
; ONCE THE ACTUAL DISPLAY FILE HAS BEEN BUILT (IN HIGH MEMORY), THIS
; STUFF IS NO LONGER NEEDED,AND THE SPACE IS USED AS PART OF THE
; INPUT BUFFER
;
;-

DSFILE:	POINT				;DRAW LINE ABOVE SCROLL AREA
	0
	200
	LONGV!LINE3
	MAXX!INTX
	0
	POINT				;POSITION THE BEAM
	0
DSDTOP:	1350
	CHAR!INT4!BLKOFF
DTEXT:	DRET
	0
	.SBTTL	VT11 INITIALIZATION ROUTINES

;+
;
; SUBROUTINE TO SIZE SCOPE
;
;	THIS ROUTINE TESTS FOR SCOPE SIZE AND SETS THE TOP OF THE
;	BUFFER DISPLAY TO THE PROPER POSITION.
;
;-

	DPC	= 172000		;DISPLAY PROGRAM COUNTER
	DSR	= 172002		;DISPLAY STATUS REGISTER

TSTSCP:	.INSRT	#TESTF			;DISPLAY A TEST FILE
1$:	TST	@#DSR			;DISPLAY STOPPED?
	BPL	1$			;NO, KEEP TESTING
	CMP	@#DPC,#G3		;STOPPED IN RIGHT PLACE?
	BNE	1$			;NO, KEEP LOOPING
	BIT	#40,@#DSR		;EDGE FLAG SET?
	BNE	2$			;YES, 12" SCOPE
	MOV	#1750,DSDTOP		;SET TOP FOR 17" SCOPE
	MOV	#8.,SCBUF		;SET 8 LINE OF COMMANDS
	MOV	#300,SCBUF+2		;AT LOCATION 300 ON SCREEN
	MOV	#340,DSFILE+4		;POSITION LINE ABOVE COMMAND TEXT
	ADD	#5.,DSARG		;DISPLAY 30 LINES OF TEXT
2$:	MOV	#DNOP,G2		;REMOVE DISPLAY STOP
	.START				;RESTART DISPLAY
	.REMOV	#TESTF			;REMOVE TEST FILE
	RTS	PC			;THEN EXIT FOREVER

TESTF:	POINT
	500
	1350
	LONGV
	0
	400
G2:	173000				;DISPLAY STOP
G3:	DRET
	0

; SUBROUTINE TO INITIALIZE DISPLAY FUNCTIONS

INDSP:	.CLEAR				;INIT DISPLAY HANDLER
	JSR	PC,TSTSCP		;TEST FOR SCOPE SIZE
	JSR	PC,BLDDFILE		;BUILD DISPLAY FILE IN HIGH MEMORY
	JSR	PC,DSTART		;START THE DISPLAY
	RTS	PC			;RETURN

; SUBROUTINE TO CREATE ACTUAL DISPLAY FILE AT TOP OF JOB
;
;	THIS SUBROUTINE ALLOCATES A DISPLAY FILE FROM THE TOP OF THE BUFFER,
;	THEN CREATES THS INITIAL FILE FROM THE TEMPLATE. IT THEN INITIALIZES
;	THE VARIOUS DISPLAY FILE POINTERS AND RETURNS.

BLDDFILE:
	MOV	BEND,R0			;POINT R0 TO END OF BUFFER
	SUB	#DFSIZE+2,R0		;DISPLAY FILE IS DFSIZE BYTES
	CMP	R0,#40000		;WILL IT OVERFLOW TO PAR1 AREA?
	BHIS	1$			;NO-GO AHEAD AND BUILD IT
	BIT	#170000,TRAPPS		;IS XM MONITOR RUNNING?
	BEQ	2$			;BRANCH IF NOT
3$:	JMP	NOROOM			;NOT ENOUGH ROOM FOR DISPLAY EDITING

2$:	MOV	R0,R2			;SJ/FB: COPY DISPLAY FILE BOTTOM ADDR
	SUB	#2000,R2		;DISPLAY FILE MUST LEAVE AT LEAST
					; 1000 CHARS WORTH OF EDIING TO BE
					; USEFULL
	CMP	R2,CBEND		;TEXT BUFFER AT LEAST 1000 CHARS BIG?
	BLO	3$			;NOPE, NOT ENOUGH FOR DISPLAY EDITING
					;YES, MAKE DISPLAY FILE
1$:	MOV	R0,DBUFR		;SET DISP FILE START POINTER
	SUB	#DFSIZE+2,BEND		;ADJUST BUFFER END POINTER
	MOV	BEND,MBSTRT		;MACRO BUFFER POINTER
	MOV	BEND,SBSTRT		;AND SAVE BUFFER POINTER
	MOV	#DSFILE,R2		;POINT R2 TO DISPLAY FILE TEMPLATE
4$:	MOV	(R2)+,(R0)+		;COPY TEMPLATE INTO ACTUAL FILE
	CMP	R2,#TSTSCP		;DONE?
	BLO	4$			;LOOP IF NOT
	INCB	VT11OK			;SET FLAG SAYING DISPLAY FILE BUILT
	RTS	PC

;END OF ONCE-ONLY VT11 INITIALIZATION CODE

	. = ...TPC

	. = .+1000
IBEND=.					;MARK END OF INPUT BUFFER 2

; USR WILL SWAP OVER THE NEXT 10000 BYTES:

USRSWP:

OBUFF1:	.REPT	256.			;OUTPUT BUFFER 1
	.WORD	0
	.ENDM

OBUFF2:	.REPT	256.			;OUTPUT BUFFER 2
	.WORD	0
	.ENDM

OBEND=.					;MARK END OF OUTPUT BUFFER 2
	.SBTTL	TTY OUTPUT ROUTINES

;SUBROUTINE CRLF-PUTS CR AND LF ON CONSOLE TTY

CRLF:	CMPB	LASTC,#12
	BEQ	CRLFOUT
	MOVB	#CR,R0			;TYPE A <CR>
	JSR	PC,TYPCHAR
LFOUT:	MOVB	#LF,R0
	JSR	PC,TYPCHAR
CRLFOUT:RTS	PC

;SUBROUTINE EPRINT
;PRINTS ASCII MESSAGE POINTED TO BY R3 ON TELETYPE
;DESTROYS R0

EPRINT:	MOVB	(R3)+,R0		;PRINT MSG CHAR
	JSR	PC,TYPCHAR
	TSTB	(R3)			;DONE?
	BNE	EPRINT			;NO-DO NEXT CHARACTER
	RTS	PC			;YES-RETURN

;SUBROUTINE TYPCHAR
;OUTPUTS A CHARACTER TO THE TTY
;ALL TTY OUTPUT MUST GO THROUGH THIS ROUTINE BECAUSE IT HANDLES TABS,
;FORM FEEDS,ALTMODES ETC.

TYPCHAR:MOVB	R0,(PC)+		;SAVE THIS CHAR AS LAST CHAR TYP
LASTC:	 .WORD	12			;INIT. TO LF
	CMPB	R0,#12			;IS CHAR A LF?
	BNE	E121$			;NO
E122$:	.TTYOU
	RTS	PC			;RETURN

E121$:	MOV	R0,-(SP)		;SAVE CHAR
	CMPB	R0,ALTMDE		;IS IT AN ALTMODE ?
	BNE	E119$			;NO
	MOVB	#'$,R0			;YES,TYPE "$"
	BR	E120$			;GO PRINT IT

E119$:	CMPB	R0,#40			;IS CHAR PRINTABLE?
	BGE	E120$			;YES - GO PRINT IT
	CMPB	R0,#FF			;IS IT A FORM FEED?
	BNE	E123$			;NO
	MOV	#LF,R0			;YES-ECHO LINE FEEDS
	MOV	#10,E124$		;8 OF 'EM
E125$:	JSR	PC,E122$
	DEC	(PC)+			;DONE?
E124$:	 .WORD	0			;COUNTER FOR FORM FEED ECHO
	BGT	E125$			;NO-DO ANOTHER
EE118$:	MOV	(SP)+,R0		;YES-RESTORE R0
	RTS	PC			;RETURN

E123$:	CMPB	R0,#15			;IS CHAR A CR?
	BNE	E126$			;NO
	MOV	#11,TABCNT		;YES-RESET TAB COUNTER
	BR	E120$			;PRINT IT

E126$:	CMPB	R0,#11			;IS CHAR A TAB?
	BEQ	E8$			;YES
	CMPB	R0,#10			;IS IT BS?
	BNE	E110$			;NO-ECHO
	TSTB	SCPFLG			;IS TERMINAL A SCOPE?
	BEQ	E110$			;BRANCH IF NO
	.TTYOU				;TYPE THE BACKSPACE
	INC	TABCNT			;ADJUST TAB COUNT FOR BS
	CMP	TABCNT,#11		;HAVE WE BACKED OVER A TAB STOP?
	BLT	EE118$			;NO-EXIT
	MOV	#1,TABCNT		;YES-ADJUST TAB COUNT DOWN
	BR	EE118$			; AND EXIT

E110$:	MOVB	#'^,R0			;YES-ECHO "^X"
E128$:	.TTYOU
	MOV	(SP),R0			;RESTORE CHAR TO R0
	BIS	#100,R0			;WHERE X IS CHAR - 100
E120$:	.TTYOU
	DEC	TABCNT			;DECREMENT TAB COUNTER
	BNE	EE118$			;RETURN IF TAB COUNTER NOT EMPTY
EE117$:	MOV	#10,(PC)+		;RESET TAB COUNTER
TABCNT:	 .WORD	10			;TAB COUNTER
	BR	EE118$			;RETURN

E8$:	MOV	#40,R0			;FOR TABS,ECHO SPACES
	JSR	PC,E122$		;TYPE IT
	DEC	TABCNT			;AS MANY AS ARE NEEDED TO REACH
	BGT	E8$			;MORE
	BR	EE117$			;DONE
	.SBTTL	TABLE OF ERROR MESSAGES

;+
;ERROR
;ERROR MESSAGE TABLE
;CONTAINS STARTING ADDRESSES OF ERROR MESSAGES

ERRTAB:	MSG0				;"<>" ERROR
	MSG1				;ILLEGAL ARGUMENT
	MSG2				;ILLEGAL COMMAND
	MSG3				;COMMAND BUFFER FULL
	MSG4				;INSUFFICIENT MEMORY
	MSG5				;SEARCH FAILED
	MSG6				;ILLEGAL MACRO
	MSG7				;END OF INPUT FILE
	MSG10				;READ ERROR
	MSG11				;OUTPUT FILE FULL
	MSG12				;ILLEGAL DEVICE
	MSG13				;FILE NOT FOUND
	MSG14				;NO FILE OPEN FOR OUTPUT
	MSG15				;DIRECTORY FULL
	MSG16				;ILLEGAL FILE NAME
	MSG17				;SYSTEM I/O ERROR
	MSG20				;NOT ENOUGH FREE BLOCKS
	MSG21				;NO FILE OPEN FOR INPUT
	MSG22				;WRITE ERROR
	MSG23				;COMMAND ABORTED
	MSG24				;PROTECTED FILE
	MSG25				;PROTECTED .BAK FILE

;ERROR MESSAGES
;ASCII ERROR MESSAGES ARE STORED HERE
;ALL MESSAGES MUST END IN A 0 BYTE

	.NLIST	BIN
MSG0:	.ASCIZ /"<>" error/
MSG1:	.ASCIZ /Invalid argument/
MSG2:	.ASCIZ /Invalid command/
MSG3:	.ASCIZ /Command buffer full/
MSG4:	.ASCIZ /Insufficient memory/
MSG5:	.ASCIZ /Search failed/
MSG6:	.ASCIZ /Invalid macro/
MSG7:	.ASCIZ /End of input file/
MSG10:	.ASCIZ /Input error/
MSG11:	.ASCIZ /Output file full/
MSG12:	.ASCIZ /Invalid device/
MSG13:	.ASCIZ /File not found/
MSG14:	.ASCIZ /No file open for output/
MSG15:	.ASCIZ /Directory full/
MSG16:	.ASCIZ /Invalid file name/
MSG17:	.ASCIZ "System I/O error"
MSG20:	.ASCIZ /Device full/
MSG21:	.ASCIZ /No file open for input/
MSG22:	.ASCIZ /Output error/
MSG23:	.ASCIZ /Command aborted/
MSG24:	.ASCIZ /Protected file already exists/
MSG25:	.ASCIZ /Protected .BAK file exists/
MACMSG:	.ASCIZ / in macro/
EDTMSG:	.NLCSI	TYPE=I,PART=PREFIX
	.ASCIZ	/F-/
NCMSG:	.ASCIZ /; no command(s) executed/
	.EVEN
;-
	.LIST	BIN
	.SBTTL	EDITOR COMMAND TABLES

; COMMAND NAME TABLES-HOLDS SINGLE CHARACTERS FOR EDIT COMMANDS

CTABLE:

; COMMANDS BELOW THIS POINT ALLOW NO ARGUMENTS

NOARG:	.BYTE CTRLC			;EXIT EDITOR (^C)
	.BYTE 'R			;READ
	.BYTE 'B			;BEGINNING
	.BYTE 'V			;VERIFY
	.BYTE 'I			;INSERT
	.BYTE '>			;ITERATION END

; COMMANDS BELOW THIS POINT ALLOW "0" ARGUMENT ONLY

ZROARG:	.BYTE 'U			;UNSAVE
	.BYTE 'M			;MACRO

; COMMANDS BELOW THIS POINT ALLOW POSITIVE ARGUMENTS ONLY

POSARG:	.BYTE 'N			;NEXT
	.BYTE 'S			;SAVE
	.BYTE 'G			;GET
	.BYTE 'F			;FIND
	.BYTE 'P			;POSITION
	.BYTE '<			;ITERATION START

; COMMANDS BELOW THIS POINT ALLOW ALL ARGUMENTS EXCEPT "@"

EXCPAT:	.BYTE 'W			;WRITE
	.BYTE 'A			;ADVANCE
	.BYTE 'X			;EXCHANGE
	.BYTE 'L			;LIST
	.BYTE 'K			;KILL

; COMMANDS BELOW THIS POINT ALLOW ALL ARGUMENTS

ALLARG:	.BYTE 'D			;DELETE
	.BYTE 'C			;CHANGE
CTEND:	.BYTE 'J			;JUMP

; COMMANDS BELOW THIS POINT ARE TWO LETTER COMMANDS,THE FIRST OF WHICH IS "E"

ETABLE:	.BYTE 'M			;EXECUTE MACRO
	.BYTE 'X			;EXIT
	.BYTE 'R			;EDIT READ
	.BYTE 'W			;EDIT WRITE
	.BYTE 'B			;EDIT BACKUP
	.BYTE 'L			;EDIT LOWER
	.BYTE 'U			;EDIT UPPER
	.BYTE 'D			;EDIT DISPLAY
	.BYTE 'C			;EDIT CONSOLE
	.BYTE 'V			;EDIT VERSION
ETEND:	.BYTE 'F			;END FILE

; COMMANDS BELOW ARE EXECUTED IN EXTENDED DISPLAY MODE

STABLE:

; COMMANDS BELOW HAVE 0 OR NO ARGUMENT

ALTMDE::				;THE FOLLOWING LOCATION IS PATCHED
					; TO CHANGE THE ALTMODE CHAR
NARG:	.BYTE 33			;ALTMODE

; COMMANDS BELOW HAVE POSITIVE ARG

PARG:	.BYTE 'N-100			;CURSOR TO NEXT LINE (ADVANCE)
	.BYTE 'D-100			;CURSOR FORWARD ONE CHAR

; COMMANDS BELOW HAVE NEGATIVE ARG

MARG:	.BYTE 'V-100			;CURSOR BACK ONE CHAR
	.BYTE 'G-100			;CURSOR UP ONE LINE
STEND:	.BYTE RUBOUT			;DELETE CHAR PRECEDING CURSOR
	.EVEN
	.SBTTL	ERROR PASS DISPATCH TABLES

;ERROR PASS DISPATCH TABLES
;THESE TABLES ARE USED TO DISPATCH TO ROUTINES ON ERROR PASS

EPTAB1:	.WORD	JR			;CTRLC
	.WORD	JR			;READ
	.WORD	JR			;BEGIN
	.WORD	JR			;VERIFY
	.WORD	TMODE			;INSERT
	.WORD	RGTBRK			;>
	.WORD	JR			;UNSAVE
	.WORD	MACEP			;MACRO
	.WORD	JR			;NEXT
	.WORD	JR			;SAVE
	.WORD	TMODE			;GET
	.WORD	TMODE			;FIND
	.WORD	TMODE			;POSITION
	.WORD	LFTBRK			;<
	.WORD	JR			;WRITE
	.WORD	JR			;ADVANCE
	.WORD	TMODE			;XCHANGE
	.WORD	JR			;LIST
	.WORD	JR			;KILL
	.WORD	JR			;DELETE
	.WORD	TMODE			;CHANGE
	.WORD	JR			;JUMP

; JR IS SIMPLY AN RTS PC

EPTAB2:	.WORD	EMACEP			;EXECUTE MACRO
	.WORD	JR			;EXIT
	.WORD	TMODE			;EDIT READ
	.WORD	TMODE			;EDIT WRITE
	.WORD	TMODE			;EDIT BACKUP
	.WORD	JR			;EDIT LOWER
	.WORD	JR			;EDIT UPPER
	.WORD	JR			;EDIT DISPLAY
	.WORD	JR			;EDIT CONSOLE
	.WORD	JR			;EDIT VERSION
	.WORD	JR			;END FILE
	.SBTTL	EDITOR DISPATCH TABLE

;EDITOR DISPATCH TABLE
;ON THE EXECUTION PASS,THIS TABLE IS USED AS THE JUMP TABLE FOR
;THE VARIOUS COMMAND ROUTINES

DTABLE:	.WORD	CCEXIT
	.WORD	READ
	.WORD	BEGIN
	.WORD	VERIFY
	.WORD	INSERT
	.WORD	RGTBRK
	.WORD	UNSAVE
	.WORD	MACRO
	.WORD	NEXT
	.WORD	SAVE
	.WORD	GET
	.WORD	FIND
	.WORD	POSITN
	.WORD	LFTBRK
	.WORD	WRITE
	.WORD	ADVNCE
	.WORD	XCHNGE
	.WORD	LIST
	.WORD	KILL
	.WORD	DELETE
	.WORD	CHANGE
	.WORD	JUMP

EDTABL:	.WORD	EMACRO
	.WORD	EXIT
	.WORD	EREAD
	.WORD	EWRITE
	.WORD	EBCKUP
	.WORD	ELOWER
	.WORD	EUPPER
	.WORD	EDSPLY
	.WORD	ECONS
	.WORD	EVERS
	.WORD	EFILE

; DISPLAY MODE DISPATCH TABLE

SDTABL:	.WORD	ALTM
	.WORD	ADVNCE
	.WORD	JUMP
	.WORD	JUMP
	.WORD	ADVNCE
	.WORD	DELETE
	.SBTTL	COMMAND LOOP

;+
;
; ROUTINE COMAND
;	BASIC EDITOR COMMAND LOOP
;	EXPECTS CBASE TO POINT TO A COMMAND STRING WHICH ENDS IN A 0 BYTE.
;	MAKES TWO PASSES OVER THE COMMAND STRING. THE FIRST USES THE
;	DISPATCH TABLES AT EPTAB1 AND EPTAB2,CALLING THE APPROPRIATE ERROR
;	CHECKING ROUTINE FOR EACH COMMAND. THE SECOND TIME THROUGH,THE
;	DISPATCH TABLES AT DTABLE ARE USED,CALLING THE ACTUAL COMMAND
;	EXECUTION ROUTINES.
;
;-

COMAND:	INCB	EPFLG			;COMMENCE ERROR PASS
COMND1:	CLR	CREL			;START POINTER AT BEGINNING OF COMMAND
	CLRB	MINFLG			;MACRO PROCESS FLAG CLEARED
CLOOP:	JSR	PC,CCCHEK		;CHECK FOR DBLE CTRL/C BEFORE
					; EACH COMMAND
	MOV	CBASE,R1		;START OF COMMAND STRING
	ADD	CREL,R1			;R1 IS ABSOLUTE POINTER INTO CS
	CLR	SPCFLG			;CLEAR 'SPECIAL CHARACTER' AND
					; 'NUMBER SEEN' FLAG
	CLR	NEGFLG			;CLEAR NEGATIVE AND "/" FLAG
	CLRB	EQSFLG			;CLEAR = SEEN FLAG
	CLRB	SRCFLG			;CLEAR SEARCH IN PROGRESS FLAG
	CLR	R2			;ZERO ARGUMENT
C16$:	TSTB	MINFLG			;ARE WE PROCESSING A MACRO?
	BEQ	CL3			;NO
	CMPB	(R1),DELIM		;DELIMETER SEEN?
	BEQ	MOUTEP			;YES
	TSTB	(R1)			;NO-END OF STRING?
	BNE	C11$			;NO
;+
;ERROR
	ERROR+6				;YES-DELIMITER ERROR
;-

MOUTEP:	CMP	ISTACK,TMP		;DID MACRO MAKE A NET CHANGE IN
	BEQ	MOUTP1			;THE ITERATION STACK?
;+
;ERROR
	ERROR+0				;YES-"<> ERR"
;-

MOUTP1:	CLRB	MINFLG			;DELIMETER SEEN, CLEAR MACRO
					; PROCESS FLAG
	JMP	CECOM			;NEXT CHAR

CL3:	TSTB	(R1)			;END OF STRING?
	BNE	C11$			;NO
	TSTB	MACFLG			;ARE WE PROCESSING A MACRO?
	BNE	CL1			;YES-NO NEED TO CHECK STACK
	CMP	ISTACK,#ISTCKA		;IS STACK FREE
	BEQ	CL1			;YES
;+
;ERROR
	ERROR+0				;NO-"<>" ERROR
;-

CL1:	TSTB	EPFLG			;ERROR PASS
	BNE	CL2			;YES
	TSTB	DSFLG			;IS DISPLAY BEING USED?
	BEQ	1$			;NO - DON'T GO UPDATE IT
	JSR	PC,DUPDAT		;UPDATE THE DISPLAY
1$:	JMP ASTER			;NO-GET NEXT COMMAND STRING

CL2:	CLRB	EPFLG			;START EXECUTION PASS
	BR	COMND1

C11$:	CMPB	(R1),#SPACE		;IS NEXT CHAR A SPACE?
	BEQ	E12$			;YES-IGNORE IT
	CMPB	(R1),ALTMDE		;IGNORE ALTMODES BETWEEN COMMANDS
	BEQ	E12$
	CMPB	(R1),#CR		;NO-IS IT A CR?
	BEQ	E12$			;YES-IGNORE IT
	CMPB	(R1),#LF		;NO-IS IT A LF?
	BEQ	E12$			;YES-IGNORE IT
	CMPB	(R1),#PLUS		;NO-IS IT A "+"
	BNE	E13$			;NO-CHECK FOR A "="
	JSR	PC,CHECKF		;YES-MAKE CERTAIN IT IS LEGAL
	BR	E12$			;THEN MOVE ON

E13$:	CMPB	(R1),#MINUS		;IS IT A "="
	BNE	E14$			;NO-CHECK FOR A "/"
	JSR	PC,CHECKF		;MAKE SURE ITS LEGAL
	INCB	NEGFLG			;YES SET NEGATIVE FLAG
	BR	E12$			;CONTINUE

E14$:	CMPB	(R1),#SLASH		;IS IT A "/"
	BNE	E17$			;NO-CHECK FOR A "="
	JSR	PC,CHECKF		;MAKE SURE ITS LEGAL
	INCB	SLSFLG			;YES-SET "/" FLAG
	BR	E12$			;MOVE ON

E17$:	CMPB	(R1),#EQSIGN		;IS IT AN "="
	BNE	E15$			;NO-CHECK FOR A DIGIT
	JSR	PC,CHECKF		;YES-MAKE SURE IT'S LEGAL
	INCB	EQSFLG			;MARK IT SEEN
	INCB	NEGFLG			;= IS A NEGATIVE ARGUMENT
	BR	E12$			;MOVE ON

E15$:	CMPB	(R1),#ZERO		;IS CHAR <0?
	BLO	CNTDIG			;YES-IT IS NOT A DIGIT
	CMPB	(R1),#NINE		;IS CHAR <9?
	BHI	CNTDIG			;NO-IT IS NOT A DIGIT
	TSTB	SLSFLG			;YES-CHAR IS DIGIT. "/" SEEN?
	BNE	ERR1			;YES-ARGUMENT ERRROR
	TSTB	EQSFLG			;CHAR IS DIGIT ;= SEEN?
	BNE	ERR1			;YES-ILLEGAL ARG
	MOVB	(R1),R4			;MOVE DIGIT INTO R4 AS A TEMPORARY
	BIC	#177760,R4		;STRIP TO 4 BITS
	ASL	R2
	MOV	R2,-(SP)
	ASL	R2			;MULTIPLY CURRENT ARG BY 10
	ASL	R2
	ADD	(SP)+,R2
	ADD	R4,R2			;AND ADD IN MOST RECENT DIGIT
	BCS	ERR1			;ARGUMENT TOO LARGE
	BIT	#140000,R2		;TEST FOR AN ARG>16384
	BNE	ERR1			;IF SO,IT IS TOO BIG
	ADD	#401,SPCFLG		;SET 'SPECIAL CHARACTER' AND
					; 'NUMBER SEEN' FLAGS
E12$:	INC	R1			;BUMP POINTER TO NEXT CS CHARACTER
	INC	CREL			;UPDATE CS POINTER
	BR	C16$			;CONTINUE

;+
;ERROR
ERR1:	ERROR+1				;ILLEGAL ARGUMENT
;-

CNTDIG:	JSR	PC,UCTRAN		;TRANSLATE COMMAND CHAR TO UPPER CASE
	CMPB	(R1),#E			;IS CHARACTER "E"?
	BEQ	ECMD			;YES-IT IS A TWO LETTER COMMAND
	MOV	#NOARG,R4		;NO-SET UP SEARCH
E63$:	CMPB	(R4)+,(R1)		;SEARCH FOR CHAR IN CTABLE
	BEQ	CFOUND			;MATCH
	CMP	R4,#CTEND+1		;NO-MATCH. CHECK FOR END OF TABLE
	BLO	E63$			;END NOT REACHED-CONTINUE SEARCH
;+
;ERROR
ERR2:	ERROR+2				;END OF TABLE REACHED-ILLEGAL COMMAND
;-

; COMMAND CHAR HAS BEEN FOUND

CFOUND:	CMP	R4,#ALLARG		;IS COMMAND IN ALL ARG SECTION?
	BHI	E24$			;YES, ALL ARGS ARE LEGAL,
					; DISPATCH TO COMMAND
	TSTB	EQSFLG			;WAS "=" SEEN?
	BNE	ERR1			;IF SO,IT WAS AN ILLEGAL ARG
	CMP	R4,#EXCPAT		;COMMAND ALLOW ALL ARGS EXCEPT "@"?
	BHI	E26$			;YES-GO EXECUTE IT
	CMP	R4,#POSARG		;NO-IS COMMAND PAST POS ARG SECTION?
	BLOS	E22$			;NO-CHECK IF ZERO ARGS ALLOWED
	TSTB	NUMFLG			;NUMBER SEEN YET?
	BEQ	E21$			;NO-ZERO ARG IS CORRECT
	TST	R2			;CHECK THE ARGUMENT
	BEQ	ERR1			;IF =0 IT IS ILLEGAL
E21$:	TSTB	NEGFLG			;MINUS SIGN TYPED?
	BNE	ERR1			;YES-ARG ILLEGAL
	TSTB	SLSFLG			;SLASH SEEN?
	BNE	ERR1			;YES-ILLEGAL ARG
	BR	E26$			;ARG IS LEGAL-CALL SUBROUTINE

E22$:	CMP	R4,#ZROARG		;DOES COMMAND ALLOW "0" ARGUMENT?
	BLOS	E23$			;NO-IT ALLOWS NO ARGS
	TST	R2			;YES-IS ARG=0?
	BEQ	E26$			;YES-EXECUTE COMMAND
E23$:	TSTB	SPCFLG			;ANY ARG TYPED?
	BNE	ERR1			;YES-ILLEGAL ARGUMENT

; EXECUTE COMMAND

E24$:	TSTB	EQSFLG			;WAS ARG "="?
	BEQ	E26$			;NO
	MOV	EQLENG,R2		;YES-ARG WAS LENGTH OF LAST TEXT OBJ
	BR	E25$

E26$:	TSTB	NUMFLG			;NUMBER SEEN?
	BNE	E25$			;YES
	INC	R2			;NO-SET ARG=1
E25$:	SUB	#CTABLE+1,R4		;FIND COMMAND NUMBER
	MOV	#EPTAB1,R3		;R3-> ERROR PASS DISPATCH TABLE
	TSTB	EPFLG			;ARE WE IN ERROR PASS?
	BNE	CMDEX			;YES-USE ERROR TABLE
	ADD	#DTABLE-EPTAB1,R3	;NO-USE REGULAR DISPATCH TABLE
	BR	CMDEX		;EXECUTE THE COMMAND

; SEARCH FOR "E" COMMANDS

ECMD:	INC	CREL
	INC	R1			;POINT TO CHAR FOLLOWING "E"
	JSR	PC,UCTRAN		;TRANSLATE CHARACTER TO UPPER CASE
	MOV	#ETABLE,R4		;SET UP SEARCH
E31$:	CMPB	(R4)+,(R1)		;SEARCH FOR COMMAND IN ETABLE
	BEQ	E32$			;FOUND IT?
	CMP	R4,#ETEND+1		;NO-END OF TABLE YET?
	BHIS	ERR2			;YES-ILLEGAL COMMAND
	BR	E31$			;NO-CONTINUE

; "E" COMMAND FOUND

E32$:	CMPB	(R1),#M			;IS CMD=EM?
	BEQ	C35$			;YES-POSITIVE ARGS ALLOWED
	JSR	PC,CHECKF		;NO-NO ARGS ALLOWED
C33$:	SUB	#ETABLE+1,R4		;FINE COMMAND #
	MOV	#EPTAB2,R3		;POINT R3 TO ERROR PASS DISPATCH TABLE
	TSTB	EPFLG			;ARE WE IN ERROR PASS?
	BNE	CMDEX			;YES-USE ERROR TABLE
	ADD	#EDTABL-EPTAB2,R3	;NO-USE REGULAR TABLE

; COMMAND EXECUTER
;	CALLED WITH ARG IN R2,COMMAND # IN R4,AND POINTER TO
;	DISPATCH TABLE IN R3

CMDEX:	MOV	R2,ARG			;SET UP ARG
	ASL	R4			;CMD #*2=INDEX OF ADDR IN JUMP TABLE
	MOV	R3,TABIND		;USE TABLE POINTER AS INDEX OF
					; NEXT INSTRUCTION
	JSR	PC,@0(R4)		;JUMP TO COMMAND SUBROUTINE
	TABIND=.-2
	TSTB	EPFLG			;ERROR PASS?
	BNE	CECOM			;YES - DON'T DISABLE 'ED' CMD
	CLRB	FTFLG			;AFTER FIRST COMMAND,
					; ED COMMAND IS ILLEGAL
CECOM:	INC	CREL			;MOVE POINTER TO NEXT CHAR
	JMP	CLOOP			;NEXT COMMAND

C35$:	TSTB	NEGFLG			;NEGATIVE ARGUMENT?
	BNE	ERR1			;YES-ILLEGAL
	TSTB	SLSFLG			;SLASH SEEN?
	BNE	ERR1			;YES-ILLEGAL ARG
	TSTB	NUMFLG			;WAS A NUMBER TYPED?
	BNE	E34$			;YES-CHECK IT
	INC	R2			;NO  NUM TYPED-SET ARG TO 1
E34$:	TST	R2			;YES-IT BETTER NOT BE 0
	BEQ	ERR1			;IT IS-ERROR
	BR	C33$			;ARG OK-CONTINUE

; SUBROUTINE CHECKF
;	USED BY THE COMMAND LOOP TO CHECK VARIOUS ARGUMENT FLAGS WHEN A
;	CHARACTER SUCH AS +,- AND / ARE SEEN

CHECKF:	TST	SPCFLG			;NUMBER OR SPECIAL CHAR SEEN YET?
1$:	BNE	ERR1			;YES-ILLEGAL ARG
	TSTB	NEGFLG			;MINUS SIGN SEEN YET?
	BNE	1$			;YES-ILLEGAL ARG
	INCB	SPCFLG			;NO-SET IT
JR:	RTS	PC			;RETURN

; SUBROUTINE UCTRAN
;	USED BY COMMAND PROCESSING ROUTINES TO TRANSLATE THE CHARACTER
;	POINTED TO BY R1 TO UPPER CASE. THE TRANSLATED CHARACTER IS NOT MOVED.

UCTRAN:	CMPB	(R1),#'A+40		;IS ASCII VALUE OF CHAR<141?
	BLT	E60$			;YES-OK TO PROCESS
	CMPB	(R1),#'Z+40		;IS CHAR A LOWER CASE ALPHABETIC?
	BGT	E60$			;NO-OK TO PROCESS
	BICB	#40,(R1)		;YES-TRANSLATE TO UPPER CASE
E60$:	RTS	PC			;RETURN
	.SBTTL	IMMEDIATE MODE COMMAND LOOP

; ENTERED UPON RECEIVING DOUBLE ALTMODE IN COMMAND MODE
; EXITS TO COMMAND MODE PROCESSING UPON RECEIPT OF SINGLE ALTMODE
; USES SDTABL TO CALL IMMEDIATE COMMAND ROUTINES
; ALL NON-COMMAND CHARS ARE INSERTED INTO TEXT AUTOMATICALLY

REFRSH:	JSR	PC,DUPDAT		;UPDATE THE DISPLAY
SCOMND:	.TTYIN				;GET CHAR FROM TTY
	CMPB	#175,R0			;CHECK IF CHAR IS IN TABLE
	BHIS	SC1$			;YES - MATCH IT
	CMPB	#40,R0			;IS CHAR A CTRL?
	BHIS	SC3$			;NOT IN TABLE - GO INSERT IT
SC1$:	MOV	#STABLE,R4		;SET UP TABLE SEARCH TOP
	MOV	#STEND+1,R3		;TABLE END
SC2$:	CMPB	(R4)+,R0		;SEARCH CHAR IN STABLE
	BEQ	SFOUND			;MATCH - GO EXECUTE CMD
	CMP	R4,R3			;END OF TABLE?
	BLO	SC2$			;NO - CONTINUE SEARCH

; INSERT ANY CHARACTER NOT IN TABLE

SC3$:	MOV	CBEND,R3		;INITIALIZE 'FROM' PTR FOR MOVUP
	MOV	SBSTRT,R2		;CHECK IF SPACE IS AVAILABLE
	SUB	R3,R2			;TEXT BUFF
	SUB	#10,R2			;ROOM FOR EMERGENCY COMMAND
	BHIS	SC4$			;SPACE AVAILABLE - CONTINUE
;+
;ERROR
	ERROR+4				;"NO ROOM"
;-

SC4$:	MOV	PTR,R2			;SET CURRENT PTR FOR MOVUP
	INC	CBEND			;BUFFER WILL BE 1 CHAR LARGER
	INC	CBSTRT			;ALSO BUMP CIB START PTR BY 1
	MOV	CBEND,R4		;INITIALIZE 'TO' PTR
	JSR	PC,MOVUP		;MAKE ROOM FOR CHAR
	MOVB	R0,(R3)+		;INSERT CHAR, AND BUMP PTR
	MOV	R3,PTR			;RESET CURSOR POSITION
	JMP	REFRSH			;REFRESH DISPLAY, GET NEXT CHAR

; IMMEDIATE COMD CHAR HAS BEEN FOUND

SFOUND:	CLRB	SLSFLG			;CLEAR "/" SEEN FLAG
	CLRB	NEGFLG			;CLEAR "-" SEEN FLAG
	CLR	R2			;ZERO ARGUMENT
	CMP	R4,#PARG		;IS ARG +1?
	BLOS	SC5$			;NO - ZERO
	INC	R2			;SET ARG TO +1
	CMP	R4,#MARG		;IS ARG -1?
	BLOS	SC5$			;NO - +1
	INCB	NEGFLG			;SET ARG TO -1
SC5$:	MOV	R2,ARG			;SET UP ARG
	SUB	#STABLE+1,R4		;CALCULATE CMD NUMBER
	ASL	R4			;#*2=INDEX INTO JUMP TABLE
	JSR	PC,@SDTABL(R4)		;JUMP TO COMMAND SUBROUTINE
	JMP	REFRSH			;REFRESH DISPLAY, GET NEXT CHAR

; ROUTINE ASTER
;	GETS NEXT COMMAND STRING AFTER CURRENT ONE FINISHED

ASTER:	TSTB	MACFLG			;DID WE JUST FINISH A MACRO?
	BEQ	AST1			;NO-GET NEXT STRING FROM TTY
	DEC	MACCNT			;YES-DECREMENT MACRO COUNT
	BEQ	AST9			;IF COUNT=0,RESUME MASTER STRING
	CLR	CREL			;COUNT NOT ZERO-START MACRO AGAIN
	JMP	CLOOP			;EXECUTE COMMAND STRING

; MACRO IS FINISHED-RESUME MASTER STRING

AST9:	MOV	CBSTRT,CBASE		;RETURN TO MASTER COMMAND STRING
	MOV	MACR1,CREL		;GET SAVED CS POINTER
	CLRB	MACFLG			;CLEAR MACRO FLAG
	JMP	CECOM			;CONTINUE IN MASTER STRING

; COMMAND STRING MUST COME FROM TTY

AST101:	JSR	PC,CRLF			;ISSUE CRLF
AST1:	CLRB	ALTFLG			;CLEAR ALTMODE FLAG
	MOV	#ISTCKA,ISTACK		;INIT ITERATION STACK
	MOV	SBSTRT,R4		;START OF SAVE BUFFER INTO R4
	SUB	CBSTRT,R4		;TOTAL LENGTH OF CIB=CBSTRT-SBSTRT/2
	ASR	R4			;DIVIDE BY 2
AST2:	.RCTRL				;ENABLE TTY IN CASE HE ^O 'D IT OUT
	MOV	CBSTRT,R3		;R3 POINTS INTO COMMAND BUFFER
	MOVB	#ASTRSK,R0		;FOLLOWED BY "*"
	JSR	PC,TYPCHAR
AST17:	CLR	RUBFLG			;CLEAR RUBOUT FLAG
AST3:	.TTYIN				;GET CHAR FROM TTY
AST6:	CLR	CCSTAT			;KEEP ^C^C FROM ABORTING INSERT
	CMPB	R0,#RUBOUT		;IS CHAR RUBOUT
	BEQ	AST12			;YES-GO TO RUBOUT PROCESSOR
	TST	RUBFLG			;NO-WAS LAST CHAR RUBOUT?
	BEQ	AST16			;NO
	MOV	R0,-(SP)		;SAVE CHAR
	MOVB	#'\,R0			;YES-ECHO SECOND "\"
	JSR	PC,TYPCHAR
	MOV	(SP)+,R0		;RESTORE CHAR
	CLR	RUBFLG			;CLEAR FLAG
AST16:	CMPB	ALTMDE,R0		;IS CHAR AN ALTMODE?
	BEQ	AST5			;YES-CHECK FOR DOUBLE ALTMODE
	CLRB	ALTFLG			;NO-CLEAR ALTMODE FLAG
	JSR	PC,TYPCHAR		;ECHO THE CHARACTER
	CMPB	R0,#CTRLX		;WAS CHAR. CTRL X?
	BEQ	AST101			;YES-FORGET EVERYTHING AND START OVER
	CMPB	R0,#CTRLU		;WAS CHAR CTRL U?
	BNE	AST13			;NO
	JSR	PC,CRLF			;YES-ECHO CRLF
CTRULP:	CMP	R3,CBSTRT		;IS CIB EMPTY?
	BLOS	AST101			;YES-START OVER
	MOVB	-(R3),R0		;NO-BACK UP A CHARACTER
	INC	R4			;AND BUMP SPACE AVAILABLE COUNT
	CMPB	R0,#LF			;WAS CHAR WE BACKED OVER A LF?
	BNE	E61$			;NO
E62$:	INC	R3			;YES-RESTORE IT
	BR	AST17			;AND START LINE FRESH

E61$:	CMPB	R0,#FF			;NO-SAME FOR FORM FEED
	BEQ	E62$
	BR	CTRULP			;NEITHER-BACK UP AGAIN

AST13:	MOVB	R0,(R3)+		;PUT CHAR IN CIB
	DEC	R4			;DECREASE AVAILABLE SPACE COUNT
	BEQ	AST11			;BUFFER FULL?
SZCHK:	CMP	R4,#12			;NO-ARE WE WITHIN 10 CHARS OF END?
	BHI	AST3			;NO-GET NEXT
	MOV	R3,-(SP)		;YES-PRINT WARNING
	MOV	#AST8,R3
	JSR	PC,EPRINT
	MOV	(SP)+,R3
	BISB	#WARN$,@#USERRB		;INDICATE A WARNING LEVEL ERROR
	BR	JMPAST3

AST11:	INCB	EPFLG			;FORCE "NO COMMANDS EXEC" SUFFIX
					; ON ERROR MESSAGE
;+
;ERROR
	ERROR+3				;CIB FULL
;-
	.LIST	BIN

	.NLIST	BIN
AST8:	.BYTE CR,LF
	.NLCSI	TYPE=I,PART=PREFIX
	.ASCII	/W-Command buffer almost full/
	.BYTE 15,12,0
	.EVEN
	.LIST	BIN

; ALTMODE SEEN

AST5:	JSR	PC,TYPCHAR		;ECHO $
	TSTB	ALTFLG			;WAS LAST CHAR ALTMODE?
	BNE	AST4			;YES-END OF COMMAND
	INCB	ALTFLG			;NO-SET ALTMODE FLAG
	MOVB	R0,(R3)+		;PUT ALTMODE IN BUFFER
	BR	AST3			;NEXT CHAR

AST4:	CLRB	-(R3)			;PUT 0 AT END OF COMMAND
	INC	R3
	CLRB	(R3)			;WE NEED 2 ZEROES IN CASE LAST
					; COMMAND IS TEXT COMMAND
	MOV	R3,CBEND		;MARK END OF COMMAND BUFFER
	MOV	CBSTRT,CBASE		;POINT TO MASTER COMMAND STRING
	JSR	PC,CRLF			;ECHO CRLF FOR DOUBLE ALTMODES
	TSTB	DSFLG			;IS DISPLAY BEING USED?
	BEQ	AST18			;NO - DON'T CHECK FOR IMMED. MODE
	TSTB	@CBSTRT			;IS CIB EMPTY?
	BNE	AST18			;NO - PROCESS COMMAND STRING
	INC	SCFLG			;NULL CIB - SET IMMEDIATE MODE
	MOVB	#'!,R0			;PRINT "!"
	JSR	PC,TYPCHAR		;TO INDICATE MODE
	JMP	SCOMND			;GET NEXT IMMEDIATE CHAR

AST18:	JMP COMAND		;EXECUTE COMMAND STRING

; RUBOUT PROCESSING

AST12:	CLRB	ALTFLG			;A RUBOUT IS NOT AN ALTMODE
	CMP	R3,CBSTRT		;CIB EMPTY?
	BNE	CHKSCOP			;NO-CHECK FOR SCOPE
	JMP	AST101			;YES-IGNORE

CHKSCOP:TSTB	SCPFLG			;IS THE CONSOLE A SCOPE?
	BNE	SCOPRUB			;YES-SPECIAL RUBOUT PROCESS
	TST (PC)+			;NO-"\" PRINTED?
RUBFLG:	.WORD	0			;RUBOUT FLAG
	BNE	AST15			;YES-DON'T BOTHER
	INC	RUBFLG			;NO-PRINT IT
	MOVB	#'\,R0
	JSR	PC,TYPCHAR
AST15:	MOVB	-(R3),R0		;ECHO RUBBED OUT CHARACTER
	JSR	PC,TYPCHAR
AST14:	INC	R4			;INCREASE AVAILABLE COUNT SPACE
JMPAST3:JMP	AST3

SCOPRUB:MOV	R3,-(SP)		;SAVE R3
	MOV	#ERASE,R3		;ADDRESS OF ERASE MESSAGE
	JSR	PC,EPRINT		;ECHO BS,SP,BS
	MOV	(SP)+,R3		;RESTORE R3
	DEC	R3			;BACK UP CHARACTER POINTER
	JMP	AST14			;CONTINUE

ERASE:	.BYTE	10,40,10,0		;BACKSPACE,SPACE,BACKSPACE

	.SBTTL	SYSTEM SUBROUTINES

; SUBROUTINE TMODE
;	REMEMBERS START OF OBJECT IN OBSTRT. SEARCHES FOR ALTMODE. RETURNS
;	LENGTH OF TEXT OBJECT IN OBLENG. MOVES R1 TO POINT TO ALTMODE

TMODE:	INC	CREL
	MOV	CREL,R1
	ADD	CBASE,R1		;R1 NOW POINTS TO ABS ADDR OF OBJECT
	MOV	CREL,OBSTRT		;REMEMBER THIS START
	CLR	R0			;ZERO LENGTH
E68$:	CMPB	(R1),ALTMDE		;ALTMODE CHAR?
	BEQ	E69$			;YES-END OF OBJECT
	TSTB	(R1)+			;0 CAN ALSO END OBJECT IF LAST
					; COMMAND IN STRING
	BEQ	E69$
	INC	CREL			;NO-BUMP POINTER
	INC	R0			;BUMP LENGTH
	BR	E68$			;LOOP

E69$:	MOV	R0,OBLENG		;TEXT OBJECT LENGTH
	TSTB	EPFLG			;ARE WE IN ERROR PASS?
	BNE	T1			;YES-ERROR PASS DOES NOT AFFECT = ARG
	MOV	R0,EQLENG		;REMEMBER IT FOR = ARGUMENT
T1:	RTS	PC			;RETURN

; SUBROUTINE CHRARG
;	INTERPRETS ARG AS # OF CHARS AND RETURNS WITH R4 POINTING
;	TO REFERENCED ADR

CHRARG:	TSTB	SLSFLG			;IS ARG="/"?
	BNE	LCCOM1			;YES-SET ADR=CBSTST-1
	TST	ARG			;ARG=0?
	BEQ	LNTSLS			;YES-USE ROUTINE IN LINARG TO FIND
					; BEGINNING OF CURRENT LINE
CHR1:	MOV	PTR,R4			;CURRENT POINTER INTO R4
	TSTB	NEGFLG			;IS ARG<0?
	BNE	CSUB			;YES-SUBTRACT ARG FROM PTR
	ADD	ARG,R4			;ADD ARG TO PTR FOR ADR
	CMP	R4,CBSTRT		;IS ADR PAST END?
	BHIS	LCCOM1			;YES-EQUIV TO "/"
	RTS	PC			;RETURN

CSUB:	SUB	ARG,R4			;PTR-ARG=ADR
	CMP	R4,PBSTRT		;ADR BEFORE BEG OF BUFFER?
	BHIS	CHRET			;NO-RETURN
	MOV	PBSTRT,R4		;YES-ADR = BEGINNING
CHRET:	RTS	PC

; SUBROUTINE EMACEP
;	ERROR PASS ROUTINE FOR EM COMMAND

EMACEP:	TSTB	MINFLG			;ARE WE PROCESSING A MACRO?
	BEQ MACEPR			;NO-RETURN
;+
;ERROR
ERM:	ERROR+6				;YES, NESTING OF MACROS IS ILLEGAL
;-

; SUBROUTINE MACEP
;	ERROR PASS ROUTINE FOR M COMMAND

MACEP:	TST	ARG			;0M ?
	BEQ	EMACEP			;YES, JUST CHECK FOR RECURSION
	INC	R1			;POINT TO DELIMETER
	INC	CREL
	MOVB	(R1)+,DELIM		;STORE DELIMETER
	BEQ	ERM			;END OF STRING MEANS DELIMETER ERROR
	JSR	PC,EMACEP		;TEST FOR RECURSION PROBLEMS
	MOV	ISTACK,TMP		;SAVE CURRENT ITERATION STACK POSITION
	INCB	MINFLG			;SET FLAG FOR MACRO PROCESSING
MACEPR:	RTS 	PC

; SUBROUTINE LINARG
;	INTERPRETS ARG AS A LINE ARGUMENT,AND RETURNS WITH R4 POINTING
;	TO IMPLIED ADR

LINARG:	TSTB	SLSFLG			;IS ARG="/"
	BEQ	LNTSLS			;NO
LCCOM1:	MOV	CBSTRT,R4		;ADR IS END OF BUFFER
	RTS	PC			;DONE

LNTSLS:	MOV	PTR,R4			;CURRENT CHAR POSITION IN R4
	MOV	ARG,R3			;NUMBER OF CRLF'S IN R3
	BEQ	L1$			;IF ARG=0,NEED 1 CRLF BACKWARDS
LTMIN:	TSTB	NEGFLG			;IS IT <0?
	BEQ	LFLOOP			;NO-MOVE FORWARD
L1$:	INC	R3			;BACK OVER ARG+1 CRLF
LBLOOP:	CMP	R4,PBSTRT		;IS ADR PAST BEG OF BUFFER?
	BLOS	LRET			;YES-SET ADR AT BEG
	CMPB	-(R4),#LF		;NO-IS PREV CHAR LF?
	BNE	LBLOOP			;NO-BACKUP
	CMP	R4,PBSTRT		;IS ADR PAST BEG OF BUFFER?
	BLOS	LRET			;YES-SET ADR AT BEG
	CMPB	-1(R4),#CR		;YES-IS PREV CHAR CR?
	BNE	LBLOOP			;NO-BACKUP
	DEC	R3			;YES-DECREASE COUNT
	BNE	LBLOOP			;MORE
	INC	R4			;DONE-MOVE OVER LAST CRLF
					; TO BEG OF NEXT LINE
LRET:	RTS PC

LFLOOP:	CMP	R4,CBSTRT		;ADR PAST END?
	BHIS	LCCOM1			;YES-SET IT TO END
	CMPB	(R4)+,#CR		;NEXT CHAR=CR?
	BNE	LFLOOP			;NO
	CMPB	(R4),#LF		;YES-CHAR AFTER THAT LF?
	BNE	LFLOOP			;NO
	DEC	R3			;YES-DECREASE COUNT
	BNE	LFLOOP			;DONE?
	INC	R4			;SPACE OVER LAST LF
	RTS	PC			;YES

; SUBROUTINE SEARCH
;	COMPARES TEXT OBJECT WITH PAGE BUFFER STARTING AT PTR.
;	RETURNS TO CALL+1 IF MATCH FOUND,CALL+2 IF SEARCH FAILS.
;	LEAVES POINTER AFTER LAST CHARACTER CHECKED. LOOKS FOR "ARG"
;	NUMBER OF MATCHES BEFORE SUCCESS.

SNOHIT:	INC	PTR			;BUMP POINTER FORWARD AND SEARCH AGAIN
SEARCH:	MOV	PTR,R4			;R4 POINTS TO DOT
	MOV	OBSTRT,R3		;R3 POINTS TO OBJECT
	ADD	CBASE,R3		;R3 NOW ABSOLUTE ADDR OF OBJECT
	MOV	OBLENG,R2		;R2 CONTAINS OBJ LENGTH
SLOOP1:	CMP	R4,CBSTRT		;END OF BUFFER?
	BHIS	SFAIL			;YES-SEARCH FAILED
	CMPB	(R4)+,(R3)+		;NO-DOES THIS CHAR MATCH?
	BNE	SNOHIT			;NO
	DEC	R2			;YES-MORE CHARS IN OBJECT TO MATCH?
	BEQ	SMATCH			;NO-SEARCH SUCCESSFUL
	BR	SLOOP1			;YES-CHECK THEM

SFAIL:	ADD	#2,(SP)			;BUMP RETURN
	MOV	R4,PTR			;SET PTR
	RTS	PC			;RETURN

SMATCH:	MOV	R4,PTR			;SET PTR
	DEC	ARG			;MORE MATCHES TO FIND?
	BGT	SEARCH			;YES-GET NEXT ONE
	RTS	PC			;NO-DONE

; SUBROUTINE BLKEMT
;	GETS CHARS FROM INPUT BUFFER, READING BLOCKS AS NECESSARY

BLKEMT:	TSTB	INOFLG			;IS THERE AN INPUT FILE OPEN?
	BNE	E41$			;YES
;+
;ERROR
	ERROR+21			;"FILE NOT OPEN"
;-

E41$:	TSTB	EOFFLG			;EOF SEEN YET?
	BEQ	E46$			;NO
EOFERR:	TSTB	SRCFLG			;YES-FILE SEARCH IN PROGRESS?
	BNE	E42$			;YES-SRCH FAIL MSG
;+
;ERROR
	ERROR+7				;NO-"EOF"

E42$:	ERROR+5				;"SRCH FAIL"
;-

E46$:	MOV	IBPTR,R2		;R2 POINTS INTO INPUT BUFFER
	INC	IBPTR			;BUMP INPUT POINTER
	MOVB	(R2)+,-(SP)		;SAVE NEXT CHAR ON STACK
	BIC	#177600,(SP)		;STRIP TO 7 BITS
	CMP	R2,#IBUFF2		;IS INPUT BUFFER 1 EMPTY?
	BNE	E43$			;NO-CHECK BUFF 2
	TSTB	EFFLG			;YES-HAS LAST BLOCK OF FILE BEEN READ?
	BEQ	E47$			;NO
E48$:	INCB	EOFFLG			;YES-SET END OF FILE FLAG FOR READ
	MOV	(SP)+,R0		;GET CHAR OFF STACK
	RTS	PC			;AND RETURN

E47$:	MOV	#IBUFF1,R2
	JSR	PC,BREAD		;READ NEXT BLOCK
	BR	E45$			;BACK TO CALLER

E43$:	CMP	R2,#IBEND		;IS BUFFER2 EMPTY
	BLO	E45$			;NO-RETURN
	TSTB	EFFLG			;YES-HAS LAST BLOCK BEEN READ?
	BNE	E48$			;YES-SET FLAG AND RETURN
	MOV	#IBUFF2,R2		;READ BLOCK 2
	JSR	PC,BREAD
	MOV	#IBUFF1,IBPTR		;RESET INPUT POINTER
E45$:	MOVB	(SP)+,R0		;CHAR INTO R0
	BEQ	E46$			;IGNORE NULLS
E44$:	CMPB	R0,#RUBOUT		;IS CHAR A RUBOUT?
	BEQ 	E46$			;YES-IGNORE IT
OUT01:	RTS	PC

BREAD:	JSR	PC,BUFZRO		;ZERO THE BUFFER BEFORE READING IT
	.WAIT	#12			;WAIT FOR LAST BUFFER
	BCS 	2$			;WAS LAST READ AN ERROR?
	JSR	PC,CCCHEK		;CHECK FOR ^C^C BEFORE EACH READ
	.READ	#AREA,#12,R2,#400,IBLKNM ;READ A BLOCK FROM INPUT FILE TO
					; BUFFER AT R2
	BCS	2$			;READ ERROR
1$:	INC	IBLKNM			;BUMP BLOCK NUMBER
	RTS	PC

2$:	TSTB	@#ERRBYT		;HARDWARE ERROR?
	BEQ	E3$
;+
;ERROR
	ERROR+10			;YES
;-

E3$:	INCB	EFFLG			;EOF-SET LAST BLOCK READ FLAG
	RTS	PC

; SUBROUTINE BUFZRO
;	CLEARS THE 256 WORD BUFFER WHOSE ADDRESS IS IN R2

BUFZRO:	MOV	R2,-(SP)		;SAVE R2
	MOV	#400,R1			;COUNTER INTO R0
E70$:	CLR	(R2)+			;ZERO LOCATION
	DEC	R1			;DECREASE COUNT
	BGT	E70$			;MORE TO GO
	MOV	(SP)+,R2		;RESTORE R2
	RTS	PC			;DONE

; SUBROUTINE CCCHEK
;	CHECKS TO SEE IF TWO CTRL/C'S HAVE BEEN DETECTED,AND
;	IF SO,PRINTS ERROR MESSAGE,RETURNING TO COMMAND MODE

CCCHEK:	TST	CCSTAT			;TWO CTRL C'S?
	BPL	1$			;RETURN IF NOT
	CLR	CCSTAT			;YES-CLEAR FLAG
	.TTINR				;FLUSH ^C'S FROM BUFFER
	.TTINR
;+
;ERROR
	ERROR+23			;"COMMAND ABORTED"
;-

1$:	RTS	PC
	.SBTTL	COMMAND SUBROUTINES

; ADVANCE
;	MOVES PTR TO IMPLIED ADR

ADVNCE:	JSR	PC,LINARG		;ADVANCE IS A LINE COMMAND
AJCOM:	MOV	R4,PTR			;SET PTR
	RTS	PC			;RETURN

; JUMP
;	MOVES POINTER TO IMPLIED ADR

JUMP:	JSR	PC,CHRARG		;ARG IS A CHAR ARG
	BR	AJCOM			;SET POINTER AND RETURN

; DELETE
;	MOVES TEXT AFTER DELETE UP

DELETE:	JSR	PC,CHRARG		;DELETE IS A CHAR COMMAND
DKCOM:	CMP	PTR,R4			;IS ADR>PTR?
	BHIS	E76$			;YES
	MOV	R4,R2			;NO
	SUB	PTR,R4			;GET # OF CHARS TO DELETE
	MOV	R4,-(SP)		;SAVE # OF DELETED CHARS
	MOV	PTR,R4			;SET UP DESTINATION
	BR	E75$			;PREPARE MOVDWN

E76$:	MOV	PTR,R2
	SUB	R4,R2			;GET # OF DELETED CHARS
	MOV	R2,-(SP)		;SAVE THAT NUMBER
	MOV	PTR,R2			;SET UP MOVE
E75$:	MOV	CBEND,R3		;MOV PB AND CIB
	MOV	R4,PTR			;SET NEW PTR
	JSR	PC,MOVDWN		;DELETE TEXT
	SUB	(SP),CBSTRT		;UPDATE NEW CIB POINTERS
	SUB	(SP),CBEND
	TSTB	MACFLG			;MACRO IN PROGRESS?
	BNE	E74$			;YES
	SUB	(SP),CBASE		;NO, ADJUST CS POINTER TO
					; REFLECT CIB MOVE
E74$:	TST	(SP)+			;CLEAN # OF CHARS OFF STACK
	RTS PC

; KILL
;	SAME AS DELETE ONCE ADR IS DETERMINED

KILL:	JSR	PC,LINARG		;KILL IS A LINE COMMAND
	BR	DKCOM			;SAME AS DELETE
	.SBTTL	IMMEDIATE MODE COMMAND SUBROUTINES

; ALTM
;	SINGLE ALTMODE - RETURNS TO COMMAND STRING MODE

ALTM:	CLRB	SCFLG			;SET IMMEDIATE MODE OFF
	MOVB	#'!,LASTC		;MAKE SURE CR-LF PRINTS
	JSR	PC,CRLF			;PRINT CR-LF
	TST	(SP)+			;POP OFF RETURN PC
	JMP	ASTER			;GET NEXT COMMAND STRING

; LIST
;	OUTPUTS CHARS BETWEEN PTR AND IMPLIED ADR TO TTY

LIST:	MOV	TTY,OUTINS		;SET UP CALL TO TYPE FOR OUTPUT DEVICE
	MOV	TTY+2,OUTINS+2
LWCOM:	JSR	PC,LINARG		;ARG IS A LINE ARG
	CMP	R4,PTR			;FORWARD OR BACKWARD?
	BLO	E77$			;BACKWARD
	MOV	R4,R3			;FORWARD
	MOV	PTR,R4			;FINAL ADR IN R3
	BR	L2

E77$:	MOV	PTR,R3			;FINAL LIST CHAR IN R3
L2:	CMP	R4,R3			;DONE?
	BEQ	LDONE			;YES
	MOVB	(R4),R0			;NO, SET UP CHAR
					; ***DO NOT CHANGE TO (R4)+
					; REMOVING INC AT OUTINS+4.BLKSTF
					; ROUTINE NEEDS R4 POINTING TO
					; CURRENT CHARACTER

OUTINS:	.WORD 0				;CALL TO OUTPUT ROUTINE GOES HERE
	.WORD 0
	INC	R4			;NEXT CHAR
	BR	L2			;LOOP

LDONE:	RTS PC

; OUTPUT CALLS

TTY:	JSR	PC,@#TYPCHAR
FILE:	JSR	PC,@#BLKSTF

; VERIFY
;	EQUIVALENT TO 0L,L

VERIFY:	CLR	ARG			;SET ARG TO 0
	JSR	PC,LIST			;DO A 0 L
	INC	ARG			;SET ARG TO 1
	BR	LIST			;FOLLOWED BY AN L. LIST WILL RETURN

; BEGIN
;	SETS PTR TO START OF PAGE BUFFER

BEGIN:	MOV	PBSTRT,PTR		;SELF-EXPLANATORY
	RTS	PC

; WRITE
;	SAME AS A LIST GOING TO FILE BUFFER INSTEAD OF TTY

WRITE:	TSTB	OTOFLG			;IS THERE AN OUTPUT FILE OPEN?
	BNE	E78$			;YES
;+
;ERROR
	ERROR+14			;NO-NO FILE
;-

E78$:	MOV	FILE,OUTINS		;SET FILE STUFFING ROUTINE AS
					; OUTPUT DEV
	MOV	FILE+2,OUTINS+2
	BR	LWCOM			;SAME AS LIST

; INSERT
;	INSERT TEXT OBJECT AT PTR

INSERT:	JSR	PC,TMODE		;GET OBJECT LENGTH
IUCOM:	MOV	SBSTRT,R4		;START OF SAVE BUFFER IN R4
	SUB	CBEND,R4		;SPACE AVAILABLE IS
					; START OF SB-END OF CIB
	SUB	#10,R4			;MUST LEAVE ROOM FOR EMERGENCY
					; COMMAND STRING
	CMP	OBLENG,R4		;COMPARE IT TO OBJECT LENGTH
	BLO	E91$			;THERE IS ROOM
;+
;ERROR
	ERROR+4				;"NO ROOM"
;-

E91$:	MOV	CBEND,R3		;INITIALIZE MOVE LIMITS
	ADD	OBLENG,CBEND		;UPDATE CBEND
	MOV	CBEND,R4		;INIT DEST FOR MOVUP
	MOV	PTR,R2			;MAKE ROOM AT PTR
	JSR	PC,MOVUP		;MAKE ROOM FOR INSERT
	ADD	OBLENG,CBSTRT		;UPDATE START OF CIB
	TSTB	MACFLG			;MACRO IN PROGRESS?
	BNE	E92$			;YES
	ADD	OBLENG,CBASE		;NO-UPDATE COMMAND POINTER
E92$:	MOV	OBSTRT,R4		;R4 POINTS TO TOBJECT
	ADD	CBASE,R4		;R4 POINTS TO ABSOLUTE ADDR OF OBJECT
E93$:	DEC	OBLENG			;DEC COUNT
	BMI	E94$			;FINISHED?
	MOVB	(R4)+,(R3)+		;NO-INSERT CHAR
	BR	E93$			;LOOP
E94$:	MOV	R3,PTR			;YES-UPDATE POINTER
	RTS PC

; CHANGE
;	EQUIVALENT TO A DELETE FOLLOWED BY AN INSERT

CHANGE:	JSR	PC,DELETE
	BR	INSERT

; EXCHANGE
;	EQUIVALENT TO A KILL FOLLOWED BY INSERT

XCHNGE:	JSR	PC,KILL
	BR	INSERT

; GET
;	SEARCHES CURRENT BUFFER-PRINTS ERROR IF NOT FOUND

GET:	JSR	PC,TMODE		;GET SEARCH OBJECT
	JSR	PC,SEARCH		;FIND IT
	 RTS	PC			;WE DID
;+
;ERROR
	ERROR+5				;WE DIDN'T
;-

; FIND
;	SEARCHES CURRENT BUFFER. IF SEARCH FAILS,WRITES CURRENT BUFFER
;	READS NEXT,AND TRIES AGAIN

FIND:	JSR	PC,TMODE		;GET SEARCH OBJECT
	INCB	SRCFLG			;SET FLAG SO EOF CAUSES SRCH ERROR
E79$:	JSR	PC,SEARCH		;FIND OBJECT
	 BR	PSDONE			;SUCCESSFUL
	MOV	ARG,-(SP)		;SAVE SEARCH ARGUMENT
	MOV	#1,ARG			;WE WANT TO DO A 1N
	JSR	PC,NEXT			;FAILED-GET IN NEXT PAGE
	MOV	(SP)+,ARG		;RESTORE SEARCH ARG
	BR	E79$			;AND TRY AGAIN

; POSITION
;	SEARCHES CURRENT BUFFER. IF SEARCH FAILS,KILLS THIS
;	BUFFER,READS NEXT, AND TRIES AGAIN.

POSITN:	JSR	PC,TMODE		;GET TEXT OBJECT
	INCB	SRCFLG			;SET FLAG SO EOF CAUSES SEARCH ERROR
E80$:	JSR	PC,SEARCH		;FIND IT
	 BR	PSDONE			;SUCCESSFUL
	INCB	SLSFLG			;FAILURE
	JSR	PC,BEGIN		;PTR TO BEGINNING
	JSR	PC,DELETE		;DO A /D
	JSR	PC,READ			;GET NEXT
	BR	E80$			;TRY AGAIN

PSDONE:	RTS	PC			;SEARCH IS DONE

; NEXT
;	EQUIVALENT TO B /W /D R

NEXT:	JSR	PC,BEGIN		;DO A B
	INCB	SLSFLG			;SET ARG="/"
	JSR	PC,WRITE		;DO A /W
	JSR	PC,DELETE		;DO A /D
	JSR	PC,READ			;DO A R
	DEC	ARG
	BGT	NEXT
	RTS	PC			;RETURN

; LEFT BRACKET (<)
;	STORES COMMAND CHAR ADDRESS ON ITERATION STACK,FOLLOWED BY COUNT

LFTBRK:	CMP	ISTACK,#ISTCKE		;STACK FULL?
	BGT	E81$			;NO
;+
;ERROR
	ERROR+0				;YES-"<>" ERROR
;-

E81$:	MOV	CREL,-(ISTACK)		;SAVE CURRENT CS POINTER ON
					; ITERATION STK
	MOV	ARG,-(ISTACK)		;SAVE COUNT
	RTS	PC			;RETURN

; RIGHT BRACKET (>)
;	CHECKS COUNT ON TOP OF ITERATION STACK
;	IF ZERO,POPS ENTRY OFF STACK AND CONTINUES.
;	IF NOT ZERO,MOVES ADR ON STACK INTO CREL

RGTBRK:	CMP	ISTACK,#ISTCKA		;STACK EMPTY?
	BLO	RGTB1			;NO
;+
;ERROR
	ERROR+0				;YES-"<> ERROR"
;-

RGTB1:	DEC	(ISTACK)		;DECREASE ITERATION COUNT BY 1
	BLE	E82$			;THIS LOOP DONE?
	MOV	2(ISTACK),CREL		;NO-RESET CREL TO START OF THIS LOOP
	RTS	PC			;RETURN

E82$:	CMP	(ISTACK)+,(ISTACK)+	;LOOP DONE-DELETE ITEM FROM STACK
	RTS	PC

; EXECUTE MACRO
;	SAVES CURRENT COMMAND STRING POINTER AND STARTS COMMAND LOOP
;	WORKING ON MACRO BUFFER

EMACRO:	INCB	MACFLG			;WE ARE STARTING A MACRO
	CMP	MBSTRT,BEND		;IS MACRO BUFFER EMPTY?
	BLO	E83$			;NO-GO AHEAD
;+
;ERROR
	ERROR+6				;YES-MACRO ERROR
;-

E83$:	MOV	CREL,MACR1		;NO-SAVE CURRENT CS POINTER
	MOV	MBSTRT,CBASE		;POINT COMMAND POINTER TO MACRO BUFFER
	MOV	ARG,MACCNT		;SET UP MACRO COUNT
	TST	(SP)+			;CLEAN OFF STACK BEFORE STARTING
					; NEW LINE.THIS IS CALLED VIA JSR BUT
					; DOES NO RTS.
	JMP	COMAND			;EXECUTE MACRO COMMAND STRING

; SAVE
;	MOVES CHARS FROM PTR THROUGH ADR INTO SAVE BUFFER

SAVE:	JSR	PC,LINARG		;SAVE IS A LINE COMMAND
	SUB	PTR,R4			;# OF CHARS TO SAVE
	MOV	PTR,R3			;START MOVING AT POINTER
	MOV	MBSTRT,R2
	SUB	R4,R2			;R2-> START OF NEW SAVE BUFFER
	CMP	R2,CBEND		;ENOUGH ROOM?
	BHI	E85$			;YES
;+
;ERROR
	ERROR+4				;"NO ROOM"
;-

E85$:	MOV	R2,SBSTRT		;SET NEW SBSTRT
E86$:	TST	R4			;DONE?
	BLE	E87$			;YES
	MOVB	(R3)+,(R2)+		;SAVE CHAR
	DEC	R4			;DECREASE COUNT
	BR	E86$

E87$:	RTS	PC			;FINISHED

; UNSAVE
;	INSERTS SAVE BUFFER AT POINTER. IF 0U,ZEROES SAVE BUFFER

UNSAVE:	TST	ARG			;IS ARG=0?
	BNE	E88$			;NO
	MOV	MBSTRT,SBSTRT		;YES-ZERO SAVE BUFFER
	RTS	PC			;RETURN

E88$:	MOV	#OBLENG,R4		;R4 POINTS TO OBJECT LENGTH
	MOV	MBSTRT,(R4)
	SUB	SBSTRT,(R4)+		;LENGTH OF SAVE BUFFER=OBJECT LENGTH
	MOV	SBSTRT,(R4)		;START OF SAVE BUFFER IS START
					; OF TEXT OBJECT
	SUB	CBASE,(R4)		;OBSTART IS THE RELATIVE ADDR OFF
					; THE MOVED CIB
	TSTB	MACFLG			;MACRO IN PROGRESS?
	BNE	E89$			;YES, INSERT WILL NOT ADD OBLONG
					; TO CBASE
	SUB	OBLENG,(R4)		;INSERT WILL ADD OBLENG TO CBASE
					; AS PART OF NORMAL OPERATION
E89$:	JMP	IUCOM			;DO AN INSERT,TREATING THE SAVE BUFFER
					; AS THE TEXT OBJECT

; READ
;	INPUTS CHARS TO PAGE BUFFER UNTIL FF OR EOF IS SEEN,OR WE GET
;	WITHIN 500 CHARS FROM END AND A CRLF IS SEEN

READ:	CLRB	SRFLG			;CLEAR SUCCESSFUL READ FLAG
	TSTB	INOFLG			;IS THERE AN INPUT FILE OPEN?
	BNE	1$			;BRANCH IF YES
;+
;ERROR
	ERROR+21			;"NO FILE OPEN FOR INPUT"
;-

1$:	MOV	CBSTRT,-(SP)		;SAVE CURRENT CIB START
	MOV	(SP),R2
	MOV	CBEND,R3
	MOV	SBSTRT,R4		;SET UP MOVE TO OPEN UP PB
	DEC	R4			;MOVE TO RIGHT BELOW SAVE BUFFER
	JSR	PC,MOVUP		;MAKE ROOM FOR READ
	MOV	R4,-(SP)		;SAVE NEW CIB START
	MOV	CBSTRT,R4		;FIRST READ CHAR GOES INTO R4
E95$:	MOV	(SP),R3			;LAST FREE SPOT IN R3
	SUB	#12,R3			;LEAVE ROOM FOR EMERGENCY
					; COMMAND STRING
	SUB	R4,R3			;ANY ROOM LEFT?
	BHI	E96$			;YES
	JSR	PC,READRS		;NO, RESTORE BUFFER BEFORE REPORTING
;+
;ERROR
	ERROR+4				; 'NO ROOM' ERROR
;-

E96$:	JSR	PC,BLKEMT		;YES-GET CHAR FROM FILE
	TST	R0			;IS CHARACTER A NULL?
	BEQ	E90$			;DON'T STORE IN BUFFER IF YES
	MOVB	R0,(R4)+		;PUT CHAR IN TEXT BUFFER
E90$:	TSTB	EOFFLG			;IS IT END OF FILE?
	BNE	E97$			;YES-EOF MEANS END OF READ
	MOVB	R0,SRFLG		;MARK THIS READ A SUCCESSFUL
	CMPB	R0,#FF			;IS CHAR FF?
	BEQ	E97$			;YES-READ IS OVER
	CMP	#776,R3			;NO-ARE WE WITHIN 500 OF END?
	BLO	E95$			;NO-READ NEXT CHAR
	CMPB	R0,#LF			;YES-IS CHAR LF?
	BNE	E95$			;NO-GET NEXT
	CMPB	-2(R4),#CR		;YES-WAS LAST CR?
	BNE	E95$			;NO-GET NEXT
					;YES-END READ

E97$:	JSR	PC,READRS		;RESTORE BUFFERS
	TSTB	MACFLG			;MACRO IN PROGRESS?
	BNE	E98$			;YES
	ADD	R4,CBASE		;NO-UPDATE CS POINTER
E98$:	TSTB	SRFLG			;AT LEAST ONE CHAR IN THIS READ?
	BNE	E99$			;YES-RETURN
	TSTB	EXFLG			;EXIT IN PROGRESS?
	BNE	E99$			;YES-DON'T REPORT THE ERROR
	JMP	EOFERR			;NO-EOF ERROR;SRCH FAIL IF SEARCHING

E99$:	RTS	PC

READRS:	MOV	(SP)+,R0		;SAVE RETURN ADDR IN R0
	MOV	SBSTRT,R3
	DEC	R3			;MOVE FROM RIGHT BELOW SAVE BUFFER
	MOV	(SP)+,R2		;SET UP MOVE DOWN
	MOV	R4,-(SP)		;SAVE NEW CIB STRT
	JSR	PC,MOVDWN		;SLIDE CIB BACK DOWN
	MOV	(SP)+,R4
	SUB	(SP)+,R4		;GET # OF CHARS READ
	ADD	R4,CBSTRT
	ADD	R4,CBEND		;UPDATE CIB POINTERS
	MOV	R0,PC			;RETURN

; MACRO
;	PUTS COMMAND MACRO INTO MACRO BUFFER
;	0M EMPTIES MACRO BUFFER

MACRO:	TST	ARG			;IS IT 0M?
	BNE	E102$			;NO-INSERT MACRO
	MOV	BEND,R4
	MOV	SBSTRT,R2
	MOV	MBSTRT,R3
	JSR	PC,MOVUP		;YES, SLIDE SAVE BUFFER TO END OF CORE
	MOV	R4,SBSTRT
	MOV	BEND,MBSTRT		;MACRO BUFFER NOW LOGICALLY EMPTY
	RTS	PC

E102$:	MOV	SBSTRT,R2
	MOV	MBSTRT,R3
	MOV	CBEND,R4
	JSR	PC,MOVDWN		;SLIDE SB DOWN,MAKING ROOM FOR INSERT
	MOV	BEND,TMP
	SUB	R4,TMP			;MAX # OF CHARS ALLOWED IN MACRO
	SUB	#10,TMP			;LEAVE ROOM FOR EMERGENCY
					; COMMAND STRING
	CLR	R2			;ZERO COUNT OF MACRO CHARS
	INC	R1			;R1 NOW POINTS TO DELIMITER
	MOVB	(R1)+,R3		;R3 HOLDS DELIMETER CHAR
	ADD	#2,CREL
E103$:	CMPB	(R1),R3			;FIND SECOND DELIMETER
	BEQ	E106$			;FOUND IT
	INC	R2			;NOT FOUND-INCREMENT MACRO CHAR COUNT
	TSTB	(R1)+			;END OF STRING?
	BEQ	E104$			;YES-DELIMITER ERROR
	INC	CREL			;NO-BUMP POINTER
	BR	E103$

E104$:	JSR	PC,E105$		;RESTORE SAVE BUFFER BEFORE REPORTING
;+
;ERROR
	ERROR+6				; 'DELIMITERS DONT MATCH' ERROR
;-

E106$:	CMP	R2,TMP			;IS THERE ENOUGH ROOM FOR THIS MACRO?
	BLO	E107$			;THERE IS
	JSR	PC,E105$		;RESTORE SAVE BUFFER BEFORE REPORTING
;+
;ERROR
	ERROR+4				; 'NO ROOM' ERROR
;-

E107$:	MOV	BEND,R3			;R3 POINTS TO END OF MACRO BUFFER
	CLRB	(R3)			;LAST BYTE OF MACRO MUST BE 0
E108$:	TST	R2			;DONE?
	BEQ	E109$			;YES
	MOVB	-(R1),-(R3)		;NO, PUT CHAR IN MACRO BUFF
					; (FROM RIGHT TO LEFT)
	DEC	R2			;DECREASE COUNT
	BR	E108$

E105$:	MOV	BEND,R3			;ON ERROR,ZERO MACRO BUFFER
E109$:	MOV	R3,MBSTRT		;START OF MBUFF
	CMPB	-(R4),-(R4)		;SUBTRACT 2 FROM R4
	MOV	R4,R3
	MOV	CBEND,R2
	MOV	MBSTRT,R4		;MOVE SAVE BUFFER UP AGAINST
					; MACRO BUFFER
	DEC	R4			;LAST LOC OF MOVE IS MBSTRT-1
	JSR	PC,MOVUP
	MOV	R4,SBSTRT		;SET START OF SB
	RTS	PC

; SUBROUTINE FNGET
;	CALLS CSI IN SPECIAL MODE TO CONVERT TEXT OBJECT INTO
;	RAD50 FILE DESCRIPTOR

FNGET:	MOV	R0,-(SP)		;SAVE R0 (WILL BE DESTROYED BY TMODE)
	MOV	#CSIBLK,R2		;R2 -> WORK AREA FOR CSI
	MOV	#CSISTR,R3		;R3 -> INPUT STRING AREA
	JSR	PC,TMODE		;ISOLATE TEXT OBJECT
	CMP	OBLENG,#19.		;FILE DESCRIPTOR MORE THAN 19 CHARS?
	BGT	E55$			;YES-ERROR
	MOV	OBSTRT,R4		;RELATIVE START OF TEXT STRING
	ADD	CBASE,R4		;MAKE IT ABSOLUTE
	MOV	R3,-(SP)		;SAVE ADDRES OF CSI AREA
E56$:	DEC	OBLENG			;MORE CHARS IN NAME?
	BLT	E57$			;NO
	MOVB	(R4)+,(R3)+		;COPY NAME INTO CSI AREA
	BR	E56$

E57$:	MOVB	#EQSIGN,(R3)+		;END WITH "="
	CLRB	(R3)+
	MOV	(SP)+,R3
	.CSISP	R2,#DEFEXT,R3		;SPECIAL MODE CSI
	BCC	E53$			;IF ERROR,NAME MUST BE ILLEGAL
;+
;ERROR
E55$:	ERROR+16			;ILLEGAL NAME
;-

E53$:	TST	(SP)+			;MAKE SURE THERE WERE NO SWITCHES
	BNE	E55$			;THERE WERE
	MOV	#4,R3			;DESCRIPTOR IS 4 WORDS LONG
	MOV	(SP)+,R0		;RESTORE ADDRESS OF FILE BLOCK
E54$:	MOV	(R2)+,(R0)+		;PUT DESCRIPTOR IN NAME BLOCK
	DEC	R3			;DONE?
	BGT	E54$			;NO
	MOV	(R2)+,FILENG		;REMEMBER LENGTH FOR ENTER
	RTS	PC			;YES-RETURN

; EDIT VERSION
;	TYPES VERSION # AND CREATION DATE ON TTY

EVERS:	JSR	PC,CRLF
	.PRINT	#VMSG
	RTS	PC			;TYPE THE MESSAGE AND RETURN

VMSG:	.NLCSI	PART=RLSVER
	PATLVL	== .-2
	.EVEN

; EDIT LOWER
;	ENABLES UPPER/LOWER CASE EDITING BY SETTING UPPER/LOWER
;	CASE BIT IN JSW

ELOWER:	BIS	#TTLC$,@#JSW 		;SET UL CASE BIT IN JSW (BIT 14)
	RTS	PC

; EDIT UPPER
;	SETS EDITING TO UPPER CASE ONLY BY CLEARING UPPER/LOWER
;	CASE BIT IN JSW

EUPPER:	BIC	#TTLC$,@#JSW		;TURN OFF UL CASE
	RTS	PC

; START ROUTINE
;	CALCULATES HOW MUCH CORE IS AVAILABLE  ,SETS THE TOP,THEN ASKS
;	FOR FIRST COMMAND.

	BR	RESTRT			;RE-ENTRY ADDRESS
START:	JSR	PC,ONCEONLY		;EXECUTE ONCE-ONLY STARTUP CODE
					; TO SET TRAP PS MASK AND SCOPE
					; FLAG
START1:	MOV	EDSTRT,SP		;STACK START
	MOV	#ERRORT,@#TRAPV		;SET UP TRAP VECTOR
	MOV	TRAPPS,@#TRAPV+2	;SET UP TRAP VECTOR PS
	MOV	#NEGFLG,R0
1$:	CLR	(R0)+			;LOOP TO INITIALIZE ALL FLAGS TO 0
	CMP	R0,#EQLENG
	BLOS	1$			;BRANCH IF NOT DONE
	.SRESET				;PURGE ANY FILES THAT MAY BE OPEN
	.SERR				;WE WANT TO HANDLE ALL ERRORS
	MOV	@#SYSPTR,R0		;MONITOR BASE IN R0
	MOV	$USRLC(R0),R0		;BOTTOM OF USR INTO R0
	TST	-(R0)			;WE WANT ADDRESS JUST BEFORE USR START
	MOV	EDTOP,-(SP)		;ADDR OF TOP OF EDITOR TO TEMP
	ADD	#20000,(SP)		;FIND ADDR OF TOP OF 4K PAGE BUFF
	CMP	R0,(SP)			;AT LEAST 4K OF BUFFER SPACE?
	BHI	2$			;BRANCH IF YES-NO NEED TO SWAP USR
	MOV	#177776,R0		;WANT ALL WE CAN GET
2$:	.SETTOP
	SUB	#17000,(SP)		;FIND ADDR OF SART OF PAGE BUFF+1000
	CMP	R0,(SP)+		;NEED AT LEAST 512 CHARS SPACE TO RUN
	BHI	E117$			;BR IF WE GOT IT
NOROOM:	.PRINT	#OVFLO			;NOT ENOUGH
	.PRINT	#MSG4			;"INSUFFICIENT MEMORY"
	BISB	#<FATAL$>,@#USERRB	;INDICATE FATAL LEVEL ERROR
	.EXIT

	.NLIST	BIN
OVFLO:
	.NLCSI	TYPE=I,PART=PREFIX
	.ASCII	/F-/<200>
	.EVEN
	.LIST	BIN

RESTRT:	INC	(PC)+			;SET FLAG SAYING RESTART DONE
RSFLAG:	.WORD	0			;NON-ZERO WHEN EDIT RE-ENTERED
	MOV	PBSTRT,EDTOP		;ADJUST EDITOR TOP IN CASE
					; HANDLER IS LOADED
	BR	START1			;AND BEGIN

E117$:	MOV	#USRSWP,@#UFLOAT	;USR SWAPS HERE
	TST	RSFLAG			;ARE WE RESTARTING?
	BNE	1$			;BR IF YES
	MOV	R0,OLDTOP		;NO, FIRST TIME:REMEMBER BUFFER TOP
	BR	3$			;AND PROCEED TO ESTABLISH POINTERS

1$:	CMP	R0,OLDTOP		;USER CHANGED CORE LAYOUT?
	BEQ	2$			;BR IF NOT
	CLRB	VT11OK			;YES-FORCE DISPLAY TO STAY OFF
	BR	3$			; AND ESTABLISH NEW POINTERS

2$:	TSTB	VT11OK			;RESTARTED, CORE SAME, DISPLAY
					; FILE BUILT?
	BEQ	3$			;BR IF NOT
	MOV	DBUFR,R0		;YES, TOP MUST BE SET TO BOTTOM
					; OF DISPLAY FILE
	TST	-(R0)
3$:	MOV	#BEND,R1		;DYNAMIC PTRS START ADDR
	MOV	R0,(R1)+		;SET BEND
	MOV	R0,(R1)+		;SET MBSTRT
	MOV	R0,(R1)+		;SET SBSTRT
	MOV	EDTOP,R0		;TOP OF EDITOR
	MOV	R0,(R1)+		;SET CBEND
	MOV	R0,PTR			;SET PTR TO EDTOP
	TST	RSFLAG			;WERE WE RESTARTED?
	BNE	VTRESTART		;YES, DON'T ERASE TEXT BUFFER
					; AND RESTART VT11
	MOV	R0,(R1)+		;SET CBSTRT
	MOV	R0,(R1)			;SET PBSTRT
	BIT	#CHAIN$,@#JSW		;WERE WE CHAINED TO?
	BEQ	E118$			;BRANCH IF NOT
	JSR	PC,DCLS			;YES-PROCESS EDIT COMMAND ARGS
E118$:	.LNKRT				;LINK TO MONITOR
	BMI	NDSP			;CAN'T LINK - NOW
	BCC	1$			;SCROLLER NOT ACTIVE?
	.UNLNK				;IT'S NOT, FORGET DISPLAY
	BR	NDSP			;CONTINUE INIT

1$:	JSR	PC,INDSP		;INIT DISPLAY AND START IT
VT5$:	JSR	PC,DUPDAT		;UPDATE DISPLAY

NDSP:	BIS	#RSTRT$!TTSPC$,@#JSW	;SET TT SPECIAL MODE AND MAKE
					; PROGRAM RE-ENTERABLE
	.QSET	#IOQ,#3			;INIT I/O Q FOR 3 ENTRIES
	.SCCA	#AREA,#CCSTAT		;SET UP CTRL C STATUS LOC
	CMP	CBSTRT,CBEND		;IS THERE A COMMAND
					; TO EXECUTE ON STARTING?
	BHIS	1$			;BRANCH IF NOT
	JMP	COMAND			;YES-GO EXECUTE IT

1$:	JMP	ASTER			;NO-GET FIRST COMMAND

VTRESTART:
	TSTB	VT11OK			;WAS DISPLAY FILE BUILT?
	BEQ	NDSP			;NO-LEAVE
	TSTB	DSFLG			;WAS DISPLAY BEING USED?
	BEQ	NDSP			;BR IF NOT-LEAVE
	.LNKRT				;LINK TO DISPLAY HANDLER
	BMI	NDSP			;LINK ERROR-FORGET DISPLAY
	JSR	PC,DREST		;YES-RESTORE TO TTY
	JSR	PC,DSTART		;START THE DISPLAY
	BR	VT5$			;AND REFRESH

; EDIT DISPLAY
;	SETS UP DISPLAY ROUTINES IF DISPLAY IS AVAILABLE

EDSPLY:	TSTB	DSFLG			;ARE WE CURRENTLY USING DSPLY?
	BNE	2$			;YES - RETURN
	TSTB	FTFLG			;FIRST COMMAND?
	BNE	4$			;YES-MUST BUILD DISP FILE
	TSTB	VT11OK			;NO-WAS DISPLAY FILE BUILT?
	BNE	1$			;YES-OK TO TURN DISP ON
;+
;ERROR
	ERROR+2				;NO-ILLEGAL COMMAND
;-

1$:	.LNKRT
	JSR	PC,DSTART		;START THE DISPLAY
	BR	5$			; AND REFRESH IT

4$:	.LNKRT				;LINK TO MONITOR
	TST	R0			;IS DSPLY THERE?
	BMI	3$			;NO - ERROR
	JSR	PC,INDSP		;INIT DISPLAY
5$:	JSR	PC,DUPDAT		;REFRESH DISPLAY
2$:	RTS	PC			;RETURN

;+
;ERROR
3$:	ERROR+12			;ILLEGAL DEVICE
;-

; EDIT CONSOLE
;	DISABLES DISPLAY FUNCTIONS IF ACTIVE AND USES TTY
;	AS OUTPUT DEVICE

ECONS:	TSTB	DSFLG			;CURRENTLY USING DISPLAY?
	BEQ	1$			;NO - IGNORE CMD AND RETURN
	.UNLNK				;UNLINK FROM MONITOR
	JSR	PC,DREST		;FIX TYPCHAR FOR TTY
	CLRB	DSFLG			;MARK DISPLAY GONE
1$:	RTS	PC			;RETURN
	.SBTTL	VT11 DISPLAY SUBROUTINES

; SUBROUTINE TO START THE VT11 DISPLAY

DSTART:	.CLEAR				;FLUSH ANY PICTURES
	MOV	DBUFR,DPTR		;AND INIT DISPLAY FILE POINTER
	ADD	#DTEXT-DSFILE,DPTR
	CLR	DARG
	JSR	PC,DCALL		;PUT DRET AT END OF FILE
	.SCROL	#SCBUF			;INIT SCROLL PARAMETERS
	.INSRT	DBUFR			;INSERT THE EDIT DISPLAY FILE
	INCB	DSFLG			;INDICATE DISPLAY NOW RUNNING
	.TTYOU	#LF			;LF TO CLEAR SCROLLER
	RTS	PC

; SUBROUTINE TO UPDATE THE DISPLAY BUFFER

DUPDAT:	.STOP				;STOP FILE TO WORK ON IT
	MOV	DSARG,ARG		;SET UP NUMBER OF LINES TO OUTPUT
2$:	MOV	DBUFR,DPTR		;POINT TO DISPLAY BUFR
	ADD	#DTEXT-DSFILE,DPTR	;SET DFILE POINTER TO START
					; OF TEXT AREA
	MOV	DSPLY,E120$		;SET UP TO DIVERT TTY
	MOV	DSPLY+2,E120$+2 	;OUTPUT TO DISPLAY BUFR
	MOV	DSPLY,E122$
	MOV	DSPLY+2,E122$+2
	MOV	DSPLY,E128$
	MOV	DSPLY+2,E128$+2
	MOV	TTY,OUTINS		;SET UP LWCOM CODE
	MOV	TTY+2,OUTINS+2		;TO USE TYPCHAR ROUTINE
	MOV	#10,TABCNT		;RESET TAB COUNTER
	CLRB	SLSFLG			;CLEAR "/" SEEN FOR LIST CMD
	INCB	NEGFLG			;SIMULATE A MINUS
	JSR	PC,LINARG		;GET ADDR OF FIRST CHAR IN R4
	CMP	R4,PTR			;IS IT BEYOND CURSOR?
	BHIS	5$			;BR IF YES-OK TO OUTPUT
	MOV	PTR,-(SP)		;PTR TO TEMP
	SUB	R4,(SP)			;GET # OF CHARS BEFORE PTR
	CMP	(SP)+,#DFSIZE/2		;WILL THEY FILL 1/2 OF DISP FULE?
	BLOS	5$			;BR IF NO-OK TO PROCEED
	DEC	ARG			;TRY AGAIN WITH FEWER LINES
	BGT	2$
	BR	4$			;STRANGE FILE-GET OUT

5$:	JSR	PC,LWCOM		;L COMMAND
	MOV	#CUR1,R1		;SETUP CURSOR ADJUSTMENT
	MOV	#100,R2			;BIT MASK FOR VECTOR WORD
	CMP	#15,R0			;LAST CHAR OUT A CR?
	BEQ	1$			;YES - MINUS CURSOR
	BIC	R2,(R1)+		; POSITIVE CURSOR
					; CLEAR MISVY IN FIRST VECT WORD
1$:	BIS	R2,(R1)+		;SET MISVY (MINUS CURSOR)
	BIC	R2,(R1)			;CLEAR MISVY
	MOV	#CURSOR,DARG		;INSERT CALL TO CURSOR
	JSR	PC,DCALL		;INTO DISPLAY BUFR.
	CLRB	NEGFLG			;SIMULATE A PLUS
	JSR	PC,LWCOM		;L COMMAND.
4$:	CLR	DARG			;INSERT A DRET 0
	JSR	PC,DCALL		;INTO DISPLAY BUFR.
	JSR	PC,DREST		;RESTORE TYPCHAR TO TTYOUT
	.START				;START DISPLAY
	RTS	PC

; SUBROUTINE TO RESTORE TO TERMINAL OUTPUT AFTER DISPLAY REFRESH

DREST:	MOV	TTYOUT,E120$		;RESTORE .TTYOUT TO
	MOV	TTYOUT+2,E120$+2	;TYPCHAR ROUTINE
	MOV	TTYOUT,E122$
	MOV	TTYOUT+2,E122$+2
	MOV	TTYOUT,E128$
	MOV	TTYOUT+2,E128$+2
	RTS	PC

; SUBROUTINE TO INSERT A CHARACTER INTO DISPLAY BUFFER.

DINSRT:	MOV	DBUFR,-(SP)
	ADD	#DFSIZE-10,(SP)		;DETERMINE ADDRESS OF LAST
					; AVAILABLE CHARACTER POSITION
	CMP	DPTR,(SP)+		;PAST IT?
	BHIS	1$			;YES, GO EXIT
	MOVB	R0,@DPTR		;NO, INSERT THE CHAR.
	INC	DPTR			;AND BUMP POINTER.
1$:	RTS	PC

; SUBROUTINE TO INSERT A DISPLAY SUBROUTINE CALL INTO DISPLAY FILE

DCALL:	BIT	#1,DPTR			;WORD BOUNDARY?
	BEQ	1$			;YES
	CLR	R0			;NO, INSERT A NULL
	JSR	PC,DINSRT		;TO ALIGN POINTER
1$:	MOV	#DJSR,@DPTR		;NOW INSERT A CALL
	ADD	#2,DPTR			;BUMP THE POINTER
	MOV	DARG,@DPTR		;INSERT SUBR. ADDRESS
	ADD	#2,DPTR			;BUMP POINTER
2$:	RTS	PC

DARG:	.WORD	0			;ADDR. OF DISPLAY SUBR
DPTR:	.WORD	0			;POINTER INTO DISPLAY FILE
DBUFR:	.WORD	0			;ADDRESS OF START OF DISPLAY FILE
DSPLY:	JSR	PC,@#DINSRT		;CALL TO A ROUTINE TO
					; INSERT ACHAR. INTO DISPLAY BUFR.
TTYOUT:	.TTYOU				;TTYOUT CODE FOR SETUP
DSARG::	.WORD	12			;LINE ARG. FOR L COMD.
	.SBTTL	FETCH	- FETCH DEVICE HANDLER

; SUBROUTINE FETCH
;	LOADS DEVICE HANDLER INTO CORE IF NOT THERE ALREADY
;	EXPECTS R2 TO POINT TO FILE DESCRIPTOR BLOCK

FETCH:	.DSTAT	#CORADD,R2		;GET INFO ON HANDLER
	BCC	2$			;BRANCH IF NO ERROR
;+
;ERROR
1$:	ERROR+12			;ILLEGAL DEVICE
;-

2$:	TST	CORADD+4		;ALREADY RESIDENT?
	BNE	FETCHR			;YES - RETURN
	INC	CORADD+2		;MAKE SURE IT FITS
	MOV	CORADD+2,R4		;GET HANDLER SIZE
	MOV	SBSTRT,R3		;FREE AREA TOP
	SUB	CBEND,R3		;MINUS BOTTOM
	SUB	#10,R3			;LESS EMERGENCY CMD SPACE
	CMP	R4,R3			;IS HNDLR SMALLER THAN AVAILABLE?
	BLOS	3$			;YES - GO INSERT IT
;+
;ERROR
	ERROR+4				;'N O  R O O M'
;-

3$:	TST	HAND1N			;AREA 1 IN USE?
	BNE	5$			;YES - USE AREA 2
	MOV	R2,R0			;SAVE R2
	JSR	PC,SETUP1		;SET UP PARMS FOR MOVE
	JSR	PC,MUP			;MOVE PB AND CIB TO MAKE HOLE
	MOV	R0,R2			;RESTORE R2
	.FETCH	EDTOP,R2		;GET THE HANDLER INTO HOLE
	BCC	4$			;BRANCH IF NO ERROR
	JSR	PC,CLOSE1		;CLOSE AREA 1 HOLE
7$:	TSTB	@#ERRBYT		;IS ERROR CODE NEGATIVE?
	BEQ	1$			;NO-MUST BE ILLEGAL DEVICE
;+
;ERROR
	ERROR+17			;YES-READ ERROR ON SYS
;-

4$:	MOV	(R2),HAND1N		;REMEMBER THE DEVICE NAME IN AREA 1
	BR	FETCHR			;EXIT

5$:	MOV	R2,R0			;SAVE R2
	NEG	R4			;SET TO DECREASE PTRS
	JSR	PC,SETUP2		;SET UP PARMS FOR MOVE DOWN
	JSR	PC,MDWN			;MOVE SB AND MB DOWN TO MAKE HOLE
	MOV	BEND,R3			;GET ADDRESS OF HOLE BOTTOM
	INC	R3			;MAKE IT WORD BOUNDARY
	BIC	#1,R3			;ADDRESS TO LOAD HANDLER
	MOV	R0,R2			;RESTORE R2
	.FETCH	R3,R2			;GET HANDLER
	BCC	6$			;BRANCH IF NO ERROR
	JSR	PC,CLOSE2		;CLOSE AREA 2 HOLE
	BR	7$			;PROCESS EMT ERROR

6$:	MOV	(R2),HAND2N		;REMEMBER DEVICE NAME IN AREA 2
	BR	FETCHR			;EXIT

UNSET1:	MOV	CORADD+2,R4		;GET HANDLER (HOLE) SIZE
	NEG	R4			;SET TO DECREASE PTRS
SETUP1:	MOV	PBSTRT,R2		;BOTTOM ADDR OF AREA TO BE MOVED
	ADD	R4,PBSTRT		;UPDATE BOTTOM ADDR
	ADD	R4,CBSTRT		;UPDATE CIB ADDR
	ADD	R4,PTR			;UPDATE CIB PTR
	TSTB	MACFLG			;ARE WE IN A MACRO?
	BNE	1$			;YES - CONTINUE
	ADD	R4,CBASE		;UPDATE CMD STRING PTR
1$:	MOV	CBEND,R3		;TOP ADDR OF AREA TO BE MOVED
	ADD	R4,CBEND		;UPDATE TOP ADDR
	RTS	PC			;RETURN

UNSET2:	MOV	CORADD+2,R4		;GET HANDLER (HOLE) SIZE
SETUP2:	MOV	SBSTRT,R2		;BOTTOM ADDR OF AREA TO BE MOVED
	ADD	R4,SBSTRT		;UPDATE BOTTOM ADDR
	MOV	BEND,R3			;TOP ADDR OF AREA TO BE MOVED
	ADD	R4,BEND			;UPDATE TOP ADDR
	ADD	R4,MBSTRT		;UPDATE MB START
	TSTB	MACFLG			;ARE WE IN A MACRO
	BEQ	1$			;NO - CONTINUE
	ADD	R4,CBASE		;UPDATE MB PTR
1$:	RTS	PC			;RETURN

CLOSE1:	JSR	PC,UNSET1		;SETUP TO ELIMINATE HOLE 1
MDWN:	ADD	R2,R4			;MOVE DESTINATION
	JMP	MOVDWN			;CLOSE IT AND RETURN

CLOSE2:	JSR	PC,UNSET2		;SETUP TO ELIMINATE HOLE 2
MUP:	ADD	R3,R4			;MOVE DESTINATION
	JMP	MOVUP			;CLOSE IT AND RETURN

; SUBROUTINE MOVUP
;	MOVES THE BYTES FROM R2 THROUGH R3 TO HIGHER CORE,WORKING DOWN.
;	STARTS AT R3,WORKS TO R2. HIGHEST ADDR OF MOVE IS IN R4

MOVUP:	INC	R3			;BACK UP IN PREPARING FOR DECREMENT
	INC	R4			;DITTO
E65$:	CMP	R3,R2			;DONE?
	BLOS	E66$			;YES-RETURN
	MOVB	-(R3),-(R4)		;NO-MOVE CHARACTER
	BR	E65$			;AND LOOP

E66$:	RTS	PC

; SUBROUTINE MOVDWN
;	MOVES THE BYTES FROM R2 THROUGH R3 TO LOWER CORE,WORKING UP
;	STARTS AT R2,WORKING UP TO R3. LOWEST ADDR OF MOVE IS IN R4

MOVDWN:	CMP	R2,R3			;DONE?
	BHI	E67$			;YES-RETURN
	MOVB	(R2)+,(R4)+		;NO-MOVE THE CHARACTER
	BR	MOVDWN			;LOOP

E67$:	RTS PC

FETCHR:	RTS PC

; SUBROUTINE RELEAS
;	RELEASES HANDLER IF NO LONGER NEEDED
;	R2 POINTS TO HANDLER NAME

RELEAS:	.DSTAT	#CORADD,#INBLK		;FIND OUT WHAT INPUT DEVICE IS
	MOV	CORADD,-(SP)		;REMEMBER IT
	.DSTAT	#CORADD,#OUTBLK		;FIND OUT WHAT OUTPUT DEVICE IS
	CMP	CORADD,(SP)+		;ARE THEY THE SANE
	BEQ	1$			;YES - CAN'T RELEASE HANDLER
	.DSTAT	#CORADD,R2		;GET LENGTH OF HANDLER
	INC	CORADD+2		;ACCOUNT FOR BOUNDARY ROUNDUP
	CMP	(R2),HAND1N		;IS THIS HANDLER IN AREA 1?
	BNE	2$			;NO-TRY AREA 2
	CLR	HAND1N			;YES-MARK AREA 1 FREE
	.RELEA	R2			;RELEASE HANDLER
	JSR	PC,CLOSE1		;RECLAIM HANDLER SPACE 1
1$:	RTS	PC

2$:	CMP	(R2),HAND2N		;IS HANDLER IN AREA 2?
	BNE	1$			;NO-MUST BE SYSTEM HANDLER,SO LEAVE IT
	CLR	HAND2N			;YES-MARK AREA 2 FREE
	.RELEA	R2			;RELEASE HANDLER
	JSR	PC,CLOSE2		;RECLAIM HANDLER SPACE 2
	BR	1$

; SUBROUTINE EBCLOSE
;	FORCES OUT LAST BUFFER,THEN
;	IF AN EDIT BACKUP IS IN PROGRESS,RENAMES INPUT FILE
;	TO FILE .BAK,THEN CLOSES OUTPUT FILE.

EBCLOS:	TSTB	OTOFLG			;IS AN OUPUT FILE OPEN?
	BEQ	E72$			;NO-DON'T FORCE OUT LAST BLOCK
	TSTB	FFFLG			;IS OUTPUT FILE FULL?
	BNE	E72$			;YES-DON'T FORCE OUT LAST BUFFER
	MOV	PTR,R4			;SET UP R4 IN CASE OF ERROR
	JSR	PC,WFORCE		;FORCE OUT LAST BUFFER LOAD
	.WAIT	#13			;WAIT FOR LAST BUFFER TO BE WRITTEN
	BCS	BW2$			;WRITE ERROR
	MOV	#OBUFF1,R2		;ADDRESS OF BUFFER 1 IN R2
	JSR	PC,BUFZRO		;ZERO IT
	MOV	#OBUFF1,OBPTR		;RESET BUFFER POINTER
E72$:	TSTB	EBFLG			;IS AN EDIT BACKUP IN PROGRESS?
	BNE	1$			;YES
	RTS	PC			;NO-RETURN

1$:	.LOCK				;FREEZE USR IN CORE
	.RENAM	#AREA,#14,#OUTBLK	;RENAME INPUT FILE TO X.BAK
	.CLOSE	#13			;CLOSE OUTPUT FILE
	.UNLOC				;RELEASE USR FROM CORE
	CLRB	OTOFLG			;MARK OUTPUT FILE CLOSED
	CLRB	EBFLG			;NO EB IN PROGRESS ANY MORE
	RTS	PC			;RETURN

; SUBROUTINE WFORCE
;	WRITES LAST OUTPUT BUFFER INTO OUTPUT FILE,FOLLOWED BY A CTRL/Z

WFORCE:	CLR	TMP1			;AVOID ADDITIONAL CHAR
	CMP	OBPTR,#OBUFF2		;WHICH BUFFER IS CURRENT POINTER IN?
	BHI	BLKST2			;IN BUFFER 2-WRITE IT
	CMP	OBPTR,#OBUFF1		;IF BUFFER IS EMPTY,WE DON'T WANT IT
	BNE	BLKST8			;IN BUFFER 1-WRITE IT
	RTS	PC			;ELSE,RETURN

; SUBROUTINE BLKSTF
;	PUTS CHARS IN OUTPUT BUFFERS, CALLING WRITE WHEN A BUFFER IS FULL

BLKSTF:	MOV	R0,TMP1			;SAVE CHARACTER
	TSTB	OTOFLG			;IS AN OUTPUT FILE OPEN?
	BNE	BLKST7			;YES
;+
;ERROR
	ERROR+14			;"FILE NOT OPEN"
;-

BLKST7:	CMP	OBPTR,#OBUFF2		;IS BUFFER 1 FULL?
	BNE	BLKST1			;NO-CHECK BUFFER 2
BLKST8:	MOV	#OBUFF1,AREA+4		;YES-WRITE BUFFER 1
	MOV	#OBUFF2,R2		;REMEMBER: ZERO BUFFER 2 BEFORE USING
	JSR	PC,BWRITE		;WRITE BUFFER
	BR	BLKST3			;PUT CHAR IN BUFFER AND RETURN

BLKST1:	CMP	OBPTR,#OBEND		;IS BUFFER 2 FULL?
	BLO	BLKST3			;PUT CHAR IN BUFFER AND RETURN
BLKST2:	MOV	#OBUFF2,AREA+4		;WRITE BLOCK 2
	MOV	#OBUFF1,R2		;ZERO BUFF1 BEFORE USING
	JSR	PC,BWRITE
	MOV	#OBUFF1,OBPTR		;MOVE POINTER TO START OF BUFF1
BLKST3:	MOVB	TMP1,@OBPTR		;PUT CHAR IN OUTPUT BUFFER
	INC	OBPTR			;BUMP OUTPUT POINTER
	RTS	PC

BWRITE:	.WAIT	#13			;WAIT FOR LAST WRITE
	BCS	BW1$			;WATCH FOR ERROR ON LAST WRITE
	JSR	PC,CCCHEK		;CHECK FOR ^C^C BEFORE EACH WRITE
	.WRITE	#AREA,#13,,#400,OBLKNM	;WRITE 1 BLOCK INTO OUTPUT FILE
	BCS	BW1$			;ERROR
	INC	OBLKNM			;WRITE SUCCESSFUL SO BUMP BLK#
	JSR	PC,BUFZRO		;CLEAR BUFFER
	RTS	PC

BW1$:	MOV	R4,PTR			;ON ERROR, MOVE POINTER TO CURRENT
					; OUTPUT SPOT
BW2$:	TSTB	@#ERRBYT		;IS IT EOF?
	BEQ	2$			;YES
;+
;ERROR
	ERROR+22			;"WRITE ERROR"
;-

2$:	INCB	FFFLG			;SET OUPUT FILE FULL FLAG
;+
;ERROR
	ERROR+11			;"FILE FULL"
;-

; EDIT READ
;	PREPARES NEW FILE FOR INPUT

EREAD:	CLRB	INOFLG			;THERE IS NOW NO INPUT FILE OPEN
	.CLOSE	#12			;CLOSE ANY OPEN INPUT FILE
	MOV	#INBLK,R2
	JSR	PC,RELEAS		;RELEASE OLS INPUT HANDLER
	MOV	#INBLK,R0
	JSR	PC,FNGET		;GET NAME FOR NEW FILE
	MOV	#INBLK,R2
	.LOCK				;LOCK USR IN CORE
	JSR	PC,FETCH		;FETCH NEW INPUT HANDLER
	.LOOKU	#AREA,#12,#INBLK	;IT IS ER-USE LOOKUP
	BCC	E111$
	CLRB	EBFLG			;SO ANOTHER EB WON'T RENAME FILE
	TSTB	@#ERRBYT		;IS ERROR BYTE NEGATIVE?
	BMI	1$			;YES-SYS I/O ERROR
;+
;ERROR
	ERROR+13			;NO-FILE NOT FOUND

1$:	ERROR+17			;SYSTEM I/O ERROR
;-

E111$:	.UNLOC				;CHASE USR OUT OF CORE
	CLR	IBLKNM			;START BLOCK 0
	CLRB	EFFLG			;CLEAR LAST BLOCK READ FLAG
	CLRB	EOFFLG			;CLEAR END OF FILE
	MOV	#IBUFF1,R2
	JSR	PC,BREAD		;DO INITIAL READS TO FILL
	MOV	#IBUFF2,R2
	JSR	PC,BREAD
	INCB	INOFLG			;MARK OPEN
	MOV	#IBUFF1,IBPTR		;INIT INPUT BUFFER POINT
	RTS	PC

; EDIT WRITE
;	PREPARES NEW FILE FOR OUTPUT
;	.LOOKUP .ENTER PROCESSING REWORKED FOR V4 TO ALLOW FOR FILE
;	PROTECTION

EWRITE:	TSTB	OTOFLG			;IS ANY OUTPUT FILE OPEN?
	BEQ	EWRIT3			;NO
	JSR	PC,EFILE1		;CLEAN UP ANY OPEN FILE
EWRIT3:	MOV	#OUTBLK,R0
	JSR	PC,FNGET		;GET NEW NAME FOR OUTPUT
EWRIT5:	MOV 	#OUTBLK,R2
	JSR	PC,FETCH		;GET NEW OUTPUT HANDLER
	.LOOKU	#AREA,#13,#OUTBLK	;FIRST SEE IF FILE ALREADY EXISTS
					; WITH THIS NAME
	BCC	5$			;IT DOES WARNING MAY BE NEEDED
	.PURGE	#13			;ENSURE THE CHANNEL IS FREE
	.ENTER	#AREA,#13,#OUTBLK,FILENG ;OPEN OUTPUT FILE
	BCC	E100$			;ERROR?
1$:	CLRB	EBFLG			;SO ANOTHER 'EB' WON'T RENAME FILE
	TSTB	@#ERRBYT		;IS ERROR BYTE NEGATIVE?
	BMI	3$			;YES-MUST BE SERIOUS SYSTEM ERROR
	CMPB	@#ERRBYT,#3		;NO, IS IT A FILE PROTECTION ERROR
	BNE	2$			;NO
;+
;ERROR
	ERROR+24			;YES, PROTECTED FILE EXISTS

2$:	ERROR+20			;NO-NOT ENOUGH ROOM FOR FILE
;-

3$:	CMPB	@#ERRBYT,#-3		;IS IT I/O ERROR?
	BNE	4$			;NO-MUST BE DIRECTORY OVERFLOW
	.PURGE	#13			;FREE THE CHANNEL FOR LATER
;+
;ERROR
	ERROR+17			;SYSTEM I/O ERROR

4$:	.PURGE	#13			;FREE THE CHANNEL FOR LATER
	ERROR+15			;DIRECTORY FULL
;-

5$:	.CLOSE	#13			;CLOSE FILE JUST OPENED
	.ENTER	#AREA,#13,#OUTBLK,FILENG ;OPEN OUTPUT FILE
	BCS	1$			;PROBLEM, WHAT'S THE ERROR
	TSTB	EBFLG			;IS THIS AN EB RATHER THAN EW?
	BNE	E100$			;YES-SUPERSESSION IS THE NORMAL CASE
	MOV	#SWARN,R3		;PRINT SUPERCESSION WARNING
	JSR	PC,EPRINT		;TYPE IT
E100$:	CLR	OBLKNM			;START AT BLOCK 0
	INCB	OTOFLG			;OUTPUT FILE IS OPEN
	CLRB	FFFLG			;CLEAR OUTPUT FILE FULL FLAG
	RTS	PC			;RETURN

	.NLIST	BIN
SWARN:	.NLCSI	TYPE=I,PART=PREFIX
	.ASCII	/W-Superseding existing file/
	.BYTE	15,12,0
	.EVEN
	.LIST	BIN

; EXIT
;	FLUSHES REST OF INPUT FILE THROUGH AND EXITS TO MONITOR

EXIT:	INCB	EXFLG			;MARK EXIT IN PROGRESS
	TSTB	OTOFLG			;IS THERE AN OUTPUT FILE OPEN?
	BNE	E115$
;+
;ERROR
E113$:	ERROR+14			;NO-"NO FILE"
;-

E115$:	TSTB	INOFLG			;IS THERE AN INPUT FILE OPEN?
	BEQ	E116$			;NO-JUST WRITE THIS BUFFER
E114$:	TSTB	EOFFLG			;EOF YET?
	BNE	E116$			;YES-DONE
	JSR	PC,NEXT			;NO-DO A NEXT
	BR	E114$

E116$:	JSR	PC,BEGIN
	INCB	SLSFLG
	JSR	PC,WRITE		;DO ONE LAST B/W TO OUTPUT LAST PAGE
	JSR	PC,EFILE		;YES-DO AN END FILE
	CLRB	EXFLG			;EXIT NO LONGER IN PROGRESS
CCEXIT:	TSTB	DSFLG			;IS DISPLAY HDWRE ACTIVE
	BEQ	1$			;NO - SKIP DISPLAY COMMANDS
	.UNLNK				;UNLINK FROM MONITOR
1$:	MOV	SP,R0			;DO A SOFT EXIT TO ALLOW RE-ENTER
	.EXIT				;EXIT TO MONITOR

; END FILE
;	CLOSES OUTPUT FILE

EFILE:	TSTB	OTOFLG			;IS AN OUTPUT FILE OPEN?
	BEQ	E113$			;YES-ISSUE ERROR MESSAGE
EFILE1:	JSR	PC,EBCLOS		;CLOSE ANY ACTIVE EB AND FORCE
					; OUT LAST BLOCKS
	.LOCK				;LOCK USR IN CORE
	.CLOSE	#13			;CLOSE OUTPUT FILE
	CLRB	OTOFLG			;MARK OUTPUT NOT OPEN
	MOV	#OUTBLK,R2
	JSR	PC,RELEAS		;FREE OUTPUT HANDLER
	.UNLOC				;CHASE USR BACK OUT
	RTS	PC

; EDIT BACKUP
;	PREPARES FILE FOR BACKUP RENAME

EBCKUP:	JSR	PC,EFILE1		;CLOSE ANY CURRENTLY OPEN FILES
	JSR	PC,EREAD		;OPEN INPUT FILE
	MOV	#INBLK,R2		;R2 POINTS TO INPUT NAME
	MOV	#OUTBLK,R0		;R0 POINTS TO OUTPUT NAME
	MOV	#-7,R3			;COUNTER INTO R3
1$:	MOV	(R2)+,(R0)+		;MOVE INPUT FILENAME INTO OUTPUT
					; AND RENAME BLOCKS
	INC	R3			;DONE WITH LOOP (7 WORDS)?
	BLT	1$			;NO
	.ENTER	#AREA,#13,#EBBLK,#1	;TRY CREATING FILE TO SEE IF IT
					; IS PROTECTED
	BCC	2$			;IT'S NOT PROTECTED
	CMPB	@#ERRBYT,#3		;WAS IT PROTECTED?
	BNE	2$			;NOPE...
;+
;ERROR
	ERROR+25			;FILE PROTECTION ERROR
;-

2$:	.PURGE	#13			;FREE UP THE CHANNEL
	INCB	EBFLG			;MARK EDIT BACKUP IN PROGRESS
	JMP	EWRIT5			;OPEN OUTPUT FILE

	EDEND=.				;TOP OF EDITOR CODE
; THE FOLLOWING CODE IS ONCE-ONLY CODE WHICH IS EXECUTED ON
; EDITOR STARTUP IF AND ONLY IF THE EDITOR WAS CHAINED TO BY
; THE DCLS "EDIT" COMMAND. IT EXECUTES OUT OF THE TEXT BUFFER
; AND IS DESTROYED WHEN THE FIRST EDITOR COMMAND IS EXECUTED
; ITS FUNCTION IS TO TAKE THE INFORMATION PASSED IN THE CHAIN
; AREA BY DCLS AND BUILD APPROPRIATE EW AND ER COMMANDS AS IF
; TYPED AT THE KEYBOARD
;
; THE INFO PASSED IN THE CHAIN AREAS IS IN THE FOLLOWING FORMAT
;	LOC 510 IS A FLAG WORD. BIT 15 IS SET IF EDIT/CREATE WAS TYPED.
;	BIT 7 IS SET OF EDIT/INSPECT WAS TYPED. IN BOTH CASES,THE
;	NAME OF THE FILE TO USE IS AN ASCIZ STRING STARTING AT 512.
;	IF LOC 510 IS ZERO,THEN LOC 512 STARTS AN ASCIZ STRING FOR
;	THE FILE TO USE FOR INPUT. IF A SECOND FILENAME DOES NOT
;	APPEAR AT LOC 540,DO AN EB ON THE NAME IN 512. IF A SECOND
;	STRING DOES APPEAR AT 540,DO AN ER ON 512 AND AN EW ON 540.

	.=.+100				;LEAVE ROOM IN BUFFER TO BUILD STRING

	FCARG	= 512			;ADDRESS OF FIRST ASCIZ FILE NAME
	SCARG	= 540			;ADDRESS OF SECOND ASCIZ FILE NAME
	OPTION	= 510			;ADDRESS OF FLAGS WORD

DCLS:	BIC	#CHAIN$,@#JSW		;CLEAR CHAIN BIT
	TST	@#OPTION		;EDIT/CREATE?
	BMI	DCREAT			;BRANCH IF YES
	TSTB	@#OPTION		;EDIT/INSPECT?
	BMI	DEREAD			;BRANCH IF YES
	TSTB	@#SCARG			;ONLY ONE FILE NAME?
	BEQ	DEBCKUP			;YES-DO EB
	MOVB	#'E,(R0)+		;NO-SET UP EW ON STRING 2
	MOVB	#'W,(R0)+
	JSR	PC,SCPY			;COPY SECOND FILE NAME INTO CMD
	MOVB	ALTMDE,(R0)+		;ALTMODE MARKS END OF TEXT
DEREAD:	MOVB	#'E,(R0)+		;SET UP TO DO ER ON FIRST STRING
	MOVB	#'R,(R0)+
DCCMN:	JSR	PC,FCPY			;COPY FIRST STRING INTO CMD
	CLRB	(R0)+			;COMMAND IS FOLLOWED BY 2 ZEROES
	CLRB	(R0)
	MOV	R0,CBEND		;MARK END OF COMMAND
	MOV	CBSTRT,CBASE		;MARK START OF COMMAND
	MOV	#ISTCKA,ISTACK		;INIT ITERATION STACK
	RTS	PC			;CONTINUE ON WITH INIT CODE

DEBCKUP:MOVB	#'E,(R0)+		;SET UP TO DO EB ON FIRST STRING
	MOVB	#'B,(R0)+
	BR	DCCMN

DCREAT:	MOVB	#'E,(R0)+		;SET UP TO DO EW ON STRING 1
	MOVB	#'W,(R0)+
	BR	DCCMN

; ROUTINE TO MOVE ASCIZ FILENAME FROM 512 OR 540 TO LOCATION
; POINTED TO BY R0

SCPY:	MOV	#SCARG,R1		;POINT R1 TO SECOND FILENAME STRING
	BR	CPYCOM

FCPY:	MOV	#FCARG,R1		;POINT R1 TO FIRST FILENAME STRING
CPYCOM:	TSTB	(R1)			;END OF STRING?
	BNE	1$			;BRANCH IF NOT
	RTS	PC			;YES-RETURN

1$:	MOVB	(R1)+,(R0)+		;MOV CHAR
	BR	CPYCOM			;LOOP
	.SBTTL	ONCE-ONLY EDITOR STARTUP CODE

; THE FOLLOWING CODE IS A ONCE-ONLY ROUTINE WHICH IS EXECUTED WHEN
; THE EDITOR IS FIRST STARTED BY AN R,RUN,OR EDIT COMMAND. IT DETERMINES
; WHICH MONITOR THE EDITOR IS RUNNING UNDER, AND SETS THE MASK FOR THE
; TRAP VECTOR PS WORD APPROPRIATELY. IT ALSO DETERMINES IF SET TT SCOPE
; IS IN EFFECT, AND IF SO, SETS SCPFLG.

ONCEONLY:
	.GTIM	#DUMMY,#DUMMY2		;GO CHECK DATE
	MOV	@#SYSPTR,R0		;MONITOR BASE ADDR IN R0
	BIT	#KT11$,CONFIG(R0)	;IS XM MONITOR RUNNING?
	BEQ	1$			;BRANCH IF NOT (SJ OR FB)
	BIS	#170000,TRAPPS		;YES, SET USER MODE IN TRAP PS MASK
1$:	BIT	#MTTY$,SYSGEN(R0)	;IS THIS A MULTI-TERM MONITOR?
	BNE	4$			;BRANCH IF IT IS
	MOV	@#30,R0			;ADDR OF EMT ROUTINE INTO R0
	MOV	-(R0),R0		;GET TTY CONFIG WORD INTO R0 (@EMT-2)
2$:	BPL	3$			;BRANCH IF SCOPE BIT NOT SET
	INCB	SCPFLG			;SET SCOPE FLAG
3$:	RTS	PC			;DONE

; HERE WE CHECK THE CONSOLE TERMINAL IN MULTI-TERMINAL
; CONFIGURATIONS TO DETERMINE IF 'SET TT SCOPE' IS IN
; EFFECT.

4$:	.MTSTA	#AREA,#CSIBLK		;GET SOME MULTI-TERMINAL INFO
	MOV	@#SYSPTR,R0		;R0->BASE OF RMON
	ADD	CSIBLK+2,R0		;R0->CONSOLE TERMINAL'S TCB
	MOV	(R0),R0			;GET TERMINAL CONFIG WORD
	BR	2$			;USE CONDITIONAL BRANCH ABOVE TO
					; TEST WHAT WE GOT
	.END	START