Enter your search terms Submit search form
	Web pdp-10.trailing-edge.com

.TITLE	SED1DS - Screen Display, Control, and Update Routines

.LIBRARY /SEDITB.MLB/
.ENABLE DEBUG
.DISABLE GLOBAL
.PSECT CODE,NOWRT,EXE,LONG

$IODEF		;  and the I/O function values
PRMDEF		;Define the SED parameters
TRMDEF		;Define the words in the terminal output table
FLGDEF		;and the flag bits

.EXTERNAL SS$_TIMEOUT

.SUBTITLE	Display Subroutines

;**********************************************************************
;			Utility Subroutines
;**********************************************************************
;The routines below deal with displaying part of the buffer on the screen
;JMP	 DISDWN - From cursor position to end of screen
;JMP	 DISALL - Entire screen
;JSB	 DISPLL - Entire screen
;JMP	 DISCUR - Reposition cursor
;JSB	 DISLIN - Position, remainder of line
;JSB	 DISONL - Position, entire line
;JSB	 DISONE - Entire line

;Here to display from the line the cursor is on to the bottom,
;position the cursor where it belongs, and go get a new command

DISDWN::BBC	#V_XCT,F1,10$	;If doing an execute,
	BRW	DISCUR		;  no display
10$:	TSTL	CPG(R10)	;Is there a sequence for clear to EOP?
	BEQL	DISDWC		;No - see if clear-to-eol's will work
	MOVL	R7,R4		;Yes, move cursor to start of line
	JSB	POSLIN
	JSB	CLEARP		;Clear to end of page
DISDW1:	MOVL	LINPTR,R6
	SUBL3	R7,LPP(R10),R4	;Find number of lines to display
	BBC	#V_WDW,F1,10$	;Windowing?
	BSBW	DISWDW		;Yes - (maybe) adjust count
10$:	BICL2	#M_FNC!M_FBL,F	;Fence will be re-drawn; bottom line OK
	BSBW	DISPLY		;Re-display all lines after cursor position
	BBC	#V_IMD,F,DISCUR	;In insert mode?
	BSBW	INSMSG		;Yes, put up insert message
	BRB	DISCUR		;Position cursor and loop

;Here if there's no clear-to-end-of-screen - use c-eol's if possible

DISDWC:	TSTL	CLN(R10)	;Can the terminal clear a line?
	BEQL	DISALL		;No - go display the entire page
	SUBL3	R7,LPP(R10),R4	;Yes - clear each line separately
				;Find number of lines to display
	BBC	#V_WDW,F1,10$	;Windowing?
	BSBW	DISWDW		;Yes - (maybe) adjust count
10$:	MOVL	R4,R3
	MOVL	R7,R4
DISDCL:	BSBW	POSLIN		;Move to the start of another line
	BSBW	CLRLNA		;Clear it out
	INCL	R4		;Move to next line
	SOBGTR	R3,DISDCL	;Loop through all lines
	MOVL	R7,R4		;Move cursor to start of first line
	BSBW	POSLIN
	BRB	DISDW1		;Re-join the flow

;DISRES: Entry point for the re-display screen option of the reset command

DISRES::BSBW	RESTPM		;Reset enter mode
	BBC	#V_XSV,F1,DISALL ;Saving an execute buffer?
	MOVB	#^O77,@XCTPTW	;Yes - overwrite real code with execute code
DISALL::BSBB	DISPLL		;(Enter here to display all and loop)
DISCUR::BSBW	POSCUR		;Re-position the cursor and return
	JMP	LOOP		;and get another command

;Subroutine to display a screenful of data, starting from DISPTR
;R1-R4 and R6 are fragged

DISPLL::BBS	#V_XCT,F1,4$	;Doing an execute?  Yes - no display
	BSBW	CLRALL		;Go home and clear the screen
	MOVL	DISPTR,R6	;Get pointer to start of display
	MOVL	LPP(R10),R4	;Set to display entire screen
	BBC	#V_WDW,F1,15$	;Windowing?
	BSBB	DISWDW		;Yes - (maybe) adjust count
15$:	BSBW	DISPS0		;Do the display
	MOVL	DISPPT,BOTPTR	;Save pointer to last line as bottom pointer
	BITL	#M_FNC,F	;Is the fence on the screen?
	BNEQ	2$		;Yes
	BICL	#M_XPB,F	;No, mark bottom pointer as good
	BRB	3$
2$:	BISL	#M_XPB,F	;Mark bottom pointer as bad
3$:	BICL	#M_FBL,F	;But bottom line itself is O.K.
	BBC	#V_IMD,F,4$	;In insert mode?
	BRW	INSMSG		;Yes - put insert message up
4$:	RSB			;No - done

;Subroutine if windowing - if top window display one fewer line

DISWDW:	TSTL	HOMPOS		;In the top window?
	BNEQ	10$		;No
	DECL	R4		;Yes - display one fewer line
10$:	RSB

;Subroutine to display one line, from cursor position to end
;Cursor does not have to be positioned; CHRPTR must be right

DISLIN::BBC	#V_XCT,F1,1$	;Doing an execute?
	RSB			;Yes, no display
