COMMENT ⊗   VALID 00009 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00002 00002	.TITLE IO
C00004 00003	"TYPSTR"  - TELETYPE OUTPUT ROUTINE
C00007 00004	"INSTR" - TELETYPE INPUT ROUTINE
C00010 00005	"HSR"   - HIGH SPEED READER INPUT ROUTINE
C00012 00006	"RNUM" - STRING TO SCALED INTEGER NUMBER CONVERSION
C00019 00007	"PNUM" - PRINTS A SCALED INTEGER AS A REAL NUMBER
C00021 00008		["PNUM" - CONT.]
C00024 00009	"CLRCMA","PRTCMA","TICKLE","TTYHIT"
C00027 ENDMK
C⊗;
.TITLE IO

;CONSOLE TELETYPE INTEFACE LOCATIONS

TTYIS	=177560		;INPUT STATUS REG
TTYIR	=177562		;INPUT REG
TTYOS	=177564		;OUTPUT STATUS REG
TTYOR	=177566		;OUTPUT REG

;RDRS	=167770		;HSP READER STATUS REG
;RDR	=167774		;HSP READER INPUT REG
RDRS	=177560		;HSP READER STATUS REG
RDR	=177562		;HSP READER INPUT REG

;PDP10 COMMUNICATIONS LINK AND TYPE OUT ROUTINE

.IFZ LSI

HCOR	=157776		;HIGHEST USEABLE WORD IN CORE
OREG	=HCOR		;PUT SOMETHING HERE, 11TTY WILL PRINT IT ON CONSOLE
IREG	=HCOR-2		;11TTY PUTS STUFF HERE FOR CONSOLE INPUT
OUTSW	=HCOR-4		;0 => YOUR CONSOLE; -1 => VT05

TYPCHR:	TST 	OUTSW		;VT05 OR CONSOLE?
	BEQ 	TYPCH1	
	TSTB 	TTYOS		;VT05 READY?
	BPL	TYPCHR		;NO
	MOVB 	R0,TTYOR	;OUTPUT A BYTE
	CMP 	#12,R0		;WAS IT A LINE FEED?
	BNE 	TYPRET		;IF NOT THAT CODE, THEN DONE.
	CLR 	R0		;OUTPUT 3 NULLS
	JSR 	PC,TYPCHR
	JSR 	PC,TYPCHR
	BR  	TYPCHR

TYPCH1:	TSTB 	OREG		;CONSOLE READY?
	BNE 	TYPCHR		;NO
	MOVB 	R0,OREG		;OUTPUT A BYTE
	MOV	#1,172566	;WAKE UP PDP10 BY GENERATING INTERRUPT
TYPRET:	RTS 	PC

.ENDC
;"TYPSTR"  - TELETYPE OUTPUT ROUTINE

;"TYPSTR" OUTPUTS A STRING ENDING WITH A NULL CHARACTER.  A POINTER TO
;THE START OF THE STRING MUST BE LOADED INTO THE SP REGISTER.  NO
;OTHER REGISTERS ARE AFFECTED.

TYPSTR:	MOV	R0,-(SP)
	BR	2$
1$:	JSR	PC,TYPCHR	;TYPE THIS CHARACTER
2$:	MOVB	(SG)+,R0	;GET A CHARACTER
	BNE	1$		;REPEAT TILL END OF STRING
	MOV	(SP)+,R0
	RTS	PC

.IFNZ LSI
TYPCHR:	TSTB	@#TTYOS		;TTY AVAILABLE?
	BPL	TYPCHR		;NO, BUSY WAIT
	MOVB	R0,@#TTYOR	;YES, SEND OFF THE CHARACTER
	CMP	#12,R0		;WAS IT A LINE FEED?
	BNE	TYPRET		;IF NOT THAT CODE, THEN DONE
	CLR	R0		;OUTPUT 3 NULLS
	JSR	PC,TYPCHR
 	JSR	PC,TYPCHR
	BR	TYPCHR
