.TITLE SIMRT SUPPORT MODULE FOR PAPERTAPE
;
;
; COPYRIGHT (c) 1975,1976,1977,1978,1979,1980 BY
; DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS.
;
; 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 WHICH IS NOT SUPPLIED BY DIGITAL.
;
;

;	H.J./RRB
;	17-JAN-77	ROM MODS.  (G.D.H.)
;	25-JUL-77	BUG FIXES FOR ROMS ( J.I.E.)
;
;	B. MATTHEWS	17-OCT-79
;		INCORPORATE V2.1 PATCHES
;			1. PATCH 26 TO CORRECT SIMRT FROM OUTPUTING AN EXTRA
;			   LINE FEED AT THE END OF FORMATTED AND TREAT V3 .WAITs
;			   AS NOP's.
;
;	B. MATTHEWS	28-NOV-79
;		TREAT .PROTECT AS A NOOP
;	T. GLYNN	25-FEB-81
;		DECLARE	VIRSZ$	WITH .WORD DIRECTIVE
;

	.GLOBL	$SIMRT

	OTI$P
	.BLKW	15.		;FIO2 GOES HERE.
	.BLKW	3		;END2 GOES HERE.
				;CONTAINS ADDRESS OF $CLOSE
				;AVOIDS LOADING OF I/O ROUTINES IN
				;NON-I/O ENVIRONMENTS.
	.BLKW			;ADDRESS OF $CLOSE PUT HERE IF LOADED
	.WORD	INITAL		; ADDRESS OF INITIALIZATION CODE.
	.BLKW	1		; $QBLK ADDRESS GOES HERE
	.WORD			; $VIRSZ ADDRESS GOES HERE

	.ASECT
	.=0
LOCORE:	JMP	@40		;0	RESTART KINDNESS
				;2	USED
	T4HDR			;4	TIME-OUT ERROR HANDLER.
	HALT			;6
	T10HDR			;10	ILLEGAL INSTRUCTION TRAP HANDLER.
	+1			;12	CARRY SET
	16			;14	BREAKPOINT
	HALT			;16
	22			;20	IOT
	HALT			;22
	PWRHDR			;24	POWER FAIL
	340			;26
	EMTER			;30	EMT HANDLER ADDRESS
	0			;32	PS
	;34		TRAP
			;36
			;40	START ADDRESS OF JOB SET BY OTI
.=42
	$$$STK			;42	INITIAL VALUE OF SP
	0			;44	JSW
	.LIMIT			;46,50	MAKE 50 CONTAIN HIGH ADDRESS
	.=.-4
	0			;46	USR LOAD ADDRESS
	.=.+2
	0			;52	EMT ERROR CODE
	0			;54	HIGH USABLE CORE ADDRESS -
					; COMPUTED DYNAMICALLY IN INIT CODE.
	0			;56	FILL CHAR AND COUNT
	TTYIN			;60	TTY INPUT VECTOR
	0			;62	PS
	TTYOUT			;64	TTY OUTPUT VECTOR
	0			;66	PS

	.=244
	FPPHDR			;244	FPP INTERRUPT VECTOR.
	0			;246	PS

	.PSECT	$STACK,RW,D,LCL,REL
	.BLKW	100
	.PSECT	$STKST,RW,D,LCL,REL
$$$STK::

	OTI$S
;INPUT RING BUFFER AND POINTERS

	.BYTE	255.
IBUF:	.REPT	80.
	.BYTE	0
	.ENDR
IBUFEN:	.BYTE	255.
IEMPT:	.WORD	IBUF
ICR:	.WORD	0		;FLAG TO DETERMINE IF C.R. LAST CHAR
ICUR:	.WORD	IBUF



;THE OUTPUT RING BUFFER AND POINTERS

OBUF:	.REPT	80.		;SIZE OF OUTPUT RING RING BUFFER
	.BYTE	0		;ALL THE ELEMENTS HAVE TO BE +
	.ENDR
OBUFEN:	.BYTE	255.		;END OF RING SIGNIFIER
	.EVEN
OEMPT:	.WORD	OBUF		;EMPTY POSITION POINTER
OCNT:	.WORD	0		;CURRENT NUMBER OF CHARS IN BUFFER
OCUR:	.WORD	OBUF		;CURRENT CHARACTER POINTER
RUBFLG:	.BLKW
LINCNT:	.BLKW
STOPO:	.BLKW
CTRLOF:	.BLKW
TABCNT:	.BLKW

