.MCall	.Module
.Module	KEDVWT RELEASE=V02 VERSION=2101 COMMENT=<Video Screen Update>,AUDIT=NO

;                   COPYRIGHT 1989, 1990, 1991 BY
;           DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS.
;                        ALL RIGHTS RESERVED
;
;THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND COPIED
;ONLY  IN  ACCORDANCE  WITH  THE TERMS  OF  SUCH  LICENSE AND WITH THE
;INCLUSION OF THE ABOVE COPYRIGHT NOTICE.  THIS SOFTWARE OR  ANY OTHER
;COPIES THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY
;OTHER PERSON.  NO TITLE TO AND OWNERSHIP OF  THE  SOFTWARE  IS HEREBY
;TRANSFERRED.
;
;THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE  WITHOUT NOTICE
;AND  SHOULD  NOT  BE  CONSTRUED AS  A COMMITMENT BY DIGITAL EQUIPMENT
;CORPORATION.
;
;DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR  RELIABILITY  OF ITS
;SOFTWARE ON EQUIPMENT THAT IS NOT SUPPLIED BY DIGITAL.
	.Enable	LC
	.Enable	GBL
;
;
;MODULE:	KEDVWT
;
;ABSTRACT:
;
;	PROVIDES SCROLLING DISPLAY FOR KED EDITOR
;
;AUTHOR:
;
;	HERB JACOBS	FROM EARLIER VERSION OF TECOIO
;
;MODIFIED BY: DJ DUFFY FOR USE WITH KED
;
;	X01.B DJD 17-AUG-77	CHANGED DISPLAY OF FF,VT
;	X01.C DJD 24-AUG-77 	VT10$0 CONDITIONAL
;	X01.D DJD 30-AUG-77	FIX BUG IN LINE POSITION
;				FIX BOMBOUT ON 8 BIT CHARS
;	X01.E DJD 31-AUG-77	FIX DISPLAY OF EOF TO BE ON
;				LAST LINE
;	X01.F DJD 3-OCT-77	MAKE IMPURE PSECT OVR
;	X01.07 DJD 11-NOV-77	FIX FOR FINAL VERSION OF VT100
;				FIX TO ALLOW VARIABLE SCREEN SIZE
;				(CHANGES FOR THIS ARE TOO NUMEROUS TO MARK)
;				FIX TO OPTIMIZE THE OUTPUT OF DIRECT CURSOR
;				SEQUENCES AT VTCHAR, ADD DEBU$G CONDITIONAL
;				TO OUTPUT ON HARDCOPY (TYPEBF)
;	X01.08 DJD 9-DEC-77	BUFFERED OUTPUT VIA .PRINT
;	X01.09 DJD 14-DEC-77	REDUCE SIZE OF POSTABLE FOR ANSI MODE
;	X01.10 DJD 16-JAN-78	FIX OUTPRM FOR WIDE SCREENS
;	X01.11 DJD 28-JAN-78	FIX GRAPHICS FOR VT100
;	X01.12 DJD 29-JAN-78	BECOMES KEDVWT FOR KED EDITOR
;				ADD SELECT DISPLAY FUNCTIONS
;	X01.13 DJD 5-JUN-78	FIX SO SCREEN IS NOT ERASED ON COMPLETE UPDATE
;				USE SHIFT IN-OUT FOR GRAPHICS
;	X01.14 DJD 16-JUN-78	MINOR FIXUP AND CLEANUP
;	X01.15 DJD 19-JUN-78	FIX FOR OVERLAYED ERROR MESSAGES
;				WRAP CHARACTER DISPLAY FIX
;	X01.16 DJD 2-JUL-78	FIX FOR LESS REPAINT ON SHORT LINES
;				DISPLAY NULL CHARACTERS MORE INTELLIGENTLY
;	X01.17 DJD 14-AUG-78	FIX BUG IN SELECT MODE DISPLAY
;		   19-AUG-78	COSMETIC UPDATES TO COMMENTS
;	X01.18 DJD 16-OCT-78	PERFORMANCE ENHANCEMENTS
;	X01.19 DJD 9-DEC-78	FIX BUG IN PERFORMANCE ENHANCEMENT
;	X01.20 DJD 16-FEB-79	REMOVE ABS IMPURE AREA FOR TRANSPORT TO RSX
;
;	Darrell Duffy
;
;	20-July-79	Fix video bugs.
;
;	Cheryl Vedoe
;
;	27-April-79	Utilize macro library.
;
;	4-May-79	Modify VWATCH to forget N lines at bottom of screen.
;
;	10-Sept-79	Fix VWATCH to not display nulls so they are not
;			  displayed in inspect mode under the RT-11 version.
;-
	.SbTtl	Post Release Edit History

;+
;
; (21/01) 08-Mar-95 Megan Gentry
;	Changes so that screen does not have to be an even number of
;	columns in width.
;
;-
	.SbTtl	Assembly parameters

;
;	VT10$0	NE	assemble for VT100 terminal
;	VT10$0	EQ	assemble for VT52 terminal
;

.IIf NDF,VT10$0, 	VT10$0	= 1	;Assume VT100 terminal

;
;	VT62$ NE	assemble VT62 support
;	VT62$ EQ	assemble for VT52
;

.IIf	NDF	VT62$	VT62$ = 0	;Assume VT52 support

;
;	DEBU$G	NE	assemble for debug of VWATCH
;	DEBU$G	EQ	assemble for no debug routines
;


.IIf	NDF,Virt$	Virt$=0		;Assume not virtual support

.IIf NDF,DEBU$G,	DEBU$G	= 0	;Assume no debug

	.MCall	SavReg	.Br	......
.If EQ	Virt$
	.MCall	Sob
.EndC ;EQ Virt$

;
;	Display appropriate subtitles
;

	.SbTtl
.If NE,VT10$0				;VT10$0
	.SbTtl	VT100 VERSION
.IfF					;VT10$0
	.SbTtl	VT52 VERSION
.EndC					;VT10$0

.If NE,DEBU$G				;DEBU$G
	.SbTtl	WITH DEBUG OPTION ENABLED
.EndC					;DEBU$G
	.SbTtl

;
;	Size of the screen image space
;

.If NE,VT10$0				;VT10$0

H.Max	==	132.			;Horizontal width maximum

.IfF					;VT10$0

H.Max	==	80.			;For the VT52

.EndC					;VT10$0

V.Max	==	24.			;Vertical size
	.SbTtl	EQUATED SYMBOLS
;
;	Max characters required for the check buffer before we quit
;	trying to fill it with larger lines
;

	MxChkC	=: 15.


;
;	Column limit before we use direct cursor addressing
;

.If EQ,VT10$0				;VT10$0

	CL.Lmt	=: 3			;Limit for VT52

.IfF					;VT10$0

	CL.Lmt	=: 6			;Limit for VT100

.EndC					;VT10$0


V.Clr	==:	0			;Clear (forget screen)
V.Updt	==:	-1			;Update screen
V.2Top	==:	-2			;Clear top 2 lines
V.3Bot	==:	3			;Clear bottom 3 lines
	.SbTtl	LOCAL MACRO DEFINITIONS

;
;	Select proper terminal I/O routines based on DEBU$G
;

;
;	$TOSTR,$TOBUF,$TOEND 		in I/O module
;

.If EQ,DEBU$G				;DEBU$G

;
;	Normal output to console terminal
;

.Macro	TypeBf
	Call	$ToBuf
.EndM

.IfF					;DEBU$G

;
;	NORMAL OUTPUT PLUS OUTPUT TO HARDCOPY CONSOLE AT
;	STANDARD ADDRESS
;

	.MCall	.TtyOut
.Macro	TypeBf
	Call	TypeBf
.EndM

.EndC					;DEBU$G

.Macro	Mult	Amt			;Call special routine
	Jsr	R4,Mult
	 .Word	Amt
.EndM	Mult
	.SbTtl	PSECT DEFINITIONS

;
;	PSect definitions
;

;>>>why not PSECT macro?
	.PSect	KEDVWT			;Code section
	.PSect	VWTDAT,GBL,D		;Impure data for root
	.PSect	IMPURE,GBL,D		;Impure area
	.PSect	KEDVWT
	.SbTtl	Define error macro

	$KED$	= 1			;Defined here but not in error module

;
;The following code is included as an error section so that it will be
;pulled out and assembled in the error module also. In this module, the
;error macro is defined to print the error message. In the error module,
;the macro is defined to assemble the message text.
;+
;ERROR
;

