.TITLE XX....
.SBTTL DUMMY HANDLER TO LIST IO NODES
.IDENT "V001"
;
.LIST	ME
;
;	AUTHOR;  F. BORGER
		; DEPT OF MEDICAL PHYSICS
		; MICHAEL REESE HOSPITAL
		;CHICAGO ILL 60616
;
;A HANDLER TO DIAGNOSE SYSTEM OPERATION, FOR ANY IO REQUEST, ALL HE DOES
;IS LIST THE IO NODE AT TI:
;
;TYPICAL TASK BUILD COMMAND FILE :
;
;	XX/PR/-FP/-FX/-AB/-CP,XX/-SP=XX,LB0:[1,1]EXEC.STB
;	/
;	LIBR=HNDLIB:RO:2
;	TASK=XX....
;	PAR=GEN
;	STACK=64
;	UIC=[1,1]
;	PRI=230
;	/
;
;
.SBTTL DEFINITIONS
;
;
;SYSTEM EVENT FLAGS
;
EVFNOR=001	;NORMAL REQUEST
EVFEXR=002	;EXPRESS REQUEST
EVFIOD=004	;I/O TRANSFER FINISHED
;
;MISC DEFINITIONS
;
PSW=177776	;ADDR OF STAT WORD
MAXFUN=27.	;MAX IO FUNCTION CODE
;
	.MCALL	DIR$,QIOW$


.SBTTL GENERAL MACROS
;
;
;
;
	.MACRO	NORDIS	A,B,C ;GENERAL NORMAL DISPATCH TABLE ENTRY
	.BYTE	A,B	;VOLUME CHAR BYTE, CONTROL VARIABLE BYTE
	.WORD	C	;THE ROUTINE ADDRESS TO JUMP TO
	.ENDM
;
;
	.MACRO	ACPDIS	A,B,C,D ;GENERAL ACP DISPATCH TABLE ENTRY
			;MAKE SURE FLAG FOR SEND/REQ IS ON
	.BYTE	A,B!200	;VOLUME CHAR BYTE, CONTROL VARIABLE BYTE
	.BYTE	C,D	;SUFFIX BYTE, SUB FUNCTION CODE BYTE
	.ENDM
;
;
	.MACRO	ILFN		;GENERAL ILLEGAL FUNCTION MACRO
	NORDIS	0,0,ILLFUN
	.ENDM
;
;
	.MACRO	DUMFUN		;GENERAL DUMMY FUNCTION MACRO
	NORDIS	0,0,DUMMY
	.ENDM
;
;
	.MACRO	ERRMAC,ERROR	;GENERAL ERROR RETURN MACRO
	MOV	#ERROR,R3	;ERROR CODE TO R3
	BR	OVER		;AND JOIN COMMON EXIT SEQUENCE
	.ENDM
;
;
	.MCALL	CALL
	.MCALL	RETURN

.SBTTL INITIALIZATION SECTION
;
;
;ROUTINE MUST DO THE FOLLOWING
;A	DECLARE ITSELF RESIDENT
;B	CONNECT INTERRUPTS (IF NECESSARY)
;C	SET UP POWER UP AST
;
;
INIT:
	MOV	#UIT,R0		;POINT R0 TO UNIT IDENTIFICATION TABLE
				;BEFORE CALLING, THE UIT MUST CONTAIN
				;WORD 0	THE DISPATCH TABLE ADDRESS
				;WORD 1,BYTE 0	 NUMBER OF UNIT ENTRIES
				;EACH UNIT ENTRY MUST HAVE IN WORD 0 :
				;A/ THE UNIT NUMBER FOR SINGLE UNIT HANDLERS
				;B/ UNIT VALIDITY MASK FOR MULTI-UNIT HANDLERS
				;WORD 1,BYTE 1	ACTUAL # OF UNITS IS RETURNED BY ..DSUT
	MOV	#"XX,R2		;DEVICE NAME TO R2
	MOV	#UF.RH,R3	;FLAG BYTE FOR PUD FLAG WORD=RESIDENT
	CALL	@#..DSUT	;REGISTERS SET SO CALL DECLARE
				;ON RETURN, R1 CONTAINS ACTUAL # OF UNITS FOUND
	BCC	111$		;BRANCH IF SUCCESSFUL
	JMP	EXITDF		;EXIT DUE TO DECLARE FAILURE
