DOQIO=0
	.SBTTL INTRODUCTION
	.TITLE	ASDEV	;ASSIGNABLE PSEUDO-TERMINAL HANDLER
;	MODIFIED TO ALLOW OUTPUT QIO TO LUN 2 IF
;	SWITCH 14 IS UP (CONDITIONAL ASSEMBLY)
;
;	THIS FEATURE IS INTENDED TO PERMIT GB TO BE USED AS A
;	PSEUDO-DEVICE PERMITTING OUTPUT TO IT TO BE COPIED TO
;	TT0: OR SOME SUCH PLACE BUT SUCH THAT IT CAN BE LEFT "LOGGED IN"
;	AND PRIVILEGED (DEFINED AS A TERMINAL IN ITS PUD) AS DESIRED.
;
	.IDENT	'V002.X'
;
; GARBAGE DEVICE HANDLER TASK FOR RSX11D.
;
; THIS HANDLER IS AN RSX11D PRIVILEGED TASK WHICH CAN ABSORB OUTPUT
; DIRECTED TO IT BY A TASK ("WRITE-ONLY MEMORY"), THUS PROVIDING A 
; MEANS BY WHICH OUTPUT GENERATED ON CERTAIN LUNS BY A PARTICULAR TASK
; MAY BE SUPPRESSED IF DESIRED (ANALOGOUS TO OS/360 "// DD DUMMY"
; STATEMENTS).  IT ALSO ACCEPTS READ FUNCTIONS, RESPONDING TO THEM BY
; IMMEDIATE GENERATION OF END-OF-FILE STATUS WITHOUT TRANSFERING ANY
; DATA.
;	THE FACILITY FOR OUTPUT TO FILES OR INPUT FROM FILES HAS BEEN
;	ADDED TO PERMIT ONE TO (ASSIGNABLY) OBTAIN FILE STRUCTURED
;	INPUT/OUTPUT FROM TASKS WHICH DO NOT NORMALLY DO FILE-
;	STRUCTURED I/O. WHERE THE FILES ARE NOT DEFINED (BY SPECIAL
;	QIO'S TO THIS HANDLER), THE INPUT WILL OBTAIN INSTANT EOF AND
;	THE OUTPUT WILL BE DISCARDED (OR AT MOST, SENT VIA QIO TO
;	ANOTHER TERMINAL).
;
; THE PUD ENTRY FOR THE GARBAGE DEVICE MUST CONTAIN THE FOLLOWING
; INFORMATION:
;
; DEVICE NAME		U.DN	"AS"
; UNIT NUMBER		U.UN	0 (BYTE)
; CHARACTERISTICS 1	U.C1	UC.REC=1 - RECORD ORIENTED DEVICE
;				(SET ALL TTY BITS)
; CHARACTERISTICS 4	U.C4	DEFAULT LINE OR BUFFER SIZE = 210 OCTAL
;
; THE REMAINDER OF THE PUD DATA WORDS ARE IRRELEVANT.
;
; THE FOLLOWING QIO FUNCTIONS ARE SUPPORTED:
;
; KILL I/O 	(12)	CANCELS ALL REQUESTS FOR THE ISSUING TASK
; I/O RUNDOWN	(22)	LIKE KILL I/O, BUT EXECUTIVE REQUEST
; UNLOAD HANDLER(42)	CAUSES HANDLER TO EXIT
; WRITE		(400)	DATA BUFFER IS UNCHANGED; I/O COMPLETION OCCURS
;			WITH LENGTH OF DATA TRANSFERED EQUAL TO BUFFER
;			LENGTH
; READ		(1000)	DATA BUFFER IS UNCHANGED; I/O COMPLETION OCCURS
;			WITH END-OF-FILE STATUS AND LENGTH OF DATA
;			TRANSFERED EQUAL TO 0.
; ATTACH	(1400)	ATTACHES THE GARBAGE DEVICE TO THE CALLER
; DETACH	(2000)	DETACHES THE GARBAGE DEVICE FROM THE CALLER
; OPEN		(2400)	OPENS INPUT ON LUN 3
;		(3400)	OPENS OUTPUT ON LUN 4
; CLOSE		(3000)	CLOSES INPUT FILE
;		(4000)	CLOSES OUTPUT FILE
;
; THE FOLLOWING COMPLETION CODES ARE RETURNED BY THE HANDLER:
;
; IE.IFC	-02	INVALID FUNCTION CODE
; IE.SPC	-06	IMPROPER USER BUFFER ADDRESS OR LENGTH
; IE.DNA	-07	DETACH FAILED -- DEVICE NOT ATTACHED
; IE.DAA	-08	ATTACH FAILED -- DEVICE ALREADY ATTACHED
; IE.EOF	-10	END OF FILE DETECTED ON READ
; IE.PRI	-16	PRIVILEGE VIOLATION
; IS.SUC	+01	SUCCESFUL COMPLETION
;
; TASK ATTRIBUTES: /-AB /-CP /DS /-FP /-FX /HD /-MU /-PI /PR /-TA /-TR
;
; TASKNAME:   AS....
; PARTITION:  GEN
; POOL LIMIT: 60
; PRIORITY:   200
; STACK:      256
; UIC:        [1,1]
; UNITS:      4
;
;	NOTE:
;	LUN 2 IS FOR QIO TO A TERMINAL (IF SW 14 IS UP)
;	LUN 3 IS FILE INPUT IF ENABLED
;	LUN 4 IS FILE OUTPUT IF ENABLED.
;
;	SPECIAL FUNCTIONS ARE USED TO OPEN/CLOSE FILES. (ALWAYS NEW VERSION)
;	FILES ARE OPENED BY OPEN WITH FILE SPECS IN BUFFER
;	FILES STAY OPEN UNTIL EITHER I/O RUNDOWN, INPUT EOF, OR HANDLER
;	UNLOAD, OR OF COURSE A USER FILE CLOSE REQUEST. BUFFER SIZE IS
;	CURRENTLY LIMITED TO 60. BYTES AND BUFFERS ARE ALLOCATED ON THE
;	HANDLER TASK STACK.
;	THE I/O RUNDOWN CODE WILL CLOSE THE FILE
;	USED FOR INPUT AND THE ONE FOR OUTPUT IF THEY ARE OPEN AT THE
;	TIME THAT PROCESSING IS DONE.
;

	.SBTTL SYMBOL DEFINITIONS
;
; MACRO CALLS:
;
	.MCALL	EXIT$S,DIR$,WTLO$
	.MCALL	FSRSZ$,FDBDF$,CLOSE$
	.MCALL	OPEN$,FDAT$A
	.MCALL	FINIT$,GSSW$S
	FSRSZ$	2	;MAX 2 FILES AT A TIME (BOTH SEQUENTIAL)
;
; DEFINITIONS:
;
GBNAME	=	"AS		;HANDLER NAME (ASSIGNABLE FILE DEVICE)
GBUNIT	=	0		;HANDLER UNIT NUMBER
;
NREFM1	=	1		;NORMAL REQUEST EVENT FLAG MASK WORD 1
XREFM1	=	2		;EXPRESS REQUEST EVENT FLAG MASK WORD 1
;
WRT	=	1		;TRANSFER DIRECTION FOR WRITE
;
	.PSECT	GBGRW,RW
;
	.SBTTL INITIALIZATION CODE, EXIT CODE, AND IDLE CODE
;
INPOPN:	.WORD	0		;NON-0 IF INPUT ACTIVE FILE
OUTOPN:	.WORD	0		;NON-O IF OUTPUT FILE ACTIVE
INFDB:	FDBDF$
	FDAT$A	R.VAR,FD.CR
OUTFDB:	FDBDF$
	FDAT$A	R.VAR,FD.CR
GBSTRT:	MOV	#GBUIT,R0	;SET ADDRESS OF UIT
	MOV	#GBNAME,R2	;SET HANDLER NAME
	MOV	#UF.RH,R3	;HANDLER RESIDENT FLAG
	JSR	PC,@#..DSUT	;DECLARE HANDLER RESIDENT
	BCS	EXIT		;GO AWAY IF IT FAILS
	CLR	EXITFL		;CLEAR EXIT FLAG
	CLR	INPOPN		;FLAG INPUT INACTIVE
	CLR	OUTOPN		;ALSO OUTPUT
	FINIT$			;INITIALIZE FILE STORAGE AREA
;	MOV	PC,SP		;INCREASE STACK SIZE
;
IDLE:	TST	EXITFL		;HANDLER WANT TO EXIT?
	BEQ	SLEEP		;NO
	TST	INPOPN		;FILE OPEN FOR INPUT?
	BEQ	1$		;NO
	CLOSE$	#INFDB		;YES, CLOSE IT
1$:	TST	OUTOPN		;HOW 'BOUT OUTPUT?
	BEQ	2$		;NO
	CLOSE$	#OUTFDB		;YES, CLOSE THAT TOO.
2$:
	MOV	#GBUIT,R0	;YES, GET UIT ADDRESS
	JSR	PC,@#..DNRC	;DECLARE NONRESIDENT...
EXIT:	EXIT$S			;...AND BECOME NONRESIDENT
;
SLEEP:	DIR$	#IDLDPB		;WAIT FOR NORMAL OR EXPRESS REQUEST
;

	.SBTTL REQUEST DEQUEING AND DISPATCH
;
CHECK:	MOV	#GBUIT,R0	;GET UIT ADDRESS
	MOV	@#.CRTSK,R1	;HANDLER ATL ADDRESS
	MOV	A.EF(R1),R5	;GET HANDLER EVENT FLAGS 1-16
	BIT	#XREFM1,R5	;ANY EXPRESS QUEUE REQUESTS?
	BEQ	1$		;NO
	JSR	PC,@#..DQRE	;YES, DEQUEUE ONE
	BCC	2$		;GOT IT!
1$:	BIT	#NREFM1,R5	;ANY NORMAL QUEUE REQUESTS?
	BEQ	IDLE		;NO
	JSR	PC,@#..DQRN	;YES, GRAB ONE
	BCS	IDLE		;NONE AFTER ALL
2$:	MOVB	R.FC+1(R1),R3	;GET I/O FUNCTION CODE
	CMP	R3,#NFUNS	;SEE IF IT'S IN VALID RANGE
	BLO	112$
	JMP	UNRFN		;ILLEGAL
112$:
;	BHIS	UNRFN		;NO, IT'S ILLEGAL
	JSR	PC,@#..VACC	;CHECK FINER DETAILS
	BCC	111$
	JMP	NOPRIV
111$:
;	BCS	NOPRIV		;NO GOOD (DON'T HAVE NEEDED PRIVILEGES)
	JMP	@#..DISP	;ALL OK: DISPATCH VIA FUNCTION TABLE
;

	.SBTTL SPECIAL FUNCTIONS (CODE 0)
;
SPECFN:	MOV	R.FC(R1),R3	;GET FUNCTION CODE
	CMP	R3,#IO.KIL	;IS IT I/O KILL?
	BEQ	1$		;YES, DO IT
	TST	R.AT(R1)	;DOES REQUEST COME FROM EXEC?
	BEQ	60$
61$:	JMP	UNRFN		;NO, CAN'T ALLOW IT!
60$:	CMP	R3,#IO.RDN	;I/O RUNDOWN?
	BEQ	2$		;YES, DO IT
	CMP	R3,#IO.UNL	;UNLOAD HANDLER?
	BNE	61$		;NO, UNRECOGNIZED FUNCTION
	INC	EXITFL		;YES, SET EXIT FLAG
	JMP	IOSUCC		;DO I/O COMPLETION
1$:	MOV	R.AT(R1),R4	;GET ATL ADDRESS OF REQUESTOR
	MOV	R4,R.PB(R1)	;PUT IT IN IORQ NODE PARAMETER 1
	MOV	A.TD(R4),R.PB+2(R1);PUT STD ADDRESS INTO PARAMETER 2
	MOV	(R2),R.PB+4(R1)	;PUT PUD ADDRESS IN PARAMETER 3
2$:	JSR	PC,@#..FLSH	;FLUSH QUEUES OF ALL RQ'S THIS TASK, UNIT
;	TST	INPOPN		;FILE OPEN FOR INPUT?
;	BEQ	100$		;NO
;	CLR	INPOPN
;	CLOSE$	#INFDB
;100$:	TST	OUTOPN		;FILE OUTPUT OPEN?
;	BEQ	101$		;NO
;	CLOSE$	#OUTFDB		;YES
;	CLR	OUTOPN
;101$:
	JMP	IOSUCC		;DONE
;

	.SBTTL ATTACH & DETACH, WRITE AND READ FUNCTIONS
;
ATTACH:	JSR	PC,@#..ATUN	;ATTACH UNIT
	BCC	1$
	JMP	ATFAIL		;FAILED
1$:	JMP	IOSUCC		;WORKED
;
DETACH:	JSR	PC,@#..DTUN	;DETACH UNIT
	BCC	1$
	JMP	DTFAIL		;FAILED
1$:	JMP	IOSUCC		;DONE
;
WRITE:	MOV	R.PB+2(R1),R3	;GET NO. OF BYTES TO WRITE
	MOV	R.PB(R1),R2	;GET VIRTUAL BUFFER ADDRESS
	MOV	#WRT,R5		;WRITE (TRANSFER DIRECTION)
	JSR	PC,@#..VXFR	;VERIFY TRANSFER
	BCC	55$
	JMP	ILLMRQ		;SORRY, BAD BUFFER
55$:
;
	.MCALL	QIOW$S
	TST	R3		;ANYTHING TO TRANSFER?
	BLE	100$		;NO, SKIP IT...
COLUN=2	;LUN FOR OUTPUT
COEFN=22 ;EF FOR OUTPUT
	MOV	R5,-(SP)	;SAVE R5 A MOMENT
	SUB	#4,SP		;I/O STATUS ON STACK
	MOV	SP,R5		;R5 POINTS TO STATUS AREA
	MOV	R0,-(SP)
	MOV	R1,-(SP)
	MOV	R2,-(SP)
	MOV	R3,-(SP)
	MOV	R4,-(SP)
	SUB	#130,SP		;SAVE DATA CELL ON STACK
	CMP	R3,#124		;CHECK # BYTES TO EMIT
	BLO	102$		;IF OK, LEAVE ALONE
	MOV	#124,R3		;ELSE CLAMP # TO WRITE TO 74 OCTAL
102$:	MOV	SP,R4		;PUT DATA ON STACK
	MOV	R4,-(SP)
	MOV	R3,-(SP)
	MOV	R5,-(SP)
	JSR	PC,@#..BLXI	;TRANSFER DATA TO TASK SPACE
	BCC	106$		;IF OK, GO ON
	ADD	#6,SP		;"RESTORE" R5,R3,R4
	BR	101$		;THEN CLEAN UP, BUG OUT
106$:	MOV	(SP)+,R5	;GET BACK CALL R5,4,3
	MOV	(SP)+,R3
	MOV	(SP)+,R4
;THUS, IF ..BLXI HAS ERROR, DO NO QIO.
	.IF	NDF,XSWTST	;
;	BIT	#40000,@#177570	;SWITCH 14 UP?
	GSSW$S			;GET SENSE SWITCHES (REAL OR FAKED UP)
;	ONLY LOOK AT SWITCHES IF ASSEMBLY CONDITIONAL IS SET UP
	BIT	#40000,@#$DSW	;TEST BIT 14
	BEQ	141$		;NO, SKIP THE QIO
	.ENDC
	QIOW$S	#IO.WVB,#COLUN,#COEFN,,R5,,<R4,R3,#40>
;	IGNORE ANY ERRORS
;
;	HERE MAY ADD I/O TO OUTPUT TO ANY OPEN FILE ON OUTFDB AS FOLLOWS:
141$:
	.MCALL	PUT$
	TST	OUTOPN		;IF ANY OUTPUT FILE THERE NOW
	BEQ	101$		;FALL THRU BUT SKIP PUT IF NO FILE
	PUT$	#OUTFDB,R4,R3	;WRITE THE DATA OUT
;
101$:	ADD	#130,SP
	MOV	R3,2(SP)	;KEEP R3 AS COUNT OF DATA BYTES
	MOV	(SP)+,R4
	MOV	(SP)+,R3
	MOV	(SP)+,R2
	MOV	(SP)+,R1
	MOV	(SP)+,R0
	ADD	#4,SP
	MOV	(SP)+,R5	;RESTORE R5
100$:
	MOV	R3,R4		;NO. OF BYTES "WRITTEN"
	MOV	#IS.SUC,R3	;SUCCESS COMPLETION CODE
	BR	IOFIN		;DONE
;
READ:	MOV	R.PB+2(R1),R3	;GET NO. OF BYTES TO READ
	MOV	R.PB(R1),R2	;GET VIRTUAL BUFFER ADDRESS	
	CLR	R5		;READ (TRANSFER DIRECTION)
	JSR	PC,@#..VXFR	;VERIFY TRANSFER
	BCS	ILLMRQ		;BUFFER IS ILLEGAL
	TST	INPOPN		;NOW IS ANY INPUT FILE THERE?
	BEQ	100$		;NO, BRANCH TO ERROR RETURN
;HERE GET DATA IN FROM FILE AND COPY IT TO USER BUFFER
	.MCALL	GET$
	MOV	R0,-(SP)
	MOV	R1,-(SP)	;INSULATE REGS FROM THIS STUFF
	MOV	R2,-(SP)
	MOV	R3,-(SP)
	MOV	R4,-(SP)
	MOV	R5,-(SP)
	SUB	#130,SP		;ALLOCATE A BUFFER ON STACK
	MOV	SP,R4		;R4 NOW POINTS TO BUFFER
	CMP	R3,#124		;BYTE COUNT SMALL ENOUGH TO USE?
	BLO	103$		;YES
	MOV	#124,R3		;NO,CLAMP IT
103$:
	MOV	R0,-(SP)
	GET$	#INFDB,R4,R3
	MOV	(SP)+,R0	;SAVE R0 VALUE
	MOV	INFDB+F.NRBD,R3	;SIZE OF RECORD ACTUALLY READ (BYTES)
	CALL	@#..BLXO	;COPY TO USER SPACE
	BCC	105$		;IF ALL WELL NO SWEAT
	MOVB	#-1,INFDB+F.ERR	; IF ERROR FLAG BAD
105$:
	ADD	R3,R4		;NO. BYTES READ+START=ADDR OF LAST
	DEC	R4		;(ADJUST BY 1 FOR NO. BYTES TO INDEX)
CRTRM=15*400	;C.R. TERMINATOR IN HIGH BYTE
AMTRM=33*400	;ALTMODE TERMINATOR IN HIGH BYTE
	MOV	#CRTRM,R0	;SET PATTERN FOR RETURN R3
	CMPB	@R4,#33		;BUT SEE IF LAST CHAR WAS ESC
	BNE	120$		;IF NOT,LEAVE R0 ALONE
	MOVB	#AMTRM,R0
120$:
	ADD	#130,SP		;RESTORE STACK
	MOV	R3,2(SP)	;"RESTORE" COUNT OF BYTES TO R4
	MOV	R0,4(SP)	;"RESTORE" TERMINATOR CHARACTER TO R3
	MOV	(SP)+,R5
	MOV	(SP)+,R4
	MOV	(SP)+,R3
	MOV	(SP)+,R2	; GET BACK REGISTERS
	MOV	(SP)+,R1
	MOV	(SP)+,R0
	BIS	#IS.SUC,R3	;OK PROBABLY (LEAVE TERMINATOR FLAG SET UP)
	TSTB	INFDB+F.ERR	;BUT WAS THERE ANY ERROR?
	BGE	IOFIN		;NO, ALL OK
	CLR	INPOPN		;YES, ERROR SO CLOSE FILE
	CLOSE$	#INFDB		;AFTER MARKING IT CLOSED.
100$:	MOV	#IE.EOF,R3	;SET END-OF-FILE STATUS
101$:	JMP	IOVER		;DONE
;

	.SBTTL ERROR CODES AND I/O COMPLETION
;
UNRFN:	MOV	#IE.IFC,R3	;ILLEGAL FUNCTION CODE
	BR	IOVER
;
ILLMRQ:	MOV	#IE.SPC,R3	;INVALID BUFFER SPECIFICATION
	BR	IOVER
;
DTFAIL:	MOV	#IE.DNA,R3	;DEVICE NOT ATTACHED
	BR	IOVER
;
ATFAIL:	MOV	#IE.DAA,R3	;DEVICE ALREADY ATTACHED
	BR	IOVER
;
NOPRIV:	MOV	#IE.PRI,R3	;PRIVILEDGE VIOLATION
	BR	IOVER
;
IOSUCC:	MOV	#IS.SUC,R3	;I/O FUNCTION SUCCEEDED
IOVER:	CLR	R4		;ZERO BYTES TRANSFERED
IOFIN:	MOV	R.FC(R1),R0	;GET I/O FUCNTION CODE
	TST	R3
	BPL	1$		;IF R3 IS POSITIVE LEAVE IT ALONE
	BIC	#177400,R3	;MASK COMPLETION CODE TO 8 BITS
1$:	CLR	R2		;ADJUSTMENT TO UNITY
	JSR	PC,@#..IODN	;DO I/O COMPLETION PROCESSING
	BIC	#^C<RF.XR>,R0	;ELIMINATE ALL BUT EXPRESS BIT
	CLR	NRNA(R0)	;CLEAR PROPER RNA WORD TO ALLOW DQ-ING
	JMP	CHECK		;LOOK FOR MORE THINGS TO DO
	.SBTTL	FILE OPEN PROCESSING CODE
;FILE OPEN INPUT OR OUTPUT (FUNCTIONS 5 AND 7)
FILOPN:
	MOV	R0,-(SP)	;PRESERVE REGS ACROSS GARBAGE HERE
	MOV	R1,-(SP)
	MOV	R2,-(SP)
	MOV	R3,-(SP)
	MOV	R4,-(SP)
	MOV	R5,-(SP)
	MOVB	R.FC+1(R1),R3	;FUNCTION CODE (4=INPUT,6=OUTPUT)
	SUB	#5,R3		;SEE IF INPUT BY ADJUSTMENT
	CMP	R3,#3		;SEE IF LEGAL (0 OR 2)
	BLO	70$
	JMP	UNRFNJ		;NO, UNRECOGNIZED FUNCTION
;FIND FILENAME IN USER BUFFER POINTED AT BY USER PARAMETER IN QIO
; (2ND PARAMETER=LENGTH,1ST=BUFFER ADDR)
;	THEN PREPARE TO OPEN IT FOR READ (WITH SHARE) OR WRITE
;	FIRST BE SURE USER HAS LEGAL DATA AREA (I.E. WE CAN READ IT)
70$:	MOV	R3,R4		;NEED R3 FOR ..VACC
	MOV	R.PB+2(R1),R3	;NO. BYTES
	MOV	R.PB(R1),R2	;BUFFER ADDR
	MOV	#WRT,R5		;WRITE DIRECTION IS OK
	JSR	PC,@#..VXFR	;TEST DATA OK
	BCC	101$
111$:	JMP	ILMRQJ		;BAD TRANSFER, IGNORE IT.
101$:
;NOW CAN SEE ABOUT OPENING THE FILE
	MOV	R4,R5
	SUB	#130,SP		;CREATE BUFFER FOR DATA
	MOV	SP,R4		;POINT R4 AT IT
	CMP	R3,#124		;BE SURE STRING LENGTH OK
	BLO	102$
	MOV	#124,R3
102$:	JSR	PC,@#..BLXI	;COPY THE FILE SPECS TO OUR BUFFER
;NOW R4 POINTS TO FILE SPECS AND R3 HAS LENGTH
	BCC	120$
	ADD	#132,SP		;FIX UP STACK
	JMP	ILMRQJ		;AND SAY ERROR
120$:
	MOV	R0,-(SP)
	CMPB	R.FC+1(R1),#5	;EQ IF INPUT, ELSE OUTPUT
	BNE	103$
	MOV	#FO.RD,R5	;SET R5 UP FOR INPUT OPEN
	MOV	#INFDB,R0	;WITH CORRECT FDB
	TST	INPOPN		;INPUT ALREADY OPEN?
	BEQ	112$		;NO, JUST DO THIS ONE
	.MCALL	CLOSE$
	CLOSE$	R0		;YES,CLOSE THIS FDB
	CLR	INPOPN		;AND FLAG AS SUCH
112$:
	BR	104$
103$:	MOV	#FO.WRT,R5	;SET UP R5 FOR WRITING
	MOV	#OUTFDB,R0	;WITH CORRECT FDB
	TST	OUTOPN		;AN OUTPUT FILE ALREADY THERE?
	BEQ	104$		;NO, NORMAL
	CLOSE$	R0		;YES,CLOSE OLD ONE
	CLR	OUTOPN		;AND FLAG CLOSED
104$:
	.MCALL	CSI$,CSI$1,CSI$2
	MOV	R0,-(SP)
	MOV	R1,-(SP)
	MOV	R2,-(SP)
	MOV	R3,-(SP)
	MOV	R4,-(SP)
	MOV	R5,-(SP)
	CSI$1	#CSIBLK,R4,R3	;SYNTAX ANALYZE USER'S STRING
	BCC	105$
106$:	MOV	16(SP),R0	;ERROR. RESTORE R0,
	ADD	#146,SP		;SP,
	JMP	ILMRQJ		;AND SAY IT FAILED
105$:				;ALL OK SO FAR
	CSI$2	#CSIBLK,OUTPUT	;PARSE AN OUTPUT FILE SPEC
	BCS	106$		;TEST FOR ERROR
;CSIBLK+C.DSDS IS NOW FILE DESCRIPTOR BLOCK
	MOV	(SP)+,R5
	MOV	(SP)+,R4
	MOV	(SP)+,R3
	MOV	(SP)+,R2
	MOV	(SP)+,R1
	MOV	(SP)+,R0
;R0 NOW IS FDB AGAIN.
	MOV	R0,R1		;FILENAME BLOCK ADDR
	ADD	#F.FNB,R1	;IS IN FDB
	MOV	#CSIBLK+C.DSDS,R2 ; DATASET IS IN CSI BLOCK
	MOV	#DFNB,R3	;DEFAULT FNB
	MOV	R0,-(SP)
	JSR	PC,.PARSE	;PARSE THE THING
	MOV	(SP)+,R0
	CLR	R4		;INITIALIZE LUN
	CMP	R0,#INFDB	;SEE NOW IF INPUT OR OUTPUT OPEN
	BEQ	107$		;INPUT,BRANCH
	MOV	#1,R4
107$:	ADD	#3,R4		;LUN 3 OR 4
	.MCALL	FDOP$R
	FDOP$R	R0,R4,R2,R3,R5
	OPEN$	R0,R5,R4,R2,R3,,#LCLBFR,#80. ; DUMMY DATA BUF,LOC
	BCC	108$		;IF OK, GO ON
	SUB	#14,SP		;FAKE REG SAVE TO ADJUST STACK
;	MOV	R0,-(SP)	;ELSE ADJUST STACK
	BR	106$
108$:
	CMP	R0,#INFDB
	BNE	109$		;OUTPUT,BRANCH
	INC	INPOPN		;FLAG INPUT FILE THERE NOW
	BR	110$
109$:	INC	OUTOPN		;FLAG FILES OPEN
110$:
	MOV	(SP)+,R0	;SAVE R0 FROM FCS
	ADD	#130,SP		;FIX UP STACK
	MOV	(SP)+,R5	;GET BACK REGS SAVED AT START HERE
	MOV	(SP)+,R4
	MOV	(SP)+,R3
	MOV	(SP)+,R2
	MOV	(SP)+,R1
	MOV	(SP)+,R0
FXXX:	MOV	#IS.SUC,R3
	JMP	IOVER		;ALL LOOKS OK SO TELL CALLER SO.
ILMRQJ:	MOV	(SP)+,R5
	MOV	(SP)+,R4
	MOV	(SP)+,R3
	MOV	(SP)+,R2
	MOV	(SP)+,R1
	MOV	(SP)+,R0
	JMP	ILLMRQ		;RESTORE REGS, THEN COMPLAIN
UNRFNJ:	MOV	(SP)+,R5
	MOV	(SP)+,R4
	MOV	(SP)+,R3
	MOV	(SP)+,R2
	MOV	(SP)+,R1
	MOV	(SP)+,R0
	JMP	UNRFN		;GET BACK REGS, THEN SCRAM
LCLBFR:	.BLKW	60.
	.SBTTL	FILE CLOSE PROCESSING CODE
;FILE CLOSE (INPUT OR OUTPUT) FUNCTIONS 6 AND 8
FILCLS:	CMPB	R.FC+1(R1),#6	;INPUT CLOSE?
	BEQ	100$		;INPUT,BRANCH (OTHERWISE MUST BE OUTPUT)
	TST	OUTOPN		;ANY OUTPUT FILE THERE?
	BEQ	FXXX		;NO, GO NOW
	CLR	OUTOPN
	MOV	R0,-(SP)
	CLOSE$	#OUTFDB
	MOV	(SP)+,R0
	BR	FXXX		;CLOSE OUTPUT AND FLAG IT
100$:	TST	INPOPN		;INPUT ACTIVE?
	BEQ	FXXX		;NO, SCRAM
	MOV	R0,-(SP)	;HAVE TO SAVE R0 FROM FCS BASH
	CLOSE$	#INFDB
	MOV	(SP)+,R0
	BR	FXXX		;GO SAY IT WORKED.
	.SBTTL	CSI AND FILENAME BLOCK AREA
	.MCALL	CSI$,CSI$1,CSI$2,NMBLK$
	.EVEN
	CSI$
CSIBLK:	.BLKB	C.SIZE
	.EVEN
DFNB:	NMBLK$	TMPTMP,TMP,0,SY,0	;DEFAULT DEVICE IS SY:TMPTMP.TMP
;

	.SBTTL UNIT ID TABLE (UIT) AND FUNCTION DISPATCH TABLE (FDT)
;
GBUIT:	.WORD	GBFDT		;POINTER TO FUNCTION DISPATCH TABLE
	.BYTE	1,0		;ONE UNIT HANDLER
	.WORD	0,0,0		;RESERVED
PUDPTR:	.WORD	GBUNIT		;UNIT NO. (BECOMES POINTER TO PUD)
NRNA:	.WORD	0		;NORMAL REQUEST NODE ADDRESS
	.WORD	0		;EXPRESS REQUEST NODE ADDRESS
;
	.MACRO	FD L,H,ADDR	;FDT TABLE ENTRIES
	.BYTE	L,H
	.WORD	ADDR
	.ENDM
;
GBFDT	=	.-4	
FUN0:	FD	000,000,SPECFN	;SPECIAL FUNCTIONS (0)
FUNSZ	=	.-FUN0		;FDT ENTRY LENGTH
	FD	010,162,WRITE	;WRITE LOGICAL (1)
	FD	010,161,READ	;READ LOGICAL (2)
	FD	020,160,ATTACH	;ATTACH (3)
	FD	020,160,DETACH	;DETACH (4)
	FD	010,043,FILOPN	;CONTROL (5) (FILE OPEN)(INPUT)
	FD	010,043,FILCLS	;(6) (FILE CLOSE)(INPUT)
	FD	010,043,FILOPN	;(7)(FILE OPEN (OUTPUT))
	FD	010,043,FILCLS	;(10) (FILE CLOSE (OUTPUT))
	.IF	DF,NORPR	;NEXT FUNCTION IS READ W/PROMPT.
	FD	140,160,UNRFN	;FIND FILE (11)
	.IFF
	FD	010,161,READ	;READ W/PROMPT=READ, FOR US
	.ENDC
	FD	140,160,UNRFN	;(12)
	FD	140,160,UNRFN	;REMOVE FILE (13)
	FD	140,160,UNRFN	;ENTER FILE (14)
	FD	140,161,IOSUCC	;ACCESS FOR READ (15)
	FD	140,163,IOSUCC	;ACCESSS FOR WRITE (16)
	FD	140,167,IOSUCC	;ACCESS FOR EXTEND (17)
	FD	100,160,IOSUCC	;DEACCESS (20)
	FD	100,161,READ	;READ VIRTUAL (21)
	FD	100,162,WRITE 	;WRITE VIRTUAL (22)
NFUNS	=	<.-FUN0>/FUNSZ	;NUMBER OF FUNCTIONS
;
IDLDPB:	WTLO$	0,NREFM1!XREFM1	;WAIT FOR MULTIPLE FLAGS DPB
;
EXITFL:	.WORD	0		;HANDLER EXIT FLAG
;
	.END	GBSTRT