.TITLE	TECOIO

;	H.J.	FROM EARLIER VERSION

	.IF NDF	HELP
	VT11=1			;DO THE SCOPE VERSION
	VT52=1			;AND THE VT52 VERSION
	VT52WS=1		;WITH WINDOW SUPPORT
	.ENDC

.SBTTL	GLOBALS, MACROS, DEFINITIONS

	.CSECT	TECOIO

.GLOBL	CLSFIL,	CURFRE,	DATE,	EOFLAG,	GETBUF,	GETFLS,	INPNTR
.GLOBL	GEXIT,	INPSAV,	KILFIL,	LISTEN,	NWATCH,	TECOJP,	OUPNTR
.GLOBL	NOCTLO,	OUTSAV,	P,	PDL,	PRINT,	PUTBUF,	QMAX
.GLOBL	QRSTOR,	QZ,	RWSIZE,	SCHBUF,	SIZER,	SWITCH,	FILBUF
.GLOBL	TECO,	TECOCH,	TECOPD,	TECOSP,	TEXIT,	TIME,	TXSTOR
.GLOBL	TYPE,	WATCH,	XITNOW,	ZMAX,	ZZ,	.VVV.V,	FFFLAG
.GLOBL	ETYPE,	ALLERR,	SIZERB,	PRINTF,	TYPEF,	SIZE,	TLISTN
.GLOBL	EUFLAG,	TFLG,	CLSOUT,	STOPON,	DELLIN,	DELCHR,	CRLFNO
.GLOBL	FLAGRW,	INDIR,	PRTLIN

.MCALL	.CSISPC,.DATE,	.DSTAT,	.EXIT,	.FETCH,	.PRINT,	.RCTRLO
.MCALL	.SETTOP,.SRESET,.TTINR,	.TTYOUT,..V2..,	.SCCA,	.HERR,	.SERR
.MCALL	.LOOKUP,.ENTER, .READW, .WRITW, .CLOSE, .PURGE, .RENAME,.PROTECT


	.ENABL	LC

	..V2..


.MACRO	ERROR	R50COD,TEXT
	.CSECT	$TIOER
$$$=.
	.RAD50	/R50COD/
	.ASCIZ	TEXT
	.EVEN
	.CSECT	TECOIO
	JSR	R4,ERR
	.WORD	$$$
.ENDM	ERROR

.MACRO	ERRORI	R50COD,TEXT
	.CSECT	$TIOER
$$$=.
	.RAD50	/R50COD/
	.ASCIZ	TEXT
	.EVEN
	.CSECT	TECOIO
	MOV	#$$$,R2
	MOV	(R2)+,R0
	SEC
	RTS	PC
	.ENDM	ERRORI
.SBTTL	DEFINITIONS

; RT-11 PARAMETERS
	USTART	= 40	;START ADDRESS OF PROGRAM
	STACK	= 42	;START OF USER STACK
	JSW	= 44	;JOB STATUS WORD
	 TTCBIT	= 100	;TTYIN AND TTYOUT DO INDEED RETURN CARRY IN F/B
	 CHAIN	= 400	;TECO ENTERED VIA CHAIN, DO CCL
	 CMDEX	= 4000	;EXECUTE COMMAND AT 512 ON EXITS
	 TTYUSR	= 10000	;TELETYPE I/O IN USER MODE
	 REENTR	= 20000	;PROGRAM IS REENTERABLE
	 LCASE	= 40000	;ENABLE LOWER CASE INPUT
	PGMTOP	= 50	;POINTER TO TOP OF LOADED PROGRAM
	ERRBYT	= 52	;EMT ERROR CONDITION
	RMON	= 54	;POINTER TO START OF RMON
	USRBUF	= 266	;OFFSET INTO RMON OF USR START
	CONFIG	= 300	;OFFSET TO CONFIG WORD
	 VT11HW	= 4	;GT-40 HARDWARE IS AVAILABLE
	SCROLL	= 302	;RESIDENT GT-40 SCROLLER
	 SCMAX	= 4	;OFFSET IN SCROLLER TO LINE COUNT
	 SCLINK	= 10	;OFFSET IN SCROLLER TO LINK-UP

; TECO SIZE PARAMETERS
	SCHSIZ	= 132.	;SIZE OF SEARCH BUFFER
	PDLSIZ	= 100	;PUSH DOWN SIZE
	FILSIZ	= 40.	;SIZE OF FILE NAME BUFFER
	SIZERB	= 10000	;WE CAN GIVE TECO A ONE TIME SHOT OF 2K

; VARIOUS ASCII CHARACTERS
	BELL	= 7
	BS	= 10
	TAB	= 11
	LF	= 12
	VT	= 13
	FF	= 14
	CR	= 15
	ESC	= 33
	SPACE	= 40
	RUBOUT	= 177
	DEL	= RUBOUT

; ETYPE VALUES  - EDIT TYPE MODES
	BOUT	= 1	;ALLOWS CHARS TO BE OUTPUT UNEDITED
	VIDEO	= 2	;HANDLE TERMINAL AS VT52
	ULCASE	= 4	;ACCEPTS LOWER CASE INPUT
	TECHO	= 10	;DISABLES ECHO FOR ^T INPUT
	ECHON	= 20	;FORCE ECHO ON ON PRINTS
	NOWAIT	= 40	;MAKES ^T NOT WAIT FOR CHAR
	TRUNC	= 400	;MAKES TECO TRUNCATE >80 LINES ON VT52
.SBTTL	MEMORY ORGANIZATION

; THE MEMORY OBTAINED BY TECOIO AND GIVEN TO TECO IS
;	ORGANIZED AS FOLLOWS:
;
;	*********************************
;	*    READ/WRITE AREA		*
;	*    SIZE = RWSIZE		*
;	*				*
;	*    CLEARED BY TECOIO		*
;	*********************************
;	*    PUSH DOWN LIST		*
;	*    POINTED TO BY TECOPD	*
;	*    SIZE = SIZEPD (GLOBAL)	*
;	*********************************
;	*    SEARCH BUFFER		*
;	*    POINTED TO BY SCHBUF	*
;	*    SIZE = SCHSIZ (GLOBAL)	*
;	*********************************
;	*    DEVICE HANDLERS		*
;	*				*
;	*    THIS AREA IS OPTIONAL	*
;	*    AND ONLY EXISTS IF USER	*
;	*    REQUESTS NON-RESIDENT	*
;	*    DEVICE HANDLERS		*
;	*********************************
;	*    TEXT STORAGE AREA		*
;	*    POINTED TO BY TXSTOR	*
;	*    SIZE IN ZMAX(RW AREA)	*
;	*********************************
;	*    Q-REGISTER STORAGE		*
;	*    POINTED TO BY QRSTOR	*
;	*    SIZE IN QMAX(RW AREA)	*
;	*********************************
;	*    FREE STORAGE		*
;	*    SIZE IN CURFRE -NO POINTER	*
;	*    USR -DOWN FROM TOP FOR 2K	*
;	*********************************
;
; ALL POINTERS IN TECOIO ARE RELATIVE TO THE BEGINNING OF
;	THE IMPURE AREA, WHICH IS POINTED TO BY FREEST IN TECOIO.
; THE TEXT STORAGE AREA AND Q-REGISTER STORAGE AREAS
;	ALSO HAVE AN ASSOCIATED WORD IN THE R/W AREA TELLING HOW
;	MUCH OF THE ALLOCATED STORAGE IS IN USE.
;	THE POINTERS ARE ARRANGED AS:
;		TXSTOR, ZZ, ZMAX
;	AND	QRSTOR, QZ, QMAX
.SBTTL	SAVE, RESTORE, ERROR


SAVREG:	MOV	R3,-(SP)	;PRESERVE R1,R3, AND R4 FOR ALL RETURNS
	MOV	R1,-(SP)	;(R4 SAVED BY JSR R4)
	MOV	SP,SPSAVE	;SAVE FOR ERROR RETURNS
	MOV	R0,-(SP)	;SAVE FOR NON ERROR RETURNS
	MOV	R2,-(SP)
	MOV	R4,-(SP)	;RETURN ADDRESS
	MOV	5*2(SP),R4	;RESTORE R4 TO ORIGINAL VALUE
	JSR	PC,@(SP)+	;EXCHANGE HIM FOR US
	MOV	(SP)+,R2	;RESTORE R2
	MOV	(SP)+,R0	; AND R0
	CLC			;SAY NORMAL RETURN
REGRET:	MOV	(SP)+,R1
	MOV	(SP)+,R3
	MOV	(SP)+,R4
	MOV	FREEST,R5	;ALWAYS POINT R5 BACK TO WORK AREA
	RTS	PC

ERR:	SEC			;TELL TECO THINGS ARE NO GOOD
	MOV	(R4)+,R2	;POINT TO RAD50 CODE
	MOV	(R2)+,R0	;GET CODE IN R0, POINTER TO TEXT IN R2
	MOV	SPSAVE,SP	;RESTORE STACK
	BR	REGRET		;AND EXIT
	.IF NDF	VT01

.SBTTL	LISTEN FOR TTY

GETCHR:	MOV	#JSW,R0		;JSW IS REFERENCED A LOT
	BIC	#LCASE+TTCBIT,@R0 ;ASSUME UPPER CASE AND SUSPEND INPUT
	BIT	#ULCASE,ETYPE(R5) ;IS INPUT TO BE LOWER CASE?
	BEQ	1$		;BRANCH IF UPPER CASE INPUT
	BIS	#LCASE,@R0	;SET ACCEPT LOWER CASE
1$:	BIS	#TTYUSR,@R0	;MAKE SURE WE ARE IN SPECIAL MODE
	JSR	PC,@(SP)+	;CO-ROUTINE FOR MORE SETUP
2$:	.TTINR			;READ THE CHAR WITH NO WAIT
	BIC	#177600,R0	;GET RID OF PARITY
	BLOS	5$		;BRANCH IF NO CHAR
	CMP	#175,R0		;CHECK FOR ALTMODES
	BEQ	3$
	CMP	#176,R0		;OF ALL SORTS
	BNE	4$
3$:	MOV	#ESC,R0		;AND FIX THEM
4$:	RTS	PC
5$:	BIT	#TTCBIT,@#JSW	;WAS THIS A NO WAIT CALL?
	BEQ	2$		;BRANCH TO WAIT FOR CHAR
	MOV	#-1,R0		;INDICATE NO CHAR AVAILABLE
RETPOP:	TST	(SP)+		;REMOVE RETURN ADDRESS
	RTS	PC		;RETURN WITHOUT ECHO


TLISTN:	JSR	PC,GETCHR	;SET UP FOR GETTING TT INPUT
	BIT	#NOWAIT,ETYPE(R5) ;DOES USER WANT IMMEDIATE RETURN?
	BEQ	1$		;BRANCH IF STANDARD READ
	BIS	#TTCBIT,@R0	;SET NO SUSPEND BIT IN JSW
1$:	JSR	PC,@(SP)+	;TRY TO GET A CHAR
	CMPB	#'C-100,R0	;IS CHAR AN ^C?
	BNE	2$		;BRANCH IF NOT
	CMPB	R0,UPCFLG	;WAS LAST CHAR ALSO A ^C?
	BNE	2$		;BRANCH IF NOT, RETURN IT AS NORMAL CHAR
	BIS	#100000,TFLG(R5);SIGNAL ABORT ON 2ND ^C
2$:	MOVB	R0,UPCFLG	;SAVE CHAR FOR NEXT TIME
	BIT	#TECHO,ETYPE(R5);ECHO ^T CHARS?
	BEQ	TYPE		;BRANCH TO ECHO IT
	RTS	PC		;RETURN WITHOUT ECHO

RETCHR:	MOV	(SP)+,CHAINF	;SAVE NEW DISPATCH ADDRESS
	BR	RETPOP		;RETURN FROM FUDGED LISTEN

	.ENABL	LSB

1$:	MOVB	#'B,R0		;ASSUME EDIT BACKUP
	TST	@#510		;ARE WE RIGHT?
	BEQ	3$		;BRANCH IF YES
	BMI	2$		;BRANCH IF CREATE
	MOVB	#'R,R0		;WAS INSPECT
	BR	3$		;GO TO FALL THRU
2$:	MOVB	#'W,R0		;SET EW FOR CREATE
3$:	MOV	#511,CHPTR	;SET UP FOR RETURNING FILENAME CHARS
	BR	5$		;RETURN THE FILE NAME STRING


LISTEN:	JSR	PC,GETCHR	;GET A CHAR FROM TERMINAL
	JMP	@CHAINF		;DISPATCH TO ROUTINE (NORMALLY GETTT)

4$:	CLRB	@#540		;SET UP LIKE /INSPECT
	MOV	#200,@#510	;SET INSPECT
CHINIT:	MOV	#600,CHPTR	;ASSUME MUNG COMMAND
	CMP	#100200,@#510	;IS THIS EXECUTE ENTRY?
	BEQ	6$		;BRANCH IF YES,JUST GIVE TECO THE STRING
	MOVB	#'E,R0		;RETURN START OF E- COMMAND
	JSR	PC,RETCHR	;RETURN TO NEXT INSTR AND RETURN CHAR
	TSTB	@#540		;IS THERE AN EXPLICIT OUT SPEC?
	BEQ	1$		;BRANCH IF NOT
	MOVB	#'W,R0		;RETURN A W FOR EW
	MOV	#537,CHPTR	;SET UP FOR RETURNING CHARS
5$:	INC	CHPTR		;BUMP TO NEXT POSITION
	JSR	PC,RETCHR
6$:	MOVB	@CHPTR,R0	;GET NEXT CHAR
	BNE	5$		;BRANCH IF NOT AT END OF FILESPEC
	MOVB	#ESC,R0		;RETURN AN ALTMODE
	JSR	PC,RETCHR
	TSTB	@#540		;WERE WE WORKING ON 1ST NAME?
	BNE	4$		;BRANCH IF NOT
	CMPB	#-1,@#510	;IS THIS MUNG WITH FILE?
	BNE	7$		;BRANCH IF NOT
	MOV	#100200,@#510	;FORCE EXECUTE STRING TO BE TAKEN
	BR	CHINIT		;GO THROUGH CODE AGAIN
7$:	TST	@#510		;NO YANK FOR CREATE
	BMI	8$		;BRANCH IF CREATE OPERATION
	MOVB	#'Y,R0		;RETURN A Y
	JSR	PC,RETCHR
	MOVB	#ESC,R0		;AND AN ESCAPE
	JSR	PC,RETCHR
8$:	CLR	INDIR(R5)	;ENABLE TECO '*' PROMPT
	MOVB	#ESC,R0		;AND AN ESCAPE
	JSR	PC,RETCHR	;END INPUT CHAIN SEQUENCE