111$:	JMP	GO		;DO WAIT LOOP

.SBTTL DIRECTIVE PARAMETER BLOCKS
	.MCALL	EXIT$,SPRA$,ASTX$,WTLO$
;
;
SCRAM:		;DO SYSTEM EXIT
	EXIT$
;
;
WAITME:		;WAIT FOR NORMAL OR EXPRESS EVENT
	WTLO$	0,EVFNOR!EVFEXR

.SBTTL WAKE UP CODE
;
;
;COMMENT SOMETHING HAPPENED TO WAKE ME UP, SOMEBODY WANTS TO
;DO SOMETHING
;
;
GO:	MOV	@#.CRTSK,R3	;HEY ACTION AT LAST
	MOV	A.EF(R3),R5	;GET SIGNIFANT EVENT FLAGS
	MOV	#UIT,R0		;POINT R0 -> UIT FOR LATER DQ'S
	BIT	#EVFEXR,R5	;ANY EXPRESS REQUESTS ?
	BEQ	NOEREQ		;NO SO DON'T TRY TO DEQUE ONE
	CALL	@#..DQRE	;YES, TRY TO DEQUE EXPRESS REQUEST
	BCC	PROREQ		;IF DEQUE SUCCEDDED PROCESS IT
NOEREQ:	BIT	#EVFNOR,R5	;NO EXP REQ (OR IT FAILED)  ARE THERE
	BEQ	IDLE		;ANY NORMAL REQ'S IF NOT ZZZZZZZZZZZ
	CALL	@#..DQRN	;NORMAL REQ TRY TO DEQ IT
	BCC	PROREQ		;DEQUE SUCCESSFUL GO PROCESS IT
IDLE:	;NOTHING TO DO, OR NOTHING SUCCESSFULLY DEQUED
	TST	EXFLAG		;PENDING EXIT REQUEST ?
	BEQ	IDLE1		;IF NOT SKIP NEXT SECTION
	TST	UNITEN+2	;CHECK IS IT A NORMAL EXIT
	BNE	IDLE1		;NORMAL EXIT  WAIT FOR ANY I/O TO FINISH
	JMP	EXITDF		;EXPRESS REQ GO DIRECTLY TO KILL
IDLE1:	MOV	#WAITME,-(SP)	;HO-HUM NOTHING TO DO
	EMT	377		;WAKE ME WHEN THERES SOMETHING TO DO
	BR	GO		;HEY I WOKE UP
;
;

.SBTTL PROCESS I/O REQUEST
;
;SHOULD COME HERE TO PROCESS SOME REQUEST THAT
;WAS DEQUED CURRENT STATUS IS
;R0=	UIT (UNIT IDENTIFICATION TABLE) ADDRESS
;R1=	IO REQUEST NODE ADDRESS
;R2=	UNITEN, UNIT ENTRY ADDRESS 
;	(IF HAVE MULTIPLE UNIT ENTRIES, ONE FOR LAST IO REQ DEQUED)
;	(R2) = PUD ADDRESS FOR REQUEST
;	2(R2)= ADDRESS OF NORMAL IO REQUEST NODE DEQUED
;	4(R2)= ADDRESS OF EXPRESS IO REQUEST NODE DEQUED
;R5=	ORIGINAL STATE OF EVENT FLAGS
;
;UIT+4=	(BYTE) UNIT # OF LAST NORMAL REQUEST DEQUED BY ..DQRN
;UIT+5=	(BYTE) UNIT # OF LAST EXPRESS REQUEST DEQUED BY ..DQRE
;
PROREQ:	MOVB	R.FC+1(R1),R3	;DO CURSORY CHECK OF FUNCTION CODE
	BLT	ILLFUN		;!!!!CAN'T HAVE NEGATIVE FUNCTION CODE
	CMP	#MAXFUN,R3	;ALSO COULD BE OVER MAXIMUM VALUE
	BLE	ILLFUN		;ALSO A BADDIE
	CALL	@#..VACC	;SEE IF REQUESTING PROGRAM HAS
	BCS	ILLPRV		;OH-OH PRIVILEDGE VIOLATION
	JMP	@#..DISP	;PASSES THE TESTS GO DISPATCH FUNCTION