.IIf NDF,$KED$,	.Page
.IIf NDF,$KED$,	.SbTtl	Errors from KEDVWT module

;
;Define the error macro for this module
;
	.MCall	ErrDef

	ErrDef	V,ERROR
;-

	.SbTtl
	.SbTtl PURE DATA

	.PSect	KEDVWT

;
;	Output translator tables
;

RTrans:	.Word	VtChar,	VtBlnk,	0	;~d~Real output translator routines

FTrans:	.Word	FChar,	FBlnk,	0	;~d~Fake output translator routines

	.PSect	VWTDAT

;
;	This is the old MOVTBL which has been retained to
;	show the structure of the table
;

;MOVTBL:	.Word	 000000*H.MAX,	 000000
;$$$$$$	=	1
;.REPT	V.SIZE/2
;	.Word	+$$$$$$*H.MAX,	+$$$$$$
;	.Word	-$$$$$$*H.MAX,	-$$$$$$
;$$$$$$	=	$$$$$$+1
;.ENDR
;MOVTBE:

;
;	Table of moves for the heuristic scroller (TRYMOV)
;

MovTbl:	.BlkW	V.Max*2+2		;~d~Zero plus alternating lines
MovTbE:					;~d~
	.PSect	KEDVWT
	.SbTtl	SEQUENCES FOR SPECIAL CHARACTERS

;
;	Codes for special characters to be displayed
;

	SeqN	=: 6			;Number of special sequences
	SqEOB	=: 1			;End of buffer sequence
	SqVT	=: 2			;Vertical tab sequence
	SqFF	=: 3			;Form feed sequence
	SqOvr	=: 4			;Overflow sequence
	SqNul	=: 5			;Null character
	SqEsc	=: 6			;Esc character


;
;	Table of addresses of sequences for special characters
;

SeqS:	.Word	OvrSeq,EOBSeq,VTSeq,FFSeq,OvrSeq,NulSeq,EscSeq ;~d~

;
;	Special conditionals for VT100 for graphics sequences
;

.If EQ,VT10$0

;
;	For VT52
;

	EOBCD	= 'A+40			;END OF BUFFER - solid rectange or
					;gtr equal
	CURCD	= 'K+40			;CR LINE SEQ - downarrow or tilde
	OVRCD	= 'H+40			;LINE WRAP SEQ - right arrow or omega
	VTCD	= 'J+40			;VERT TAB SEQ - divide by or
					;down arrow
	FFCD	= 'F+40			;FORM FEED SEQ - degree or uparrow
	NULCD	= 176			;NULL CHARACTER - para or ??
	ESCCD	= 'g			;ESC CHARACTER - plusminus or
					;horseshoe
.EndC					;VT10$0

;
;	Macro to define a sequence
;

.If	NE	VT10$0
	.Macro	Seq XX,YY,ZZ
XX'Seq:	.Byte	<SO>,<YY>,<SI>
.IIf NB,<ZZ>,.Byte ZZ
	.Byte	<NoCrLf>
	.EndM
.IfF;	NE	VT10$0
	.Macro	SEQ XX,YY,ZZ
XX'Seq:	.Byte	<ESC>,<AO.EGF>
	.Byte	XX'CD
	.Byte	<ESC>,<AO.XGF>
.IIf NB,<ZZ>,.Byte ZZ
	.Byte	<NoCrLf>
	.EndM
.EndC;	NE	VT10$0
;
;	Define the sequences
;

	Seq	EOB,<G.CkBd>		;End of buffer
	Seq	CUR,<G.CR>,<BS>		;CR on line
	Seq	OVR,<G.Diam>		;Wrap line
	Seq	VT,<G.VT>		;VT seq
	Seq	FF,<G.FF>		;Form feed
	Seq	NUL,<G.Dot>		;Null char
	Seq	ESC,<G.PI>		;Esc character
	.Even
	.SbTtl	ESC SEQUENCES FOR TERMINAL

;
;	Generally used esc sequences
;

.If EQ,VT10$0

;
;	For VT52
;

ClnSeq:	.Byte	<ESC>,<AO.EL>,<NoCrLf>	;~d~Erase end of line
DirSeq:	.Byte	<ESC>,<AO.DCA>,<NoCrLf>	;~d~Cursor addressing
EEOSeq:	.Byte	<ESC>,<AO.ED>,<NoCrLf>	;~d~Blast to end of screen
LFSeq:	.Byte	<LF>,<NoCrLf>		;~d~Forward scroll
RevSeq:	.Byte	<ESC>,<AO.RLF>,<NoCrLf>	;~d~Reverse scroll
EosSeq:	.Byte	<ESC>,<AO.HOM>,<ESC>,<AO.ED> ;~d~Erase end of screen
NoSeq:	.Byte	<NoCrLf>		;~d~

.IfF					;VT10$0

;
;	For VT100
;

ClnSeq:	.Byte	<ESC>,<A.CSI>,<A.EL>,<NoCrLf> ;~d~Erase end of line
DirSeq:	.Byte	<ESC>,<A.CSI>,<NoCrLf>	;~d~Direct position introducer
EEOSeq:	.Byte	<ESC>,<A.CSI>,<A.ED>,<NoCrLf> ;~d~Blast to end of screen
LFSeq:	.Byte	<LF>,<NoCrLf>		;~d~Forward scroll
RevSeq:	.Byte	<ESC>,<A.RI>,<NoCrLf>	;~d~Backward scroll
EOSSeq:	.Byte	<ESC>,<A.CSI>,<A.CUP>,<ESC>,<A.CSI>,<A.ED> ;~d~Erase whole screen
NoSeq:	.Byte	<NoCrLf>		;~d~No sequence at all
SLcSeq:	.Byte	<ESC>,<A.CSI>,<A.REV>,<A.SEP>,<A.BOLD>,<A.SGR>,<NoCrLf> ;~d~Use reverse video
SLOSeq:	.Byte	<ESC>,<A.CSI>,<A.SGR>,<NoCrLf> ;~d~Turn them all off

.EndC					;VT10$0
.If	NE	VT62$
SLcSeq:	.Byte	<ESC>,<AO.REV>,<NoCrLf>	;~d~
SLOSeq:	.Byte	<ESC>,<AO.NOR>,<NoCrLf>	;~d~
.EndC;	NE	VT62$
	.Even
	.SbTtl	IMPURE AREA

	.PSect	IMPURE

;	*** ORDER ***

OutChr:	.BlkW	1			;~d~Output a character
OutBln:	.BlkW	1			;~d~End of line or buffer cleaner
RtMost:	.BlkW	1			;~d~Inited to zero as end of list
BuStrt:	.BlkW	1			;~d~Line counter, inited to zero

;	*** END ORDER ***

P:	.BlkW	1			;~d~Pointer to text in BKWPLYGND
ZZ:	.BlkW	1			;~d~Total chars in playground
NWatch:	.BlkW	1			;~d~Lines on screen- set to 16.
LinPtr:	.BlkW	1			;~d~Char counter (P) of line starts
SvStrt:	.BlkW	1			;~d~Saved line counter
InitFl:	.BlkW	1			;~d~>=0 implies unknown screen state
BuIndx:	.BlkW	1			;~d~Contains line index into screen map
CurLin:	.BlkW	1			;~d~Contains line number of cursor
CurChr::.BlkW	1			;~d~Contains column number of cursor
CurAbs::.BlkW	1			;~d~Contains absolute map position
					;of cursor
UnderC:	.BlkW	1			;~d~Character pos of under score
PreLin:	.BlkW	1			;~d~Last set line to screen
PreCol::.BlkW	1			;~d~Last set column to screen
QukFlg::.BlkW	1			;~d~Nonzero if we know the screen
					;zero if line term seen or
					;something blown away
WrpLns:	.BlkW	1			;~d~Nonzero if wrapped lines on screen

H.Size::.BlkW	1			;~d~Columns on screen
H.SzM1::.BlkW	1			;~d~Columns -1
H.SzM2::.BlkW	1			;~d~Columns -2
H.Wds:	.BlkW	1			;~d~Columns /2
V.Size::.BlkW	1			;~d~Lines
V.SzM1:	.BlkW	1			;~d~Lines-1

.If NE,VT10$0!VT62$			;IF VT100 TERMINAL

;
;	Select range data
;

SlcRng:	.BlkW	1			;~d~Non zero for select range active
SlcLow:	.BlkW	1			;~d~Low address of range
SlcHih:	.BlkW	1			;~d~High address of range

.EndC					;VT10$0

MapSiz:	.BlkW	1			;~d~Characters in map area