TRAP4:	.BLKW			; ADDRESS OF REAL TRAP4 HANDLER.
TRAP10:	.BLKW			; ADDRESS OF REAL TRAP 10 HANDLER.
FPPSET:	.BLKW			; ADDRESS OF REAL FPP INTERRUPT HANDLER.
HILIMT:	.BLKW			; REAL HIGH LIMIT.

	JSW = 54
	IDENT	06

INITAL:	MOV	#246,FPPSET	; INITIALLY NO FPP ISR.
	MOV	#TRP4,TRAP4	; WE'LL SET 1ST TRAP4 VECTOR.
	MOV	#6,TRAP10	; NO INITIAL TRAP 10 VECTOR.
	MOV	#IBUF-1,R0
2$:	CLR	(R0)+		; CLEAR OUT RING BUFFERS.
	CMP	R0,#IEMPT	; DONE?
	BLO	2$		; BR IF NO.
	MOVB	@PC,-1(R0)	; SET END OF RING PTR
	MOV	#IBUF,(R0)+
	CLR	(R0)+
	MOV	#IBUF,(R0)+
3$:	CLR	(R0)+
	CMP	R0,#OBUFEN
	BLO	3$
	MOV	#377,(R0)+
	MOV	#OBUF,(R0)+
	CLR	(R0)+
	MOV	#OBUF,(R0)+
4$:	CLR	(R0)+
	CMP	R0,#TABCNT
	BLOS	4$
	COMB	IBUF-1		; THIS BYTE GETS A -1.
	MOV	@#50,R0		; GET HIGH LIMIT.
	BIC	#777,R0		; DIV 1/4 K.
	MOV	SP,R2		; * SAVE INITIAL SP VALUE.
1$:	TST	@R0		; IS MEMORY THERE?
	ADD	#1000,R0	; HOW 'BOUT NEXT BOUNDRY.
	CMP	R0,#160000	; ARE WE STILL IN REAL MEMORY?
	BLO	1$		; BR IF YES.
TRP4:	MOV	R2,SP		; * RESET STACK POINTER.
	SUB	#36,R0		; ACTUAL HI LIMIT (FOR SETTOP).
	MOV	R0,HILIMT	; SAVE IT.
	MOV	#6,TRAP4	; SAY NO TRAP4 HANDLER.
	RTS	PC		; AND RETURN.

$SIMRT:
EMTER:	MOV	R1,-(SP)	;SAVE REGS
	MOV	2(SP),R1	;GET PC OF TROUBLE MAKER
	MOV	R2,-(SP)
	MOV	R3,-(SP)
	MOV	R4,-(SP)
	MOV	R5,-(SP)
	MOV	R0,-(SP)
	MOV	-(R1),R1	;GET EMT INSTRUCTION
	BIC	#EMT,R1		;REMOVE EMT OPCODE
	MOV	R1,R2		;COPY REQUEST CODE
	BIC	#177417,R2	;STRIP OFF CHANNEL, CHECK WAIT
	CMP	#240,R2		;240 IS A WAIT
	BEQ	BRNOP		;WHICH IS A NOP TO US
	SUB	#340,R1		;340 IS LOWEST EMT CODE EMULATED
	BLT	UNSUPT		;LESS THAN 340 IS ERROR
	CMP	#375-340,R1	;375 IS SPECIAL CASE FOR V2
	BEQ	EMT375		;IF 375 GO PROCESS SUBCODE
	CMP	#374-340,R1	;374 IS SPECIAL CASE FOR V3.
	BEQ	EMT374
	CMP	#355-340,R1	;355 IS HIGHEST CODE HANDLED
	BLO	UNSUPT		;BRANCH IF UNSUPPORTED
	ASL	R1		;GET WORD INDEX
	JMP	@DISPAT(R1)	;JUMP TO APPROPRIATE ROUTINE