1$:	BSBW	POSCUR		;Move cursor to its rightful position
	TSTL	CLN(R10)	;Can terminal clear to end of line?
	BNEQ	2$		;Yes
	MOVL	F1,SAVEAC+16	;No - make tabs come out as spaces
	BICL	#M_TBS,F1
	BRB	3$		;  and clear line later
2$:	BSBW	CLRLNR		;Let the terminal clear the line
3$:	MOVL	CHRPTR,R6	;Set to write one line where cursor is
	MOVZBL	#1,R4		;Say one line will be displayed
	MNEGL	CPL(R10),R2	;Compute negative character count
	ADDL2	R8,R2		;Count: chars remaining in line
	BBC	#V_WRP,F1,4$	;Will lines wrap around?
	CMPL	R7,LPP.1	;Yes, on last line?
	BLSS	4$
	DECL	R2		;No - do one more character
4$:	DECL	R2
	MOVL	R2,CHRCNT	;Save it as the character count
	ADDL3	SL,R8,R2	;Offset: slide + chars not remaining
	BSBW	DISPL0

DISCLR:	TSTL	CLN(R10)	;Could terminal clear to end of line?
	BEQL	10$
11$:	RSB			;Yes - done
10$:	MOVL	F1,SAVEAC+16	;No - restore correct TBS flag
	MOVL	CHRCNT,R0	;Get ending position in line
	BEQL	11$		;Nothing to clear if line is full
	ADDL2	CPL(R10),R0
	SUBL	#2,R0
	BRW	CLRLN2		;Clear remainder of line and return

;Here to display one entire line pointed to by (R6)
;If cursor is already positioned enter at DISONE

DISONL::BBC	#V_XCT,F1,1$	;Doing an execute?
	RSB			;Yes - no display
1$:	MOVL	R7,R4
	BSBW	POSLIN		;Move cursor to start of line
	MOVL	LINPTR,R6

DISONE::TSTL	CLN(R10)	;Can terminal clear to end of line?
	BNEQ	10$		;Yes
	MOVL	F1,SAVEAC+16	;No
	BICL	#M_TBS,F1	;Make tabs come out as spaces
	BRB	20$		;and clear line later
10$:	BSBW	CLRLNA		;Let terminal clear the whole line
20$:	MOVZBL	#1,R4		;Display one entire line
	BSBB	DISPLY		;Display the line
	BRB	DISCLR		;Clear rest of line and return

;Subroutine to display (R4) lines starting at where R6 points in buffer
;Cursor is assumed to be at the right position
;R1-R4 and R6 are fragged

DISPLY::BBC	#V_XCT,F1,1$	;Doing an execute?
	RSB			;Yes - no display
1$:	BICL	#M_LFF,F
	BRB	DISPS1
DISPS0::BICL	#M_FNC!M_LFF,F
DISPS1:	BSBW	DISSLD		;Skip over, if there's a slide
DISPL0:	MOVAB	TYPBUF+TYPSIZ+1,R3 ;Set up end-of-type-buffer address

;Now copy line into display buffer

DISPL1:	CMPL	R6,EN		;At end of buffer?
	BLEQ	10$
	BRW	DISPEN		;Yes - display the rest, then done
10$:	MOVZBL	(R6)+,R1	;Get a character from the file buffer
	BEQL	DISPL1		;Ignore a null
	INCL	R2		;Count the character
	INCL	CHRCNT		;Increment the character count
	BGEQ	DISSKP		;Jump if line has filled the screen
	BBCC	#V_LFF,F,DISPL2	;Looking for a line feed?
	BRW	DISPLF		;Yes - see if this is one
DISPL2:	CMPB	R1,#^A" "	;Some kind of control character?
	BLSS	DISCTL		;Yes - handle it separately
	CMPB	R1,#^O177	;Is it a rubout?
	BEQL	DISRUB		;Yes - display as highlighted "?"
DISPL3:	MOVB	R1,(R5)+	;Store character in type buffer

DISPL4:	CMPL	R3,R5		;Is buffer filled?
	BGEQ	DISPL1		;No
	BSBW	PUTTYP		;Yes - finish buffer and output it
	BRB	DISPL1		;Either way, get some more

;Here if a full line of characters has been found; ignore rest of line

DISSKP:	CMPB	R1,#^O12	;Is last character a <LF>?
	BNEQ	10$		;No
	BICL	#M_LFF,F	;Yes - clear linefeed flag
	BRW	DISPLF		;and end line
10$:	CMPB	R1,#^O15	;Use this char if it's a <CR>
	BEQL	DISKP2
DISKP1:	MOVZBL	(R6)+,R1	;Ignore rest of line
DISKP2:	CMPB	R1,#^O15	;End of line?
	BNEQ	DISKP1		;No - ignore another character
	MOVZBL	(R6)+,R1	;Found <CR> - get <LF>
	CMPB	R1,#^O12	;Is it really?
	BNEQ	DISKP2		;Of course not - keep ignoring
	BBS	#V_WRP,F1,10$	;Need a carriage return at end of long line?
	BRW	DISPF1		;Yes - finish line with <CR>
