.NLIST
; COPYRIGHT (C) 1975
;
; DIGITAL EQUIPMENT CORPORATION
; MAYNARD, MASSACHUSETTS 01754
;
; THIS SOFTWARE IS FURNISHED UNDER A LICENSE FOR USE ONLY
; ON A SINGLE COMPUTER SYSTEM AND MAY BE COPIED ONLY 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 EXCEPT
; FOR USE ON SUCH SYSTEM AND TO ONE WHO AGREES TO THESE
; LICENSE TERMS. TITLE TO AND OWNERSHIP OF THE SOFTWARE
; SHALL AT ALL TIMES REMAIN IN DIGITAL.
;
; THE INFORMATION IN THIS DOCUMENT IS SUBJECT TO
; CHANGE WITHOUT NOTICE AND SHOULD NOT BE CONSTRUED
; AS A COMMITMENT BY DIGITAL EQUIPMENT CORPORATION.
; DIGITAL ASSUMES NO RESPONSIBILITY FOR ANY ERRORS THAT
; MAY APPEAR IN THIS DOCUMENT
;
; DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE
; OR RELIABILITY OF ITS SOFTWARE ON EQUIPMENT
; WHICH IS NOT SUPPLIED BY DIGITAL.
;
.LIST


;
;UPDATE 'GB001'
;29-NOV-76
;CHANGES TO CODE IN REGION OF 'TTSCRL:'
;TO MAKE SOURCE COMPATIBLE WITH LINKED VERSION OF
;DISTRIBUTED 'RSXMON.SYS'
;
.IIF DF NLRMON, .NLIST	;UPDATE LEVEL 7

.SBTTL	MONITOR DATA BASE
; START OF RESIDENT MONITOR.
.CSECT	RT11

$RMON:	JMP	$INTEN

$CSW:	BSS	16.*5	;CHANNEL STATUS TABLE
SB17	= $CSW+<15.*5*2>+2 ;POINTS TO START BLOCK OF CHANNEL 17

 HDERR$	= 1		;BITS IN CSW WORD 0
 INDX$M	= 76		;MASK FOR DEVICE INDEX
 RENAM$	= 100
 DWRIT$	= 200
 DBLOK$	= 400
 DBLK$M	= 17400		;MASK FOR DIR. BLOCK #
 DBLK$N	= 160377	;COMPLEMETARY MASK
 EOF$	= 20000
 ACTIV$	= 100000

 C.SBLK	= 2		;OFFSETS INTO CHANNEL
 C.LENG	= 4
 C.USED	= 6
 C.DEVQ	= 10

$SYSCH:	.WORD	0,0	;WD 1 USED AT $SYS
	.WORD	0
I.SPLS:
I.SERR:	.WORD	0	;USED FOR HARD/SOFT ERRORS
	.WORD	0
BLKEY:	0		;DIRECTORY BLOCK # IN CORE
CHKEY:	0		;DEVICE WHOSE DIRECTORY IS IN CORE
$DATE:	0		;DATE WORD
DFLG:	0		;DIRECTORY OP. IN PROGRESS FLAG
$USRLC:	USRBUF		;WHERE DIRECTORY BUFFER IS
QCOMP:	COMPLT		;HANDLERS GO HERE TO FINISH UP
SPUSR:	0		;SOFTWARE ERROR FLAG
.IF DF	$RXPRO							;###
SYUNIT:	400		;UNIT 1 FOR RSX PROTO			;###
.IFF								;###
SYUNIT:	0		;HOLDS UNIT WE BOOTED FROM
.ENDC	;$RXPRO							;###
SYSVER:	.BYTE	2		;VERSION NUMBER
SYSUPD:	.BYTE	UPDATE		;EDIT NUMBER FOR VERSION
CONFIG:	.WORD	0		;SYSTEM CONFIGURATION FLAGS
SCROLL:	.WORD	0		;LINK TO GT40 SCROLLER CODE
TTKS:	177560			;CONSOLE IO ADDRESSES
TTKB:	177562
TTPS:	177564
TTPB:	177566
MAXBLK:	.WORD	-1		;MAXIMUM FILE SIZE ALLOCATED
E16LST:	LST16-$RMON		;PTR TO EMT 16 FOR BATCH
$TIME:	BSS	2	;DOUBLE PRECISION TIMER
SYNCH:	.WORD	SINK	;FOR COMPATIBILITY W/FB
LOWMAP:			;MAP OF PROTECTED WORDS IN LOW CORE
; BYTES ARE READ FROM LEFT TO RIGHT. E.G., THE FOURTH BYTE PROTECTS
; THE RANGE 60-76, AND A VALUE OF 11110000 WOULD PROTECT 60-66.
.RADIX	2
	.BYTE	11111111,00111100,00001111,11110000  ;0-76
	.BYTE	11000011,00000000,00000000,00000000 ;100-176
	.BYTE	00111111,11000000,00110011,00110000 ;200-276
	.BYTE	00000000,00000000,00000000,00000000 ;300-376
	.BYTE	00000000,00000000,00000000,00000000 ;400-476
.RADIX	8.
MAPOFF	= LOWMAP-	$RMON
USRLOC:	.WORD	USRBUF	;WHERE USR IS AT ANY GIVEN MOMENT
GTVECT:	.WORD	320	;WORD FOR GT40
ERRCNT:	.WORD	0	;ERROR COUNT RETURNED FROM CUSPS
FUTURE:	.WORD	0,0	;FUTURE EXPANSION
SYINDX:	.WORD	0	;SYSTEM DEVICE INDEX NUMBER
SYINDO= SYINDX-$RMON

SYSLOW:	.WORD	$RMON	;PSEUDO START OF MONITOR
$UNAM1:	BSS	$SLOT	;ASSIGNED NAME TABLE - PERMANENT NAMES
DKASSG=	. - $RMON
.IF DF	$RXPRO							;###
	.RAD50	/DK1/		;DK1 FOR RSX PROTO		;###
.IFF								;###
	.RAD50	/DK0/
.ENDC	;$RXPRO							;###
SYASSG	= .-$RMON
.IF DF	$RXPRO							;###
	.RAD50	/SY1/		;SY1 FOR RSX PROTO		;###
.IFF								;###
	.RAD50	/SY0/
.ENDC	;$RXPRO							;###
$UNAM2:	BSS	$SLOT	;ASSIGNED NAME TABLE - USER NAMES
	.RAD50	/DK /
	.RAD50	/SY /
$PNAME:	BSS	$SLOT		;PERMANENT NAME TABLE
$STAT:	BSS	$SLOT
CORPTR:	.WORD	0		;FREE CORE POINTER
	CORPTR			;****UPDATE WITH BOOT*****

 FILST$	= 100000
 RONLY$	=  40000
 WONLY$	=  20000
 SPECL$	=  10000

TTENTR:				;ENTRY POINT FOR TT:--ASSUMES 1 ST SLOT.
$ENTRY:	BSS	$SLOT

$PNAMO=$PNAME-$ENTRY
$DVREC:	BSS	$SLOT
CCB:	BSS	10	;RESIDENT CCB FOR KMON
;**************************************************
; THE FOLLOWING VALUES ARE FOR COMPATIBILITY WITH
; THE BF MONITOR. THEY ARE THE SINGLE USER
; EQUIVALENTS OF THE BF IMPURE AREA POINTERS.
;**************************************************

I.CNUM:	16.		;INITIAL NUMBER OF CHANNELS DEFINED
I.CSW:	$CSW		;POINTER TO CSW AREA
;**************************************************

.SBTTL	DEVICE TABLES

;**********************************************************************
;
; THE FOLLOWING  MACRO IS USED TO MAKE ENTRIES IN ALL
; THE DEVICE-RELATED TABLES, BOTH IN THE USR AND THE RMON.
; THE 4 MACRO ARGUMENTS ARE HANDLER NAME, # OF BLOCKS ON DEVICE,
; STATUS (FOR $STAT), AND ENTRY POINT (GLOBAL NAME).
;
.MACRO	DEVICE	NAME,SIZ,STAT,ENTRY
. = $HSIZE + HNUM
.IF IDN	NAME,DK
	 .WORD SYSIZE
.IFF
	 .WORD	NAME'SIZE
.ENDC
. = $DVSIZE + HNUM
	 .WORD SIZ
. = $PNAME + HNUM
	 .RAD50	/NAME/
. = $STAT + HNUM
	 .WORD	STAT
.IF NB	ENTRY
. = $ENTRY + HNUM
	 .WORD ENTRY
.ENDC
HNUM = HNUM + 2
.ENDM	DEVICE

HNUM = 0		;START OF WITH 0 DEVICE INDEX
... = .			;KEEP OUR PLACE

;	NAME	SIZE	STATUS	ENTRY
;	----	----	------	-----
TT.NUM = HNUM
DEVICE	 TT	  0	4
DEVICE	 DS    1024.	16+FILST$  DSSYS
DEVICE	 RK   11300	 0+FILST$  RKSYS
DEVICE   RF    2000     12+FILST$  RFSYS
DEVICE	 PR	  0	 7+RONLY$
DEVICE	 PP	  0	10+WONLY$
DEVICE   MT       0     11+SPECL$
DEVICE	 LP	  0 	 3+WONLY$
DEVICE	 DT	1102	 1+FILST$  DTSYS
DEVICE   CT       0     13+SPECL$
DEVICE   CR       0     14+RONLY$
BA.NUM	= HNUM
DEVICE   BA       0      4
DEVICE   DP	40000.	21+FILST$  DPSYS
DEVICE   DX	494.	22+FILST$  DXSYS
.IIF NDF BANDW, .NLIST
.IF DF	BANDW
DEVICE	 AM	200	15+FILST$
.ENDC
.IIF NDF BANDW, .LIST

. = ...			;BACK TO WHERE WE WERE

.SBTTL	DESCRIPTION OF MONITOR DATA BASE