.SBTTL ERROR & NORMAL RETURNS
;
ILLFUN:	ERRMAC	IE.IFC		;ILLEGAL FUNCTION REQUESTED
;
ILLBUF:	CLR	TRAWDC		;CLEAR SOFTWARE STATUS WORD
	ERRMAC	IE.SPC		;ILLEGAL BUFFER
;
ILLATT:	ERRMAC	IE.DAA		;ILLEGAL ATTACH (ALREADY ATTACHED)
;
ILLDET:	ERRMAC	IE.DNA		;ILLEGAL DETACH (NEVER ATTACHED)
;
ILLPAR:	ERRMAC	IE.BAD		;ILLEGAL PARAMETER
;
ILLPRV:	ERRMAC	IE.PRI		;PRIVILEGE VIOLATION
;
OVEROK:	MOV	#IS.SUC,R3	;SUCCESSFUL OPERATION
				;AND FALL INTO OVER CODE

;
.SBTTL IODONE (OVER ) CODE
;ON ENTERING OVER CODE, MUST HAVE:
;R1 = REQUEST NODE ADDRESS
;R2 = POINTER TO UNIT ENTRY WORD CONTAINING PUD POINTER
;R3 = STATUS TO RETURN IN IO STATUS BLOCK WORD 1
;
OVER:	MOV	R.FC(R1),-(SP)	;SAVE FUNCTION CODE
	MOV	R2,-(SP)	;SAVE UNIT ENTRY ADDRESS
	MOV	R4,-(SP)
	CLR	R2		;CLEAR DECREMENT
				;R3 ALREADY HAS STATUS CODE
	MOV	TRAWDC,R4	;NUMBER OF BYTES XFERRED TO R4
	CLR	TRAWDC		;CLEAR TRANSFER WORD COUNT
	CALL	@#..IODN	;CALL IO DONE SUBROUTINE
	MOV	(SP)+,R4
	MOV	(SP)+,R2	;RESTORE UNIT ENTRY ADDRESS
	MOV	(SP)+,R3	;RESTORE FUNCTION CODE
	BIC	#177775,R3	;ISOLATE EXPRESS BIT
	ADD	R3,R2		;ADVANCE R2 IF AN EXPRESS REQ
	CLR	2(R2)		;CLEAR UNIT ENTRY POINTER TO LET MORE DEQUE
	JMP	GO		;& RETURN HERE WE GO ROUND AGAIN
;
; ON EXIT WORD # 1 OF IO-STATUS BLOCK CONTAINS "ERROR" CODE
;CURRENT CODES RETURNED ARE:
;
;IE.IFC=-2		;ILLEGAL I/O FUNCTION REQUESTED
;IE.SPC=-6		;WORD COUNT OR POINTER BAD
;IE.DAA=-8.		;CAN'T ATTACH, ALREADY DONE
;IE.DNA=-7		;ILLEGAL DETACH, NEVER ATTACHED
;IE.BAD=-1		;ILLEGAL PARAMETER
;IE.PRI=-16.		;PRIVILEGE VIOLATION
;IS.SUC=1		;SUCCESS SOMEHOW WE DID IT RIGHT
;
;WORD #2 CONTAINS # OF CHARACTERS OR BYTES  TRANSFERRED)

.SBTTL EXIT CODE
;
EXITDF:		;JUMP TO HERE IF ..DSUT FAILED !!!
	MOV	#SCRAM,-(SP)	;GO EXIT
	EMT	377
;

.SBTTL	SAVE & RESTORE R0 THRU R5
;
;MOST OF THE HANDLERS EXPECTS STANDARD USAGE OF THE REGISTERS
;
;IT'S A GOOD IDEA TO SAVE REGISTERS ON ENTERING A FUNCTION, AND
;RESTORING THEM WHEN YOU'R DONE
;
;
SAVREG:	MOV	R0,-(SP)
	MOV	R1,-(SP)
	MOV	R2,-(SP)
	MOV	R3,-(SP)
	MOV	R4,-(SP)
	MOV	R5,-(SP)	;AT THIS POINT, (SP) THRU 12(SP) HAVE SAVED
				;REGISTERS, 14(SP) HAS RETURN ADDRESS
	MOV	14(SP),-(SP)
	RTS	PC		;RETURN
				;AFTER RETURN STACK HAS 6 REGISTERS AND ONE
				;RETURN ADDRESS ON IT
