.TITLE	TIOINI	INITIALIZATION
.SBTTL	INITIALIZATION

; LAST EDIT ON 17-MAR-80 BY MARK BRAMHALL

.IDENT	/V36/

.MCALL	.EXIT,	.GTJB,	.GVAL,	.MTATCH,.MTDTCH,.MTGET,	.MTSTAT,.PRINT
.MCALL	.PROTECT,.RCTRLO,.READW,.SCCA,	.SERR,	.SETTOP,.SRESET,.UNPROTECT

.EQUATE	R5SIZE,<2+PDLSIZ+SCHSIZ+FILSIZ+TAGSIZ+<PARMSZ*5>+1+1+2>

.DSECT	-R5SIZE		;LAYOUT OF OUR PRIVATE READ/WRITE AREA

HANDLR::.BLKW		;LOCATION TO FETCH HANDLER(S) INTO
PDLSRT:	.BLKB	PDLSIZ	;PDL AREA
SCHSRT:	.BLKB	SCHSIZ	;SEARCH BUFFER AREA
FILSRT:	.BLKB	FILSIZ	;FILENAME BUFFER AREA
TAGSRT:	.BLKB	TAGSIZ	;TAG BUFFER AREA
CMDPRM:	.BLKB	PARMSZ	;INDIRECT COMMAND PARAMETERS
INPNOR:	.BLKB	PARMSZ	;NORMAL INPUT PARAMETERS
INPALT:	.BLKB	PARMSZ	;ALTERNATE INPUT PARAMETERS
OUPNOR:	.BLKB	PARMSZ	;NORMAL OUTPUT PARAMETERS
OUPALT:	.BLKB	PARMSZ	;ALTERNATE OUTPUT PARAMETERS
LSTCHR:	.BLKB		;LAST CHARACTER TYPED
CTXFLG:	.BLKB		;COUNT OF DOUBLE CONTROL/C'S
SPSAVE:	.BLKW		;SAVED SP VALUE FOR ERROR RECOVERY
			;START OF "TECO"S R5 AREA

.ASSUME	.	EQ	0

.EQUATE	ET$RFA,	100000	;REFRESH SCOPE SCROLLER IS ACTIVE
.SBTTL	REENTRY CODE

	ORG	TECOIO

.ENABL	LSB

10$:	MOV	$$R5,R5		;(RE-)GET THE CORRECT R5 VALUE
	BEQ	40$		;NOT THERE YET (WHY??)
	BIT	#ET$RFS,ETYPE(R5) ;DO WE HAVE THE REFRESH SCOPE?
	BEQ	20$		;BRANCH IF NOT
	.PROTECT #AREA,$$DVEC	;(RE-)OBTAIN EXCLUSIVE USE OF VT11/VS60
	BCC	20$		;WE GOT THE VECTORS (BACK)
	BIC	#ET$RFS,ETYPE(R5) ;WE FAILED (WHY??), FORGET ABOUT SCOPE...
20$:	CLR	CMDPRM+SZ(R5)	;NO INDIRECT COMMAND FILE OPEN
	CLR	INDIR(R5)	; OR ACTIVE
	CLR	INPNOR+SZ(R5)	;NO NORMAL INPUT FILE OPEN
	CLR	INPALT+SZ(R5)	;NO SECONDARY INPUT FILE OPEN
	CLR	OUPNOR+SZ(R5)	;NO NORMAL OUTPUT FILE OPEN
	CLR	OUPALT+SZ(R5)	;NO SECONDARY OUTPUT FILE OPEN
30$:	MOV	#TFLG,R2	;GET ADDRESS OF TECO'S STOP INDICATOR
	ADD	R5,R2		; AND MAKE IT ABSOLUTE
	.SCCA	#AREA,R2	;SET THAT AS THE CONTROL/C MAGIC ADDRESS
	.SERR			;HANDLE OUR OWN ERRORS
	BIS	#TTLC$!RENTR$!TTSPC$,@#JSW ;TURN ON OUR OWN I/O, ALLOW REENTER
	BIC	#CMDEX$!CHAIN$!TCBIT$,@#JSW ;TURN OFF CHAIN BIT, ETC.
	JMPX	TECO		;NOW GO START US UP...

.SBTTL	ENTRY/REENTRY POINT

INIT::	BIS	#TTLC$!TTSPC$,@#JSW ;TURN ON OUR OWN I/O EARLY
	BIC	#RENTR$!CMDEX$!TCBIT$,@#JSW ;TURN OFF SOME OTHER BITS
	.RCTRLO			;RESET CONTROL/O
	.SRESET			;PURGE ALL CHANNELS
	ASL	(SP)+		;START OR REENTER?
	BCC	10$		;IT'S REENTER
40$:	MOV	#30$,-(SP)	;IT'S START, WE'LL GO LATER...

.DSABL	LSB
.SBTTL	CHECK FOR RE-STARTING

.ENABL	LSB

	TST	$$R5		;ARE WE TRYING TO START AGAIN?
	BEQ	20$		;NOPE
	MOV	PC,R1		;YEP, GET CURRENT LOCATION
	SUB	@#USERSP,R1	; AND FIND THE ROOT RELOAD BYTE SIZE
	;CLC			;C=0 ('SUB' <SMALL>,<BIG> => C=0)
	ASR	R1		;NOW FIND THE RELOAD WORD SIZE
	.READW	#AREA,#15.,USERSP,R1,#1 ;RELOAD THE ROOT CODE FROM IMAGE
	BCC	10$		;NO ERROR
	CALL	DEATH,R1,RELOAD	;DIE A HORRIBLE DEATH ON ANY ERROR

10$:	JMPX	START		;COMPLETELY RE-START AFTER THE RELOAD...

20$:				;CONTINUE

.DSABL	LSB
.SBTTL	FUDGE UP THE OVERLAY HANDLING

.ENABL	LSB

	MOV	#DCDLOD,R2	;GET POINTER TO AUTO-LOAD VECTOR FOR DECODER
	CMP	(R2)+,(PC)+	;HAS THIS CALL REALLY BEEN AUTO-VECTORED?
		JSR	R5,@(PC)+
	BNE	20$		;NOPE, SOME ERROR...
	MOV	(R2)+,R0	;YEP, GET START OF OVERLAY LOADER CODE
