.TITLE	CRTRUB	SCOPE TYPE DETERMINATION, TABLES, SEQUENCES
.NLIST	TTM
.LIST	TOC,MEB,BEX
.ENABL	REG,GBL
.SBTTL	SCOPE TYPE DETERMINATION, TABLES, SEQUENCES

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

.IDENT	/V36/

.SBTTL	ASSEMBLY PARAMETERS

; RSTS		ASSEMBLE FOR RSTS/E SCOPE TYPE DETERMINATION	(D=NO)
; RSX		ASSEMBLE FOR RSX-11 SCOPE TYPE DETERMINATION	(D=NO)
; VMS		ASSEMBLE FOR VAX/VMS SCOPE TYPE DETERMINATION	(D=NO)
; RT11		ASSEMBLE FOR RT-11 SCOPE TYPE DETERMINATION	(D=NO)

; NOTE: YOU MUST SELECT EXACTLY ONE OPERATING SYSTEM FROM THE FOUR ABOVE.

; WATCH		ASSEMBLE TO INCLUDE "WATCH" SUPPORT		(D=YES)
; SCROLL	ASSEMBLE TO INCLUDE SCROLLING SUPPORT		(D=YES)
; IMMEDC	ASSEMBLE TO INCLUDE IMMEDIATE MODE COMMANDS	(D=YES)
; I$$SOB	ASSEMBLE FOR HARDWARE 'SOB' INSTRUCTION		(D=NO)
; I$$DIV	ASSEMBLE FOR HARDWARE 'DIV' INSTRUCTION		(D=NO)
.SBTTL	DEFAULT AND SET UP THE ASSEMBLY PARAMETERS

.IIF	NDF	RSTS,	RSTS=0	;DEFAULT TO NOT RSTS/E
.IIF	NDF	RSX,	RSX=0	;DEFAULT TO NOT RSX-11
.IIF	NDF	VMS,	VMS=0	;DEFAULT TO NOT VAX/VMS
.IIF	NDF	RT11,	RT11=0	;DEFAULT TO NOT RT-11

$$$$$$	=	0

.IF	NE	RSTS

$$$$$$	=	$$$$$$+1

.SBTTL		ASSEMBLED FOR RSTS/E SCOPE TYPE DETERMINATION

.ENDC	;NE	RSTS

.IF	NE	RSX

$$$$$$	=	$$$$$$+1

.SBTTL		ASSEMBLED FOR RSX-11 SCOPE TYPE DETERMINATION

.ENDC	;NE	RSX

.IF	NE	VMS

$$$$$$	=	$$$$$$+1

.SBTTL		ASSEMBLED FOR VAX/VMS SCOPE TYPE DETERMINATION

.ENDC	;NE	VMS

.IF	NE	RT11

$$$$$$	=	$$$$$$+1

.SBTTL		ASSEMBLED FOR RT-11 SCOPE TYPE DETERMINATION

.ENDC	;NE	RT11

.IF	NE	$$$$$$-1

.ERROR	;NO OR MORE THAN ONE SCOPE TYPE DETERMINATION ROUTINE SPECIFIED

.ENDC	;NE	$$$$$$-1
.IIF	NDF	WATCH,	WATCH=1		;DEFAULT TO INCLUDING "WATCH" SUPPORT
.IIF	NDF	SCROLL,	SCROLL=1	;DEFAULT TO INCLUDING SCROLL SUPPORT
.IIF	NDF	IMMEDC,	IMMEDC=1	;DEFAULT TO INCLUDING IMMEDIATE MODE

.IF	NE	WATCH

.IF	NE	SCROLL

.SBTTL		ASSEMBLED TO INCLUDE "WATCH" SUPPORT W/ SCROLLING

.IFF	;NE	SCROLL

.SBTTL		ASSEMBLED TO INCLUDE "WATCH" SUPPORT W/O SCROLLING

.ENDC	;NE	SCROLL

.IFF	;NE	WATCH

.SBTTL		ASSEMBLED TO NOT INCLUDE "WATCH" SUPPORT

SCROLL	=	0			;TURN OFF SCROLLING IF NO "WATCH"

.ENDC	;NE	WATCH

.IF	NE	IMMEDC

.SBTTL		ASSEMBLED TO INCLUDE IMMEDIATE MODE COMMANDS

.IFF	;NE	IMMEDC

.SBTTL		ASSEMBLED TO NOT INCLUDE IMMEDIATE MODE COMMANDS

.ENDC	;NE	IMMEDC
.IIF	NDF	I$$SOB,	I$$SOB=0	;DEFAULT TO NO HARDWARE 'SOB'

.IF	EQ	I$$SOB

.MACRO	SOB	REG,DST
	 DEC	REG
	 BNE	DST
.ENDM	SOB

.SBTTL		ASSEMBLED WITHOUT HARDWARE 'SOB' INSTRUCTION

.IFF	;EQ	I$$SOB

.SBTTL		ASSEMBLED WITH HARDWARE 'SOB' INSTRUCTION

.ENDC	;EQ	I$$SOB

.IIF	NDF	I$$DIV,	I$$DIV=0	;DEFAULT TO NO HARDWARE 'DIV'

.IF	EQ	I$$DIV

.MACRO	DIVR0	AMT
	 MOV	AMT,R0
	 JSR	PC,DIVR0
.ENDM	DIVR0

.SBTTL		ASSEMBLED WITHOUT HARDWARE 'DIV' INSTRUCTION

.IFF	;EQ	I$$DIV

.MACRO	DIVR0	AMT
	 CLR	R0
	 DIV	AMT,R0
.ENDM	DIVR0

