;**************************************************************************;
;									   ;
;		ESPRIT III COLOR     TERMINAL UNIT ROUTINE	 	   ;
;									   ;
;**************************************************************************;
;
;                                 NOTICE
;
;	(c) 1984  Alpha Micro Systems Inc. / Alpha Base Systems Inc. 
;		All Rights reserved
;
;Edit history:
;
; FLIP Code added 1984

	SEARCH	SYS
	SEARCH	SYSSYM
	SEARCH	TRM
	RADIX	8.

	NVALU	FLIP			; M68 TVI950/V:1 to flip :and ;

	OBJNAM	.TDV

OUT$ = 1

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

ESCNT=	0
FNCPRC= 2
	CH2	=^H2000	; d		; ch2 flags 'function char #2 ok'

	BSH	=^H4000	; e		; backslash flag (from teltyp.mac)
	FIP	=BSH	; e		; bsh = function in progress flag

; Bitmap of defined functions (for new tdv format)
  FN.1	=^B1111111111111111	; 0-15	; Tel950 can do all 0-15 functions
  FN.2	=^B1111111111111001	;16-31	; some of fncts not yet defined
  FN.3	=^B1111111111111111	;32-47
  FN.4	=^B1111111111111111	;48-63	
  FN.5	=^B0111111111111111	;64-79
  FN.6	=^B0000000000000000	;80-95
  FN.7	=^B0000000000000000	;96-111
  FN.8	=^B0000000000000000	;112-127
  FN.9	=^B0000000000011100	;128-143
  FN.10	=^B0000000000000000	;144-159
  FN.11	=^B0000000000000000	;160-175
  FN.12	=^B0000000000000000	;176-191

$CTLA	=^H01				; control a
$BS	=^H08				; backspace
$TAB	=^H09				; tab
$LF	=^H0A				; line- feed
$VT	=^H0B				; vertical tab
$FF	=^H0C				; right- arrow, formfeed
$CR	=^H0D				; carriage return
$CTLU	=^H15				; control u
$CTLZ	=^H1A				; control z
$ESC	=^H1B				; escape char
$SPACE	=^H20
$COMMA	=^H2C				; comma
$SEMC	=^H3B				; semicolon
$LB	=^H3C				; <
$RUB	=^H7F				; rubout
BIT7	=^H80				; set bit 7
$CTLA7	=1+BIT7				; ^A- don't strip first
$CR7	=$CR+BIT7			; carriage return
$ESC7	=$ESC+BIT7			; escape with bit7 set
CTLMSK	=^H1F				; for masking to control chars

DEFINE	LDIN	CHAR
	BYTE	233,CHAR,0
	ENDM
	
DEFINE	TYPEP	CHAR
	BYTE	233,'.,CHAR,0
	ENDM

DEFINE	TYPEG	CHAR
	BYTE	233,'G,CHAR,0
	ENDM

DEFINE  CTL     TRG,CHAR
        BYTE    TRG,CHAR-'@
        ENDM



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

	WORD	FN.2
	WORD	FN.1
	WORD	FN.4
	WORD	FN.3
	WORD	FN.6
	WORD	FN.5
	WORD	FN.8
	WORD	FN.7
	WORD	FN.10
	WORD	FN.9
	BLKW 	6.			; FOR SUPERVUE
	WORD 	[SUP],[ER],[VUE]
	RAD50	/ABSVX SVX/

JMPINP:	JMP	INP			; go handle input characters
JMPCRT:	JMP	CRT			; go handle tcrt codes
JOUT:	JMP	OUTPUT			; output

;********************
;*	 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
;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
	RTN
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

;

	RADIX 8
;********************
;*	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
	ANDW	#177,D1			; [for mark]

2$:	CMPB	D1,#^H16		; replace ^v with lf 
	BNE	5$
	MOVB	#^H0A,D1
	BR	INX

5$:
IF	NE,FLIP

	CMPB	D1,#^H1E		; HOME SWAP
	BNE	CKLESC
	MOVB	#^H0A,D1		; must be AFTER #dat check
	BR	INX
ENDC

CKLESC:
	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
INX:	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
;   - 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
	CMPB	D1,#1			; function sequences start with SOH
	JNE	INMNOT			;   - escape sequence -

;Function codes translation
INMF:	MOVB	(A0)+,D1		; get the second character
	ANDW	#177,D1			; remove parity

30$:
	MOV	T.IBF(A5),A6
	ADD	T.ICC(A5),A6
	MOVB	#07,@A6			; force ^G ahead of this char