MapSt::	.BlkW	1			;~d~Last known screen
MapEnd:	.BlkW	1			;~d~Address of end of map

	.BlkW	1			;~d~Place for char count of line
ChCkBl:	.BlkW	1			;~d~Flag word
	.BlkB	H.Max			;~d~Room for chars

	.PSect	KEDVWT

	.SbTtl
	.SbTtl TYPEBF	- OUTPUT TO HARDCOPY IF DEBU$G

.If NE,DEBU$G

;++
;TYPEBF
;
;FUNCTIONAL DESCRIPTION:
;
;	Output all chars to hardcopy for study
;	ESC goes as CR,LF,$ so we can see esc sequences
;	clearly
;	Output to hardcopy occurs unless swr is zero
;	Note debug configuration has VT100 as a separate DL-11
;	and the RT-11 console is switches there for use
;
;INPUT:
;	R0 = character to print
;
;OUTPUT: NONE
;--

	SWR=:177570			;Console switches
	TPSR=:177564			;Hardcopy terminal output
					;(Real console)
	TPBR=:TPSR+2			;Buffer register
.Enable	LSB
TypeBf:	Mov	R0,-(SP)		;~x~Save the char
	.TtyOut				;~x~Output to screen
	Tst	SWR			;Hardcopy output
;>>>comments to here
	Beq	10$			;~x~No output if SWR = 0
	CmpB	R0,#<ESC>!200		;Check for esc
	Beq	20$			;~x~Something special
	CmpB	R0,#<ESC>&77		;Check both esc chars
	Beq	20$			;~x~Yes'em
	Call	30$			;~x~Output char
10$:	Mov	(SP)+,R0		;~x~Restore char
	Return				;~x~
	......
20$:	Mov	#<CR>,R0		;~x~Esc goes as CR
	Call	30$			;~x~(private output routine)
	Mov	#<LF>,R0		;... LF
	Call	30$			;~x~
	Mov	#'$,R0			;... AND A $
	Call	30$			;~x~
	Br	10$			;~x~
	...........
;
;	Private output routine
;	program transfer
;

30$:	TstB	TPSR			;~x~Wait for done
	Bpl	30$			;~x~
	MovB	R0,TPBR			;Output char
	Return				;~x~
	......
.EndC					;DEBU$G
	.SbTtl	VWATCH	- MAIN ENTRY
;++
;VWATCH
;
;FUNCTIONAL DESCRIPTION:
;
;	Screen manager for text display
;
;INPUT:
;	R0 = 0  => forget screen
;	R0 = -1 => update screen
;	R0 = -N => clear first n lines of screen to
;		refresh after prompt
;	R0 = +N => Clear last N lines of screen
;
;OUTPUT:
;	R0 = Value of NWATCH on entry to VWATCH
;	All other registers preserved
;--
.Enable	LSB
VWatch::				;~x~
	Mov	R0,BuStrt 		;Save the calling argument
	Bne	10$			;~x~If arg <> 0 process a real call
	Clr	InitFl 			;Else forget the entire screen
10$:	Mov	BCP,-(SP)		;~x~Setup some data from the scroller
	Sub	PlyGnd,@SP		;Chars behind us
	Inc	@SP			;Correct for one more
	Add	PlyEnd,@SP		;Make total chars in buffer
	Sub	FCP,@SP			;By adding rest beyond us
	Mov	(SP)+,ZZ		;Like TECO also
	Mov	BCP,P 			;Save abs addr as P
	Mov	NWatch,R0		;Return NWATCH
	SavReg				;Save all registers
	Mov	V.Size,R1		;Put maximum legal count into odd reg
	Mov	BuStrt,R0 		;Get calling argument back again
	Beq	30$			;~x~Br if forgetting whole screen
	Bgt	20$			;~x~Br if bottom of screen
	Com	R0			;Make changed lines count positive
	Beq	DoIt			;~x~Branch if no special screen mods
	Inc	R0			;Correct to plus number of lines
20$:	Cmp	R0,R1			;~x~Is argument over maximum?
	Bhi	30$			;~x~Yes, use maximum
	Mov	R0,R1			;No, use argument
30$:	Clr	QukFlg			;~x~Remember we do not know screen
	Clr	WrpLns			;No wrapped lines on screen
	Mult	H.Size			;Multiply line count by bytes on line
	Mov	MapSt,R0 		;Build a pointer
	Tst	BuStrt			;Are we clearing from the top?
	Ble	40$			;~x~Br if so
	Mov	MapEnd,R0		;Else point to end of map
	Sub	R1,R0			;Subtract bytes to clear
40$:	Asr	R1			;~x~Get number of words to clear
50$:	Clr	(R0)+			;~x~Clear what we think it looks like
	Sob	R1,50$			;~x~For that many lines
	Mov	#-1,PreLin 		;Clobber last known cursor
$GtCod::				;~x~Entry to reload the code overlay
	Return				;~x~And exit
	......
	.SbTtl	DOIT	- START SCREEN UPDATE
;++
;DOIT
;
;FUNCTIONAL DESCRIPTION:
;
;	START SCREEN UPDATE PROCESS
;
;INPUT:
;	R0 = 0
;
;OUTPUT:
;	(SP) -> chckbl	check buffer
;	2(SP) = P = BCP
;--
.Enable	LSB
DoIt:					;~x~
	Call	$ToStr			;~x~Setup buffer for output
.If NE,VT10$0!VT62$			;VT10$0
	Call	SetSlc			;~x~Setup for select mode display
.EndC					;VT10$0
	Mov	P,-(SP) 		;Save current pointer
	Tst	WrpLns			;Any wrapped lines on the screen??
	Bne	20$			;~x~Yes - forget quick check
	Tst	QukFlg			;Do we know the screen??
	Beq	20$			;~x~No - so look for lots of differences
	Cmp	BCP,LinPtr 		;Bcp behind us??
	Blo	20$			;~x~Take the long way
	Cmp	FCP,PlyEnd 		;Forward pointer at end of
					;Playground??
	Beq	20$			;~x~Yes so use the long way to fix
					;Screen
	Cmp	LinPtr,PlyGnd 		;Linptr at beginning of playground??
	Bhis	10$			;~x~Nope ok
	Cmp	BCP,PlyGnd 		;Did it move
	Blo	10$			;~x~No
	Mov	PlyGnd,LinPtr 		;Point to real text
10$:	Jmp	QukOut			;~x~Just output the differences
	..............
20$:	Jsr	R4,SeTJsr		;~x~Set up for
	 .Word	FTrans			;Counting lines
	Mov	FCP,R4			;Incase we are at start
	Mov	ZZ,R1			;Chars here
	Cmp	BCP,PlyGnd 		;Any chars??
	Blo	50$			;~x~Nope
;	Clr	r0			;set the argument
	Call	.VVV.V			;~x~Do 0l (start of cursor line)
	Mov	R1,R4			;Set start of the cursor line
	Mov	P,R1			;Use p for address in case
					;Special check for line term was used
	Cmp	R1,PlyGnd		;Any bkwplygnd??
	Blos	30$			;~x~Nope- skip subtract
	Sub	PlyGnd,R1		;Make count for backhalf of plygnd
	Br	40$			;~x~Ok to use
	...........
30$:	Clr	R1			;~x~Use zero
40$:	Mov	R1,-(SP)		;~x~Save for sub
	Mov	ZZ,R1 			;Get total size of text buffer
	Sub	(SP)+,R1		;And find size to end of buffer
	Bpl	50$			;~x~Count must be positive
	Mov	#77777,R1		;Use largest pos number
50$:	Call	DoText			;~x~Now count lines in that text
	Mov	V.Size,R0		;Set the screen's size
	Mov	NWatch,-(SP) 		;Get the standard cursor line number
	Beq	60$			;~x~Zero, make it valid
	Cmp	R0,(SP)			;Might be valid, check upper limit
	Bhi	70$			;~x~It is valid, use it
60$:	Mov	#16.,(SP)		;~x~Use a default standard if invalid
70$:	Sub	BuStrt,R0 		;~x~Calc line number of cursor line
	Cmp	R0,(SP)			;Should we use the calculated value?
	Blos	80$			;~x~Nope, use standard
	Mov	R0,(SP)			;Yep, use calculated
80$:	Mov	#ChCkBl,R2 		;~x~Get pointer to checking buffer
	Mov	R2,-(SP)		;Save start of the buffer
	Clr	(R2)			;Indicate no fudge movement initially
	Clr	-2(R2)			;No chars in buffer now