.SBTTL		ASSEMBLED WITH HARDWARE 'DIV' INSTRUCTION

.ENDC	;EQ	I$$DIV
.SBTTL	NECESSARY SEQUENCES FOR RUBOUT AND CONTROL/U

.PSECT	CRTRUB,RO,I,GBL,REL,OVR

CRTRUB:	BR	CRTSET		;BRANCH TO THE SET UP ROUTINE

.ENABL	LSB

.IIF	NE	.-CRTRUB-2, .ERROR ;CURSOR UP SEQUENCE IS INCORRECTLY LOCATED
CUPSEQ:	.WORD	10$,10$,30$,50$	;CURSOR UP SEQUENCE POINTERS

.IIF	NE	.-CRTRUB-12, .ERROR ;ERASE SEQUENCE IS INCORRECTLY LOCATED
ERLSEQ:	.WORD	20$,20$,40$,60$	;ERASE A WHOLE LINE SEQUENCE POINTERS

10$:	.BYTE	2,233,'A	;VT52 & VT100(VT52) =>	<ESC><A>

20$:	.BYTE	4,015		;VT52 & VT100(VT52) =>	ENSURE LEFT MARGIN
	.BYTE	233,'K		;			<ESC><K>
	.BYTE	015		;			ENSURE LEFT MARGIN