GETTT:
	.IF DF	HELP		;DON'T ALLOW PROMPT IF THIS IS HELP.SAV
	.PRINT	#HLPMSG
	BR	TEXIT		;EXIT
	.ENDC

	JSR	PC,@(SP)+	;LISTEN USES ALL DEFAULTS
	CLRB	UPCFLG		;MAKE DOUBLE ^C CHECK ONLY WORK FOR ^T
	BIC	#100000,TFLG(R5);MAKE SURE 2 IN A ROW IS OK AS REGULAR
				;TERMINAL INPUT AND FALL INTO ECHO CODE
	.DSABL	LSB
	.NLIST
	.IFF

.SBTTL	LISTEN FOR TTY AND KEEP CURSOR BLINKING

	ONCTR	=  200		;LOOP COUNT FOR CURSOR ON
	OFFCTR	= 2000		;LOOP COUNT FOR CURSOR OFF

CURSOR:	TST	NWATCH(R5)	;IS THE SCOPE ON?
	BLE	LISTEN
	DEC	(PC)+		;COUNT FLICKERER
FLICKR:	.WORD	1
	BGT	LISTEN		;IF > 0, LEAVE IT OFF
	BEQ	1$		;IF = 0, TURN IT ON
	BVC	2$		;IF < 0 BUT NOT DONE, GO DISPLAY IT
	MOV	#100000+OFFCTR-ONCTR,FLICKR	;TURN IT OFF
1$:	ADD	#100000+ONCTR,FLICKR		;TURN IT ON
	BR	CURSOR		;LOOP
2$:	MOV	#YPOS,R0	;POINT TO STATUS REGS
	MOV	CURSY,@R0	;PUT IN Y CURSOR
	MOV	CURSX,-(R0)	;  AND X CURSOR POSITION
	MOV	#4,-(R0)	;SET UP COMMAND
	MOV	#9.,5$		;SET UP COUNT
3$:	INC	@R0		;INTENSIFY!
4$:	TSTB	@R0		;WAIT FOR COMPLETION
	BPL	4$
	ADD	#6,4(R0)	;INCREMENT YPOS
	DEC	(PC)+		;DONE YET?
5$:	.WORD	9.
	BNE	3$		;NO, INTENSIFY ANOTHER

LISTEN:	BIS	#TTYUSR+TTCBIT,@#JSW ;MAKE SURE WE ARE IN SPECIAL MODE
	.TTINR
	BCS	CURSOR		;GO DISPLAY CURSOR IF NOT READY
	BIC	#177600,R0
	BEQ	LISTEN		;IGNORE NULLS
	CMP	R0,#175		;CHECK FOR ALTMODES
	BLO	1$
	CMP	R0,#176		;OF ALL SORTS
	BHI	1$
	MOV	#ESC,R0		;AND FIX THEM
1$:				;FALL INTO ECHO ROUTINE

	.ENDC
	.LIST
.SBTTL	TYPE CHARACTER

TYPE:	MOV	R0,-(SP)	;SAVE A REG
TYPE1:	BIT	#BOUT,ETYPE(R5)	;OUTPUT CHAR AS IS?
	BNE	2$		;BRANCH TO DO SO
	CMP	#RUBOUT,R0	;PRINT IT AL ALL?
	BEQ	4$		;NO
	CMP	#SPACE,R0	;NEED WE EDIT IT?
	BLOS	2$		;NOT IF 40 < CHAR
	CMP	#ESC,R0		;ALTMODE?
	BEQ	5$
	CMP	#TAB,R0		;TAB?
	BEQ	2$
	CMP	#CR,R0		;RETURN?
	BEQ	2$
	CMP	#LF,R0		;LINE FEED?
	BEQ	2$
	CMP	#FF,R0		;FORM FEED?
	BEQ	6$
	CMP	#BELL,R0	;BELL?
	BNE	1$		;NO, SPECIAL ECHOS AS ^..
	.TTYOUT			;BELL ECHOS AS DING ^G
1$:	MOV	#'^,R0
	.TTYOUT
	MOV	@SP,R0
	BIS	#100,R0
2$:	.TTYOUT
3$:	MOVB	#1,OUTDNE	;FLAG OUTPUT SENT TO TERMINAL
4$:	MOV	(SP)+,R0
	RTS	PC
5$:	MOV	#'$,R0		;HERE FOR ALTMODE
	BR	2$
6$:	MOV	#4.,-(SP)	;HERE FOR FORM FEED
7$:	MOV	#LF,R0		;ECHO AS FOUR LINE FEEDS
	.TTYOUT
	DEC	@SP
	BNE	7$
	INC	(SP)+
	BR	3$

TYPEF:	MOV	R0,-(SP)	;SAVE THE CHAR FOR RETURN
	CMP	#100,R0		;SHOULD CHAR BE CONSIDERED FOR FLAGING?
	BGT	TYPE1		;BRANCH IF NOT
	TST	EUFLAG(R5)	;WHAT KIND OF FLAGGING?
	BMI	TYPE1		;BRANCH IF NONE
	BEQ	1$		;BRANCH IF FLAG LOWER
	BIT	#40,R0		;IS CHAR UPPER
	BEQ	2$		;BRANCH IF YES TO FLAG THE CHAR
	BR	3$		;MAKE CHAR UPPER CASE BUT DONT FLAG
1$:	BIT	#40,R0		;IS CHAR LOWER?
	BEQ	TYPE1		;BRANCH IF UPPER, DO NOTHING
2$:	MOV	#'',R0		;SET UP TO OUTPUT A QUOTE
	.TTYOUT
3$:	MOV	@SP,R0		;RETRIEVE THE CHAR
	BIC	#40,R0		;MAKE SURE ITS UPPER CASE
	BR	TYPE1		;GO OUTPUT IT
DELLIN:	JMP	@DLIN		;DO PROPER LINE DELETE FOR TERMINAL
DELCHR:	JMP	@DCHR		;SAME FOR CHARACTER DELETE

DLIN:	.WORD	CRLFNO		;DEFAULT TO HARDCOPY TERMINAL
DCHR:	.WORD	TYPE		;SAME FOR CHARACTER DELETES

FLAGRW:
	.IF DF	VT52

	CMP	#ETYPE,R2	;IS THIS TERMINAL FLAG
	BNE	1$		;BRANCH IF NOT
	CMP	#-1,R3		;IS THIS A NEW VALUE?
	BNE	1$		;BRANCH IF NOT
	JSR	R4,SAVREG	;PRESERVE THE REGISTERS
	BIC	#^C<VIDEO>,R0	;ONLY INTERESTED SCOPE MODE BIT
	MOV	R0,R1		;MAKE COPY OF BIT
	ADD	ETYPE(R5),R0	;GET OLD VALUE
	BIT	#VIDEO,R0	;IS IT CHANGING?
	BEQ	1$		;BRANCH IF NOT
	MOV	#CRLFNO,DLIN	;ASSUME HARDCOPY TERMINAL
	MOV	#TYPE,DCHR	;ASSUME HARDCOPY TERMINAL
	TST	R1		;DOES USER WANT VT52 HANDLING?
	BEQ	1$		;BRANCH IF NOT, ASSUMPTIONS RIGHT
	MOV	#VTDLIN,DLIN	;SET UP TO DO VIDEO TERMINAL DELETES
	MOV	#VTDCHR,DCHR	;

	.IFTF

1$:	RTS	PC

	.IFT

VTDLIN:	.PRINT	#ERLIN		;REMOVE LINE ON A VT52
	RTS	PC		;CONTINUE

VTDCHR:	CMPB	#SPACE,R0	;CLASSIFY CHARACTER
	BEQ	4$		;BRANCH IF BLANK TO JUST BACKSPACE
	BLT	2$		;BRANCH IF CHARACTER 1 PRINT POSITION
	CMPB	#ESC,R0		;IS IT AN ESCAPE?
	BEQ	2$		;BRANCH IF YES, WAS OUTPUT AS '$'
	CMPB	#CR,R0		;IS IT A REAL SPECIAL?
	BEQ	3$		;BRANCH IF HARD TO HANDLE HORIZONTAL POS
	BLT	1$		;BRANCH IF ECHOED IF '^' FORM TO ERASE 2
	CMPB	#TAB,R0		;CHECK FOR OTHER END OF REAL SPECIALS
	BGT	1$		;WAS OUTPUT IN '^' FORM, ERASE 2
	BEQ	3$		;BRANCH TO HANDLE TAB BY RE-ECHO LINE
	CMPB	#VT,R0		;CHECK FOR LF,VT,FF
	BGT	6$		;BRANCH IF LINEFEED FOR CURSOR UP
	BLT	5$		;BRANCH IF FF FOR 4*CURSOR  P
1$:	.PRINT	#DEL1		;REMOVE 1 PRINTABLE CHAR
2$:	.PRINT	#DEL1		;REMOVE 1 PRINTABLE CHAR
	RTS	PC		;RETURN
3$:	.PRINT	#ERLIN		;ERASE THE WHOLE LINE
	JMP	PRTLIN		;AND RE-ECHO IT AND RETURN
4$:	.TTYOUT	#BS		;OUTPUT A BACKSPACE
	RTS	PC
5$:	.PRINT	#CURUP3		;MOVE THE CURSOR UP 3
6$:	.PRINT	#CURUP		;MOVE THE CURSOR UP 1
	RTS	PC

DEL1:	.BYTE	BS,SPACE,BS,200
ERLIN:	.BYTE	CR,ESC,'K,200
CURUP3:	.BYTE	ESC,'A,ESC,'A
CURUP:	.BYTE	ESC,'A,200
	.EVEN

	.ENDC

.SBTTL	PRINT STRINGS

PRINTF:	JSR	R4,SAVREG	;SAVE THE REGISTERS
	MOV	#TYPEF,R2	;PRINT FLAGGED USES TYPE FLAGGED
	BR	PRLP		;JUMP INTO PRINT CODE

PRINT:	JSR	R4,SAVREG	;SAVE THE REGISTERS
	MOV	#TYPE,R2	;PRINT USES TYPE SUBROUTINE
PRLP:	BIT	#ECHON,ETYPE(R5);SHOULD WE FORCE ECHO ON?
	BEQ	1$		;BRANCH IF NOT
	.RCTRLO			;TURN ECHO ON
1$:	DEC	R4		;COUNT LENGTH
	BMI	RETTEC		;NO MORE
	MOVB	(R3)+,R0
	JSR	PC,@R2		;CALL APPROP TYPE SUBROUTINE
	BR	1$
.SBTTL	GEXIT, TEXIT, NOCTLO, TIME, DATE, SWITCH

GEXIT:	MOV	#512,R0		;SET UP TO EXECUTE COMMAND
	MOV	R0,R1		;SAVE FOR LATER
	MOV	FILBUF(R5),R2	;GET POINTER TO COMMAND TO EXECUTE
1$:	MOVB	(R2)+,(R0)+	;MOVE IN A BYTE
	BNE	1$		;BRANCH UNTIL END OF STRING
	SUB	R1,R0		;CALC SIZE
	MOV	R0,-(R1)	;STORE IT AT 510
	BIS	#CMDEX,@#JSW	;SET FLAG FOR MONITOR
	CLR	EXITFL		;SIGNAL HARD EXIT

TEXIT:				;EXIT FROM TECO
	.NLIST
	.IF DF	VT01		;CLEAR SCOPE IF ANY
	JSR	PC,SCLEAR	;TURN OFF SCOPE
	.ENDC
	.LIST
	.IF DF	VT11

	JSR	PC,SCLEAR	;STOP THE DISPLAY
	MOV	SCROLP,R3	;END THE LINK-UP
	BEQ	1$
	MOV	LINK,@R3	;RELINK HIM TO HIMSELF
	MOV	LCTSAV,SCMAX-SCLINK(R3) ;RESTORE LINE COUNT
	MOV	@R3,@#DPC	;RESTART SCROLLER
1$:
	.ENDC
	.IF NDF	HELP		;USE HARD EXIT CODE FOR HELP.SAV
	MOV	EXITFL,R0	;SOFT EXIT FOR EX, HARD EXIT FOR EG
	.IFF
	CLR	R0		;MAKE HELP.SAV NON-REENTERABLE
	.SETTOP			;PREVENT WRITE OF PROGRAM AREA
	.ENDC
	.EXIT

XITNOW:	BIC	#TTYUSR,@#JSW	;TURN OFF SPECIAL MODE BIT
ALLERR:	BIC	#100000!BOUT,ETYPE(R5)	;TURN ECHO BACK ON
	BIS	#TTCBIT,@#JSW	;TURN ON NO WAIT IN FB
	MOV	R0,-(SP)	;SAVE R0 (ERROR CODE)
1$:	.TTINR			;EMPTY TYPE AHEAD RING BUFFER FOR ERRORS
				;NOTE--THIS EATS BATCH STREAMS ON ERRORS
	BCC	1$		;LOOP TILL ALL CHARS GONE
	MOV	(SP)+,R0	;RESTORE R0
	BIC	#TTCBIT,@#JSW	;RESET NO WAIT FLAG
NOCTLO:	.RCTRLO
RETTEC:	RTS	PC

STOPON:	TST	ETYPE(R5)	;IS CONTROL/C TRAP ON
	BPL	1$		;NO
	BIC	#100000,ETYPE(R5) ;YES, BUT CLEAR IT NOW
	MOV	R0,(SP)		;SAVE R0
2$:	.TTINR			;CLEAR INPUT
	BCC	2$
	MOV	(SP)+,R0	;RESTORE R0
1$:	RTS	PC		;EXIT

DATE:	.DATE
	RTS	PC

TIME:	CLR	R0		;SORRY, WE HAVE NO TIME
	RTS	PC

SWITCH:	MOV	@#177570,R0
	RTS	PC


WATCH:
	.IF NDF	VT11
	.IF NDF	VT52WS
	RTS	PC
	.IFF
	JMP	VWATCH
	.ENDC
	.IFF
	.IF NDF	VT52WS
	JMP	SWATCH
	.IFF
	JSR	PC,SWATCH
	JMP	VWATCH
	.ENDC
	.ENDC
	.IF DF	VT11

.SBTTL	VT11,VS60 HANDLER

DPC	= 172000	;DISPLAY PC
DPS	= 172002	;DISPLAY STATUS REGISTER
GTVECT	= 354		;MONITOR OFFSET FOR VT11 VECTOR
CHAR	= 100000	;CHARACTER MODE
SHORTV	= 104000	;SHORT VECTORS
POINT	= 114000	;POINT MODE
INT4	= 3000		;INTENSITY 4
LPOFF	= 100		;LIGHT PEN OFF
BLKOFF	= 20		;BLINK OFF
BLKON	= 30		;BLINK ON
EDGEFL	= 40		;EDGE FLAG INDICATOR
LINE0	= 4		;SOLID LINES
DJMP	= 160000	;DISPLAY JUMP
DSTOP	= 173400	;STOP & INTERRUPT
DSTOPN	= 173000	;STOP!
INTX	= 40000		;INTENSIFY
CFACTR	= 40.		;CHICKEN FACTOR
MISVX	= 20000		;SHORT NEGATIVE X
MISVY	= 100		;SHORT NEGATIVE Y
XSZ	= 7.		;X SIZE OF CURSOR
YSZ	= 12.		;Y SIZE OF CURSOR


