;	TVI920.TDV - driver for Televideo 920
; 
;	Copyright [c] Noel Alaska Systems Technology, 1985.
 
;	T$AB is a bit I define in terminal status word that tells VTAM
;	'func' keys will be used for alt escape, tchar, and pchar.  So
;	it will 'passthru' ^G, ^[,  and ^_ to the controlled job, only
;	recognizing them when the parity bit is set -  which the input
;	routine of this driver does when it translates the func keys.

	SEARCH	SYS
	SEARCH	SYSSYM
	SEARCH	TRM

T$AB	=	^O02000

	OBJNAM	0,0,[TDV]

;Define capability flags
;

TDVFLG=TD$DIM!TD$EOS!TD$EOL!TD$LID!TD$CID!TD$BLN!TD$UND!TD$RVA!TD$MLT

;********************
;*	 TVI920	    *
;********************
;Terminal driver communications area
TVI920:	WORD	TD$NEW!TD$TCH		; terminal attributes
	BR	JMPINP			; input routine				[102]
	RTN				; output routine (none)
	BR	ECHO			; echo routine
	BR	JMPCRT			; crt control
	RTN				; INIT routine

	WORD	4			; impure area of one longword.

RCNT:	BYTE	24.			; number of rows
CCNT:	BYTE	80.			; number of columns

	LWORD	TDVFLG			; terminal attributes

	BR	JMPTCH			; entry for TRMCHR routine

JMPINP:	JMP	INP			; go handle input			[102]
JMPCRT:	JMP	CRT			; go handle TCRT codes
JMPTCH:	JMP	TCH			; go handle TRMCHR call

;********************
;*	 ECHO	    *
;********************
;SPECIAL ECHO PROCESSING IS PERFORMED HERE
;RUBOUTS WILL BACKSPACE AND ERASE THE PREVIOUS CHARACTER
;CONTROL-U WILL ERASE THE ENTIRE LINE BY BACKSPACING AND ERASING
ECHO:	CMPB	D1,#25			;CONTROL-U
	BEQ	CTRLU			; 
	CMPB	D1,#177			;RUBOUT
	BNE	ECHX			; 

;RUBOUTS ARE HANDLED BY THE OLD BACKSPACE-AND-ERASE GAME
;SPECIAL HANDLING MUST BE PERFORMED IF WE ARE RUBBING OUT A TAB
;D6 CONTAINS THE CHARACTER BEING RUBBED OUT
RUBOUT:	CMPB	D6,#11			;WAS IT A TAB?
	BEQ	RBTB			;  YES
	CMPB	D6,#40			;  no, was it a control char.? 		[103]
	BLO	RBX			;   yes -				[103][104]
;RUBOUT WAS OF A PRINTABLE CHARACTER - QUEUE UP THE BACKSPACE SEQUENCE
KRTG:	MOV	#3,D3			;SET CHARACTER COUNT
	LEA	A6,ERUB			;SET BUFFER ADDRESS
	MOV	A6,D1			;  INTO D1
	TRMBFQ				;QUEUE THE BACKSPACE SEQUENCE
RBX:	RTN				; 					[103]

ERUB:	BYTE	10,40,10,0
;RUBOUT WAS OF A TAB - WE MUST CALCULATE HOW BIG THE TAB WAS AND BACKUP OVER IT
RBTB:	CLR	D3		;PRECLEAR D3
	MOVW	T.POB(A5),D3	;SET BEGINNING POSITION COUNT
	MOV	T.ICC(A5),D2	;SET INPUT CHARACTER COUNT
	MOV	T.IBF(A5),A6	;SET INPUT BUFFER BASE
KRTS:	DEC	D2		;DONE WITH SCAN?
	BMI	KRTQ		;  YES
	MOVB	(A6)+,D1	;SCAN FORWARD CALCULATING POSITION
	CMPB	D1,#11		;  TAB
	BEQ	KRTT
	CMPB	D1,#15		;  CR
	BEQ	KRTC
	CMPB	D1,#33		;  ALTMODE
	BEQ	KRTI
	CMPB	D1,#40		;  CONTROL-CHAR
	BLO	KRTS
	CMPB	D1,#172
	BHI	KRTS
KRTI:	INC	D3		;INCREMENT POSITION FOR ONE CHARACTER
	BR	KRTS
KRTT:	ADD	#10,D3		;ADJUST POSITION FOR TAB
	AND	#^C7,D3
	BR	KRTS
KRTC:	CLR	D3		;CLEAR POSITION FOR CR
	BR	KRTS
KRTQ:	COM	D3		;CALCULATE NECESSARY BACKSPACES
	AND	#7,D3
	INC	D3
	MOV	#10,D1		;SET IMMEDIATE BACKSPACE CHARACTER
	TRMBFQ			;QUEUE THE BACKSPACES
ECHX:	RTN

;ECHO A CONTROL-U BY ERASING THE ENTIRE LINE
CTRLU:	TST	D6		;NO ACTION IF NOTHING TO ERASE
	BEQ	CTUX
	CLR	D3		;PRECLEAR D3
	MOVW	T.POO(A5),D3	;CALCULATE BACKSPACE NUMBER TO ERASE THE LINE
	SUBW	T.POB(A5),D3
	BEQ	ECHX
	CMP	D3,T.ILS(A5)	;INSURE NOT GREATER THAN TERMINAL WIDTH
	BLOS	CLUA
	MOV	T.ILS(A5),D3
CLUA:	MOV	#10,D1		;QUEUE UP BACKSPACES
	TRMBFQ
	ASL	D1,#2		;QUEUE UP SPACES
	TRMBFQ
	MOV	#10,D1		;QUEUE UP BACKSPACES
	TRMBFQ
CTUX:	RTN

PAGE
;********************
;*	 TCH	    *
;********************
;Handle TRMCHR call
;A1 points to argument block, A2 indexes this TDV, D2 contains flags
;Can only use A1,A2,A6,D1,D2,D6,D7
TCH:	MOV	TD.FLG(A2),TC.FLG(A1)	; transfer flags
;	MOV	JOBCUR,A6		; index job
;	MOV	JOBTRM(A6),A6		; index terminal control area
;	MOV	T.IMP(A6),A6		; index impure area
	CLR	D6			; preclear register
	MOVB	RCNT(A2),D6		; get row count
	MOVW	D6,TC.ROW(A1)		; transfer row count
	MOVB	CCNT(A2),D6		; Get column count 			[103]
	MOVW	D6,TC.COL(A1)		; transfer column count.		[103]
;	MOVW	@A6,TC.COL(A1)		; transfer column count			[103]
	CLRW	TC.CLR(A1)		; no colors
	MOVW	#0,TC.TSL(A1)		; set length of top status line		[101]
	MOVW	#0,TC.SSL(A1)		; set length of shifted status line	[101]
	MOVW	#0,TC.USL(A1)		; set length of unshifted status line	[101]
	MOV	D2,D7			; get TRMCHR argument flags		[101]
	AND	#TC$BMP,D7		; does user want bitmap			[101]
	BEQ	20$			; no - skip transfer code		[101]
; user has requested bitmap -- return to him
	PUSH	A1			; save argument block index			[101]
	ADDW	#TC.BMP,A1		; index bitmap return area			[101]
	LEA	A6,TCHBMP		; index our bitmap			[101]
	MOV	#<256./16.>-1,D7	; get amount to transfer		[101]
10$:	MOVW	(A6)+,(A1)+		; transfer to user
	DBF	D7,10$			; loop until done
	POP	A1			; restore register
20$:	RTN				; return to TRMCHR monitor routine

; Define feature bitmap
TCHBMP:	BYTE	^B11111111		; 0 - 7
	BYTE	^B01111111		; 8 - 15
	BYTE	^B00000000		; 16 - 23
	BYTE	^B10000000		; 24 - 31	(no horiz or vertical pos)
	BYTE	^B00001011		; 32 - 39
	BYTE	^B11100001		; 40 - 47 
	BYTE	^B00111001		; 48 - 55
	BYTE	^B00000000		; 56 - 63 
	BYTE	^B10111111		; 64 - 71
	BYTE	^B01000001		; 72 - 79
	BYTE	^B00000000		; 80 - 87	(no alternate page )
	BYTE	^B00000000		; 88 - 95 	(no smooth scroll)
	BYTE	^B00000000		; 96 - 103
	BYTE	^B00000000		; 104 - 111	(no non-space attributes)
	BYTE	^B00000000		; 112 - 119 	(no non-space attributes)
	BYTE	^B00000000		; 120 - 127 	(no cursor blink & steady)
	BYTE	^B00000000		; 128 - 135 	(no top status line )
	BYTE	^B00000000		; 136 - 143	(no AM-70 style color)
	BYTE	^B00000000		; 144 - 151
	BYTE	^B00000000		; 152 - 159
	BYTE	^B00000000		; 160 - 167
	BYTE	^B00000000		; 168 - 175
	BYTE	^B00000000		; 176 - 183
	BYTE	^B00000000		; 184 - 191
	BYTE	^B00000000		; 192 - 199
	BYTE	^B00000000		; 200 - 207
	BYTE	^B00000000		; 208 - 215
	BYTE	^B00000000		; 216 - 223
	BYTE	^B00000000		; 224 - 231
	BYTE	^B00000000		; 232 - 239
	BYTE	^B00000000		; 240 - 247
	BYTE	^B00000000		; 248 - 255

PAGE
;************************
;*	INPUT		* Input routine for Televideo 950 
;************************
INP:	BMI	INMLT		; skip if multi-byte processing
	ANDB	#177,D1		; remove parity

CKLESC:	CMPB	D1,#1		; function code?
	BEQ	INPM		;   yes - could be multi-byte sequence
INX:	LCC	#0		;   no - normal processing
	RTN
INPM:	LCC	#PS.N		; possible multi-byte - return N flag
	RTN

; --- get here for multi-byte sequence ---
INMLT:	MOVB	(A0)+,D1	; get the first character
	ANDB	#177,D1
	DECB	D0		; no translation if single character
	BEQ	INMX

;Function codes translation
INMF:	MOVB	(A0)+,D1	; get the second character
	ANDB	#177,D1		; remove parity
	LEA	A6,XLAT1	; index the translation table
10$:	MOVB	(A6)+,D7	; get character
	BEQ	30$		;   end of table - take char as is
	CMPB	D1,D7		; this one it?
	BEQ	20$		;   yes -
	INC	A6		;   no  - keep looken
	BR	10$
20$:	MOVB	@A6,D1		; translate the sequence
	ORW	#T$AB,@A5	; force T$AB bit
	BR	INMX
30$:	MOV	T.IBF(A5),A6
	ADD	T.ICC(A5),A6
	MOVB	#01,(A6)+	; force ^A ahead of char
	MOVB	D1,(A6)+	;	then char itself
	MOVB	#15,D1		;	then trailing CR
	ADD	#2,T.ICC(A5)
	ADD	#2,T.BCC(A5)
INMX:	LCC	#0		; reset the flags
INMX2:	RTN

XLAT1:	BYTE	'E,207		; func E is alternate escape	[vtam]
	BYTE	'e,207		;
	BYTE	'P,237		; func P is picture request	[vtam]
	BYTE	'p,237		; 
	BYTE	'T,235		; func T is toggle request	[vtam]
	BYTE	't,235		; 
	BYTE	0,0		; end of table
	EVEN

PAGE
;********************
;*	 CRT	    *
;********************
;SPECIAL CRT CONTROL PROCESSING
;D1 CONTAINS THE CONTROL CODE FOR X,T POSITIONING OR SPECIAL COMMANDS
;IF D1 IS POSITIVE WE HAVE SCREEN POSITIONING (ROW IN HI BYTE, COL IN LO BYTE)
;IF D1 IS NEGATIVE WE HAVE THE SPECIAL COMMAND IN THE LOW BYTE
CRT:	TSTW	D1		;IS IT CURSOR POSITION?
	BMI	CRTS		;  NO
;CURSOR POSITIONING - D1 CONTAINS X,Y COORDINATES
	TTYI			;SEND POSITION COMMAND
	BYTE	233,75,0,0
	ADD	#17437,D1	;ADD POSITION OFFSETS
	ROR	D1,#8.		;SEND ROW FIRST
	TTY
	ROL	D1,#8.		;SEND COLUMN SECOND
	TTY
	RTN
;SPECIAL COMMANDS - D1 CONTAINS THE COMMAND CODE IN THE LOW BYTE
CRTS:	AND	#377,D1		;STRIP THE HIGH BYTE
	BNE	CRTU		;  AND BRANCH UNLESS CLEAR SCREEN
	TTYI			;SPECIAL CASE FOR CLEAR SCREEN
	BYTE	233,52,0
	EVEN
CRTZ:	TTYL	CRTNUL		; OUTPUT SOME NULLS
	RTN

;COMMAND PROCESSING PER DIRECTOR TABLES
CRTU:	PUSH	A2		;SAVE A2
	CMP	D1,#CRCB-CRCA	;CHECK FOR VALID CODE
	BHI	CRTX		;  AND BYPASS IF BAD
	LEA	A2,CRCA-1	;INDEX THE TABLE
	ADD	D1,A2		;ADD COMMAND CODE
	MOVB	@A2,D1		;PICK UP DATA FIELD OFFSET
	ADD	D1,A2		;MAKE ABSOLUTE DATA ADDRESS
	TTYL	@A2		;PRINT THE DATA FIELD
	CMPB	@A2,#36		;SLEEP IF HOME COMMAND
	BEQ	CRTXZ
	CMPB	1(A2),#100	;SLEEP IF ERASE COMMAND
	BHI	CRTXZ
CRTX:	POP	A2		;RESTORE A2
	RTN

CRTXZ:	POP	A2		;RESTORE A2
	BR	CRTZ		;  AND GO OUTPUT NULLS

;Null characters for long commands
CRTNUL:	BYTE 200,200,200,200,200,200,200,200,200,200,200,0
	EVEN

;BYTE OFFSET AND DATA TABLES FOLLOW FOR ALL COMMANDS
CRCA:	BYTE	C1-.,C2-.,C3-.,C4-.,C5-.,C6-.,C7-.,C8-.
	BYTE	C9-.,C10-.,C11-.,C12-.,C13-.,C14-.
	BYTE	C15-.,C16-.,C17-.,C18-.,C19-.,C20-.
	BYTE	C21-.,C22-.,C23-.,C24-.,C25-.,C26-.,C27-.,C28-.,C29-.,C30-.
	BYTE	C31-.,C32-.,C33-.,C34-.,C35-.
	BYTE	C36-.,C37-.,C38-.,C39-.,C40-.
	BYTE	C41-.,C42-.,C43-.,C44-.,C45-.
	BYTE	C46-.,C47-.,C48-.,C49-.,C50-.
	BYTE	C51-.,C52-.,C53-.,C54-.,C55-.,C56-.,C57-.,C58-.,C59-.,C60-.
	BYTE	C61-.,C62-.,C63-.,C64-.,C65-.,C66-.,C67-.,C68-.,C69-.,C70-.
	BYTE	C71-.,C72-.,C73-.,C74-.,C75-.,C76-.,C77-.,C78-.,C79-.,C80-.
	BYTE	C81-.,C82-.,C83-.,C84-.,C85-.,C86-.,C87-.,C88-.,C89-.,C90-.
	BYTE	C91-.,C92-.,C93-.,C94-.,C95-.,C96-.,C97-.,C98-.,C99-.,C100-.
	BYTE	C101-.,C102-.,C103-.,C104-.,C105-.,C106-.,C107-.,C108-.,C109-.,C110-.
	BYTE	C111-.,C112-.,C113-.,C114-.,C115-.,C116-.,C117-.,C118-.,C119-.,C120-.
	BYTE	C121-.,C122-.,C123-.,C124-.,C125-.,C126-.,C127-.,C128-.,C129-.,C130-.
	BYTE	C131-.,C132-.,C133-.,C134-.,C135-.,C136-.,C137-.,C138-.,C139-.,C140-.
	BYTE	C141-.,C142-.,C143-.,C144-.,C145-.,C146-.,C147-.
	BYTE	C148-.,C149-.,C150-.,C151-.,C152-.,C153-.,C154-.,C155-.,C156-.
CRCB:

C1:	BYTE	30.,0			; cursor home (move to column 1,1)
C2:	BYTE	200+13.,0		; cursor return (move to column 1)
C3:	BYTE	11.,0			; cursor up
C4:	BYTE	10.,0			; cursor down
C5:	BYTE	8.,0			; cursor left
C6:	BYTE	12.,0			; cursor right
C7:	BYTE	233,43,0		; lock keyboard
C8:	BYTE	233,42,0		; unlock keyboard
C9:	BYTE	233,'T,0		; erase to end of line
C10:	BYTE	233,'Y,0		; erase to end of screen
C11:	BYTE	233,'),0		; enter backgroud display mode (reduced intensity).
C12:	BYTE	233,'(,0		; enter foreground display mode (normal intensity)
C13:	BYTE	233,'&,0		; enable protected  fields
C14:	BYTE	233,'',0		; disable protected fields
;13:
;14:	BYTE	0
C15:	BYTE	233,'R,0		; delete line
C16:	BYTE	233,'E,0		; insert line
C17:	BYTE	0; 233,'W,0		; delete character
C18:	BYTE	0; 233,'Q,0		; insert character
C19:	BYTE	233,'?,0		; read cursor address
C20:	BYTE	233,'1,0		; read character at current cursor position
C21:	BYTE	233,'^,0		; start blink field
C22:	BYTE	233,'q,0  		; end blink field
C23:					; start line drawing mode (enable alternate character set)
C24:					; end line drawing mode (disable alternate character set)
C25:					; set horizontal position
C26:					; set SCREEN DARK
C27:					; set SCREEN BRIGHT
C28:					; cursor on
C29:    BYTE	0
C30:	BYTE	233,'l,0		; start underscore			[102]
C31:	BYTE	233,'m,0		; end underscore			[102
C32:	BYTE	233,'j,0		; start reverse video			[102]
C33:	BYTE	233,'k,0		; end reverse video			[102]
C34:	BYTE	233,'j,08.,233,'^,0	; start reverse blink			[102]
C35:	BYTE	233,'k,08.,233,'q,0	; end reverse blink			[102]
C36:					; turn off screen display		[102]
C37:					; turn on screen display		[102]
C38:					; top left corner
C39:					; top right corner
C40:					; bottom left corner
C41:					; bottom right corner
C42:					; top intersect
C43:					; right intersect
C44:    byte 0				; left intersect
C45:	BYTE	'+,0			; bottom intersect
C46:	BYTE	'-,0			; horizontal line
C47:	BYTE	'|,0			; vertical line
C48:	BYTE	'+,0			; intersection
C49:
C50:					; slant block
C51:					; cross-hatch block
 	BYTE	'X,0			; solid block
C52:	BYTE	'=,0			; double line horizontal
C53:	BYTE	'|,0			; double line vertical
C54:	BYTE	233,'=,'7,40,0		; send message to function key line
C55:					; send message to shifted function key line
C56:					; set normal display format
C57:					; set horizontal split (follow with row code)
C58:					; set vertical split (39 char columns)
C59:					; set vertical split (40 char columns)
C60:					; set vertical split column to next char
C61:					; activate split segment 0
C62:					; activate split segment 1
C63:	BYTE	0			; send message to host message field
C64:	BYTE	'^,0			; up-arrow
C65:	BYTE	'|,0			; down-arrow
C66:	BYTE	'`,0			; raised dot
C67:	BYTE	'~,0			; end of line marker
C68:	BYTE	'[,0			; horizontal tab symbol
C69:					; paragraph
C70:					; dagger
C71:					; section
C72:					; cent sign
C73:					; one-quarter
C74:					; one-half
C75:					; degree
C76:					; trademark
C77:					; copyright
C78:	BYTE	' ,0			; registered
C79:					; undefined
C80:					; undefined
C81:					; undefined
C82:					; undefined
C83:					; undefined
C84:					; undefined
C85:					; undefined
C86:					; undefined
C87:					; undefined
C88:					; undefined
C89:					; undefined
C90:					; undefined
C91:					; undefined
C92:					; undefined
C93:					; undefined
C94:					; undefined
C95:					; undefined
C96:					; undefined
C97:					; undefined
C98:					; undefined
C99:					; undefined
C100:					; undefined
C101:					; undefined
C102:					; undefined
C103:					; undefined
C104:					; undefined
C105:					; undefined
C106:					; undefined
C107:					; undefined
C108:					; undefined
C109:					; undefined
C110:					; undefined
C111:					; undefined
C112:					; undefined
C113:					; undefined
C114:					; undefined
C115:					; undefined
C116:					; undefined
C117:					; undefined
C118:					; undefined
C119:					; undefined
C120:					; undefined
C121:					; undefined
C122:					; undefined
C123:					; undefined
C124:					; undefined
C125:					; undefined
C126:					; undefined
C127:	BYTE	0			; undefined

; -----	LAST OF ALPHA-MICRO DEFINED TCRTS -----

; ----- begin SuperVue defined calls ------
C128:					; start line 25 (line 0 on some terms)
C129:					; end   line 25   " 
C130:					; line lock on
C131:					; line lock off
C132:					; clear line 25
C133:					; start underline (per char type)
C134:					; end   underline   "
; ----- begin Alpha-Base defined calls -----
C135:					; set SCREEN DARK
C136:					; set SCREEN BRIGHT
C137:					; key click on
C138:					; key click off
C139:					; blank on
C140:	BYTE	0			; blank off
C141:	BYTE	233,'j,08.,233,'l,08.,233,'^,0	; reverse//underline/blink ON
C142:	BYTE	233,'k,08.,233,'m,08.,233,'q,0	; reverse/blink/underline off
C143:	BYTE	233,'j,08.,233,'l,0	; reverse/underline on
C144:	BYTE	233,'k,08.,233,'m,0	; reverse/underline off
C145:	BYTE	233,'l,08.,233,'^,0	; blink/underline on
C146:	BYTE	233,'m,08.,233,'q,0	; blink/underline off
C147:					; cursor blink  block
C148:					; cursor steady block
C149:					; cursor blink  underline
C150:					; cursor steady underline
C151:					; send msg to host msg fld (centered)
C152:					; end line 25
C153:					; Turn L25 Msg ON
C154:					; undefined
C155:					; undefined
C156:	BYTE	0			; undefined
	WORD	0

	EVEN
	END