;**********************************************************************
; CHANNEL STATUS TABLE---$CSW
; THIS TABLE CONTAINS 16 ENTRIES OF 5 WORDS EACH
; DESCRIBING THE I/O CHANNELS. THE FORMAT IS:
;
; OFFSET	BIT(S)	MEANING
; ------	------	-----------------------------------------------
;    0		 0	1 => HARD ERROR OCCURED ON DEVICE
;		1-5	DEVICE INDEX IN TABLES
;		 6	1 => RENAME OPERATION IN PROGRESS
;		 7	1 => CLOSE REQUIRES DIRECTORY REWRITE
;		8-12	DIRECTORY BLOCK # OF FILE
;		 13	1 => EOF FOUND ON CHANNEL
;		 15	1 => CHANNEL ACTIVE
;    2			START BLOCK OF FILE
;    4			LENGTH OF FILE (HOLE) ALLOCATED
;    6			ACTUAL DATA LENGTH (HIGHEST BLK WRITTEN)
;   10		0-7	NUMBER OF REQUESTS PENDING ON THIS CHANNEL
;		8-15	PHYSICAL UNIT NUMBER
;
;**********************************************************************
;
; BLKEY AND CHKEY ARE USED TO INDICATE WHICH DIRECTORY IS IN CORE
;  AND WHAT DEVICE THAT DIRECTORY IS ATTACHED TO.
; BLKEY IS THE NUMBER OF THE DIRECTORY SEGMENT NOW IN CORE
; SEGMENTS ARE NUMBERED 1-32. THEY ARE 2 PHYSICAL BLOCKS EACH.
;
; CHKEY DESCRIBES THE DEVICE TO WHICH THE DIRECTORY IS ATTACHED.
; THE EVEN BYTE CONTAINS THE DEVICE INDEX, IDENTIFYING THE DEVICE TYPE,
; AND THE ODD BYTE CONTAINS THE UNIT NUMBER OF THE DEVICE
;
;**********************************************************************
;
; USER NAME TABLES: $UNAM1 AND $UNAM2.
; THESE TABLES ARE USED TO HOLD THE DEVICE NAMES DEFINED VIA
; THE ASSIGN COMMAND. THE USER SPECIFIES 2 NAMES IN THE ASSIGN:
;	.ASSIGN	NAM1 NAM2
; NAM1 IS THE SYSTEM PERMANENT NAME, AND NAM2 IS HIS SUPPLIED NAME.
; $UNAM2 CONTAINS THE USER'S NAME, AND AT THE CORRESPONDING
; LOCATION IN $UNAM1 IS THE SYSTEM NAME WHICH IS EQUATED TO IT.
;
;**********************************************************************
;
; $STAT CONTAINS INFORMATION ABOUT THE DEVICE TYPES AND THE STRUCTURE
; OF THE DEVICES IN THE SYSTEM. THE 2 BYTES IN EACH ENTRY ARE:
;  EVEN BYTE: CONTAINS AN NUMBER WHICH IS UNIQUE TO THAT DEVICE:
;	0 = RK05
;	1 = DECTAPE
;	2 = CASSETTE
;	3 = LINE PRINTER
;	4 = TTY (ASR 33,35)
;	5 = LA30
;	6 = VT05
;	7 = HI SPEED READER
;	10= HI SPEED PUNCH
;	11= MAGTAPE
;	12= RF11 DISK
;	13= TA11 CASSETTE
;	14= CR11 CARD READER
;
;
; THE ODD BYTE CONTAINS INFORMATION ON THE STRUCTURE OF THE DEVICE:
;	BIT 15		1 => FILE STRUCTURED DEVICE
;			0 => NON FILE STRUCTURED
;	BIT 14		1 => READ ONLY DEVICE (PTR)
;	BIT 13		1 => WRITE ONLY DEVICE (LPT)
;	BIT 12		1 => SPECIAL FILE DEVICE (CASSETTE)
;
;**********************************************************************
;
; $ENTRY TABLE
; WHEN A DEVICE HANDLER IS IN CORE, THE $ENTRY WORD FOR THE
; DEVICE POINTS TO THE HANDLER (LAST Q-ELEMENT WORD).
; A ZERO WORD MEANS THE HANDLER IS NOT IN CORE.
;
;**********************************************************************

.SBTTL	EMT PROCESSOR, FPP EXCEPTION, TRAPS TO 4/10

.ENABL	LSB

EMTPRO:	BIC	#1,2(SP)	;CLEAR C BIT
	JSR	R1,SVREG	;SAVE REGISTERS
	CLR	R2		;FOR CALLING THE USR
	MOV	SAVE+2(SP),R5	;R5 -> WORD AFTER THE EMT
	MOV	-(R5),R4	;R4 = EMT INSTRUCTION
	CMPB	R4,#374		;IS IT NEW FORMAT?
	BHIS	NEWEMT		;YES.
	MOV	SP,R1		;NO. POINT R1 TO ARGS ON STACK
	ADD	#SAVE+6,R1
	MOV	R4,R5		;COPY IT
	BIC	#-20,R4		;ISOLATE CHANNEL NUMBER
	BIC	#177417,R5
	ASR	R5
	ASR	R5
	ASR	R5
	BR	EMTCOM		;MERGE WITH COMMON CODE

NEWEMT:	BNE	1$		;EMT 375 OR 376
	ADD	#E375MX*400,R0	;INDEX TO END OF LIST
	BR	3$		;AND LINK WITH COMMON CODE
1$:	CMPB	R4,#376		;IS IT 376 OR 377?
	BHI	20$		;EMT 377 IS IGNORED
	BEQ	E376		;376 IS FATAL ERROR CODE
	MOV	R0,R1
	MOV	(R1)+,R0	;PUT CODE AND CHANNEL INTO R0
	MOV	(R1)+,(SP)	;NORMAL R0 ARG TO R0
	ROR	R2		;C BIT SET FROM CMPB. R1 NOW
				;POINTS TO ARG. LIST
3$:	CLR	R4		;R4 WILL HOLD CHANNEL DATA
	BISB	R0,R4
	BEQ	4$		;CHANNEL # IS 0.
	CMPB	R4,I.CNUM	;COMPARE CHAN SPECIFIED W/# DECLARED
	BHI	CHANER		;CHANNEL IS TOO GREAT
4$:	MOV	R0,R5		;FUNCTION GOES TO R5
	CLRB	R5
	SWAB	R5
	CMPB	#EMTMAX,R5	;IS IT A LEGAL ONE?
	BLOS	TOOBIG		;NO
	ASL	R5		;*2 FOR INDEXING
	MOV	(SP),R0		;R0 ARG BACK TO R0

EMTCOM:	TST	(R5)+		;FIX INDEX INTO FUNCTION LIST
	MOV	R5,-(SP)	;SAVE INDEX
	ADDR	TTILCT,R5	;POINT R5 TO LINE COUNT
				;****NOTE---IT IS VITAL THAT R5 BE
				;POINTED TO TTILCT HERE, AS CERTAIN
				;EMT'S ASSUME THAT, AND AVOID DOING
				;AN ADDR ADDRESS MACRO.*******
	ASL	R4		;MULTIPLY # CHANNELS BY 2
	MOV	R4,R3		;NOW POINT R3 TO CORRECT CSW AREA
	ASL	R3
	ASL	R3
	ADD	R4,R3
	ADD	I.CSW,R3
	ADD	PC,@SP
	ADD	@(SP)+,PC

; THE FOLLOWING TABLE IS A LIST OF THE FUNCTIONS AVAILABLE AT
; THE EMT LEVEL. THE FUNCTIONS ARE DIVIDED INTO 2 MAIN GROUPS:
; THE EMT 375 FUNCTIONS COME FIRST, AND THE EMT 374 EMT'S
; FOLLOW.

T1:	D$LETE-T1		; 0 DELETE
	L$OOK -T1		; 1 LOOKUP
	E$NTER-T1		; 2 ENTER
	T$RPST-T1		; 3 SET 4/10 TRAPS
	R$NAME-T1		; 4 RENAME
	S$AVST-T1		; 5 SAVESTAT
	R$OPEN-T1		; 6 REOPEN
	C$LOSE-T1		; 7 CLOSE
	R$EAD -T1		; 10 READ
	W$RITE-T1		; 11 WRITE
	W$AIT -T1		; 12 WAIT
	EMTDON-T1		; 13  CHCOPY IN BF SYSTEM
	EMTDON-T1		; 14 SPECIAL DEVICE LIST
	C$DFN  -T1		; 15 DEFINE CHANNELS
	EMT16 -T1		; 'OLD' EMT 16
	EMT17 -T1		; USED FOR INTERNAL ERRORS
	G$TJB -T1		; 20  GET JOB PARAMS
..GTIM	= <. - T1> / 2
	G$TIM -T1		; 21 GET TIME OF DAY
..MRKT	= <. - T1> / 2
	EMTDON-T1		; 22 MARK TIME IN BF
	EMTDON-T1		; 23 CANCEL MARK TIME
	EMTDON-T1		; 24 TIMED WAIT
	EMTDON-T1		; 25 SEND DATA
	EMTDON-T1		; 26 RECEIVE DATA
	EMTDON-T1		; 27 CHANNEL STATUS
	S$FPA -T1		; 30 SET FPP EXCEPTION
	EMTDON-T1		; 31 PROTECT VECTORS
	S$PFUN-T1		; 32 MAGTAPE/CASSETTE FONCS.
	EMTDON-T1		; 33 CONTEXT SWITCH

E375MX	= .-T1/2

TSUB1:	W$AIT -T1		; 0 WAIT
	EMTDON-T1		; 1 SUSPEND
	EMTDON-T1		; 2 RESUME
	P$URGE-T1		; 3 PURGE CHANNEL
	S$ERR -T1		; 4 SET SOFT ERROR FLAG
	H$ERR -T1		; 5 SET HARD ERROR FLAG
	C$LOSE-T1		; 6 CLOSE IN NEW FORMAT
	L$OCK -T1		; 7 TEST AND LOCK
	C$HAIN-T1		; 10 CHAIN
	EMTDON-T1		; 11 MWAIT

E374MX	= .-TSUB1/2		;NUMBER OF EMT 374 FUNCTIONS
EMTMAX	= .-T1/2		;TOTAL NUMBER OF EMTS

TOOBIG:	MONERR	EMT.E,0		;ILLEGAL EMT
20$:	BR	EMTOUT

CHANER:	MONERR	CHAN.E,0	;ILLEGAL CHANNEL ERR
	BR	EMTOUT
.DSABL	LSB

E376:	MOV	SAVE+2(SP),R0	;R0 T0 CODE,LEVEL
	MOV	ERRPC(SP),R3	;PC INTO R3
	MOVB	(R0)+,R2	;LEVEL TO R2
	MOVB	(R0)+,R4	;ERROR CODE TO R4
	BPL	1$		;CODE >0 MEANS EITHER
	COM	R4		; NEGATIVE IS ONLY FATAL
	BR	2$		;R4 NOE CODE. PRINT ERROR
1$:	TST	I.SERR		;GIVE FATAL ERROR?
	BNE	3$		;NO. A SOFTY