GTINT:	TST	(PC)+		;FLAG TO STOP?
GSTOPF:	0
	BNE	1$		;BRANCH IF DON'T STOP
	CLR	GHALTD		;INDICATE DPU STOPPED
	BR	GTRTI		;RETURN FROM INTERRUPT
1$:	INC	@#DPC		;RESTART DISPLAY
GTRTI:	RTI

				;DON'T USE ANY REGISTERS!!
SCLEAR:	CLR	GSTOPF		;BRING DPU TO HALT
GWAIT:	TST	(PC)+		;IS DPU HALTED?
GHALTD:	.WORD	0		;0 MEANS HALTED, OTHER MEANS NOT
	BNE	GWAIT		;BRANCH TILL DPU IS STOPPED
	TST	SCROLP		;CHECK SCROLLER LINK WORD
	BEQ	QCKRET		;BRANCH IF NONE
	MOV	#DISINI,@SCROLP	;RELINK THE SCROLLER TO HIMSELF
	MOV	#DISINI,@#DPC	;RESTART THE SCROLLER
QCKRET:	RTS	PC		;RETURN WITH BUFFER IN UPDATABLE STATE
SWATCH:	TST	GTFLAG		;DO WE HAVE A VT11?
	BEQ	QCKRET		;BRANCH IF NOT, DON'T DO A THING
	TST	R0		;WHAT SHOULD WE DO?
	BEQ	SCLEAR		;TURN IT OFF
	BMI	QCKRET		;IGNORE NEGATIVE CALLS
	CMP	LINMAX,R0	;TOO MANY ?
	BGE	1$
	MOV	LINMAX,R0
1$:	JSR	R4,SAVREG	;SAVE EVERYTHING
	MOV	GTVCTR,R1	;GET ADDRESS OF VT11 VECTOR
	MOV	#GTINT,(R1)+	;SET INTERRUPT LOC
	MOV	#340,@R1	;PRIORITY 7
	MOV	P(R5),-(SP)	;SAVE CURRENT POINTER
	MOV	R0,-(SP)	;SAVE LINE COUNT
	NEG	R0		;GO BACKWARDS N LINES
	JSR	PC,.VVV.V	;USING TECO'S MOVER
	MOV	R1,R4		;NEW P IS RETURNED IN R1, TOO
	MOV	(SP)+,R0	;RETRIEVE LINE COUNT
	INC	R0		;BUMP BY ONE
	MOV	@SP,P(R5)	;RESTORE STARTING POINT
	JSR	PC,.VVV.V		;AND ADVANCE
	SUB	R4,R1		;R1 NOW CONTAINS DISPLAY COUNT
	ADD	TXSTOR(R5),R4	;R4 IS NOW ABSOLUTE STARTING POINT
	MOV	@SP,P(R5)	;FINALLY REFIX POINTER
	ADD	TXSTOR(R5),@SP	;COMPUTE CURSOR POINTER
	MOV	(SP)+,(PC)+	;SAVE POSITION OF CURSOR
CURSR:	.WORD	0		;CHARACTER POS OF CURSOR
	JSR	PC,SCLEAR	;CLEAR THE SCOPE
	MOV	DCHRS,R3	;POINT TO DISPLAY BUFFER

CRET:	CLR	R2		;START TABS
DSPLAY:	CMP	#72.,R2		;ABOUT TO OVERFLOW?
	BGT	2$		;BRANCH IF NOT
	TST	R1		;IS THIS LAST CHAR IN BUFFER?
	BEQ	2$		;BRANCH IF IT IS, DON'T WANT OVERFLOW
	CMPB	#CR,@R4		;AVOID SEQUENCE IF OVERFLOW ON CR
	BEQ	2$		;BRANCH IF CR
	MOV	#OVSEQ,R0	;FOR LINE OVERFLOW USE SEQUENCE
1$:	MOVB	(R0)+,(R3)+	;LF, CR, SHIFT-OUT, ^W, SHIFT-IN, BLANK
	BNE	1$		;BRANCH IF NOT DONE
	DEC	R3		;TAKE OUT NULL
	MOVB	@R0,R2		;SET COLUMN COUNTER
2$:	CMP	CURSR,R4	;ARE WE AT THE CURSOR?
	BNE	4$		;NO
	JSR	R0,DINSRT	;INSERT A DJMP INTO BUFFER
	.WORD	DJMP		;JUMP TO THE CURSOR
	MOV	#UPCUR,(R3)+	;IT IS USUALLY AN UP CURSOR
	CMPB	@R4,#LF		;ARE WE BEFORE A LINE FEED?
	BNE	3$		;NO
	TST	R1		;YES. IS THE LINE FEED GOING OUT?
	BEQ	3$		;NO
	MOV	#DWNCUR,-2(R3)	;YES. CHANGE TO A DOWN CURSER
3$:	MOV	R3,CURETN	;AND FIX THE RETURN
4$:	DEC	R1		;KNOCK DOWN CHARACTER COUNT
	BMI	WRTN		;BRANCH IF DONE
	CMP	CHICKN,R3	;ARE WE TOO CLOSE FOR COMFORT?
	BLOS	WRTN		;YES. QUIT NOW
	MOVB	(R4)+,@R3	;GET A BYTE OF TEXT
5$:	INC	R2		;COUNT FOR TABS
	CMPB	#SPACE,(R3)+	;IS IT SPECIAL?
	BLE	DSPLAY		;BRANCH IF NOT
	CMPB	#TAB,-(R3)	;IS IT A TAB?
	BEQ	8$		;BRANCH IF IT IS
	BHI	10$		;BRANCH IF MUST BE REGULAR CONTROL CHAR
	CMPB	#CR,(R3)+	;IS CHAR A CR?
	BEQ	CRET		;BRANCH IF IT IS, RESET COLUMN COUNTER
	BLO	9$		;BRANCH IF >CR, MAY BE ALTMODE?
	MOV	#LF,R0		;INSERT LINEFEEDS FOR VT OR FF
	DEC	R2		;REFIX COLUMN COUNTER
	CMPB	R0,-(R3)	;IS IT FF, VT OR LF
	BEQ	6$		;SINGLE SPACE
	MOVB	R0,(R3)+	;DO TRIPLE LF FOR FF OR VT
	MOVB	R0,(R3)+
6$:	MOVB	R0,(R3)+
	BR	DSPLAY		;AND CONTINUE

7$:	INC	R2		;BUMP COLUMN COUNTER
8$:	MOVB	#SPACE,(R3)+	;PUT OUT A BLANK
	BIT	#7,R2		;ARE WE DONE?
	BNE	7$		;NO, KEEP GOING
	BR	DSPLAY		;YEP, CONTINUE

9$:	CMPB	#ESC,-(R3)	;IS IT AN ALTMODE?
	BNE	10$		;REGULAR CONTROL CHAR
	MOVB	#'$,(R3)+	;PRINT IT LIKE A DOLLAR SIGN
	BR	DSPLAY		;AND CONTINUE THE LOOP
10$:	MOVB	(R3)+,@R3	;MAKE ROOM FOR UPARROW
	MOVB	#'^,-1(R3)	;PRINT ARROW
	BISB	#100,@R3	;PUT IT IN RANGE
	BR	5$		;AND CONTINUE

WRTN:	JSR	R0,DINSRT	;INSERT A DJMP INTO DISPLAY FILE
	.WORD	DJMP
	MOV	#DISEND,@R3
	MOV	SP,GSTOPF
	MOV	SP,GHALTD	;INDICATE DISPLAY RUNNING
	MOV	SCROLP,R0	;POINT TO THE SCROLLER LINK WORD
	BEQ	1$		;NONE, JUST START THE DISPLAY
	MOV	#LINK+2,@R0	;LINK THE BUFFER INTO THE SCROLLER
	MOV	SCLCNT,SCMAX-SCLINK(R0) ;SHORTEN HIM
	RTS	PC
1$:	MOV	#DISINI,@#DPC
	RTS	PC

DINSRT:	CLRB	(R3)+		;FORCE EVEN
	BIC	#1,R3
	MOV	(R0)+,(R3)+	;INSERT WORD
	RTS	R0		;RETURN


	.ENDC
	.IF DF	VT52WS

.SBTTL	VT52 "WATCH" FOR TECO-11

.SBTTL	ASSEMBLY PARAMETERS

; I$$SOB	ASSEMBLE FOR HARDWARE 'SOB' INSTRUCTION

; I$$MUL	ASSEMBLE FOR HARDWARE 'MUL' INSTRUCTION

.SBTTL	DEFAULT AND SET UP THE ASSEMBLY PARAMETERS

H.SIZE	=	80.	;HORIZONTAL WIDTH
V.SIZE	=	24.	;VERTICAL SIZE

.IF	NDF	I$$SOB
.MACRO	SOB	REG,DST
	DEC	REG
	BNE	DST
.ENDM	SOB
.ENDC

.IF	NDF	I$$MUL
.MACRO	MULT	AMT
	JSR	PC,MUL'AMT
.ENDM	MULT
.ENDC

.MACRO	TYPEBF
	.TTYOUT
.ENDM
.SBTTL	SCOPE "WATCH" ROUTINE

VWATCH:	TST	VT52FL		;IS THE WORK AREA ALLOCATED?
	BPL	10$		;BRANCH IF NOT, MUST EXIT
	BIT	#512.,ETYPE(R5)	;IS THE SCOPE AVAILABLE?
	BEQ	10$		;NOPE, QUICKLY EXIT
	MOV	R0,BUSTRT+RWSIZE(R5) ;SAVE THE CALLING ARGUMENT
	BMI	20$		;ARG <0, PROCESS A REAL CALL
	CLR	INITFL+RWSIZE(R5) ;ARG >=0, FORGET THE ENTIRE SCREEN
10$:	RTS	PC		;EXIT

20$:	MOV	NWATCH(R5),R0	;RESTORE ARGUMENT TO OLD ARGUMENT
	JSR	R4,SAVREG	;SAVE ALL REGISTERS
	MOV	BUSTRT+RWSIZE(R5),R0 ;GET CALLING ARGUMENT BACK AGAIN
	COM	R0		;MAKE COUNT OF CHANGED LINES POSITIVE
	BEQ	DOIT		;BRANCH IF NO SPECIAL SCREEN MODS
	MOV	#24.,R1		;PUT MAXIMUM LEGAL COUNT INTO ODD REG
	CMP	R0,R1		;IS ARGUMENT OVER MAXIMUM?
	BHI	30$		;YES, USE MAXIMUM
	MOV	R0,R1		;NO, USE ARGUMENT
30$:	MULT	40		;MULTIPLY LINE COUNT BY 40. TO GET WORDS
	MOV	#MAPST+RWSIZE,R0 ;BUILD A POINTER
	ADD	R5,R0		; TO THE MAP
40$:	CLR	(R0)+		;CLEAR WHAT WE THINK IT LOOKS LIKE
	SOB	R1,40$		; FOR THAT MANY LINES
	MOV	#-1,PRELIN+RWSIZE(R5) ;CLOBBER LAST KNOWN CURSOR
	CLRB	OUTDNE		;RESET THE OUTPUT OCCURRED FLAG
	RTS	PC		; AND EXIT
DOIT:
;	MOV	ETYPE(R5),-(SP)	;SAVE ENTERING EDIT FLAG VALUE
;	BIS	#1,ETYPE(R5)	; AND, THEN, ENSURE IMAGE MODE OUTPUT
	JSR	R4,SETJSR	;SET UP FOR
	 .WORD	FTRANS		; COUNTING LINES
	MOV	P(R5),-(SP)	;SAVE CURRENT POINTER
	;CLR	R0		;SET THE ARGUMENT
	JSR	PC,.VVV.V	;DO 0L (START OF CURSOR LINE)
	MOV	R1,R4		;SET START OF THE CURSOR LINE
	MOV	ZZ(R5),R1	;GET TOTAL SIZE OF TEXT BUFFER
	SUB	R4,R1		; AND FIND SIZE TO END OF BUFFER
	JSR	PC,DOTEXT	;NOW COUNT LINES IN THAT TEXT
	MOV	#V.SIZE,R0	;SET THE SCREEN'S SIZE
	MOV	NWATCH(R5),-(SP) ;GET THE STANDARD CURSOR LINE NUMBER
	BEQ	10$		;ZERO, MAKE IT VALID
	CMP	R0,(SP)		;MIGHT BE VALID, CHECK UPPER LIMIT
	BHI	20$		;IT IS VALID, USE IT
10$:	MOV	#16.,(SP)	;USE A DEFAULT STANDARD IF INVALID
20$:	SUB	BUSTRT+RWSIZE(R5),R0 ;CALC LINE NUMBER OF CURSOR LINE
	CMP	R0,(SP)		;SHOULD WE USE THE CALCULATED VALUE?
	BLOS	30$		;NOPE, USE STANDARD
	MOV	R0,(SP)		;YEP, USE CALCULATED
30$:	MOV	#CHCKBL+RWSIZE,R2 ;GET POINTER TO CHECKING BUFFER
	ADD	R5,R2		; ABSOLUTELY
	MOV	R2,-(SP)	;SAVE START OF THE BUFFER
	CLR	(R2)		;INDICATE NO FUDGE MOVEMENT INITIALLY
	TSTB	OUTDNE		;HAS ANY TERMINAL OUTPUT BEEN DONE?
	BEQ	40$		;NOPE
	CLR	INITFL+RWSIZE(R5) ;YEP, INDICATE SCREEN UNKNOWN
40$:	TST	INITFL+RWSIZE(R5) ;DO WE KNOW WHAT'S ON THE SCREEN?
	BPL	50$		;BRANCH IF NOT
	INC	(R2)		;SET THE FLAG WORD
50$:	JSR	R4,SETJSR	;SET UP FOR
	.WORD	FTRANS		; COUNTING LINES

LINES:	MOV	#FCHAR,OUTCHR+RWSIZE(R5) ;RESET OUTPUT ROUTINE
	MOV	P(R5),LINPTR+RWSIZE(R5) ;SAVE OLD LINE INDEX
	BEQ	TRYMOV		;AT TOP OF PAGE, QUIT FOR NOW
	MOV	#-1,R0		;GET TO START OF PREVIOUS TEXT LINE
	JSR	PC,.VVV.V	;USING TECO'S MOVER
	MOV	R1,R4		;NEW 'P' IS RETURNED IN R1, MAKE COPY
	SUB	LINPTR+RWSIZE(R5),R1 ;MAKE R1 CONTAIN
	NEG	R1		; ONLY CHARS IN -1L
	CMP	R1,#15.		;15. OR MORE CHARACTERS HERE?
	BLO	20$		;NOPE, DON'T PUT INTO CHECKING BUFFER
	TST	BUSTRT+RWSIZE(R5) ;IS THIS THE FIRST TIME THROUGH??
	BEQ	20$		;YES, FIRST TIME, DON'T BUFFER THE LINE
	MOV	(SP),R2		;GET CHECKING BUFFER POINTER
	TSTB	(R2)		;IS IT ALREADY FILLED?
	BLE	20$		;YEP, DON'T REUSE IT THEN
	NEG	(R2)+		;ELSE MARK AS USED NOW
	MOV	R2,BUINDX+RWSIZE(R5) ; AND SET STARTING FILL IN POINTER
	MOV	#CCHAR,OUTCHR+RWSIZE(R5) ;  AND CHANGE THE OUTPUT ROUTINE
	MOV	#40.,R0		;SET SIZE OF BUFFER IN WORDS