DISPAT:	.WORD	TTYINR		;340
	.WORD	TTOUTR		;341
	.WORD	DSTATS		;342
	.WORD	UNSUPT		;343
	.WORD	UNSUPT		;344
	.WORD	UNSUPT		;345
	.WORD	NOP		;346
	.WORD	NOP		;347	UNLOCK
	.WORD	EXIT		;350	EXIT
	.WORD	PRINT		;351
	.WORD	UNSUPT		;352
	.WORD	NOP1		;353	QSET
	.WORD	SETTOP		;354
	.WORD	RCTRLO		;355

	.GLOBL	$HRDWR		;MATH HARDWARE LEVEL (FROM OTS)
T4HDR:	JMP	@TRAP4		; DISPATCH TO TRAP  4 HANDLER.
T10HDR:	JMP	@TRAP10		; DISPATCH TO TRAP 10 HANDLER.
FPPHDR:	CMP	#$HRDWR,#8.	;DOES FP-11B EXIST?
	BLO	FPPEXT		;NOPE - IT'S FIS
	STST	-(SP)		;ELSE STORE FPU STATUS
FPPEXT:	JMP	@FPPSET		;JUMP TO INTERRUPT SERVICE
PWRHDR:	MOV	#$$$STK,SP	;RESET STACK POINTER.
	CLR	-(SP)		; NEW PS.
	MOV	@#40,-(SP)	; * NEW START ADDRESS.
	RTI			; THIS CODE DISABLES INTERRUPTS AT STARTUP.

EMT375:	CMP	#27.*400,@R0	;R0 -> ARG BLOCK; IS IT .CNTXSW?
	BEQ	BRNOP		;YES - .CNTXSW IS A NOP TO US
	CMP	#31*400,@R0	;IS IT A .PROTECT 26-NOV-79
	BEQ	BRNOP		;YES, TREAT AS NOP 26-NOV-79
	CMP	#24.*400,@R0	;.SFPA ?
	BNE	1$		;NO - GO CHECK FOR .GTJB
	MOV	2(R0),FPPSET	;SET FLOATING POINT EXCEPTION ADDRESS
	JMP	NOP

1$:	CMP	#3.*400,(R0)+	;.TRPSET?
	BNE	2$		;BRANCH IF NO
	MOV	@R0,TRAP4	;SET TRAP
	MOV	@R0,TRAP10	; 4 AND 10
	BR	NOP

2$:	CMP	#16.*400,-2(R0)	;.GTJB ?
	BNE	UNSUPT		;IF NOT, IT'S AN UNSUPPORTED EMT
	MOV	@R0,R0		;R0 -> 8-WORD PARM BLOCK
	CLR	(R0)+		;JOB # = 0 (BACKGROUND)
	MOV	HILIMT,(R0)+	;HIGH LIMIT SET BY .SETTOP
	CLR	(R0)+		;LOW LIMIT IS ZERO ON BARE MACHINE
	BR	NOP		;IGNORE CHANNEL AREA INFO (UNUSED BY F4)

	ARG1=20			;FIRST PASSED ARG ON STACK
	ARG2=22			;2ND

RCTRLO:	CLR	CTRLOF		;TURN ON TTY OUTPUT
BRNOP:	BR	NOP

;PROBABLY A GOOD TIME TO START THE TTY
SETTOP:	MOV	#100,@$TPS	;INITIALIZE TTY OUT
	MOV	#101,@$TKS	;INITIALIZE TTY IN
	MOV	HILIMT,R0	;SET SETTOP ADDRESS FOR OTI
	TST	-(R0)		; PRESERVE 1ST WORD OF ABS LOADER.
	BR	NOP

DSTATS:	CMP	(PC)+,@R0	;ONLY GOOD IF TTY
	.RAD50	/TT /
	BNE	BADRT1		;SUCCCEEDS ONLY FOR TTY
	MOV	ARG1(SP),R1	;ADDR TO RETURN INFO TO
	MOV	#4,(R1)+	;FLAG AS TTY
	MOV	#100,(R1)+	;A GUESS AT THE SIZE
	MOV	#TTOUTR,(R1)+	;POSIBLE ENTRY POINT
	CLR	@R1		;DIRECTORY SIZE WORD
	BR	NOP1		;SUCESSFUL RETURN WITH 1 ARG ON STACK

REMARG:	MOV	SP,R2		;PUSH REGS AND PS DOWN OVER AN ARG
	ADD	#ARG1+2,R2	;POINT R2 TO ARG1, REMEMBERING RET ADDR
	MOV	R2,R3		;POINT R3 TO AFTER ARG
	TST	(R3)+
	MOV	#9.,R4		;PUSH 9 WORDS DOWN, INCLUDING RET ADDR