10$:	DECL	R4		;No - working on last line?
	BLSS	20$		;No
	BRW	DISPF2		;No
20$:	CLRB	(R5)		;Yes - overwrite last char with null
	BRW	PUTTYP		;Finish the display and return

;Here if character is a control character
;If not <CR>, <LF>, or <TB>, display as reversed-ascii character

DISCTL:	CMPB	R1,#^O15	;Just a <CR>?
	BNEQ	10$
	BISL2	#M_LFF,F	;Maybe - set flag to look for <LF>
	BRB	DISPL4		;and check no further
10$:	CMPB	R1,#9		;Tab?
	BEQL	DISTAB		;Yes - treat specially
	BSBB	DISREV		;Else output reversed character
	BRB	DISPL4

;Here if character is a rubout - display as protected "?"

DISRUB:	MOVB	#^A"?"-64,R1	;Set it up so it comes out as a space
	BSBB	DISREV		;Output it in reversed-ascii
	BRB	DISPL4		;and go check the buffer

;Here to handle a tab - de-bump position by size of tab
;If slide is a multiple of 8, work with tab; else convert to spaces

DISTAB:	BITL	#7,SL		;Is slide a multiple of 8?
	BNEQ	DISTBX		;No - simulate with spaces
	BBC	#V_TBS,F1,DISTBX ;Got hardware tabs?
	BBS	#V_DTB,F,DISTBA	;Want to display tabs?
DISTB0:	BITL	#7,R2		;Move over to tab boundary
	BEQL	10$
	INCL	R2
	INCL	CHRCNT
	BLSS	DISTB0
10$:	BRW	DISPL3		;Save tab in display buffer

DISTBA:
DISTBB:	BSBW	PROTON		;Turn protection on
10$:	MOVB	#^A".",(R5)+	;Output protected dots over the length of the tab
	BITL	#7,R2		;At a tab boundary?
	BEQL	20$		;Yes
	INCL	R2		;No - keep going
	INCL	CHRCNT
	BNEQ	10$
20$:	BSBW	PROTOF		;Turn protection off
	BRW	DISPL4		;  and return

;DISTBA:	BSBB	DISREV		;Output a reversed "I"
;       BITL	#7,R2		;Is tab really only one space long?
;	BNEQ	10$
;	BRW	DISPL4		;Yes - don't output the tab
;10$:	MOVB	#9,R1		;Else get the tb back again
;	BRB	DISTB0		;and output it

DISTBX:	BBS	#V_DTB,F,DISTBB	;Want to display tabs?
DISTX1:	MOVB	#^A" ",(R5)+	;Simulate tab: get a space
	BITL	#7,R2		;Save until at a tab boundary
	BEQL	10$
	INCL	R2
	INCL	CHRCNT
	BNEQ	DISTX1
10$:	BRW	DISPL4

;DISTBB:	BSBB	DISREV		;Output a reversed "I"
;	BITL	#7,R2		;At a tab boundary?
;	BNEQ	10$
;	BRW	DISPL4		;Yes - continue
;10$:	INCL	R2
;	INCL	CHRCNT
;	BRB	DISTX1		;No - output some spaces, too

;Subroutine to output the character in R1 as highlighted ASCII

DISREV:	PUSHR	#^M<R1>		;Save R1
	BSBW	PROTON		;Turn on background mode
	POPR	#^M<R1>		;Restore reversable character
	ADDB2	#^A"A"-1,R1	;Make it a character
	MOVB	R1,(R5)+	;Save it
	BSBW	PROTOF		;Turn off background mode
	CMPL	R3,R5		;Is buffer filled?
	BGEQ	10$		;Yes - finish buffer and output it
	BRW	PUTTYP
10$:	RSB			;No - just return

;Here if EOF reached before E.O. Screen. Output fence; done

DISPN1:	POPR	#^M<R0>		;Restore the stack (here from DISSLD)
DISPEN:	BSBW	PUTTYP		;Finish buffer and output it
	BRW	FIXBLW		;Display fence and return

;Here if expecting a <LF> after a <CR>. If got one, count an end of line

DISPLF:	CMPB	#^O12,R1	;Is this character a <LF>?
	BNEQ	DISPCR		;No - reverse the <CR> and continue
DISPF1:	SOBGTR	R4,10$		;Count lines output - not finished
	BSBW	PUTTYP		;Empty the buffer
	BBS	#V_SCN,F,DISTST	;Scanning?  Yes - see if user wants to stop
	RSB			;No - just return
10$:	MOVB	#^O15,(R5)+	;Save the old <CR>
	BSBW	CDOWN		;Move to next line down

DISPF2:	BSBB	DISTST		;Interrupt display if it's a command
	CMPL	R6,EN		;At the end of the buffer?
	BGEQ	DISPEN		;Yes - finish the display
	MOVL	R6,DISPPT	;Save pointer to the start of this line
	BSBW	DISSLD		;Skip over, if there's a slide
	BRW	DISPL4		;and continue

;Here if character following <CR> is not <LF> - make <CR> reversed CTRL-M