10$:	CMP	R0,R2		;HAVE WE GONE TOO FAR?
	BHIS	20$		;YES INDEED, SOME ERROR...
	CMP	(R0)+,(PC)+	;IS THIS THE 'ADD #$OVTAB-6,R1' INSTRUCTION?
		ADD	(PC)+,R1
	BNE	10$		;NOPE, KEEP LOOKING...
	MOV	(R0),R0		;YEP, GET OVERLAY TABLE BASE ADDRESS LESS 6
	MOV	R0,OVBASE	; AND SAVE IT FOR LATER
	ADD	(R2)+,R0	;FORM POINTER TO DECODER'S LOAD PARAMETERS
	MOV	#DCDEND,R4	;GET ENDING ADDRESS OF THE OVERLAY
	SUB	#DCDSRT,R4	; THEN FIND THE OVERLAY'S TOTAL SIZE
	ASR	R4		;DIVIDE BYTE SIZE FOR WORD SIZE
	INC	R4		; AND ADD IN THE OVERLAY INDICATOR WORD
	MOV	(R0),R3		;GET DECODER'S LOAD ADDRESS (OR WDB POINTER)
	TST	(R3)+		; AND SKIP THE "WHAT'S LOADED HERE" INDICATOR
	CMP	R3,(R2)		;DOES (LOAD ADDRESS +2) MATCH (ENTRY POINT)?
	BEQ	30$		;YEP, ALL SET, IT'S A REAL DISK OVERLAY
	CMP	R3,#START	;DOES IT LOOK LIKE A WDB POINTER?
	BHI	20$		;NOPE, SOME TYPE OF ERROR...
	MOV	-4(R2),R3	;FETCH THE LOAD CALL ADDRESS AGAIN
	CMP	(R3)+,(PC)+	;DOES IT LOOK LIKE THE VIRTUAL CALL ADDRESS?
		INC	(PC)+
	BNE	20$		;NOPE, FORGET THIS MESS...
	TST	(R3)+		;TRULY IS IT THE VIRTUAL CALL ADDRESS?
	BNE	20$		;NOPE AGAIN, REALLY GET OUT OF HERE...
	MOV	R3,-4(R2)	;CLOSE ENOUGH, CHANGE TO BECOME A DISK OVERLAY
	ADD	#40-1,R4	;ROUND UP DECODER'S OVERLAY SIZE
	BIC	#40-1,R4	; BY THE VIRTUAL OVERLAY MOD FACTOR
	BIT	#VIRT$,@#JSW	;FINAL CHECK FOR RUNNING VIRTUAL?
	BNE	30$		;INDEED VIRTUAL, LET'S GO TRY IT
20$:	CALL	DEATH,R1,OVLYER	;DEATH, GO SAY IT & DIE...

30$:	CMP	R4,4(R0)	;IS THE OVERLAY'S LOAD SIZE CORRECT?
	BNE	20$		;INCORRECT, SOME ERROR IN LINK OR DECODER...
	MOV	#$$RTSP,(R2)	;MAKE OVERLAY'S ENTRY POINT BE A SIMPLE RETURN
	MOV	#<<DCDSIZ+1>/2>+1,4(R0) ;SHORTEN OVERLAY LOAD TO ONLY DECODER
	MOV	R0,OVLOAD	;SAVE POINTER TO DECODER OVERLAY LOAD ADDRESS
	MOV	#DCDEND,R3	;GET THE START OF TRULY JUST BEYOND US
	ADD	#20000-1,R3	;DO A 4K WORD
	BIC	#20000-1,R3	; ROUND UP FOR VIRTUAL R/W START
	BIT	#VIRT$,@#JSW	;ARE WE RUNNING VIRTUALLY?
	BNE	60$		;YEP, GO SET R/W START AS VIRTUAL R/W START
	MOV	OVBASE,R2	;GET OVERLAY BASE TABLE ADDRESS LESS 6
	CLR	R3		;PRE-SET MAXIMUM ADDRESS OF VERY SMALL INDEED
40$:	ADD	#6,R2		;ADVANCE TO NEXT ENTRY IN OVERLAY TABLE
	CMP	R2,R0		;ARE WE UP TO DECODER OVERLAY?
	BHIS	50$		;YES, STOP THIS SCAN
	MOV	4(R2),R4	;ELSE GET THE OVERLAY'S WORD SIZE
	ASL	R4		; AND DOUBLE IT FOR ITS BYTE SIZE
	ADD	(R2),R4		;  THEN FIND ITS ENDING ADDRESS
	CMP	R4,R3		;IS THIS OVERLAY'S TOP > THE MAXIMUM SO FAR?
	BLOS	40$		;NO, IT'S SMALLER, LOOP FOR MORE
	MOV	R4,R3		;YES, SO SET A NEW MAXIMUM ADDRESS
	BR	40$		; AND LOOP...

50$:	CMP	R3,(R0)		;IS FOUND MAXIMUM > THE ORIGINAL LOAD ADDRESS?
	BLOS	20$		;NOPE, SOME SORT OF ERROR...
60$:	MOV	R3,(R0)		;SET LOWEST POSSIBLE R/W BASE
	MOV	R3,$$R5		; WHICH IS ALSO INITIAL TRIAL R/W BASE

.DSABL	LSB
.SBTTL	INITIAL MEMORY ALLOCATION

;+
;	$$R5 = CURRENT BASE FOR READ/WRITE AREA
;	OVBASE -> OVERLAY BASE TABLE LESS 6
;	OVLOAD -> LOAD ADDRESS FOR DECODER OVERLAY
;	@OVLOAD = LOWEST POSSIBLE BASE FOR READ/WRITE AREA
;-

.ENABL	LSB

	.SETTOP	#-2		;TRY TO GRAB MUCHO MEMORY
	MOV	R0,R2		; THEN SAVE WHAT WE ACTUALLY GOT
	CALL	GVAL,R1,CONFIG	;GET THE CONFIGURATION WORD
	BIT	R1,#USR$	;CAN THE USR SWAP AT ALL?
	BNE	10$		;NOPE, NO NEED TO BACK OFF FOR ITS SIZE
	CALL	GVAL,R1,USRSIZ	;GET THE USR'S SIZE IN BYTES
	SUB	R1,R2		; THEN BACK OFF BY USR'S SIZE
	BLO	30$		;UNDERFLOW!!!
10$:	MOV	$$R5,R0		;GET THE STARTING ADDRESS OF AVAILABLE MEMORY
	ADD	#ENSIZE+R5SIZE+RWSIZE+400.,R0 ; AND ADD IN OUR BARE MINIMUM
	BCS	30$		;OVERFLOW!!!
	CMP	R2,R0		;WOULD THE USR LOAD INTO OUR CRITICAL MEMORY?
	BLO	30$		;YES, WE MUST ABORT...
	BIT	#VIRT$,@#JSW	;ARE WE A VIRTUAL JOB?
	BNE	20$		;WE'RE VIRTUAL, NO USR LOAD ADDRESS, ETC.
	TST	(R2)+		;ELSE SKIP UP TO FIRST ADDRESS BEYOND US
	MOV	R2,@#USRADR	; AND SET A SPECIFIC USR LOAD ADDRESS
	TST	-(R2)		;BACK OFF A WORD SO WE WON'T CLOBBER THE USR
	.SETTOP	R2		; THEN SET A TOP SO IT WON'T HAVE TO SWAP
	.GTJB	#AREA,#JOBSTS	;GET OUR JOB STATICTICS
	CMP	JOBSTS,#2	;IS THIS A FOREGROUND RUN?
	BNE	40$		;NOPE, IT IS A BACKGROUND RUN
20$:	MOV	(PC)+,@(PC)+	;ENSURE NO DEVICE HANDLER FETCHING
		SEC		;	SEC
		.WORD	$$FET	;	 @ $$FET
	MOV	(PC)+,@(PC)+	;ALSO THE EXIT
		RTS	PC	;	RETURN
		.WORD	$$FET+2	;	 @ $$FET+2
	BR	40$		;NOW CONTINUE

30$:	CALL	DEATH,R1,NOROOM	;NO MEMORY TO START, GO DIE...

40$:				;CONTINUE

.DSABL	LSB
.SBTTL	INITIAL HARDWARE SET UP

;+
;	$$R5 = CURRENT BASE FOR READ/WRITE AREA
;	OVBASE -> OVERLAY BASE TABLE LESS 6
;	OVLOAD -> LOAD ADDRESS FOR DECODER OVERLAY
;	@OVLOAD = LOWEST POSSIBLE BASE FOR READ/WRITE AREA
;-