;
;IF YOU CALLED SAVREG:, YOU MUST CALL RESREG BEFORE ISSUING ANY RTSPC !!!
;
RESREG:				;AT THIS POINT (SP) IS RETURN ADDRESS
				;2(SP) THRU 14 (SP) HAVE REGISTERS
				;16(SP) HAS RETURN ADDRESS FROM SAVREG CALL
	MOV	(SP)+,14(SP)	;OVERWRITE RETURN ADDRESS
	MOV	(SP)+,R5
	MOV	(SP)+,R4
	MOV	(SP)+,R3
	MOV	(SP)+,R2
	MOV	(SP)+,R1
	MOV	(SP)+,R0
	RTS	PC		;RETURN TO CALLER

.SBTTL ATTACH	DETACH	DUMMY FUNCTIONS
;
;ON ENTRY, AS A RESULT OF DISPATCHING THE FUNCTION
;
;R0 = UIT (UNIT IDENTIFICATION TABLE) ADDRESS
;R1 = IO REQUEST NODE ADDRESS
;R2 = ADDRESS OF PUD POINTER WORD IN UNITEN
;R3 = IO FUNCTION CODE
;R5 = STATE OF TASK EVENT FLAGS AT WAKE UP
;
;ITS A GOOD IDEA TO KEEP THESE AS OTHER ROUTINES USUALLY EXPECT THEM
;
;
;
ATTACH:		;HERE TO ATTACH TO A UNIT
	CALL	@#..ATUN	;CALL ATTACH SUBROUTINE
	BCC	11$		;BRANCH IF OK
	JMP	ILLATT		;ELSE REPORT ILLEGAL ATTACH
11$:	JMP	DUMMY		;NOW LIST THE IO NODE
;
;
DETACH:		;DETACH FROM A UNIT 
	CALL	@#..DTUN	;CALL DETACH SUB
	BCC	DUMMY		;BRANCH IF OK
	JMP	ILLDET		;REPORT BAD DETACH
;
;
DUMMY:		;LIST THE IO NODE AT TI:

	CALL	SAVREG		;SAVE USED REG'S
	MOV	#NAMES,R4	;POINT AT TAG LINES
	MOV	#R.SIZ,R5	;SIZE OF AN IO REQUEST NODE
	MOV	R1,R3		;NODE ADDRESS TO R3 ALSO
	DIR$	#DIVDPB		;DO DIVIDING LINE
	ASR	R5		;CONVERT TO WORDS
LOOP1:	MOV	#LINE,R0	;POINT TO ASCII OUTPUT LINE
	MOV	R3,R1		;ADDRESS OF WORD IN NODE TO R1
	JSR	PC,$CBOMG	;CONVERT NODE ADDRESS TO ASCII
	TST	(R0)+		;BUMP POINTER PAST "  "
	MOV	(R4)+,(R0)+	;FILL IN NAME OF IRQ WORD
	CLR	BYTFLA		;CLEAR BYTE FLAG
	CMP	(R4),#"PR	;PRI & DPB SIZE
	BNE	111$		;NO
	INC	BYTFLA		;YES SET BYTE FLAG
111$:	CMP	(R4),#"LU	;LUN & EV FLAG # ?
	BNE	222$		;NO
	INC	BYTFLA		;YES, SET FLAG
222$:	CMP	(R4),#"PC	;PROGRAMMER & GROUP CODE ?
	BNE	333$		;NO
	INC	BYTFLA		;YES
333$:	MOV	(R4)+,(R0)+
	MOV	(R4)+,(R0)+
	MOV	(R3)+,R1	;CONTENTS OF NODE TO R1
	TST	BYTFLA		;BYTE PRINTOUT ?
	BEQ	99$		;NO
	BIC	#177400,R1	;YES, CLEAR UPPER BYTE
