.TITLE	DPY
PACKAGE TO ALLOW NICE UPDATING ROUTINES
FROM DIB'S DPY PACKAGE

.LIBRARY	@DPYDEF@
DPY$TRMDEF

BUFSIZ=200

.SBTTL	DATA BASE

.PSECT	DPY$DATA,RD,WRT,NOEXE

URLIN:	.BLKL	1		;CURRENT LINE WE ARE IN

URCOL:	.BLKL	1		;CURRENT COLUMN WE ARE IN

IN:	.BLKL	2		;SEE BELOW
.=WIN
INLIN:	.BLKW	1
AXLIN:	.BLKW	1
INCOL:	.BLKW	1
AXCOL:	.BLKW	1

CREEN:	.BLKB	60*150		;ASSUME BIG TERMINAL

PYTAB:	.LONG	FUNINI		;INITIALIZATION FUNCTION
.LONG	FUNDPY		;UPDATE DISPLAY
.LONG	FUNWIN		;SET WINDOW
.LONG	FUNSTR		;STRING OUTPUT FUNCTION
.LONG	FUNCHR		;CHARACTER OUTPUT FUNCTION
.LONG	FUNLOC		;RETURN LOCATION FUNCTION
.LONG	FUNTAB
.LONG	FUNTTY		;FORCE OUTPUT
.LONG	FUNREF		;DO REFRESH
MAXUUO=<.-DPYTAB>/4	;MAX CHMU ARG

RMTAB:	.LONG	VT52		;VT52 IS DEFAULT
.LONG	VT100
.LONG	I100
.LONG	ADM3A
.LONG	VT100D		;DUMB VT100 (NO ADDRESSING, FOR SHOW)
.LONG	HP2645
.LONG	HZ1500		;HAZELTINE 1500
.LONG	LA120		;HARD COPY "DPY"
MAXTRM=<.-TRMTAB>/4

.MACRO	TT	NAME,?L1
.SAVE_PSECT
.PSECT	TTNAM,RD,NOWRT,NOEXE
1:	.ASCIC/'NAME'/
.RESTORE_PSECT
.LONG	L1
.LONG	DPY$C_'NAME'
.ENDM

TTAB:	TT	VT52
TT	VT100
TT	VT100D
TT	I100
TT	ADM3A
TT	HP2645
TT	HZ1500
TT	LA120
OSB:	.BLKQ	1

PYCHN::
.BLKW	1

TDEV:	.ASCID/TT/

RMPTR:	.BLKL	1		;POINTER INTO TRMTAB

RMBUF:	.BLKB	BUFSIZ

DRSUM:	.BLKL	1		;SUM OF # CHARS TO ADDRESS FOR CURRENT TERMINAL

UFPTR:	.BLKL	1		;POINTER INTO TRMBUF

TABMSK:
.REPEAT 20
.BYTE	^X01
.ENDR

ABMSK:	.BLKB	20

PY$FLAGS:
.BLKL	1
DPY$V_TAB=0		;PROCESSING A TAB
DPY$M_TAB=1
DPY$V_REF=1		;DO REFRESH
DPY$M_REF=2
DPY$V_IWIN=2		;USING IMPLICIT WINDOW
DPY$M_IWIN=4
DPY$V_OKUP2=3		;OK TO UPDATE TWICE
DPY$M_OKUP2=8
DPY$V_LINCLR=4		;IN A CLR LINE SEQUENCE
DPY$M_LINCLR=16
DPY$V_FRMCLR=5		;IN A CLR FORM SEQUENCE
DPY$M_FRMCLR=32

PYEFN:	.BLKL	1

TFNTB:	.LONG	NULTTY
.LONG	HOMTTY
.LONG	CLRTTY
.LONG	BOTTTY

TYBUF:	.BLKB	300

BUF:	.ASCII/Terminal type: /
PBUFL=.-PBUF

RMCHR:	.BLKQ	1

.SBTTL	TERMINAL CONTROL BLOCKS

.PSECT	DPY$TRM,RD,NOWRT,NOEXE

T52:
TTY	-
	LINES=24,-
	COLUMNS=80,-
	EATCHR=SPACE,-
	LEFT=<<^O10>>,-
	RIGHT=<<ESC>/C/>,-
	UP=<<ESC>/A/>,-
	DOWN=<<ESC>/B/>,-
	HOME=<<ESC>/H/>,-
	CLEAR=<<ESC>/H/<ESC>/J/>,-
	EOL=<<ESC>/K/>,-
	EOF=<<ESC>/J/>,-
	ADR1=<<ESC>/Y/>,-
	ADR2=<//>,-
	ADR3=<//>,-
	XOFF=<^O37>,-
	YOFF=<^O37>