2$:	CLR	@#UFLOAT	;SO WE CAN ENTER CLUSR2
	MOV	#1000,SP
	CLR	RECURS		;NO COMPLETION ROUTINE
	.SRESET			;RESET IO QUEUE
	JSR	PC,CLUSR2	;GET FRESH USR IN
	MOV	USRLOC,R5	;JUMP UP INTO USR
	JMP	IOFSET(R5)
3$:	COMB	R4		;MAKE ERROR BYTE NEGATIVE
	MOVB	R4,@#ERRBYT
	ADD	#ERRPS,R2	;POINT TO HIS C BIT
	ADD	SP,R2
	BIS	#1,(R2)		;TURN ON USR'S C BIT
	MOV	R0,SAVE+2(SP)	;NEW RETURN PC
	CLR	R2		;SO WE DON'T POP REGISTERS
	BR	EMTOUT
.ENABL	LSB
T$RPST:	TST	R0		;IS THER AN ADDRESS?
	BNE	1$		;YES. USE IT.
	MOV	TRAPER,R0	;NO. USE MONITOR'S NOW.
1$:	MOV	R0,(PC)+	;SAVE TRAP ADDRESS.
TRAPLC:	.WORD	MONTRP		;***SET BY BOOT****
	BR	EMTOUT

MONTRP:	BCS	20$		;C SET => TRAP TO 10
	SUB	#12.,SP		;GET STACK RIGHT FOR ERROR
	MONERR	TR04.E,0,FATAL	;FATAL...TRAP TO 4
20$:	SUB	#12.,SP
	MONERR	TR10.E,0,FATAL	;FATAL...TRAP TO 10

TRAP4:
TRAP10:	ROL	@#ERRBYT	;SAVE C BIT
	CMP	#400,SP		;STACK OVERFLOW?
	BLO	24$		;BRANCH IF NOT
	HALT			;HALT ON OVERFLOW
	BR	.-2
24$:	MOV	TRAPLC,-(SP)	;SAVE USER ADDRESS
	BNE	25$		;IF 0, USE MONITOR'S ADDRESS
	MOV	TRAPER,(SP)
TRAPER=.+2
25$:	MOV	#MONTRP,TRAPLC	;AND DISABLE TRAPS
	ASR	@#ERRBYT	;RESTORE C BIT
	JMP	@(SP)+		;TO USER WITH C BIT SET RIGHT

S$FPA:	CMP	#1,R0		;ANY USER FPP ADDRESS?
	BLO	11$		;NO. USE OUR OWN
	MOV	FPPIGN,R0	;NO. GIVE ?M- ERROR
11$:	MOV	R0,(PC)+
FPPADD:	.WORD	MONFPP		;****BOOT****
EMTOUT:	JMP	EMTDON

FPPINT:	BIT	#HWFPU$,CONFIG	;DO WE HAVE FPP?
	BNE	13$
	RTI			;NO. JUST RETURN
13$:	STST	-(SP)		;SAVE FPP STATUS
	MOV	FPPADD,-(SP)	;SAVE HIS ADDRESS
FPPIGN=.+2
	MOV	#MONFPP,FPPADD	;TURN OFF TRAPS
	JMP	@(SP)+

MONFPP:	SUB	#14.,SP
	MONERR	FPP.E,0,FATAL	;FATAL FPP TRAP

.DSABL	LSB
.SBTTL	SYNCH CODE

SINK:	CMP	(R5)+,(SP)+	;HERE WE HAVE TO SAVE R0,R1
	MOV	R0,-(SP)	;AND RESTORE R4,R5
	MOV	R1,-(SP)
	MOV	6(R4),R0	;SETUP R0 WITH 4TH WD OF SYNC BLK
	JSR	PC,(R5)		;RETURN TO USER CODE
	MOV	(SP)+,R1
	MOV	(SP)+,R0
	RTS	PC

.SBTTL	EMT 16, USR CALLS
EMT16:	TST	(R4)+		;R4 HAS SUB CODE TO DO
	ADD	PC,R4
	ADD	(R4),PC

LST16:	T$TIN -LST16
	T$TOUT-LST16
	D$STAT-LST16		;DEVICE STATUS
	F$ETCH-LST16		;FETCH/RELEASE
	C$SIGN-LST16		;GENERAL MODE CSI
	C$SISP-LST16		;SPECIAL MODE CSI
	L$OCK -LST16		;LOCK USR
	U$NLOK-LST16		;RELEASE USR
	E$XIT -LST16		;EXIT PROGRAM
	P$RINT-LST16		;STRING PRINT
	S$RSET-LST16		;SOFT RESET
	Q$SET -LST16		;SET IO QUEUE
	S$ETOP-LST16		;SET TOP OF CORE
	R$CTLO-LST16		;RESET ^O BIT
	EMTDON-LST16
	H$RSET-LST16		;HARD RESET

; FOLLOWING IS A TABLE OF CALLS INTO THE USR. R2 IS
; USED AS AN INDEX TO THE PROPER FUNCTION ONCE CONTROL
; HAS PASSED INTO THE USR.

C$SIGN:	CLR	R4		;******CSIGEN MUST BE FIRST*********
C$SISP:	INC	R2		;CSI SPECIAL
H$RSET:	INC	R2		;HARD RESET
S$RSET:	INC	R2		;SOFT RESET
D$STAT:	INC	R2		;DEVICE STATUS
R$NAME:	INC	R2		;RENAME
L$OOK:	INC	R2		;LOOKUP
E$NTER:	INC	R2		;ENTER
C$LOS2:	INC	R2		;CLOSE
F$ETCH:	INC	R2		;FETCH/RELEASE
D$LETE:	INC	R2		;DELETE
C$DFN2:	INC	R2		;DEFINE CHANNELS
Q$SET:				;SET IO QUEUE
	JSR	PC,CALUSR	;GRAB THE USR
	JMP	@USRLOC		;TO THE USR NOW

LKINT:	ADC	$TIME+2		;LOW ORDER TIME
	ADC	$TIME		;HIGH ORDER TIME
	RTI

C$DFN:	CLR	USRLOC		;WE WILL READ A NEW USR NOW.
	BR	C$DFN2		;BACK TO MAIN STREAM

.SBTTL	CLOSE, HARD/SOFT ERRORS, GET TIME, GET JOB PARAMS
.SBTTL	CHAIN

;****************************************
; CLOSE EMT
; IF NO DIRECTORY OPE@ATION IS REQUIRED,
; THE CHANNEL IS DISSOCIATED, AND THE
; OPERATION IS DONE. IF DIRECTORY WORK
; IS REQUIRED, THE USR IS CALLED.
;******************************************
C$LOSE:	BIT	#RENAM$+DWRIT$,(R3) ;DIRECTORY REWRITE NEEDED?
	BNE	C$LOS2		;YES. CALL USR
P$URGE:	CLR	(R3)+		;DISSOCIATE CHANNEL
	BR	E16XT		;EXIT

S$ERR:	INC	R2		;EVEN BYTE WAS 0 FROM EMT PROCESSOR
H$ERR:	MOVB	R2,I.SERR
	BR	E16XT

G$TIM:	ADD	#$TIME-TTILCT,R5 ;R5 POINTS TO TTILCT
.IF DF	$RXPRO							;###
	DSAR$S			;DISABLE AST'S			;###
.IFF								;###
	MOV	#PR7,@#PS	;KEEP OUT CLOCK INTERRUPT
.ENDC	;$RXPRO							;###
	MOV	(R5)+,(R0)+	;HIGH TIME
	MOV	(R5),(R0)	;LOW TIME
.IIF DF	$RXPRO,	ENAR$S		;ENABLE AST'S			;###
	BR	E16XT

G$TJB:	CLR	(R0)+		;JOB # 0
	MOV	SYSLOW,(R0)+	;HIGH LIMIT
	CLR	(R0)+		;0 IS LOW ADDR
	MOV	I.CSW,(R0)	;CHANNEL AREA
	BR	E16XT

C$HAIN:	BIS	#CHAIN$,@#JSW	;SET CHAIN BIT
	MOV	SP,R0		;SO R0 IS NON-ZERO IN KMON
	BR	CHXIT		;AND BRANCH INTO EXIT

.SBTTL	TTYIN/TTYOUT
.ENABL	LSB

T$TIN:	BIT	#TTSPC$,@#JSW	;USER MODE TTY?
.IF DF	$RXPRO							;###
	JSR	PC,@#TICHK	;CHK IF ANY CHARS-IF NOT-WAIT	;###
	BR	T$TIN		;NO CHAR-LOOP BACK		;###
	BR	.+6		;CHAR-GO ON			;###
.IFF								;###
	BEQ	1$		;NO. WE ARE WAITING FOR A LINE
	TST	TTIBUF+4	;YES. IS CHAR COUNT NON-0?
	BR	2$
.ENDC	;$RXPRO							;###
1$:	TSTB	(R5)		;IS LINE COUNT NON-0?
2$:	BEQ	NOINPT		;NO INPUT. RETURN
	ADDR	TTIBUF+6,R1	;EMT SIDE POINTER TO R1
	INC	(R1)		;BUMP POINTER TO NEXT CHAR
	CMP	(R1),2(R1)	;DO WE NEED TO WRAP AROUND?
	BNE	3$
	SUB	#TTYIN,(R1)	;DECREASE POINTER
3$:	MOVB	@(R1),R0	;MOVE THE CHAR.
	DEC	-(R1)		;DECREASE COUNT
	MOV	R0,R4
	MOV	R0,(SP)		;SET R0 FOR RETURN
	JSR	PC,EOLTST
	BNE	E16XT
	DECB	(R5)
	CMP	R0,#03		;READING OUT A ^C?
	BNE	E16XT
	BIS	#100000,(R5)	;INHIBIT FURTHER TT: ACTION
	.EXIT			;YES. DO ^C EXIT
E16XT:	CLR	R2

; THIS IS THE GENERAL END OF THE LINE FOR EMT'S

E16.16:
EMTDON:	JSR	R1,POPREG	;RESTORE A FEW REGISTERS
	RTI

; EMT 16 SUBFUNCTION 1--TTYOUT. THIS EMT PUTS A CHARACTER
; INTO THE OUTPUT RING BUFFER.

T$TOUT:	MOV	R0,R4
	JSR	PC,OPUT		;PUT A CHAR OUT
4$:	BCC	E16XT		;IT FIT.
NOINPT:	EMTERR+0		;RETURN WITH C SET
E16LNK:	BR	E16XT