10$:	MOV	(PC)+,(R2)+	;BLANK THE
	 .BYTE	SPACE,SPACE
	SOB	R0,10$		; WHOLE BUFFER
20$:	MOV	BUSTRT+RWSIZE(R5),SVSTRT+RWSIZE(R5) ;SAVE STARTING VALUE
	JSR	PC,DOTEXT	;FORMAT A LINE
	MOV	BUSTRT+RWSIZE(R5),R0 ;GET FINISHING LINE NUMBER
	TST	CHCKBL+RWSIZE(R5) ;DOES CHECKING BUFFER LINE NEED SETTING?
	BPL	30$		;NOPE
	MOVB	R0,CHCKBL+1+RWSIZE(R5) ;YEP, SO SAVE LINE NUMBER
30$:	CMP	R0,2(SP)	;WOULD WE BE AT TOP?
	BLO	LINES		;BRANCH IF NOT
	MOV	SVSTRT+RWSIZE(R5),BUSTRT+RWSIZE(R5) ;RESTORE CORRECT VALUE
TRYMOV:	MOV	(SP)+,R2	;GET CHECKING BUFFER POINTER
	TSTB	(R2)+		;DID WE FILL IT?
	BGE	OUTPUT		;NOPE
	MOVB	(R2)+,R0	;SAVE THE "BUSTRT" VALUE
	MOV	BUSTRT+RWSIZE(R5),R1 ;GET ENDING "BUSTRT" VALUE
	SUB	R0,R1		;CALCULATE THE BUFFERED LINE NUMBER
	MULT	80		;FIND OFFSET OF THE BUFFERED LINE
	MOV	R1,(SP)		; AND SAVE IT
	MOV	#MOVTBL-2,R4	;GET THE MOVEMENT TABLE
10$:	TST	(R4)+		;SKIP OVER THE UNUSED MOVE AMOUNT
	CMP	R4,#MOVTBE	;ARE MORE MOVES POSSIBLE?
	BHIS	OUTPUT		;NO, PUNT ON IT
	MOV	(SP),R1		;YES, GET THE BUFFERED LINE'S OFFSET
	ADD	(R4)+,R1	;BUILD OFFSET POINTER FOR THIS TRY
	CMP	R1,#MAPND-MAPST	;IS THIS OFFSET OUT OF THE SCREEN?
	BHIS	10$		;TOO FAR OUT, GO TRY ANOTHER MOVE
	ADD	#MAPST+RWSIZE,R1 ;INDEX TO SCREEN MAP
	ADD	R5,R1		; ABSOLUTELY
	MOV	R2,R3		;SET POINTER TO CHECK BUFFER
	MOV	#40.,R0		; AND LOAD A COUNTER
20$:	CMP	(R3)+,(R1)+	;MATCH??
	BNE	10$		;NO
	SOB	R0,20$		;YES, LOOP
	MOV	(R4)+,R1	;TOTAL MATCH!! GET THE MOVMENT AMOUNT
	CLR	R2		;SET CURSOR TO COLUMN 0
	MOV	#V.SIZE-1,BUSTRT+RWSIZE(R5) ;ASSUME WE ARE GOING UP
	MOV	#LFSEQ,R3	;SEQUENCE TO RAISE SCREEN
	MOV	R1,R4		;SAVE THAT MOVE COUNT
	BEQ	OUTPUT		;NO MOVEMENT, SO QUIT
	BPL	30$		;ASSUMPTION RIGHT
	MOV	#REVSEQ,R3	;SEQUENCE TO LOWER SCREEN
	CLR	BUSTRT+RWSIZE(R5) ;FIX TO LOWER SCREEN
	NEG	R4		;MAKE COUNT POSITIVE
30$:	JSR	PC,DOSEQ	;POSITION THE SCREEN
	SOB	R4,30$		; THE CORRECT NUMBER OF TIMES
	MOV	#MAPST+RWSIZE,R2 ;SET POINTER TO START OF MAP
	ADD	R5,R2		; ABSOLUTE
	MOV	R2,R0		;BUILD POINTER
	ADD	#MAPND-MAPST,R0	; TO END OF MAP
	MULT	80		;CALC OFFSET TO START MOVE FROM
	BMI	60$		;BRANCH IF TO MOVE INTERNAL MAP DOWN
	ADD	R2,R1		;ADD IN MAP BASE
40$:	MOV	(R1)+,(R2)+	;MOVE THE DATA
	CMP	R1,R0		;DID WE MOVE LAST DATA BYTE?
	BLO	40$		;BRANCH IF NOT
50$:	MOV	(PC)+,(R2)+	;FILL REMAINDER WITH BLANKS
	 .BYTE	SPACE,SPACE
	CMP	R2,R0		;ARE WE AT END OF TABLE?
	BLO	50$		;BRANCH IF NOT
	BR	OUTPUT		;ELSE DONE SHIFTING

60$:	ADD	R0,R1		;POINT TO END OF DATA TO BE MOVED
70$:	MOV	-(R1),-(R0)	;MOVE THE DATA
	CMP	R1,R2		;ARE WE AT THE TOP?
	BHI	70$		;BRANCH IF NOT
80$:	MOV	(PC)+,-(R0)	;BLANK FILL REMAINDER
	 .BYTE	SPACE,SPACE
	CMP	R0,R2		;ARE WE AT TOP?
	BHI	80$		;BRANCH IF NOT
OUTPUT:	TST	(SP)+		;JUNK THE STACK ITEM
	JSR	R4,SETJSR	;SET UP FOR
	.WORD	RTRANS		; THE REAL OUTPUT
	MOV	LINPTR+RWSIZE(R5),R4 ;GET STARTING POINT OF TEXT
	MOV	ZZ(R5),R1	;GET END OF TEXT
	SUB	R4,R1		; AND FIND AMOUNT OF TEXT TO DO
	MOV	#MAPST+RWSIZE,BUINDX+RWSIZE(R5) ;INIT THE INDEX INTO THE MAP
	ADD	R5,BUINDX+RWSIZE(R5) ; ABSOLUTE
	TST	INITFL+RWSIZE(R5) ;DO WE KNOW THE STATE OF THE SCREEN?
	BMI	10$		;BRANCH IF YES
	CLR	R2		;CLEAR THE COLUMN NUMBER
	CLR	MAPST+RWSIZE(R5) ;CLOBBER THE LAST COPY OF THE MAP
	MOV	#-1,PRELIN+RWSIZE(R5) ;CLOBBER LAST KNOWN CURSOR
	JSR	PC,CLREND	;CLEAR THE SCREEN
10$:	MOV	(SP),P(R5)	;FINALLY REFIX POINTER
	ADD	TXSTOR(R5),(SP)	;COMPUTE CURSOR POINTER
	MOV	(SP),UNDERC+RWSIZE(R5) ;SAVE POSITION OF UNDER SCORE
	MOV	#V.SIZE-1,CURLIN+RWSIZE(R5) ;PRESET CURSOR AT END OF
	MOV	#H.SIZE-1,CURCHR+RWSIZE(R5) ; SCREEN
	JSR	PC,DOTEXT	;NOW REALLY UPDATE THE SCREEN
	MOV	CURLIN+RWSIZE(R5),BUSTRT+RWSIZE(R5) ;SET THE LINE FOR CURSOR
	MOV	CURCHR+RWSIZE(R5),R2 ;SET THE COLUMN
	JSR	PC,SETCUR	;MOVE THE CURSOR
	MOV	(SP)+,R0	;GET ABS CURSOR LOCATION
	TST	P(R5)		;IS CURSOR AT START OF TEXT?
	BEQ	20$		;YES, CANNOT BE AFTER ANYTHING...
	CMPB	-(R0),#CR	;IMMEDIATELY AFTER A <CR>?
	BNE	20$		;NOPE
	MOV	#CURSEQ,R3	;YEP, SET FANCY SEQUENCE
	JSR	PC,DOTYPE	; AND OUTPUT IT
	CLRB	@CURABS+RWSIZE(R5) ;  BUT FORGET THAT LOCATION IN THE MAP
20$:	;JSR	PC,TYPEFC	;FORCE OUT ANY PARTIAL BUFFER
	MOV	#-1,INITFL+RWSIZE(R5) ;NOW WE KNOW WHAT'S ON THE SCREEN
	CLRB	OUTDNE		;ALSO CLEAR TERMINAL OUTPUT FLAG
;	ROR	(SP)+		;DO WE NEED TO CLEAR IMAGE OUTPUT?
;	BCS	30$		;NOPE, IT WAS SET ON ENTRY
;	BIC	#1,ETYPE(R5)	;YEP, SO CLEAR IT ALREADY
30$:	RTS	PC		;FINALLY WE CAN EXIT
DOTEXT:	ADD	TXSTOR(R5),R4	;MAKE POINTER ABSOLUTE
	MOV	R1,-(SP)	;SAVE THE CHARACTER COUNT
	BR	70$		;INITIALIZE COLUMN COUNTER AND POINTER

10$:	CMPB	(R4),#CR	;AVOID SEQUENCE IF OVERFLOW ON <CR>
	BEQ	60$		;BRANCH IF <CR>
	MOV	#200,R0		;ELSE SET THE OVERFLOW "CHARACTER"
	BIT	#400,ETYPE(R5)	;ALLOWING LINE OVERFLOWS?
	BEQ	20$		;YEP, SO DO IT
	INC	R4		;NOPE, EAT THE CHARACTER
	CMP	R2,#H.SIZE-1	;WHERE ARE WE??
	BHIS	40$		;REALLY AT THE END, PUNT ON IT
	JSR	PC,@OUTCHR+RWSIZE(R5) ;PUT OVERFLOW "CHARACTER" THERE
	BR	40$		;THEN CONTINUE

20$:	INC	(SP)		;REMEMBER TO GET THE CHARACTER AGAIN
	MOV	R2,RTMOST+RWSIZE(R5) ;SET HIGHEST COLUMN NUMBER
	CLR	R2		;SIMULATE CARRIAGE RETURN
	JSR	PC,NEWLIN	;FIX SCREEN
	BHIS	140$		;BRANCH IF AT BOTTOM OF SCREEN
	JSR	PC,@OUTCHR+RWSIZE(R5) ;OUTPUT OVERFLOW "CHARACTER"
	MOV	#SPACE,R0	;FOLLOW IT WITH A <SPACE>
30$:	JSR	PC,@OUTCHR+RWSIZE(R5) ;OUTPUT CHARACTER
40$:	CMP	R4,UNDERC+RWSIZE(R5) ;IS THIS WHERE THE CURSOR BELONGS?
	BNE	50$		;BRANCH IF NOT
	MOV	R1,CURABS+RWSIZE(R5) ;SAVE ABSOLUTE POSITION IN MAP
	MOV	BUSTRT+RWSIZE(R5),CURLIN+RWSIZE(R5) ;SAVE THE LINE NUMBER
	MOV	R2,CURCHR+RWSIZE(R5) ;SAVE THE COLUMN NUMBER
	CMP	R2,#H.SIZE	;IS THE COLUMN NUMBER ILLEGAL?
	BLO	50$		;NOPE
	MOV	#H.SIZE-1,CURCHR+RWSIZE(R5) ;YEP, SO FIX IT ALREADY
50$:	DEC	(SP)		;KNOCK DOWN CHARACTER COUNT
	BMI	130$		;BRANCH IF NO MORE FOR END OF SCREEN
	CMP	R2,#H.SIZE-2	;ABOUT TO OVERFLOW?
	BHIS	10$		;BRANCH IF TRUE
60$:	MOVB	(R4)+,R0	;GET A BYTE OF TEXT
	CMP	R0,#DEL		;IS IT <RUBOUT>?
	BEQ	110$		;BRANCH IF YES
	CMP	R0,#SPACE	;IS IT SPECIAL?
	BHIS	30$		;BRANCH IF NOT
	CMP	R0,#TAB		;IS IT A <TAB>?
	BEQ	100$		;BRANCH IF IT IS
	BLO	110$		;BRANCH IF MUST BE REGULAR CONTROL CHAR
	CMP	R0,#CR		;IS CHAR A <CR>?
	BNE	80$		;BRANCH IF IT IS, RESET COLUMN COUNTER
	CMP	R2,RTMOST+RWSIZE(R5) ;SAVE RIGHT MOST COLUMN ON LINE
	BLOS	70$		;BRANCH IF NOT AT IT
	MOV	R2,RTMOST+RWSIZE(R5) ;SAVE IT FOR CLEARING REMAINDER
70$:	CLR	R2		;RESET COLUMN COUNTER
	MOV	BUINDX+RWSIZE(R5),R1 ;SET POINTER INTO MAP
	BR	40$		; AND CONTINUE
80$:	BHI	110$		;BRANCH IF > <CR>, MAY BE <ESC>?
	SUB	#LF,R0		;R0=0 FOR <LF>, R0=1 FOR <VT>, R0=2 FOR <FF>
	ASL	R0		;R0=0 FOR <LF>, R0=2 FOR <VT>, R0=4 FOR <FF>
90$:	JSR	PC,NEWLIN	;HANDLE A NEW SCOPE LINE
	BHIS	140$		;BRANCH IF AT BOTTOM OF SCREEN
	DEC	R0		;KEEP COUNT FOR <VT>'S AND <FF>'S
	BMI	40$		;BRANCH IF DONE WITH CHAR
	BR	90$		;ELSE CONTINUE

100$:	MOV	#SPACE,R0	;OUT SPACES TO TAB STOP
	JSR	PC,@OUTCHR+RWSIZE(R5) ;OUTPUT THE CHARACTER
	BIT	R2,#7		;AT A TAB STOP?
	BEQ	40$		;BRANCH IF SO
	CMP	R2,#H.SIZE-2	;ELSE ABOUT TO OVERFLOW LINE?
	BLO	100$		;NOPE, LOOP
	BR	40$		;YES, QUIT

110$:	MOV	#'$,-(SP)	;GUESS AT <ESC>
	CMP	R0,#ESC		;GOOD GUESS??
	BEQ	120$		;YES, <ESC> GOES AS "$"
	ADD	#100,R0		;NO, PUT CHARACTER INTO RANGE
	BIC	#^C<177>,R0	; AND MASK IT FOR SAFETY
	MOV	R0,(SP)		;SAVE CHARACTER
	MOV	#'^,R0		;PRINT ARROW
	JSR	PC,@OUTCHR+RWSIZE(R5) ;OUTPUT THE CHAR
120$:	MOV	(SP)+,R0	;GET THE CHAR BACK
	BR	30$		; AND CONTINUE