90$:	Tst	InitFl 			;~x~Do we know what's on the screen?
	Bpl	100$			;~x~Branch if not
	Inc	(R2)			;Set the flag word
100$:	Jsr	R4,SetJsr		;~x~Set up for
	 .Word	FTrans			;Counting lines
	.SbTtl	LINES	- COMPUTE LINES ON THE SCREEN
;++
;LINES
;
;FUNCTIONAL DESCRIPTION:
;
;while moving back to count lines on screen we will pickup a line to
;compare with the screen image to see if we can scroll (checkbuffer)
;we will pickup the first line regardless how short and the first larger
;than MXCHKC characters if we find one
;
;INPUT:
;	(SP) -> check buffer
;
;OUTPUT:
;	CHCKBL check buffer loaded
;--
.Enable	LSB
Lines:	Mov	#FChar,OutChr 		;~x~Reset output routine
	Mov	P,LinPtr 		;Save old line index
	Cmp	P,PlyGnd 		;Are we at start of buffer??
	Blos	TryMov			;~x~At top of page, quit for now
	Mov	#-1,R0			;Get to start of previous text line
	Call	.VVV.V			;~x~Using teco's mover
	Mov	R1,R4			;New 'p' is returned in r1, make copy
	Sub	LinPtr,R1 		;Make r1 contain
	Neg	R1			;Only chars in -1l
	Tst	BuStrt 			;Is this the first time through??
	Beq	30$			;~x~Yes, first time, don't buffer
					;The line
	Mov	(SP),R2			;Get checking buffer pointer
	TstB	(R2)			;Should we fill it?
	Beq	30$			;~x~No- we don't have a screen image
	Bpl	10$			;~x~Ok we should fill it first time
					;For sure
	Cmp	-2(R2),#MxChkC		;Enough chars in buffer?
	Bge	30$			;~x~Yes plenty
	Cmp	R1,-2(R2)		;Enough chars to be worthwhile?
	Ble	30$			;~x~No since we already have a line
					;Of some kind
10$:	Mov	R1,-2(R2)		;~x~Save the number of chars here
	Mov	#-1,(R2)+		;Else mark as used now
	Mov	R2,BuIndx 		;And set starting fill in pointer
	Mov	#CChar,OutChr 		; and change the output routine
	Mov	H.Size,R0		;R0 = Number of columns
	Mov	(PC)+,R3		;Use R3 for a data word
	 .Byte	<SPC>,<SPC>
20$:	Movb	R3,(R2)+		;~x~Blank the
	Sob	R0,20$			;~x~Whole buffer

30$:	Mov	BuStrt,SvStrt 		;~x~Save starting value
	Call	DoText			;~x~Format a line
	Mov	BuStrt,R0 		;Get finishing line number
	Tst	ChCkBl 			;Does checking buffer line
					;Need setting?
	Bpl	40$			;~x~Nope
	MovB	R0,ChCkBl+1 		;Yep, so save line number
40$:	Cmp	R0,2(SP)		;~x~Would we be at top?
	Blo	Lines			;~x~Branch if not
	Mov	SvStrt,BuStrt 		;Restore correct value

	.SbTtl	TRYMOV	- ATTEMPT TO SCROLL THE SCREEN
;++
;TRYMOV
;
;FUNCTIONAL DESCRIPTION:
;
;	Attempt to scroll the screen to match the new screen contents
;
;INPUT:
;	(SP) -> Check buffer
;
;OUTPUT:
;--
.Enable	LSB
TryMoV:	Mov	(SP)+,R2		;~x~Get checking buffer pointer
	TstB	(R2)+			;Did we fill it?
	Bge	Output			;~x~Nope
	MovB	(R2)+,R0		;Save the "bustrt" value
	Mov	BuStrt,R1 		;Get ending "bustrt" value
	Sub	R0,R1			;Calculate the buffered line number
	Mult	H.Size			;Find offset of the buffered line
	Mov	R1,(SP)			;And save it
	Mov	#MovTbl-2,R4		;Get the movement table
10$:	Tst	(R4)+			;~x~Skip over the unused move amount
	Cmp	R4,#MovTbE		;Are more moves possible?
	Bhis	Output			;~x~No, punt on it
	Mov	(SP),R1			;Yes, get the buffered line's offset
	Add	(R4)+,R1		;Build offset pointer for this try
	Cmp	R1,MapSiz 		;Is this offset out of the screen?
	Bhis	10$			;~x~Too far out, go try another move
	Add	MapSt,R1 		;Index to screen map
	Mov	R2,R3			;Set pointer to check buffer
	Mov	H.Size,R0		;And load a counter
20$:					;~x~

.If NE VT10$0 ! VT62$
	MovB	(R1)+,-(SP)		;Ignore select range when comparing
	BicB	#200,@SP		;Clear the bits in map image word
	CmpB	(SP)+,(R3)+		;Compare with check buffer
.IfF ;NE VT10$0 ! VT62$
	CmpB	(R3)+,(R1)+		;Match??
.EndC ;NE VT10$0 ! VT62$

	Bne	10$			;~x~No
	Sob	R0,20$			;~x~Yes, loop

	Mov	(R4)+,R1		;Total match!! get the movment amount
	Clr	R2			;Set cursor to column 0
	Mov	V.SzM1,BuStrt 		;Assume we are going up
	Mov	#LFSeq,R3		;Sequence to raise screen
	Mov	R1,R4			;Save that move count
	Beq	Output			;~x~No movement, so quit
	Bpl	30$			;~x~Assumption right
	Mov	#RevSeq,R3		;Sequence to lower screen
	Clr	BuStrt 			;Fix to lower screen
	Neg	R4			;Make count positive
30$:	Call	DoSeq			;~x~Position the screen
	Sob	R4,30$			;~x~The correct number of times
	Mov	MapSt,R2 		;Set pointer to start of map
	Mov	R2,R0			;Build pointer
	Add	MapSiz,R0		;To end of map
	Mov	(PC)+,R3		;Get some spaces
	 .Byte	<SPC>,<SPC>
	Mult	H.Size			;Calc offset to start move from
	Bmi	60$			;~x~Branch if to move internal map down
	Add	R2,R1			;Add in map base
40$:	MovB	(R1)+,(R2)+		;Move the data
	Cmp	R1,R0			;Did we move last data byte?
	Blo	40$			;~x~Branch if not
50$:	MovB	R3,(R2)+		;~x~Fill remainder with blanks
	Cmp	R2,R0			;Are we at end of table?
	Blo	50$			;~x~Branch if not
	Br	Output			;~x~Else done shifting
	..............
60$:	Add	R0,R1			;~x~Point to end of data to be moved
70$:	MovB	-(R1),-(R0)		;~x~Move the data
	Cmp	R1,R2			;Are we at the top?
	Bhi	70$			;~x~Branch if not
80$:	MovB	R3,-(R0)		;~x~Blank fill remainder
	Cmp	R0,R2			;Are we at top?
	Bhi	80$			;~x~Branch if not
	.SbTtl	OUTPUT	- OUTPUT SCREEN IMAGE
;++
;OUTPUT
;
;FUNCTIONAL DESCRIPTION:
;
;	Output screen image
;
;INPUT:
;	(SP) -> Check buffer
;	2(SP) = BCP = cursor position
;
;OUTPUT:
;--
.Enable	LSB
Output:	Tst	(SP)+			;~x~Junk the stack item
	Mov	SP,QukFlg		;Set for we know the screen
	Clr	WrpLns			;Set for no wrapped lines in the text
	.Br	QukOut

	.SbTtl	QUKOUT	- OPTIMISED SCREEN IMAGE OUTPUT
;++
;QUKOUT
;
;FUNCTIONAL DESCRIPTION:
;
;	Quick way to output screen image if we know no scrolling can
;	occur
;
;INPUT:
;	(SP) = BCP = cursor position
;
;OUTPUT:
;	Screen updated
;	Return from VWATCH
;--
QukOut:					;~x~Output if we know the screen
	Jsr	R4,SetJsr		;~x~Set up for
	 .Word	RTrans			;The real output
	Mov	LinPtr,R4 		;Get starting point of text
	Mov	PlyEnd,R1		;Get end of text
	Sub	FCP,R1			;PLYEND-FCP
	Cmp	BCP,PlyGnd 		;No backward text?
	Blo	10$			;~x~Nope
	Inc	R1			;+
	Add	BCP,R1			;BCP-LINPTR+1
	Sub	R4,R1			;