33$:	INC	T.ICC(A5)
	INC	T.BCC(A5)
INMX:	LCC	#0			; reset the flags
INMX2:	RTN


;Escape code translation
INMNOT:	MOVB	(A0)+,D1		; get the second character
	ANDB	#177,D1			; remove parity
	BIT	#T$XLT,@A5		; TRANSLATE??
	BEQ	8$			; NO USE internal
	ORB	#200,D1			; set the 8 bit
;	CALL	40$
;	MOVB	D1,@A6
;	CLR	D1
	LCC	#0
	RTN
8$:
	LEA	A6,XLAT2			; index the translation table
10$:	MOVB	(A6)+,D7		; get character
	JEQ	INMX2			;   end of table - take char(s) 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
	BIT	#^H80,D1		; special send??
	JEQ	INMX
30$:	CALL	40$			; accept sequence 'as is'
	MOVB	#07,@A6
35$:
	JMP	INMX			; move the chr
; subroutine
40$:	MOV	T.IBF(A5),A6	; subroutine inserts char
	ADD	T.ICC(A5),A6
	INC	T.ICC(A5)
	INC	T.BCC(A5)
	RTN

XLAT1:	BYTE	'J,2		; func N is new job requeste
	BYTE	'j,2
	BYTE	'I,1		; func I is toggle request
	BYTE	'i,1		; 
	BYTE	'E,3		; func P is FLIP subsystem request
	BYTE	'e,3		; 
	BYTE	0,0		; end of table
	EVEN

XLAT2:
	CTL 	'1,'T
 	CTL	'2,'R
	CTL	'3,'S
	CTL	'4,'E
	CTL	'5,'U
	CTL	'6,'O
	CTL	'",'X
	CTL	'8,'V
	CTL	'9,'\
	BYTE	'Q,^H06			; ins chr
	BYTE	'R,^H1A			; delete line
	BYTE	'W,^H04			; del chr
	BYTE	'E,^H02			; ins line
	BYTE	'q,^H11			; ^Q set insert mode
	BYTE	'7,^H1E			; hme(send key)
	BYTE	'Y,^H0E			; ^Y  Erase eol
	BYTE	'y,^H16			; ^V  Erase word
	BYTE	'T,^H19			; ^N Skip Eol
	BYTE	'I,^H01			; bs (backtab) ^A
	BYTE	'L,^H80+'|		; shft print = dial
	BYTE	'P,^H80+'\		; print = toggle ans/hu
	BYTE	'*,^H16			; ^V Erase Word
	BYTE	't,^H1F			; full line erase ^_
	BYTE	'j,^H0B			; shifted up arrow fix
	BYTE	0,0			; end of table
 	EVEN


;
OUTPUT:
	SAVE	A0,A3,A6,A4,D7
;	TST	T.IMP(A5)
;	BEQ	NOFLP			; NO IMPURE
	MOV	T.IMP(A5),A3
	ADD	#4,A3			; bump up

	TSTB	@A3			; ESC IN PROCESS?
	BEQ	2$			; NO
	
	CMPB	@A3,#25.		; in prgress??
	BNE	1$			; no

	CMPB	D1,#13.			; end??
	BEQ	4$			; yes - reset
	CMPB	D1,#215
	BEQ	4$

	CMPB	D1,#'|			; break??
	BNE	10$			; no -just output
	jmp	DOL25B			; execute the break

1$:
	CMPB	D1,#'f			; L25??
	BNE	4$			; NO

	CLRB	1(A3)			; reset toggle
	MOVB	#25.,@A3		; set the switch
	BR	10$

2$:	CMPB	D1,#^H1B		; esc??
	BNE	10$
	SETB	@A3			; set active
	BR	10$

4$:	CLRB	@A3

10$:
OUTX:
	REST	A0,A3,A6,A4,D7
	LCC	#10			; Set to output character
	rtn

	EVEN

	PAGE

DOL25B:					; line 25 attribute toggle
	TSTB	1(A3)			; toggle chk
	BEQ	2$
	CLRB	1(A3)
	LEA	A3,L25G
1$:
	LEA	A0,T.OQX(A5)		; inque this
	QINS	A0
	CLR	(A0)+
	MOV	#3,(A0)+		; length
	MOV	A3,@A0
	CLR 	D1
	LCC	#4
	REST	A0,A3,A6,A4,D7
	RTN
2$:
	SETB	1(A3)			; reset
	LEA	A3,L25W
	BR	1$