130$:	SUB	TXSTOR(R5),R4	;MAKE TEXT POINTER RELATIVE AGAIN
	CMP	R4,ZZ(R5)	;AT END OF BUFFER NOW?
	BNE	140$		;NOPE
	CMP	R2,#H.SIZE	;YEP, ANY ROOM LEFT ON THIS LINE?
	BHIS	140$		;SORRY, NO ROOM LEFT
	MOV	#201,R0		;ROOM, SET END OF BUFFER "CHARACTER"
	JSR	PC,@OUTCHR+RWSIZE(R5) ; AND OUTPUT IT	
140$:	TST	(SP)+		;JUNK THE CHARACTER COUNTER
CLREND:	MOV	#EEOSEQ,R3	;SET EOS SEQUENCE FOR BLANKING
	MOV	#MAPND+RWSIZE,R0 ;POINT TO END OF SCREEN MAP
	ADD	R5,R0		; ABSOLUTELY
	JMP	@OUTBLN+RWSIZE(R5) ;CALL BLANKER FOR REST OF SCREEN
NEWLIN:	MOV	R0,-(SP)	;SAVE FOR LATER
	MOV	R2,-(SP)	;ALSO SAVE COLUMN POSITIN
	MOV	BUINDX+RWSIZE(R5),R0 ;CALCULATE END OF
	ADD	#80.,R0		; LINE POINTER
	MOV	#CLNSEQ,R3	;SET SEQ TO CLEAR ONLY THIS LINE
	JSR	PC,@OUTBLN+RWSIZE(R5) ;ERASE THE REMAINDER OF LINE IF ANYTHING
	CLR	RTMOST+RWSIZE(R5) ;CLEAR IT FOR NEW LINE
	MOV	R0,BUINDX+RWSIZE(R5) ;UPDATE TO NEW LINE ON SCREEN FACE
	INC	BUSTRT+RWSIZE(R5) ;FLAG A NEW LINE DONE
	MOV	R0,R1		;SET NEW MAP POINTER
	TST	(SP)		;GET THE COLUMN POSITION
	BEQ	20$		;BRANCH IF AT COLUMN 0, NORMAL CASE
	CMP	BUSTRT+RWSIZE(R5),#V.SIZE ;ALREADY OFF THE SCREEN?
	BHIS	20$		;BRANCH IF YES, FORGET IT
	CLR	R2		;START FROM COLUMN 0
	MOV	#SPACE,R0	;USE SPACES FOR BLANKING
10$:	JSR	PC,@OUTCHR+RWSIZE(R5) ;OUTPUT ONE BLANK
	CMP	R2,(SP)		;UP TO THE CURSOR POSITION YET?
	BLO	10$		;BRANCH TO CONTINUE TO BLANK
20$:	MOV	(SP)+,R2	;RESET COLUMN POSITION
	MOV	(SP)+,R0	;GET BACK FLAG FOR TYPE OF CHAR
	CMP	BUSTRT+RWSIZE(R5),#V.SIZE ;'BHIS' BRANCHES IF AT BOTTOM
	RTS	PC		;RETURN

SETJSR:	MOV	#OUTCHR+RWSIZE,R3 ;GET ADDRESS OF FIRST VECTOR
	ADD	R5,R3		; ABSOLUTELY
	MOV	(R4)+,R2	;GET POINTER TO THE TABLE
10$:	MOV	(R2)+,(R3)+	;PUT IN A NEW ADDRESS
	BNE	10$		;LOOP THROUGH LIST
	CLR	(R3)+		;CLEAR "BUSTRT" ALSO
	RTS	R4		;THEN EXIT

.IF	NDF	I$$MUL

MUL80:	ASL	R1		;*80. IS *40.*2
MUL40:	MOV	R1,-(SP)	;SAVE *1
	ASL	R1		;NOW *2
	ASL	R1		;NOW *4
	ADD	(SP)+,R1	;NOW *5
	ASL	R1		;NOW *10.
	ASL	R1		;NOW *20.
	ASL	R1		;NOW *40.
	RTS	PC		;SO EXIT

.ENDC
VTBLNK:	MOV	R1,-(SP)	;SAVE
	MOV	R2,-(SP)	; WORK
	MOV	R4,-(SP)	;  REGS
	MOV	R0,-(SP)	;ADDRESS TO STOP AT
	CMP	R2,RTMOST+RWSIZE(R5) ;CHECK FOR RIGHTMOST USED COLUMN
	BHIS	10$		;R2 IS RIGHT
	MOV	RTMOST+RWSIZE(R5),R2 ;FIX R2
10$:	MOV	BUINDX+RWSIZE(R5),R1 ;GET ADDRESS OF CURRENT LINE
	ADD	R2,R1		;POINT TO WHERE WE ARE IN BUFFER
	MOV	#-1,R4		;SET FLAG TO CLEAR EOS IF NEEDED
20$:	CMP	R1,(SP)		;ARE WE AT END YET?
	BHIS	60$		;BRANCH IF YES
	BIT	R1,#1		;ON WORD BOUNDARY?
	BEQ	40$		;BRANCH IF YES
	CMPB	#SPACE,(R1)+	;IS THIS A BLANK ALREADY?
	BEQ	20$		;BRANCH IF YES
	MOVB	#SPACE,-1(R1)	;SET IT TO A BLANK
	INC	R4		;DO WE HAVE TO CLEAR END OF SCREEN?
	BNE	20$		;BRANCH IF ALREADY DONE
30$:	JSR	PC,DOSEQ	;CLEAR LINE OR SCREEN
	BR	20$		;CONTINUE THE CLEAR LOOP

40$:	CMP	(PC)+,(R1)+	;ARE THESE BLANKS ALREADY?
	 .BYTE	SPACE,SPACE
	BEQ	50$		;YES
	MOV	#SPACE*400+SPACE,-2(R1) ;SET LAST TWO TO BLANKS
	INC	R4		;DO WE HAVE TO CLEAR TO EOS?
	BEQ	30$		;BRANCH IF WE NEED TO
50$:	CMP	R1,(SP)		;ARE WE AT END YET?
	BLO	40$		;NOT YET
60$:	MOV	(SP)+,R0	;RESTORE THE LIMIT
	MOV	(SP)+,R4	;RESTORE
	MOV	(SP)+,R2	; WORK
	MOV	(SP)+,R1	;  REGS
	RTS	PC		;EXIT
VTCHAR:	CMPB	R0,(R1)+	;ARE CHARACTERS THE SAME??
	BEQ	FCHAR		;BRANCH IF YES, DON'T SEND IT!
	JSR	PC,SETCUR	;POSITION THE CURSOR
	MOVB	R0,-1(R1)	;SAVE THE CHARACTER
	BPL	10$		;NOT SPECIAL
	ASLB	R0		;SPECIAL, MAKE INTO AN INDEX
	MOV	SEQS(R0),R3	; AND GET THE SEQUENCE POINTER
	JSR	PC,DOTYPE	;  AND OUTPUT IT
	BR	20$		;THEN CONTINUE

10$:	TYPEBF			;NOW SEND CHARACTER
20$:	INC	PRECOL+RWSIZE(R5) ;INDICATE CURSOR MOVED 1 TO THE RIGHT
FCHAR:	INC	R2		;ADVANCE COLUMN NUMBER
	RTS	PC		; THEN EXIT

.ENABL	LSB

CCHAR:	INC	R2		;ADVANCE COLUMN NUMBER
	MOVB	R0,(R1)+	;SAVE THE CHARACTER
	BGT	10$		;NORMAL, CONTINUE
	NEG	CHCKBL+RWSIZE(R5) ;SPECIAL, SAY THIS LINE NOT FILLED
FBLNK:	MOV	#FCHAR,OUTCHR+RWSIZE(R5) ;RESET THE OUTPUT ROUTINE
10$:	RTS	PC		;THEN RETURN

.DSABL	LSB
.ENABL	LSB

SETCUR:	MOV	R0,-(SP)	;SAVE R0
	MOV	BUSTRT+RWSIZE(R5),R0 ;GET LINE NUMBER
	CMP	R0,PRELIN+RWSIZE(R5) ;IS THIS THE RIGHT LINE?
	BNE	10$		;BRANCH IF NOT, MUST SET CURSOR
	MOV	#V.SIZE,R0	;SET TO NOT VERTICALLY POSITION CURSOR
				;THIS IS TO HELP STOP VT52 FROM FLICKER
	CMP	R2,PRECOL+RWSIZE(R5) ;ARE WE AT RIGHT CURSOR POSITION?
	BEQ	30$		;BRANCH IF YES, DON'T MOVE IT
10$:	MOV	BUSTRT+RWSIZE(R5),PRELIN+RWSIZE(R5) ;SAVE CURSOR POS ON SCREEN
	MOV	R2,PRECOL+RWSIZE(R5) ; BOTH LINE AND COLUMN
	MOV	R3,-(SP)	;SAVE R3 OVER SEQUENCES
	MOV	#DIRSEQ,R3	;POINT TO DIRECT CURSOR ADDRESS CODE
	JSR	PC,DOTYPE	; AND OUTPUT IT
	ADD	#40,R0		;ADJUST LINE NUMBER
	TYPEBF			; AND OUTPUT IT
	MOV	R2,R0		;NOW SET COLUMN NUMBER
	ADD	#40,R0		;ADJUST COLUMN NUMBER
	TYPEBF			; AND OUTPUT IT
20$:	MOV	(SP)+,R3	;RESTORE R3
30$:	MOV	(SP)+,R0	;RESTORE R0
	RTS	PC		; AND EXIT

DOSEQ:	JSR	PC,SETCUR	;SET UP THE CURSOR
DOTYPE:	MOV	R0,-(SP)	;SAVE R0
	MOV	R3,-(SP)	; AND R3
40$:	MOVB	(R3)+,R0	;GET A CHARACTER
	ASLB	R0		;IS IT THE ENDING 200?
	BEQ	20$		;YES
	ASR	R0		;NO, RESTORE CHARACTER
	TYPEBF			;ELSE BUFFER IT
	BR	40$		; AND CONTINUE

.DSABL	LSB
RTRANS:	.WORD	VTCHAR,	VTBLNK,	0

FTRANS:	.WORD	FCHAR,	FBLNK,	0

MOVTBL:	.WORD	 000000*80.,	 000000
$$$$$$	=	1
.REPT	V.SIZE/2
	.WORD	+$$$$$$*80.,	+$$$$$$
	.WORD	-$$$$$$*80.,	-$$$$$$
$$$$$$	=	$$$$$$+1
.ENDR
MOVTBE:

SEQS:	.WORD	OVRSEQ,EOBSEQ

EOBSEQ:	.BYTE	ESC,'F,'A+40,ESC,'G,200
CURSEQ:	.BYTE	ESC,'F,'K+40,ESC,'G,ESC,'D,200
OVRSEQ:	.BYTE	ESC,'F,'H+40,ESC,'G,200
CLNSEQ:	.BYTE	ESC,'K,200
DIRSEQ:	.BYTE	ESC,'Y,200
EEOSEQ:	.BYTE	ESC,'J,200
LFSEQ:	.BYTE	LF,200
REVSEQ:	.BYTE	ESC,'I,200

	.EVEN
; THE LAYOUT OF THE READ/WRITE REGION

.ASECT
.	=	0

OUTCHR:	.BLKW		;OUTPUT A CHARACTER
OUTBLN:	.BLKW		;END OF LINE OR BUFFER CLEANER
RTMOST:	.BLKW		;INITED TO ZERO AS END OF LIST
BUSTRT:	.BLKW		;LINE COUNTER, INITED TO ZERO

LINPTR:	.BLKW		;CHAR COUNTER (P) OF LINE STARTS
SVSTRT:	.BLKW		;SAVED LINE COUNTER
INITFL:	.BLKW		;>=0 IMPLIES UNKNOWN SCREEN STATE
BUINDX:	.BLKW		;CONTAINS LINE INDEX INTO SCREEN MAP
CURLIN:	.BLKW		;CONTAINS LINE NUMBER OF CURSOR
CURCHR:	.BLKW		;CONTAINS COLUMN NUMBER OF CURSOR
CURABS:	.BLKW		;CONTAINS ABSOLUTE MAP POSITION OF CURSOR
UNDERC:	.BLKW		;CHARACTER POS OF UNDER SCORE
PRELIN:	.BLKW		;LAST SET LINE TO SCREEN
PRECOL:	.BLKW		;LAST SET COLUMN TO SCREEN

CHCKBL:	.BLKW		;FLAG WORD
	.BLKB	80.	;ROOM FOR CHARS

MAPST:	.BLKB	80.*24.	;LAST KNOWN SCREEN
MAPND:			;END OF SCREEN MAP

SCRWSZ:			;SIZE OF READ/WRITE REGION

	.CSECT	TECOIO

	.ENDC
	.NLIST
	.IF DF	VT01

.SBTTL	SCOPE HANDLER

VTCSR=	176756		;CONTROL AND STATUS
XPOS=	176760		;X POSITION REGISTER
YPOS=	176762		;Y POSITION REGISTER
XSIZE=	3700		;WIDTH OF SCREEN
YSIZE=	3700		;HEIGHT OF SCREEN
DELTA=	6		;CHARACTER SPACING
YDELTA=	-66		;HEIGHT OF ONE LINE

SCLEAR:	MOV	#VTCSR,R5	;POINT TO CONTROL REG
	MOV	#2,@R5		;FLASH!
1$:	TSTB	@R5		;WAIT FOR THE END
	BPL	1$
	RTS	PC

WATCH:	JSR	R5,SAVREG	;SAVE EVERYTHING
	TST	R0		;ARE WE DOING STUFF?
	BLE	SCLEAR		;TURN IT OFF
	MOV	P(R5),-(SP)	;SAVE CURRENT POINTER
	NEG	R0		;GO BACKWARDS N LINES
	JSR	PC,.VVV.V	;USING TECO'S MOVER
	MOV	R1,R4		;NEW P IS RETURNED IN R1, TOO
	MOV	NWATCH(R5),R0	;RETRIEVE LINE COUNT
	INC	R0		;BUMP BY ONE
	MOV	@SP,P(R5)	;RESTORE STARTING POINT
	JSR	PC,.VVV.V	;AND ADVANCE
	SUB	R4,R1		;R1 NOW CONTAINS DISPLAY COUNT
	INC	R1		;(AT LEAST 1)
	ADD	TXSTOR(R5),R4	;R4 IS NOW ABSOLUTE STARTING POINT
	MOV	@SP,P(R5)	;FINALLY REFIX POINTER
	ADD	TXSTOR(R5),@SP	;MAINTAIN CURSOR POINTER ON STACK
	JSR	PC,SCLEAR	;CLEAR THE SCOPE
	MOV	#YSIZE,R3	;MAINTAIN Y POSITION IN R3
	TST	(R5)+		;POINTER STAYS AT XPOS
CRET:	CLR	@R5		;START LINE ANEW
	CLR	TABCNT		;START TABS, TOO