10$:	Tst	r1			;~x~check the count
	Bpl	20$			;~x~Pos- ok
	Mov	#77777,R1		;Use largest pos number
20$:	Mov	MapSt,BuIndx 		;~x~Init the index into the map
	Tst	InitFl 			;Do we know the state of the screen?
	Bmi	30$			;~x~Branch if yes
	Clr	R2			;Clear the column number
	Clr	@MapSt 			;Clobber the last copy of the map
	Mov	#-1,PreLin 		;Clobber last known cursor
30$:	Mov	(SP),P 			;~x~Finally refix pointer
	Mov	FCP,(SP)		;This is real cursor pos
	Mov	(SP),UnderC 		;Save position of under score
	Mov	V.SzM1,CurLin 		;Preset cursor at end of
	Mov	H.SzM1,CurChr 		;Screen
	Call	DoText			;~x~Now really update the screen
	Mov	CurLin,BuStrt 		;Set the line for cursor
	Mov	CurChr,R2 		;Set the column
	Call	SetCur			;~x~Move the cursor
	Mov	(SP)+,R0		;Get abs cursor location
	Cmp	BCP,PlyGnd 		;Is cursor at start of text?
	Blo	40$			;~x~Yes, cannot be after anything...
	CmpB	@BCP,#<CR>		;Immediately after a <cr>?
	Bne	40$			;~x~Nope
	Mov	#CurSeq,R3		;Yep, set fancy sequence
	Call	DoType			;~x~And output it
	ClrB	@CurAbs 		; but forget that location in the map
40$:	Mov	#-1,InitFl 		;~x~Now we know what's on the screen

.If NE,VT10$0!VT62$			;Clean up select range attribute

	Tst	SlcRng			;Attribute on?
	Beq	50$			;~x~Nope
	Mov	#SLoSeq,R3		;Turn it off
	Call	DoType			;~x~With the sequence
	Clr	SlcRng			;And say its off
50$:					;~x~

.EndC					;VT10$0

60$:	Call	$ToEnd			;~x~Flush output buffer
	Return				;~x~Finally we can exit
	......
	.SbTtl DOTEXT	- COMPUTE SCREEN CHARS FROM BUFFER
;++
;DOTEXT
;
;FUNCTIONAL DESCRIPTION:
;
;	Compute screen chars from buffer
;
;INPUT:
;	R1 = count of chars to process
;	R4 = address in buffer to start
;
;OUTPUT:
;;REGISTER USAGE:
;	R2 = column on line
;	R1 -> map
;	R4 -> chars in buffer
;--
.Enable	LSB
DoText:					;~x~
	Cmp	R4,PlyGnd		;Started at top of file??
	Bhis	10$			;~x~Nope ok
	Mov	FCP,R4			;Start- really at cursor
10$:	Mov	R1,-(SP)		;~x~Save the character count
	Br	90$			;~x~Initialize column counter
	...........			;And pointer
20$:	CmpB	(R4),#<CR>		;~x~Avoid sequence if overflow on <cr>
	Beq	70$			;~x~Branch if <cr>
	Mov	#SqOvr,R0		;Else set the overflow "character"

30$:	Inc	(SP)			;~x~Remember to get the character again
	Mov	R2,RtMost 		;Set highest column number
	Clr	R2			;Simulate carriage return
	Call	NewLin			;~x~Fix screen
	Bhis	160$			;~x~Branch if at bottom of screen
	Mov	SP,WrpLns		;Remember we had a wrapped line
	Call	@OutChr 		;~x~Output overflow "character"
	Mov	#<SPC>,R0		;Follow it with a <space>
40$:	Call	@OutChr 		;~x~Output character
50$:	Cmp	R4,UnderC 		;~x~Is this where the cursor belongs?
	Bne	60$			;~x~Branch if not
	Mov	R1,CurAbs 		;Save absolute position in map
	Mov	BuStrt,CurLin 		;Save the line number
	Mov	R2,CurChr 		;Save the column number
	Cmp	R2,H.Size 		;Is the column number illegal?
	Blo	60$			;~x~Nope
	Mov	H.SzM1,CurChr 		;Yep, so fix it already
60$:	Dec	(SP)			;~x~Knock down character count
	Bmi	150$			;~x~Branch if no more for end of screen
	Cmp	R2,H.SzM2 		;About to overflow?
	Bhis	20$			;~x~Branch if true
70$:	MovB	(R4)+,R0		;~x~Get a byte of text
	Mov	BCP,-(SP)		;Make address to check split
	Inc	@SP			;In no mans land
	Cmp	R4,(SP)+		;Time to switch buffer sides ?
	Bne	80$			;~x~Nope
	Mov	FCP,R4			;Start on second half
;>>> CHANGE FOR 8BIT (AND A LOT MORE TOO)
80$:	Bic	#^C177,R0		;~x~Clear garbage for 7 bit code
	Beq	50$			;~x~Br if null
	Cmp	R0,#<DEL>		;Is it <rubout>?
	Beq	130$			;~x~Branch if yes
	Cmp	R0,#<SPC>		;Is it special?
	Bhis	40$			;~x~Branch if not
	Cmp	R0,#<HT>		;Is it a <tab>?
	Beq	120$			;~x~Branch if it is
	Blo	130$			;~x~Branch if must be regular control
					;Character
	Cmp	R0,#<CR>		;Is char a <cr>?
	Bne	100$			;~x~Branch if not, reset column counter
	Cmp	R2,RtMost 		;Save right most column on line
	Blos	90$			;~x~Branch if not at it
	Mov	R2,RtMost 		;Save it for clearing remainder
90$:	Clr	R2			;~x~Reset column counter
	Mov	BuIndx,R1 		;Set pointer into map
	Br	50$			;~x~And continue
	...........
100$:	Bhi	130$			;~x~Branch if > <cr>, may be <esc>?
	Sub	#<LF>,R0		;R0=0 for <lf>, r0=1 for <vt>,
					;R0=2 for <ff>
	Beq	110$			;~x~Lf? yes- go home
	Inc	R0			;Make vt=2, ff=3

.IIf NE <SQFF-3>!<SQVT-2>,.ERROR 0;Definitions of sqff or sqvt are wrong

	Call	@OutChr 		;~x~Output the char
	Mov	R2,RtMost 		;Save right most column
	Clr	R2			;Simulate cr for vt and ff
110$:	Call	NewLin			;~x~On a blank line
	Bhis	160$			;~x~Done- end of screen
	Br	50$			;~x~Next char
	...........
;120$:	Mov	#SqNul,R0		;~x~The sequence for a null
;	Br	40$			;~x~Go display it
	...........
120$:	Mov	#<SPC>,R0		;~x~Out spaces to tab stop
	Call	@OutChr 		;~x~Output the character
	Bit	R2,#7			;At a tab stop?
	Beq	50$			;~x~Branch if so
	Cmp	R2,H.SzM2 		;Else about to overflow line?
	Blo	120$			;~x~Nope, loop
	Br	50$			;~x~Yes, quit
	...........
130$:	Mov	#SqEsc,-(SP)		;~x~Guess at <esc>, its a special code
	Cmp	R0,#<ESC>&77		;Good guess??
	Beq	140$			;~x~Yes, <esc> goes as "pi"
	Add	#100,R0			;No, put character into range
;>>> CHANGR FOR 8BIT
	Bic	#^C<177>,R0		;And mask it for safety
	Mov	R0,(SP)			;Save character
	Mov	#<G.Ctrl>,R0		;Print arrow
	Call	@OutChr 		;~x~Output the char
140$:	Mov	(SP)+,R0		;~x~Get the char back
	Br	40$			;~x~And continue
	...........
150$:	Cmp	R4,PlyEnd		;~x~At end of buffer now?
	Blo	160$			;~x~Nope
	Cmp	R2,H.Size 		;Yep, any room left on this line?
	Bhis	160$			;~x~Sorry, no room left
	Mov	#SqEOB,R0		;Room, set end of buffer "character"
	Call	@OutChr 		;~x~And output it
160$:	Tst	(SP)+			;~x~Junk the character counter

ClrEnd:	Mov	#EEOSeq,R3		;~x~Set eos sequence for blanking
	Mov	MapEnd,R0 		;Point to end of screen map
	Jmp	@OutBln 		;~x~Call blanker for rest of screen
	..............
	.SbTtl	NEWLIN	- PROCESS NEXT LINE OF SCREEN
