;**************************************************************************;
;									   ;
;			TELEVIDEO TERMINAL UNIT ROUTINE			   ;
;									   ;
;**************************************************************************;
;								PSL-00154-00
;                                 NOTICE
;
;All  rights  reserved.  This software is the property of Alpha Microsystems
;and the material contained herein is the  proprietary  property  and  trade
;secrets  of  Alpha Microsystems, embodying substantial creative efforts and
;confidential information, ideas and expressions, no part of  which  may  be
;reproduced  or  transmitted  in  any  form  or  by  any  means, electronic,
;mechanical,  or  otherwise,  including  photocopying  or  input  into   any
;information  storage  or  retrieval  system  without  the  express  written
;permission of Alpha Microsystems.
;
;CAUTION: Unauthorized distribution or reproduction  of  this  material  may
;subject you to legal action.
;
;Copyright (C) 1982 - Alpha Microsystems
;
;Edit history:
;
;[106] 8 May 1985
;	Correct my boo-boo in edit 105. /RJH
;[105] 2 May 1985
;	Fixed problem with rubbing out control characters. /RJH
;[104] 30 NOV 1984
;	Updated to meet the new standards: Updated the TRMCHR routine to support
; 	the new fields. Also to return the bitmap. /bys
;[103] 24 April 1984
;	Add latest video attribute TCRT calls and implement printer control
;	TCRT's. /RBC
;[102] 8 September 1982
;	Add extended display functions. /RBC
;[101] 2 Aug 1982
;	Added multi-byte function code processing to input routine. /DW
;[100] 3 May 1982
;	Move cursor TCRT calls to correspond to new standard. /RBC


	SEARCH	SYS
	SEARCH	SYSSYM
	SEARCH	TRM

	OBJNAM	T925TO.TDV

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

;********************
;*	 TELVID	    *
;********************
;Terminal driver communications area
TELVID:	WORD	TD$NEW!TD$TCH			; terminal attributes
	BR	JMPINP			; input routine
	RTN				; output routine
	BR	ECHO			; echo routine
	BR	JMPCRT			; crt control
	RTN				; no init routine yet
	WORD	0			; no impure area yet
ROWCNT:
	BYTE	24.			; number of rows
COLCNT:
	BYTE	80.			; number of columns
	LWORD	TFEATS			; terminal has:
					;   insert/delete line
					;   insert/delete character
					;   dim video attribute
					;   erase to end of screen
					;   erase to end of line

	BR	JMPTCH
JMPINP:	JMP	INP			; go handle input characters
JMPCRT:	JMP	CRT			; go handle tcrt codes
JMPTCH:	JMP	TCH			; go handle TRMCHR routine

;********************
;*	 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.		[105]
	BLO	RBX			;    yes -				[105][106]
;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				; 					[105]

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


;********************
;*	INP	    *
;********************
;Input character processing subroutine
;Return a negative flag to indicate possible multi-byte key codes
;Detect a negative flag which indicates the multi-byte processing return
INP:	BMI	INMLT			; skip if multi-byte processing
	CMPB	D1,#1			; function code?
	BEQ	INPM			;   yes - could be multi-byte sequence
	CMPB	D1,#33			; escape?
	BEQ	INPM			;   yes - could be multi-byte sequence
;
;++++++ NEW STUFF FOR AUTO TURN-ON WITH TRMOFF.LIT +++++++++
;
	PUSH	D1			;save everything (paranoid we are)
	PUSH	D7
	PUSH	A6
	PUSH	D3
	CLR	D1			;clear the reg
	MOVW	T.STS(A5),D6		;get the terminal status word
	PUSH 	D6			;and save the original
	ANDW	#20000,D6		;get this bit
	CMPW	D6,#20000		;see if this bit is on (tv OFF)
	BLO	CONT			;NO, tv is ON, so normal processing
	POP 	D6			;tv OFF, so get the status word
	MOVW	#20000,D7		;and the bit indicating it's OFF
	COMW	D7			;complement
	ANDW	D7,D6			;and turn this bit off (tv will be ON)
 	MOVW	D6,@A5			;move this into the status word
	LEA	A6,C37			;get the "turn on" byte string address
	MOV	A6,D1			;move this address to D1 for TRMBFQ
	MOV 	#2,D3			;the number of bytes for turn on
	TRMBFQ				;turn tv ON
CONT:	POP 	D6			;restore junk
	POP	D3
	POP	A6
	POP	D7
	POP	D1
;
;++++++ END OF "NEW HOT STUFF" - ZOUNDS! ++++++++++++++++
;
	LCC	#0			;   no - normal processing
	RTN

INPM:	LCC	#PS.N			; possible multi-byte - return N flag
	RTN