.DSABL	LSB

.ENABL	LSB
.SBTTL	EXIT
;**********************************************************************
; EXIT EMT
; EXIT CAUSES THE EXECUTING PROGRAM TO TRANSFER CONTROL
; BACK TO THE MONITOR. THE MONITOR FILE SERVICES
; ARE PUT INTO THEIR NORMAL POSITION PRECEDING RMON, AND THE
; USER IS SWAPPED OUT IF NECESSARY.
; BEFORE CALLS ARE MADE TO THE IO ROUTINES, EXIT WAITS FOR
; ALL IO TO COMPLETE. WHEN IO IS DONE, EXIT POINTS THE QUEUE INTO
; THE MONITOR AREA, AND THE INITIATES IO CALLS TO READ IN THE
; MONITOR. NOTE THAT AT MEXIT THE Q IS RESET AGAIN TO
; CONTAIN THE CORRECT NUMBER OF ENTRIES.
;**********************************************************************

E$XIT:	BIC	#CHAIN$,@#JSW	;TURN OFF THE CHAIN BIT!
CHXIT:	MOV	SP,EXTFLG	;DOING AN EXIT. WE DON'T WANT
				;TO RE ENTER THE EXIT ROUTINE
	ADDR	AVAIL,R5	;SET R5 TO FIRST ENTRY
	CMP	-(R5),-(R5)	;ARE FREE=TOTAL NUMBER?
	BLT	CHXIT		;NOT YET.
	CMP	(R5)+,(R5)+	;BACK TO AVAIL
	MOV	R5,(R5)		;POINT Q INTO QSTART ENTRY
	ADD	#2,(R5)
	CMP	$ENTRY+TT.NUM,SYSLOW ;TT HANDLER LOADED?
	BHIS	1$		;BR IF LOADED
	CLR	$ENTRY+TT.NUM	;ELSE CLEAR ITS ENTRY
1$:	ADD	#SPTR-AVAIL,R5	;SWITCH TO MONITOR STACK
	MOV	R5,SP
	CLR	I.SERR		;RESET FOR ?M- ERRORS
	CLR	TRAPLC		;DISABLE USER TRAPS TO 4/10
	ADD	#$CSW-SPTR,R5	;NOW RESET FOR 16 CHANNELS
	ADDR	I.CSW,R2	;ADDRESS OF CSW GOES HERE
	MOV	R5,(R2)
	MOV	#16.,-(R2)
	MOV	R0,-(SP)	;SAVE R0. KMON TESTS VALUE.
	MOV	$KMLOC,R2	;POINT TO PERM ADDRESS FOR KMON
	TST	KMLOC		;IS KEYBOARD IN CONTROL?
	BNE	5$		;YES. GO TO MEXIT2
	MOV	$SWPBL,R0	;START OF SWAP AREA
	TST	@#JSW		;DOES USR FLOAT?
	BMI	2$		;BRANCH IF NOT
	TST	USRLOC		;IF USR NOT IN CORE,
	BEQ	2$		;DON'T READ ANYTHING!
	JSR	PC,$RSYS
2$:	ADDR	$SWPBL,R5	;R5 TO IO LISTS
	MOV	(R5)+,R0	;BLOCK NUMBER ($SWPBL)
	CMP	@#USERTOP,R2	;DO WE HAVE TO SWAP?
	BLO	4$		;NO. DON'T WRITE OUT USER
	MOV	R2,(R5)		;GET ADDRESS TO WRITE FROM
	BIC	#777,(R5)	;FULL BLOCK
	MOV	(R5)+,(R5)	;COMPUTE SIZE TO WRITE
	SUB	@#USERTO,(R5)
	BHI	3$		;DIDN'T DESTROY ANYTHING!
	ROR	(R5)		;WORD COUNT
	DEC	(R5)
	TST	-(R5)
	JSR	PC,IOSR
4$:	TST	(R5)+
3$:	CMP	(R5)+,(R5)+	;READ IN KMON/USR
	ADD	#SWAPSZ,R0	;ADD IN # OF SWAP BLOCKS
	JSR	PC,IOSR
	CMP	-(R2),-(R2)	;POINT JMP TO MEXIT
5$:	JMP	MEXIT2-KMON(R2)

$SWPBL:	0
EXLIST:	0
	-<USRLEN+KMLEN>
	0
$KMLOC:	KMON
	USRLEN+KMLEN
	0

.DSABL	LSB

.SBTTL	SET TOP, CANCEL ^O

; EMT16 SUBFUNCTION 14--SET TOP OF CORE. THIS EMT
; TAKES THE VALUE PASSED IN R0 AND INTERPRETS IT AS
; THE NEW TOP OF THE USER PROGRAM AREA. IF THE NEW VALUE
; OVERWRITES ANY CURRENTLY RESIDENT SECTION OF THE
; MONITOR, THAT SECTION IS MARKED AS BEING NON-RESIDENT.

.ENABL	LSB

S$ETOP:	BIS	#USWAP$,@#JSW
	CMP	R0,SYSLOW	;GOING TOO HIGH ?
	BLO	12$		;NO, OK
	MOV	SYSLOW,R0	;RESET HIM TO HIGHEST
1$:	TST	-(R0)
12$:	CMP	R0,$KMLOC	;DESTROYING KEYBOARD?
	BLO	3$
	CLR	(PC)+
KMLOC:	KMON
	CMP	R0,$USRLC	;WIPING USR?
	BLO	3$
	BIT	#USR$,CONFIG	;IS USR MANUALLY LOCKED?
	BEQ	11$		;NO. GO AHEAD AND SWAP
	MOV	$USRLC,R0	;SET TOP TO USR
	BR	1$
11$:	CLR	USRLOC		;USR NON-RES.
	BIC	#USWAP$,@#JSW
3$:	MOV	R0,(SP)		;RETURN TOP TO HIM
	MOV	R0,@#USERTOP	;AND ALSO TO 50
E16XT1:
2$:	BR	E16LNK

;CANCEL CONTROL O
R$CTLO:	CLRB	TTOCLO
	BR	2$

.SBTTL	LOCK USR, INTERNAL ERROR EMT
; EMT 16 SUBFUNCTION 6--LOCK USR IN CORE
; IF A USER WANTS TO HAVE THE USR IN CORE FOR A SERIES OF
; I/O TYPE OPERATIONS, HE CAN LOCK IT INTO CORE WITH THE
; LOCK EMT. IF THE MONITOR IS ALREADY IN CORE, THIS
; OPERATION IS A NOP.

L$OCK:	JSR	PC,CALUSR	;READ MONITOR IN
	BR	2$



; EMT 17--USED FOR INTERNAL PURPOSES ONLY.. SHOULD NOT BE
; CALLED BY THE USER. MOVES AN ERROR CODE INTO LOCATION
; SET ASIDE FOR THE CODE, AND TURNS THE C BIT ON IN THE
; OFFENDING EMT'S STATUS.
EMT17:	ASR	R4		;NEED NUMBER BETWEEN 0-17
	MOVB	R4,@#ERRBYT
5$:	BIS	#1,ERRPS(SP)	;SET C BIT ON
	BR	2$
.DSABL	LSB

.SBTTL	TTY INTERRUPT (INPUT)
.IF DF	$RXPRO							;###
	.SBTTL	KB INPUT AST FOR RSX TASK			;###
.ENDC	;$RXPRO							;###
.ENABL	LSB

; THE TTY SERVICE ROUTINES USE RING BUFFERS FOR ALL TTY IO.
; EACH RING BUFFER IS PRECEEDED BY A FOUR WORD RING BUFFER
; HEADER. THE HEADER WORDS ARE:
;	1) 'PUT' POINTER. TTY INPUT INTERRUPT
;	POINTER INTO NEXT FREE BYTE
;	2) RING BUFFER CHARACTER COUNT
;	3) 'GET' POINTER. EMT PULLS CHARS. FROM THIS PTR.
;	4) ABSOLUTE UPPER LIMIT OF RING BUFFER.
; THE TTY OUTPUT RING HAS A HEADER FOR THE SAME PURPOSE.


40$:	CMPB	(R2)+,#'S&77	;END OF 'MUST CHECK' LIST?
	BNE	3$		;NOT YET.
	BIT	#TTSPC$,@#JSW	;CHECK MORE SPECIALS?
	BNE	TTINC3		;NO. IN SPECIAL MODE
	BR	3$		;OK. DO MORE CHECKS
.IF DF	$RXPRO							;###
TTIEX4:	CLR	R2		;CLR R2 FOR POPREG ROUTINE	;###
	JSR	R1,POPRG1	;RESTORE REGS			;###

	JMP	@#TTIEX6	;TO BOOT TASK TO EXIT FROM AST	;###

.ENDC	;$RXPRO							;###

TTIINT:	JSR	R1,SVREG	;SAVE VOLATILE REGISTERS
	ADDR	TTIBUF+4,R5	;POINT TO RING COUNT
.IF DF	$RXPRO							;###
	MOV	@#KBBUF,R0	;GET CHAR FROM BUFFER		;###
.IFF								;###
	MOV	@TTKB,R0	;CHARACTER INTO R0
	CLR	@#PS		;BACK TO LEVEL 0
.ENDC	;$RXPRO							;###
	BIC	#200,R0		;STRIP OFF PARITY BIT
	BEQ	TTIEX3		;IGNORE NULLS
	BIT	#TTLC$,@#JSW	;CONVERT TO UPPER CASE?
	BNE	1$		;NO, CONVERSION IS DISABLED
	CMP	R0,#141		;CONVERT LOWER CASE
	BLT	1$		;TO UPPER CASE
	CMP	R0,#172
	BGT	1$
	BIC	#40,R0
1$:	ADDR	TTIPRE,R1	;R1 TO PREVIOUS WORD
2$:	ADDR	4$,R2		;POINT TO LIST OF SPECIAL CHARACTERS
3$:	CLR	R3		;DO THIS BECAUSE MOVB IS BAD!
	BISB	(R2)+,R3	;ADDRESS DIFFERENCE TO R3
	BEQ	T.SPEC		;0 ENDS LIST. CHECK NON PRINTS.
	CMPB	(R2),R0		;IS IT A MATCH?
	BNE	40$		;NO. SEE IF DONE FIRST PART YET.
	ADD	R3,PC		;JUMP TP PROCESS