1$:	MOV	-(R2),-(R3)	;PUSH WORD DOWN
	DEC	R4		;COUNT
	BNE	1$		;DO'EM ALL
	TST	(SP)+		;GET EXTRA WORD OFF TOP OF STACK
RTSRET:	RTS	PC		;RETURN	

EXIT:	MOV	#STOP,R5	;OUTPUT A STOP MESSAGE
	BR	MSGOUT		;SEND MESSAGE

EMT374:	BIC	#377,R0		; CLEAR LOW BYTE OF EMT 17-OCT-79
	BEQ	NOP		; IF ZERO THEN V3 .WAIT TREAT AS NOP 17-OCT-79
	SUB	#10.*400,R0	; SUB CODE 0?
	BEQ	NOP		; IF SO RETURN 0 FOR DATE.
				; ELSE UNSUPPORTED EMT.
UNSUPT:	MOV	#NEEDRT,R5	;OUTPUT THE BAD NEWS
MSGOUT:	JSR	PC,OSTRNG	;SEND THE MESSAGE
1$:	BR	1$		;LOOP

PRINT:	MOV	R0,R5		;SAVE ADDR OF STRING IN R5
	JSR	PC,OSTRNG	;OUTPUT STRING POINTED TO BY R5
	BR	NOP		;RETURN

ONE$:	JSR	PC,TTIOUT	;OUTPUT THE CHARACTER
OSTRNG:	MOVB	(R5)+,R0	;GET NEXT BYTE
	BGT	ONE$		;GO PUT OUT THE CHARACTER
	BMI	RTSRET		;RETURN
	MOVB	#15,R0		;SET UP TO DO THE C.R.
	JSR	PC,TTIOUT	; OUTPUT THE C.R. 17-OCT-79
	MOVB	#12,R0		; SET UP TO OUTPUT L.F. 17-OCT-79
	JMP	TTIOUT		; OUTPUT THE L.F. AND EXIT 17-OCT-79
	
TTOUTR:	JSR	PC,OUTCHR	;OUTPUT THE CHARACTER IN R0
	BCS	BADRET		;RING BUFFER FULL
	BR	NOP		;LEAVE

	.ENABL	LC