30$:	.BYTE	5,233,'<	;VT100(ANSI) =>		ENSURE ANSI MODE
	.BYTE	233,'[,'A	;			<ESC><[><A>

40$:	.BYTE	7,015		;VT100(ANSI) =>		ENSURE LEFT MARGIN
	.BYTE	233,'<		;			ENSURE ANSI MODE
	.BYTE	233,'[,'K	;			<ESC><[><K>
	.BYTE	015		;			ENSURE LEFT MARGIN

50$:	.BYTE	5,232,0,0,0,0	;VT05 => <CUP><NUL><NUL><NUL><NUL>

60$:	.BYTE	3,015,236,015	;VT05 => <CR><EOL><CR>

	.EVEN

.DSABL	LSB
.SBTTL	DETERMINE SCOPE TYPE

;+
; CRTSET - DETERMINE SCOPE TYPE.
;
;*RSTS*	R4 -> FIRQB @ +6 WITH CHARACTERISTICS (UU.TRM) OF SCOPE TERMINAL
;*RSX*	R4 -> HORIZONTAL SIZE BYTE (@ +0) & TYPE BYTE (@ +2) OF SCOPE TERMINAL
;*VMS*	R4 -> DEVICE INFORMATION BUFFER @ +6 (DIB$) OF SCOPE TERMINAL
;*RT11*	R4 -> TERMINAL STATUS BLOCK @ +6 (M.TWID) OF SCOPE TERMINAL
;	CRTYPE(R5) = 0 (I.E., PRE-SET FOR DEFAULT SCOPE SUPPORT)
;
;	JSR	PC,CRTRUB
;
;	R4 =  SIZE OF "WATCH" STATIC READ/WRITE REGION (0 => NONE)
;	CRTYPE(R5) = 0 FOR SCOPE SUPPORT TYPE #1 (VT52)
;		     2 FOR SCOPE SUPPORT TYPE #2 (VT100 IN VT52 MODE)
;		     4 FOR SCOPE SUPPORT TYPE #3 (VT100 IN ANSI MODE)
;		     6 FOR SCOPE SUPPORT TYPE #4 (VT05)
;	VTSIZE+RWSIZE(R5) = VERTICAL SIZE IF "WATCH" SUPPORT (10.-127.)
;	HTSIZE+RWSIZE(R5) = HORIZONTAL SIZE IF "WATCH" SUPPORT (10.-254.&EVEN)
;	SCROLN+RWSIZE(R5) = 0 (NO SCROLLING INITIALLY)
;	"ET$CRT" SET IN "ETYPE(R5)" IF SCOPE SUPPORTED FOR RUBOUT & CONTROL/U
;	"ET$IAS" SET IN "ETYPE(R5)" IF SCOPE SUPPORTED FOR "WATCH"
;-

CRTSET:	MOV	R0,-(SP)	;SAVE R0
	MOV	#6,R0		;PRESET SCOPE TYPE TO 6

.IF	NE	RSTS

	DECB	(R4)		;FORM THE TRUE HORIZONTAL SIZE
	CMPB	(R4),#72.	;IS SCOPE A VT05 (WIDTH = 72.)?
	BEQ	40$		;YES
	INCB	12-6(R4)	;REALLY A VT100 ("XON")?
	BEQ	30$		;YES, USE IT IN ANSI MODE

.ENDC	;NE	RSTS
.IF	NE	RSX

	CMPB	2(R4),#T.VT05	;IS SCOPE A VT05?
	BEQ	40$		;YES
	CMPB	2(R4),#T.V100	;IS SCOPE A VT100?
	BEQ	30$		;YES, USE IT IN ANSI MODE
	CMPB	(R4),#72.	;IS SCOPE A VT05 (WIDTH = 72.)?
	BEQ	40$		;YES

.ENDC	;NE	RSX

.IF	NE	VMS

	CMPB	5-6(R4),#T$VT05	;IS SCOPE A VT05 (T$VT05 = TT$_VT05)?
	BEQ	40$		;YES
	CMPB	5-6(R4),#T$VT55	;IS SCOPE A VT55 (T$VT55 = TT$_VT55)?
	BEQ	10$		;YES, GO PRETEND IT'S A VT52
	CMPB	5-6(R4),#T$V100	;IS SCOPE A VT100 (T$V100 = TT$_VT100)?
	BEQ	30$		;YES, USE IT IN ANSI MODE
	CMPB	5-6(R4),#T$VT52	;IS SCOPE A VT52 (T$VT52 = TT$_VT52)?
	BNE	10$		;NO, BUT GIVE USER SCOPE SUPPORT FOR A VT52...
	BIT	10-6(R4),#T$XON	;REALLY A VT100 (T$XON = TT$M_HOSTSYNC)?
	BNE	30$		;YES, USE IT IN ANSI MODE

.ENDC	;NE	VMS

.IF	NE	RT11

	CMPB	(R4),#72.	;IS SCOPE A VT05 (WIDTH = 72.)?
	BEQ	40$		;YES
	BIT	#TANSI$,0-6(R4)	;REALLY A VT100 ("ANSI")?
	BNE	30$		;YES, USE IT IN ANSI MODE

.ENDC	;NE	RT11
10$:	TST	-(R0)		;CHANGE SCOPE TYPE TO 0 (VT52)
20$:	TST	-(R0)		;CHANGE SCOPE TYPE TO 2 (VT100 IN VT52 MODE)
30$:	TST	-(R0)		;CHANGE SCOPE TYPE TO 4 (VT100 IN ANSI MODE)
40$:	MOV	R0,CRTYPE(R5)	;SET THE SCOPE TYPE
	BIS	#ET$CRT,ETYPE(R5) ; AND ENABLE SCOPE RUBOUT SUPPORT

.IF	NE	WATCH

	MOV	50$(R0),VTSIZE+RWSIZE(R5) ;SAVE VERTICAL SIZE FOR "WATCH"
	MOV	60$(R0),HTSIZE+RWSIZE(R5) ;SAVE HORIZONTAL SIZE FOR "WATCH"

.IF	NE	SCROLL

	CLR	SCROLN+RWSIZE(R5) ;SET NOT SCROLLING INITIALLY

.ENDC	;NE	SCROLL

	BIS	#ET$IAS,ETYPE(R5) ;ENABLE "WATCH" SUPPORT
	MOV	#SRWSIZ,R4	; AND SET SIZE OF STATIC READ/WRITE REGION

.IFF	;NE	WATCH

	CLR	R4		;NO STATIC READ/WRITE REGION SINCE NO "WATCH"

.IFTF	;NE	WATCH

	MOV	(SP)+,R0	;RESTORE R0
	RTS	PC		; AND EXIT

.IFT	;NE	WATCH

50$:	.WORD	24.,24.,24.,20.	;TABLE OF VERTICAL SIZES
60$:	.WORD	80.,80.,80.,72.	;TABLE OF HORIZONTAL SIZES

.ENDC	;NE	WATCH
.IF	NE	WATCH

.SBTTL	NECESSARY TABLES AND SEQUENCES FOR "WATCH" SUPPORT

.PSECT	SCRSEQ,RO,D,GBL,REL,CON

; POSTBL - TABLE OF NUMBER OF CHARACTERS NEEDED TO POSITION CURSOR.
;
;	THIS TABLE IS USED FOR A CURSOR MOVEMENT OPTIMIZATION:
;	IF THE NUMBER OF PLACES TO MOVE THE CURSOR RIGHT (ON THE
;	SAME LINE) IS LESS THAN THIS TABLE'S ENTRY, THEN THE
;	PRECEEDING TEXT CHARACTERS ARE OUTPUT INSTEAD. THIS ENSURES
;	THAT WE ARE ALWAYS SENDING THE MINIMAL NUMBER OF CHARACTERS
;	TO THE SCREEN.

POSTBL::.WORD	4		;<ESC><Y><LINE #><COLUMN #>
	.WORD	4		;<ESC><Y><LINE #><COLUMN #>
	.WORD	4		;<ESC><[><# MOVES><C>
	.WORD	7		;<CTRL/N><LINE #><4 FILL'S><COLUMN #>

; FIXSEQ - CLEAN UP MODES (IF ANY).

FIXSEQ::.WORD	10$,10$,20$,NULL ;CLEAN UP MODES (IF ANY)

10$:	.BYTE	033,'[,'?,'2,'L+40 ;ENSURE VT52 MODE
	.BYTE	033,'\		;EXIT HOLD SCREEN MODE (IF ON)
	.BYTE	010,010,010,040,040,040 ;CLEAN UP THE "?2L" JUNK...
	.BYTE	033,'G,200	;EXIT GRAPHICS MODE (IF ON)

20$:	.BYTE	033,'<		;ENSURE ANSI MODE
	.BYTE	033,'[,'M+40	;TURN OFF ALL CHARACTER ATTRIBUTES
	.BYTE	017		;EXIT GRAPHICS MODE (IF ON)
	.BYTE	033,'7		;SAVE CURSOR POSITION
	.BYTE	033,'[,'?,'6	;ENSURE ORIGIN MODE
	.BYTE	    ';,'7,'L+40	; AND AUTO WRAP ARE OFF
	.BYTE	033,'8		;RESTORE CURSOR POSITION
	.BYTE	033,'),'0,200	;SET GRAPHICS MODE TO GRAPHICS CHARACTER SET

	.EVEN

; HOMSEQ - GO TO HOME.

HOMSEQ::.WORD	10$,10$,20$,30$	;GO TO HOME

10$:	.BYTE	033,'H,200	;GO TO HOME

20$:	.BYTE	033,'[,'H,200	;GO TO HOME

30$:	.BYTE	035		;GO TO HOME
FILL4:	.BYTE	0,0,0,0		;4 FILL'S
NULL:	.BYTE	200		;NULL SEQUENCE

	.EVEN

; EOLSEQ - ERASE FROM CURSOR TO END OF LINE.

EOLSEQ::.WORD	10$,10$,20$,30$	;ERASE FROM CURSOR TO END OF LINE

10$:	.BYTE	033,'K,200	;ERASE FROM CURSOR TO END OF LINE

20$:	.BYTE	033,'[,'K,200	;ERASE FROM CURSOR TO END OF LINE

30$:	.BYTE	036,200		;ERASE FROM CURSOR TO END OF LINE

	.EVEN

; EOSSEQ - ERASE FROM CURSOR TO END OF SCREEN.

EOSSEQ::.WORD	10$,10$,NULL,20$ ;ERASE FROM CURSOR TO END OF SCREEN

10$:	.BYTE	033,'J,200	;ERASE FROM CURSOR TO END OF SCREEN

20$:	.BYTE	037,0,0,0,0,200	;ERASE FROM CURSOR TO END OF SCREEN & 4 FILL'S

	.EVEN

; SCUSEQ - SCROLL SCREEN UP (WITH CURSOR AT LOWER LEFT).

SCUSEQ::.WORD	10$,10$,10$,VT05LF ;SCROLL SCREEN UP

10$:	.BYTE	012,200		;SCROLL SCREEN UP

VT05LF:	.BYTE	012,0,0,0,0,200	;SCROLL SCREEN UP & 4 FILL'S

	.EVEN

; SCDSEQ - SCROLL SCREEN DOWN (WITH CURSOR AT UPPER LEFT).

SCDSEQ::.WORD	10$,10$,20$,NULL ;SCROLL SCREEN DOWN

10$:	.BYTE	033,'I,200	;SCROLL SCREEN DOWN

20$:	.BYTE	033,'M,200	;SCROLL SCREEN DOWN

	.EVEN

; GONSEQ - TURN ON GRAPHICS MODE.

GONSEQ::.WORD	10$,10$,20$,NULL ;TURN ON GRAPHICS MODE

10$:	.BYTE	033,'F,200	;TURN ON GRAPHICS MODE

20$:	.BYTE	016,200		;TURN ON GRAPHICS MODE

	.EVEN

; GOFSEQ - TURN OFF GRAPHICS MODE.

GOFSEQ::.WORD	10$,10$,20$,NULL ;TURN OFF GRAPHICS MODE

10$:	.BYTE	033,'G,200	;TURN OFF GRAPHICS MODE

20$:	.BYTE	017,200		;TURN OFF GRAPHICS MODE

	.EVEN

; MONSEQ - TURN ON MARK'D REGION MODE.

MONSEQ::.WORD	NULL,NULL,10$,NULL ;TURN ON MARK'D REGION MODE

10$:	.BYTE	033,'[,'7,'M+40,200 ;SET REVERSE VIDEO ATTRIBUTE

	.EVEN

; MOFSEQ - TURN OFF MARK'D REGION MODE.

MOFSEQ::.WORD	NULL,NULL,10$,NULL ;TURN OFF MARK'D REGION MODE

10$:	.BYTE	033,'[,'M+40,200 ;CLEAR ALL ATTRIBUTES

	.EVEN

; GRPTBL - TABLE OF GRAPHICS MODE CHARACTERS.
;
;	EACH TABLE CONTAINS 11. BYTES CORRESPONDING TO THE GRAPHICS
;	MODE CHARACTERS FOR:
;
;		 1) A LINE WHICH OVERFLOWS THE SCREEN'S WIDTH
;		 2) CURSOR POSITIONED ON <LF> IMMEDIATELY AFTER <CR>
;		    ALSO, "SEE ALL" MODE SYMBOL FOR <LF>
;		 3) "SEE ALL" MODE SYMBOL FOR CONTROL CHARACTER FLAG
;		 4) "SEE ALL" MODE SYMBOL FOR <VT>
;		 5) AT END OF BUFFER ENDING WITHOUT <FF>
;		 6) AT END OF BUFFER ENDING WITH <FF>
;		    ALSO, "SEE ALL" MODE SYMBOL FOR <FF>
;		 7) "SEE ALL" MODE SYMBOL FOR <HT>
;		 8) "SEE ALL" MODE SYMBOL FOR NULL SPACING
;		 9) "SEE ALL" MODE SYMBOL FOR <CR>
;		10) "SEE ALL" MODE SYMBOL FOR OVERPRINT <CR>
;		11) "SEE ALL" MODE SYMBOL FOR <ESC>