.ENABL	LSB

	SUB	@#RMON,$$SWRO	;REMOVE RMON'S BIAS FOR SWITCHES ADDRESS
	CALL	GVAL,R1,CONFG2	;GET CONFIGURATION WORD #2
	BIT	R1,#SWRHW	;HARDWARE SWITCHES TO READ?
	BNE	10$		;YES
	MOV	(PC)+,@(PC)+	;NO, CHANGE "SWITCH" ROUTINE
		CLR	R0	;	CLR	R0
		.WORD	$$SWR	;	 @ $$SWR
	MOV	(PC)+,@(PC)+	; AND
		RTS	PC	;	RTS	PC
		.WORD	$$SWR+2	;	 @ $$SWR+2
10$:	CALL	GVAL,R1,CONFIG	;GET CONFIGURATION WORD
	BIT	R1,#CLK50	;IS THE CLOCK REALLY 50HZ?
	BEQ	20$		;NOPE, IT'S 60HZ
	MOV	(PC)+,@(PC)+	;YEP, SET FIRST 50HZ DIVISOR
		.WORD	50.*2/4	;	DIVISOR FOR HIGH ORDER
		.WORD	$$TIMD	;	 @ $$TIMD
	MOV	(PC)+,@(PC)+	;SET SECOND 50HZ DIVISOR
		.WORD	50.*2*512. ;	DIVISOR FOR LOW ORDER
		.WORD	$$TIMD+2 ;	 @ $$TIMD+2
20$:	CLR	-(SP)		;PRE-SET NO SCOPE SUPPORT OF ANY SORT
	BIT	#VIRT$,@#JSW	;ARE WE A VIRTUAL JOB?
	BNE	40$		;YES, FORGET ABOUT VT11/VS60 SUPPORT
	CALL	GVAL,R1,CONFIG	;GET CONFIGURATION WORD
	BIT	R1,#VT11HW	;DOES VT11/VT60 HARDWARE EXIST?
	BEQ	40$		;NO
	CALL	GVAL,R1,GTVECT	;YES, GET THE VT11/VS60 VECTOR ADDRESS
	.PROTECT #AREA,R1	; THEN TRY TO GET THOSE VECTORS
	BCS	40$		;BRANCH IF CAN'T HAVE THEM
	MOV	R1,$$DVEC	;ELSE SAVE THE VECTOR'S ADDRESS
	CALL	GVAL,R1,SCROLL	;GET SCROLLER PARAMETER WORD
	TST	R1		;IS THE SCROLLER ACTIVE?
	BEQ	30$		;NOT NOW
	BIS	#ET$RFA,(SP)	;IT'S ACTIVE, REMEMBER TO CHANGE SEQUENCES
30$:	BIT	#ET$RFS,$$ET	;TRY FOR REFRESH SCOPE SUPPORT?
	BEQ	40$		;NOPE
	TST	#SCPLOD		;ARE WE LINKED WITH SUPPORT CODE?
	BEQ	40$		;NO CODE, SO NO SUPPORT POSSIBLE
	BIS	#ET$RFS,(SP)	;CODE, INDICATE REFRESH SCOPE DESIRED
40$:				;CONTINUE

.DSABL	LSB
.SBTTL	FIND OUR "CONSOLE" TERMINAL

;+
;	SP -> SCOPE DESIRES
;	$$R5 = CURRENT BASE FOR READ/WRITE AREA
;	$$DVEC =  ADDRESS OF REFRESH SCOPE VECTORS
;	OVBASE -> OVERLAY BASE TABLE LESS 6
;	OVLOAD -> LOAD ADDRESS FOR DECODER OVERLAY
;	@OVLOAD = LOWEST POSSIBLE BASE FOR READ/WRITE AREA
;-

.ENABL	LSB

	MOV	#TERSTS+10,R4	;POINT JUST BEYOND THE TERMINAL STATUS BLOCK
	MOV	#$$VT+10,R0	; AND POINT JUST BEYOND USER'S MODEL
	MOV	-(R0),-(R4)	;COPY
	MOV	-(R0),-(R4)	; USER'S
	MOV	-(R0),-(R4)	;  TO
	MOV	-(R0),-(R4)	;   OUR'S
	BNE	40$		;SOMETHING THERE, USE THE USER'S INFORMATION
	CALL	GVAL,R1,SYSGEN	;GET THE SYSGEN PARAMETERS WORD
	BIT	R1,#MULTI	;ARE WE RUNNING WITH MULTI-TERMINALS?
	BEQ	50$		;NOPE
	MOV	#-1,R2		;YEP, START "CONSOLE" AT (BIASED) UNIT #0
	CALL	GVAL,R1,MONVER	;FETCH THE MONITOR VERSION NUMBER
	CMPB	R1,#4		;RT-11 V4 (OR GREATER)?
	BLO	20$		;NO
	.MTSTAT	#AREA,#JOBSTS	;YES, GET THE MULTI-TERMINAL CONFIGURATION
	MOV	JOBSTS+0,R0	;GET OFFSET TO UNIT #0'S 'TCB'
10$:	INC	R2		;GO TO THE NEXT UNIT
	ADD	JOBSTS+6,R0	;ADD IN DISTANCE BETWEEN 'TCB'S
	CMP	R0,JOBSTS+2	;PASSED THE "CONSOLE" TERMINAL'S 'TCB'?
	BLOS	10$		;NOT YET...
	.MTGET	#AREA,R4,R2	;GET THE TERMINAL'S STATUS
	BR	40$		; AND GO USE IT

20$:	INC	R2		;GO TO THE NEXT UNIT
	CMP	R2,#16.		;HAVE WE GONE TOO FAR???
	BHI	50$		;MUCH TOO FAR, QUIT!!!
	.MTATCH	#AREA,#0,R2	;TRY TO ATTACH TO THE "CONSOLE" TERMINAL
	BCS	30$		;ERROR, SKIP THIS UNIT...
	.MTGET	#AREA,R4,R2	;ELSE GET THE TERMINAL'S STATUS
30$:	ROR	R3		;PUT ERROR (C-BIT) INTO A REGISTER
	.MTDTCH	#AREA,R2	;NOW FREE UP THE CONSOLE TERMINAL
	ASL	R3		;RESTORE ERROR BACK INTO C-BIT
	BCS	20$		;THERE WAS AN ERROR, NO VALID STATUS
	TSTB	M.TSTW(R4)	;IS THIS OUR "CONSOLE" TERMINAL?
	BPL	20$		;NO, LOOP FOR NEXT UNIT...
.ASSUME	CONSL$	EQ	200
40$:	ADD	#M.TWID,R4	;INDEX INTO TERMINAL STATUS BLOCK
	BR	70$		; AND GO CHECK OUT THE STATUS

50$:	MOV	@#30,R2		;GET 'EMT' VECTOR POINTER
	SUB	#2,R2		; AND FIND THE INTERNAL "M.TSTS"
	CALL	GVALAB,R1	;  THEN GET IT
	MOV	R1,(R4)+	;LOAD "M.TSTS" FROM INTERNAL STATUS
.ASSUME	M.TSTS	EQ	0
	CLR	(R4)+		;SET "M.TST2" TO ZERO