DSPLAY:	CMP	R4,@SP		;ARE WE AT THE CURSOR?
	BNE	1$		;NO
	MOV	#CURSX,R0	;YES, SAVE STATUS
	MOV	@R5,@R0		;SAVE X POSITION
	SUB	#DELTA+2,(R0)+	;  JUST BEFORE THIS CHARACTER
	MOV	R3,@R0		;SAVE Y POSITION
	DEC	@R0		;  A LITTLE LONGER THAN REAL
	TST	(SP)+		;REMOVE PRUNE FROM STACK
1$:	DEC	R1		;KNOCK DOWN CHARACTER COUNT
	BEQ	WRTN		;  IF ZERO, VANISH
	MOVB	(R4)+,R0	;GET A BYTE OF TEXT
	BIC	#177600,R0	;PUT IT IN RANGE
	CMP	R0,#40		;IS IT SPECIAL?
	BLO	3$		;YES, DO SOMETHING SPECIAL
	BEQ	7$		;TREAT BLANKS QUICKLY
2$:	JSR	PC,DSCHAR	;DISPLAY A CHARACTER
	BR	DSPLAY		;AND CONTINUE THE LOOP

3$:	CMP	R0,#015		;CHECK FOR CARRIAGE RETURN
	BEQ	CRET		;DO A CARRIAGE RETURN
	BHI	5$		;TOO BIG TO BE SUPER-SPECIAL
	CMP	R0,#11		;CHECK FOR TAB
	BEQ	4$		;GO DO TAB
	BLO	5$		;JUST A REGULAR CONTROL
	ADD	#YDELTA,R3	;DO A LINE FEED (FOR LF,FF,VT)
	BR	DSPLAY		;AND CONTINUE

4$:	JSR	PC,DSBLNK	;WELL, DISPLAY A BLANK
	BIT	#7,(PC)+	;ARE WE DONE?
TABCNT=	.
	.WORD	0
	BNE	4$		;NO, KEEP GOING
	BR	DSPLAY		;YEP, CONTINUE

5$:	CMP	R0,#ESC		;ALTMODE?
	BNE	6$		;NOPE
	MOV	#'$,R0		;YEP, FIX IT
	BR	2$
6$:	MOV	R0,-(SP)	;SAVE CHARACTER
	MOV	#'^,R0		;PRINT ARROW
	JSR	PC,DSCHAR
	MOV	(SP)+,R0	;RESTORE CHARACTER
	ADD	#100,R0		;PUT IT IN RANGE
	BR	2$		;AND DISPLAY IT
7$:	MOV	#DSPLAY,-(SP)	;RETURN FROM BLANK DISPLAYING

DSBLNK:	ADD	#36.,@R5	;JUST BUMP THE X COUNT
	BR	INCTAB		;AND DO CLEAN-UP

DSCHAR:	MOV	R0,-(SP)	;MULTIPLY BY 5
	ASL	R0
	ASL	R0
	ADD	(SP)+,R0
	ADD	#CHRTBL-240,R0	;POINT INTO TABLE
	MOV	#4000,R2	;BIT COUNTS ITERATIONS
	MOV	#DELTA,-(SP)	;USEFUL HERE
BLOOP:	TST	(R5)+		;ADVANCE POINTER TO YPOS AND CLEAR CARRY
	MOV	R3,@R5		;SET STARTING Y POSITION
	BISB	(R0)+,R2	;GET A PATTERN BYTE
1$:	RORB	R2		;GET NEXT BIT
	BEQ	4$		;NO, NEXT BYTE
	BCC	3$		;YES, DO WE DO THIS?
	MOV	#5,-4(R5)	;YES, INTENSIFY A POINT
2$:	TSTB	-4(R5)		;WAIT FOR READY
	BPL	2$
3$:	ADD	@SP,@R5		;BUMP Y POSITION
	BR	1$		;AND CONTINUE WITH BYTE
4$:	ADD	@SP,-(R5)	;DONE BYTE, ADVANCE X POS AND CLEAR C
	ASL	R2		;ANY MORE?
	BCC	BLOOP		;YEP
	ADD	(SP)+,@R5	;SPACE BETWEEN CHARACTERS
INCTAB:	INC	TABCNT		;NOPE, INDICATE WE DID SOMETHING
	CMP	@R5,#XSIZE	;ARE WE TOO BIG?
	BLT	WRTN		;NO, OK
	ADD	#YDELTA,R3	;YES, ADVANCE TO NEXT LINE
	MOV	#<36.*32.>,@R5	;START X OVER THERE
WRTN:	RTS	PC

CURSX:	.WORD	0		;SCREEN COORDINATES OF CURSOR
CURSY:	.WORD	0

	.ENDC
	.LIST
.SBTTL	SIZER SWAPS THE USR TO GET MORE CORE

SIZER:	CMP	#10000,R1	;WE HAVE AT MOST 2K
	BLO	2$		;BRANCH IF REQUEST HOPELESS, C=1
	MOV	R0,-(SP)	;SAVE R0 FOR TECO
	MOV	@#PGMTOP,-(SP)	;SAVE CURRENT TOP
	.SETTOP	#-2		;TELL THE MONITOR WE'RE SWAPPING
	CMP	R0,(SP)+	;DID WE GET ANY?
	SEC
	BEQ	1$		;BRANCH IF NOT
	.RCTRLO			;TELL THE USER
	.PRINT	#MESSAG
	ADD	#10000,CURFRE(R5) ;YES. GIVE HIM USR SIZE
	CLC			;SIGNAL GOOD RETURN
1$:	MOV	(SP)+,R0	;RESTORE R0
2$:	RTS	PC
.SBTTL	FNGET AND FETCH - CALL CSI, FETCH HANDLER

; FNGET SCANS OFF THE FILE NAME INTO THE BUFFER AREA
; ASSOCIATED WITH THE BLOCK IN R3,  IT THEN CALLS THE CSI

FNGET:	.CSISPC	R3,#DEFEXT,R1
	BCS	FNERR		;ERROR IN NAME
	TST	(SP)+		;NO SWITCHES ARE VALID!
	BEQ	RET
FNERR:	ERROR	IFN,<'Error in file name'>

; LOAD THE REQUESTED HANDLER
;	R3-> RAD50 DEVICE NAME
; IF HANDLER ALREADY IN MEMORY THIS IS A NOP
; IF NOT, TEXT AND Q REGISTERS ARE SHUFFLED UP TO MAKE ROOM
; ONCE A HANDLER BECOMES LOADED IT IS NEVER RELEASED
;    BECAUSE OF NON-BLOCK REPLACEABLE DEVICES AND LAZINESS

FETCH:	MOV	#SCRACH,R1
	.DSTAT	R1,R3		;GET INFORMATION ABOUT DEVICE
	BCS	DEVERR		;BRANCH IF BAD DEVICE NAME
	TST	4(R1)		;IS HANDLER ALREADY LOADED?
	BNE	RET		;BRANCH IF YES
	MOV	R1,-(SP)	;PRESERVE R1
	MOV	2(R1),-(SP)	;SIZE OF HANDLRE IN BYTES
	MOV	QZ(R5),R1	;GET CURRENT SIZE OF Q-REG AREA
	ADD	@SP,R1		;SET UP TO INCLUDE HANDLER
	JSR	R4,SIZE		;LET TECO MEMORY MANAGER HANDLE IT
	.WORD	QMAX		;AREA TO GET SPACE FROM
	BCC	TOOBIG		;BRANCH IF HANDLER WON'T FIT, YES C=0!
	MOV	TXSTOR(R5),R2	;TARGET ADDRESS FOR HANDLER
	MOV	R2,R0		;MAKE A COPY
	ADD	@SP,R0		;TO BE ADDRESS OF END OF HANDLER
	MOV	@#RMON,R1	;EVEN IF HANDLER WILL FIT CHECK USR
	CMP	R0,USRBUF(R1)	;DO HANDLER AND USR OVERLAP?
	BHIS	TOOBIG		;BRANCH IF SO
	SUB	@SP,QMAX(R5)	;NOW TAKE BACK ROOM FOR HANDLER
	ADD	ZMAX(R5),R0	;FIND NEW TOP OF TEXT AND Q-REG AREA
	ADD	QMAX(R5),R0
	MOV	R0,R1		;MAKE COPY
	SUB	@SP,R1		;POINT R1 TO OLD TOP OF AREA
1$:	MOVB	-(R1),-(R0)	;MOVE A BYTE
	CMP	R1,R2		;ARE WE DONE?
	BHI	1$		;BRANCH IF MORE TO MOVE
	ADD	@SP,TXSTOR(R5)	;UPDATE NEW TEXT LOW POINTER
	ADD	(SP)+,QRSTOR(R5); AND UPDATE NEW Q-REG LOW POINTER
	.FETCH	R2,R3		;GET THE HANDLER
	BCS	DEVERR		;SOME KIND OF ERROR
	MOV	(SP)+,R1	;RESTORE R1
RET:	RTS	PC
DEVERR:	ERROR	DEV,<'Invalid device'>
TOOBIG:	ERROR	MEM,<'Memory overflow'>
.SBTTL	GETFLS - ENTRY FOR ER, EW, EB, EN, AND EI

GETFLS:	JSR	R4,SAVREG	;CAREFUL WITH THESE
	CMPB	R2,#'N-'R	;IS IT EN?
	BEQ	ENCODE		;BRANCH IF EN
	CMPB	R2,#'I-'R	;IS IT EI?
	BEQ	EICODE		;BRANCH IF EI

	MOV	FILBUF(R5),R4	;GET POINTER TO STRING
	MOV	#FILSPC,R3	;POINT TO STRING DESTINATION
	MOV	R3,R1		;MAKE A COPY
1$:	CMP	#FILSPC+24,R3	;IS STRING TOO LONG?
	BLO	FNERR		;BRANCH IF TOO LONG
	CMPB	#',,@R4		;PERFORM CHEAP SYNTAX CHECK
	BEQ	FNERR		;BRANCH IF IMBEDDED COMMA IN STRING
	CMPB	#'=,@R4		;ALSO CHECK FOR A=A OR A= OR =A
	BEQ	FNERR		;BRANCH IF IMBEDDED EQUAL SIGN
	CMPB	#'<,@R4		;AND LASTLY ALTERNATE EQUALS
	BEQ	FNERR		;BRANCH IF ERROR
	MOVB	(R4)+,(R3)+	;FIND THE END OF THE FILE NAME STRING
	BNE	1$		;BRANCH IF NOT END
	TSTB	-(R3)		;RT CSI WANTS ASCIZ STRING
	CMP	R1,R3		;CHECK FOR NULL FILE NAME
	BEQ	NULLE		;BRANCH IF ER$ OR EW$ COMMAND
	TST	R2		;IS THIS EW OR EB?
	BEQ	2$		;BRANCH IF ER
	MOVB	#'=,(R3)+	;ALLOW FOR LENGTH SPECIFIER
	CLRB	@R3		;STILL KEEP IT ASCIZ
2$:	TST	R2		;IS THIS EB, ER, OR EW?
	BEQ	EREAD
	BPL	EWRITE
	BR	EBACK

ENCODE:	ERROR	UEN,<"Edit Next not implemented">
EICODE:	ERROR	UEI,<"Edit Indirect not implemented">
NULLE:	ERROR	MFN,<"Missing file name">
; EDIT BACKUP:
;	DO AN EDIT READ
;	FUDGE THE NAME, AND FALL THROUGH TO AN EDIT WRITE

EBACK:	TST	OOPFLG		;IS AN OUTPUT FILE STILL ACTIVE?
	BNE	OUTOPN		;BRANCH IF SO, ERROR
	JSR	PC,EREAD	;START AN INPUT FILE
	MOV	#INBLK+12,R0	;PREPARE TO COPY OUTPUT NAME
	MOV	#OUTBLK+12,R1	;AND SET UP POINTER, TOO
	MOV	-(R0),-(R1)
	MOV	-(R0),-(R1)
	MOV	-(R0),-(R1)
	MOV	-(R0),-(R1)
	MOV	-(R0),-(R1)
	MOV	SP,EBFLG	;MARK EB IN PROGRESS
	BR	EW1$		;AND ENTER THE OUTPUT FILE
.SBTTL	EDIT WRITE

; EDIT WRITE:
;	SCAN THE FILE NAME
;	CLEAR THE OUTPUT BUFFERS

EWRITE:	TST	OOPFLG		;IS AN OUTPUT FILE OPEN?
	BNE	OUTOPN		;BRANCH IF YES TO GIVE ERROR
	MOV	#OUTBLK,R3	;SET UP 39 WORD AREA
	JSR	PC,FNGET	;GET THE FILE NAME SCANNED
	JSR	PC,FETCH	;MAKE SURE HANDLER IS LOADED
	.PURGE	#13		;MAKE SURE CHANNEL INACTIVE
	TST	@R1		;CHECK FOR FILE STRUCTURED?
	BPL	EW1$		;BRANCH IF NOT, CAN'T SUPERCEDE
	.LOOKUP	#OAREA,#13	;LOOKUP THE OUTPUT FILE
	BCS	EW1$		;BRANCH IF FILE NOT FOUND
	.RCTRLO			;ENABLE ECHO
	.PRINT	#SUPER		;PRINT WARNING MESSAGE
EW1$:	.PURGE	#13		;FREE THE CHANNEL
	.ENTER	#OAREA,#13,,FILESZ ;CREATE THE OUTPUT FILE
	BCS	EERR		;SEE WHAT ERROR IS
	CLR	OBLKNM		;SET THE BLOCK NUMBER TO 0
	MOV	#OUTBLK,R3	;POINT R3 TO SET OUTPUT INFO
	MOV	#OBUF,-(R3)	;INIT OUTPUT DATA POINTER
	MOV	#-1,-(R3)	;INDICATE OUTPUT FILE OPEN
	DEC	R0		;REDUCE OUTPUT FILE SIZE BY 1
				;THIS MAKES NON-FILE ENTERS =-1
				;AND ALLOWS OTHERS - INTERNAL BUFFER
	MOV	R0,-(R3)	;SAVE IN OLIMIT FOR PUTBUF
	RTS	PC		;RETURN

EERR:	CMPB	@#ERRBYT,#-3	;SEE WHAT KIND OF ERROR
	BNE	DEVFUL		;EITHER DIECTORY OR DEVICE FULL
DIOERR:	ERROR	DIO,<"Directory IO error">
DEVFUL:	ERROR	NRO,<"No room for output">
OUTOPN:	ERROR	OFO,<"Output file already open">
.SBTTL	EDIT READ, READ NEXT BLOCK

; EDIT READ:
;	ABORT ANY ACTIVE INPUT FILE
;	SCAN FILE NAME, GET HANDLER
;	LOOKUP FILE