T100:	TTY	-
	FLAGS=TRM$M_ASCII,-
	LINES=24,-
	COLUMNS=132,-
	EATCHR=SPACE,-
	LEFT=<<BSP>>,-
	RIGHT=<<ESC>/[C/>,-
	UP=<<ESC>/[A/>,-
	DOWN=<<ESC>/[B/>,-
	HOME=<<ESC>/[H/>,-
	CLEAR=<<ESC>/[H/<ESC>/[J/>,-
	EOL=<<ESC>/[K/>,-
	EOF=<<ESC>/[J/>,-
	ADR1=<<ESC>/[/>,-
	ADR2=<<SEMI>>,-
	ADR3=</H/>


100:	TTY	-
	FLAGS=<TRM$M_REVERSE>,-
	CFLAGS=<TRM$M_C_ZEROBX!TRM$M_C_ZEROBY>,-
	LINES=24,-
	COLUMNS=80,-
	EATCHR=SPACE,-
	LEFT=<<BSP>>,-
	RIGHT=<<ESC>/C/>,-
	UP=<<ESC>/A/>,-
	DOWN=<<ESC>/B/>,-
	HOME=<<ESC>/H/>,-
	CLEAR=<<FF>>,-
	EOL=<<ESC>/K/>,-
	EOF=<<ESC>/J/>,-
	ADR1=<<ESC>/f/>,-
	XOFF=<^O40>,-
	YOFF=<^O40>



DM3A:
TTY	LINES=24,-
	COLUMNS=80,-
	CFLAGS=<TRM$M_C_ZEROBX!TRM$M_C_ZEROBY>,-
	EATCHR=SPACE,-
	LEFT=<<BSP>>,-
	RIGHT=<<FF>>,-
	UP=<<VT>>,-
	DOWN=<<LF>>,-
	HOME=<<^O36>>,-
	CLEAR=<<^O32>>,-
	XOFF=<^O40>,-
	YOFF=<^O40>,-
	ADR1=<<ESC>/=/>

T100D:	TTY	-
	FLAGS=TRM$M_ASCII,-
	LINES=24,-
	COLUMNS=132,-
	EATCHR=SPACE,-
	LEFT=<<BSP>>,-
	RIGHT=<<ESC>/[C/>,-
	UP=<<ESC>/[A/>,-
	DOWN=<<ESC>/[B/>,-
	HOME=<<ESC>/[H/>,-
	CLEAR=<<ESC>/[H/<ESC>/[J/>,-
	EOL=<<ESC>/[K/>,-
	EOF=<<ESC>/[J/>

P2645:
TTY	-
	LINES=24,-
	COLUMNS=79,-
	EATCHR=SPACE,-
	LEFT=<<^O10>>,-
	RIGHT=<<ESC>/C/>,-
	UP=<<ESC>/A/>,-
	DOWN=<<ESC>/B/>,-
	HOME=<<ESC>/H/>,-
	CLEAR=<<ESC>/H/<ESC>/J/>,-
	EOL=<<ESC>/K/>,-
	EOF=<<ESC>/J/>

Z1500:
TTY	LINES=24,-
	COLUMNS=80,-
	FLAGS=<TRM$M_REVERSE>,-
	CFLAGS=<TRM$M_C_ZEROBX!TRM$M_C_ZEROBY>,-
	EATCHR=SPACE,-
	LEFT=<<BSP>>,-
	RIGHT=<<^O20>>,-
	UP=<<ALT><FF>>,-
	DOWN=<<ALT><VT>>,-
	HOME=<<ALT><^O22>>,-
	CLEAR=<<ALT><^O34>>,-
	ADR1=<<ALT><^O21>>

A120:
TTY	LINES=66,-
	COLUMNS=132,-
	EATCHR=SPACE,-
	LEFT=<<BSP>>,-
	RIGHT=<<SPACE>>,-
	UP=<<SPACE>>,-			;NOT REAL BUT NOT USED
	DOWN=<<LF>>,-
	HOME=<<FF>>,-
	CLEAR=<<FF>>

.SBTTL	DISPATCHER

THIS PART IS THE TRAP FOR THE CHMU INSTRUCTION
WE DISPATCH TO THE PROPER ROUTINE BASED ON THE CMU CODE

.PSECT	DPY$CODE,RD,NOWRT,EXE

PY$DISPATCH::
MOVL		(SP)+,R0		;GET INDEX TO CODE
BLSS		ILLCALL			;ILLEGAL
CMPL		R0,#MAXUUO		;MAX CALL
BGTR		ILLCALL
MOVAL		@TRMPTR,R1		;LOAD POINTER
MOVL		DPYTAB[R0],R0		;GO TO ROUTINE
JSB		(R0)
REI					;RETURN

LLCALL:
MOVL		#SS$_ILLSER,R0		;ILLEGAL SERVICE CALL
REI

.SBTTL	INITIALIZATION ROUTINE
ROUTINE CALLED TO INITIALIZE DPY DATA BASE
ARGUMENT, IF ANY, IS TERMINAL TYPE (BY VALUE)

FIRST THE SERVICE CALL:

.ENTRY	DPY$INI,^M<R2,R3,R4,R5,R6,R7>

CHMU		#0
RET

UNINI:
$ASSIGN_S	CHAN=DPYCHN,DEVNAM=TTDEV
PUSHAL		DPYEFN
CALLS		#1,LIB$GET_EF
$QIOW_S		EFN=DPYEFN,-
		CHAN=DPYCHN,FUNC=#IO$_SENSEMODE,-
		P1=TRMCHR,P2=#8
CLRL		R6		;SET DEFAULT TERMINAL TYPE
TSTL		(AP)		;ANY ARGS?
BEQL		DODEF		;NO
MOVL		4(AP),R6	;GET TYPE
BGEQ		10$		;ILLEGAL TERMINAL TYPE
BSBW		ASKTRM		;IMPLIES ASK FOR IT0$:	MNEGL		#1,-(SP)	;ASSUME FOREIGN TERMINAL
CMPL		R6,#MAXTRM	;MAXIMUM TERMINAL TYPE
BGTR		DODEF1		;ASSUME FOREIGN TYPE
ODEF:	MOVL		R6,(SP)
MOVL		TRMTAB[R6],R6	;POINT TO TERMINAL TYPE
ODEF1:	MOVL		R6,TRMPTR	;SAVE
CLRW		MINLIN		;CLEAR MINIMUM ROW
MOVW		TRM$W_MAXLIN(R6),MAXLIN	;SET MAXIMUM
CLRW		MINCOL		;MINIMUM COLUMN
MOVW		TRM$W_MAXCOL(R6),MAXCOL
MOVC5		#0,SCREEN,TRM$B_EATCHR(R6),#60*150,SCREEN ;CLEAR SCREEN
MOVZBL		TRM$T_ADR1(R6),R2	;COMPUTE ADRSUM
MOVZBL		TRM$T_ADR2(R6),ADRSUM
ADDL2		R2,ADRSUM
MOVZBL		TRM$T_ADR3(R6),R2
ADDL2		R2,ADRSUM	;ALL OF THEM
ADDL2		#2,ADRSUM	;INCLUDE ADDRESSING CHARS
CLRL		CURLIN
CLRL		CURCOL		;START AT (0,0)
MOVC3		#20,DTABMSK,TABMSK
MOVZBL		TRM$T_HOMCLR(R6),R0
$QIOW_S		EFN=DPYEFN,-
		CHAN=DPYCHN,FUNC=#IO$_WRITEVBLK!IO$M_NOFORMAT,-
		IOSB=IOSB,-
		P1=TRM$T_HOMCLR+1(R6),P2=R0	;POUTPUT CLEAR
POPL		R1
RSB

.SBTTL	STRING OUTPUT FUNCTION

ARGUMENTS:
	4(AP)-->DESCRIPTOR FOR STRING TO OUTPUT
AS IN ALL DPY FUNCTIONS, WHEN CALLED FROM THE DISPATCHR, R1 POINTS
TO THE TERMINAL DESCRIPTOR BLOCK


THE ROUTINE:

.ENTRY	DPY$STR,^M<R2,R3,R4,R5,R6,R7>

CHMU		#3
RET

UNSTR:	MOVQ		@4(AP),R4		;DESCRIPTOR
MOVZWL		R4,R4			;ONLY COUNT
$:	SOBGEQ		R4,10$			;SEE IF MORE CHARACTERS
BRW		DONSTR			;DONE0$:	
MOVZBL		(R5)+,R0		;GET CHARACTER
CALLS		#0,STORE		;STORE CHARACTER
CMPW		#SS$_ABORT,R0		;
BEQL		20$
BLBS		R0,5$
RSB
0$:	INCL		R4
DECL		R5			;BACK UP
BRB		5$

ONSTR:	MOVZWL		#SS$_NORMAL,R0
RSB


.SBTTL	STORE

CHARACTER PASSED IN R0.  NO OTHER ARGS
R1 ALSO POINTS TO TERMINAL CONTROL BLOCK AND IS NOT DESTROYED

.ENTRY		STORE,^M<R2,R3,R4,R5,R6,R7>

BBCC		#DPY$V_IWIN,DPY$FLAGS,5$;IMPLICIT WINDOW?
CLRW		CURLIN
CLRW		CURCOL			;JUST FINISHED A DPY$
$:	MOVZWL		#SS$_BUFFEROVF,-(SP)	;STORE RETURN CODE
MOVL		CURLIN,R2		;GET CURRENT LINE
CLRL		R3
SUBW3		#1,CURCOL,R3
CMPW		R2,MAXLIN		;OVER MAX?
BLEQ		10$			;NO
BRW		LF20$:	ACBW		MAXCOL,#1,R3,20$	;ANY CHAR OK
CMPB		#^O15,R0		;ELSE ONLY <CR>
BEQL		15$
BRW		RETSTR1			;ELSE EAT IT5$:	SUBW3		#1,MINCOL,R3
MOVZWL		#SS$_NORMAL,(SP)
BRW		RETSTR			;CONTINUE
0$:	MOVZWL		#SS$_NORMAL,(SP)
CMPB		#^O12,R0		;<LF>?
BNEQ		25$
BRW		DOLF			;YES, NEW ROW
5$:	CMPB		#^O15,R0		;NOW IS IT <CR>
BNEQ		30$			;NO
MOVZWL		#SS$_ABORT,(SP)		;FLAG BACKUP
MOVZBL		#^A/ /,R0		;AND MAKE SPACE
0$:	MOVZWL		TRM$W_MAXCOL(R1),R6
MULL2		R2,R6
ADDL2		R2,R6
ADDL2		R3,R6			;POINT TO SCREEN POSITION
CMPB		#^A/	/,R0		;IS IT A <TAB>?
BNEQ		40$			;NO
BBCS		#DPY$V_TAB,DPY$FLAGS,35$	;FORCE SPACE	
BBC		R3,TABMSK,35$
DECL		R3
BICL2		#DPY$M_TAB,DPY$FLAGS	;CLEAR TAB FLAG
BRW		RETSTR
5$:	MOVL		#^A/ /,R0		;PUT IN SPACE
MOVZWL		#SS$_ABORT,(SP)	;SET TO FUDGE COUNTS
BRB		41$
0$:	BBCC		#DPY$V_TAB,DPY$FLAGS,41$
1$:	CMPB		#^A/ /,R0		;CTL CHAR?
BLEQ		45$			;NO
MOVB		#^A/ /,R0		;YES, EAT IT
5$:	CMPB		R0,SCREEN(R6)		;SEE IF SAME
BEQL		RETSTR			;CONTINUE
BBS		#DPY$V_OKUP2,DPY$FLAGS,50$
BBC		#7,SCREEN(R6),50$
$EXIT_S		#SS$_ABORT
0$:	BISB3		#^X80,R0,SCREEN(R6)	;PUT IN CHARACTER
ETSTR:	MOVL		R2,CURLIN
INCL		R3
MOVL		R3,CURCOL
ETSTR1:
POPL		R0			;RETURN CODE
RET

OLF:	DECL		R3			;ACCOUNT FOR ACBW EARLIER
ACBW		MAXLIN,#1,R2,RETSTR		;PUT IN
F2:	MOVZWL		#SS$_BUFFEROVF,(SP)
BRB		RETSTR

.SBTTL		DPY ROUTINE

WHAT DPY IS ALL ABOUT

.ENTRY		DPY$DPY,^M<R2,R3,R4,R5,R6,R7,R8,R9,R10,R11>

CHMU		#1
RET

UNDPY:	MOVL		R1,R8		;SAVE
CALLS		#0,SLURP	;FINISH OFF THE WINDOW
CLRQ		R10		;CURRENT POSITION
CLRQ		R6		;where cursor last moved to
MOVAL		TRMBUF,BUFPTR	;SET BUFFER POINTER
MOVZWL		TRM$W_MAXCOL(R8),R9
BBC		#DPY$V_REF,DPY$FLAGS,LOOP
PUSHAB		TRM$T_HOME(R8)
CALLS		#1,MOVASC
OOP:	MULL3		R9,R10,R0	;POINT TO SCREEN
ADDL2		R10,R0
ADDL2		R11,R0
MOVB		SCREEN[R0],R1	;GET CHARACTER
BBS		#DPY$V_REF,DPY$FLAGS,1$	;FORCE REFRESH
BLSS		1$		;IF CHANGED
BRW		NXTCHR		;IF NOT$:	BICB3		#^X80,R1,-(SP)	;SAVE REAL CHARACTER
MOVB		(SP),SCREEN[R0]
BITL		#DPY$M_LINCLR!DPY$M_FRMCLR,DPY$FLAGS
BEQL		10$
$:	BRW		PUTCHR10$:	SUBL3		R6,R10,R0	;ROW DIFFERENCE
SUBL3		R7,R11,R1	;COLUMN DIFFERENCE
BNEQ		50$
TSTL		R0
BNEQ		50$
BRW		PUTCHR		;IF NO DIFFERENCE
0$:	CLRL		-(SP)		;ADDEND TO INCLUDE <CR>
MOVZBL		TRM$T_RIGHT(R8),-(SP);COMPUTE HOW MUCH TO MOVE
TSTL		R1
BGTR		100$		;IF RIGHT IS RIGHT
MULL3		(SP),R11,-(SP)	;# CHARACTERS FROM BEGINNING
INCL		(SP)		;INCLUDE <CR>
MNEGL		R1,R2		;NEGATE
CMPL		(SP)+,R2
BGTR		75$		;NO
MOVL		R11,R1		;THAT MANY CHARACTERS
MOVZBL		#1,4(SP)	;ALSO HERE
5$:	MOVZBL		TRM$T_LEFT(R8),(SP);IF LEFT
MNEGL		(SP),(SP)	;SO WILL BE POSITIVE00$:	MULL3		R1,(SP)+,R2	;CHARACTER COUNT
ADDL2		(SP),R2		;IF TO INCLUDE CR
MOVZBL		TRM$T_DOWN(R8),-(SP)
TSTL		R0
BGTR		200$
MOVZBL		TRM$T_DOWN(R8),(SP)
MNEGL		(SP),(SP)
00$:	MULL2		R0,(SP)
ADDL2		(SP)+,R2
TSTB		TRM$T_ADR1(R8)	;IS ADDRESSING POSSIBLE?
BEQL		250$		;NO
BBC		#TRM$V_ASCII,TRM$L_FLAGS(R8),275$	;MAKE WORST CASE
SUBL2		#2,R2		;ESTIMATE ONLY
75$:	CMPL		R2,ADRSUM	;ADDR IS CHEAPER?
BGTR		ADR		;YES
50$:	TSTL		(SP)+		;PUT IN <CR>?
BEQL		300$		;NO
MOVQ		R0,-(SP)
MOVZBL		#^O15,R0
CALLS		#0,MOVCHR
MOVQ		(SP)+,R0
MOVL		R11,R1
00$:	BRW		NOADR
DR:	CLRL		(SP)+		;FIX STACK
PUSHAL		TRM$T_ADR1(R8)	;START STRING
CALLS		#1,MOVASC
MOVZBL		TRM$B_YOFF(R8),-(SP)
BBC		#TRM$V_REVERSE,TRM$L_FLAGS(R8),327$
MOVZBL		TRM$B_XOFF(R8),(SP)
XORL2		R10,R11
XORL2		R11,R10
XORL2		R10,R11			;EXCHANGE
27$:	BBC		#TRM$V_ASCII,TRM$L_FLAGS(R8),350$
ADDL2		R10,(SP)
CALLS		#1,DECCNV
BRB		400$
50$:	ADDL3		(SP)+,R10,R0
CALLS		#0,MOVCHR
00$:	PUSHAL		TRM$T_ADR2(R8)
CALLS		#1,MOVASC
MOVZBL		TRM$B_XOFF(R8),-(SP)
BBC		#TRM$V_REVERSE,TRM$L_FLAGS(R8),425$
MOVZBL		TRM$B_YOFF(R8),(SP)
25$:	BBC		#TRM$V_ASCII,TRM$L_FLAGS(R8),450$
ADDL2		R11,(SP)
CALLS		#1,DECCNV
BRB		500$
50$:	ADDL3		(SP)+,R11,R0
CALLS		#0,MOVCHR
00$:	BBC		#TRM$V_REVERSE,TRM$L_FLAGS(R8),550$
XORL2		R10,R11
XORL2		R11,R10
XORL2		R10,R11
50$:	PUSHAL		TRM$T_ADR3(R8)
CALLS		#1,MOVASC
UTCHR:	BITL		#DPY$M_LINCLR!DPY$M_FRMCLR,DPY$FLAGS
BEQL		600$
75$:	BRW		PUTCHR1
00$:	CMPB		#^A/ /,(SP)			;IS THIS A SPACE?
BNEQ		575$				;NO
MULL3		R9,R10,R1			;POINT TO SCREEN
ADDL2		R10,R1
ADDL2		R11,R1
MOVZWL		TRM$W_MAXLIN(R8),-(SP)		;GET
MULL3		R9,(SP),R0			;# OF CHARS
ADDL2		(SP)+,R0
ADDL2		R9,R0
SUBL2		R1,R0				;# OF CHARS
MOVAB		SCREEN+1(R1),R1
DECL		R0				;EXCL THIS ONE
BLEQ		PUTCHR1				;FORGET IF SO
PUSHAB		(R1)
TSTB		TRM$T_EOF(R8)			;CAN THIS TERMINAL EOF
BEQL		TRYEOL				;NO
OFLP:	SKPC		#^A/ /,R0,(R1)			;FIND CHAR
BEQL		DOEOF
CMPB		#^A/ /!^X80,(R1)		;IS IT "NEW" SPACE?
BNEQ		TRYEOL				;NO
INCL		R1
DECL		R0
BGTR		EOFLP
OEOF:	MOVAB		TRM$T_EOF(R8),(SP)
MOVQ		R10,R6
CALLS		#1,MOVASC
BBCS		#DPY$V_FRMCLR,DPY$FLAGS,PUTCHR1
BRB		PUTCHR1
RYEOL:	SUBL3		R11,R9,R0
POPL		R1
TSTB		TRM$T_EOL(R8)			;CAN THIS TERM EOL?
BEQL		PUTCHR1				;NO
OLLP:	SKPC		#^A/ /,R0,(R1)
BEQL		DOEOL
CMPB		#^A/ /!^X80,(R1)
BNEQ		PUTCHR1
INCL		R1
DECL		R0
BGTR		EOLLP
OEOL:	PUSHAB		TRM$T_EOL(R8)
CALLS		#1,MOVASC
BISL2		#DPY$M_LINCLR,DPY$FLAGS
MOVQ		R10,R6
UTCHR1:
MOVZBL		(SP)+,R0
BITL		#DPY$M_LINCLR!DPY$M_FRMCLR,DPY$FLAGS
BNEQ		NXTCHR
CALLS		#0,MOVCHR
MOVQ		R10,R6
INCL		R7
XTCHR:	ACBW		TRM$W_MAXCOL(R8),#1,R11,LOOP
EWLIN:	BICL2		#DPY$M_LINCLR,DPY$FLAGS
CLRL		R11
ACBW		TRM$W_MAXLIN(R8),#1,R10,LOOP
BICL2		#DPY$M_FRMCLR,DPY$FLAGS
PUSHAB		TRM$T_HOME(R8)
UTBUF:	CALLS		#1,MOVASC
MOVAL		TRMBUF,R0
SUBL3		R0,BUFPTR,R0
reaka:	$QIOW_S		EFN=DPYEFN,-
		CHAN=DPYCHN,FUNC=#IO$_WRITEVBLK!IO$M_NOFORMAT,-
		IOSB=IOSB,-
		P1=TRMBUF,P2=R0
BBSC		#DPY$V_REF,DPY$FLAGS,BREAK1	;CLEAR REFRESH FLAG
REAK1:	BISL2		#DPY$M_IWIN,DPY$FLAGS
MOVW		TRM$W_MAXCOL(R8),MAXCOL
MOVW		TRM$W_MAXLIN(R8),MAXLIN		;RESET TO BIG WINDOW
RSB

HERE IF NO ADDRESSING IS BEST (OR ONLY) WAY TO GO
R0=ROW DIFFERENCE FROM CURRENT POSITION
R1=COLUMN DIFFERENCE
R11=COLUMN TO GO TO
OADR:	PUSHL		R0		;SAVE
MOVAL		TRM$T_RIGHT(R8),-(SP)	;DEFAULT SPACE
TSTL		R1
BEQL		DOCOL
BGTR		50$
MOVAL		TRM$T_LEFT(R8),(SP)
MNEGL		R1,R1
0$:	PUSHL		#1
PUSHL		R1
OLP1:	CALLG		4(SP),MOVASC
SOBGTR		(SP),NOLP1
CLRQ		(SP)+
OCOL:	CLRL		(SP)+
MOVAL		TRM$T_DOWN(R8),R1
POPL		R0
BEQL		DONCOL
BGTR		60$
MNEGL		R0,R0
MOVAL		TRM$T_UP(R8),R1
0$:	PUSHL		R1
PUSHL		#1
PUSHL		R0
OLP2:	CALLG		4(SP),MOVASC
SOBGTR		(SP),NOLP2
CLRQ		(SP)+
CLRL		(SP)+
ONCOL:	BRW		PUTCHR

.SBTTL	WINDOW FUNCTION

.ENTRY	DPY$SIZ,^M<R2,R3,R4,R5>

CHMU		#2
RET

UNWIN:
BBSC		#DPY$V_IWIN,DPY$FLAGS,5$	;NO IMPLICIT WINDOW
CALLS		#0,SLURP			;FINISH OFF WINDOW
$:	SUBW3		#1,4(AP),MINLIN
BGEQ		10$
CLRW		MINLIN0$:	SUBW3		#1,6(AP),MAXLIN
BGEQ		20$
MOVW		TRM$W_MAXLIN(R1),MAXLIN
0$:	SUBW3		#1,8(AP),MINCOL
BGEQ		30$
CLRW		MINCOL
0$:	SUBW3		#1,10(AP),MAXCOL
BGEQ		40$
MOVW		TRM$W_MAXCOL(R1),MAXCOL
0$:	MOVZWL		MINCOL,CURCOL
MOVZWL		MINLIN,CURLIN
MOVZWL		#SS$_NORMAL,R0
RSB

.SBTTL	TAB FUNCTION

.ENTRY	DPY$TAB,^M<R2,R3,R4,R5>

CHMU		#6
RET

UNTAB:
MOVAL		@4(AP),R0
BNEQ		10$
MOVAL		DTABMSK,R00$:	MOVC3		#20,(R0),TABMSK
MOVZWL		#SS$_NORMAL,R0
RSB

.SBTTL	TTY FUNCTION

.ENTRY	DPY$TTY,^M<R2,R3,R4,R5,R6,R7,R8>

CHMU		#7
RET

UNTTY:
MOVL		4(AP),R0
MOVL		TTFNTB[R0],R0
JMP		(R0)
ULTTY:	RSB

OMTTY:	MOVZBL		TRM$T_HOME(R1),R0
$QIOW_S		EFN=DPYEFN,CHAN=DPYCHN,-
		FUNC=#IO$_WRITEVBLK,-
		IOSB=IOSB,-
		P1=TRM$T_HOME+1(R1),P2=R0
RSB

LRTTY:	MOVZBL		TRM$T_HOMCLR(R1),R0
$QIOW_S		EFN=DPYEFN,CHAN=DPYCHN,-
		FUNC=#IO$_WRITEVBLK,-
		IOSB=IOSB,-
		P1=TRM$T_HOMCLR+1(R1),P2=R0
RSB

OTTTY:	MOVL		R1,R6				;SAVE POINTER
BSBW		HOMTTY				;SET CURSOR TO HOME
MOVZBL		TRM$T_DOWN(R6),R7
MOVZBL		#2,R8				;ONE LESS THAN
MOVAL		TTYBUF,R3
OTLP:	MOVC3		R7,TRM$T_DOWN+1(R6),(R3)
ACBW		TRM$W_MAXLIN(R6),#1,R8,BOTLP	;MOVE ALL
MULL2		R7,R8
$QIOW_S		CHAN=DPYCHN,FUNC=#IO$_WRITEVBLK,-
		IOSB=IOSB,-
		P1=TTYBUF,P2=R8
RSB

.SBTTL	CHARACTER FUNCTION

.ENTRY	DPY$CHR,0

CHMU		#4
RET

UNCHR:
MOVZBL		4(AP),R0
CALLS		#0,STORE
RSB

.SBTTL	REFRESH FUNCTION

.ENTRY	DPY$REF,^M<R2,R3,R4,R5,R5,R6,R7,R8,R9,R10,R11>

CHMU		#8
RET

UNREF:	BISL2		#DPY$M_REF,DPY$FLAGS
BRW		FUNDPY			;AND TREAT LIKE DPY FUNCTION
.SBTTL	LOCATION FUNCTION

.ENTRY	DPY$LOC,0

CHMU		#5
RET

UNLOC:
MOVAL		@4(AP),R0
MOVL		CURLIN,(R0)
MOVL		CURCOL,4(R0)
MOVZWL		#SS$_NORMAL,R0
RSB

.SBTTL	MISCELLANEOUS SUBROUTINES

.ENTRY		MOVASC,^M<R2,R3,R4,R5,R6,R7>

TA:	MOVL		BUFPTR,R7	;POINT TO CURRENT
MOVZBL		@4(AP),R0	;COUNT
BEQL		NORRET
ADDL3		R0,R7,R1
MOVAL		TRMBUF,R2
SUBL3		R2,R1,R2
CMPL		#BUFSIZ,R2
BGEQ		DOMOV
MOVAL		TRMBUF,R2
SUBL3		R2,R7,R0
reakb:	$QIOW_S		EFN=DPYEFN,-
		CHAN=DPYCHN,FUNC=#IO$_WRITEVBLK!IO$M_NOFORMAT,-
		IOSB=IOSB,-
		P1=TRMBUF,P2=R0
REAK2:	BLBC		R0,DONMOV
MOVZWL		IOSB,R0
BLBC		R0,DONMOV
MOVAL		TRMBUF,BUFPTR
BRW		STA
OMOV:	MOVAL		@4(AP),R1
MOVC3		R0,1(R1),(R7)
MOVL		R3,BUFPTR
ORRET:	MOVZBL		#SS$_NORMAL,R0
ONMOV:	RET


.ENTRY		MOVCHR,^M<R2,R3,R4,R5>

MOVZBL		R0,R4
TC:	MOVL		BUFPTR,R1
MOVAL		TRMBUF,R2
SUBL3		R2,R1,R2
CMPL		#BUFSIZ,R2
BGTR		OKA
MOVAL		TRMBUF,R2
SUBL3		R2,R1,R1
reakc:	$QIOW_S		EFN=DPYEFN,-
		CHAN=DPYCHN,FUNC=#IO$_WRITEVBLK!IO$M_NOFORMAT,-
		IOSB=IOSB,-
		P1=TRMBUF,P2=R1
REAK3:	BLBC		R0,DONMOVC
MOVZWL		IOSB,R0
BLBC		R0,DONMOVC
MOVAL		TRMBUF,BUFPTR
BRW		STC
KA:	MOVB		R4,(R1)+
MOVL		R1,BUFPTR
MOVZWL		#SS$_NORMAL,R0
ONMOVC:
RET

.ENTRY		SLURP,^M<R2,R3,R4,R5>

ROUTINE TO PUT SPACES IN THE REST OF A WINDOW
***EXPECTS TERMINAL BLOCK TO BE POINTED TO BY R1***
R1 IS PRESERVED

MOVL		CURLIN,R2
CLRL		R3
SUBW3		#1,CURCOL,R3
CMPW		R2,MAXLIN
BGTR		7$
$:	ACBW		MAXCOL,#1,R3,10$			;IF OK
SUBW3		#1,MINCOL,R3
ACBW		MAXLIN,#1,R2,5$			;BACK FOR MORE
ADDL3		#1,R3,CURCOL
MOVL		R2,CURLIN			;SAVE
$:	MOVZWL		#SS$_NORMAL,R0
RET0$:	MOVZWL		TRM$W_MAXCOL(R1),R0
MULL2		R2,R0
ADDL2		R2,R0
ADDL2		R3,R0
CMPB		#^A/ /,SCREEN(R0)		;SEE IF ALREADY SPACE
BEQL		5$				;YES
MOVB		#<^A/ /!^X80>,SCREEN(R0)	;SET SPACE
BRB		5$

.ENTRY		DECCNV,^M<R2,R3,R4,R5>

ROUTINE TO CONVERT TO ASCII TYPE COORDINATES
ARG (POINTED TO BY VALUE BY AP IS NUMBER TO CONVERT

CLRL		R4				;COUNT
MOVL		4(AP),R2			;GET LINE
P:	INCL		R4				;INCREMENT
CLRL		R3				;CLEAR UPPER
EDIV		#10,R2,R2,-(SP)			;SAVE
BNEQ		LP				;CONTINUE
UTLP:	ADDL3		(SP)+,#^A/0/,R0
CALLS		#0,MOVCHR			;PUT IN CHARACTER
SOBGTR		R4,OUTLP
RET

ROUTINE TO ASK WHAT KIND OF TERMINAL WE ARE ON
RETURNS WITH TERMINAL TYPE IN R6

SKTRM:	MOVAB		DPY$C_VT52,R6			;TRY VT52
CMPB		#DT$_VT52,TRMCHR+1		;IS IT A 52?
BNEQ		10$
$:	RSB0$:	MOVAB		DPY$C_VT100,R6			;OR A 100?
CMPB		#DT$_VT100,TRMCHR+1
BEQL		5$
$QIOW_S		EFN=DPYEFN,-
		CHAN=DPYCHN,FUNC=#IO$_READPROMPT!IO$M_CVTLOW,-
		IOSB=IOSB,-
		P1=TTYBUF,P2=#80,P5=#PBUF,P6=#PBUFL
CLRL		R7				;LET R6 INDEX THE DATA
RMLP:	MOVQ		TTTAB[R7],R5			;ADDRESS OF STRING
MOVZBL		(R5),R0
CMPC5		IOSB+2,TTYBUF,#0,R0,1(R5)	;SAME?
BEQL		FNDTTY
ACBL		#MAXTRM-1,#1,R7,TRMLP
BRB		ASKTRM
NDTTY:	RSB

.END