.ASSUME	M.TST2	EQ	M.TSTS+2
	MOV	@#FILLCH,(R4)+	;SET INDICATED FILL CHARACTER/FILL COUNT
.ASSUME	FILLCT	EQ	FILLCH+1
.ASSUME	M.TFIL	EQ	M.TST2+2
.ASSUME	M.FCNT	EQ	M.TFIL+1
	MOV	#72.,(R4)	;SET "M.TWID" TO 72.("VT05"), "M.TSTW" TO ZERO
.ASSUME	M.TWID	EQ	M.TFIL+2
.ASSUME	M.TSTW	EQ	M.TWID+1
	TSTB	M.FCNT-M.TWID(R4) ;IS ANY FILL ACTIVE?
	BNE	60$		;YEP
	MOVB	#80.,(R4)	;NOPE, SAY WIDTH IS 80.("VT52")
60$:	CALL	GVAL,R1,CONFIG	;GET CONFIGURATION WORD
	ASR	R1		;FB/XM MONITOR?
	BCC	70$		;NOPE
.ASSUME	FBMON$	EQ	1
	MOV	@#30,R2		;YEP, GET 'EMT' VECTOR POINTER
	SUB	#10,R2		; AND FIND THE INTERNAL "M.TWID"
	CALL	GVALAB,R1	;  THEN GET IT
	MOVB	R1,(R4)		;SET "M.TWID" FROM INTERNAL STATUS
70$:	TST	M.TSTS-M.TWID(R4) ;IS THE "CONSOLE" A SCOPE TYPE TERMINAL?
	BPL	80$		;NOPE, FORGET ALL SCOPE SUPPORT
.ASSUME	VT05$	EQ	100000
	BIT	#ET$CRT,$$ET	;SHOULD WE EVEN TRY FOR SCOPE SUPPORT?
	BEQ	80$		;NOPE AGAIN, GO FORGET ALL SCOPE SUPPORT
	MOV	$$R5,R5		;GET (DUMMY) READ/WRITE AREA POINTER
	CLR	ETYPE(R5)	; AND FORM A (DUMMY) "ET" FLAG
	CALLX	CRTRUB		;ASK FOR SCOPE TYPE DETERMINATION
.GLOBL	TANSI$			; PASSING THE ANSI BIT INTO ROUTINE
	BIT	ETYPE(R5),#ET$CRT ;DID WE GET ANY SUPPORT?
	BEQ	80$		;NO, FORGET ALL SCOPE SUPPORT
	BIS	#ET$CRT,(SP)	;YES, INDICATE SCOPE SUPPORT WANTED
	BMI	80$		;REFRESH SCOPE SCROLLER ACTIVE, NO SCOPE WATCH
.ASSUME	ET$RFA	EQ	100000
	BIT	#ET$IAS,$$ET	;TRY FOR SCOPE WATCH SUPPORT?
	BEQ	80$		;NO
	TST	R4		;YES, DID WE GET SUPPORT FOR WATCH?
	BEQ	80$		;NOPE
	BIS	#ET$IAS,(SP)	;YEP, INDICATE SCOPE WATCH SUPPORT ALSO
80$:				;CONTINUE

.DSABL	LSB
.SBTTL	RECOVER MEMORY IF INTERACTIVE SCOPE WATCH NOT DESIRED

;+
;	SP -> SCOPE DESIRES
;	$$R5 = CURRENT BASE FOR READ/WRITE AREA
;	$$DVEC =  ADDRESS OF REFRESH SCOPE VECTORS
;	OVBASE -> OVERLAY BASE TABLE LESS 6
;	OVLOAD -> LOAD ADDRESS FOR DECODER OVERLAY
;	@OVLOAD = LOWEST POSSIBLE BASE FOR READ/WRITE AREA
;	TERSTS =  TERMINAL STATUS BLOCK
;-

.ENABL	LSB

	BIT	(SP),#ET$IAS	;WILL WE NEED THE SCOPE WATCH CODE?
	BNE	30$		;YES, WE MUST KEEP IT
	BIT	#VIRT$,@#JSW	;ARE WE RUNNING VIRTUALLY?
	BNE	30$		;YES, THERE'S NOTHING TO RECOVER...
	MOV	#SCRLOD,R2	;GET POINTER TO SCOPE WATCH AUTO-LOAD VECTOR
	CMP	(R2),(PC)+	;IS IT REALLY AUTO-LOAD?
		JSR	R5,@(PC)+
	BNE	30$		;NOPE, WE CAN'T REMOVE IT...
	MOV	(PC)+,@(PC)+	;YEP, ENSURE WE'LL NEVER TRY TO EXECUTE IT
		RTS	PC	;	RETURN
		.WORD	SCREEN	;	 @ SCREEN
	MOV	OVBASE,R0	;GET OVERLAY BASE TABLE ADDRESS LESS 6
	MOV	R0,R3		;COPY THE BASE TABLE ADDRESS
	ADD	4(R2),R3	; AND FIND ENTRY FOR SCOPE WATCH
	CLR	R2		;PRE-SET MAXIMUM ADDRESS TO VERY SMALL INDEED
10$:	ADD	#6,R0		;ADVANCE TO NEXT ENTRY IN OVERLAY TABLE
	CMP	R0,OVLOAD	;ARE WE UP TO THE DECODER OVERLAY?
	BHIS	20$		;YES, STOP THIS SCAN
	CMP	R0,R3		;IS THIS THE SCOPE WATCH OVERLAY?
	BEQ	10$		;YEP, SKIP IT SINCE WE'RE REMOVING IT
	MOV	4(R0),R4	;ELSE GET THE OVERLAY'S WORD SIZE
	ASL	R4		; AND DOUBLE IT FOR ITS BYTE SIZE
	ADD	(R0),R4		;  THEN FIND ITS ENDING ADDRESS
	CMP	R4,R2		;IS THIS OVERLAY'S TOP > THE MAXIMUM SO FAR?
	BLOS	10$		;NO, IT'S SMALLER, LOOP FOR MORE
	MOV	R4,R2		;YES, SO SET A NEW MAXIMUM ADDRESS
	BR	10$		; AND LOOP...

20$:	TST	R2		;DID WE FIND A REAL MAXIMUM?
	BEQ	30$		;NOPE (WHY NOT??)
	CMP	R2,@OVLOAD	;MAXIMUM ADDRESS ALREADY > READ/WRITE START?
	BHIS	30$		;YEP (WHY??)
	MOV	R2,@OVLOAD	;NOPE, SET A NEW LOWEST POSSIBLE R/W BASE
	MOV	R2,$$R5		; AND ALSO SAY IT'S THE CURRENT BASE
30$:				;CONTINUE

.DSABL	LSB
.SBTTL	INITIAL REFRESH SCOPE SET UP

;+
;	SP -> SCOPE DESIRES
;	$$R5 = CURRENT BASE FOR READ/WRITE AREA
;	$$DVEC =  ADDRESS OF REFRESH SCOPE VECTORS
;	OVBASE -> OVERLAY BASE TABLE LESS 6
;	OVLOAD -> LOAD ADDRESS FOR DECODER OVERLAY
;	@OVLOAD = LOWEST POSSIBLE BASE FOR READ/WRITE AREA
;	TERSTS =  TERMINAL STATUS BLOCK
;-