TYPRET:	RTS	PC
.ENDC


;"LINOUT" TYPES A ASC STRING OF CHARACTERS ON TO THE TELETYPE.  THE
;ASC STRING IS A ASSUME TO END WITH A NULL CHARACTER.  A CR/LF IS
;ADDED TO THE END OF THE STRING DURING TYPE OUT.

LINOUT:	JSR	PC,TYPSTR
	MOV	#CRLFX,SG
	JSR	PC,TYPSTR
	RTS	PC


;"CRLF" IS A SUBROUTINE FOR TYPING OUT ONE CARRIAGE RETURN AND LINE
;FEED ON THE TELETYPE.

CRLF:	MOV	#CRLFX,SG
	JSR	PC,TYPSTR
	RTS	PC
CRLFX:	.BYTE	15,12,0,0


;"NULLS" PRINTS OUT A SERIES OF NULL CHARACTERS THAT SERVES
;AS A LEADER FOR PUNCHED PAPER TAPES.

NULLS:	MOV	R0,-(SP)
	MOV	R1,-(SP)
	MOV	#80.,R1		;PUNCH THIS MANY NULLS
	CLR	R0
	JSR	PC,TYPCHR	;PUNCH A NULL
	SOB	R1,.-4
	MOV	(SP)+,R1
	MOV	(SP)+,R0
	RTS	PC

;END OF OUTPUT ROUTINES
;"INSTR" - TELETYPE INPUT ROUTINE

;THE STRING BYTE POINTER MUST BE IN SG.  A CARRIAGE RETURN IS ASSUMED
;TO BE THE ACTIVATION CHARACTER.  A RUB OUT IS A DELETING BACKSPACE
;CHARACTER.  A RUB OUT TYPED WHEN NO CHARACTERS ARE IN THE LINE BUFFER
;ALSO ACTIVATES AND RETURNS AN EMPTY LINE.  AT THE COMPLETION OF THIS
;ROUTINE, A NULL CHARACTER IS PLACED IN THE INPUT STRING. SG IS LEFT
;UNCHANGED.

;REGISTERS USED:
;	SG PASSES THE ARGUMENT AND IS NOT MODIFIED

INSTR:	MOV	R0,-(SP)
	MOV	R1,-(SP)
	MOV	SG,-(SP)
	CLR	R1		;SET = 1 IF LAST CHAR WAS A BS
IN2:
  .IFNZ LSI
	INCB	@#TTYIS		;START PAPER TAPE READER IF NEC.
	TSTB	@#TTYIS		;TTY READY?
	BPL	.-4
	MOVB	@#TTYIR,R0	;GET A CHARACTER
  .IFF
	TST 	OUTSW		;VT05 OR CONSOLE?
	BEQ 	CONSIN	
	TSTB	TTYIS		;TEST IF KEYBOARD READY
	BEQ	IN2		;WAIT TILL IT IS
	MOVB	TTYIR,R0	;GET A CHARACTER
	BR	GOTCAR
CONSIN:	MOV	IREG,R0		;BYTE FROM PDP10?
	BEQ	IN2		;NO
	CLR	IREG
   .ENDC
GOTCAR:	BIC     #177600,R0	;MASK OFF - MAKE IT 7 BITS
	CMP	R0,#177		;BACK SPACE?
	BNE	IN4		;NO
	CMP	SG,(SP)		;ACTIVATE IF NO CHARACTERS
	BEQ	IN7
	TST	R1		;LAST CHAR A BS?
	BGT	IN3		;YES
	MOV	#'\,R0		;PRINT \ TO INDICATE RUB OUT
	JSR	PC,TYPCHR
	MOV	#1,R1
IN3:	MOVB	-(SG),R0	;PRINT DELETED CHARACTER
	BR	IN6