;++
;NEWLIN
;
;FUNCTIONAL DESCRIPTION:
;
;	Process next line of screen
;
;	Remainder of line blanked
;	Next line to cursor blanked
;	BUINDX updated
;	BUSTRT = N lins on screen
;	On return BHIS if last line on screen done
;
;INPUT:
;
;OUTPUT:
;
;--
.Enable	LSB
NewLin:	Mov	R0,-(SP)		;~x~Save for later
	Mov	R2,-(SP)		;Also save column positin
	Mov	BuIndx,R0 		;Calculate end of
	Add	H.Size,R0		;Line pointer
	Mov	#ClnSeq,R3		;Set seq to clear only this line
	Call	@OutBln 		;~x~Erase the remainder of line
					;If anything
	Clr	RtMost 			;Clear it for new line
	Mov	R0,BuIndx 		;Update to new line on screen face
	Inc	BuStrt 			;Flag a new line done
	Mov	R0,R1			;Set new map pointer
	Tst	(SP)			;Get the column position
	Beq	20$			;~x~Branch if at column 0, normal case
	Cmp	BuStrt,V.Size 		;Already off the screen??
	Bhis	20$			;~x~Yes forget it
	Clr	R2			;No, start from column 0
	Mov	#<SPC>,R0		;And use spaces for blanking
10$:	Call	@OutChr			;~x~Output one blank
	Cmp	R2,(SP)			;Up to cursor yet??
	Blo	10$			;~x~Nope, continue
20$:	Mov	(SP)+,R2		;~x~Reset column position
	Mov	(SP)+,R0		;Get back flag for type of char
	Cmp	BuStrt,V.Size		;'BHIS' branches if at bottom
	Return				;~x~Return
	......
	.SbTtl	SETJSR	- SET CALL ADDRESSES FOR FUNCTIONS
;++
;SETJSR
;
;FUNCTIONAL DESCRIPTION:
;
;	Set call addresses for functions
;
;INPUT:
;	Jsr R4,SETJSR
;	.Word -> RTRANS or FTRANS  (real or fake translator table)
;
;OUTPUT:
;	Transfer addresses copied to table at OUTCHR
;--
.Enable	LSB
SetJsr:	Mov	#OutChr,R3 		;~x~Get address of first vector
	Mov	(R4)+,R2		;Get pointer to the table
10$:	Mov	(R2)+,(R3)+		;~x~Put in a new address
	Bne	10$			;~x~Loop through list
	Clr	(R3)+			;Clear "bustrt" also
	Rts	R4			;~x~Then exit
	.SbTtl	MULT	- MULTIPLY ROUTINE

;++
;MULT
;
;FUNCTIONAL DESCRIPTION:
;
;	Multiply by a constant
;
;INPUT:
;		Jsr R4,MULT
;		.Word ADDR
;	INPUTS:	R1 = multiplier
;		ADDR = multiplicand
;
;OUTPUT:
;	R1 = product
;--
.Enable	LSB
MULT:	Mov	R2,-(SP)		;~x~Save a working register
	Mov	(R4)+,R2		;Get address offset
	Mov	@R2,R2			;Get multiplicand
	Mov	R1,-(SP)		;Factor
	Clr	R1			;Clear answer
10$:	Asr	R2			;~x~Low bit to c
	Bcc	20$			;~x~Add?
	Add	@SP,R1			;Yes -
20$:	Asl	@SP			;~x~Shift multiplier
	Tst	R2			;Done?
	Bne	10$			;~x~No - next bit
	Tst	(SP)+			;Dump factor
	Mov	(SP)+,R2		;Restore working reg
	Tst	R1			;Set cc's on result
	Rts	R4			;~x~Return
	.SbTtl	VTBLNK	- BLANK SCREEN IMAGE
;++
;VTBLNK
;
;FUNCTIONAL DESCRIPTION:
;
;	Blank screen image
;
;INPUT:
;	R0=end address
;	R2=column
;
;OUTPUT:
;
;
;REGISTER USAGE:
;	R1=screen image address
;	R2=col to make address
;	R4=clear via eos flag
;--
.Enable	LSB
VtBlnk:					;~x~
;>>>savreg?
	Mov	R1,-(SP)		;Save
	Mov	R2,-(SP)		;Work
	Mov	R4,-(SP)		; regs
	Mov	R0,-(SP)		;Address to stop at
	Mov	(PC)+,R0		;Get some spaces
	 .Byte	<SPC>,<SPC>
	Cmp	R2,RtMost 		;Check for rightmost used column
	Bhis	10$			;~x~R2 is right
	Mov	RtMost,R2 		;Fix r2
10$:	Mov	BuIndx,R1 		;~x~Get address of current line
	Add	R2,R1			;Point to where we are in buffer
	Mov	#-1,R4			;Set flag to clear eos if needed
20$:	Cmp	R1,(SP)			;~x~Are we at end yet?
	Bhis	60$			;~x~Branch if yes
	Bit	R1,#1			;On word boundary?
	Beq	40$			;~x~Branch if yes
	CmpB	R0,(R1)+		;Is this a blank already?
	Beq	20$			;~x~Branch if yes
	MovB	R0,-1(R1)		;Set it to a blank
	Inc	R4			;Do we have to clear end of screen?
	Bne	20$			;~x~Branch if already done
30$:	Call	DoSeq			;~x~Clear line or screen
	Br	20$			;~x~Continue the clear loop
	...........
40$:	Cmp	R0,(R1)+		;~x~Are these blanks already?
	Beq	50$			;~x~Yes
	Mov	R0,-2(R1)		;Set last two to blanks
	Inc	R4			;Do we have to clear to eos?
	Beq	30$			;~x~Branch if we need to
50$:	Cmp	R1,(SP)			;~x~Are we at end yet?
	Blo	40$			;~x~Not yet
60$:	Mov	(SP)+,R0		;~x~Restore the limit
	Mov	(SP)+,R4		;Restore
	Mov	(SP)+,R2		;Work
	Mov	(SP)+,R1		; regs
	Return				;~x~Exit
	......
	.SbTtl	VTCHAR	- OUTPUT A CHAR TO SCREEN FOR REAL
;++
;VTCHAR
;
;FUNCTIONAL DESCRIPTION:
;
;	Write a character to the screen for real
;
;INPUT:
;	R0 = character
;	R4 -> screen map
;
;OUTPUT:
;--
.Enable	LSB
VtChar:					;~x~
.If NE,VT10$0!VT62$			;Select mode display
	Cmp	R4,SlcLow		;Inside select range (r4 = char adr)
	Blo	10$			;~x~Nope
	Cmp	R4,SlcHih		;Beyond?
	Bhi	10$			;~x~Yes
;>>> CHANGE FOR 8BIT
	Bis	#200,R0			;Set magic bit
10$:					;~x~
.EndC					;Vt10$0
	CmpB	R0,(R1)+		;Are characters the same??
	Beq	FChar			;~x~Branch if yes, don't send it!

;
;	now we are going to optimize the output of direct cursor addressing
;	by seeing if we can output characters quicker than the move.
;

	Cmp	BuStrt,PreLin		;Are the last line and the
					;Target line the same
	Bne	50$			;~x~No- we must use cursor addressing
	Mov	R2,-(SP)		;Work space of the column number
	Sub	PreCol,@SP		;Make a diff in columns
	Beq	30$			;~x~None- ok no change
	Cmp	@SP,#CL.Lmt		;Check with the column limit
	Bhi	40$			;~x~Use cursor addrssing
	Mov	R1,-(SP)		;Save work regs
	Mov	R0,-(SP)		;
	Sub	4(sp),r1		;adjust address for output
	Dec	R1			;And back one more
20$:	MovB	(R1)+,R0		;~x~Get a char to output
	Call	70$			;~x~Output old character
	Dec	4(SP)			;Count them
	Bgt	20$			;~x~Til done
	Mov	(SP)+,R0		;Restore working regs
	Mov	(SP)+,R1
	Mov	R2,PreCol 		;New values
	Mov	BuStrt,PreLin 		;And for line
30$:	Tst	(SP)+			;~x~Dump the stuff
	Br	60$			;~x~
	...........
40$:	Tst	(SP)+			;~x~Dump col diff

50$:	Call	SetCur			;~x~Position the cursor
60$:	MovB	R0,-1(R1)		;~x~Save the character

	Call	70$			;~x~Output character
	Inc	PreCol 			;Indicate cursor moved 1 to the right
	.Br	Fchar
;
;	Fake output of one char
;

FChar:	Inc	R2			;~x~Advance column number
	Return				;~x~Then exit
	......
;
;Check for select range and special characters and output
;character accordingly.
;