.ENABL	LSB

	MOV	$$ET,-(SP)	;GET THE "ET" FLAG DEFAULTS
	BIC	#ET$RFS!ET$IAS!ET$CRT,(SP) ;CLEAR OUT WHAT'S INDICATOR(S)
	BIS	#ET$XIT,(SP)	; AND ALWAYS SET THE "NO PROMPT" BIT
	CLR	-(SP)		;SET "NWATCH" DEFAULT TO ZERO
	BIT	4(SP),#ET$RFS	;DO WE DESIRE REFRESH SCOPE SUPPORT?
	BEQ	30$		;NOPE
	MOV	$$R5,R5		;YEP, POINT TO AVAILABLE MEMORY
	MOV	#SCPLOD,R2	;GET POINTER TO SUPPORT'S AUTO-LOAD VECTOR
	CMP	(R2),(PC)+	;IS IT REALLY AUTO-LOAD?
		JSR	R5,@(PC)+
	BNE	10$		;NOPE, NO RELOCATION NEEDED OR POSSIBLE
	MOV	OVBASE,R0	;YEP, GET OVERLAY BASE TABLE LESS 6
	ADD	4(R2),R0	; AND FIND THE SUPPORT'S TABLE ENTRY
	SUB	(R0),6(R2)	;TAKE OLD LOAD POINT AWAY FROM ENTRY POINT
	ADD	R5,6(R2)	; THEN ADD IN THE NEW LOAD POINT
	MOV	R5,(R0)		;SET LOAD POINT TO START OF AVAILABLE MEMORY
	CLR	(R5)		; AND ENSURE THAT THE OVERLAY WILL REALLY LOAD
10$:	CALL	GVAL,R1,SCROLL	;GET SCROLLER PARAMETER WORD AGAIN
	CALL	(R2)		;GO TRY FOR REFRESH SCOPE SUPPORT
	TST	R4		;WAS REFRESH SCOPE OBTAINED(SIZE<>0)?
	BNE	20$		;YEP
	.UNPROTECT #AREA,$$DVEC	;NOPE, RELEASE THE VT11/VS60 VECTORS
	BR	30$		; AND CONTINUE

20$:	MOV	R5,$$R5		;YEP, SET NEW BASE FOR THE READ/WRITE AREA
	MOV	R3,(SP)		;SET CORRECT "NWATCH" VALUE
	BIS	#ET$RFS,2(SP)	; AND INDICATE REFRESH SCOPE SUPPORT EXISTS
	MOV	R1,$$RFSC	;SET THE REFRESH SCOPE "WATCH" ENTRY POINT
30$:				;CONTINUE

.DSABL	LSB
.SBTTL	INITIAL MEMORY SET UP

;+
;	SP -> "NWATCH" DEFAULT VALUE, "ET" FLAG DEFAULT VALUE, SCOPE DESIRES
;	$$R5 = CORRECT BASE FOR READ/WRITE AREA
;	$$DVEC =  ADDRESS OF REFRESH SCOPE VECTORS
;	OVLOAD -> LOAD ADDRESS FOR DECODER OVERLAY
;	@OVLOAD = LOWEST POSSIBLE BASE FOR READ/WRITE AREA
;	TERSTS =  TERMINAL STATUS BLOCK
;-

.ENABL	LSB

	BR	50$		;CONTINUE

10$:	MOV	@#USERTOP,R0	;GET LAST ADDRESS AVAILABLE TO US
	SUB	R5,R0		;FIND AMOUNT OF FREE MEMORY
	BLOS	20$		;NOTHING!!! EXIT SAYING SO!!!
	CMP	R0,#ENSIZE+R5SIZE+RWSIZE+400.+<DCDSIZ+1>+512. ;IS ENOUGH FREE?
20$:	RETURN			;EXIT WITH CC'S ALL SET

30$:	BIT	#ET$RFS,2(SP)	;DID WE CONFIGURE REFRESH SCOPE SUPPORT?
	BNE	40$		;YES, SORRY, WE MUST TAKE IT AWAY...
	CALL	DEATH,R1,NOROOM	;NOPE, CAN'T START AT ALL, GO DIE...

40$:	BIC	#ET$RFS,2(SP)	;TAKE AWAY REFRESH SCOPE SUPPORT
	CLR	(SP)		; AND SET "NWATCH" DEFAULT BACK TO ZERO
	MOV	#$$RTSP,$$RFSC	;RESET ENTRY POINT TO BE A SIMPLE RETURN
	.UNPROTECT #AREA,$$DVEC	;RELEASE THE REFRESH SCOPE VECTORS
	MOV	@OVLOAD,$$R5	;RESET READ/WRITE AREA BASE TO ORIGINAL BASE
50$:	MOV	$$R5,R5		;GET BASE OF THE READ/WRITE AREA
	CALL	10$		;GO SEE IF WE HAVE ENOUGH MEMORY
	BHI	60$		;YEP, KEEP THE CURRENT TOP
	.SETTOP	#-2		;ELSE REQUEST MUCHO MEMORY
	CALL	10$		;GO SEE IF WE NOW HAVE ENOUGH MEMORY
	BLOS	30$		;WE'RE STILL IN TROUBLE, TAKE DRASTIC ACTION
60$:	MOV	@#USERTOP,R0	;(RE-)GET LAST ADDRESS AVAILABLE TO US
	TST	(R0)+		; AND MAKE IT THE FIRST UNAVAILABLE ADDRESS
70$:	CLR	-(R0)		;CLEAR THE READ/WRITE AREAS
	CMP	R0,R5		;DONE?
	BHI	70$		;NOT YET...
	ADD	#ENSIZE+R5SIZE,R5 ;FORM TECO'S READ/WRITE AREA POINTER
	MOV	R5,$$R5		; AND SAVE IT IN THE ROOT
	MOV	@#USERSP,TECOSP(R5) ;SET THE RESET SP STACK VALUE
	MOV	#TECOCH,TECOJP(R5) ;SET NORMAL JUMP DISPATCH TABLE ADDRESS
	COM	OUTDNE(R5)	;SAY ALL SORTS OF OUTPUT HAS BEEN DONE
	MOV	$$ED,EDIT(R5)	;DEFAULT THE "ED" FLAG
	MOV	$$EU,EUFLAG(R5)	;DEFAULT THE "EU" FLAG
	MOV	(SP)+,NWATCH(R5) ;DEFAULT "NWATCH"
	MOV	(SP)+,ETYPE(R5)	;DEFAULT THE "ET" FLAG

.DSABL	LSB
.SBTTL	INITIAL INTERACTIVE SCOPE SET UP

;+
;	R5 -> INTO READ/WRITE AREA (THE R5 OFFSET POINTER)
;	SP -> SCOPE DESIRES
;	OVLOAD -> LOAD ADDRESS FOR DECODER OVERLAY
;	TERSTS =  TERMINAL STATUS BLOCK
;-

.ENABL	LSB

	BIT	(SP),#ET$CRT	;SHOULD WE TRY FOR ANY SCOPE SUPPORT?
	BEQ	10$		;NOPE, SO DON'T
	MOV	#TERSTS+6,R4	;YEP, GET POINTER INTO TERMINAL STATUS BLOCK
.ASSUME	M.TWID	EQ	6
	CALLX	CRTRUB		; AND ASK FOR FINAL SCOPE TYPE DETERMINATION
.GLOBL	TANSI$			;  PASSING THE ANSI BIT INTO ROUTINE
	BIT	(SP),#ET$IAS	;ALLOWING SCOPE WATCH SUPPORT?
	BNE	20$		;YEP
	BIC	#ET$IAS,ETYPE(R5) ;NOPE, SO ENSURE IT IS TURNED OFF