IN4:	CMP	R0,#15		;C/R?
	BEQ	IN8		;TERMINATE IF ITS A CR
	CMP	R0,#40		;LEGAL CHARACTER?
 	BLT	IN2		;IGNOR IF ITS NOT LEGAL
	CMPB	#141,R0		;CHANGE TO UPPER CASE IF ALPHA
	BGT	IN5
	CMPB	#172,R0
	BLT	IN5
	BIC	#40,R0
IN5:	MOVB	R0,(SG)+	;ELSE SAVE THE CHARACTER
	DEC	R1		;LAST CHAR A RUB OUT?
	BMI	IN6		;NO
	MOV	#'\,R0		;YES, INDICATE 1ST NEW CHAR
	JSR	PC,TYPCHR
	MOVB	-1(SG),R0
IN6:	JSR	PC,TYPCHR	;ECHO
	BR	IN2

IN7:	MOV	#'\,R0		;INDICATE ACTIVATION
	JSR	PC,TYPCHR
IN8:	CLRB	(SG) 		;PUT IN A NULL CHARACTER
	JSR	PC,CRLF		;TYPE CR/LF
	MOV	(SP)+,SG
	MOV	(SP)+,R1
	MOV	(SP)+,R0
	RTS	PC

;END OF "INSTR"
;"HSR"   - HIGH SPEED READER INPUT ROUTINE

;THE STRING BYTE POINTER MUST BE IN SG.  A CARRIAGE RETURN IS ASSUMED
;TO BE THE ACTIVATION CHARACTER.  AT THE COMPLETION OF THIS ROUTINE,
;A NULL CHARACTER IS PLACED IN THE INPUT STRING.  SG IS LEFT UNCHANGED.
;IF A CR IS TYPED ON THE TTY KEYBOARD WHILE THIS ROUTINE IS READING,
;THE OPERATION IS ABORTED AND AN ERROR MESSAGE PTR IS LEFT IN R1 AND
;THE C BIT IS SET, OTHERWISE THE C BIT IS CLEARED.

;REGISTERS USED:
;	SG PASSES THE ARGUMENT AND IS NOT MODIFIED

HSR:	MOV	R0,-(SP)
	MOV	SG,-(SP)
1$:	JSR	PC,TICKLE	;ABORT?
	BCS	4$		;YES
	TSTB	@#RDRS		;CHARACTER IN BUFFER?
	BPL	1$
	MOVB	@#RDR,R0	;GET A CHARACTER
	BIC     #177600,R0	;MASK OFF - MAKE IT 7 BITS
	CMP	R0,#15		;C/R?
	BEQ	3$		;TERMINATE IF ITS A CR
	CMP	R0,#177		;RUB OUT?
	BEQ	1$		;IGNOR
	CMP	R0,#40		;LEGAL CHARACTER?
 	BLT	1$		;IGNOR IF ITS NOT LEGAL
	CMPB	#141,R0		;CHANGE TO UPPER CASE IF ALPHA
	BGT	2$
	CMPB	#172,R0
	BLT	2$
	BIC	#40,R0
2$:	MOVB	R0,(SG)+	;SAVE THE CHARACTER
	BR	1$

3$:	CLRB	(SG)		;END OF STRING, PUT IN A NULL

4$:	MOV	(SP)+,SG
	MOV	(SP)+,R0
	RTS	PC

;END OF "HSR"
;"RNUM" - STRING TO SCALED INTEGER NUMBER CONVERSION