GRPTBL::.WORD	10$,20$,20$,30$	;TABLE OF GRAPHICS CHARACTERS

10$:	.BYTE	'H+40		;RIGHT ARROW
	.BYTE	'K+40		;DOWN ARROW
	.BYTE	'G+40		;PLUS OR MINUS
	.BYTE	'J+40		;DIVIDED BY
	.BYTE	'^+40		;PARAGRAPH
	.BYTE	'A+40		;SOLID RECTANGLE
	.BYTE	'F+40		;DEGREES
	.BYTE	'I+40		;ELIPSIS
	.BYTE	'@+40		;"CD"
	.BYTE	'D+40		;"5/"
	.BYTE	'C+40		;"3/"

20$:	.BYTE	'H+40		;"NL"
	.BYTE	'E+40		;"LF"
	.BYTE	'G+40		;PLUS OR MINUS
	.BYTE	'I+40		;"VT"
	.BYTE	'@+40		;DIAMOND
	.BYTE	'C+40		;"FF"
	.BYTE	'B+40		;"HT"
	.BYTE	'^+40		;CENTERED DOT
	.BYTE	'D+40		;"CR"
	.BYTE	'\+40		;NOT EQUALS
	.BYTE	'[+40		;PI

30$:	.BYTE	'+		;+
	.BYTE	''		;'
	.BYTE	'^		;NO GRAPHICS...
	.BYTE	040		;NO GRAPHICS...
	.BYTE	'%		;%
	.BYTE	'@		;@
	.BYTE	040		;NO GRAPHICS...
	.BYTE	040		;NO GRAPHICS...
	.BYTE	040		;NO GRAPHICS...
	.BYTE	040		;NO GRAPHICS...
	.BYTE	'$		;NO GRAPHICS...

	.EVEN