99$:
	JSR	PC,$CBOMG	;CONVERT CONTENTS TO ASCII
	TST	BYTFLA		;ARE THESE BYTE VALUES ?
	BEQ	444$		;NO
	MOVB	#' ,-6(R0)	;MAKE 3 DIGIT OUTPUT
	MOVB	#' ,-5(R0)
	MOVB	#' ,-4(R0)	
	ADD	#2,R0		;BUMP OVER TO 2ND VALUE AREA
	MOV	(R4)+,(R0)+	;FILL IN 2ND R.XX STRING
	MOV	(R4)+,(R0)+
	MOV	(R4)+,(R0)+
	MOV	-2(R3),R1	;GET CONTENTS OF NODE AGAIN
	SWAB	R1		;GET UPPER BYTE
	BIC	#177400,R1	;CLEAR LOWER
	JSR	PC,$CBOMG	;CONVERT IT AGAIN
	MOVB	#' ,-6(R0)
	MOVB	#' ,-5(R0)
	MOVB	#' ,-4(R0)	;MAKE 3 DIGIT PRINTOUT
	MOV	#LINEXL,QIODPB+Q.IOPL+2 ;CHANGE LENGTH OF PRINTOUT
444$:	DIR$	#QIODPB		;WRITE LINE
	MOV	#LINELN,QIODPB+Q.IOPL+2 ;CHANGE BACK TO SHORT LINE
	DEC	R5		;DO R.SIZ LINES
	BLE	777$
	JMP	LOOP1
777$:	CALL	RESREG		;RESTORE REGISTERS
	JMP	OVEROK		;DO SUCCESS STATUS

.SBTTL EXPRESS FUNCTION HANDLERS
;
;
;FUNCTION 12 -------KILL REQUEST
;CLUDGES TO LOOK LIKE I/O RUNDOWN THEN 
;ENTERS I/O RUNDOWN SEQUENCE
;
;FUNCTION 22 -------I/O RUNDOWN
;USES ..FLSH TO CLEAR ALL REQUESTS FROM THE CURRENT USER
;
;FUNCTION 42 -------EXIT (UNLOAD)
;VALIDATES REQUEST THEN SETS
;EXFLAG SO THAT NEXT TIME IN IDLE HANDLER
;DOES EXIT
;
;
EXPFUN:	MOV	R.FC(R1),R3	;GET FUNCTION CODE
	CMP	#IO.KIL,R3	;REQUEST FOR KILL ??
	BEQ	KILLRQ		;PROGRAM COMMITS HARI-KARI
	TST	R.AT(R1)	;OTHERWISE EXEC BETTER BE ASKING FOR EXP
	BNE	EXPILL		;NOT EXEC ---- THAT'S A NO-NO
	CMP	#IO.RDN,R3	;ITS THE EXEC/ I/O RUNDOWN ?
	BEQ	IORNDQ		;YES GO DO IT
	CMP	#IO.UNL,R3	;IF NOT RUNDOWN BETTER BE EXIT
	BEQ	EXITGO		;YES IT'S AN EXIT GO DO IT
EXPILL:	JMP	ILLFUN		;FELL THROUGH UNRECON'ED FUNCTION
;
;
KILLRQ:	MOV	R.AT(R1),R4	;SET UP RNA POINTER
	MOV	R4,R.PB(R1)	;STORE ATL NODE ADDRESS
	MOV	A.TD(R4),R.PB+2(R1)	;STORE STD NODE
	MOV	(R2),R.PB+4(R1)	;STORE PUD START
				;NOW JOIN I/O RUNDOWN
;
;
IORNDQ:	CALL	@#..FLSH	;FLUSH QUEUE OF ALL USER REQUESTS
	JMP	DUMMY		;LIST IO NODE
;
;
EXITGO:	INC	EXFLAG		;SET EXIT FLAG TO INDICATE
	JMP	DUMMY		;LIST IO NODE
;
;

.SBTTL SYSTEM STATUS TABLES
;			NOTE	NOTE	NOTE
;
;	ANY IMPURE (READ/WRITE) DATA STORAGE SHOULD BE PLACED HERE
;	IF ONE WISHES A MULTI-USER HANDLER WITH SEPERATE PURE SECTIONS
;	ALL READ/WRITE DATA STORAGE SHOULD BE HERE.
;	IN ADDITION, THE CODE FOR ADJUSTING THE STACK TO OVERWRITE
;	THE INIT CODE SHOULD BE DELETED.
;
;THE UNIT IDENTIFICATION TABLE (UIT) CONSISTS OF A 5-WORD HEADER AREA,
;FOLLOWED BY ONE OR MORE 3 WORD UNIT ENTRIES
;
;
;
				;THE FOLLOWING WORD WILL NOT CHANGE