EREAD:	.PURGE	#12		;FREE INPUT CHANNEL
	MOV	#INBLK,R3	;SET UP 39 WORD AREA
	JSR	PC,FNGET	;SCAN THE NAME
	MOV	R3,R0		;COPY R3
	TST	R2		;IS THIS ER OR EB?
	BNE	1$		;BRANCH IF EB, FILE ACTS AS OUTPUT
	MOV	#INBLK+30.,R2	;NAME COMES BACK AS 1ST INPUT
				;THIS ALLOWS ERDEV: (SUPERTECO)
	MOV	(R2)+,(R0)+	;COPY UP FILESPEC
	MOV	(R2)+,(R0)+	;COPY UP FILESPEC
	MOV	(R2)+,(R0)+	;COPY UP FILESPEC
	MOV	(R2)+,(R0)+	;COPY UP FILESPEC
1$:	JSR	PC,FETCH	;LOAD THE HANDLER
	.LOOKUP	#LAREA		;OPEN THE INPUT FILE
	BCS	EINOFL		;IT WEREN'T THERE
	MOV	#IBUF+512.,-(R3);INIT PTR TO CAUSE READ
	MOV	#-1,-(R3)	;NO EOF YET AND INPUT FILE EXISTS
	CLR	IBLKNM		;SET BLOCK NUMBER TO 0
	CLR	EOFLAG(R5)	;NOT AT END-OF-FILE IF NEW FILE
	RTS	PC		;RETURN TO TECO

EINOFL:	CMPB	#-3,@#ERRBYT	;WHAT KIND OF ERROR?
	BEQ	DIOERR		;BRANCH IF FILE CANT EVEN BE LOOKED UP
	ERROR	FNF,<'File not found'>
.SBTTL	KILL FILE, CLOSE FILE, FLUSH OUTPUT BUFFER

; KILL FILE
;	PURGE OUTPUT CHANNEL
;	TURN OFF EB INDICATION IF ON

KILFIL:	JSR	R4,SAVREG	;SAVE ALL REGISTERS
;	TST	OOPFLG		;IS AN OUTPUT FILE OPEN?
;	BEQ	NOOFIL		;BRANCH IF NO OUTPUT FILE
	.PURGE	#13		;FREE THE OUTPUT CHANNEL
	BR	OUTCEB		;AND GO CLEAR INDICATIONS

; END FILE
;	DO ANY EB CLOSING NEEDED
;	RELEASE HANDLER FOR OUTPUT, CLEAR FLAG

CLSFIL:	MOV	R0,-(SP)	;PRESERVE R0
	.PURGE	#12		;FREE THE INPUT FILE
	CLR	IOPFLG		;NO INPUT FILE OPEN ANY MORE
	CLR	EOFLAG(R5)	;SO WE CAN'T BE AT END OF FILE
	MOV	(SP)+,R0	;RESTORE IT
CLSOUT:	JSR	R4,SAVREG
	MOV	#OOPFLG,R4	;SET UP FOR OUTPUT
	TST	(R4)+		;IS AN OUTPUT FILE OPEN?
	BEQ	NOOFIL		;ERROR IF NOT
	MOV	#511.,R2	;COUNT TO WRITE
1$:	CLR	R0		;SETUT A NULL
	JSR	PC,PUTBYT	;OUTPUT IT
	DEC	R2
	BNE	1$		;LOOP UNTIL DONE
	TST	EBFLG		;WERE WE IN EB?
	BEQ	OUTCLS		;IF NOT, JUST CLOSE OUTPUT
	MOV	#OUTBLK+16,R1	;POINT TO NEWNAME AREA
	MOV	#OUTBLK+6,R0	;POINT TO OLD INPUT NAME
	MOV	(PC)+,@R1	;SET NEW EXTENSION TO BAK
	.RAD50	/BAK/
	MOV	-(R0),-(R1)	;PUT IN REST OF NEW NAME
	MOV	-(R0),-(R1)
	MOV	-(R0),-(R1)
	.RENAME	#RNAREA		;MAKE THE DUPLICATE NAMED INPUT .BAK
OUTCLS:	.CLOSE	#13		;CLOSE THE OUTPUT FILE
	BCS	DIOERR		;BRANCH ON ERROR
OUTCEB:	CLR	EBFLG		;NO LONGER IN EB
	CLR	OOPFLG		;INDICATE OUTPUT FILE NO LONGER OPEN
	RTS	PC		;RETURN

NOOFIL:	ERROR	NFO,<'No output file'>
.SBTTL	PUTBUF - OUTPUT A TECO BUFFER LOAD

; PUTBUF:
;	OUTPUT A BUFFER

	.ENABL	LSB

PUTBUF:	JSR	R4,SAVREG	;SAVE REGS
	MOV	R0,R3		;SAVE CHARACTER POINTER IN BETTER SPOT
	MOV	#OOPFLG,R4	;POINT TO OUTPUT FLAG
	TST	(R4)+		;IS AN OUTPUT FILE OPEN?
	BEQ	NOOFIL		;ERROR IF NAE
	MOV	@R4,-(SP)	;GET CURRENT BUFFER POINTER
	SUB	#OBUF+510.,@SP	;CALC APPROX NUMBER CHARS CAN FIT
				;REMEMBER POSSIBLE FF AND ASR'D BIT
	ADD	R1,@SP		;REDUCE NUMBER OF CHARS TO WRITE
	ASR	@SP		;MAKE A BLOCK COUNT  -THIS IS ASR'D BIT
	CLRB	@SP		;WE WILL ALWAYS ASSUME 1 MORE BLOCK
	SWAB	@SP		;NOW BLOCK COUNT
	INCB	@SP		;ALWAYS KEEP NUMBER POSITIVE
	ADD	OBLKNM,@SP	;PLUS WHERE WE CURRENTLY ARE
	CMP	(SP)+,OLIMIT	;AGAINST TOTAL WE ARE ALLOWED TO WRITE
	BHI	OUTFUL		;BRANCH IF WE ARE GOING TO BLOW IT
1$:	DEC	R1		;OUTPUT ANY MORE?
	BMI	3$		;BRANCH IF NO MORE CHARS TO OUTPUT
	MOVB	(R3)+,R0	;GET CHARACTER TO OUTPUT
	MOV	#1$,-(SP)	;FAKE CALL TO OUTPUT THE CHARACTER
PUTBYT:	MOVB	R0,@(R4)+	;PUT THE CHARACTER INTO THE BUFFER
	INC	-(R4)		;BUMP THE POINTER
	CMP	#OBUF+512.,@R4	;AT END OF BUFFER?
	BHI	2$		;BRANCH IF STILL MORE ROOM
	MOV	#OWAREA,R0	;SET UP FOR WRITE WAIT EMT
	EMT	375		;OUTPUT THE BLOCK
	BCS	4$		;BRANCH IF ERROR
	INC	OBLKNM		;BUMP THE BLOCK NUMBER FOR NEXT TIME
	MOV	#OBUF,@R4	;RESET OUTPUT DATA POINTER
2$:	RTS	PC

3$:	TST	R2		;OUTPUT A FORM FEED?
	BEQ	2$		;BRANCH IF NOT TO RETURN
	MOV	#14,R0		;SET UP A FORM FEED
	BR	PUTBYT		;OUTPUT IT AND RETURN

4$:	TSTB	@#ERRBYT	;WHAT KIND OF ERROR?
	BNE	OUTERR		;HARDWARE ERROR
				;SHOULD NEVER FALL THRU (PRECHECK)
OUTFUL:	ERROR	FUL,<"Output file full">
OUTSAV:	ERRORI	UEA,<"EA not implemented">
INPSAV:	ERRORI	UEP,<"EP not implemented">
OUTERR:	ERROR	OUT,<"Output error">

	.DSABL	LSB
.SBTTL	GETBUF - READ A TECO BUFFER LOAD

; GETBUF:
;	READS BUFFER LOAD, AS PER TECO'S REQUEST

GETBUF:	JSR	R4,SAVREG	;SAVE REGISTERS
	MOV	R0,R3		;R0 MIGHT GET CLOBBERED
	CLR	FFFLAG(R5)	;ASSUME NO FORM FEED
	CLR	EOFLAG(R5)	;ASSUME NOT AT END OF FILE
	MOV	#IOPFLG,R4	;POINT TO INPUT FILE AREA
	TSTB	(R4)+		;IS INPUT FILE OPEN?
	BEQ	NOIFIL		;NO, RETURN AN ERROR
	TSTB	(R4)+		;ARE WE AT END OF FILE
	BEQ	4$		;BRANCH IF YES
1$:	DEC	R1		;DOES TECO WANT MORE?
	BMI	3$		;BRANCH IF NOT
2$:	JSR	PC,GETBYT	;GET A BYTE
	BEQ	4$		;BRANCH IF END OF FILE
	CMPB	R0,#RUBOUT	;IGNORE RUBOUTS
	BEQ	2$		;BRANCH IF RUBOUT
	CMPB	R0,#FF		;IF FORM FEED
	BEQ	5$		;GO SET FLAG AND EXIT
	MOVB	R0,(R3)+	;PUT BYTE, ADVANCE POINTER
	INC	ZZ(R5)		;UPDATE END OF TEXT POINTER FOR TECO
	CMP	R1,#128.	;FEWER THAN 128 BYTES LEFT?
	BLOS	3$		;BRANCH IF LESS THAN 128 BYTES LEFT
	CMP	R0,#LF		;LINE FEED?
	BNE	1$		;BRANCH IF NOT, JUST CONTINUE
	CMP	R1,R2		;LESS THAN 1/4 BYTES LEFT?
	BHI	1$		;BRANCH IF PLENTY OF ROOM
3$:	RTS	PC		;RETURN TO TECO

4$:	COM	EOFLAG(R5)	;WE ARE AT END OF INPUT FILE
	RTS	PC
5$:	COM	FFFLAG(R5)	;INDICATE STOPPED ON FORM FEED
	RTS	PC

NOIFIL:	ERROR	NFI,<"No input file">

GETBYT:	CMP	#IBUF+512.,@R4	;AT END OF CURRENT BUFFER?
	BHI	2$		;BRANCH IF NOT
	MOV	#IRAREA,R0	;SET UP FOR READ WAIT
	EMT	375		;READ THE BLOCK
	BCC	1$
	TSTB	@#ERRBYT	;WHAT KIND OF ERROR?
	BNE	INERR		;HARDWARE
	CLRB	IEFFLG		;EOF, SOFT ERROR
	RTS	PC		;RETURN WITH Z SET
1$:	INC	IBLKNM		;BUMP BLOCK NUMBER
	MOV	#IBUF,@R4	;RESET INPUT DATA POINTER
2$:	MOVB	@(R4)+,R0	;GET A DATA BYTE
	INC	-(R4)		;BUMP POINTER
	BIC	#177600,R0	;STRIP TO 7-BIT ASCII
	BEQ	GETBYT		;IGNORE NULLS
	RTS	PC		;RETURN WITH BYTE IN R0

INERR:	ERROR	INP,<"Input error">
.SBTTL	DATA AREA

; DATA AREA

FREEST	= .+2			;TOP OF PROGRAM AFTER LINK
	.LIMITS
EBFLG:	.WORD	0		;0= EB NOT IN PROGRESS, -1 EB ACTIVE
SPSAVE:	.WORD	0		;SP FOR ERROR RETURN
SCRACH:	.BLKW	5
DEFEXT:	.WORD	0,0,0,0
CHPTR:	.WORD	0	;HOLDS CHAINED FILENAME POINTER
CHAINF:	.WORD	GETTT	;HOLDS LISTEN DISPATCH ADDRESS FOR STARTUP CHAIN
UPCFLG:	.WORD	0	;CONTAINS PREVIOUS CHAR FOR DOUBLE ^C CHECK
EXITFL:	.WORD	1	;DEFAULT EXIT TO SOFT EXIT FOR REENTER
OUTDNE:	.WORD	0	;OUTPUT HAS BEEN DONE TO TERMINAL (FOR VT52)
VT52FL::.WORD	1	;0 MEANS DON'T TRY FOR WORK AREA, -1 MEANS EXISTS

; INPUT
LAREA:	.BYTE	12	;INPUT CHANNEL NUMBER
	.BYTE	1	;LOOKUP
	.WORD	INBLK	;POINTER TO DEVICE FILENAME BLOCK
	.WORD	0	;SPECIAL COUNT ARGUMENT

IRAREA:	.BYTE	12	;INPUT CHANNEL NUMBER
	.BYTE	10	;.READ EMT
IBLKNM:	.WORD	0	;BLOCK NUMBER
	.WORD	IBUF	;INPUT BUFFER
	.WORD	256.	;WORD COUNT
	.WORD	0	;READ WAIT INDICATOR

			;KEEP THE NEXT 4 BYTES TOGETHER
IOPFLG:	.BYTE	0	;0 = NO INPUT, -1 = INPUT FILE OPEN
IEFFLG:	.BYTE	-1	;0 = AT END OF FILE, -1 = NOT AT END OF FILE
IBPTR:	.WORD	0
INBLK:	.BLKW	4	;KEEP THIS NEXT TO IBUF, 39 WORDS FOR CSISPC
IBUF:	.BLKW	256.

; OUTPUT
OAREA:	.BYTE	13	;OUTPUT ON CHANNEL 13
	.BYTE	2	;.ENTER
	.WORD	OUTBLK	;POINT TO DEVICE FILENAME BLOCK
	.WORD	0	;FILE SIZE
	.WORD	0	;COUNT ARGUMENT

OWAREA:	.BYTE	13	;OUTPUT CHANNEL NUMBER
	.BYTE	11	;WRITE EMT INDICATOR
OBLKNM:	.WORD	0	;OUTPUT BLOCK NUMBER
	.WORD	OBUF	;OUTPUT BUFFER POINTER
	.WORD	256.	;WORD COUNT
	.WORD	0	;INDICATE WAIT FOR COMPLETION

OLIMIT:	.WORD	0	;UNSIGNED MAX SIZE OF OUTPUT FILE
OOPFLG:	.WORD	0	;-1 = OUTPUT FILE OPEN, 0 = NO OUTPUT FILE
OBPTR:	.WORD	0
OUTBLK:	.BLKW	4
FILESZ:	.WORD	0
OBUF:	.BLKW	256.

RNAREA:	.BYTE	14	;AN UNUSED CHANNEL
	.BYTE	4	;.RENAME
	.WORD	OUTBLK	;POINTER TO RENAME BLOCK

	.NLIST	BEX
MESSAG:	.ASCIZ	/[+2K Memory]/
SUPER:	.ASCIZ	/%Superseding existing file/
	.IF DF	HELP		;HELP GETS EXTRA MESSAGE
HLPMSG:	.ASCIZ	/?HELP-F-Error in HELP command/
	.ENDC
FILSPC:	.BLKB	26		;MAXIMUM FILE NAME LENGTH IS 20
	.EVEN
	.LIST	BEX

	.IF DF	VT11
GTFLAG:	.WORD	0		;0 -> NO VT11, 1 -> 12", -2 -> 17"
LCTSAV:	.WORD	0
LINMAX:	.WORD	0
CHICKN:	.WORD	0
SCROLP:	.WORD	0
SCLCNT:	.WORD	0

DISEND:	DSTOP
DISINI:	POINT+INT4+LPOFF+BLKOFF+LINE0
	0
SCRTOP:	.WORD	0
	DJMP			;LINK TO SCROLLER IF PRESENT