L25G:	BYTE	233,'G,'7
L25W:	BYTE	233,'G,'5


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
	TTYI				; send position command
	BYTE	233,275,0,0
	ADD	#^H1F1F,D1		; add position offsets
	ROR	D1,#8.			; send row
	TTY
	ROL	D1,#8.			; send col
	TTY
	RTN

CRTS:
;	CMPW	D1,#-^H0100
;	JCS	COLORS			; its color time

	AND	#377,D1			; strip the high byte
	CMPB 	D1,#254. 		; LOAD FUNCTION KEYS??
	BNE	0$

	TTYL	C254			; Execute the FUNCTION KEYS
	RTN
0$:
	CMPB	D1,#240.		; PRT ON
	BEQ	1$
	CMPB	D1,#241.		; PRT OFF
	BNE	4$
	TTYL	C241
	RTN
1$:	TTYL	C240			; PRT ON
10$:	rtn

4$:

	ASL	D1			;  times 2 (word offset).
	PUSH	A2			; save A2
	LEA	A2,CRCA			; index the table
	CMP	D1,#CRCB-CRCA		; check for valid code
	BHI	CRTX			;   and bypass if bad
DOCRT:	ADD	D1,A2			; add command code
	MOVW	@A2,D1			; pick up data field offset
	ADD	D1,A2			; make absolute data address
	TTYL	@A2

 	CMPB	1(A2),#'Y		; eos clear ??
	BNE	CRTX
	SLEEP	#75.			; wait a little

CRTX:	POP	A2
	RTN



;Word offset and data tables follow for all commands
;
CRCA:
WORD	C0-.,  C1-.,  C2-.,  C3-.,  C4-.,  C5-.,  C6-.,  C7-.,  C8-.,  C9-.
WORD	C10-., C11-., C12-., C13-., C14-., C15-., C16-., C17-., C18-., C19-.
WORD	C20-., C21-., C22-., 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-.,C109-.
WORD	C110-.,C111-.,C112-.,C113-.,C114-.,C115-.,C116-.,C117-.,C118-.,C119-.
WORD	C120-.,C121-.,C122-.,C123-.,C124-.,C125-.,C126-.,C127-.,C128-.,C129-.
WORD	C130-.,C131-.,C132-.,C133-.,C134-.,C135-.,C136-.,C137-.,C138-.,C139-.
WORD	C140-.,C141-.,C142-.,C143-.,C144-.,C145-.,C146-.,C147-.,C148-.,C149-.
WORD	C150-.,C151-.,C152-.,C153-.,C154-.,C155-.,C156-.,C157-.,C158-.,C159-.
WORD	C160-.,C161-.,C162-.,C163-.,C164-.,C165-.,C166-.,C167-.,0
CRCB:

;
;	Special character table for FLIP
;
COLCRT:
WORD	C158-.,C158-.,C160-.,C164-.,C162-.,C154-.,C167-.,C156-.

COLREV:
WORD	C32-.,C32-.,C139-.,C143-.,C34-.,C145-.,C141-.,C30-.

	PAGE