.IF	NE	SCROLL

.SBTTL	NECESSARY SEQUENCES FOR SCROLLING SUPPORT

; CONSEQ - TURN ON CURSOR CHARACTER ATTRIBUTES.

CONSEQ::.WORD	NULL,10$,20$,NULL ;TURN ON CURSOR CHARACTER ATTRIBUTES

10$:	.BYTE	033,'<		;ENTER ANSI MODE
	.BYTE	033,'[,'1,';,'7,'M+40 ;SET BOLD & REVERSE VIDEO ATTRIBUTES
	.BYTE	033,'[,'?,'2,'L+40,200 ;BACK TO VT52 MODE

20$:	.BYTE	033,'[,'1,';,'7,'M+40,200 ;SET BOLD & REVERSE VIDEO ATTRIBUTES

	.EVEN

; COFSEQ - TURN OFF CURSOR CHARACTER ATTRIBUTES.

COFSEQ::.WORD	NULL,10$,20$,NULL ;TURN OFF CURSOR CHARACTER ATTRIBUTES

10$:	.BYTE	033,'<		;ENTER ANSI MODE
	.BYTE	033,'[,'M+40	;CLEAR ALL ATTRIBUTES
	.BYTE	033,'[,'?,'2,'L+40 ;BACK TO VT52 MODE
	.BYTE	033,'G,200	;TURN OFF GRAPHICS MODE

20$:	.BYTE	033,'[,'M+40	;CLEAR ALL ATTRIBUTES
	.BYTE	017,200		;TURN OFF GRAPHICS MODE

	.EVEN

; SAVCUR - SAVE CURSOR POSITION AND ATTRIBUTES.

SAVCUR::.WORD	NULL,10$,20$,NULL ;SAVE CURSOR POSITION AND ATTRIBUTES

10$:	.BYTE	033,'<		;ENTER ANSI MODE
	.BYTE	033,'7		;SAVE CURSOR POSITION AND ATTRIBUTES
	.BYTE	033,'[,'?,'2,'L+40,200 ;BACK TO VT52 MODE

20$:	.BYTE	033,'7,200	;SAVE CURSOR POSITION AND ATTRIBUTES

	.EVEN

; RESCUR - RESTORE CURSOR POSITION AND ATTRIBUTES.

RESCUR::.WORD	NULL,10$,20$,NULL ;RESTORE CURSOR POSITION AND ATTRIBUTES

10$:	.BYTE	033,'<		;ENTER ANSI MODE
	.BYTE	033,'8		;RESTORE CURSOR POSITION AND ATTRIBUTES
	.BYTE	033,'[,'?,'2,'L+40,200 ;BACK TO VT52 MODE

20$:	.BYTE	033,'8,200	;RESTORE CURSOR POSITION AND ATTRIBUTES

	.EVEN

.ENDC	;NE	SCROLL
.SBTTL	NECESSARY SUBROUTINES FOR "WATCH" SUPPORT

.PSECT	SCRSUB,RO,I,GBL,REL,CON

;+
; DIGITS - OUTPUT ASCII DIGITS.
;
;	R1 =  NUMBER TO OUTPUT, 0 BASED
;
;	JSR	PC,DIGITS
;
;	R0 =  UNDEFINED
;	R1 =  UNDEFINED
;-

DIGITS:	INC	R1		;ANSI WANTS NUMBER "1" BASED
	DIVR0	#100.		;DIVIDE FOR HUNDREDS
	MOV	R0,-(SP)	;SAVE HUNDREDS
	BEQ	10$		;NO HUNDREDS, SO SKIP THEM
	JSR	PC,30$		;HUNDREDS, GO OUTPUT IT
10$:	DIVR0	#10.		;DIVIDE FOR TENS
	BIS	R0,(SP)+	;DO TENS AND/OR HUNDREDS EXIST?
	BEQ	20$		;NOPE
	JSR	PC,30$		;YEP, GO OUTPUT THE TENS
20$:	MOV	R1,R0		;SET UNITS
30$:	ADD	#'0,R0		;MAKE INTO AN ASCII DIGIT
	BR	GOTYPE		; AND GO OUTPUT IT
;+
; DIRECT - DO DIRECT CURSOR ADDRESSING.
;
;	R0 =  DESIRED LINE NUMBER (ROW), 0 BASED
;	R2 =  DESIRED COLUMN NUMBER, 0 BASED
;	PRELIN+RWSIZE(R5) = CURRENT CURSOR LINE NUMBER (ROW), 0 BASED
;	PRECOL+RWSIZE(R5) = CURRENT CURSOR COLUMN NUMBER, 0 BASED
;	VTSIZE+RWSIZE(R5) = SCREEN'S VERTICAL SIZE
;	HTSIZE+RWSIZE(R5) = SCREEN'S HORIZONTAL SIZE
;
;	JSR	PC,DIRECT
;
;	R0 =  UNDEFINED
;	R3 =  UNDEFINED
;-

.ENABL	LSB