DISPCR:	PUSHR	#^M<R1>		;Save current character
	MOVB	#^O15,R1	;Set to output reversed <CR>
	JSB	DISREV
	POPR	#^M<R1>		;Restore current character
	BRW	DISPL2

;Here if user typed a character during the display - stop it if
;enter or command, else drive on

DISTST:	$QIOW_S	FUNC=#IO$_TTYREADALL!IO$M_NOECHO!IO$M_TIMED,-
		CHAN=TTCHAN,-
		IOSB=TTY_STATUS_BLOCK,-
		P1=TTYBUF,-
		P2=#1,-
		P3=#0		;Read with zero timeout to test for input
	BLBS	R0,20$		;Go if no errors
10$:	RSB			;Otherwise, just return
20$:	CMPW	TTY_STATUS_BLOCK,#SS$_TIMEOUT	;Check for timeout error
	BEQL	10$		;Return if so
	BBSS	#V_CWT,F,10$	;Say character has been read - has one already?
	BBCC	#V_SCN,F,30$	;Scanning?
	BICL	#M_CWT,F	;Yes - no waiting command
	MOVL	#12,R7		;Put cursor near center of screen
	MOVL	#40,R8
	BISL	#M_XPL!M_XPC,F	;Line and character pointers are no good
	RSB			;and quit
30$:	MOVB	TTYBUF,TYPCHR	;Save character for later
	CMPB	TYPCHR,#^A" "	;Control character?
	BGEQ	10$		;No - just continue with the display
	MOVL	STACK,SP	;Yes - clean up the stack
	MOVAB	TYPBUF,R5	;Purge any unsent output
	JMP	LOOP		;Get another command

;Subroutine to skip over a slide's worth of spaces

DISSLD:	TSTL	SL		;If no slide,
	BEQL	DISSLE		;just set up size
	MNEGL	SL,CHRCNT	;Else skip that many characters
	CLRL	R2
DISSL1:	MOVZBL	(R6)+,R1	;Get a character from the file buffer
	CMPL	R6,EN		;At end of buffer?
	BLEQ	5$		;No
	BRW	DISPN1		;Yes - display the rest, then done
5$:	TSTB	R1		;Null character?
	BEQL	DISSL1		;Yes, ignore it
	CMPB	#^O15,R1	;If <CR>, see if end of line
	BNEQ	10$
	MOVZBL	(R6),R1		;Get linefeed
	CMPB	#^O12,R1	;Is it really?
	BNEQ	DISSL2		;No - skip the <CR>
	INCL	R6		;Yes - skip <CRLF>
	MOVL	(SP)+,R0	;Kill call to DISSLD
	MOVAB	TYPBUF+TYPSIZ+1,R3 ;Set up end-of-type-buffer address
	BRW	DISPLF		;and end the line
10$:	CMPB	#9,R1		;Tab?
	BEQL	DISSLT		;Yes - count it
DISSL2:	INCL	R2		;Go until skipped out
	INCL	CHRCNT
	BLSS	DISSL1
DISSLE:	MNEGL	CPL(R10),CHRCNT	;Get character count
	DECL	CHRCNT
	MOVL	SL,R2		;And column number
	RSB			;Then return

DISSLT:	BICL3	#^C7,R2,R1 	;Here if tab - find its size
	SUBL	#8,R1
10$:	INCL	R2		;Count a space, jump if end of slide
	INCL	CHRCNT
	BGEQ	DISLFP
	INCL	R1		;Loop through tab
	BLSS	10$
	BRB	DISSL1		;Get another character

DISLFP:	INCL	R1		;If exactly counted out,
	BEQL	DISSLE		;  put nothing in
	CLRL	CHRCNT
10$:	MOVB	#^A" ",(R5)+	;Slide ends in middle of tab
	INCL	CHRCNT
	INCL	R1		;Put in all extra spaces
	BLSS	10$
	SUBL	CPL(R10),CHRCNT	;Set up length of remainder of line
	DECL	CHRCNT
	CLRL	R2
	RSB			;Then done

.SUBTITLE	Undo Damage Caused by Enter Mode

;***************************************************************************
;Routines to undo the damage caused by enter mode, which can be:
;  1. Reversed-space at cursor position (cover with character from buffer)
;  2. Enter line at bottom of screen (re-write with line from buffer)
;  3. Enter flag (reset it)
;  4. Cursor is ill-positioned (re-position it)

;The enter flag must always be cleared. The other things may not need to
;be undone, depending on how much of the screen has been overwritten.
;Thus the above are handled by different subroutines, so no more work needs
;to be done than necessary.

;The line at the bottom must be re-done quickly if it needs to be done at all.
;The text mark should also be done quickly, so CHRPTR may not need re-making.
;Cursor positioning should be the last thing done by the command routine