NEEDRT:	.ASCIZ	/****** A requested operation needs RT-11/
STOP:	.ASCIZ	<15><12><12><12>/****** Stop/

	.EVEN

BADRT1:	JSR	PC,REMARG	;REMOVE A WORD FROM BOTTOM OF STACK
BADRET:	BIS	#1,16(SP)	;SET CALLERS CARRY
	BR	SKIP
NOP1:	JSR	PC,REMARG	;GET RID OF WORD ON STACK AT BOOTOM
				;CLEANS OF UNWANTED ARGS ON STACK
NOP:	BIC	#1,16(SP)	;CLEAR CALLERS CARRY
SKIP:	MOV	(SP)+,R0
	MOV	(SP)+,R5	;RESTORE REGS
	MOV	(SP)+,R4
	MOV	(SP)+,R3
	MOV	(SP)+,R2
	MOV	(SP)+,R1
	RTI			;RETURN
$TKS::	.WORD	177560		;TELETYPE KEYBOARD STATUS
$TKB::	.WORD	177562		;TELETYPE KEYBOARD BUFFER
$TPS::	.WORD	177564		;TELETYPE PRINTER STATUS
$TPB::	.WORD	177566		;TELETYPE PRINTER BUFFER

	.ENABL	LSB

TTYIN:	MOV	R1,-(SP)	;SAVE THE REGISTERS
	MOV	R2,-(SP)
	MOV	R3,-(SP)
	MOV	R4,-(SP)
	MOV	R5,-(SP)
	MOV	R0,-(SP)
	MOVB	@$TKB,R0	;GET INPUTTED CHAR
	BIC	#177600,R0	;GET RID OF PARITY
	BEQ	SKIP		;IGNORE NULLS
	BIT	#40000,@#JSW	;ENABLE LC SET?
	BNE	1$		; BR IF YES.
	CMP	R0,#141		;BE KIND AND CAPITALIZE ALL CHARS
	BLT	1$		;BRANCH IF CHAR LOWER THAN LOWERS
	CMP	R0,#172		;CHECK UPPER RANGE OF LOWER CASE
	BGT	1$		;BRANCH IF CHAR GREATER THAN LOWERS
	SUB	#40,R0		;MAPPING FUNCTION TO UPPER CASE
1$:	MOV	#IEMPT,R3	;INIT IN POINTER
	MOV	#SPEC,R1	;GET ADDRESS OF SEARCH LIST
2$:	MOVB	(R1)+,R2	;GET OFFSET OF ROUTINE
	BEQ	NORMAL		;0 MEANS END OF LIST
	CMPB	(R1)+,R0	;IS THIS A MAGIC CHARACTER
	BNE	2$		;LOOP THROUGH THE LIST
	JMP	HERE(R2)	;GO TO HANDLER

3$:	MOV	#IBUF,-(R3)	;RESET TO BEGINING OF BUFFER
NORMAL:	TSTB	@(R3)+		;SEE IF NEXT SLOT EMPTY
	BEQ	5$		;BRANCH IF IT IS
	BMI	3$		;HIT END OF RING, RESET POINTER
	MOV	#7,R0		;SET BELL CHAR
	BR	OUTIT		;LET'EM KNOW RING FULL
5$:	MOVB	R0,@-(R3)	;PUT CHAR INTO BUFFER
	TST	RUBFLG		;SEE IF WE'RE IN A RUBOUT SEQUENCE
	BEQ	4$		;BRANCH IF NOT
	JSR	PC,TBSLSH	;HIT'EM WITH A \
	MOVB	@0(R3),R0	;RESTORE THE CHAR
4$:	INC	@R3		;BUMP THE RING POINTER
OUTIT:	JSR	PC,TTIOUT	;OUTPUT THE CHAR IN R0
HERE:	BR	SKIP		;RETURN FROM INTERUPT

	.DSABL	LSB

ALT:	MOV	#33,R0		;MAKE ALL ALTMODES LOOK ALIKE
	BR	NORMAL

CR:	MOVB	#12,R0		; SET UP TO OUTPUT A L.F. 17-OCT-79
	JSR	PC,TTIOUT	; OUTPUT THE L.F. 17-OCT-79
	MOVB	#15,R0		; SET UP C.R. AS CURRENT CHAR 17-OCT-79
	INC	LINCNT		;A FULL LINE HAS BEEN COLLECTED
	BR	NORMAL		;PUT IT IN INPUT BUFFER

CTRLS:	MOV	SP,STOPO	;SET ^S FLAG
	BR	SKIP		;EXIT
CTRLQ:	CLR	STOPO		;CLEAR ^S STATE
	CLR	@$TPS		;CLEAR STATUS SO RESET WILL CAUSE INT
	MOV	#100,@$TPS	;RESET INTERRUPT FLAG
	BR	SKIP		;EXIT

CTRLO:	COM	CTRLOF		;INVERT CONTROL O FLAG
	BR	OUTIT

RUBOUT:	JSR	PC,BACKUP	;BACKUP UP A CHAR IF POSSIBLE
	BEQ	CRLF		;BRANCH IF NOT
	TST	RUBFLG		;ARE WE IN A RUBOUT SEQUENCE?
	BNE	1$		;BRANCH IF YES
	JSR	PC,TBSLSH	;OUTPUT A \
1$:	MOVB	R4,R0		;R4 CONTAINS REMOVED CHAR
	BR	OUTIT		;ECHO IT

CTRLU:	JSR	PC,TTIOUT	;SEND THE ^U
1$:	JSR	PC,BACKUP	;BACKUP A CHAR
	BNE	1$		;GET BACK TO BEGINING OF LINE

CRLF:	TST	RUBFLG		;TEST RUBFLG
	BEQ	1$		;BRANCH IF NOT IN RUBOUT SEQUENCE
	JSR	PC,TBSLSH	;OUTPUT A \
1$:	MOVB	#15,R0		;SET UP TO SEND A C.R.
	JSR	PC,TTIOUT	; OUTPUT THE C.R. 17-OCT-79
	MOVB	#12,R0		; NOW SET UP TO OUTPUT THE L.F. 17-OCT-79
	BR	OUTIT		;SEND IT

CTRLC:	JSR	PC,TTIOUT	;ECHO ZEE ^C
	JMP	EXIT		;PERFORM AN EXIT


TTYINR:	TST	LINCNT		;SEE IF A LINE IS READY
	BNE	4$		; BRANCH IF CHARS AVAILABLE 17-OCT-79
	JMP	BADRET		; JUMP IF NO CHARS AVAILABLE YET 17-OCT-79
4$:	MOV	#ICR,R3		;GET ADDR OF INTERSETING POINTERS
	TST	(R3)+		;DID WE JUST GIVE BACK A C.R.?
	BEQ	1$		;BRANCH IF NOT
	CLR	-(R3)		;RESET C.R. FLAG
	DEC	LINCNT		;REDUCE NUMBER OF FULL LINES
	MOV	#12,R0		;SET UP TO RETURN A L.F.
	BR	3$		;RETURN IT
2$:	MOV	#IBUF,-(R3)	;RESET RING POINTER
1$:	MOVB	@(R3)+,R0	;GET A CHAR OUT OF RING BUFFER
	BMI	2$		;WE'RE WRAPPING AROUND
	CLRB	@-(R3)		;EMPTIFY POSITION
	INC	@R3		;BUMP POINTER
	CMPB	#15,R0		;SEE IF LINE TERMINATOR
	BNE	3$		;BRANCH IF NOT
	INC	-(R3)		;SET C.R. FLAG
3$:	MOV	R0,@SP		;RETURN CHAR IN R0
	JMP	NOP		;GIVE SUCESSFUL RETURN

WRAPA:	MOV	#IBUFEND,@R3	;RESET RING POINTER TO END
BACKUP:	MOV	@R3,R2		;GET ADDRESS OF NEXT SLOT
	MOVB	-(R2),R4	;GET CHAR INTO R4
	BMI	WRAPA		;BACKED INTO BEGINING OF BUFFER
	BEQ	1$		;NOTHING IN BUFFER
	CMPB	#15,R0		;DID WE BACK INTO A C.R.
	BEQ	1$		;BRANCH IF SO
	CLRB	@R2		;REMOVE CHAR FROM BUFFER
	DEC	@R3		;MOVE EMPTY BACK 1
1$:	RTS	PC		;RETURN
	
TBSLSH:	COM	RUBFLG		;INVERT RUBFLG
	MOVB	#'\,R0		;SET UP \
				;SEND IT AND RETURN

;	DELETED CODE IN TTIOUT TO PUT OUT EXTRA LINE FEED 17-OCT-79

TTIOUT:	JSR	PC,OUTCHR	;INSERT IT INTO OUTPUT RING
	BCS	TTIOUT		;WAIT UNTIL IT FITS
	RTS	PC		;RETURN

TTYOUT:	MOV	R1,-(SP)	;SAVE THE REGISTERS
	MOV	R2,-(SP)
	MOV	R3,-(SP)
	MOV	R4,-(SP)
	MOV	R5,-(SP)
	MOV	R0,-(SP)
	TST	STOPO		;SEE IF ^S IS IN EFFECT
	BNE	SKIP1		;BRANCH IF IT IS
	MOV	#OCNT,R5	;GET ADDRESS OF INTERESTING OUTPUT INFO
NOTYPE:	TST	(R5)+		;SEE IF ANY CHARS LEFT IN RING
	BNE	2$		;BRANCH IF SOME LEFT
	CLR	@$TPS		;CLEAR INT SO NEW CHAR CAN CAUSE ONE
	BR	SKIP1		;LEAVE
2$:	MOVB	@(R5)+,R0	;GET NEXT CHAR
	BPL	1$		;A REAL CHAR
	MOV	#OBUF,-(R5)	;RESET RING POINTER WHEN WE HIT END
	BR	2$		;TRY AGAIN
1$:	INC	-(R5)		;BUMP POINTER
	DEC	-(R5)		;DECREMENT CHAR COUNT
	TST	CTRLOF		;SEE IF CONTROL O ON
	BNE	NOTYPE		;BRANCH TO CLEAR OUT RING BUFFER
	MOVB	R0,@$TPB	;STICK NEW CHARACTER INTO TTY OUTPUT
SKIP1:	JMP	SKIP		;RETURN


	.ENABL	LSB

OUTCHR:	MOV	#OCNT,R1	;GET ADDRESS OF OUTPUT POINTERS
	CMP	#<OBUFEND-OBUF-1>,@R1	;SEE IF BUUFER FULL?
	BLO	NOTRDY		;C IS SET IF BRANCH OCCURS(BUFFER FULL)
	BIC	#177600,R0	;GETRID OF PARITY
	MOV	R0,-(SP)	;SAVE THE CHAR
	BEQ	1$		;OUTPUT NULLS AS IS
	CMPB	#33,R0		;CHECK TYPE OF CHAR
	BEQ	2$		;BRANCH IF ALTMODE
	BLT	6$		;CHAR IS REGULAR 1 SPACE TYPE
	CMP	#7,R0		;IS IT BELL?
	BEQ	1$		;OUTPUT AS IS
	CMP	#15,R0		;IS IT C.R.
	BEQ	3$		;BRANCH IF SO
	BLT	4$		;BRANCH TO OUTPUT AS CONTROL CHAR
	CMP	#11,R0		;IS IT A TAB?
	BEQ	5$		;BRANCH IF TAB
	BLT	1$		;BRANCH TO OUTPUT AS IS(L.F.,V.T.,F.F.)
4$:	MOV	#'^,R0		;OUTPUT CHAR AS ^CHAR+100
	JSR	PC,TTIOUT	;SEND IT
	MOV	@SP,R0		;GET ORGINAL
	ADD	#100,R0		;MAKE IT PRINTABLE
	JSR	PC,TTIOUT	;GO OUTPUT IT
	BR	7$		;GO TO SUCCESS CODE
2$:	MOV	#'$,R0		;OUTPUT ALTMODE AS $
6$:	INC	TABCNT		;BUMP COLUMN COUNTER
	BR	1$		;GO OUTPUT IT
3$:	CLR	TABCNT		;RESET TO BEGINING OF LINE
	BR	1$		;OUTPUT THE CHAR
5$:	MOV	#40,R0		;CONVERT TABS TO BLANKS
	JSR	PC,TTIOUT	;OUTPUT A BLANK
	BIC	#177770,TABCNT	;SEE IF AT TAB STOP?
	BNE	5$		;BRANCH IF NOT
	BR	7$		;GO THROUGH SUCCESS EXIT CODE
8$:	MOV	#OBUF,(R1)+	;RESET START OF RING POINTER
1$:	TSTB	@-(R1)		;SEE IF WE HIT END OF RING
	BMI	8$		;BRANCH TO RESET IT
	MOVB	R0,@(R1)+	;PUT CHAR INTO RING
	INC	@R1		;BUMP THE COUNT
	INC	-(R1)		;BUMP CURRENT POINTER
	MOV	#100,@$TPS	;POKE INTERRUPT IN CASE I IGNORED ONE
	TSTB	R0		;+OUTPUT CHAR A NULL?
	BEQ	7$		;+BR IF YES. DONT FILL AFTER NULL.
	CMPB	@#56,R0		;CHECK FILL CHAR
	BNE	7$		;NOT IT
	MOVB	@#57,R2		;SET UP FILL COUNT
	BEQ	7$		;+BR IF NO FILL COUNT.
	CLR	R0		;SET UP TO SEND NULLS
9$:	JSR	PC,TTIOUT	;OUTPUT THE NULL
	DEC	R2		;DID WE OUTPUT THE REQUIRED NUMBER?
	BGT	9$		;OUT PUT ANOTHER FILL CHAR
7$:	MOV	(SP)+,R0	;RESTORE THE ORIGINAL CHAR
	CLC			;SIGNIFY SUCCESS
NOTRDY:	RTS	PC		;RETURN

	.DSABL	LSB

SPEC:	.BYTE	CTRLC-HERE,'C&77
	.BYTE	CTRLO-HERE,'O&77
	.BYTE	CTRLS-HERE,'S&77
	.BYTE	CTRLQ-HERE,'Q&77
	.BYTE	CTRLU-HERE,'U&77
	.BYTE	ALT-HERE,175
	.BYTE	ALT-HERE,176
	.BYTE	RUBOUT-HERE,177
	.BYTE	CR-HERE,15
	.BYTE	0

	.END