DIRECT::MOV	R1,-(SP)	;SAVE R1
	MOV	CRTYPE(R5),R1	;GET THE SCOPE TYPE
	SUB	#4,R1		;VT52=-4, VT100(VT52)=-2, VT100(ANSI)=0, VT05=2
	MOV	R0,-(SP)	;COPY DESIRED LINE NUMBER (ROW)
	SUB	PRELIN+RWSIZE(R5),(SP) ; AND FIND # LINES (ROWS) TO MOVE
	BEQ	10$		;NONE, LINE (ROW) IS ALREADY CORRECT
	CMP	R2,PRECOL+RWSIZE(R5) ;SOME, IS COLUMN NUMBER ALREADY CORRECT?
	BNE	60$		;NOPE, DO DIRECT CURSOR ADDRESSING
	MOV	#150$,R3	;SET SEQUENCE FOR CURSOR DOWN (& UP)
	TST	(SP)		;CHECK THAT MOVEMENT DIRECTION
	BR	30$		; AND GO USE IT

10$:	CMP	R1,#-4		;CHECK FOR VT52 SCOPE TYPE
	BNE	20$		;NOT A VT52
	MOV	#24.,R0		;THIS IS TO HELP STOP VT52 FROM FLICKER...
20$:	MOV	#160$,R3	;SET SEQUENCE FOR CURSOR RIGHT (& LEFT)
	MOV	R2,(SP)		;COPY DESIRED COLUMN NUMBER
	SUB	PRECOL+RWSIZE(R5),(SP) ; AND FIND # COLUMNS TO MOVE
30$:	BPL	40$		;WE NEED TO MOVE THE CURSOR DOWN -OR- RIGHT
	NEG	(SP)		;CORRECT FOR A POSITIVE MOVEMENT AMOUNT
	ADD	#10,R3		; AND CHANGE TO CURSOR UP -OR- LEFT
40$:	CMP	(SP),170$+4(R1)	;WITHIN THE MAXIMUM RANGE?
	BHIS	60$		;NOPE, DO DIRECT CURSOR ADDRESSING
	MOV	(SP)+,R0	;YEP, PUT THE COUNT INTO A REGISTER
	TST	R1		;VT100 IN ANSI MODE?
	BEQ	100$		;YES, DO DIFFERENTLY
50$:	JSR	PC,DOTYPE	;DO 1 CURSOR DOWN/UP -OR- RIGHT/LEFT
	SOB	R0,50$		; AND LOOP...
	MOV	(SP)+,R1	;RESTORE R1
	RTS	PC		; AND EXIT
60$:	TST	(SP)+		;JUNK THAT MOVEMENT AMOUNT
	MOV	#180$,R3	;SET SEQUENCE FOR DIRECT CURSOR ADDRESSING
	JSR	PC,DOTYPE	; AND START DIRECT CURSOR ADDRESSING
	TST	R1		;VT100 IN ANSI MODE?
	BEQ	110$		;YES, DO DIFFERENTLY
	JSR	PC,90$		;NO, ADJUST AND OUTPUT LINE NUMBER (ROW)
	TST	R1		;VT05 NEEDING FILL?
	BLE	70$		;NOPE
	MOV	#190$,R3	;YEP, SET FILLER SEQUENCE
	JSR	PC,DOTYPE	; AND GO DO IT
70$:	MOV	R2,R0		;NOW SET COLUMN NUMBER
80$:	MOV	(SP)+,R1	;RESTORE R1
90$:	ADD	#40,R0		;ADJUST LINE (ROW) OR COLUMN NUMBER
GOTYPE:	JMP	TYPEBF		;OUTPUT CHARACTER, THEN EXIT

100$:	MOV	4(R3),-(SP)	;STACK THE FINAL CHARACTER (LESS 40)
	MOV	#180$,R3	;SET START OF MOVE SEQUENCE
	JSR	PC,DOTYPE	; AND GO DO IT
	MOV	R0,R1		;COPY THE MOVE COUNT
	DEC	R1		; MAKING IT 0 BASED
	BR	130$		;NOW GO DO IT

110$:	MOV	#'H-40,-(SP)	;SET FINAL CHARACTER (LESS 40)
	MOV	R0,R1		;COPY THE LINE NUMBER (ROW)
	BEQ	120$		;NO NEED FOR OUTPUT IF WOULD BE "1"
	JSR	PC,DIGITS	;ELSE OUTPUT AS ASCII DIGITS
120$:	MOV	#';,R0		;SET THE SEPERATOR
	JSR	PC,TYPEBF	; AND OUTPUT IT
	MOV	R2,R1		;COPY THE COLUMN NUMBER
130$:	BEQ	140$		;NO NEED FOR OUTPUT IF WOULD BE "1"
	JSR	PC,DIGITS	;ELSE OUTPUT AS ASCII DIGITS
140$:	MOV	(SP)+,R0	;SET THE FINAL CHARACTER (LESS 40)
	BR	80$		; AND GO EXIT OUTPUTTING FINAL
150$:	.WORD	200$,200$,'B-40,VT05LF ;CURSOR DOWN
	.WORD	210$,210$,'A-40,220$ ;CURSOR UP

160$:	.WORD	230$,230$,'C-40,240$ ;CURSOR RIGHT
	.WORD	250$,250$,'D-40,260$ ;CURSOR LEFT