10$:	CLR	R4		;SAY NO ADDITIONAL MEMORY IS NEEDED
20$:	TST	(SP)+		;IS REFRESH SCOPE SCROLLER ACTIVE?
	BPL	30$		;NOPE
.ASSUME	ET$RFA	EQ	100000
	MOV	#$$CRTS,R2	;GET POINTER TO START OF SCOPE RUBOUT STUFF
	CMP	(R2)+,(PC)+	;DOES THE ROUTINE START WITH 'CLR R4'?
		CLR	R4
	BEQ	30$		;YEP, SO NO SPACE FOR SEQUENCES WAS ALLOCATED
	MOVB	-2(R2),R0	;NOPE, GET BRANCH DESTINATION SIGN EXTENDED
	ASL	R0		; AND DOUBLE IT FOR WORD ADDRESSING
	ADD	R0,R2		;  THEN FIND THE REAL START OF THE ROUTINE
	MOV	#$$ERLS,R0	;GET POINTER TO ERASE LINE POINTERS
	MOV	R2,(R0)		;SET A NEW SEQUENCE POINTER
	MOV	(R0)+,(R0)	;PROPAGATE
	MOV	(R0)+,(R0)	; INTO REMAINING
	MOV	(R0)+,(R0)	;  THREE POINTERS
	MOV	(PC)+,(R2)+	;SET ERASE LINE SEQUENCE (CLOBBER INIT CODE!)
	 .BYTE	2,CR
	MOVB	#LF,(R2)+	; WHICH IS SIMPLY <CR><LF>
	MOV	#$$CUPS,R0	;GET POINTER TO CURSOR UP POINTERS
	MOV	R2,(R0)		;SET A NEW SEQUENCE POINTER
	MOV	(R0)+,(R0)	;PROPAGATE
	MOV	(R0)+,(R0)	; INTO REMAINING
	MOV	(R0)+,(R0)	;  THREE POINTERS
	CLRB	(R2)+		;SET CURSOR UP SEQUENCE (CLOBBER INIT CODE!)
	MOV	(PC)+,@(PC)+	;CHANGE CONTROL/U TO ECHO ^U<CR><LF>
		JMP	@(PC)+	;	JMP	@#CRLF
		.WORD	$$DELN	;	 @ $$DELN
	MOV	(PC)+,@(PC)+	;SET THE JMP'S TARGET
		.WORD	CRLF	;	CRLF
		.WORD	$$DELN+2 ;	 @ $$DELN+2
30$:				;CONTINUE

.DSABL	LSB
.SBTTL	REST OF INITIAL MEMORY SET UP

;+
;	R4 =  EXTRA MEMORY TO RESERVE FOR INTERACTIVE SCOPE "WATCH"
;	R5 -> INTO READ/WRITE AREA (THE R5 OFFSET POINTER)
;	OVLOAD -> LOAD ADDRESS FOR DECODER OVERLAY
;-

.ENABL	LSB

	ADD	R5,R4		;GO BEYOND ANY INTERACTIVE SCOPE SUPPORT
	ADD	#RWSIZE,R4	; AND GO BEYOND TECO'S READ/WRITE DATA
	MOV	R5,R0		;COPY THE READ/WRITE AREA POINTER
	ADD	#HANDLR,R0	; AND GO TO HANDLER FETCH LOCATION IN R/W AREA
	MOV	R4,(R0)+	;LOAD INITIAL HANDLER FETCH ADDRESS
	MOV	R0,TECOPD(R5)	;LOAD START OF TECO'S PDL
.ASSUME	PDLSRT	EQ	HANDLR+2
	MOV	R0,PDL(R5)	; AND INITIALIZE THE PDL
	ADD	#PDLSIZ,R0	;  THEN SKIP THE PDL
	MOV	R0,SCHBUF(R5)	;LOAD START OF SEARCH BUFFER
.ASSUME	SCHSRT	EQ	PDLSRT+PDLSIZ
	ADD	#SCHSIZ-1,R0	; THEN SKIP MOST OF THE SEARCH BUFFER
	COMB	(R0)+		;  AND FLAG ITS END
	MOV	R0,FILBUF(R5)	;LOAD START OF FILENAME BUFFER
.ASSUME	FILSRT	EQ	SCHSRT+SCHSIZ-1+1
	ADD	#FILSIZ-1,R0	; THEN SKIP MOST OF THE FILENAME BUFFER
	COMB	(R0)+		;  AND FLAG ITS END
	MOV	R0,TAGBUF(R5)	;LOAD START OF TAG BUFFER
.ASSUME	TAGSRT	EQ	FILSRT+FILSIZ-1+1
	ADD	#TAGSIZ-1,R0	; THEN SKIP MOST OF THE TAG BUFFER
	COMB	(R0)+		;  AND FLAG ITS END
	ADD	#CH,R0		;INDEX TO FIRST I/O PARAMETER BLOCK @ CH
.ASSUME	CMDPRM	EQ	TAGSRT+TAGSIZ-1+1
	MOV	(PC)+,R2	;START WITH CHANNEL #0 AND READ (CODE=10)
	 .BYTE	0,10
10$:	MOV	R2,(R0)		;LOAD CHANNEL # AND READ/WRITE CODE
.ASSUME	CD	EQ	CH+1
	MOV	#256.,WC-CH(R0)	;SET WORD COUNT TO 256. WORDS (1 BLOCK)
	ADD	#PARMSZ,R0	;SKIP TO NEXT I/O PARAMETER BLOCK
.ASSUME	INPNOR+CH EQ	CMDPRM+CH+PARMSZ
.ASSUME	INPALT+CH EQ	INPNOR+CH+PARMSZ
.ASSUME	OUPNOR+CH EQ	INPALT+CH+PARMSZ
.ASSUME	OUPALT+CH EQ	OUPNOR+CH+PARMSZ
	INC	R2		; AND ADVANCE THE CHANNEL #
	CMP	R0,R5		;DONE WITH I/O PARAMETER BLOCKS?
	BLO	10$		;NOT YET...
.ASSUME	OUPALT+CH+PARMSZ GE 0
	INCB	OUPNOR+CD(R5)	;NORMAL OUTPUT IS REALLY WRITE (CODE=11)
	INCB	OUPALT+CD(R5)	;SECONDARY OUTPUT IS ALSO WRITE (CODE=11)
	MOV	#INPNOR+SZ,INPNTR(R5) ;SET NORMAL INPUT
	ADD	R5,INPNTR(R5)	; AND MAKE IT ABSOLUTE
	MOV	#OUPNOR+SZ,OUPNTR(R5) ;SET NORMAL OUTPUT
	ADD	R5,OUPNTR(R5)	; AND MAKE IT ABSOLUTE
	MOV	@#USERTOP,R3	;GET LAST AVAILABLE ADDRESS TO USE
	ADD	#2,R3		; THEN MAKE IT THE FIRST ILLEGAL ADDRESS
	BNE	20$		;IT'S NOT ALL OF MEMORY
	TST	-(R3)		;WE CAN'T USE IT ALL, WASTE THE LAST WORD