;Multi-byte processing is done here
;This occurs when TRMSER has accumulated all bytes of a multi-byte keystroke
;D0 contains the character count and A0 indexes the data string
;A5 indexes the terminal definition block and must be preserved
;The translated character must be returned in D1 for storage
;This routine may destroy only A0,A3,A6,D0,D6,D7
INMLT:	MOVB	(A0)+,D1		; get the first character
	DECB	D0			; no translation if single character
	BEQ	INMX
	CMPB	D1,#1			; function sequences start with SOH
	BEQ	INMF			;   function sequence -
;Escape sequences are translated directly by setting bit 7 on
;This will cause them to map to 240-377
	MOVB	(A0)+,D1		; get the second character
INMG:	ORB	#200,D1			; set bit 7 on
	BIT	#T$XLT,@A5		; are we doing translation?
	BEQ	INMNOT			;   no - check for another translation
INMX:	LCC	#0			; reset the flags
INMX2:	RTN

;Function codes require additional translation so that they become 200-237
INMF:	MOVB	(A0)+,D1		; get the second character
	SUBB	#'@,D1			; offset so that F1 becomes 0
	BR	INMG			;   and go finish up

;Come here if program is not doing translation and we must do our own
INMNOT:	LEA	A6,XLTTBL		; index the translation table
10$:	MOVB	(A6)+,D7		; get character
	BEQ	INMX2			;   end of table - ignore the character
	CMPB	D1,D7			; is it in the table?
	BEQ	20$			;   yes -
	INC	A6			;   no - bypass translation
	BR	10$			; loop for more -

;Come here to translate the character
20$:	MOVB	@A6,D1			; translate the character
	BR	INMX