C0:	BYTE	233,'*,0		; clear screen
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,':,0		; start RED   field
C22:	BYTE	233,'G,'0,0  		; end RED   field
C23:	BYTE 	233,'$,0		; start line drawing mode (enable alternate character set)
C24:	BYTE	233,'%,0		; end line drawing mode (disable alternate character set)
C25:					; set horizontal position
C26:	BYTE	233,'d,0		; set SCREEN DARK
C27:	BYTE	233,'b,0		; set SCREEN BRIGHT
C28:	BYTE	233,'.,'2,0		; cursor on
C29:	BYTE	233,'.,'0,0		; cursor off
C30:	BYTE	233,'G,'5,0		; reverse CYAN
C31:	BYTE	233,'G,'0,0		; reverse CYAN off			[102
C32:	BYTE	233,'G,'7,0		; reverse WHITE
C33:	BYTE	233,'G,'0,0		; reverse WHITE off
C34:	BYTE	233,'G,'>,0		; reverse RED
C35:	BYTE	233,'G,'0,0		; reverse RED off
C36:	BYTE	233,'o,0		; turn off screen display		[102]
C37:	BYTE	233,'n,0		; turn on screen display		[102]
C38:	BYTE	'B,0			; top left corner
C39:	BYTE	'C,0			; top right corner
C40:	BYTE	'A,0			; bottom left corner
C41:	BYTE	'D,0			; bottom right corner
C42:	BYTE	'N,0			; top intersect
C43:	BYTE	'L,0			; right intersect
C44:	BYTE	'M,0			; left intersect
C45:	BYTE	'O,0			; bottom intersect
C46:	BYTE	'K,0			; horizontal line
C47:	BYTE	'J,0			; vertical line
C48:	BYTE	'I,0			; intersection
C49:
C50:					; slant block
C51:					; cross-hatch block
	BYTE	233,'%,233,'U,^H7F,233,'u,233,'$,0	; solid block
C52:	BYTE	'K,0			; double line horizontal
C53:	BYTE	'J,0			; double line vertical
C54:	BYTE	233,'f,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:					; up-arrow
C65:					; down-arrow
C66:	BYTE	32.,0			; raised dot
C67:	BYTE	'M,0			; end of line marker
C68:	BYTE	32.,0			; horizontal tab symbol
C69:	BYTE	'L,0			; 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:	byte 33,'P,0			; Print screen
C80:					; set 132 mode n/a
C81:    byte 0				; set normal mode
C82:	BYTE	233,96.,0		; PRINTER PORT ON-TRANSPARENT
C83:	BYTE	233,97.,0	 	; PRINTER PORT OFF (1=FLIP on)
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:	BYTE	0			; scroll box down one line
C95:					; select jump scroll
C96:	BYTE	33,'9,0			; select fast smooth scroll
C97:					; select med-fast smooth scroll
C98:					; select med-slow smooth scroll
C99:	BYTE	33,'8,0			; select slow smooth scroll
C100:	BYTE	33,'G,':,0		; start underscore/blink (red)
C101:	BYTE	33,'G,'0,0		; end underscore/blink 
C102:	BYTE	33,'G,'4,0		; start underscore/reverse (green)
C103:	BYTE	33,'G,'0,0		; end underscore/reverse
C104:	BYTE	33,'G,'>,0		; start underscore/reverse/blink (redrev)
C105:	BYTE	33,'G,'0,0		; end underscore/reverse/blink

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:	BYTE	33,'f,233,'G,'5,0	; start line 25 (line 0 on some terms)
C129:	BYTE	215,0			; end   line 25   " 
C130:	BYTE	33,'!,'1,0		; line lock on
C131:	BYTE	33,'!,'2,0		; line lock off
C132:	BYTE	233,'f,13.,0		; clear line 25
C133:	BYTE	0			; start underline (per char type)
C134:	BYTE	0			; end   underline   "
; ----- begin Alpha-Base defined calls -----
C135:	BYTE	233,'d,0		; set SCREEN DARK
C136:	BYTE 0;	233,'b,0		; set SCREEN BRIGHT (disallow in Color)
C137:	BYTE	' ,0			; SPACE
C138:	BYTE	233,'<,0		; key click off
C139:	BYTE	233,'G,'M,0    		; reverse BLUE
C140:	BYTE	233,'G,'0,0		; reverse BLUE off
C141:	BYTE	233,'G,'4,0		; reverse GREEN
C142:	BYTE	233,'G,'0,0		; reverse GREEN off
C143:	BYTE	233,'G,'?,0		; reverse MAGENTA
C144:	BYTE	233,'G,'0,0		; reverse MAGENTA off
C145:	BYTE	233,'G,'6,0		; reverse YELLOW on
C146:	BYTE	233,'G,'0,0		; reverse YELLOW off
C147:	BYTE	233,'.,'1,0		; cursor blink  block
C148:	BYTE	233,'.,'2,0		; cursor steady block
C149:	BYTE	233,'.,'3,0		; cursor blink  underline
C150:	BYTE	233,'.,'4,0		; cursor steady underline
C151:	BYTE	233,'f,233,'G,'M	; send msg to host msg fld (centered)
	ASCII	/                /
	byte 	233,'G,'7
	BYTE	0
C152:	BYTE	233,'G,'M,215,0			; end line 25
C153:	BYTE 	233,'g,0		; Turn L25 Msg ON

;COLOR TABLE on, off (off = on + 1)
C154:	BYTE    233,'G,'2,0		; yellow
C155:	BYTE    233,'G,'0,0
C156:	BYTE	233,'G,'1,0 		; cyan
C157:	BYTE    233,'G,'0,0
C158:	BYTE    233,'G,'3,0		; white
C159:	BYTE    233,'G,'0,0		; 
C160:	BYTE    233,'G,'9,0		; blue
C161:	BYTE    233,'G,'0,0
C162:	BYTE    233,'G,':,0		; red
C163:	BYTE    233,'G,'0,0
C164:	BYTE    233,'G,';,0		; magenta
C165:	BYTE    233,'G,'0,0
C166:	BYTE	233,'G,'8,0		; black (blank)
C167:	BYTE	233,'G,'0,0

; color only tcrts

C170:	BYTE    233,'G,'2,0		; yellow
C171:	BYTE    233,'G,'6,0		; reverse yellow
C172:	BYTE	233,'G,'1,0 		; cyan
C173:	BYTE    233,'G,'5,0		; reverse cyan
C174:	BYTE    233,'G,'3,0		; white
C175:	BYTE    233,'G,'7,0		; reverse white
C176:	BYTE    233,'G,'9,0		; blue
C177:	BYTE    233,'G,'M,0		; reverse blue
C178:	BYTE    233,'G,':,0		; red
C179:	BYTE    233,'G,'>,0		; reverse red
C180:	BYTE    233,'G,';,0		; magenta
C181:	BYTE    233,'G,'?,0		; reverse magenta
C182:	BYTE	233,'G,'8,0		; black (blank)
C183:	BYTE	233,'G,'0,0		; off green
C184:	BYTE	233,'G,'4,0		; reverse green




C240:	BYTE	233,96.,6,0		; PRINTER PORT ON-TRANSPARENT
C241:	BYTE	233,97.,4,0		; PRINTER PORT OFF (1=FLIP on)
C242:	BYTE	6,0			; FLIP off (Don't track screen)
C243:	BYTE	4,0			; FLIP on  (Start tracking screen)

radix 16.
C254:					; FUNCTION KEYS
; - revision 4.7 - function key extentions - 950 type terminals
  	BYTE	1B,'|,'1,'1,1B,'1,19	; F1
  	BYTE	1B,'|,'2,'1,1B,'2,19	; F2
  	BYTE	1B,'|,'3,'1,1B,'3,19	; F3
  	BYTE	1B,'|,'4,'1,1B,'4,19	; F4
  	BYTE	1B,'|,'5,'1,1B,'5,19	; F5
  	BYTE	1B,'|,'6,'1,1B,'6,19	; F6
  	BYTE	1B,'|,'7,'1,1B,'",19	; F7
  	BYTE	1B,'|,'8,'1,1B,'8,19	; F8
  	BYTE	1B,'|,'9,'1,1B,'9,19	; F9
  	BYTE	1B,'|,':,'1,1B,'A,19	; F10
  	BYTE	1B,'|,';,'1,1B,'B,19	; F11
 	BYTE	1B,'|,'<,'1,1B,'a,19	; sF1
 	BYTE	1B,'|,'=,'1,1B,'b,19	; sF2
 	BYTE	1B,'|,'>,'1,1B,'c,19	; sF3
 	BYTE	1B,'|,'?,'1,1B,'d,19	; sF4
 	BYTE	1B,'|,'@,'1,1B,'e,19	; sF5
 	BYTE	1B,'|,'A,'1,1B,'g,19	; sF6
 	BYTE	1B,'|,'B,'1,1B,'h,19	; sF7
 	BYTE	1B,'|,'C,'1,1B,'i,19	; sF8
 	BYTE	1B,'|,'D,'1,1B,'j,19	; sF9
 	BYTE	1B,'|,'E,'1,1B,'k,19	; sF10
 	BYTE	1B,'|,'F,'1,1B,'l,19	; sF11
	BYTE	0

	BYTE	0


SPCTBL:	BYTE	'=			; Move cursor escape character
	BYTE	'B			; top left corner	(TCRT 38)
	BYTE	'C			; top right corner	(TCRT 39)
	BYTE	'A			; bottom left corner	(TCRT 40)
	BYTE	'D			; bottom right corner	(TCRT 41)
	BYTE	'N			; top intersect		(TCRT 42)
	BYTE	'L			; right intersect	(TCRT 43)
	BYTE	'M			; left intersect	(TCRT 44)
	BYTE	'O			; bottom intersect	(TCRT 45)
	BYTE	'K			; horizontal line	(TCRT 46)
	BYTE	'J			; vertical line		(TCRT 47)
	BYTE	'I			; intersection		(TCRT 48)
	BYTE    13.                     ; Turn off Line 25.

	END


COLORS:
	PUSH	A2
	CMPW	D1,#^H0FE00		; foreground color
	BCC	FORCOL
 	CMPW	D1,#^H0FC00
	BCC	BAKCOL
	BR	CRTX			; no background
	
FORCOL:
	LEA	A2,COLCRT
	BR	EXCOL			; execute

BAKCOL:
	LEA	A2,COLREV
EXCOL:	AND	#377,D1
	ASL	D1
	BR	DOCRT			; execute
	





.