70$:					;~x~
.If NE,VT10$0!VT62$	;If VT100
	Call	Video			;~x~Make sure of the video attribute
					;  for select
.EndC		;NE,VT10$0
	Cmp	R0,#SeqN		;Check for special character
	Bhi	80$			;~x~Br if not
	Asl	R0			;Else make offset
	Mov	SeqS(R0),R3		;Get code
;>>>callr?
	Call	DoType			;~x~Write sequence
	Return				;~x~
	......

80$:	TypeBf				;~x~Type single character
	Return				;~x~
	......
;++
;CCHAR
;
;FUNCTIONAL DESCRIPTION:
;
;	SAVE CHAR IN CHECK BUFFER
;
;INPUT:
;	R0 = CHAR
;	R1 -> CHECK BUFFER
;	R2 = COLUMN
;
;OUTPUT:
;	NORMAL CHAR => CHAR SAVED
;	SPECIAL CHAR => NOT FILLED
;--
.Enable	LSB
CChar:	Inc	R2			;~x~Advance column number
	MovB	R0,(R1)+		;Save the character
	Bgt	10$			;~x~Normal, continue
	Neg	ChCkBl 			;Special, say this line not filled

;
;	Fake blanker reset output routine to fake output of chars
;

FBlnk:	Mov	#FChar,OutChr 		;~x~Reset the output routine
10$:	Return				;~x~Then return
	......

.Dsabl	LSB
	.SbTtl	VIDEO	- SETUP VIDEO ATTRIBUTE FOR SELECT RANGE
;++
;VIDEO
;
;FUNCTIONAL DESCRIPTION:
;
;	Setup video attribute
;
;INPUT:
;	R0 = CHAR + 200 if in select range
;	SLCRNG not zero if range on
;
;OUTPUT:
;	SLCRNG set and terminal in correct mode
;	200 bit in char clear
;--

.If NE,VT10$0!VT62$			;Select range display

.Enable	LSB
Video:	TstB	R0			;~x~Check the char for in range
	Bpl	10$			;~x~Char in range?- no
;>>>CHANGE FOR 8BIT
	Bic	#^C177,R0		;Clear range bit
	Tst	SlcRng			;Range on?
	Bne	30$			;~x~Yes- leave it on
	Mov	SP,SlcRng		;No- make nonzero to remember its on
	Mov	#SlcSeq,R3		;Select range on to terminal
	Br	20$			;~x~Ok carry on
	...........
10$:	Tst	SlcRng			;~x~Select range on?
	Beq	30$			;~x~Nope- leave it that way
	Clr	SlcRng			;Now its off
	Mov	#SlOSeq,R3		;Sequence for off
20$:	Call	DoType			;~x~Do the  required sequence
30$:	Return				;~x~
	......

.Dsabl	LSB
.EndC					;VT10$0
	.SbTtl	SETCUR	- SETUP CURSOR POSITION
;++
;SETCUR
;
;FUNCTIONAL DESCRIPTION:
;
;	Setup cursor position
;	Set cursor to next position of a change
;
;INPUT:
;	R2=current column
;	BUSTRT= current line
;
;OUTPUT:
;	PRECOL=new column
;	PRELIN=new line
;--
.Enable	LSB
SetCur:	Mov	R0,-(SP)		;~x~Save r0
	Mov	BuStrt,R0 		;Get line number
	Cmp	R0,PreLin 		;Is this the right line?
	Bne	10$			;~x~Branch if not, must set cursor
.If EQ,VT10$0				;NOT IF VT100
	Mov	V.Size,R0 		;Set to not vertically position
					;Cursor this is to help stop vt52
					;From flicker
.EndC					;VT10$0
	Cmp	R2,PreCol 		;Are we at right cursor position?
	Beq	30$			;~x~Branch if yes, don't move it
10$:	Mov	BuStrt,PreLin 		;~x~Save cursor pos on screen
	Mov	R2,PreCol 		;Both line and column
	Mov	R3,-(SP)		;Save r3 over sequences
	Mov	#DirSeq,R3		;Point to direct cursor address code
	Call	DoType			;~x~And output it
.If EQ,VT10$0
	Add	#40,R0			;Adjust line number
	TypeBf				;~x~And output it
	Mov	R2,R0			;Now set column number
	Add	#40,R0			;Adjust column number
	TypeBf				;~x~And output it
.IfF					;VT10$0
	Call	OutPrm			;~x~Output a ansi parameter
	Mov	#<A.SEP>,R0
	TypeBf				;~x~Separator
	Mov	R2,R0			;Column number
	Call	OutPrm			;~x~Output as parameter
	Mov	#<A.CUP>,R0		;Final character
	TypeBf				;~x~
.EndC					;VT10$0
20$:	Mov	(SP)+,R3		;~x~Restore r3
30$:	Mov	(SP)+,R0		;~x~Restore r0
	Return				;~x~And exit
	......
	.SbTtl	DOSEQ	- OUTPUT A ESC SEQUENCE
;++
;DOSEQ
;
;FUNCTIONAL DESCRIPTION:
;
;	Output a esc seq
;
;INPUT:
;	R3 -> esc seq
;
;OUTPUT:
;--
DoSeq:	Call	SetCur			;~x~Set up the cursor
DoType:	Mov	R0,-(SP)		;~x~Save r0
	Mov	R3,-(SP)		;And r3
40$:	MovB	(R3)+,R0		;~x~Get a character
	AslB	R0			;Is it the ending 200?
	Beq	20$			;~x~Yes
	Asr	R0			;No, restore character
	TypeBf				;~x~Else buffer it
	Br	40$			;~x~And continue
	...........
.Dsabl	LSB
	.SbTtl	OUTPRM	- OUTPUT AN ANSI PARAMETER
;++
;OUTPRM
;
;FUNCTIONAL DESCRIPTION:
;
;	Output ANSI esc parameter
;
;INPUT:
;	R0 = binary parameter
;
;OUTPUT:
;	R0 destroyed
;--

.If NE,VT10$0				;VT10$0
.Enable	LSB
OutPrm:	Tst	R0			;~x~Check value
	Beq	30$			;~x~No parameter for zero
	Inc	R0			;Lines and columns start at 1
	MovB	PosTbl(R0),-(SP) 	;Get the table byte
	CmpB	R0,#100.		;Beyond table?
	Blo	10$			;~x~Nope
	Sub	#100.,R0		;Yep adjust for table size
	MovB	PosTbl(R0),@SP		;Get the real byte
	Neg	R0			;Make -1 to -9 for neat check
	Mov	R0,-(SP)		;Save for later check
	MovB	#'1,R0			;Get the leading digit
	TypeBf				;~x~Output it
	Cmp	(SP)+,#-9.		;101-109 get special check
	Blo	10$			;~x~Unsigned check br on zero (100)
	Mov	#'0,R0			;Output middle zero
	TypeBf				;~x~Output char
10$:	MovB	@SP,R0			;~x~Get the next two
	Call	20$			;~x~Output low order
	MovB	(SP)+,R0		;Get the high order
	Asr	R0			;Move to low nibble
	Asr	R0
	Asr	R0			;By shifts
	Asr	R0
20$:	Bic	#^C17,R0		;~x~Get lower nibble
	Beq	30$			;~x~No nibble to output
	Add	#'0-1,R0		;Make a digit in ascii
	TypeBf				;~x~Output it
30$:	Return				;~x~
	......
.EndC					;VT10$0
	.SbTtl	POSTBL	- TABLE OF POSITION PARAMETERS
;++
;POSTBL
;
;DESCRIPTION:
;
;	Table of position parameters for ansi esc sequences
;	Use of this table avoids having to do a decimal conversion
;
;	Table encodes two digits of a parameter in the range
;	1-99 using one byte for each encoding.
;
;	Byte is in following format
;
;	BIT			MEANING
;	0-3		next digit 0-9 +1
;	4-7		next digit 0-9 or zero if none
;--

.If NE,VT10$0				;VT10$0

PosTbl:					;~d~
.Dsabl	CRF				;No cref of the symbols
	.Byte	1*20+1			;Special for 100 value
	$$NUM=1
.Rept	99.
	$$HIGH=$$NUM/10.
	$$LOW=$$NUM-<$$HIGH*10.>
  .If EQ,$$High
	.Byte	$$LOW+1
  .IfF
	.Byte	$$LOW+1*20+$$HIGH+1
  .EndC
	$$NUM=$$NUM+1
.EndR
.Enable	CRF

.EndC					;VT10$0
	.SbTtl HV.FIX	- FIX UP LINES AND COLUMNS