170$:	.WORD	<2+1+0+1>/2	;<ESC><Y><L><C> VS. N*(<ESC><B/A/C/D>)
	.WORD	<2+1+0+1>/2	;<ESC><Y><L><C> VS. N*(<ESC><B/A/C/D>)
	.WORD	-1		;<ESC><[><L><;><C><H> VS. <ESC><[><N><B/A/C/D>
	.WORD	<1+1+4+1>/1	;<^N><L><0><0><0><0><C> VS. N*(<^X/BS>)

180$:	.WORD	270$,270$,ANSI,280$ ;START DIRECT CURSOR ADDRESSING

190$:	.WORD	NULL,NULL,NULL,FILL4 ;FILL AS REQUIRED

200$:	.BYTE	033,'B,200	;VT52 & VT100 IN VT52 MODE => <ESC><B>

210$:	.BYTE	033,'A,200	;VT52 & VT100 IN VT52 MODE => <ESC><A>

220$:	.BYTE	032,0,0,0,0,200	;VT05 => <CTRL/Z> & 4 FILL'S

230$:	.BYTE	033,'C,200	;VT52 & VT100 IN VT52 MODE => <ESC><C>

240$:	.BYTE	030,200		;VT05 => <CTRL/X>

250$:	.BYTE	033,'D,200	;VT52 & VT100 IN VT52 MODE => <ESC><D>

260$:	.BYTE	010,200		;VT05 => <BS>

270$:	.BYTE	033,'Y,200	;VT52 & VT100 IN VT52 MODE => <ESC><Y>

ANSI:	.BYTE	033,'[,200	;VT100 IN ANSI MODE => <ESC><[>

280$:	.BYTE	016,200		;VT05 => <CTRL/N>

	.EVEN

.DSABL	LSB
.IF	NE	SCROLL

;+
; SETSCR - SET SCROLLING REGION.
;
;	R1 = STARTING LINE NUMBER (ROW) OF SCROLLING REGION, 0 BASED
;	R2 = SIZE OF SCROLLING REGION
;
;	CALL	SETSCR
;
;	R0 =  UNDEFINED
;	R1 =  UNDEFINED
;	R2 =  UNDEFINED
;	R3 =  UNDEFINED
;-

SETSCR::MOV	#10$,R3		;SET SEQUENCE TO START THE OPERATION
	JSR	PC,DOTYPE	; AND GO DO IT
	ADD	R1,R2		;CALCULATE THE ENDING SCROLLED LINE (ROW) +1
	JSR	PC,DIGITS	;EMIT THE STARTING LINE (ROW) AS DIGITS
	MOV	#';,R0		;SET THE ";" SEPARATOR
	JSR	PC,TYPEBF	; AND OUTPUT IT
	MOV	R2,R1		;SET THE ENDING SCROLLED LINE (ROW) +1
	DEC	R1		; THEN CORRECT IT
	JSR	PC,DIGITS	;EMIT ENDING LINE (ROW) AS DIGITS
	MOV	#20$,R3		;SET SEQUENCE TO END THE OPERATION
	JSR	PC,DOTYPE	; AND GO DO IT
	JMP	SCRHOM		;EXIT BY GOING TO HOME...

10$:	.WORD	NULL,30$,ANSI,NULL ;SET SCROLLING REGION SEQUENCE START

20$:	.WORD	NULL,40$,50$,NULL ;SET SCROLLING REGION SEQUENCE END

30$:	.BYTE	033,'<		;ENTER ANSI MODE
	.BYTE	033,'[,200	;START AN ANSI SEQUENCE

40$:	.BYTE	'R+40		;END THE ANSI SEQUENCE
	.BYTE	033,'[,'?,'2,'L+40,200 ;BACK TO VT52 MODE

50$:	.BYTE	'R+40,200	;END THE ANSI SEQUENCE

	.EVEN

.GLOBL	DOTYPE,	TYPEBF,	SCRHOM

.ENDC	;NE	SCROLL
.IF	EQ	I$$DIV

DIVR0:	MOV	R0,-(SP)	;SAVE DIVISOR ON THE STACK
	MOV	#-1,R0		;PRE-SET BIASED RESULT
10$:	INC	R0		;COUNT 1 MORE IN RESULT
	SUB	(SP),R1		; AND DO TRIAL SUBTRACT FROM DIVIDEND
	BHIS	10$		;NO UNDERFLOW YET...
	ADD	(SP)+,R1	;UNDERFLOW, CORRECT REMAINDER
	RTS	PC		; AND EXIT

.ENDC	;EQ	I$$DIV

.ENDC	;NE	WATCH
.IF	NE	IMMEDC

.SBTTL	NECESSARY SUBROUTINE FOR IMMEDIATE MODE COMMAND SUPPORT

.PSECT	TECOLS,RO,I,GBL,REL,OVR

TECOLS:	TST	QPNTR(R5)	;IS THIS THE FIRST INPUT REQUEST?
	BNE	10$		;NOPE, CAN'T BE IMMEDIATE MODE COMMAND
	BIT	#ED$IMD,EDIT(R5) ;ARE IMMEDIATE MODE COMMANDS ALLOWED?
	BEQ	10$		;NOPE, QUIT RIGHT NOW
	TST	INDIR(R5)	;AN INDIRECT COMMAND FILE ACTIVE?
	BNE	10$		;YEP, NO IMMEDIATE COMMANDS WANTED HERE
	MOV	QZ(R5),-(SP)	;GET CURRENT Q-REG ACTIVE STORAGE SIZE
	ADD	#20.,(SP)	; AND ADD IN A FUDGE FACTOR
	CMP	(SP)+,QMAX(R5)	;IS ENOUGH SPACE FREE TO PLAY WITH?
	BHIS	10$		;NOT ENOUGH SPACE, DON'T TRY FOR AN IMMEDIATE
	MOV	#40$,-(SP)	;THERE'S ENOUGH SPACE, CHECK FOR IMMEDIATES
10$:	JSR	PC,LISTEN	;GO CALL THE REAL 'LISTEN' ROUTINE
20$:	RTS	PC		;RETURN

30$:	MOV	#ETYPE,R2	;SET OFFSET TO THE FLAG TO READ/WRITE ("ET")
	MOV	#-1,R3		; AND SAY THAT WE'RE ABOUT TO WRITE THE FLAG
	JSR	PC,FLAGRW	;GO CHECK OUT THE FLAG
	MOV	R0,ETYPE(R5)	; THEN SET IT
	RTS	PC		;  AND RETURN

40$:	CMP	R0,#033		;IS THE FIRST THING ESCAPE?
	BNE	20$		;NOPE, NO ACTION REQUESTED, JUST EXIT
	MOV	ETYPE(R5),R0	;GET ORIGINAL "ET" FLAG
	MOV	R0,-(SP)	; AND SAVE IT
	BIS	#ET$CC!ET$LC,R0	;CONTROL/C TRAP, ENABLE LOWER CASE
	BIC	#ET$CKE!ET$NCH,R0 ;TURN ON ECHOING, ALWAYS STALL
	JSR	PC,30$		;GO CHANGE THE "ET" FLAG
	MOV	#'0,-(SP)	;SET CODE FOR <ESCAPE><CTRL-CHAR> ("0")
	JSR	PC,TLISTN	;READ THE NEXT CHARACTER
	CMP	R0,#40		;CONTROL CHARACTER?
	BLO	80$		;YEP, THAT'S CODE "0"
	INC	(SP)		;NOPE, SET CODE FOR <ESCAPE><CHAR> ("1")
	CMP	R0,#'[		;IS IT <ESCAPE><[><CHAR>?
	BEQ	70$		;YES, THAT'S ALSO CODE "1", BUT NEXT CHARACTER
	CMP	R0,#'?		;IS IT <ESCAPE><?><CHAR>?
	BEQ	60$		;YES, THAT'S CODE "2" ON THE NEXT CHARACTER
	CMP	R0,#'O		;IS IT <ESCAPE><O><????>?
	BNE	80$		;NONE OF THE ABOVE, IT'S CODE "1"
	JSR	PC,TLISTN	;WE NEED THE NEXT CHARACTER AT THIS POINT
	CMP	R0,#'A		;IS IT ALPHABETIC?
	BLO	50$		;NOPE, USE CODE "2"
	CMP	R0,#'Z		;IS IT UPPER CASE ALPHABETIC?
	BHI	50$		;NOPE, ALSO USE CODE "2"
	CMP	R0,#'M		;ALAS, IT IS UPPER CASE "M"?
	BNE	80$		;NOPE, IT'S CODE "1"
50$:	INC	(SP)		;SET CODE FOR <ESCAPE><?><CHAR> ("2")
	BR	80$		; AND GO SET CHARACTER CODE

60$:	INC	(SP)		;SET CODE FOR <ESCAPE><?><CHAR> ("2")
70$:	JSR	PC,TLISTN	;READ THE FINAL CHARACTER
80$:	BIC	#^C<37>,R0	;TRIM CHARACTER TO 5 BITS
	SWAB	R0		; AND PUT IT IN THE HIGH BYTE
	BIS	R0,(SP)		;  THEN .OR. IT INTO THE TYPE CODE
	MOV	2(SP),R0	;GET BACK THE ORIGINAL "ET" FLAG VALUE
	JSR	PC,30$		; AND GO RESET IT
	BIT	#ET$CRT,ETYPE(R5) ;SCOPE TYPE TERMINAL?
	BEQ	90$		;NO
	JSR	PC,DELLIN	;YES, ERASE TECO'S PROMPT
	MOV	#012,R0		;SET A "DELETED" CHARACTER OF LINE FEED
	JSR	PC,DELCHR	; TO MOVE THE CURSOR UP A LINE
90$:	MOV	(SP)+,R3	;MOVE CODES TO A REGISTER
	TST	(SP)+		; AND PURGE THE OLD "ET" VALUE
	CLR	ERRPOS(R5)	;NO ERROR POSITION IF STORING
	CLR	QLCMD(R5)	;NO LAST COMMAND IF STORING ANYTHING
	MOV	QZ(R5),R1	;GET RELATIVE PLACE TO STORE CHARACTERS
	ADD	QRSTOR(R5),R1	; AND MAKE IT ABSOLUTE
	MOV	#140$,R2	;GET POINTER TO THE COMMAND STRING LAYOUT
100$:	MOVB	(R2)+,R0	;FETCH A COMMAND STRING CHARACTER
	BMI	120$		;IT'S THE FINAL CHARACTER
	BNE	110$		;IT'S REAL, USE IT AS IS
	MOVB	R3,R0		;GET TYPE CODE FIRST, CHARACTER CODE SECOND
	SWAB	R3		;SWITCH FOR THE NEXT CODE
110$:	MOV	#100$,-(SP)	;SET A RETURN ADDRESS TO FETCH THE NEXT...
120$:	BIC	#^C<177>,R0	;ENSURE A 7-BIT CHARACTER
	MOV	R0,TEMP(R5)	;SAVE CHARACTER ABOUT TO BE STORED
130$:	INC	QZ(R5)		;INDICATE 1 MORE IN COMMAND
	INC	QPNTR(R5)	; Q-REGISTER
	MOVB	R0,(R1)+	;STORE THE CHARACTER
	RTS	PC		; AND RETURN

140$:	.BYTE	0, ',, '^&37, 0, 'M, 'A, 233 ;PROTOTYPE COMMAND STRING
	.EVEN

.ENDC	;NE	IMMEDC

.END