LINK:	.+2			;ELSE LINK TO OURSELF
VT11IN::POINT+INT4+LPOFF+BLKOFF+LINE0
	0
YPOS:	.WORD	1350		;Y POSITION FOR 12" SCREEN
	CHAR
	DJMP
DCHRS:	.WORD	0

UPCUR::	SHORTV+BLKON
	YSZ+INTX
	YSZ+MISVY
CURCOM:	XSZ*200+INTX
	XSZ+XSZ*200+MISVX
	XSZ*200+INTX
	CHAR+BLKOFF
	DJMP
CURETN:	.WORD	0

DWNCUR::SHORTV+BLKON
	YSZ+MISVY
	YSZ+INTX
	DJMP
	CURCOM

SCRSZR:	POINT
	0
	1500
	DSTOPN


; THE BUFFER SIZE SLOTS IN THIS TABLE MUST REMAIN EVEN!!!!
	BBUFSZ	= 6000		;THIS MUST BE > BIGGEST BUFFER SIZE

DPARMS:	.WORD	15.		;12",
	.WORD	1350
	.WORD	0		;NO SCROLLER
	.WORD	25.*74.+100.	;BUFFER SIZE
	.WORD	20.		;17",
	.WORD	1750		;Y START
	.WORD	0		;NO SCROLLER
	.WORD	35.*74.+100.	;BUFFER SIZE
	.WORD	11.		;12"
	.WORD	24.*5		;Y START
	.WORD	5		;NUMBER OF LINES TO SCROLL
	.WORD	20.*74.+100.	;BUFFER SIZE
	.WORD	15.		;17"
	.WORD	24.*6		;Y START
	.WORD	6		;NUMBER OF LINES TO SCROLL
	.WORD	26.*74.+100.	;BUFFER SIZE

PROBLK:	.BYTE	0,31
GTVCTR:	.WORD	0
OVSEQ:	.BYTE	LF,CR,16,27,17,40,0,2	;SPECIAL SEQ FOR CONT LINES
	.EVEN

	.ENDC
.SBTTL	START AND REENTER CODE


	.IF DF	VT11

1$:	TST	GTFLAG		;DO WE HAVE THE SCOPE?
	BEQ	2$		;BRANCH IF NOT
	.PROTECT #PROBLK	;REGET THE VECTORS
2$:	JMP	REENT
	BR	1$		;ON REENTRY, REENTER

	.IFF
	BR	REENT		;GO TO REENTER CODE
	.ENDC	;DF VT11

START::	.SRESET
	MOV	FREEST,R5	;GET FREE AREA POINTER
	MOV	@#RMON,R1	;POINT TO RMON
	MOV	USRBUF(R1),R4	;LEAVE USR RESIDENT
	MOV	R4,R0
	TST	-(R0)
	MOV	R5,-(SP)	;CALC START SIZE NEEDED
	ADD	#RWSIZE+PDLSIZ+SCHSIZ+FILSIZ+1000,@SP ;GET SIZE OF R/W
				;AREA + SAFETY ADJUST
	CMP	R0,(SP)+	;IS USR OVER PROGRAM?
	BHI	1$		;BRANCH IF NOT
	MOV	#-2,R0		;USR MUST OVERLAY IF PROGRAM OVERLAPS IT
1$:	.SETTOP
	MOV	R0,R3		;R3 IS MORE PERMANENT
	MOV	R5,R2
	MOV	#RWSIZE+PDLSIZ+SCHSIZ+FILSIZ,R0	;GET SIZE OF R/W AREA

	.IF DF	VT52WS
	TST	VT52FL		;SHOULD WE EVEN TRY TO ALLOCATE VT52 SPACE
	BEQ	2$		;BRANCH IF NOT
	MOV	R4,-(SP)	;DON'T ALLOCATE VT52 STUFF IF NO ROOM
	SUB	#SCRWSZ+4000,@SP;MAKE SURE THERE IS AT LEAST THIS SPACE
	CMP	R2,(SP)+	;DO WE OVERLAP?
	BHI	2$		;BRANCH IF YES
	ADD	#SCRWSZ,R0	;ALLOCATE WORK AREA FOR VT52 VARIABLES
	NEG	VT52FL		;INDICATE SAFE TO EXECUTE VWATCH ROUTINE
	.ENDC

2$:	ASR	R0		;NEED GLOBAL ARITHMETIC
3$:	CLR	(R2)+
	DEC	R0
	BNE	3$
	MOV	SP,TECOSP(R5)	;START HIS STACK
	SUB	#PDLSIZ+SCHSIZ+FILSIZ,R2 ;POINT R2 TO START OF PDL
	MOV	R2,TECOPD(R5)	;START OF PUSH DOWN LIST
	MOV	R2,PDL(R5)	;AND AGAIN
	ADD	#PDLSIZ,R2	;SKIP OVER PD SPACE
	MOV	R2,SCHBUF(R5)	;START OF SEARCH BUFFER
	ADD	#SCHSIZ-1,R2	;SKIP OVER SEARCH BUFFER
	COMB	(R2)+		;SET UP A NULL SEARCH BUFFER
	MOV	R2,FILBUF(R5)	;START OF FILENAME BUFFER
	ADD	#FILSIZ-1,R2	;SKIP TO END OF FILE NAME BUFFER
	COMB	(R2)+		;SET UP NULL FILE NAME BUFFER

	.IF DF	VT11

	MOV	GTVECT(R1),GTVCTR ;ADDRESS OF VT11 STOP VECTOR
	ADD	#CONFIG,R1	;POINT TO CONFIG WORD
	CLR	GTFLAG		;ASSUME NO VT11
	BIT	#VT11HW,(R1)+	;IS THERE A VT11?
	BEQ	7$		;BRANCH IF NOT
	SUB	#BBUFSZ,R4	;CHECK TO SEE IF DISPLAY REASONABLE
	CMP	R2,R4		;COULD DISPLAY LIST HIT USR??
	BHIS	7$		;BRANCH IF MIGHT, MAKE BELIEVE NO VT11
	.PROTECT #PROBLK	;ASK FOR THEM GRAPHICS VECTORS
	BCS	7$		;BRANCH IF CAN'T HAVE THEM
	INC	GTFLAG		;SET FLAG INDICATING VT11
	MOV	#LINK+2,LINK	;RESET OUR LINK WORD
	CLR	R4		;USED FOR SCREEN SIZE/ SCROLLER SETUP
	MOV	@R1,R1		;R1 -> SCROLLER, IF ANY
	BEQ	4$		;NO SCROLLER. REMEMBER THAT
	INC	R4		;INDICATE SCROLLER
	ADD	#SCLINK,R1	;R5 -> LINK WORD IN SCROLLER
	MOV	@R1,LINK	;LINK OUR BUFFER TO THE SCROLLER
	MOV	SCMAX-SCLINK(R1),LCTSAV ;PRESERVE HIS COUNT
	MOV	#SCRSZR,@R1	;CAUSE SCROLLER TO RUN SCREEN TEST
	BR	5$
4$:	MOV	#SCRSZR,@#DPC	;START SCREEN TEST
5$:	TST	@#DPS		;WAIT FOR DONE
	BPL	5$
	BIT	#EDGEFL,@#DPS	;IS EDGE FLAG SET?
	BNE	6$		;BRANCH IF 12" SCREEN
	COM	GTFLAG		;GTFLAG - INDICATES 17" SCREEN
	MOV	#1750,YPOS	;SET MY Y POSITION
6$:	ROL	R4		;SET SCREEN SIZE
	ASL	R4
	ASL	R4
	ASL	R4		;MAKE INDEX INTO 4 WORD ENTRY TABLES
	ADD	#DPARMS,R4	;MAKE ABSOLUTE POINTER
	MOV	@R4,NWATCH(R5)	;ENABLE ^W FOR VT11
	MOV	(R4)+,LINMAX	;SET LINE WINDOW
	MOV	(R4)+,SCRTOP	;SET MAXY FOR SCROLLER
	MOV	(R4)+,SCLCNT	;SET SCROLLER COUNT
	MOV	R2,DCHRS	;FILL IN DJMP ADDRESS OF BUFFER
	ADD	(R4)+,R2	;SIZE OF BUFFER
	MOV	R2,CHICKN	;SET UP NEAR END POINTER
	SUB	#CFACTR,CHICKN	;ADJUST BY CHICKEN FACTOR
	MOV	R1,SCROLP	;REMEMBER!

	.ENDC

7$:	MOV	R2,TXSTOR(R5)	;START OF TEXT AREA
	SUB	R2,R3		;SIZE OF TEXT AND QREG AREAS
				;C MUST BE 0 FROM EARLIER CHECKS
	ROR	R3		;DIVIDE FREE SPACE INTO 2 PARTS
	MOV	R3,ZMAX(R5)
	MOV	R3,QMAX(R5)
	ADD	R3,R2
	MOV	R2,QRSTOR(R5)
	CLR	CURFRE(R5)	;WE'VE GIVEN HIM ALL FOR NOW
	COM	EUFLAG(R5)	;ASSUME NO CASE FLAGGING!
	TST	VT52FL		;ARE WE SET UP FOR A VT52?
	BPL	8$		;BRANCH IF NOT
	BIS	#512.,ETYPE(R5)	;SET VT52 AVAILABLE BIT
8$:	MOV	#TECOCH,TECOJP(R5) ;LOAD DEFAULT JUMP DISPATCH TABLE
	MOV	#IOPFLG,INPNTR(R5) ;LOAD INPUT FLAG POINTER FOR TECO
	MOV	#OOPFLG,OUPNTR(R5) ;LOAD OUTPUT FLAG POINTER FOR TECO

REENT:
	MOV	FREEST,R5	;IN CASE OF REENTRY
	CLR	OOPFLG		;NO OUTPUT FILE OPEN
	CLR	IOPFLG		;NO INPUT FILE OPEN
	CLR	EBFLG		;NO EB IN PROGRESS
	BIS	#TTYUSR+REENTR,@#JSW ;TURN ON OUR OWN I/O

	MOV	#GETTT,CHAINF	;DEFAULT LISTEN TO READ FROM TERMINAL
	BIT	#CHAIN,@#JSW	;ARE WE CHAINED TO?
	.IF DF	HELP		;IF HELP.SAV ONLY CHAIN ENTRY VALID
	BNE	1$		;BRANCH IF CHAIN ENTRY
	JMP	TEXIT		;IMMEDIATELY HARD EXIT
	.IFF
	BEQ	2$		;NO, ENTER NORMALLY
	.ENDC
1$:	MOV	#CHINIT,CHAINF	;ENABLE CHAIN STARTUP SEQUENCE
	MOV	SP,INDIR(R5)	;SIMULATE INDIRECT FILE
	BIC	#CHAIN,@#JSW	;YES. TURN OFF CHAIN BIT
2$:
	.IF DF	HELP		;USE ^C INTERCEPT ONLY FOR TECO NOT HELP
	BR	3$		;SKIP ERROR TRAP CODE
	.ENDC

	MOV	R5,SCRACH+2	;POINT TO TECO ABORT FLAG FOR DOUBLE ^C
	ADD	#TFLG,SCRACH+2	;
	.SCCA	#SCRACH		;ENABLE ^C INTERCEPT
	.SERR			;HANDLE OUR OWN ERRORS

3$:	JMP	TECO
	.NLIST
	.IF DF	VT01

.SBTTL	CHARACTER TABLE

	.MACRO	CHAR	NAME$,VALUE$
	. = <''NAME$-40>*5+CHRTBL	; ORG TO CORRECT PLACE
	.IRP	VAL,<VALUE$>
	...=VAL/20!VAL
	...=.../4!...
	.BYTE	.../2!...+1+VAL
	.ENDR
	.ENDM

	.CSECT	CHRTBL

CHRTBL:
	.REPT	64.
	.BYTE	0,0,0,0,0
	.ENDR

	CHAR	$	<22,52,177,52,44>
	CHAR	<^>	<20,40,177,40,20>
	CHAR	%	<143,144,10,23,143>
	CHAR	<&>	<6,71,115,62,5>
	CHAR	<:>	<0,0,11,0,0>
	CHAR	<;>	<0,1,26,0,0>
	CHAR	^/</	<10,34,66,143,101>
	CHAR	>	<101,143,66,34,10>
	CHAR	/	<3,4,10,20,140>
	CHAR	"	<0,160,0,160,0>
	CHAR	'	<0,0,160,0,0>
	CHAR	(	<0,34,42,101,0>
	CHAR	)	<0,101,42,34,0>
	CHAR	!	<0,0,173,0,0>
	CHAR	.	<0,0,1,0,0>
	CHAR	+	<10,10,76,10,10>
	CHAR	-	<10,10,10,10,10>
	CHAR	<=>	<24,24,24,24,24>
	CHAR	<,>	<0,1,6,0,0>
	CHAR	[	<0,177,101,101,0>
	CHAR	]	<0,101,101,177,0>
	CHAR	<\>	<60,30,14,6,3>
	CHAR	_	<1,1,1,1,1>
	CHAR	@	<76,101,135,124,74>
	CHAR	*	<24,10,76,10,24>
	CHAR	#	<24,76,24,76,24>
	CHAR	?	<40,100,105,110,60>

	CHAR	0	<76,105,111,121,76>
	CHAR	1	<21,41,177,1,1>
	CHAR	2	<41,103,105,111,61>
	CHAR	3	<42,101,101,111,66>
	CHAR	4	<14,24,44,177,4>
	CHAR	5	<162,121,121,121,116>
	CHAR	6	<36,45,105,105,102>
	CHAR	7	<103,104,110,120,140>
	CHAR	8	<66,111,111,111,66>
	CHAR	9	<61,111,111,112,74>

	CHAR	A	<37,50,110,50,37>
	CHAR	B	<177,111,111,111,66>
	CHAR	C	<76,101,101,101,42>
	CHAR	D	<177,101,101,42,34>
	CHAR	E	<177,111,111,111,101>
	CHAR	F	<177,110,110,110,100>
	CHAR	G	<76,101,101,105,47>
	CHAR	H	<177,10,10,10,177>
	CHAR	I	<0,101,177,101,0>
	CHAR	J	<2,1,101,176,100>
	CHAR	K	<177,10,24,42,101>
	CHAR	L	<177,1,1,1,1>
	CHAR	M	<177,40,20,40,177>
	CHAR	N	<177,60,10,6,177>
	CHAR	O	<76,101,101,101,76>
	CHAR	P	<177,110,110,110,60>
	CHAR	Q	<76,101,105,102,75>
	CHAR	R	<177,110,114,112,61>
	CHAR	S	<61,111,111,111,106>
	CHAR	T	<100,100,177,100,100>
	CHAR	U	<176,1,1,1,176>
	CHAR	V	<170,6,1,6,170>
	CHAR	W	<177,2,4,2,177>
	CHAR	X	<143,24,10,24,143>
	CHAR	Y	<160,10,17,10,160>
	CHAR	Z	<103,105,111,121,141>
	.ENDC

	.LIST
	.END	START