20$:	SUB	#512.,R3	;FIND ADDRESS OF "EI" I/O BUFFER
	BLOS	40$		;UNDERFLOW!!! (SOME SORT OF BUG!)
	MOV	R3,R2		;COPY "EI" I/O BUFFER ADDRESS
	SUB	R4,R2		;FIND INITIAL SIZE OF FREE MEMORY
	BLOS	40$		;UNDERFLOW!!! (SOME SORT OF BUG!)
	MOV	#DCDSIZ,R0	;GET SIZE OF INITIAL COMMAND DECODER
	MOV	R0,QARRAY+<<'Y-'A>*2*2>(R5) ;ALL IS USED BY Q-REG "Y"
	MOV	R0,QZ(R5)	;ALSO SET CORRECT Q-REGISTER IN USE SIZE
	SUB	R0,R2		;FIND FREE MEMORY LESS INITIAL COMMAND DECODER
	BLOS	40$		;UNDERFLOW!!! (SOME SORT OF BUG!)
	;CLC			;C=0 (NOT 'BLOS' = 'BHI' => 'BHIS' = 'BCC')
	ROR	R2		;TEXT & Q-REGISTERS EACH GET 1/2 OF FREE SPACE
	ADC	R0		; WITH ANY REMAINDER GOING TO Q-REGISTERS
	ADD	R2,R0		;GIVE Q-REGISTERS THEIR HALF
	BIT	R2,#1		;IS SIZE OF TEXT BUFFER ODD?
	BEQ	30$		;NOPE
	DEC	R2		;YEP, MOVE ONE BYTE FROM TEST
	INC	R0		; TO Q-REGISTERS
30$:	CMP	R2,#150.	;IS ENOUGH THERE?
	BLOS	40$		;UNDERFLOW!!! (SOME SORT OF BUG!)
	MOV	R4,TXSTOR(R5)	;LOAD START OF TEXT BUFFER
	MOV	R2,ZMAX(R5)	; AND ITS INITIAL SIZE
	ADD	R2,R4		;  THEN SKIP ITS SIZE
	MOV	R4,QRSTOR(R5)	;LOAD START OF Q-REGISTERS
	MOV	R0,QMAX(R5)	; AND ITS INITIAL SIZE
	CLR	-(R4)		;ENSURE THAT THE DECODER OVERLAY WILL LOAD
	MOV	R4,@OVLOAD	; AND SET DECODER OVERLAY LOAD ADDRESS
	CALLX	DCDLOD		;GO LOAD IN THE DECODER CODE (AS AN OVERLAY!)
	CLR	(R4)+		;CLEAR THE LOADED INDICATOR WORD
	BR	50$		;CONTINUE

40$:	CALL	DEATH,R1,NOROOM	;GO DIE, SOME CODING BUG OCCURED...

50$:				;CONTINUE

.DSABL	LSB
.SBTTL	BUILD COMMAND LINE

;+
;	R3 -> "EI" I/O BUFFER
;	R5 -> INTO READ/WRITE AREA (THE R5 OFFSET POINTER)
;-

.ENABL	LSB

	MOV	#CMDPRM+SZ,R4	;GET INDIRECT COMMAND FILE I/O BLOCK POINTER
	ADD	R5,R4		; AND MAKE IT ABSOLUTE
	COM	(R4)+		;SET THE FILE AS OPEN(SZ<>0)
	MOV	R4,INDIR(R5)	; AND TELL TECO ABOUT IT
.ASSUME	CC	EQ	SZ+2
	MOV	#512.,(R4)+	;SET CURRENT COUNT TO A FULL BUFFER'S WORTH
	MOV	R3,(R4)		;SET CURRENT POINTER TO THE I/O BUFFER
.ASSUME	CP	EQ	CC+2
	MOV	R3,RP-CP(R4)	; AND ALSO THE RESET POINTER
	MOV	R3,R0		;COPY POINTER TO ACTIVE "EI" I/O BUFFER
	MOV	#NULCMD,R1	; AND POINT AT THE NULL COMMAND STRING
	CALL	40$		;GO MOVE IN THAT NULL COMMAND
	BIT	#CHAIN$,@#JSW	;WERE WE CHAINED TO?
	BEQ	50$		;NOPE, NO COMMAND LINE, DONE
	MOV	#510,R2		;YEP, GET POINTER TO CHAIN INFORMATION
	CMP	(R2)+,#-1	;IS IT THE NEW TECO INTERFACE?
	BEQ	60$		;THAT IT IS...
	SUB	#NULEND-NULMID,R0 ;ELSE BACK UP OVER THE 2 ESC'S AND NULL
	CLR	R2		;CLEAR THE "EXECUTE" FLAG
	CALL	HERB		; AND GO DO HERB'S THING...
	TST	R2		;WAS THERE AN EXECUTE INVOLVED?
	BNE	50$		;YES, DON'T TOUCH THAT COMMAND STRING!
	MOV	R3,R2		;NO EXECUTE, COPY BUFFER POINTER AGAIN
	ADD	#NULMID-NULCMD,R2 ; AND POINT AT HERB'S COMMAND STRING
	CMPB	(R2)+,#'E	;DOES STRING START WITH AN E- COMMAND?
	BNE	50$		;NO??!!??
	MOVB	(R2)+,R4	;YES, GET THE KIND OF E- COMMAND
	MOV	#INSCMD,R1	;GUESS AT INSPECT COMMAND ("TECO/INSPECT")
	CMP	R4,#'R		;GOOD GUESS ("ER")?
	BEQ	10$		;YES
	MOV	#EDICMD,R1	;NO, TRY FOR NORMAL EDIT COMMAND ("TECO")
	CMP	R4,#'B		;GOOD GUESS ("EB")?
	BEQ	10$		;YES
	MOV	#CRECMD,R1	;NO, MUST BE CREATE COMMAND ("MAKE")
10$:	MOV	TXSTOR(R5),R0	;GET POINTER TO THE TEXT BUFFER
	CALL	40$		;MOVE IN THE COMMAND NAME
	MOVB	#SPACE,-1(R0)	; FOLLOWED BY A SPACE (NOT A NULL)
	CALL	70$		;GO MOVE IN A FILE SPECIFICATION
	CMPB	(R2)+,#'E	;DOES "ER" FOLLOW?
	BNE	30$		;IT CAN'T
	CMPB	(R2)+,#'R	;MIGHT BE...
	BNE	30$		;BUT IT'S NOT
	MOVB	#'=,(R0)+	;SET OUTPUT=INPUT FORMAT
	CALL	70$		; AND MOVE IN ANOTHER FILE SPECIFICATION
	MOV	TXSTOR(R5),R2	;GET TEXT BUFFER POINTER AGAIN
	MOV	#EDICMD,R1	; AND POINTER TO "TECO"
20$:	MOVB	(R1)+,(R2)+	;REPLACE "MAKE" WITH "TECO"
	BNE	20$		; IN A SMALL LOOP
	MOVB	#SPACE,-(R2)	;CLOBBER THE NULL WITH A SPACE
30$:	SUB	TXSTOR(R5),R0	;FIND AMOUNT INSERTED INTO TEXT BUFFER
	MOV	R0,ZZ(R5)	; AND STORE AS TEXT BUFFER SIZE IN USE
	CMP	R0,ZMAX(R5)	;DID THAT OVERFLOW THE TEXT BUFFER?
	BHI	90$		;YEP, SOME SORT OF BUG?!?
	MOV	R3,R0		;(RE-)COPY POINTER TO ACTIVE "EI" I/O BUFFER
	MOV	#INICMD,R1	; AND POINT AT THE INITIAL COMMAND STRING