;++
;HV.FIX
;
;FUNCTIONAL DESCRIPTION:
;
;	Fix us up for a screen size
;
;INPUT:
;	R1 = H.SIZE, columns
;	R2 = V.SIZE, lines
;
;OUTPUT:
;	C set if too large
;	screen size parameters set
;--
.Enable	LSB
HV.Fix::				;~x~
;>>>	savreg?
	Mov	R3,-(SP)		;Save r1-r3 for work space
	Mov	R2,-(SP)
	Mov	R1,-(SP)
	Cmp	R1,#H.Max		;Too large?
	Bhi	50$			;~x~Yep
	Cmp	R2,#V.Max		;Too large?
	Bhi	50$			;~x~Yep

;	Cmp	R2,#V.Max		;full screen?
	Bne	10$			;~x~Nope
	Mov	#V.Max/3*2,NWatch 	;Initialize line of cursor
	Br	20$			;~x~Ok
	...........
10$:	Mov	R2,-(SP)		;~x~Save v.size
	Asr	R2			;Use lines/2
	Inc	R2			;Plus one
	Mov	R2,NWatch		;As the cursor line
	Mov	(SP)+,R2		;Restore v.size
20$:					;~x~
	Mov	R1,H.Size 		;Columns
	Asr	R1			;Columns/2
	Mov	R1,H.Wds 		;Words per line
	Asl	R1			;Back to columns
	Dec	R1
	Mov	R1,H.SzM1 		;Columns-1
	Dec	R1
	Mov	R1,H.SzM2 		;Columns-2
	Mov	R2,V.Size 		;Lines
	Dec	R2
	Mov	R2,V.SzM1 		;Lines-1
;
;	build table for trymov to guess scroll count
;

	Inc	R2			;Back to lines
	Asr	R2			;Lines/2
	Mov	@SP,R1			;Restore columns
	Mov	#MovTbl,R3		;Build table to guess moves
	Clr	(R3)+			;Start with zero guess
	Clr	(R3)+			;And scroll count of zero
	Mov	#1,-(SP)		;Counter
30$:	Mov	R1,(R3)+		;~x~Guess next line
	Mov	@SP,(R3)+		;Scroll count
	Neg	R1			;Guess back one line
	Mov	R1,(R3)+
	Mov	@SP,(R3)		;Scroll count
	Neg	(R3)+			;Is minus
	Neg	R1			;Make plus again
	Add	2(SP),R1		;One line farther out
	Inc	@SP			;Scroll count one more
;>>>sob
	Dec	R2			;Till all lines done
	Bgt	30$			;~x~Back to make more

;
;	compute and save the size and end of map area
;

	Mov	H.Size,r1		;columns
	Mult	V.Size			;Times lines
	Mov	R1,MapSiz		;Save the size of the map
	Add	MapSt,R1		;Base
	Mov	R1,MapEnd		;Addr of end of map

	Tst	(SP)+			;Dump the scroll count
.If NE,VT10$0!VT62$
	Clr	SlcRng			;Init select range rememberance
.EndC					;Vt10$0
;	Clc				;no error
40$:	Mov	(SP)+,R1		;~x~Restore regs
	Mov	(SP)+,R2
	Mov	(SP)+,R3
	Return				;~x~
	......
50$:	Sec				;~x~Return error
	Br	40$			;~x~
	...........
	.SbTtl	SETSLC	- SETUP SELECT RANGE DISPLAY
;++
;SETSLC
;
;FUNCTIONAL DESCRIPTION:
;
;	Handling of select range display
;
;the select range is to be marked on the screen by a video attribute.
;reverse video is used since it is one that will work somehow even in the
;Basic machine (VT100 without advanced video board)
;
;INPUT:
;
;SELECT DATA
;
;GLOBAL DATA
;	SLCTC(+2)	select range low-high double precision
;			plus count means chars to left of cursor (right range)
;			minus count means chars to right of cursor
;			(left range)
;	SLCTQ		nonzero for select range enabled
;
;LOCAL DATA
;	SLCRNG		nonzero if terminal is in select range mode
;	SLCLOW		low memory address of select range in playground
;	SLCHIH		high memory address of range
;
;	If SLCTC is plus for right range
;		SLCLOW	= BCP-SLCTC+1
;		SLCHIH	= BCP
;
;	If SLCTC is minus for left range
;		SLCLOW	= FCP
;		SLCHIH	= FCP-SLCTC
;
;OUTPUT:
;	SLCLOW, SLCHIH setup properly
;--
.If NE,VT10$0!VT62$			;VT10$0
.Enable	LSB
SetSlc:	Mov	R1,-(SP)		;~x~Save some working regs
	Mov	R2,-(SP)
	Mov	#-1,SlcLow		;Assume an illegal address
	Clr	SlcHih
	Tst	SlctQ			;Select mode on?
	Beq	50$			;~x~Nope
	Mov	FCP,R1			;Setup working regs
	Mov	R1,R2
	Tst	SlctC+2			;Which direction?
	Beq	20$			;~x~Right
	Bgt	30$			;~x~Right range too large
	Inc	R1			;Advance beyond fcp for fudge
	Cmp	SlctC+2,#-1		;Ok or too big?
	Bne	10$			;~x~Too big?
	Cmp	SlctC,#-3000. 		;Too big?
	Blo	10$			;~x~Too big
	Sub	SlctC,R2		;Adjust high address
	Br	40$			;~x~Ok
	...........
10$:	Mov	#-1,R2			;~x~Set high address
	Br	40$			;~x~
	...........
20$:	Tst	SlctC			;~x~Any real range?
	Beq	50$			;~x~Nope
	Cmp	SlctC,#3000. 		;It the range off screen?
	Bhi	30$			;~x~Yes
	Mov	BCP,R1			;This select range does not include
					;Fcp but leave in on so bcp char will
					;Show fudge
	Sub	SlctC,R1		;Make low address
	Inc	R1			;+1
	Inc	R1			;For a fudge
	Br	40$			;~x~Carry on
	...........
30$:	Clr	R1			;~x~Nope
40$:	Mov	R1,SlcLow		;~x~Save stuff
	Mov	R2,SlcHih
50$:	Mov	(SP)+,R2		;~x~Restore regs
	Mov	(SP)+,R1
	Return				;~x~
	......
.Dsabl	LSB
.EndC					;VT10$0
	.SbTtl .VVV.V	- MOVE ROUTINE
;++
;.VVV.V
;
;FUNCTIONAL DESCRIPTION:
;
;	Move routine that does not really move
;	Position cursor for analysis of previous line of text buffer
;
;INPUT:
;	R0 = 0 -> R1-> beginning of line
;	R0 = -N -> R1 -> beginning of n th previous line
;	R0 > 0 -> signal system error
;	P -> address of last line
;
;OUTPUT:
;	R1 = address of previous line
;	P updated also
;--
.Enable	LSB
.VVV.V:	Tst	R0			;~x~Check argument
	Bgt	60$			;~x~System error
	Mov	P,R1			;Get address to start
	Tst	R0			;Is it 0l first time
	Beq	50$			;~x~Yes- special check
10$:	Cmp	R1,PlyGnd		;~x~Start of buffer??
	Blos	40$			;~x~Yes- stop
	CmpB	-1(R1),#<LF>		;Line term??
	Blo	20$			;~x~Nope
	CmpB	-1(R1),#<FF>		;Inclusive
	Blos	30$			;~x~Hit one
20$:	Dec	R1			;~x~Backup
	Br	10$			;~x~And keep looking
	...........
30$:	Inc	R0			;~x~Count lines
	Ble	20$			;~x~Not yet
40$:	Mov	R1,P			;~x~Back to pointer
	Return				;~x~
	......
50$:	Cmp	R1,PlyGnd		;~x~Bcp at start?
	Blos	40$			;~x~Yes
	MovB	@R1,R0			;Check for line term
	CmpB	R0,#<LF>		;At 0l already?
	Blo	10$			;~x~Nope
	CmpB	R0,#<FF>		;If so pass fcp
	Bhi	10$			;~x~As start of line
	Inc	R1			;Point bcp one more
	Mov	R1,P			;Save as p pointer as fudge
	Mov	FCP,R1			;To start line properly
	Return				;~x~And not cause screen screwup
	......
60$:					;~x~
;+
;ERROR

	ERROR	<Bad call to .VVV.V>,F	;~x~
;Logic error in program
;-
	Jmp	$Fatal			;~x~Exit very soon
	..............
.Dsabl	LSB


	.End