4$:	.BYTE	CTRLC -4$,'C&77		;^C***KEEP ^S AS LAST IN 
	.BYTE	CTRLO -4$,'O&77		;^O***THE LIST***
	.BYTE	CTRLQ -4$,'Q&77		;^Q
	.BYTE	CTRLS -4$,'S&77		;^S

	.BYTE	CTRLU-4$,'U&77
	.BYTE	ALT-4$,  ESCAPE
	.BYTE	ALT-4$,  175
	.BYTE	ALT-4$,  176
	.BYTE	RUB-4$,  RUBOUT
	.BYTE	TTINCC-4$,CR	;DON'T WANT TO ECHO ^CR
	.BYTE	TTINCC-4$,LF
	.BYTE	TTINCC-4$,FF
	.BYTE	TTINCC-4$,TAB
	.WORD	0
	.EVEN
.DSABL	LSB

.ENABL	LSB

ALT:	MOV	#ESCAPE,R0	;SET TO HANDLE ESCAPES
	BR	TTINC3		;SEND 33 TO BUFFER
T.SPEC:	CMP	R0,#40		;PRINTING CHAR?
	BGE	TTINCC		;YES.
	JSR	PC,EKOR0	;NO. ECHO ^(CHAR)

TTINCC:	CMP	#RUBOUT,(R1)	;WAS LAST A RUBOUT?
	BNE	TTINC3
	JSR	PC,TTORUB	;ECHO A '\'
TTINC3:	MOV	R0,R4
	MOV	#BELL,R4
	CMP	(R5),#TTYIN-1	;WE ACTUALLY ONLY ALLOW 81 CHARACTERS
				;THIS PREVENTS EVER HAVING THE RING
				;BUFFER POINTERS THE SAME AND THUS
				;LOCKING UP THE KEYBOARD
	BGE	3$		;NO. DON'T ALTER TTIPRE
	INC	(R5)		;BUMP CURRENT COUNT
	INC	-(R5)		;BUMP INPUT POINTER
	CMP	(R5),6(R5)	;TIME TO WRAP ABOUT?
	BNE	1$
	SUB	#TTYIN,(R5)
1$:	MOVB	R0,@(R5)+	;PUT IN CHAR. AND GO TO COUNT
	MOV	R0,R4
	JSR	PC,EOLTST
	BNE	2$
	INCB	TTILCT		;BUMP LINE COUNT
2$:	MOV	R0,(R1)
3$:	BIT	#TTSPC$,@#JSW	;DON'T ECHO IN USER MODE
	BNE	4$
TTIEXZ:	TST	SYNC		;SHOULD WE OUTPUT IT?
	BNE	4$		;NO.
	JSR	PC,TTOPUT	;OUTPUT THE CHARACTER
4$:	MOV	TTENTR,R4	;IF TT HANDLER IS AROUND, GO TO IT
	BR	5$		;;;UNCONDITIONAL FOR RT/RSX TT HANDLER
	JSR	R4,6.(R4)	;AND GET THE CHARACTER WE PUT IN
	TTILCT-.
5$:	SUB	#3,R0		;TEST FOR CARRIAGE RETURN
	CMP	R0,#LF
	BEQ	TTINC3		;PUT IN LF WITH CR
.IF DF	$RXPRO							;###
TTIEX3:	BR	TTIEX4		;GO EXIT FROM AST		;###
.IFF								;###
TTIEX3:	BR	E16XT1
.ENDC	;$RXPRO							;###
TTIPRE:	0			;PREVIOUS TTY INPUT CHAR.


.DSABL	LSB

.SBTTL	^O, ^C^C, ^U, RUBOUT, INPUT BUFFER
.SBTTL	STRING PRINT
CTRLO:	CLR	TTOBUF+2	;CLEAR OUTPUT BUFFER
	MOV	TTOBUF,TTOBUF+4	;EQUATE BUFFER POINTERS
	JSR	PC,EKOR0	;ECHO ^O
	JSR	PC,TTLFCR	;CR/LF
	COMB	TTOCLO		;FLIP THE FLOP
	BR	TTIEX3
;**************************************************

CTRLC:	JSR	PC,EKOR0	;ECHO ^C
	JSR	PC,TTLFCR	;GEN CR/LF AFTER ^C.
	MOV	$ENTRY+BA.NUM,R3 ;IS BA.SYS RESIDENT?
	BEQ	1$		;BR IF NOT RESIDENT
	CLR	6(R3)		;MAKE BATCH STOP COMPLETELY
1$:	CMP	R0,(R1)
	BNE	TTINC3
	TST	(PC)+		;ARE WE DOING AN EXIT NOW?
EXTFLG:	0
	BNE	TTIEX3		;YES. IGNORE THIS ONE

	TST	DFLG		;DIRECT. OPERATION IN PROGRESS?
	BEQ	CTRLC2		;NO. OK TO EXIT
	MOV	#140000,DFLG	;YES. DON'T HONOR ^C UNTIL DONE.
	BR	TTIEX3		;RETURN FROM INTERRUPT
;**************************************************

CTRLU:	JSR	PC,EKOR0	;ECHO ^U
TTICTL:	JSR	PC,RUBCM2	;TEST FOR EMPTY BUFF, AND IF
				;NOT EMPTY, MOV LAST CHAR TO R4
	BEQ	TTIBUM
	JSR	PC,RUBCOM
	BR	TTICTL
TTIBUM:	CLR	(R1)
TTCRLF:	JSR	PC,TTLFCR
	BR	TTIEX3
;**************************************************

CTRLS:	MOV	SP,SYNC		;STOP OUTPUT
	BR	TTIEX3
CTRLQ:	CLR	SYNC		;RESUME OUTPUT
.IF DF	$RXPRO							;###
	JSR	PC,@#NULOUT	;GET TT OUTPUT STARTED		;###
.IFF								;###
	CLR	@TTPS		;CLEAR. NEXT WILL GEN INTERRUPT
	MOV	#IENABL,@TTPS	;START INTERRUPTS
.ENDC	;$RXPRO							;###
	BR	TTIEX3
;***************************************************

RUB:	JSR	PC,RUBCM2	;TEST FOR BUFF EMPTY, IF NOT
				;MOVE LAST CHAR TO R4
	BEQ	TTIBUM
	CMP	R0,(R1)
	BEQ	1$
	JSR	PC,TTORUB	;ECHO A '\'
	MOV	R0,(R1)
1$:	MOVB	@(R5),R4
	JSR	PC,RUBCOM
	BR	TTIEXZ



;****************************************************
;  STRING PRINT EMT

P$RINT:	MOVB	(R0)+,R4	;CHARACTER TO R4
.IF DF	$RXPRO							;###
	BEQ	TTCRSX		;NULL MEANS DONE, DO CR/LF	;###
.IFF								;###
	BEQ	TTCRLF		;NULL MEANS DONE. DO CR/LF
.IFTF								;###
	CMPB	#200,R4		;A 200 BYTE SAYS NO CRLF
.IFT								;###
	BEQ	TTIEX5		;JUST EXIT			;###
.IFF								;###
	BEQ	TTIEX3
.ENDC	;$RXPRO							;###
	JSR	PC,TTOPT2	;OUTPUT CHAR
	BR	P$RINT

;******************************************************
.IF DF	$RXPRO							;###
TTCRSX:	JSR	PC,TTLFCR	;CRLF				;###
TTIEX5:	JMP	E16XT		;EXIT FROM EMT			;###
CTRLC2:								;###
.IFF								;###
CTRLC2:	INC	(PC)+		;DELAY FOR 11/05
	0
	BNE	CTRLC2
	RESET			;STOP ALL IO
.ENDC	;$RXPRO							;###
	TST	CONFIG		;DO WE HAVE A CLOCK?
	BPL	1$		;NO
	MOV	(PC),@#LKCS	;TURN ON THE CLOCK AGAIN
1$:	MOV	QSIZE,QCNT	;SET FREE ENTRIES=TOTAL ENTRIES
	.EXIT			;AND EXIT

TTLFCR:	JSR	R3,ECHO
	.BYTE	CR,LF
TTIRTS:	RTS	PC

RUBCOM:	CMP	(R5),-2(R5)	;TIME TO WRAP AROUND?
	BNE	1$
	ADD	#TTYIN,(R5)	;RESET POINTER
1$:	DEC	(R5)+		;NOW DECREASE THE POINTER
				;AND BUMP TO COUNT
	DEC	(R5)		;DECREASE CHAR. COUNT
	RTS	PC

;****************************************
; THESE RING POINTERS AND TTILCT MUST
; BE KEPT TOGETHER AND IN THIS ORDER FOR THE
; TT: HANDLER TO BE ABLE TO WORK
;******************************************
TTILCT:	.BYTE	0		;EVEN BYTE IS LINE COUNTER
	.BYTE	0		;BIT 15 IS TT: INHIBIT FLAG
				;IF ^C IS HIT, AND TT: IS ACTIVE,
				;THIS BIT CAUSES TT: TO ABORT.
TTIBUF	= .
	IBUFR			;LOW LIMIT OF BUFFER
	IBUFR			;INTERRUPT SIDE POINTER
	0			;CURRENT COUNT
	IBUFR			;EMT SIDE POINTER
	IBUFR+TTYIN		;UPPER LIMIT
TTOBUF=.
	OBUFR			;EMT SIDE PTR
	0			;COUNT
	OBUFR			;INT PTR.
	OBUFR+TTYOUT		;HI LIMIT
TTOCLO:	.BYTE	0,0		;^O FLIP FLOP

IBUFR:	.BLKB	TTYIN		;START OF RING BUFFER
OBUFR:	.BLKB	TTYOUT
	.EVEN

RUBCM2:	TST	(R5)		;IS IT EMPTY?
	BEQ	TTIRTS		;BUFFER MUST BE EMPTY
	MOVB	@-(R5),R4	;PUT LAST CHAR INTO R4
EOLTST:	CMPB	R4,#LF
	BEQ	1$
	CMPB	R4,#03
	BEQ	1$
	CMPB	R4,#'Z&32	;IS IT EOF?
1$:	RTS	PC

.SBTTL	TTY OUTPUT ROUTINES, INTERRUPT ENTRY

TTORUB:	MOV	#'\,R4		;ECHO A \
TTOPUT:	CMP	R4,#ESCAPE	;ECHOING AN ESCAPE?
	BNE	TTOPT2		;NO.
	MOV	#'$,R4		;YES. ECHO DOLLAR SIGN
TTOPT2:	JSR	PC,OPUT		;OUTPUT A CHAR.
	BCS	TTOPT2		;WAIT FOR ROOM
	RTS	PC