40$:	MOVB	(R1)+,(R0)+	;MOVE IN
	BNE	40$		; THE COMMAND...
50$:	RETURN			;EXIT

60$:	MOV	#30$,-(SP)	;SET RETURN TO LOAD INITIAL COMMAND STRING
	MOV	TXSTOR(R5),R0	;POINT TO THE TEXT BUFFER
70$:	MOVB	(R2)+,(R0)	;COPY A FILE SPECIFICATION/COMMAND
	BEQ	80$		;NULL IS ONE TYPE OF END
	CMPB	(R0)+,#ESC	;ELSE LOOK FOR A TERMINATING ESCAPE
	BNE	70$		;NOT FOUND YET, LOOP...
	DEC	R0		;ELSE BACK UP OVER THAT ESCAPE
80$:	RETURN			;EXIT

90$:	CALL	DEATH,R1,NOROOM	;SAY NO ROOM'S AVAILABLE...

.DSABL	LSB
.SBTTL	HERB'S COMMAND LINE BUILDING

.ENABL	LSB

10$:	MOV	#'B,R1		;ASSUME EDIT BACKUP
	TST	@#510		;ARE WE RIGHT?
	BEQ	30$		;BRANCH IF YES
	BMI	20$		;BRANCH IF CREATE
	MOV	#'R,R1		;WAS INSPECT
	BR	30$		;GO TO FALL THRU

20$:	MOV	#'W,R1		;SET EW FOR CREATE
30$:	MOVB	R1,(R0)+	;SET THE E- COMMAND CHAR
	MOV	#512,R1		;SET UP FOR RETURNING FILENAME CHARS
	BR	50$		;RETURN THE FILE NAME STRING

40$:	CLRB	@#540		;SET UP LIKE /INSPECT
	MOV	#200,@#510	;SET INSPECT
HERB:	MOV	#600,R1		;ASSUME MUNG COMMAND
	CMP	#100200,@#510	;IS THIS EXECUTE ENTRY?
	BEQ	50$		;BRANCH IF YES, JUST GIVE TECO THE STRING
	MOVB	#'E,(R0)+	;SET START OF E- COMMAND
	TSTB	@#540		;IS THERE AN EXPLICIT OUT SPEC?
	BEQ	10$		;BRANCH IF NOT
	MOVB	#'W,(R0)+	;SET A W FOR EW
	MOV	#540,R1		;SET UP FOR RETURNING CHARS
50$:	MOVB	(R1)+,(R0)+	;SET THE NEXT CHAR
	BNE	50$		;BRANCH IF NOT END OF FILESPEC
	MOVB	#ESC,-1(R0)	;SET AN ESCAPE
	CMP	R1,#600		;WAS THIS THE EXECUTE STRING?
	BLOS	60$		;NO
	MOVB	-(R0),R2	;YES, NO ESCAPE AND SET NON-ZERO FLAG...
60$:	TSTB	@#540		;WERE WE WORKING ON 1ST NAME?
	BNE	40$		;BRANCH IF NOT
	CMPB	#-1,@#510	;IS THIS MUNG WITH FILE?
	BNE	70$		;BRANCH IF NOT
	MOV	#100200,@#510	;FORCE EXECUTE STRING TO BE TAKEN
	BR	HERB		;GO THROUGH CODE AGAIN

70$:	TST	@#510		;NO YANK FOR CREATE
	BMI	80$		;BRANCH IF CREATE OPERATION
	MOVB	#'Y,(R0)+	;SET A Y
80$:	MOVB	#ESC,(R0)+	;SET
	MOVB	#ESC,(R0)+	; THREE
	MOVB	#ESC,(R0)+	;  ESCAPES
	RETURN			;EXIT

.DSABL	LSB
.SBTTL	GET A VALUE FROM WITHIN RMON

;+
; GVALAB - GET AN ABSOLUTE VALUE.
;
;	R2 =  ADDRESS
;
;	CALL	GVALAB,R1
;
;	R1 =  VALUE
;	R2 =  UNDEFINED
;-

.ENABL	LSB

GVALAB:	SUB	@#RMON,R2	;REMOVE THE RMON BIAS
	.GVAL	#AREA,R2	;ASK MONITOR FOR THE VALUE
	BR	10$		; AND GO CHECK...

;+
; GVAL - GET A VALUE FROM WITHIN RMON.
;
;	CALL	GVAL,R1,OFFSET
;
;	R1 =  VALUE FROM WITHIN RMON
;-

GVAL:	.GVAL	#AREA,(R1)+	;ASK MONITOR FOR THE RMON OFFSET'S VALUE
10$:	BCS	20$		;FAILURE??
	MOV	R0,(SP)		;ELSE MOVE THE FETCHED VALUE TO SAVED R1
	RETURN	R1		; AND EXIT WITH IT

20$:	CALL	DEATH,R1,GVLERR	;WHY DID THAT .GVAL FAIL??

.DSABL	LSB
.SBTTL	RANDOM DEATH ANNOUNCER

;+
; DEATH - DIE A HORRIBLE DEATH.
;
;	CALL	DEATH,R1,MESSAGE
;
; MESSAGE: .ASCIZ "HORRIBLE DEATH MESSAGE"	("?TECO-F-" ADDED)
;-

DEATH:	BIC	#TTLC$!RENTR$!TTSPC$!CMDEX$!CHAIN$!TCBIT$,@#JSW	;TURN ALL OFF
	.RCTRLO			;DEATH, CANCEL CONTROL/O
	.PRINT	#FATAL		;SAY TECO IS DIEING
	.PRINT	(R1)		; AND WHY
	CLR	R0		;DO A HARD
	.EXIT			; EXIT

	TMPORG	TIOTXT

.NLIST	BEX

RELOAD:	.ASCIZ	"I/O error reloading root"

OVLYER:	.ASCIZ	"TECO was incorrectly assembled or linked"

NOROOM:	.ASCIZ	"Not enough memory to start"

GVLERR:	.ASCIZ	"RMON offset value fetch failed"

FATAL:	.ASCII	"?TECO-F-"<200>

.LIST	BEX

	UNORG
.SBTTL	COMMAND STRINGS, READ/WRITE AREA

	ORG	TIOTXT

NULCMD:	.ASCII	?0,0XYEI?<ESC>
NULMID:	.ASCIZ	<ESC><ESC>
NULEND:

INSCMD:	.ASCIZ	?TECO/INSPECT?

CRECMD:	.ASCIZ	?MAKE?

EDICMD:	.ASCIZ	?TECO?

INICMD:	.ASCIZ	?:EITECO?<ESC>?"U-1U1MY'?<ESC><ESC><ESC>

.PSECT	INITRW,RW,D,LCL,REL,CON
	ORG	INITRW

JOBSTS:	.BLKW	8.		;HOLDS JOB STATISTICS/MULTI-TERMINAL CONFIG

OVBASE:	.BLKW			;HOLDS POINTER TO OVERLAY BASE TABLE LESS 6

OVLOAD:	.BLKW			;HOLDS POINTER TO DECODER OVERLAY LOAD ADDRESS

TERSTS:	.BLKW	4		;TERMINAL STATUS BLOCK

AREA:	.BLKW	5		;WORK AREA FOR MONITOR CALLS

.END