;Subroutine to reset enter mode (Note: can't frag R4)

RESTPM::BBSC	#V_ENT,F,RESTP1	;Was enter typed?
	RSB			;No - nothing to do
RESTP1::BITL	#M_XCT!M_XBN,F1	;Executing?
	BEQL	20$		;No
	BRW	ERSPM2		;Yes - don't output anything
20$:	MOVL	R4,-(SP)	;Else save old R4
	BRB	ERSPM1		;and de-blip the blip

;Subroutine to write last line of screen over entered parameter

ERASPM::BBSC	#V_ENT,F,10$	;Was enter typed?
	RSB			;No - nothing to do
10$:	BITL	#M_XCT!M_XBN,F1	;Executing?
	BNEQ	ERSPM2		;Yes - don't output anything
ERSPM0::MOVL	R4,-(SP)	;Save old R4
	BSBW	FIXBLN		;Re-do the bottom line
ERSPM1:	MOVZBL	CHRCUR,R1	;Got a blip to de-blip?
	BEQL	ERSP2A		;No - don't de-blip it
	CMPB	R1,#^A" "	;Is char a control char?
	BGEQ	10$		;No
	BBC	#V_MRK,F1,ERSP2A ;Yes - got a mark there?
	ADDB3	#^O100,R1,CHRCUR ;Yes - make character a real character
10$:	BSBW	POSCUR		;Else position the cursor
	MOVB	CHRCUR,(R5)+	;and put proper character back there
	BSBW	CLEFT		;  and position over the character
ERSP2A:	MOVL	(SP)+,R4	;Restore R4
ERSPM2::BBSC	#V_CMV,F,10$	;Clear cursor movement flag - was it on?
	RSB			;No - return
10$:	CMPL	R7,SAVPOS	;Yes - was row changed?
	BEQL	20$		;No
	BISL	#M_XPL!M_XPC,F	;Yes - pointers are no good
	MOVL	SAVPOS,R7	;Restore saved row position
20$:	CMPL	R8,SAVPOS+4	;Was column changed?
	BEQL	30$		;No
	BISL	#M_XPC,F	;Yes - cursor position is no good
	MOVL	R8,R1		;Save change in columns in SAVEAC
	MOVL	SAVPOS+4,R8	;  and restore saved column pointer
	SUBL	R8,R1
	MOVL	R1,SAVEAC
	BGEQ	30$
	MNEGL	R1,SAVEAC
30$:	BRW	PUTTYP		;Output the positioning and return

.SUBTITLE Output the fence

;Subroutines to fix up the bottom line of the screen
;Erase it if NEL flag is set
;else puts up insert mode message, fence, or both

FIXBLC::BSBW	CLEARP		;Clear to end of screen

FIXBLN::BBC	#V_NEL,F1,FIXBLF ;Can bottom line remain fragged?
	BRW	CBOTOM		;Yes - just erase it
FIXBLF::BBC	#V_IMD,F,10$	;No - in insert mode?
	BBC	#V_BEP,F1,20$	;Yes - but beeping?
10$:	BICL	#M_FBL,F	;Not insert, or beeping - repair bottom line
	BRB	30$
20$:	JMP	INSMSG		;Insert, not beep - put up insert mode message
30$:	BBCC	#V_XPB,F,40$	;Is pointer to last line valid?
	BSBW	MAKBPT		;No - make it
40$:	MOVL	BOTPTR,R6	;Is there really a bottom line?
	BEQL	FNCPUT		;No - put up the fence and return
	BSBW	CBOTOM		;Else move to bottom of screen
	BRW	DISONE		;Re-do the bottom line and return

;Subroutine to put up the fence or insert mode message,
;but not repair the bottom line if no message should be displayed

FIXBLW::BBC	#V_IMD,F,10$	;In insert mode?
	BBS	#V_BEP,F1,10$	;Yes - but beeping?
	JMP	INSMSG		;Insert, not beep - put up insert mode message
10$:	BICL	#M_FBL,F	;Not insert, or beeping - repair bottom line
	BBCC	#V_XPB,F,20$	;Is pointer to last line valid?
	BSBW	MAKBPT		;No - make it
20$:	MOVL	BOTPTR,R6	;Is there really a bottom line?
	BEQL	FNCPUT		;No - put up the fence
	RSB			;Yes - do nothing

;*****************************************************************************
;Subroutine to output the fence (FNCCLR clears to end of screen)

FNCCLR::BSBW	CLEARP		;Clear to end of screen
FNCPUT::ADDL3	#3,R7,R1	;Get row + 3
	CMPL	R1,LPP.1	;Close to the bottom of the screen?
	BLSS	10$		;No
	BRW	CBOTOM		;Yes - just clear the bottom line
10$:	MOVAB	FENCE,R1	;Output the fence on the bottom line
	BSBW	PUTBTM
	BSBW	PROTOF
	BISL	#M_FNC,F	;Set flag to say fence is up
	BRW	POSCUR		;Re-position the cursor; done

;Subroutine to output insert mode message

INSMSG::BBC	#V_BEP,F1,10$	;Beeping?
	RSB			;Yes - no message
10$:	BBCC	#V_XPB,F,20$	;Is pointer to last line valid?
	BSBW	MAKBPT		;No - make it
20$:	MOVL	BOTPTR,R6	;Is there really a bottom line?
	BNEQ	30$		;Yes
	MOVAB	INSMS2,R1	;No - put up fence as well as insert mode
	BISL	#M_FNC,F
	BRB	40$
30$:	MOVAB	INSMS1,R1	;Yes - output just insert mode
	BICL	#M_FNC,F
40$:	BSBW	PUTBTM
	BSBW	PROTOF
	BISL	#M_FBL,F	;Mark bottom line as fragged
	BRW	POSCUR		;Re-position the cursor and return
INSMS1:	.ASCIZ	/ *INSERT MODE* /
INSMS2:	.ASCIZ	/ *INSERT MODE ** FENCE* /

.SUBTITLE	Subroutines to Position the Cursor

;*****************************************************************************
;Subroutines to position the cursor
;These just call the actual positioning routines in the terminal-dependent
;code, output idles as desired, and type out the type buffer

POSLIN::ADDL	HOMPOS,R4	;Make position relative to home
	JSB	@PSL(R10)	;Position to the right line
	SUBL	HOMPOS,R4	;Restore proper position
	BRB	POSEND		;Go finish off

POSCUR::ADDL	HOMPOS,R7	;Make row position relative to home
	JSB	@PSC(R10)	;Position to the right character
	SUBL	HOMPOS,R7	;Restore proper position
POSEND::BBC	#V_NLP,F1,20$	;Follow with some nulls?  No
	MOVB	NUL(R10),R1	;Yes - get null character
	CVTWL	NUL+2(R10),R2	;  and number of nulls to output
10$:	MOVB	R1,(R5)+	;Output a null
	SOBGTR	R2,10$		;Output all nulls, in fact
20$:	BRW	PUTTYP		;Then send it all out and return

.SUBTITLE	Terminal Dependent Output Section
;Store various character sequences in the type buffer

CBOTOM::BSBW	CMVBTM		;Move to bottom line
				;and fall into clear it code
CLRLNA::CVTBL	#-1,R0		;Set to clear entire line
	BRB	CLRLN2
CLRLNR::MOVL	R8,R0		;Set to clear to end of line
CLRLN2:	MOVL	CLN(R10),R1	;Can terminal clear to end of line?
	BEQL	5$		;No
	BRW	PUTSEQ		;Yes - go do it
5$:	MOVL	R2,-(SP)	;No - do it in software
	MOVL	R0,-(SP)	;Save some registers
	BGEQ	10$		;Is R0/-1?
	CLRL	R0		;Yes - make it zero
10$:	SUBL2	CPL(R10),R0	;Find number of spaces to output
	MNEGL	R0,R0
	MOVZBL	#^A" ",R1	;Get a space
	MOVAB	TYPBUF+TYPSIZ+1,R2 ;Set up end-of-type-buffer address
	BSBB	CLRLN1		;Space over
	MOVL	R8,-4(SP)	;Exchange CM and last stack item
	MOVL	(SP),R8
	MOVL	-4(SP),(SP)
	TSTL	R8
	BGEQ	20$		;Want a CR?
	MOVB	#^O15,(R5)+	;Yes - output it
	BSBW	PUTTYP		;and output the buffer
	BRB	30$
20$:	BSBW	POSCUR		;Re-position the cursor
30$:	MOVL	(SP)+,R8	;Get real column back
	MOVL	(SP)+,R2	;Restore R2 too
	RSB

CLRLN1:	SUBL	#2,R0
10$:	MOVB	R1,(R5)+	;Space over
	CMPL	R2,R5		;Is type buffer full?
	BGTR	20$		;No
	BSBW	PUTTYP		;Yes - output it
	MOVB	#^A" ",R1	;Get the space again
20$:	SOBGTR	R0,10$		;Do all the spaces
	RSB			;Done

CHOME::	TSTL	HOMPOS		;Is home really home?
	BNEQ	10$		;No
	MOVL	CHM(R10),R1	;Yes - get sequence for cursor home
	BRW	PUTSEQ		;and output it
10$:	CLRL	R4		;No - position to the fake home
	BRW	POSLIN

CLRALL::BBS	#V_WDW,F1,10$	;In a window?
	MOVL	HCP(R10),R1	;No - go home and clear page
	BRB	PUTSEQ
10$:	CLRL	R4		;Yes - position to fake home
	BSBW	POSLIN		;Position home
	TSTL	HOMPOS		;In lower window?
	BEQL	15$		;No
	MOVL	CPG(R10),R1	;Yes - can terminal clear to EOP?
	BEQL	20$		;No - continue
	BRB	PUTSEQ		;Yes - do it
15$:	SUBL3	#1,LPP(R10),R4	;In upper window - clear one line fewer
	BRB	40$
20$:	MOVL	LPP(R10),R4	;No - output a bunch of clear lines
	BRB	40$
30$:	BSBB	CDOWN
40$:	BSBW	CLRLNA
	SOBGTR	R4,30$
	BRB	CHOME		;Go home, output, and return

CLEARP::MOVL	CPG(R10),R1	;Clear to end of page
	BRB	PUTSEQ
PROTON::MOVL	PON(R10),R1	;Can protection be turned on?
	BNEQ	PUTSEQ		;Yes - do it
	RSB			;No - nothing to do
PROTOF::MOVL	POF(R10),R1	;Can protection be turned off?
	BNEQ	PUTSEQ		;Yes - do it
	RSB			;No - nothing to do
CMVBTM::MOVL	MVB(R10),R1	;Cursor to bottom
	BRB	PUTSEQ
CRIGHT::MOVL	CRG(R10),R1	;Cursor right
	BRB	PUTSEQ
CLEFT::	MOVL	CLF(R10),R1	;Cursor left
	BRB	PUTSEQ
CURUP::	MOVL	CUP(R10),R1	;Cursor up
	BRB	PUTSEQ
CDOWN::	MOVL	CDN(R10),R1	;Cursor down
	BRB	PUTSEQ
ROLLUP::MOVL	RUP(R10),R1	;Roll up and clear line
	BRB	PUTSEQ
ROLLDN::MOVL	RLD(R10),R1	;Roll down and clear line

;Subroutine to output up to 4 characters in R1 (PUTSQ1)

PUTSEQ::BITL	#^XFFFF,R1	;Got a routine address?
	BNEQ	10$		;No
	ASHL	#-16,R1,R1	;Yes - position the address offset
	ADDL	R10,R1		;Add in the base address
	JMP	(R1)		;and dispatch to it
10$:	BITL	#^XFF,R1	;Got the address of a long ascii string?
	BNEQ	PUTSQ1		;No
	ASHL	#-16,R1,R1	;Yes - position the string address
	ADDL	R10,R1		;Add in the base address
	BRB	PUTSTG		;and go output the string
PUTSQ1::MOVL	R1,TEMP		;Prepare to output the string
	MOVAB	TEMP,R1		;Point to the string
	BRB	PUTSTG		;and go output it

;Subroutine to move to bottom, clear, protect, and output (R1)

PUTBTM::MOVL	R1,SAVEAC+48	;Save the message address
	BSBW	CBOTOM		;Put message on bottom line
	BSBB	PROTON		;Protect
	MOVL	SAVEAC+48,R1	;Get address back

;Subroutine to output a string.  Address in R1 (fragged)

PUTSTG::TSTB	(R1)		;Check for null character
	BEQL	10$		;If so, done
	MOVB	(R1)+,(R5)+	;Save character in type buffer
	BRB	PUTSTG		;and loop
10$:	RSB			;Return on null character

;Subroutine to output a string ending in either space or null
;(Don't output the space).  String to be output is in R1

PUTSPCL::MOVL	R1,TEMP		;Save the string to be output
	MOVAB	TEMP,R1		;Point to the string
10$:	TSTB	(R1)		;Check for null character
	BEQL	20$
	CMPB	(R1),#^A" "	;Also check for space
	BEQL	20$
	MOVB	(R1)+,(R5)+	;Save character in type buffer
	BRB	10$
20$:	RSB			;Return on null or space

;Subroutine to output a string, address in R1 (fragged). Uses R0, R2
;Same as PUTSTG, but control characters are simulated by being protected
;If string being output is already protected enter PUTSTC; else PUTSTS

PUTSTS::CLRL	R2		;Clear flag to get simulation
	BRB	PUTSC1
PUTSTC::CVTBL	#-1,R2		;Set flag so no simulation
PUTSC1:	MOVZBL	(R1)+,R0	;Get a character
	CMPB	R0,#^O177	;Got a delimiter?
	BEQL	PUTSCD		;Yes - simulate it
	CMPB	R0,#^A" "	;Got a printing character?
	BLSS	PUTSC2		;No - simulate it
	MOVB	R0,(R5)+	;Save character in type buffer
	BRB	PUTSC1		;and loop

PUTSCD:	MOVZBL	#^A">"-64,R0	;Make 177 come out as protected ">"
PUTSC2:	TSTB	R0		;Check for null
	BNEQ	10$		;No
	RSB			;Yes - return
10$:	MOVL	R1,-(SP)	;Else save character and string address
	MOVL	R0,-(SP)
	TSTL	R2		;Want to protect?
	BNEQ	20$		;No
	BSBW	PROTON		;Yes - do so
20$:	MOVL	(SP)+,R0	;Restore the character
	ADDB	#^O100,R0	;Convert to printing character
	MOVB	R0,(R5)+	;Save it in the type buffer
	TSTL	R2		;Want to protect?
	BNEQ	30$		;No
	BSBW	PROTOF		;Yes - do so
30$:	MOVL	(SP)+,R1	;Restore the string address
	BRB	PUTSC1		;and continue

;Subroutine to output an error message (address in R1, fragged)
;Same as PUTSTG, but #'s are converted to spaces

PUTSTX::MOVZBL	(R1)+,R0	;Get a character
	BNEQ	10$
	RSB			;Done if null
10$:	CMPB	#^A"#",R0	;Else got an artificial space?
	BNEQ	20$
	MOVB	#^A" ",R0	;Yes - make it a real one
20$:	MOVB	R0,(R5)+	;Save in type buffer
	BRB	PUTSTX		;and loop

;Subroutine to output "more informative" error messages.
;Output a string, similar to PUTSTX, but expanding special codes
;in the string according to the values of ERRCOD and longwords following.
;	^A	output value in ASCII
;	^D	output value in decimal
;	^x	output character x (as long as x NE A,D)
;The first occurance of one of these symbols is expanded from ERRCOD/,
;the second from ERRCOD+4, the third from ERRCOD+8, etc.

PUTSTE::CVTBL	#-4,ERRCTR	;Set the error code counter
	MOVL	R1,ERRPTR	;Save the pointer
PTSTE0:	MOVZBL	@ERRPTR,R0	;Get a character
	BNEQ	10$
	RSB			;Done if null
10$:	INCL	ERRPTR		;Increment to next character
	CMPB	R0,#^A"#"	;Got an artificial space?
	BNEQ	20$
	MOVB	#^A" ",R0	;Yes - make it a real one
	BRB	PTSTE1
20$:	CMPB	R0,#^A"^"	;Got an up-arrow?
	BEQL	PTSTE2		;Yes - handle special
PTSTE1:	MOVB	R0,(R5)+	;Save character in type buffer
	BRB	PTSTE0		;and loop

PTSTE2:	MOVZBL	@ERRPTR,R0	;Peek at the next character
	BNEQ	10$
	RSB			;Done if null (not normal)
10$:	INCL	ERRPTR
	CMPB	R0,#^A"A"	;Ascii expansion?
	BEQL	PTSTEA		;Yes
	CMPB	R0,#^A"D"	;Decimal expansion?
	BEQL	PTSTED		;Yes
	BRB	PTSTE1		;No - just output the character

PTSTEA:	MOVAL	PUTSTG,R0	;Routine to put ASCII characters in type buffer
	BRB	PTSTE3		;Set up for and use routine

PTSTED:	MOVAL	PUTNUM,R0	;Routine to put Decimal number in type buffer
;	BRB	PTSTE3
PTSTE3:	ADDL	#4,ERRCTR	;Increment pointer to ERRCOD block
	MOVL	ERRCTR,R1
	MOVL	L^ERRCOD(R1),R1	;Load next ERRCOD longword into R1
	JSB	(R0)		;Output code via appropriate routine
	BRW	PTSTE0		;Go for another character

;Subroutine to output filespecs (for the switch command)
;Same as PUTSTG, but outputs only until first "/"

PUTSTF::MOVZBL	(R1)+,R0	;Get a character
	BNEQ	10$		;Done if null
5$:	RSB
10$:	CMPB	R0,#^A"/"	;Else got start of switches?
	BEQL	5$		;Yes - done
	MOVB	R0,(R5)+	;Save in type buffer
	BRB	PUTSTF		;and loop

;Subroutine to output the type buffer

PUTTYP::BBS	#V_XCT,F1,PUTTY2 ;If executing, throw the buffer away
	CMPL	#TYPBUF,R5	;Anything in the buffer?
	BNEQ	PUTTYF		;Yes
	RSB			;No - just return
PUTTYF::SUBL3	#TYPBUF,R5,TBFSIZ ;Compute size of the record
	MOVL	R0,-(SP)	;Save R0
	$QIOW_S	CHAN=TTCHAN,-	;Output the record
		FUNC=#IO$_WRITEVBLK!IO$M_NOFORMAT,-
		P1=TYPBUF,-
		P2=TBFSIZ
;Test for errors here
	MOVL	(SP)+,R0	;Restore R0
PUTTY2:	MOVAB	TYPBUF,R5	;Restore the buffer pointer
	RSB			;and return

;Subroutine to output a decimal number
;Enter with number in R1, uses R0, R1

PUTNPO::INCL	R1		;Output (R1) + 1
PUTNUM::PUSHR	#^M<R0,R1,R2,R3,R4,R5>	;Save registers
	CVTLP	R1,#8,TMPSTR	;Convert to packed decimal
	EDITPC	#8,TMPSTR,FIXPATTERN,DEC_STRING ;Convert to ascii string
	POPR	#^M<R0,R1,R2,R3,R4,R5> 	;Restore registers
	MOVAB	DEC_STRING,R1	;Point to the ascii string
	MOVZBL	#8,R0		;Get the length
10$:	CMPB	#^A"0",(R1)	;Get rid of leading zeros
	BNEQ	20$
	INCL	R1		;Step to next character
	SOBGTR	R0,10$
	MOVB	#^A"0",(R5)+
	RSB
20$:	MOVB	(R1)+,(R5)+	;Copy the rest of the string
	SOBGTR	R0,20$
	RSB			;Then return

;Pattern for the EDITPC command above
FIXPATTERN:	EO$SET_SIGNIF		;Set the significance flag
		EO$MOVE		8	;Move 8 bytes
		EO$END			;End the edit

;Subroutine to output filespecs (for the Save File command)
;Same as PUTSTG, but outputs only until first ";"

PUTFIL::MOVZBL	(R1)+,R0	;Get a character
	BNEQ	10$		;Done if null
5$:	RSB
10$:	CMPB	R0,#^A";"	;Else got start of version number?
	BEQL	5$		;Yes - done
	MOVB	R0,(R5)+	;Save in type buffer
	BRB	PUTFIL		;and loop

GLOB			;Define the external routines

.END