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