UIT:	.WORD	DISPCH		;POINTER TO DISPATCH TABLE
				;THE LOWER BYTE OF THE NEXT WORD SHOULD BE SET
				;TO THE MAXIMUM NUMBER OF UNITS SERVICED BY
				;THE HANDLER (=# OF UNIT ENTRIES TO FOLLOW)
				;AFTER CALLING ..DSUT OR ..DSMU THE UPPER BYTE
				;WILL HAVE THE # OF UNITS ACTUALLY FOUND IN 
				;THE RESULTANT PUD SCAN
	.BYTE	1,0		;NUMBER OF UNITS
				;THE FOLLOWING WORD SHOULD INITIALLY BE 0
				;THE LOWER BYTE WILL BE FILLED WITH THE UNIT
				;NUMBER OF THE LAST NORMAL REQUEST DEQUED
				;THE UPPER BYTE WILL BE FILLED WITH THE UNIT
				;NUMBER OF THE LAST EXPRESS REQUEST DEUED
	.WORD	0
				;THE FOLLOWING WORDS ARE NECESSARY BUT RESERVED
	.WORD	0,0
;
;
;NOW SHOULD FOLLOW ONE OR MORE UNIT ENTRIES. THE NUMBER OF UNIT ENTRIES
;SHOULD CORRESPOND TO THE NUMBER OF UNITS SPECIFIED ABOVE
;
;
				;BEFORE CALLING ..DSUT OR ..DSMU, THIS SHOULD
				;CONTAIN THE UNIT NUMBER (FOR A SINGLE UNIT
				;OR MULTI UNIT HANDLER) OR THE UNIT VALIDITY
				;MASK (FOR A MULTI-USER HANDLER WITH SEPERATE
				;VERSIONS SERVICING SEPERATE UNITS)
				;AFTER CALLING ..DSUT OR ..DSMU, THIS WILL
				;CONTAIN THE ADDRESS OF THE PUD FOUND BY
				;THE PUD SCAN
UNITEN:	.WORD	0
				;THE FOLLOWING WORD WILL CONTAIN THE LAST NORMAL
				;IO REQUEST NODE DEQUED BY ..DQRN
				;HANDLER MUST CLEAR THIS LOCATION TO ENABLE
				;DE-QUEING OF ANOTHER NORMAL IO REQUEST
	.WORD	0
				;THE FOLLOWING WORD WILL CONTAIN THE LAST EXPRESS
				;IO REQUEST NODE DEQUED BY ..DQRE
				;HANDLER MUST CLEAR THIS LOCATION TO ENABLE
				;DE-QUEING OF ANOTHER EXPRESS IO REQUEST
	.WORD	0

.SBTTL DISPATCH TABLE
DISPCH:
;	THE FIRST TWO WORDS OF THE DISPATCH TABLE ARE ONLY USED
;	FOR DIRECTORY TYPE DEVICES THAT NEED AN ACP TO ASSIST THEM.
;	DEPENDING ON THE SUCCESS OR FAILURE OF SEND/REQUESTS TO
;	THE APPROPRIATE ACP, THESE WORDS CONTAIN THE ADDRESS OF
;	THE ROUTINES TO EXECUTE
;
	.WORD	ILLFUN		;ADDRESS TO BRANCH TO IF SEND/REQ FAILS
	.WORD	ILLFUN		;ADDRESS TO BRANCH TO IF SEND/REQ SUCCEEDS
;
;
;NOW THE FUNCTION CODE ENTRIES THEMSELVES (2-WORDS)
;	FOR EACH ENTRY, THE LOWER BYTE OF THE FIRST WORD CONTAINS A
;	VOLUME CHARACTERISTIC MASK
	V.MOU=200	;VOLUME MUST BE MOUNTED TO PERFORM THIS FUNCTION
	V.F11=100	;VOLUME MUST BE A FILES-11 VOLUME
	V.UNL=40	;VOLUME MUST NOT HAVE AN UNLOAD PENDING
	V.ATT=20	;VOLUME MUST PERMIT ATTACH/DETACH FUNCTIONS
	V.DCF=10	;DEVICE CONTROL FNS MUST BE PERMITTED
			;BITS 2-0 ARE RESERVED
;
;
;	THE UPPER BYTE OF THE FIRST WORD CONTAINS A "CONTROL VARIABLE"
			;THIS FUNCTION SHOULD BE ROUTED TO THE ACP TASK &
	CV.ACP=200	;WORD U.DACP OF PUD CONTAINS ACP NAME
	CV.SUB=100	;5 HIGH-ORDER BITS OF SUBFUNCTION CODE MUST = 0
	CV.EXP=40	;THE EXPRESS BIT (BIT 1) OF THE SUBFUNCTION CODE MUST = 0
			;BIT 20 IS RESERVED
	CV.DEL=10	;USER MUST HAVE FILE DELETE PRIVELEGES
	CV.EXT=4	;USER MUST HAVE FILE EXTEND PRIVELEGES
	CV.WRI=2	;USER MUST HAVE FILE WRITE PRIVELEGES
	CV.REA=1	;USER MUST HAVE FILE READ PRIVELEGES
;
;
;THE SECOND WORD OF THE FUNCTION ENTRY CONTAINS THE ADDRESS OF THE
;CODE TO DISPATCH TO, (IF THE HANDLER ITSELF MUST PERFORM THE FUNCTION)
;
;
;THE SECOND WORD OF THE FUNCTION ENTRY CONTAINS A SUFFIX BYTE AND A SUB-
;FUNCTION CODE BYTE, (IF A SEND/REQUEST SHOULD BE PERFORNED)
;

; THE DISPATCH TABLE ITSELF
;
	NORDIS	0,0,EXPFUN	;0 = EXPRESS FUNCTIONS
	DUMFUN			;1
	DUMFUN			;2
	NORDIS	V.ATT,CV.SUB!CV.EXP,ATTACH ;3 = ATTACH
	NORDIS	V.ATT,CV.SUB!CV.EXP,DETACH ;4 = DETACH
	DUMFUN			;5
	DUMFUN			;6
	DUMFUN			;7
	DUMFUN			;10 = UNDEFINED
	DUMFUN			;11 = FIND FILE
	DUMFUN			;12 = ILLEGAL 
	DUMFUN			;13 = REMOVE FILE
	DUMFUN			;14 = ENTER FILE
	DUMFUN			;15 = ACCESS FOR READ
	DUMFUN			;16 = ACCESS FOR READ/WRITE
	DUMFUN			;17 = ACCESS FOR READ/WRITE/EXTEND
	DUMFUN			;20 = DEACCESS
	DUMFUN			;21
	DUMFUN			;22
	DUMFUN			;23
	DUMFUN			;24
	DUMFUN			;25
	DUMFUN			;26
	DUMFUN			;27
				;ENOUGH FUNCTIONS ALREADY !!!!!!

.SBTTL GENERAL IMPURE STORAGE AREA
TRAWDC:	.WORD	0		;NUMBER OF WORDS/BYTES IN IO REQUEST
EXFLAG:	.WORD	0		;EXIT PENDING FLAG
OLDPAR:	.WORD	0		;SAVE PAR AFTER ..SPD3 CALL
OLDPDR:	.WORD	0		;SAVE PDR AFTER ..SPD3 CALL
;
.SBTTL	DATA AREAS
BYTFLA:	.WORD	0		;FLAG FOR BYTE VAR
QIODPB:	QIOW$	IO.WVB,5,5,,,,<LINE,LINELN,40>
LINE:	.ASCII	/000000  S.XX  000000/
	LINELN=.-LINE
	.ASCII	/  /
LINEX:	.ASCII	/S.XX  000000/
	LINEXL=.-LINE
	.EVEN
DIVDPB:	QIOW$	IO.WVB,5,5,,,,<DIV,DIVLN,40>
DIV:	.ASCII	/----------------------/
	DIVLN=.-DIV
	.EVEN
NAMES:	.ASCII	/            R.TD  R.AT  R.PR  R.DP  R.LU  R.FN  R.FC  R.SB  /
	.ASCII	/R.AE  R.PC  R.GC  R.PB                                R.PD  /
	.ASCII	/R.EL  R.WA              R.IA  R.IB  R.UB  /
	.END	INIT