;THIS ROUTINE CONVERTS A REAL NUMBER STRING OF THE FORM SIII.DDD INTO
;A SCALED INTEGER.  "S" IS AN OPTIONAL SIGN CHARACTER, III IS THE
;INTEGER FIELD, AND DDD IS THE DECIMAL FRACTION FIELD.  THE LENGTH OF
;EACH FIELD IS VARIABLE AND EITHER THE INTEGER OF FRACTIONAL FIELD CAN
;BE OMITTED.  IF THE FRACTIONAL FIELD IS MISSING, THE DECIMAL POINT
;NEED NOT BE TYPED.  LEADING SPACE CHARACTERS ARE IGNORED AND SCANNING
;CONTINUES UNTIL AN UNEXPECTED CHARACTER IS ENCOUNTERED.  AFTER THE
;NUMBER IS READ IN, IT IS CONVERTED TO A SINGLE 16 BIT INTEGER NUMBER
;ACCORDING TO THE FOLLOWING FORMULA:
;
;	INTEGER NUMBER ← (NUMBER*10↑X*2↑14)/SCALE
;   WHERE 
;	X ← 5 - (MAX. # OF INTEGER DIGITS ANY NUMBER CAN HAVE)
;	SCALE ← INTEGER(LARGEST NUMBER TO READ IN*10↑X)/2
;
;THERE ARE SEVERAL ENTRY POINTS INTO THIS PROGRAM.  THE ENTRY POINTS
;SET UP "X" AND "SCALE" TO HANDLE A PARTICULAR TYPE OF NUMBER.  A
;TYPICAL CALLING SEQUENCE FOLLOWS:
;
;		MOV	#STRING,SG	;POINT TO ASC STRING
;		JSR	PC,GETINT	;DECODE A INTEGER NUMBER
;		BCS	ERROR		;BRANCH IF NUMBER TOO LARGE OR
;					;  NO NUMBER FOUND
;		MOV	R0,NUMBER
;
;IF THE INPUT STRING IS INVALID, THE C BIT IS SET AND R1 IS RETURNED 
;NON-ZERO.  IF NO NUMBER WAS ENCOUNTERED, THE C BIT IS SET AND R1 IS
;ZERO.  OTHERWISE THE C BIT IS CLEARED.  SG IS LEFT POINTING AT THE
;FIRST CHARACTER FOLLOWING THE NUMBER.

;REGISTERS USED:
;	SG, R0, R1  PASS ARGUMENTS AND ARE ALTERED

;MULTIPLE ENTRY POINTS

GETANG:	MOV	#2,-(SP)	;ANGLES:  -360 ≤ THETA < 360
	MOV	#18000.,-(SP)
	BR	RNUM

GETDIS:	MOV	#3,-(SP)	;DISTANCES -32 ≤ D < 32
	MOV	#16000.,-(SP)
	BR	RNUM

GETINT:	CLR	-(SP)		;INTEGERS '100000 ≤ INT ≤ 77777
	MOV	#40000,-(SP)
	BR	RNUM
	
GETHUN:	MOV	#2,-(SP)	;REAL NUMBERS IN STEPS OF .01
	MOV	#40000,-(SP)

;START OF MAIN PROGRAM

RNUM:	MOV	R3,-(SP)	;SAVE REGISTERS
	MOV	R2,-(SP)
	CLR	-(SP)		;INDICATE NO NUMBER ENCOUNTERED YET
	CLR	R0    		;ACCUMULATE NUMBER IN HERE
	CLR	R1

;SCAN PAST LEADING ZEROS AND CHECK FOR SIGN CHARACTER

CHKSP:	MOVB	(SG)+,R2	;PICK UP A CHARACTER
	CMP	#40,R2		;IGNOR SPACE CHARACTERS
	BEQ	CHKSP
	CMP	#53,R2		;IGNOR "+"
	BEQ	FNDSGN
	CMP	#55,R2		;"-"?
	BNE	CHKZRO 		;BRANCH IF NOT
	NEG 	6(SP)   	;ELSE COMPLEMENT SCALE FACTOR
FNDSGN:	BIS	#BADNUM,(SP)	;INDICATE SIGN ENCOUNTERED
SKPZRO:	MOVB	(SG)+,R2	;SKIP OVER LEADING ZEROS
CHKZRO:	CMP	#60,R2
	BNE	NOTZRO
	BIS	#BADNUM+1,(SP)	;INDICATE DIGIT ENCOUNTERED
	BR	SKPZRO

;CHECK IF CHARACTER IS A DIGIT

NOTZRO:	MOV	#6,R3		;5-X IS THE # OF INT. DIG. TO READ
	SUB	10(SP),R3
	BR	.+4
CHKDG: 	MOVB	(SG)+,R2	;GET THE NEXT CHARACTER
       	CMP 	R2,#60		;COMPARE TO ASC ZERO
	BLT	CHKDP		;BRANCH IF OUT OF RANGE
	CMP	R2,#71		;COMPARE TO ASC 9
	BGT	CHKDP
	JSR	PC,ADDDIG	;ACCUMULATE SUM
	BIS	#BADNUM+1,(SP)	;INDICATE DIGIT ENCOUNTERED
	SOB	R3,CHKDG	
	BR	BADSYN		;BRANCH IF TOO MANY INTEGERS READ IN

;CHECK IF THE CHARACTER IS A DECIMAL POINT AND PICK UP FRACTION PART

CHKDP:	MOV	10(SP),R3	;GET X
      	CMP	#56,R2		;"."?
	BNE	NORM		;SKIP IF NOT D.P.
	BIS	#BADNUM,(SP)	;INDICATE D.P. ENCOUNTERED
GETFC:	MOVB	(SG)+,R2	;GET NEXT CHARACTER
	CMP	R2,#60		;BRANCH IF NOT A DIGIT
	BLT	NORM
	CMP	R2,#71
	BGT	NORM
	BIS	#BADNUM+1,(SP)	;INDICATE DIGIT ENCOUNTERED
	DEC	R3		;IGNOR IF ALREADY READ IN FRACTION
	BMI	GETFC
	JSR	PC,ADDDIG	;ACCUMULATE SUM
	BR	GETFC

;EXIT IF NO NUMBER ENCOUNTERED, ELSE NORMALIZE AND SCALE

NORM:	BIT	#1,(SP)		;CHECK IF ANY NUMBERS ENCOUNTERED
	BEQ	BADSYN		;BRANCH IF NONE FOUND
	TST	R3		;BRANCH IF NUMBER ALREADY NORMALIZED
	BLE	SCALIT
NORMIT:	MOV	#60,R2		;ELSE SUM ← SUM*10+0
	JSR	PC,ADDDIG
	SOB	R3,NORMIT
SCALIT:	ASHC	@#K14,R0	;SUM ← SUM*2↑14
	DIV	6(SP),R0	;SUM ← SUM/SCALE
	BVC	RNUMDN		;EXIT CLEANLY IF NO ERROR

;EXIT SEQUENCE

BADSYN:	SEC			;INDICATE SOME TYPE OF ERROR
RNUMDN:	MOV	(SP)+,R1	;THIS IS PART OF THE ERROR CODE
	BIC	#1,R1
	MOV	(SP)+,R2
	MOV	(SP)+,R3
	BIT	(SP)+,(SP)+	;CLEAR X AND SCALE OFF STACK
	DEC	SG		;ADJUST STRING POINTER
	RTS	PC

;SUBR TO ADD ANOTHER DIGIT TO THE ACCUMULATED SUM IN R0,R1

ADDDIG:	ASHC	@#K1,R0		;SUM*2
	MOV	R0,-(SP)	;SAVE IT
	MOV	R1,-(SP)
	ASHC	@#K2,R0		;SUM*8
	ADD	(SP)+,R1	;SUM*8+SUM*2
	ADC	R0
	ADD	(SP)+,R0
	BIC	#60,R2		;MASK OUT ASC BASE OF NEW DIGIT
	ADD	R2,R1		;SUM*10+NEW DIGIT
	ADC	R0
	RTS	PC


;END OF "RNUM"
;"PNUM" - PRINTS A SCALED INTEGER AS A REAL NUMBER

;PERFORMS THE REVERSE OPERATION OF RNUM.  A TYPICAL CALLING SEQUENCE
;TO ONE OF THE MULTIPLE ENTRY POINTS FOLLOWS:
;
;		MOV	NUMBER,R0	;SCALED INTEGER
;		MOV	#STRING,SG	;PUT CONVERTED STRING IN HERE
;		JSR	PC,PUTINT
;
;AFTER CONVERSION, THE STRING POINTER IS LEFT POINTING AT A NULL
;CHARACTER WHICH FOLLOWS THE FINAL CHARACTER OF THE CONVERTED
;NUMBER.

;REGISTERS USED:
;	R0, SG PASS ARGUMENTS AND R0,R1,SG ARE ALTERED

;MULTIPLE ENTRY POINTS

PRTANG:	INC	(SP)		;ANGLES, FIXED FORMAT
PTSANG:	MOV	#.+6,R1		;NO LEADING SPACES
	BR	PNUM
	.WORD	18000.,2-6

PRTDIS:	INC	(SP)		;DISTANCES, FIXED FORMAT
PTSDIS:	MOV	#.+6,R1		;NO LEADING SPACES
	BR	PNUM
	.WORD	16000.,3-6

PRTINT:	INC	(SP)		;INTEGERS, FIXED FORMAT
PTSINT:	MOV	#.+6,R1		;NO LEADING SPACES
	BR	PNUM
	.WORD	40000,0-6

PTSHUN:	MOV	#.+6,R1		;HUNDREDS, NO LEADING SPACES
	BR	PNUM
	.WORD	40000,2-6
;	["PNUM" - CONT.]

PNUM:	MOV	R2,-(SP)	;SAVE REGISTERS
	MOV	R3,-(SP)
	MOV	R4,-(SP)
	MOV	R1,R4
	MOV	#-60,-(SP)	;THIS + ASC 0 = NULL CHARACTER
	MOV	#60,R3		;ASSUME NUMBER POSITIVE
	MUL	(R4)+,R0	;SCALE NUMBER UP
	BGE	NUMPOS		;SKIP IF NUMBER > 0
	MOV	#55,R3		;ELSE SAVE NEGATIVE SIGN
	COM	R0		;ABS(NUMBER)
	NEG	R1
	BCS	.+4
	INC	R0
NUMPOS:	ADD	#20000,R1	;ROUND OFF
	ADC	R0
        ASHC	@#KM14,R0	;NORMALIZE
	MOV	#4,R2		;4 DECIMAL DIGITS + 1
DIVLP:	DIV	@#K10,R0
	MOV	R1,-(SP)	;LEAST SIGNIFICANT DIGIT
	MOV	R0,R1		;POSITION FOR NEXT DIVISION
	CLR	R0
	SOB	R2,DIVLP
	MOV	#6,R0		;COUNT TO PRINT 5 DIGITS AND NULL
	MOV	(R4)+,R2	;GET X
	CLR	R4		;GET 1 IF FIXED FORMAT, ELSE 0
	ROR	20(SP)
	ADC	R4
	ASL	20(SP)		;CLEAR LSB FROM RETURN ADDR
	BR	.+4		;FORM COMPLETE STRING
POPTHM:	MOV	(SP)+,R1	;GET BACK A DIGIT
	INC	R2		;BUMP UP INTEGER DIGIT COUNT
	BCS	CHKDCM		;BRANCH IF SIGN ALREADY PRINTED
	BEQ	SETSGN		;GO PRINT SIGN BEFORE DECIMAL PT
	TST	R1		
	BNE	NOWSGN
	MOVB	#40,(SG)
	ADD	R4,SG
	BR	NXTDG
NOWSGN:	BIC	#20,R3		;+(=SPACE) OR - BEFORE 1ST DIGIT
	CMP	#40,R3		;IGNOR "+" IF NO LEADING SP. CHAR
	BNE	SETSGN
	TST	R4
	BEQ	.+4
SETSGN:	MOVB	R3,(SG)+	;SIGN CHARACTER
	TST	R2		;TIME TO PRINT DEC. PT?
CHKDCM:	BNE	.+6
	MOVB	#56,(SG)+	;SEND OFF DECIMAL POINT
	ADD	#60,R1		;ADD ASC BASE TO NUMBER AND SEND OFF
	MOVB	R1,(SG)+
	SEC			;INDICATE SIGN PRINTED
NXTDG:	SOB	R0,POPTHM
	MOV	(SP)+,R4	;RESTORE REGISTERS
	MOV	(SP)+,R3
	MOV	(SP)+,R2
	DEC	SG		;POINT TO NULL CHARACTER
	RTS	PC

;END OF "PNUM"
;"CLRCMA","PRTCMA","TICKLE","TTYHIT"

;"CLRCMA" CAN BE CALLED FOLLOWING A STRING SCANNING ROUTINE TO ADJUST
;THE STRING POINTER IN SG TO SKIP OVER COMMA CHARACTERS WHICH ARE 
;USED TO SEPARATE NUMBERS.  SG MUST BE POINTING AT THE INPUT STRING.
;IF ANY CHARACTER OTHER THAN A SPACE OR NULL IS ENCOUNTERED BEFORE THE
;COMMA, THE C BIT IS SET, SG IS LEFT POINTING AT THE OFFENDING
;CHARACTER AND AN ERROR CODE IS SET IN R1.

CLRCMA:	CMPB	#40,(SG)+	;IGNOR LEADING SPACE CHARACTERS
	BEQ	CLRCMA
	TSTB	-(SG)		;EXIT IF END OF STRING
	BEQ	CLRCXX
	CMPB	#54,(SG)+	;SKIP OVER COMMA
	BEQ	CLRCXX
	DEC	SG		;ELSE SIGNAL ERROR
	MOV	#NOCOMA,R1
	SEC
CLRCXX:	RTS	PC


;"PRTCMA" PUTS A COMMA FOLLOWED BY A SPACE CHARACTER IN THE OUTPUT
;STRING.

PRTCMA:	MOVB	#54,(SG)+
	MOVB	#40,(SG)+
	CLRB	(SG)
	RTS	PC


;"TICKLE" RETURNS WITH THE C BIT SET IF A C/R CHARACTER HAS BEEN
;TYPED ON THE TELETYPE, OTHERWISE THE C BIT IS CLEARED.  THE
;CHARACTER TYPED IS FLUSHED.  R1 IS LOADED WITH AN ERROR CODE
;IS C IS SET ELSE R1 IS NOT CHANGED

TICKLE:	TSTB	@#TTYIS		;TTY KEYBOARD TICKLED?
	BPL	TICKDN		;NO
	MOVB	@#TTYIR,-(SP)	;DID SOMEONE TYPE A C/R?
	BIC	#200,(SP)
	CMPB	#15,(SP)+
	BNE	TICKDN		;NO
	MOV	#ABORT,R1	;YES
	SEC
	BR	.+4
TICKDN:	CLC
	RTS	PC


;"TTYHIT" RETURNS WITH THE N BIT SET IF A CHARACTER HAS BEEN
;TYPED ON THE KEYBOARD, OTHERWISE THE N BIT IS CLEARED.

TTYHIT:
   .IFNZ LSI
	TSTB	@#TTYIS		;CHARACTER TYPED ON KEYBOARD?
	RTS	PC
   .IFF
	TST 	OUTSW		;VT05 OR CONSOLE?
	BEQ 	10$
	TSTB	TTYIS		;TEST IF KEYBOARD READY
	RTS	PC

10$:	TST	IREG		;BYTE FROM PDP10?
	BEQ	.+4
	SEN
	RTS	PC
   .ENDC