;Translation table
XLTTBL:
;;;	BYTE	314,3			; CANCEL = Control-C
;;;	BYTE	302,3			; SHIFT + CANCEL = Control-C
;;;	BYTE	   ,15			; EXECUTE = Return
;;;	BYTE	276,15			; SHIFT + EXECUTE = Return
;;;	BYTE	313,'U-100		; DEL LINE = Control-U
	BYTE	000,000

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	ROWCNT(A2),D6		; get row count
	MOVW	D6,TC.ROW(A1)		; transfer row count
	MOVB	COLCNT(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		[104]
	MOVW	#0,TC.SSL(A1)		; set length of shifted status line	[104]
	MOVW	#0,TC.USL(A1)		; set length of unshifted status line	[104]
	MOV	D2,D7			; get TRMCHR argument flags		[104]
	AND	#TC$BMP,D7		; does user want bitmap			[104]
	BEQ	20$			; no - skip transfer code		[104]
; user has requested bitmap -- return to him
	PUSH	A1			; save argument block index		[104]
	ADDW	#TC.BMP,A1		; index bitmap return area		[104]
	LEA	A6,TCHBMP		; index our bitmap			[104]
	MOV	#<256./16.>-1,D7	; get amount to transfer		[104]
10$:	MOVW	(A6)+,(A1)+		; transfer to user			[104]
	DBF	D7,10$			; loop until done			[104]
	POP	A1			; restore register			[104]
20$:	RTN				; return to TRMCHR monitor routine

; Define feature bitmap
TCHBMP:	BYTE	^B11111111		; 0 - 7
	BYTE	^B11111111		; 8 - 15
 	BYTE	^B01111111		; 16 - 23
	BYTE	^B11111000		; 24 - 31	(no horiz or vertical pos)
	BYTE	^B00111111		; 32 - 39
	BYTE	^B11100000		; 40 - 47 
	BYTE	^B00001001		; 48 - 55
	BYTE	^B00000000		; 56 - 63 
	BYTE	^B11111111		; 64 - 71
	BYTE	^B11111111		; 72 - 79
	BYTE	^B00001100		; 80 - 87	(no alternate page )
	BYTE	^B10000000		; 88 - 95 	(no smooth scroll)
	BYTE	^B11110000		; 96 - 103
	BYTE	^B00000011		; 104 - 111	(no non-space attributes)
	BYTE	^B00000000		; 112 - 119 	(no non-space attributes)
	BYTE	^B00001111		; 120 - 127 	(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
;********************
;*	 CRT	    *
;********************
;Special crt control processing
;D1 contains the control code for X,Y 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
	ASL	D1			;  times 2 (word offset).
	CMP	D1,#CRCB-CRCA		; check for valid code
	BHI	CRTX			;   and bypass if bad
	LEA	A2,CRCA-2		; index the table
	ADD	D1,A2			; add command code
	MOVW	@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

;Escape sequence translation table
;
EXTB:	BYTE	67,73,105,111,120,121,122,124,127,131,377,377


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

CRCB:
	PAGE

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
C15:	BYTE	233,'R,0		; delete line
C16:	BYTE	233,'E,0		; insert line
C17:	BYTE	233,'W,0		; delete character
C18:	BYTE	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,'G,'2,0		; start blink field
C22:	BYTE	233,'G,'0,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:	BYTE	0			; set vertical position
C27:	BYTE	233,'.,0		; set terminal attributes
C28:	BYTE	233,'.,'2,0		; cursor on
C29:	BYTE	233,'.,'0,0		; cursor off
C30:	BYTE	233,'G,'8,0		; start underscore			[102]
C31:	BYTE	233,'G,'0,0		; end underscore			[102
C32:	BYTE	233,'G,'4,0		; start reverse video			[102]
C33:	BYTE	233,'G,'0,0		; end reverse video			[102]
C34:	BYTE	233,'G,'6,0		; start reverse blink			[102]
C35:	BYTE	233,'G,'0,0		; end reverse blink			[102]
C36:	BYTE	233,'o,0		; turn off screen display		[102]
C37:	BYTE	233,'n,0		; 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:					; left intersect
C45:	BYTE	'+,0			; bottom intersect
C46:	BYTE	'-,0			; horizontal line
C47:	BYTE	'|,0			; vertical line
C48:	BYTE	'+,0			; intersection
C49:					; solid block
C50:					; slant block
C51:	BYTE	'O,0			; cross-hatch block
C52:					; double line horizontal
C53:					; double line vertical
C54:					; 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:	BYTE	' ,0			; paragraph
C70:	BYTE	' ,0			; dagger
C71:	BYTE	' ,0			; section
C72:	BYTE	' ,0			; cent sign
C73:	BYTE	' ,0			; one-quarter
C74:	BYTE	' ,0			; one-half
C75:	BYTE	' ,0			; degree
C76:	BYTE	' ,0			; trademark
C77:	BYTE	' ,0			; copyright
C78:	BYTE	' ,0			; registered
C79:	BYTE	33,'P,0			; print screen
C80:					; reserved for set to wide mode
C81:	BYTE	0			; reserved for set to normal mode
C82:	BYTE	33,'`,0			; enter transparent print mode
C83:	BYTE	33,'a,0			; exit transparent print mode
C84:					; begin writing to alternate page
C85:					; end writing to alternate page
C86:					; toggle page
C87:					; copy to alternate page
C88:					; insert column
C89:					; delete column
C90:					; block fill with attribute
C91:					; block fill with character
C92:					; draw a box
C93:					; scroll box up one line
C94:					; scroll box down one line
C95:					; select jump scroll
C96:					; select fast smooth scroll
C97:					; select med-fast smooth scroll
C98:					; select med-slow smooth scroll
C99:	BYTE	0			; select slow smooth scroll
C100:	BYTE	33,'G,':,0		; start underscore/blink
C101:	BYTE	33,'G,'0,0		; end underscore/blink
C102:	BYTE	33,'G,'<,0		; start underscore/reverse
C103:	BYTE	33,'G,'0,0		; end underscore/reverse
C104:	BYTE	33,'G,'>,0		; start underscore/reverse/blink
C105:	BYTE	33,'G,'0,0		; end underscore/reverse/blink
C106:					; start underscore w/o space
C107:					; end underscore w/o space
C108:					; start reverse w/o space
C109:					; end reverse w/o space
C110:					; start reverse/blinking w/o space
C111:					; end reverse/blinking w/o space
C112:					; start underscore/blinking w/o space
C113:					; end underscore/blinking w/o space
C114:					; start underscore/reverse w/o space
C115:					; end underscore/reverse w/o space
C116:					; start underscore/reverse/blinking w/o space
C117:					; end underscore/reverse/blinking w/o space
C118:					; start blink w/o space
C119:	BYTE	0			; end blink w/o space
C120:	BYTE	233,'.,'1,0		; set cursor to blinking block
C121:	BYTE	233,'.,'2,0		; set cursor to steady block
C122:	BYTE	233,'.,'3,0		; set cursor to blinking underline
C123:	BYTE	233,'.,'4,0		; set cursor to steady underline
C124:					; spare
C125:					; spare
C126:					; spare
C127:	BYTE	0			; spare
C128:	BYTE	33,'F,'!,0		; select top status line
C129:	BYTE	177			; end of all status line
C130:	BYTE	33,'z,40,0		; select unshifted status line
C131:	BYTE	33,'Z,40,0		; select shifted status line
C132:					; select black text
C133:					; select white text
C134:					; select blue text
C135:					; select magneta text
C136:					; select red text
C137:					; select yellow text
C138:					; select green text
C139:					; select cyan text
C140:					; select black reverse text
C141:					; select white reverse text
C142:					; select blue reverse text
C143:					; select magneta reverse text
C144:					; select red reverse text
C145:					; select yellow reverse text
C146:					; select green reverse text
C147:	BYTE	0			; select cyan reverse text


	EVEN

	END

.