.ENABL	LSB

OPUT:	TSTB	TTOCLO		;IS ^O ON?;ALSO CLEAR C
	BNE	2$		;ASSUME ITS OK.
TTSCRL:	BIC	#177600,R4	;NO PARITY BITS
	ADDR	TTOBUF+2,R2	;R2 TO COUNT
	CMP	#TTYOUT-1,(R2)	;WILL THIS ONE FIT?
	BLO	3$
	MOVB	R4,@-(R2)	;STORE CHARACTER IN BUFFER
	INC	(R2)		;INCREASE POINTER
	CMP	(R2),6(R2)	;TIME TO WRAP AROUND?
	BLO	1$
	SUB	#TTYOUT,(R2)	;DECREASE COUNT.
1$:	INC	2(R2)		;BUMP COUNT IN RING BUFF
.IF DF	$RXPRO							;###
;
;NEXT LINE DISABLED BY ';' 					;;;GB001
;
;	DSAR$S			;DISABLE AST'S			;###
	240							;;;GB001
	240							;;;GB001
	JSR	PC,@#TSTANP	;SEE IF AST NOT PENDING		;###	;;;GB001
;
;
;NEXT LINE DISABLED WITH ';'
;
;11$:	ENAR$S			;RE-ENABLE AST'S		;###	;;;GB001
11$:	240							;GB001
	240							;GB001
.IFF								;###
	MOV	#100,@TTPS
.ENDC	;$RXPRO							;###
2$:	CLC			;C IS CLEAR
3$:	RTS	PC


; THIS TTY INTERRUPT SERVICE HANDLES TABS AND FILL CHARACTERS.

TTOINT:	ADDR	TTOBUF+4,R5,PUSH ;SAVE R5, POINT TO COUNT
	JSR	R4,TTO2		;R4 TO TABCNT
TABCNT:	0			;# OF FILL OR SPACES TO PRINT
FILLC:	0			;CHARACTER TO PRINT
CHCNT:	10			;# SPACES TO NEXT TAB STOP
TTO2:	TST	(PC)+		;ARE WE DOING OUTPUT?
SYNC:	0
	BNE	TTPOXT		;NO. JUST RTI
	DEC	(R4)+		;DOING TABS OR FILLS?
	BGT	TPRNT3		;YES. PRINT SOME
31$:	MOV	R4,-(SP)	;SAVE VITAL R4
	MOV	TTENTR,R4	;***IF TT: RESIDENT, AND BUSY, GO INTO
				;*** THE WRITE PART OF TT: AND CHANGE
				;***THE R5 POINTER
	BR	41$		;;;UNCONDITIONAL FOR RT/RSX TT HANDLER
	JSR	R4,8.(R4)	;OUTPUT INT.
	TTILCT-.
41$:	MOV	(SP)+,R4	;RESTORE R4
	CMP	(R5),2(R5)	;TIME TO WRAP AROUND?
	BNE	4$
	SUB	#TTYOUT,(R5)	;CYCLE POINTER
4$:	DEC	-(R5)		;DECREASE COUNT
	CMP	(R5)+,#-1	;DONE YET?
	BEQ	TTODON		;***NOTE. WE DO THIS SO THAT TT:
				;CAN USE THIS CODE ALSO****
	MOVB	@(R5)+,(R4)	;GET CHARATER
	CMP	(R4),#40	;TEST FOR PRINTING CHAR.
	BLT	TCHKSP		;<40. CHECK SPECIALS
	CMP	(R4)+,#RUBOUT
	BGE	TTPRNT		;>177. IT WON'T PRINT
	DEC	(R4)		;DECREASE # TO NEXT STOP
	BNE	TTPRNT		;IF 0, RESET TO 10
	MOV	#10,(R4)
TTPRNT:	TST	-(R4)		;POINT TO FILLC
TPRNT7:	INC	-(R5)		;NEXT BUFFER LOC
.IF DF	$RXPRO							;###
TPRNT3:	JSR	PC,@#R4OUT	;WRITE CHAR TO TT		;###
.IFF								;###
TPRNT3:	MOV	(R4),@TTPB	;PRINT CHARACTER
.ENDC	;$RXPRO							;###
	BR	TTPOXT

TCHKSP:	CMP	(R4),#TAB	;IS IT A TAB?
	BNE	5$
	MOV	#40,(R4)+	;ECHO N SPACES
	MOV	(R4),-4(R4)	;SET UP TABCNT
	BR	6$		;RESET TAB STOP
5$:	CMP	(R4)+,#CR	;CARRIAGE RETURN
	BNE	7$
	CLR	-4(R4)		;END OF LINE. CLEAR FILL COUNT.
6$:	MOV	#10,(R4)
7$:	TST	-(R4)		;POINT TO FILLC
	CMPB	(R4),@#TTFILL	;HAVE TO FILL?
	BNE	TPRNT7		;NO. JUST PRINT THIS ONE
.IF DF	$RXPRO							;###
	JSR	PC,@#R4OUT	;WRITE CHAR TO TT		;###
.IFF								;###
	MOV	(R4),@TTPB	;TYPE THIS ONE
.ENDC	;$RXPRO							;###
	CLR	(R4)		;FILLERS ARE NULLS
	CLR	-(R4)		;POINT R1 TO FILL COUNT AND CLEAR IT
	MOVB	@#TTNFIL,(R4)	;XFER FILL COUNT TO TABCNT
	INC	-(R5)		;NEXT BUFFER WORD
	BR	TTPOXT		;AND EXIT FOR NOW.

TTODON:
.IF DF	$RXPRO							;###
	JMP	@#RSTTDN	;DONE-CLEAN UP AND EXIT		;###
.IFF								;###
	CLR	@TTPS		;CLEAR INTERRUPTS
	CLR	-(R5)
.ENDC	;$RXPRO							;###
TTPOXT:	MOV	(SP)+,R4
	MOV	(SP)+,R5
.IF DF	$RXPRO							;###
	JMP	@#TTEXIT	;GO EXIT FROM TT INTERRUPT	;###
.IFF								;###
	RTI
.ENDC	;$RXPRO							;###
.DSABL	LSB

;**************************************************
; COMMON INTERRUPT ENTRY CODE. PUSHES R5,R4 ON STACK
; SETS PROPER PRIORITY, THEN RECALLS THE HANDLER
; VIA A JSR PC,. ON RETURN, REGS ARE RESTORED AND
; THE RTI IS DONE
;**************************************************

$INTEN:	MOV	R4,-(SP)	;R5 IS ON STACK FROM JSR R5
.IF DF	$RXPRO							;###
	TST	(R5)+		;DON'T DIDDLE STATUS FOR RSX	;###
.IFF								;###
	BIC	(R5)+,@#PS	;SET PRIORITY BITS
.IFTF								;###
	JSR	PC,(R5)		;CALL THE HANDLER BACK
.IFF								;###
	BR	TTPOXT		;RESTORE REGS AND RTI
.IFT								;###
	JMP	@#XAST	;TO BOOT TASK TO EXIT AST	;###
.ENDC	;$RXPRO							;###

.ENABL	LSB
.SBTTL	READ/WRITE EMT HANDLERS, MT/CT FUNCS.

S$PFUN:	MOV	(R3),R2		;GET DEVICE INDEX
	BIC	#^C76,R2
	ADD	PC,R2		;MAKE IT PIC
;	BIT	#SPECL$,$STAT-.(R2)
;	BEQ	RWXT		;IT ISN'T SPECIAL
	MOVB	#377,4(R1)	;BE NICE, GIVE HIM A 377
	TST	4(R1)		;IF NOT <0, GIVE ERROR
	BPL	5$

R$EAD:	JSR	R4,TSWCNT	;DO SOME CHECKING
	NOP
	NOP
NFREAD:	MOV	R4,(SP)		;SET WORD COUNT FOR R0
1$:	BIT	#HDERR$,(R3)	;HARD ERROR?
	BNE	6$
	BIT	#EOF$,(R3)	;END OF MEDIUM?
	BNE	4$
	MOV	R1,R5		;POINT R5 AT ARG LIST
	TST	-(R5)		;R5 TO TOP OF LIST. (BUFFER)
	MOV	(R3),R2		;ISOLATE ENTRY VALUE OF HANDLER
	BIC	#177701,R2
	ADDR	$ENTRY,R2,ADD	;COMPUTE PHYSICAL ENTRY POINT
	MOV	(R2),R2		;TST HNDLR IN CORE, AND
				;MOVE ENTRY PT. TO R2
	BEQ	2$		;NO HANDLER! ZOUNDS, MAN!
	ADD	C.SBLK(R3),R0	;MAKE BLOCK ABSOLUTE.
	MOV	C.DEVQ(R3),R1	;UNIT # TO R1
	CLRB	R1
	JSR	PC,QMANGR	;QUEUE AN ENTRY
	BIT	#HDERR$,(R3)	;HARDWARE GOOF?
	BNE	6$
RWXT:	MOV	#3,R2		;3 ARGUMENTS TO CLEAN UP
	BR	E16.7A

2$:	MONERR	NODV.E,0	;NO DEVICE HANDLER
	BR	RWXT		;EXIT SOFTLY, DARLING

3$:	TST	(SP)+		;PURGE STACK
4$:	BIC	#EOF$,(R3)	;CLEAR EOF BIT
5$:	EMTERR+0
	BR	RWXT

6$:	BIC	#HDERR$,(R3)	;CLEAR ERROR BIT
	EMTERR+1
	BR	RWXT

7$:	TST	(SP)+
	EMTERR+2
	BR	RWXT

	;WRITE EMT

W$RITE:	JSR	R4,TSWCNT
	 BR	NFWRIT		;NON FILE OR DIRECTORY OP.
	 EMTERR+0
	CMP	R5,C.USED(R3)
	BLOS	NFWRIT
	BIT	#DWRIT$,(R3)	;ENTERED ?
	BEQ	NFWRIT		;NO
	MOV	R5,C.USED(R3)
NFWRIT:	MOV	R4,(SP)		;WORD COUNT FOR R0
	NEG	R4		;MAKE IT A WRITE
	BR	1$		;DO COMMON STUFF

.SBTTL	READ/WRITE ROUTINE
; TSWCNT-
; TSWCNT SETS R5 TO THE REQUESTED WORD COUNT.
; R3 POINTS TO THE CHANNEL STATUS WORD
; IF THE STARTING BLOCK OF A CHANNEL IS 0, IT  IS EITHER
; A NON-FILE STRUCTURED DEVICE, OR A DIRECTORY OPERATION.
; IN EITHER CASE, THE READ IS ALLOWED TO PROGRESS.

TSWCNT:	TST	(R1)+		;POINT TO WORD COUNT
	MOV	(R1),R5		;WORD COUNT TO R5
	MOV	R5,(SP)		;NOTE THAT R4 IS NOT VALUABLE ON
				;ENTRY, AND THIS WILL CAUSE THE
				;CORRECTED WORD COUNT TO BE RETURNED
				;IN R4
	MOV	(R3),R2		;STATUS PTR TO R1, AND
				;IS CHANNEL OPEN?
	BPL	7$		;NO. THAT 'S A NO-NO
	BIC	#177701,R2	;STATUS POINTER TO R1
	ADDR	$STAT,R2,ADD
	TST	(R2)		;NON FILE DEVICE?
	BPL	TSWOUT		;POSITIVE MEANS NON FILE
	BIC	#EOF$,(R3)	;CLEAR EOF FOR FILE STRUCTURED
	TST	C.SBLK(R3)	;0 HERE MEANS DIRECTORY OPERATION
	BEQ	TSWOUT
	CMP	(R4)+,(R4)+	;TO LEGAL RETURN
	MOV	C.LENG(R3),R2	;FILE LENGTH TO R2
	CMP	R0,R2		;IS BLOCK NUMBER LEGAL?
	BHIS	3$		;NO. GENERATE EOF.
	ADD	#377,R5		;CHANGE WORD COUNT TO BLOCKS
	CLRB	R5
	SWAB	R5
	ADD	R0,R5		;NEW CLOSING LENGTH GUESS
	SUB	R5,R2		;WILL IT ALL FIT?
	BPL	TSWOUT		;YES. GET OUT
	ADD	R2,R5		;MAKE R5 HIGHEST THAT IS LEGAL
	MOV	R5,(SP)		;AND RETURN # WE READ.
	SUB	R0,(SP)
	SWAB	(SP)
	TST	-(R4)		;TAKE EOF EXIT
TSWOUT:	RTS	R4
.DSABL	LSB

.SBTTL	SAVESTATUS AND REOPEN; I/O WAIT
.SBTTL	CHANNEL DEFINE

S$AVST:	TST	(R3)		;IS THIS CHANNEL OPEN?
	BPL	1$		;NO. SAVE 'NOT OPEN' STATUS
	TSTB	(R3)		;WAS AN 'ENTER'DONE?
	BMI	E5ER1		;YES. NO SAVESTATUS PERMITTED
1$:	MOV	(R3),(R0)+	;CHANNEL STAT. WORD
	CLR	(R3)+		;DEACTIVATE CHANNEL.
	.REPT	4		;FILL IN REMAINING DATA
	 MOV	(R3)+,(R0)+
	.ENDR
XCLOSE:	CLR	R2
E16.7A:	JMP	EMTDON


; REOPEN----
R$OPEN:	TST	(R3)		;CHANNEL CAN'T BE IN USE
	BMI	E5ER0		;AMAZING! REOPEN IS INVERSE OF SAVE!
	.REPT	5		;REPLACE THE WORDS
	 MOV	(R0)+,(R3)+
	.ENDR
	BR	XCLOSE
E5ER0:	EMTERR+0
	BR	XCLOSE

; EMT12--WAIT ON I/O. ALSO, THIS EMT RETURNS AN ERROR IF THE
; CHANNEL IS NOT ACTIVE. THIS GIVES A WAY OF CHECKING TO SEE IF
; A CHANNEL IS CURRENTL BEING USED.

W$AIT:	TST	(R3)		;CHANNEL ACTIVE?
	BPL	E5ER0		;>0=> NO
1$:	TSTB	C.DEVQ(R3)	;WAIT TILL PENDING REQUESTS=0
	BNE	1$
	BIT	#HDERR$,(R3)	;WAS THERE AN ERROR?
	BEQ	XCLOSE		;NO. RETURN TO USER
	BIC	#HDERR$,(R3)	;YES. CLEAR HARD ERROR BIT
E5ER1:	EMTERR+1
	BR	XCLOSE

.SBTTL	SWAP USR ROUTINE

; CALUSR----
; THIS ROUTINE LOADS THE USR INTO CORE.
; THE USER PROGRAM IS SWAPPED OUT IF NECESSARY.

CALUSR:	INC	MONCAL		;BUMP USAGE COUNT
	TST	USRLOC		;MONITOR IN CORE?
	BNE	MONRES
CLUSR2:	MOV	@#UFLOAT,-(SP)	;ADDRESS OF FLOATING USR
	BNE	1$
	MOV	$USRLC,(SP)	;LOAD BELOW RMON
1$:	MOV	(SP),MONLOC
	TST	@#JSW		;DO WE HAVE TO SWAP?
	BMI	2$		;NO. READ IN USR.
	MOV	$SWPBL,R0	;WRITE USER OUT FIRST
	NEG	MONLOC+2	;MAKE IT A WRITE
	JSR	PC,$WSYS
2$:	MOV	(PC)+,R0
$MONBL:	0			;***BOOT***
	MOV	(SP)+,USRLOC	;MAKE MONITOR RESIDENT

$RSYS:	MOV	#USRLEN,MONLOC+2
$WSYS:	ADDR	MONLOC,R5	;POINT R5 TO MONLOC
IOSR:	JSR	PC,$SYS
	BCS	MONIOF
MONRES:	RTS	PC

.SBTTL	USR RELEASE,RETURN, REG. SAVE&RESTORE

.EVEN
; EMT 16-SUB 7--RELEASE USR FROM CORE. AFTER A LOCK IS DONE,
; THIS EMT RELEASES THE USR. ALSO, MONOUT IS THE RETURN POINT
; FROM ALL NON RESIDENT USR FUNCTIONS.

				;NOTE THAT R2=0 HERE
U$NLOK:	TST	MONCAL		;AT WHAT LEVEL ARE WE?
	BEQ	E16.7A		;NOT LOCKED !
MONOUT:	DEC	(PC)+		;TIME TO RE-READ USER?
MONCAL:	0
	BNE	E16.7A		;I GUESS NOT.
KMTST:	TST	KMONIN		;IS KMON IN CONTROL?
	BNE	E16.7A		;YES. DON'T SWAP.
	TST	DFLG		;DO WE HAVE TO SERVICE ^C?
	BPL	1$		;>0 IMPLIES NO.
	.EXIT			;YES. EXIT.
1$:	TST	@#JSW		;DO WE HAVE TO SWAP?
	BMI	E16.7A		;NO IF MINUS
	CLR	USRLOC		;USR NO LONGER IN CORE
	CLR	BLKEY		;KILLS DIRECTORY IN CORE
	MOV	$SWPBL,R0	;READ IN THE USER
	JSR	PC,$RSYS
	BR	E16.7A		;END OF EMT.

SPAREA:				;COMMON EMT 375 LIST, AND
KMBLK:	BSS	5		;IO BLOCK FOR 'FINAL' READ
MONLOC:	USRBUF
	USRLEN
MONIOF:	0			;HALT AT FATAL READ ERROR
	BR	MONIOF		;PROTECTION!!!

RDOVLY:	JSR	PC,IOSR		;I HOPE HANK SET IT UP RIGHT!
ENTRPG:	MOV	@#USERSP,SP	;NEW STACK POINTER
	CLR	(PC)+		;USER IS RUNNING
KMONIN:	1
	JMP	@R2		;TO THE USER!

.SBTTL	ECHO, SVREG, POPREG
; ECHO--ECHOES CHARACTERS ON CONSOLE TTY
ECHO:	MOVB	(R3)+,R4
	JSR	PC,TTOPUT
	MOVB	(R3)+,R4
	BEQ	1$
	JSR	PC,TTOPUT
1$:	RTS	R3

SVREG:	MOV	R2,-(SP)
	MOV	R3,-(SP)
	MOV	R4,-(SP)
	MOV	R5,-(SP)
	MOV	R0,-(SP)
	JMP	(R1)

; POPREG--POP REGISTERS FROM THE STACK; ALSO, R2 CONTAINS THE NUMBER
; OF USER ARGUMENTS TO REMOVE FROM THE STACK.

POPREG:	MOV	SAVE+4(SP),R3	;SEE IF IT'S A NEW EMT
	CMPB	#374,-2(R3)
	BLOS	NOPOP		;YES. NO POPPING NEEDED
.IF DF	$RXPRO							;###
POPRG1:								;###
.ENDC	;$RXPRO							;###
	ASL	R2		;WDS TO POP INTO BYTES
	BEQ	NOPOP		;NONE TO DO
	MOV	SP,R3		;MARK CURRENT SPOT
	ADD	#OLDPS+4,R3	;TO PS/PC OF EMT
	ADD	R3,R2		;TO 1 ABOVE FIRST ARG.
1$:	MOV	-(R3),-(R2)	;MOVE THE CONTENTS
	CMP	R3,SP		;DONE?
	BHI	1$		;NOT YET
	MOV	R2,SP		;YES. SET NEW STACK
NOPOP:	TST	(SP)+		;OLD VALUE OF R1..USELESS
	MOV	(SP)+,R0	;NOW RESTORE USER REGISTERS
	MOV	(SP)+,R5
	MOV	(SP)+,R4
	MOV	(SP)+,R3
	MOV	(SP)+,R2
	RTS	R1

EKOR0:	MOVB	R0,-(SP)
	ADD	#100,(SP)	;ECHO THE UPPER CASE
	MOVB	(SP)+,EBYT
	JSR	R3,ECHO
	.BYTE	'^
EBYT:	.BYTE	0		;HOLDS CHAR TO BE ECHOED
	RTS	PC

.SBTTL	QUEUE AND QUEUE MANAGER

; RT11 IS DRIVEN FROM AN IO QUEUE.
; ALL IO REQUESTS ARE PUT INTO A COMMON QUEUE, AND THE
; INDIVIDUAL DEVICE DRIVERS TAKE THEIR JOBS FROM THAT QUEUE

; THE ENTRY POINT FOR MONITOR IO REQUESTS IS $SYS. THIS ENTRY
; SAVES ALL REGISTERS, AND INITIATES A CALL TO THE
; Q MANAGER
$SYS:	JSR	R1,SVREG	;SAVE REGISTERS
	ADDR	$SYSCH,R3	;SYS CSW AREA
	CLR	10(R3)		;CLEAR SYS IO COUNT TO
				;PREVENT SYSTEM HANG-UP.
	MOV	SYUNIT,R1	;SYS UNIT # TO R1
	MOV	(PC)+,R2	;LAST Q ENTRY FOR SYS
SYENTR:	.WORD	0

SYENTO=SYENTR-$RMON

	MOV	2(R5),R4	;SET WORD COUNT FOR XFER
	JSR	PC,QMANGR	;Q A REQUEST
1$:	JSR	R1,NOPOP	;RESTORE REGISTERS
	ROR	$SYSCH		;SEE IF ERROR IS ON
	RTS	PC

;**********************************************************************
; THIS IS THE INITIAL Q
;
; KEEP THESE ENTRIES IN THIS ORDER
;**************
.ENABL	LSB

QSIZE:	1			;ONE ENTRY LONG
QCNT:	1			;ONE FREE ENTRY
AVAIL:	QSTART			;POINTS TO FIRST ELMENT
QSTART:	BSS	7		;ONE ENTRY STANDARD

; QUEUE MANAGER.
; THE Q MANAGER IS ENTERED WHEN AN IO REQUEST IS TO BE PUT IN
; THE Q. THE ENTRY CONDITIONS ARE:
;	CALLED BY-	JSR	PC,QMANGR
;	REGISTERS:
;		0	BLOCK TO READ/WRITE
;		1	UNIT NUMBER IN LOW BITS OF ODD BYTE
;		2	POINTS TO 4TH WORD OF HANDLER
;		3	POINTER TO CHANNEL STATUS WORD
;		4	WORD COUNT FOR TRANSFER
;		5	POINTER TO ARGUMENT LIST

QMANGR:	MOV	R4,-(SP)	;SAVE WORD COUNT FOR LATER
1$:	ADDR	QCNT,R4		;R4 TO QCNT POINTER
	DEC	(R4)+		;IS THERE ROOM IN Q YET?
	BMI	9$		;NO
	MOV	R3,-(SP)	;SAVE REGISTERS
	MOV	R0,-(SP)
	MOV	#PS,R0		;POINTER TO CPU STATUS
.IF DF	$RXPRO							;###
	DSAR$S			;DISABLE AST'S			;###
.IFF								;###
	MOV	#340,(R0)	;SET TO NO INTERRUPTS SERVICED
.ENDC	;$RXPRO							;###
	MOV	(R4),R4		;GET FIRST AVAILABLE ENTRY
	MOV	(R4),AVAIL	;MAKE THE NEXT ELEMENT AVAILABLE
.IF DF	$RXPRO							;###
	ENAR$S			;ENABLE AST'S			;###
.IFF								;###
	CLR	(R0)		;BACK TO 0 FOR A WHILE
.ENDC	;$RXPRO							;###
	CLR	(R4)+		;ZERO PTR. TO NEXT Q ELEMENT
	MOV	R3,(R4)+	;FILL IN Q: PTR TO CSW
	INCB	10(R3)		;BUMP CHANNEL Q REQUEST COUNT
	MOV	R4,R3
	MOV	(SP)+,(R4)+	;BLOCK NUMBER
	MOV	R1,(R4)+	;UNIT NUMBER
	MOV	(R5)+,(R4)+	;BUFF ADDRESS
	MOV	2(SP),(R4)+	;WORD COUNT
	TST	(R5)+		;SKIP THIS WORD COUNT
	MOV	(R5)+,(R4)	;COMPLETION FUNCTION
;**************************************************
	CMPB	(R4),#377	;SPECIAL CALL?
	BNE	2$
	SWAB	(R4)
	MOVB	(R4),-6(R4)	;PUT CODE INTO CODE WD.
	MOV	(R5)+,(R4)	;REAL COMPLETION ADD.
	BR	3$
2$:	CLRB	-6(R4)		;NORMAL R/W OPERATION
;**************************************************
3$:	MOV	R5,-(SP)
.IF DF	$RXPRO							;###
	DSAR$S			;DISABLE AST'S			;###
.IFF								;###
	MOV	#PR7,(R0)	;LEVEL 7
.ENDC	;$RXPRO							;###
	TST	EXTFLG		;*IF EXIT IN PROGRESS, DON'T
	BNE	4$		;*WAIT FOR SYS TO EMPTY OUT
	MOV	(R2),R1		;*IS DEVICE BUSY?
	BNE	5$		;*YES. ADD NEW ELEMENT TO Q
4$:	MOV	R3,(R2)+	;*SET DEVICE BUSY
.IF DF	$RXPRO							;###
	ENAR$S			;ENABLE AST'S			;###
.IFF								;###
	CLR	(R0)		;*BACK TO LEVEL 0
.ENDC	;$RXPRO							;###
	MOV	R3,(R2)+	;POINT BUSY FLAG AT Q ELEMENT
	JSR	PC,(R2)		;START THE HANDLER
	BR	6$
5$:	MOV	R3,-4(R1)	;* LINK NEW ELEMENT TO END OF Q
	MOV	R3,(R2)		;* AND SET LAST Q ELEMENT TO IT
.IF DF	$RXPRO							;###
	ENAR$S			;ENABLE AST'S			;###
.IFF								;###
	CLR	(R0)		;*
.ENDC	;$RXPRO							;###
6$:	MOV	(SP)+,R5
	MOV	(SP)+,R3
	TST	-(R5)		;GO TO COMPLETION?
	BNE	8$
7$:	TSTB	10(R3)		;WAIT FOR IO TO COMPLETE
	BNE	7$
8$:	MOV	(SP)+,R4	;KEEP STACK STRAIGHT
	RTS	PC

9$:	INC	-(R4)
10$:	TST	(R4)		;WAIT FOR FREE
	BLE	10$
	BR	1$


.DSABL	LSB

.SBTTL	QUEUE COMPLETION, KMON STACK
.ENABL	LSB

; WHEN A DEVICE TRANSFER COMPLETES, THE HANDLER TRANSFERS TO
; COMPLT, TO START A NEW REQUEST OR TO ENTER THE COMPLETION 
; ROUTINE SPECIFIED.
; ENTER WITH R4 AND R5 ON STACK. R4 POINTS TO THE LOCATION
; IN THE HANDLER WHICH POINTS TO THE CURRENT Q ENTRY BEING
; PROCESSED.

COMP	= 14
COMPLT:	JSR	R1,SVREG	;WILL NEED THIS FOR SPACE
	MOV	(R4),R5		;GET PTR. TO CURRENT Q ELEMENT
	BIT	#HDERR$,@-(R5)	;HARD ERROR?
	BNE	7$		;YES. GO SERVICE IT
1$:	MOV	(R5),R2		;PUT CSW INTO R0 NOW
	MOV	(R2),R0		;THERE IT GOES!
	CLR	R1		;NOW DIVIDE TO GET CHAN. NUMBER
	SUB	I.CSW,R2	;SUBTRACT START OF CSW AREA
2$:	SUB	#10.,R2		;DIVIDE BY 12(8) BYTES FOR CHAN NUM.
	BLO	3$
	INC	R1		;CHANNEL NUMBER BUILT IN R1
	BR	2$
3$:	ADD	#10,(R5)+	;NOW DECREASE PENDING IO Q
	DEC	@-(R5)		;REQUESTS
	MOV	#PS,R2		;A FEW OPERATIONS ON PSW
.IF NDF	$RXPRO							;###
	MOV	(R2),-(SP)	;SAVE WHAT WE ENTERED WITH
.ENDC	;$RXPRO							;###
.IF DF	$RXPRO							;###
	DSAR$S			;DISABLE AST'S			;###
.IFF								;###
	MOV	#PR7,(R2)	;AND GO TO LEVEL 7
.ENDC	;$RXPRO							;###
	MOV	-(R5),(R4)	;PTR. TO NEXT ELEMENT IF ANY
	BNE	4$
	CLR	-(R4)		;NONE. DEVICE IS FREE
	CLR	R4		;REMEMBER THAT IT IS FREE
4$:	MOV	AVAIL,(R5)	;PUT OLD ELEMENT INTO AVAILABLES
	MOV	R5,AVAIL
	INC	QCNT		;NEW ELEMENT AVAILABLE
	MOV	COMP(R5),R5	;COMPLETION ADDRESS
.IF NDF	$RXPRO							;###
	MOV	(SP)+,(R2)	;BACK TO DEVICE PRIORITY
.IFF								;###
	ENAR$S		;???	;ENABLE AST'S			;###?????????????
.ENDC	;$RXPRO							;###
	CMP	#1,R5		;GO TO A COMPLETIO ADDRESS?
	BHIS	5$
	INC	RECURS		;YES. SET MONITOR PROTECT
	MOV	@#ERRBYT,-(SP)	;SAVE ERROR STATUS
	JSR	PC,(R5)		;DO COMPLETION
	MOV	(SP)+,@#ERRBYT
	DEC	(PC)+
RECURS:	0
5$:	TST	R4		;WAS DEVICE FREE BEFORE COMPLETION?
	BEQ	6$		;YES. NO MORE ENTRIES NOW
	JSR	PC,2(R4)	;CALL HANDLER TO START NEW TRANSFER
6$:	JSR	R1,NOPOP	;RESTORE REGS.
	RTS	PC		;BACK INTO $INTEN

7$:	TSTB	@#JSW		;HALT ON HARD ERROR?
	BPL	1$
	HALT

.	= . + 100
SPTR	= .
.DSABL	LSB

MAXSYH	= DTSIZE
.IIF GT RKSIZE-MAXSYH	MAXSYH = RKSIZE
.IIF GT DXSIZE-MAXSYH	MAXSYH=DXSIZE
RMONSZ	= . + MAXSYH - $RMON + 777 / 1000 ;RMON LENGTH IN BLOCKS
RMSIZE	= RMONSZ * 1000		;RMON LENGTH IN BYTES
RMLEN	= RMONSZ * 400		;RMON LENGTH IN WORDS

RT11SZ	= KMONSZ + USRSZ + RMONSZ ;NUMBER OF BLOCKS IN ALL OF RT-11
RTSIZE	= RT11SZ * 1000		;SIZE OF RT-11 IN BYTES
RTLEN	= RT11SZ * 400		;SIZE OF RT-11 IN WORDS
FILLER=	RT11SZ*1000-<.-KMON+MAXSYH>	;AMOUNT TO FILL TO PLACE THE
					;KMON OVERLAYS ON A BLOCK

.CSECT	SYSHND
; SYSTEM HANDLER FITS IN THIS CSECT
.	= . + MAXSYH + FILLER
.IIF DF NLRMON, .LIST