.TITLE	ROLLIN
.IDENT	/MRH002/
	.SBTTL	INTRO PAGE
;
;
;THIS PROGRAM IS DESIGNED TO DO A ROLLIN FROM/TO
;RK DISK AND 9-TRACK MAGTAPE WHILE RSX IS RUNNING
;
;
;THE DISKS AND MAGTAPES INVOLVED SHOULD BE MOUNTED AS
;FOREIGN VOLUMNS, ALTHOUGH MOUNTED FILES-11 DISKS (INCLUDING
;DK0: CAN BE COPIED/WRITTEN. THE MAGTAPE
;MUST ALLOW DEVICE CONTROL FUNCTIONS
;
;
;CALLING PROCEEDURE IS
;
;MCR>ROL
;
;TYPICAL COMMAND LINE WOULD BE:
;
;	MT0:XXXXXX=DK2:    (WHERE XXXXXXX IS LABEL FOR FILE NAME ON MAG-TAPE)
;				CURRENTLY NAME MUST BE 6 LETTERS
;
;	LEGAL DEVICES ARE	DK0--3	DP0--2	DR0--3	MT0	MM0
;
;	CURRENTLY TWO SWITCHES ARE SUPPORTED:
;
;	/VE(RIFY)	CHECK TRANFER (TO DISK) BY RE-READING BUFFER
;			BACK FROM OUTPUT VOLUME
;
;	/OV(ERWRITE)	OVERWRITE ANY DATA ON OUTPUT TAPE, (I.E. DO NOT
;			FOLLOW NORMAL PROCEEDURE OF SEARCHING FOR END OF
;			VOLUME BEFORE STARTING WRITE.) USED TO WRITE FIRST
;			SAVE SET ON A TAPE. ALSO DONE AUTOMATICALLY IF
;			COPYING A LARGE DISK TO THE STREAMER TAPE MM
;
;TASK BUILD COMMAND FILE
;
;ROLLIN/-FP,ROLLIN/-SP=ROLLIN,[1,1]EXEC.STB
;/
;TASK=...ROL
;LIBR=SYSRES:RO
;PRI=100
;STACK=64
;ASG=TI:3
;PAR=GEN
;
;
;NOTE:
;DUE TO SYSTEM VARAITIONS, LEGAL DEVICES FOR WHICH TRANSFERS WILL BE ALLOWED
;ARE IN TABLES "INPTAB" AND "OUTTAB" THESE MUST BE MODIFIED TO INCLUDE
;(OR DELETE) DEVICES.
;
	.GLOBL	IO.RLB,IO.WLB,IO.ATT,IO.DET,IO.SPF,IO.EOF
	.GLOBL	IO.RWD,..ATRD,..RDTA
	.MCALL	EXIT$S,GTIM$C,GMCR$,DIR$
.PAGE
.SBTTL	GET USER'S COMMAND LINE
START:
	DIR$	#GETMCR		;GET MCR COMMAND LINE
	CMP	@#0,#8.		;IS THERE A COMMAND ?
	BLE	1$		;NO
	INC	MCRFLA		;YES, SHOW IT HAPPENED
	MOV	@#0,R0		;COUNT TO R0
	SUB	#4,R0		;ACCOUNT FOR 'ROL '
	MOV	#GETMCR+G.MCRB+4,R1 ;START READING AFTER 'ROL '
	MOV	#BUFFER,R2
2$:	MOVB	(R1)+,(R2)+	;XFER A CHARACTER TO REGULAR BUFFER
	SOB	R0,2$		;UNTIL DONE
1$:	MOV	.CRTSK,R0	;GET CURRENT ATL ADDRESS (ME)
	MOV	A.TI(R0),R0	;GET TI PUD START
	BIT	#UT.PR,U.PR(R0)	;IS IT A PRIVILEGED TERMINAL ?
	BNE	GETCMD		;YES GET COMMAND
	MOV	#24.,R0		;NO R0 = NUMBER OF ERROR MESSAGE
	CLR	R1		;CLEAR R1 (NO INSERTED TEXT)
	JSR	PC,ERRQIO	;WRITE ERROR MESS
	JMP	ENDRUN		;AND SCRAM
GETCMD:
	TST	MCRFLA		;WAS THERE EVER AN MCR FLAG ?
	BEQ	22$		;BR IF NOT
	INC	MCRFL1		;ELSE COUNT # OF THEM
	CMP	MCRFL1,#1	;FIRST TIME FOR ONE-LINER
	BEQ	NOTCTZ		;IF SO, TRY IT
	EXIT$S			;MCRFL1 GT 1 MEANS ONE-LINER FAILED, JUST EXIT
22$:	MOV	#IO.WLB,R0	;I/O CODE TO R0
	MOV	#3,R1		;LOGICAL DEV NUMBER TO R1
	MOV	#PROMPT,R2	;START OF PROMPT BUFFER TO R2
	MOV	#4,R3		;LENGTH OF PROMPT TO R3
	MOV	#44,R4		;CAR. CTL CODE TO R4
	JSR	PC,QIO		;CALL QIO SUBROUTINE
	;NOW CET COMMAND LINE FROM TERMINAL
	MOV	#IO.RLB,R0	;CHANGE QIO TO A READ
	MOV	#BUFFER,R2	;INTO INTERNAL BUFFER
	MOV	#80.,R3		;ACCEPT UP TO 80 BYTES
	CLR	R4		;CLEAR CAR CTL TO BE SURE
	JSR	PC,QIO		;NOW READ THE COMMAND LINE
	CMPB	IOSTAT,#-12	;IS FIRST CHAR A CTL Z ?
	BNE	NOTCTZ		;NO
	JMP	ENDRUN		;YES,?O MORE XFER REQUESTS
.PAGE
.SBTTL	PARSE OUTPUT DEVICE AND NAME
NOTCTZ:	MOV	#BUFFER,R0	;R0 POINTER TO BUFFER START
	MOV	#OUTDEV,R1	;POINTER TO OUTDEV STORAGE TO R1
	MOV	#4,R2		;XFER 4 ASCII CHARACTERS
	JSR	PC,XFERBT	;FROM BUFFER TO OUTDEV
	CMPB	-1(R0),#':	;FOURTH CHAR A ':'
	BEQ	1$		;YES SKIP NEXT
	DEC	R0		;IMPLIED DEVICE 0 BACK UP POINTER
	MOV	#"0:,OUTNUM	;AND REWRITE ASCII STRING CORRECTLY
1$:	CMP	OUTDEV,#"MT	;IS OUTDEV MAG TAPE ?
	BEQ	2$		;YES
	CMP	OUTDEV,#"MM	;OR STREAMER ?
	BNE	OUTNMT		;NOT MAGTAPE OUTPUT
2$:	MOV	#FILEOU,R1	;YES STORE OUTPUT FILENAME
	MOV	#6,R2		;OF 6 ASCII CHARACTERS
	JSR	PC,XFERBT	;IN FILEIN STORAGE AREA
	CMPB	(R0),#'=	;AFTER TAPE NAME, SHOULD BE AT '="
	BEQ	OUTNMT		;IF IT IS, WE'RE OK
	MOV	#34.,R0		;ELSE MESSAGE NUMBER
	CLR	R1		;NO INSERT
	JSR	PC,ERRQIO	;DO ERROR MESSAGE
	JMP	ENDRUN
OUTNMT:	CMPB	(R0)+,#'=	;DONE WITH OUTPUT DEV, SHOULD HAVE "="
	BEQ	ATEQ
	MOV	#2,R0		;IF NOT BAD INPUT DEVICE ERROR
	CLR	R1
	JSR	PC,ERRQIO	;DO MESSAGE
	JMP	ENDRUN		;AND QUIT
.PAGE
.SBTTL	PARSE INPUT DEVICE AND NAME, AND ANY SWITCH
ATEQ:	MOV	#INPDEV,R1	;STORE INPUT DEVICE
	MOV	#4,R2		;OF FOUR ASCII BYTES
	JSR	PC,XFERBT	;USING SAME SUBROUTINE
	CMPB	-1(R0),#':	;AGAIN IS IT IMPLIED UNIT 0 ?
	BEQ	1$		;BR IF NOT
	DEC	R0		;ADJUST INPUT STRING POINTER
	MOV	#"0:,INPNUM	;AND READJUST ASCII STRING
1$:	MOV	#300.,LOOTOT	;SET LOOP COUNT FOR A DK
	MOV	#8192.,MTSIZE	;AND BUFFER SIZE FOR A DK
	CMP	INPDEV,#"DP	;CHECK FOR DP DEVICES
	BEQ	2$		;FOUND ONE
	CMP	OUTDEV,#"DP
	BEQ	2$
	CMP	INPDEV,#"DR	;CHECK FOR DR'S
	BEQ	22$
	CMP	OUTDEV,#"DR
	BEQ	22$		;LAST CHANCE FOR A BIG DISK
	BR	3$		;NO DP'S OR DR'S MENTIONED
				;AS OF SEPT 82, FOR DR MAX=131680. BLOCKS
22$:	MOV	#4115.,LOOTOT	;SET LOOP TOTAL FOR A DR
	BR	23$
2$:	MOV	#4113.,LOOTOT	;DP'S ARE 80. BLOCKS SMALLER, SO NUMBER IS
				;SLIGHTLY LESS
23$:	MOV	#16384.,MTSIZE	;AND SIZE IN CASE IT'S TAPE TO/FROM DISK
				;CHANGED SO EACH LOOP DOES ONE CDC SURFACE
	CMP	INPDEV,#"DK	;FOR LARGE DISKS, BETTER NOT HAVE DK OR
	BEQ	21$		;AS INPUT/OUTPUT DEVICE
	CMP	OUTDEV,#"DK
	BEQ	21$
	CMP	INPDEV,#"MT	;SAME THING FOR OLDER TU10, THINGS WON'T FIT
	BEQ	21$
	CMP	OUTDEV,#"MT
	BEQ	21$
	BR	3$		;FELL THROUGH, BIG TRANSFER IS DP/DR/STREAMER
21$:	MOV	#25.,R0		;NO, ERROR MESS # TO R0
	JMP	ILLINP		;TELL OPERATOR WHY
3$:	CMP	INPDEV,#"MT	;IS INPUT MAG TAPE ?
	BEQ	INPIMT		;YES IT IS
	CMP	INPDEV,#"MM	;OR STREAMER ?
	BEQ	INPIMT
	JMP	INPNMT		;NO SKIP NEXT
INPIMT:	MOV	#FILEIN,R1	;POINTER TO INPUT FILE STORAGE
	MOV	#6,R2		;BYTE COUNT TO XFER
	JSR	PC,XFERBT	;STORE INPUT FILE NAME
INPNMT:	CLR	CKFLAG		;CLEAR READ AFTER WRITE CHECK FLAG
	CLR	OVFLAG		;CLEAR DON'T POSITION TAPE FLAG
	CMP	INPDEV,#"DP	;BACKING UP LARGE DISK ?
	BEQ	55$		;BR IF YES
	CMP	INPDEV,#"DR	;
	BNE	111$		;NO LARGE DISK
55$:	INC	OVFLAG		;FORCE NO SKIP SINCE ONLY ONE BACKUP PER TAPE
111$:	CMPB	(R0)+,#'/	;SWITCH THERE ?
	BNE	1$		;NO
	CMPB	(R0),#'V	;VERIFY ?
	BEQ	222$		;BR IF YES
	CMPB	(R0),#'O	;OVERWRITE ?
	BEQ	333$		;BR IF YES
	MOV	R0,-(SP)
	MOV	R1,-(SP)
	MOV	#37.,R0		;GIVE MESSAGE NUMBER
	CLR	R1		;NO NUMBER INSERT
	JSR	PC,ERRQIO	;REPORT BAD SWITCH VALUE
	MOV	(SP)+,R1
	MOV	(SP)+,R0
	CMPB	(R0)+,(R0)+	;LOOK FOR ANOTHER SWITCH
	BR	111$
222$:	INC	CKFLAG		;YES SET FLAG FOR CHECK
	CMPB	(R0)+,(R0)+	;LOOK FOR SECOND SWITCH
	BR	111$
333$:	INC	OVFLAG		;YES SET FLAG FOR OVERWRITE TAPE
	CMPB	(R0)+,(R0)+	;LOOK FOR SECOND SWITCH
	BR	111$
1$:	CMP	INPDEV,OUTDEV	;ARE INPUT & OUT SAME DEVICE
	BNE	NOTSAM		;NO WE'RE OK
	CMP	INPNUM,OUTNUM	;IF SAME, # BETTER NOT BE
	BNE	NOTSAM		;NOT SAME PHYSICAL DEVICE
	MOV	#3,R0		;ERROR MESS #
	JMP	ILLINP		;GO TO ILLEGAL INPUT LINE CODE
.PAGE
.SBTTL	CHECK FOR LEGAL INPUT/OUTPUT DEVICES
NOTSAM:	;NO DEV NAME CONFLICTS, CHECK FOR LEGAL DEVICES
	MOV	#INPDEV,R0	;SET UP TO CHECK INPUT DEVICE
	JSR	PC,CKDEV	;CHECK IT
	BCC	INPDOK		;DEVICE IS LEGAL
	MOV	#3,R0		;ERROR, MESS # TO R0
	JMP	ILLINP		;ILLEGAL INPUT LINE
INPDOK:	MOV	#OUTDEV,R0	;SET TO CHECK OUT DEV
	JSR	PC,CKDEV	;CHECK IT
	BCC	OUTDOK		;DEVICE IS LEGAL
	MOV	#2,R0		;ILLEGAL, ERROR MESS # TO R0
	JMP	ILLINP		;ILLEGAL INPUT LINE
;
;	OK SO WE AT LEAST HAVE LEGAL INPUT & OUTPUT DEVICES
;	FIRST ASSIGN OUTDEV TO #1 AND INDEV TO #2
;
OUTDOK:	MOV	#1,ASGLUN	;PUT LUN IN DPB
	MOV	OUTDEV,ASGNAM	;INSERT DEVICE NAME
	MOVB	OUTNUM,R1	;ASCII DEV NUMBER TO R1
	SUB	#60,R1		;CONVERT IT TO OCTAL
	MOV	R1,OUTNMO	;SAVE OCTAL DEV NUMBER
	MOV	R1,ASGNUM	;PUT IT IN DPB TOO
	MOV	#ASGDPB,-(SP)	;PUT START OF DPB ONTO STACK
	EMT	377		;AND CALL DIRECTIVE
	BCC	OUTASG		;OUTPUT ASSIGNED OK
	MOV	#OUTDEV,R2	;POINTER TO OUTDEV IN R2
	BR	BADASG		;TELL OPERATOR ASSIGN FAILED
OUTASG:	MOV	#2,ASGLUN	;SET TO ASSIGN UNIT 2
	MOV	INPDEV,ASGNAM	;INSERT DEV NAME
	MOVB	INPNUM,R1	;GET ASCII DEV NUMBER
	SUB	#60,R1		;CONVERT TO OCTAL
	MOV	R1,INPNMO	;SAVE OCTAL DEV NUMBER
	MOV	R1,ASGNUM	;AND PUT IN DPB
	MOV	#ASGDPB,-(SP)	;START OF DPB ONTO STACK
	EMT	377		;CALL DIRECTIVE
	BCC	INPASG		;ASSIGN WORKED
	MOV	#INPDEV,R2	;ON ERROR, POINTER IN R2 FOR ERROR
	BR	BADASG		;TELL OPERATOR ABOUT ERROR
;
;	WARN OPERATOR IF RESTORING TO DP, MIGHT LOOSE 80 BLOCKS
;
INPASG:	CMP	OUTDEV,#"DP	;OUTPUT TO DP ?
	BNE	ATTACH		;SKIP IF NOT
	MOV	#36.,R0		;GIVE MESSAGE NUMBER
	CLR	R1		;NO NUMBER INSERT
	JSR	PC,ERRQIO	;REPORT IT
	JMP	ATTACH
.PAGE
.SBTTL	MISC ERROR HANDLING
;
;
;THIS CODE REPORTS AN ILLEGAL COMMAND LINE AND REQUESTS ANOTHER
;
	;ERROR MESSAGE NUMBER ALREADY SET INTO R0
ILLINP:	CLR	R1		;NO IMBEDED TEXT
	JSR	PC,ERRQIO	;AND REPORT ERROR
	JMP	GETCMD		;READ ANOTHER COMMAND
;
;SECTION TO REPORT ASSIGN FAILURES & POSSIBLY TRY AGAIN
;
BADASG:	MOV	#4,R0		;SET UP FOR BAD ASSIGN MESSAGE
	MOV	#1,R1		;WITH INSERTED TEXT
				;R2 ALREADY SET IN ASSIGN CODE
	MOV	#4,R3		;BYTE COUNT OF DEV TO R3
	JSR	PC,ERRQIO	;WRITE ERROR MESSAGE
	JMP	ALLOUT		;& TRY TO CLEAR UP AND RUN AGAIN
;
.PAGE
.SBTTL	SUB TO CHECK FOR LEGAL DEVICES
;
;
;CALL WITH R0 CONTAINING ADDRESS OF INPUT OR OUTPUT DEVICE
;STRING (ASCII) IE "MT0:"
;
;C-BIT IS SET ON RETURN TO INDICATE ERROR, OTHERWISE CLEARED
;
CKDEV:	MOV	#INPTAB,R1	;R1 POINTS TO START OF INPUT DEV TABLE
	CMP	R0,#OUTDEV	;CHECKING OUTPUT DEVICE ?
	BNE	CKAGIN		;NO
	MOV	#OUTTAB,R1	;POINT R1 TO START OF OUTPUT DEVICE TABLE
CKAGIN:	CMP	(R0),(R1)+	;COMPARE DEV NAMES
	BEQ	NAMMAT		;NAMES MATCH
	TST	(R1)+		;NO MATCH, BUMP R1 PAST DEV NUMBER
	BR	NOMAT		;AND TRY AGAIN
NAMMAT:	CMP	2(R0),(R1)+	;COMPARE UNIT NUMBERS
	BNE	NOMAT		;NO MATCH, TRY AGAIN
	CLC			;ITS A LEGAL DEVICE, CLEAR C BIT AS INDICATOR
	RTS	PC		;AND RETURN
NOMAT:	TST	(R1)		;ARE WE THROUGH TABLE ?
	BNE	CKAGIN		;NO CHECK NEXT DEVICE IN TABLE
NG:	SEC			;YES SET C BIT AS ERROR FLAG
	RTS	PC		;AND RETURN
.PAGE
.SBTTL	TABLE OF LEGAL INPUT AND OUTPUT DEVICES
;
;TABLE OF LEGAL DEVICES FOR ROLLIN INPUT
INPTAB:	.ASCII	/DK0:DK1:DK2:DK3:/
	.ASCII	/MT0:/
	.ASCII	/MM0:/
	.ASCII	/DP0:DP1:DP2:/
	.ASCII	/DR0:DR1:DR2:DR3:/
	.WORD	0		;END OF TABLE FLAG
;
;TABLE OF LEGAL DEVICES FOR ROLLIN OUTPUT
OUTTAB:	.ASCII	/DK0:DK1:DK2:DK3:/
	.ASCII	/MT0:/
	.ASCII	/MM0:/
	.ASCII	/DP0:DP1:DP2:/		;ALLOW RESTORES TO ANY DP
	.ASCII	/DR0:DR1:DR2:DR3:/		
	.WORD	0		;END OF TABLE FLAG
.PAGE
.SBTTL	ATTACH DEVICES IN QUESTION
;
;THIS SUBROUTINE REPORTS AN ATTACH FAILURE
;
BADATT:	MOV	#6,R0		;SET TO PRINT ERROR MESS #6
	MOV	#1,R1		;WITH INSERTED TEXT
				;R2 ALREADY SET
	MOV	#4,R3		;INSERT 4 ASCII CHARACTERS
	JSR	PC,ERRQIO	;& REPORT ERROR
	RTS	PC		;BUT CONTINUE OPERATION
;
;
ATTACH:				;NOW TRY TO ATTACH DEVICES
	MOV	#IO.ATT,R0	;ATTACH CODE TO R0
	MOV	#1,R1		;LUN TO R1
	JSR	PC,QIO		;DO ATTACH QIO
	CMP	#1,IOSTAT	;CHECK IO STATUS CODE
	BEQ	OUTATC		;ATTACH WENT OK
	MOV	#OUTDEV,R2	;FAILED SET UP FOR ATTCH FAIL REPT
	JSR	PC,BADATT	;GO REPORT
OUTATC:	MOV	OUTDEV,OUTATT	;SHOW OUTPUT ATTACHED
	MOV	#2,R1		;CHANGE LUN TO INPUT DEVICE
	JSR	PC,QIO		;DO THIS ATTACH QIO
	CMP	#1,IOSTAT	;CHECK STATUS
	BEQ	ATTAOK		;WELL, WE FINALLY CAN START CRUNCHING
	MOV	#INPDEV,R2	;SET UP DEV POINTER IN R2
	JSR	PC,BADATT	;REPORT ERROR AND CONTINUE
;
;
.SBTTL	POSITION MAG-TAPE
;
ATTAOK:	MOV	INPDEV,INPATT	;SHOW INPUT ATTACHED
		;HERE WE FINALLY CAN START REAL CODE
	CMP	OUTDEV,#"MT	;IS OUTPUT ON MAGTAPE
	BEQ	1$		;YES, MAY HAVE TO SKIP FILES
	CMP	OUTDEV,#"MM	;NO, CHECK FOR STREAMER
	BNE	OUTRDY		;NO OUT ON DISK IS SET
1$:	TST	OVFLAG		;SKIP TAPE POSITIONING ?
	BNE	ENDOV		;YES, SKIP IT
	MOV	#IO.SPF,R0	;SET UP TO DO A SKIP FILES
	MOV	#1,R1		;ON DEV #1
	MOV	#100.,R2	;SET TO SKIP LOTS MORE THAN WE NEED
	JSR	PC,QIO		;DO QIO TO MT
	CMPB	#-11.,IOSTAT	;AT END OF VOLUME ?
	BEQ	ENDOV		;YES WE'RE AT END
	MOV	#13.,R0		;SET MESSAGE NUMBER IN R0
	CLR	R1		;SET FOR NO INSERTED TEXT
	JSR	PC,ERRQIO	;WRITE ERROR MESSAGE
	JMP	ALLOUT		;AND TRY TO UNDO
ENDOV:	CLR	ENDOVF		;CLEAR FLAG SINCE WE'LL BE WRITING
;
.PAGE
.SBTTL	WRITE HEADER AND REEL LABEL ON TAPE
;
;	FIRST WRITE HEADER (ROLLIN FORMAT)
;
	MOV	#9.,R1		;SET TO CONVERT ASCII FILE NAME (WITH EXT.)
	MOV	#FILEOU,R2	;POINTED TO BY R2
	MOV	#BUFFER,R3	;TO RAD 5O CODE STARTING AT BUFFER
	JSR	PC,..ATRD	;CALL CONVERSION SUBROUTINE
	BCC	NAMEOK		;YES GOT A GOOD RAD-50 NAME
	MOV	#14.,R0		;NO SET UP FOR ERROR MESS #14
	CLR	R1		;WITH NO TEXT INSERTION
	JSR	PC,ERRQIO	;WRITE THE ERROR MESSAGE
	JMP	ALLOUT		;& TRY ERROR EXIT
NAMEOK:	MOV	#BUFFER+6,R0	;POINT TO LATER IN BUFFER
	MOV	UIC,(R0)+	;PUT UIC IN BUFFER
	MOV	PCODE,(R0)+	;AND PROTECTION CODE
	GTIM$C	DATTIM		;GET TIME FROM SYSTEM
	JSR	PC,DOSDAT	;DO OUR ROUTINE TO CONVERT TO DOS DATE
	CLR	(R0)+		;AND CLEAR LAST WORD
	MOV	#IO.WLB,R0	;SET UP FOR A WRITE
	MOV	#1,R1		;ON UNIT #1
	MOV	#BUFFER,R2	;WRITE STARTING AT BUFFER
	MOV	#14.,R3		;WRITE 14 BYTES
	JSR	PC,QIO		;DOIT-DOIT-DOIT
	CMP	IOSTAT,#1	;CHECK DIRECTIVE STAT
	BEQ	HEADOK		;IT WENT
	MOV	#15.,R0		;SET TO PRINT ERROR 15
	CLR	R1		;WITH NO INSERTED TEXT
	JSR	PC,ERRQIO	;WRITE ERROR MESS
	JMP	ALLOUT		;& TRY TO RECOVER
;
;
;	HEADER HAS BEEN WRITTEN, NOW WRITE REEL LABEL
;
HEADOK:	MOV	#BUFFER,R0	;POINTER TO BUFFER START
	MOV	#1,(R0)+	;WRITE REEL # 1 INTO BUFFER
	MOV	#255.,R3	;USE R3 AS COUNTER
WRITE0:	CLR	(R0)+		;CLEAR OUT A WORD
	SOB	R3,WRITE0	;IF NOT AT END, CLEAR ANOTHER
	MOV	#IO.WLB,R0	;IO CODE IN R0
	MOV	#1,R1		;OUTPUT LUN TO R1
	MOV	#BUFFER,R2	;BUFFER START TO R2
	MOV	#512.,R3	;BYTE COUNT TO R3
	JSR	PC,QIO		;WRITE REEL # BLOCK
	CMP	IOSTAT,#1	;WAS WRITE SUCCESSFUL
	BEQ	OUTRDY		;YES READY TO WRITE ON MT
	MOV	#16.,R0		;NO SET ERROR MESS # INTO R0
	CLR	R1		;NO INSERTED TEXT
	JSR	PC,ERRQIO	;REPORT ERROR
	JMP	ALLOUT		;AND TRY FOR RECOVERY
.PAGE
.SBTTL	LOOK FOR FILE HEADER ON MAG-TAPE
;
OUTRDY:	;MAG TAPE SET FOR OUTPUT IF NECESSARY
	;BUT MAY NEED TO SET UP FOR INPUT
;
	CMP	INPDEV,#"MT	;IS INPUT DEV MAG TAPE ?
	BEQ	READMT		;YES SET IT UP
	CMP	INPDEV,#"MM	;OR STREAMER
	BEQ	READMT		;YES
	JMP	MTREDY		;NO READY FOR XFER
READMT:	MOV	#IO.RLB,R0	;SET UP TO READ
	MOV	#2,R1		;FROM INPUT LUN
	MOV	#BUFFER,R2	;INTO BUFFER
	MOV	#8192.,R3	;OF 8192 BYTES
	JSR	PC,QIO		;DO QIO
	CMP	IOSTAT,#1	;WAS READ SUCCESSFUL ?
	BEQ	ISITHD		;YES, SEE IF IT'S A HEADER
	MOV	#18.,R0		;NO, ERROR MESS # TO R0
	JSR	PC,CONCOD	;CONVERT ERROR CODE TO ASCII
	JSR	PC,ERRQIO	;WRITE ERROR(INCLUDING ERROR CODE)
	JMP	ALLOUT		;TRY FOR RECOVERY
ISITHD:	CMP	IOSTA2,#14.	;IS IT A 14 BYTE BLOCK ?
	BNE	SKIPFL		;NO SKIP IT
	JMP	HEADCK		;YES GO CHECK FOR NAME MATCH
SKIPFL:	MOV	#IO.SPF,R0	;SET UP TO SKIP THIS FILE
	MOV	#2,R1		;ON INPUT LUN
	MOV	#1,R2		;SKIP ONE FILE ONLY
	JSR	PC,QIO		;DO QIO
	CMP	IOSTAT,#1	;WAS IT SUCCESSFUL
	BEQ	READMT		;YES READ NEXT FILE
SKIPER:	CMP	IOSTAT,#-11.	;AT END OF VOLUME ?
	BNE	OTHERR		;NO SOME OTHER READ ERROR
	MOV	#8.,R0		;SET UP MESSAGE 8
	CLR	R1		;NO INSERTED TEXT
	JSR	PC,ERRQIO	;WRITE ERROR
	JMP	ALLOUT		;AND TRY RECOVERY
OTHERR:	MOV	#18.,R0		;# OF MT WRITE ERROR MESS
	JSR	PC,CONCOD	;CONVERT ERROR CODE -> ASCII
	JSR	PC,ERRQIO	;WRITE ERROR
	JMP	ALLOUT		;AND EXIT
.PAGE
.SBTTL	CHECK MAG-TAPE FILE HEADER NAME FOR MATCH
;
;
;FOUND A HEADER, CHECK NAME FOR MATCH
HEADCK:	MOV	#9.,R1		;SET TO CONVERT 9 RAD50 CHARACTERS
	MOV	#BUFFER,R2	;IN BUFFER
	MOV	#MTNAME,R3	;TO ASCII CHARS IN MTNAME
	JSR	PC,..RDTA	;CALL SYS SUB
	BCC	NAMECK		;IF NAME IS LEGAL, COMPARE IT
	MOV	#14.,R0		;OTHERWISE BAD NAME MESSABE
	CLR	R1		;NO EXTRA TEXT
	JSR	PC,ERRQIO	;WRITE ERROR AT TERM
	JMP	ALLOUT		;AND TRY FOR RESTART
NAMECK:	;VALID MAGTAPE NAME
	MOV	#MTNAME,R0	;R0 POINTER FOR NAME ON MT
	MOV	#FILEIN,R1	;R1 POINTER TO CMD FILE NAME
	MOV	#9.,R2		;USE R2 AS COUNTER
CHKBYT:	CMPB	(R0)+,(R1)+	;SAME CHARACTER ?
	BNE	NAMENG		;WOOPS NO MATCH
	SOB	R2,CHKBYT	;ANOTHER CHAR TO COMPARE ?
	BR	MTINOK		;DONE MAG TAPE SET FOR INPUT
NAMENG:	BR	SKIPFL		;JUST SKIP TILL WE GET ANOTHER HEADER
;
;
;
MTINOK:	;NAMES MATCH, NOW ACCOUNT FOR REEL LABEL
	MOV	#IO.RLB,R0	;READ CODE TO R0
	MOV	#2,R1		;IN PUT LUN
	MOV	#BUFFER,R2	;JUST READ INTO BUFFER
	MOV	#512.,R3	;READ A 512. BYTE BLOCK
	JSR	PC,QIO		;DO READ QIO
	CMP	IOSTAT,#1	;SUCCESSFUL
	BNE	SKIPER		;USE SKIP ERROR CODE
;
.PAGE
.SBTTL	MAIN TRANSFER LOOP
;
;ALL MAG-TAPE SET UP DONE
;
MTREDY:	CLR	BLKOUT		;START OUTPUT XFER AT BLOCK 0
	CLR	BLKOHG
	CLR	BLKINP		;SAME FOR INPUT
	CLR	BLKIHG
	CLR	LOOPCT		;ALSO CLEAR LOOP COUNTER
LOOPMN:	INC	LOOPCT		;COUNT A PASS
	CMP	INPDEV,#"MT	;MAG-TAPE INPUT ?
	BEQ	11$		;BR IF YES
	CMP	INPDEV,#"MM	;OR STREAMER
	BNE	1$		;NO
11$:	JSR	PC,MTREAD	;YES READ FROM TAPE
1$:	CMP	INPDEV,#"DP	;OR DP
	BEQ	12$		;IF SO, DO DP READ
	CMP	INPDEV,#"DR	;OR DR
	BNE	2$		;NO
12$:	JSR	PC,DPREAD	;YES
2$:	CMP	INPDEV,#"DK	;OR DK ?
	BNE	READDN		;NO
	JSR	PC,DKREAD	;YES
READDN:	CMP	OUTDEV,#"MT	;MAGTAPE OUTPUT ?
	BEQ	11$		;BR IF YES
	CMP	OUTDEV,#"MM	;OR STREAMER ?
	BNE	1$		;NO
11$:	JSR	PC,MTWRIT	;YES
1$:	CMP	OUTDEV,#"DP	;A DP ?
	BEQ	12$		;IF SO, DO DP WRITE
	CMP	OUTDEV,#"DR	;OR DR
	BNE	2$		;NO
12$:	JSR	PC,DPWRIT	;YES
2$:	CMP	OUTDEV,#"DK	;OR DK
	BNE	WRITDN		;NO
	JSR	PC,DKWRIT	;YES
WRITDN:	;ONE 4096 WORD BLOCK WAS XFERRED
	CMP	ERRCNT,#16.	;TOO MANY ERRORS ?
	BGE	ERROUT		;YEA, SCRAM
	CMP	LOOPCT,LOOTOT	;DONE WITH ALL BLOCKS ?
	BLT	LOOPMN		;NO LOOP TIL DONE
	JMP	ALLDNE		;YES FINISH UP
;
;
;
ERROUT:	MOV	#1,R0		;MESS # TO R0
	CLR	R1		;WITH NO EXTRA ASCII
	JSR	PC,ERRQIO	;REPORT ERROR
	CLR	ERRCNT		;CLEAR COUNTER FOR NEXT TIME AROUND
				;NOW JOIN CLEAR OUT SEQUENCE
.PAGE
.SBTTL	CLOSE OUT MAG-TAPE AS OUTPUT DEVICE
;
;WRITE END-OF-FILE MARKS AND POSITION OUTPUT MAG-TAPE
;
;
ALLDNE:	CMP	OUTDEV,#"MT	;OUTPUT ON MAGTAPE ?
	BEQ	1$		;BR IF YES
	CMP	OUTDEV,#"MM	;OR STREAMER ?
	BNE	ALLOUT		;NO
1$:	CLR	ENDOVF		;USE AS COUNTER
LOOPEF:	MOV	#IO.EOF,R0	;END OF FILE IO CODE
	MOV	#1,R1		;TO OUTPUT LUN
	JSR	PC,QIO		;WRITE AN END OF FILE
	CMP	IOSTAT,#1	;DID IT GO ?
	BEQ	ENDFOK		;YES
	MOV	#13.,R0		;ERROR MESS # TO R0
	CLR	R1		;NO INSERTED TEXT
	JSR	PC,ERRQIO	;WRITE ERROR MESS
	JMP	ALLOUT		;AND ERROR EXIT
ENDFOK:	INC	ENDOVF		;INCREMENT ENDFILE COUNT
	CMP	ENDOVF,#3	;DID WE WRITE 3 EOF'S ?
	BLT	LOOPEF		;NO DOIT AGAIN
;
;
;NOW BACKSPACE OVER ALL THREE OF THE EOF'S
;SO ANY SUBSEQUENT SEARCH FOR AN ENDOV WORKS OK
;UNLESS OUTPUT WAS TO A BIG DISK (ONLY ONE DISK PER TAPE)
;IN THIS CASE, JUST REWIND THE TAPE SO IT CAN BE TAKEN OFF
;
	CMP	INPDEV,#"DP	;ARE WE SAVING A BIG DISK ?
	BEQ	22$		;BR IF YES
	CMP	INPDEV,#"DR
	BNE	1$		;BRANCH IF NOT
22$:	MOV	#IO.RWD,R0	;SET REWIND FUNCTION
	MOV	#1,R1		;ON OUTPUT LUN
	JSR	PC,QIO		;START THE REWIND (HANDLER RETURNS IMMEDIATELY)
	BR	ALLOUT		;AND CHECK FOR INPUT FROM MAGTAPE
1$:	MOV	#IO.SPF,R0	;FOR SMALL DISKS, DO SKIP IO CODE
	MOV	#1,R1		;ON OUTPUT LUN
	MOV	#-3,R2		;SKIP COUNT TO R2
	JSR	PC,QIO		;DO BACKSPACE QIO
	CMP	IOSTAT,#1	;WENT OK ?
	BEQ	ALLOUT		;YES
	MOV	#13.,R0		;NO MESS # TO R0
	CLR	R1		;NO EXTRA ASCII
	JSR	PC,ERRQIO	;WRITE ERROR MESS
.PAGE
.SBTTL	CLOSE OUT MAG-TAPE AS INPUT DEVICE
;
;
;IF MAGTAPE WAS INPUT DEVICE, SKIP OVER EOF
;SO SUBSEQUENT ROLLINS FROM MAG-TAPE WORK
;UNLESS WE RESTORED A BIG DISK. IN THAT CASE, JUST REWIND THE TAPE
;
;
ALLOUT:	CMP	INPDEV,#"MT	;WAS READ FROM MAG-TAPE ?
	BEQ	1$		;BR IF YES
	CMP	INPDEV,#"MM	;OR STREAMER ?
	BNE	CKATCH		;NO DON'T BOTHER
1$:	CMP	OUTDEV,#"DP	;WERE WE RESTORING A BIG DISK ?
	BEQ	22$		;BR IF YES
	CMP	OUTDEV,#"DR
	BNE	2$		;BRANCH IF NOT
22$:	MOV	#IO.RWD,R0	;SET REWIND FUNCTION
	MOV	#2,R1		;ON INPUT LUN
	JSR	PC,QIO		;START THE REWIND (HANDLER RETURNS IMMEDIATELY)
	BR	CKATCH		;AND DETACH DEVICES
2$:	MOV	#IO.SPF,R0	;FOR SMALL DISKS, SET UP FOR SKIP
	MOV	#2,R1		;ON INPUT LUN
	MOV	#1,R2		;SKIP 1 EOF
	JSR	PC,QIO		;DO THE QIO
;
.PAGE
.SBTTL	DETACH ATTACHED DEVICES
;
;FINAL CLEAN UP--DEATTACH WHERE NEEDED
;
CKATCH:	CMP	OUTATT,OUTDEV	;WAS OUTPUT EVER ATTACHED ?
	BNE	OUTNAT		;NO DON'T TRY TO DEATTACH
	MOV	#IO.DET,R0	;YES, DETACH CODE TO R0
	MOV	#1,R1		;OUTPUT LUN TO R1
	JSR	PC,QIO		;DO DETACH QIO
	CMP	IOSTAT,#1	;SUCCESS ?
	BEQ	OUTNAT		;YES TYR OUTPUT
	MOV	#OUTDEV,R2	;POINTER TO OUTPUT DEV TO R2
	JSR	PC,BADDET	;USE SUB TO REPORT BAD DETACH
OUTNAT:	CMP	INPATT,INPDEV	;WAS INPUT ATTACHED ?
	BNE	INPNAT		;NO DON'T DETACH
	MOV	#IO.DET,R0	;DETACH CODE TO R0
	MOV	#2,R1		;INPUT LUN TO R1
	JSR	PC,QIO		;DO DETACH QIO
	CMP	IOSTAT,#1	;DID IT GO ?
	BEQ	INPNAT		;YES
	MOV	#INPDEV,R2	;NO POINTER TO INPUT DEV TO R2
	JSR	PC,BADDET	;USE BAD DETACH REPORT SUB
INPNAT:	;ALL UNDONE, TRY ANOTHER COMMAND
	TST	MCRFLA		;WAS THIS AN MCR ONE LINER ?
	BNE	ENDRUN		;IF YES SCRAM
	JMP	GETCMD
;
;
;SUB TO REPORT DETACH FAILURES
;
BADDET:	MOV	#10.,R0		;ERROR MESS # TO R0
	MOV	#1,R1		;TEXT INSERT FLAG
	MOV	#4,R3		;INSERT 4 BYTES
	JSR	PC,ERRQIO	;WRITE ERROR MESS
	RTS	PC		;AND RETURN
;
;
;
ENDRUN:	;CONTROL-Z SEEN ON INPUT OR MCR ONE LINER
	EXIT$S			;AND EXIT
;
.PAGE
.SBTTL	DK READ/WRITE SUBS
;
;SUBROUTINE TO READ FROM DK
;
DKREAD:	MOV	#IO.RLB,R0	;LOAD IO CODE
	MOV	#2,R1		;LOAD INPUT LUN
	MOV	#BUFFER,R2	;LOAD BUFFER START
	MOV	#8192.,R3	;LOAD BYTE COUNT
	CLR	R4		;PAR#3=0
	MOV	BLKINP,R5	;CURRENT STARTING BLOCK TO R5
	JSR	PC,QIO		;DO THE QIO
	CMP	IOSTAT,#1	;WENT OK ?
	BEQ	DKRDOK		;YES
	MOV	#22.,R0		;ERROR MESS # IN R0
	MOV	BLKINP,R1	;BLOCK COUNT TO R1
	JSR	PC,DKERR	;WRITE ERROR
DKRDOK:	ADD	#16.,BLKINP	;INCREMENT BLOCK START
	RTS	PC		;AND RETURN
;
;
;SUBROUTINE TO WRITE TO DK
;
;
DKWRIT:	MOV	#IO.WLB,R0	;IO CODE TO R0
	MOV	#1,R1		;OUTPUT LUN TO R1
	MOV	#BUFFER,R2	;BUFFER START TO R2
	MOV	#8192.,R3	;BYTE COUNT TO R3
	CLR	R4		;PAR 3=0
	MOV	BLKOUT,R5	;START BLOCK IN R5
	JSR	PC,QIO		;DO WRITE
	CMP	IOSTAT,#1	;WENT OK?
	BEQ	DKWTOK		;YESS IT WENT
	MOV	#20.,R0		;ERROR MESS # TO R0
	MOV	BLKOUT,R1	;BLOCK # TO R1
	JSR	PC,DKERR	;WRITE ERROR MESS
DKWTOK:	TST	CKFLAG		;WANT WRITE CHECK ?
	BEQ	DKCKOK		;NO SO SKIP
	MOV	#IO.RLB,R0	;YES, SET PARAMS AGAIN
	MOV	#1,R1		;OUTPUT DEVICE FOR CHECK LUN TO R1
	MOV	#BUFFER,R2	;BUFFER POINTER
	MOV	#8192.,R3	;BYTE COUNT
	CLR	R4		;PAR 3=0
	MOV	BLKOUT,R5	;STARTING BLOCK IN R5
	JSR	PC,QIO		;DO READ CHECK
	CMP	IOSTAT,#1	;SUCCESSFUL ?
	BEQ	DKCKOK		;BR IF OK
	MOV	#32.,R0		;ELSE MESS # TO R0
	MOV	BLKOUT,R1	;STARTING BLOCK # TO R1
	JSR	PC,DKERR	;AND REPORT ERROR
DKCKOK:	ADD	#16.,BLKOUT	;BUMP STARTING BLOCK NUMBER
	RTS	PC		;AND RETURN
.PAGE
.SBTTL	DK ERROR REPORTING SUB
;
;
;
;SUB TO REPORT DISK READ OR WRITE ERROR
;
;
DKERR:	MOV	R0,R5		;SAVE START OF MESS POINTER
	MOV	R1,R0		;BLOCK COUNT TO R0
	MOV	#BLKEND,R3	;R3 POINTS AT END OF ASCII BL #
	MOV	#5,R4		;USE R4 AS COUNTER
LOPCON:	MOV	R0,R1		;NUMBER INTO R1
	CLR	R0		;CLEAR UPPER REGISTER
	DIV	#10,R0		;DIVIDE
	ADD	#60,R1		;CONVERT REMAINDER TO ASCII
	MOVB	R1,-(R3)	;STORE IN MESSAGE
	SOB	R4,LOPCON	;DO ANOTHER IF NECC
	MOV	R5,R0		;RESTORE MESSAGE POINTER
	MOV	#1,R1		;INDICATE INSERTED MESSAGE
	MOV	#BLKBUF,R2	;START INTO R2
	MOV	#8.,R3		;BYTE COUNT TO R3
	JSR	PC,ERRQIO	;WRITE ERROR MESSAGE
	INC	ERRCNT		;COUNT THE ERROR
	RTS	PC		;AND RETURN
;
;
BLKBUF:	.ASCII	/ 00000/
BLKEND:
.PAGE
.SBTTL	SUB TO READ FROM DP
;
;SUB TO READ FROM DP
;
DPREAD:	MOV	#IO.RLB,R0	;FN CODE TO R0
	MOV	#2,R1		;LOAD INPUT LUN
	MOV	#BUFFER,R2	;LOAD BUFFER START
	MOV	#16384.,R3	;LOAD BYTE COUNT
	CMP	INPDEV,#"DP	;REALLY READING FROM DP ?
	BNE	1$		;SKIP CHECK IF NOT
	CMP	LOOPCT,LOOTOT	;IS IT THE LAST RECORD ?
	BNE	1$		;SKIP IF NOT
	MOV	#8192.,R3	;ELSE MAKE LAST RECORD HALF SIZE
1$:	CLR	R4		;PAR#3=0
	MOV	BLKINP,R5	;CURRENT STARTING BLOCK TO R5
	MOV	BLKIHG,PAR4	;LOAD HIGHER WORD
	JSR	PC,QIO		;DO THE QIO
	CLR	PAR4
	CMP	IOSTAT,#1	;WENT OK ?
	BEQ	DPRDOK		;YES
	MOV	#28.,R0		;ERROR MESS # IN R0
	MOV	BLKINP,R1	;BLOCK COUNT TO R1
	JSR	PC,DPERR	;WRITE ERROR
DPRDOK:	ADD	#32.,BLKINP	;INCREMENT BLOCK START
	ADC	BLKIHG		;DO 2 WORD MATH
	RTS	PC		;AND RETURN
.PAGE
.SBTTL	SUB TO WRITE TO DP
;
;SUBROUTINE TO WRITE TO DP
;
DPWRIT:	MOV	#IO.WLB,R0	;IO CODE TO R0
	CMP	OUTDEV,#"DR	;OUTPUT TO DR DISK ?
	BNE	2$		;SKIP IF NOT
	CMP	LOOPCT,LOOTOT	;WRITING LAST TRACK ?
	BNE	2$		;SKIP IF NOT
	MOV	#IO.WLT,R0	;TELL DR HANDLER WE WANT TO WRITE LAST TRACK
2$:	MOV	#1,R1		;OUTPUT LUN TO R1
	MOV	#BUFFER,R2	;BUFFER START TO R2
	MOV	#16384.,R3	;BYTE COUNT TO R3
	CMP	OUTDEV,#"DP	;REALLY WRITING TO DP ?
	BNE	1$		;SKIP CHECK IF NOT
	CMP	LOOPCT,LOOTOT	;IS IT THE LAST RECORD ?
	BNE	1$		;SKIP IF NOT
	MOV	#8192.,R3	;ELSE MAKE LAST RECORD HALF SIZE
1$:	CLR	R4		;PAR 3=0
	MOV	BLKOUT,R5	;START BLOCK IN R5
	MOV	BLKOHG,PAR4	;UPPER WORD TO P4
	JSR	PC,QIO		;DO WRITE
	CLR	PAR4
	CMP	IOSTAT,#1	;WENT OK?
	BEQ	DPWTOK		;YESS IT WENT
	MOV	#26.,R0		;ERROR MESS # TO R0
	MOV	BLKOUT,R1	;BLOCK # TO R1
	JSR	PC,DPERR	;WRITE ERROR MESS
DPWTOK:	TST	CKFLAG		;WANT FURTHER CHECK ?
	BEQ	DPCKOK		;NO
	MOV	#IO.RLB,R0	;SET PARAMETERS AGAIN TO BE DOUBLE SURE
	MOV	#1,R1		;LUN
	MOV	#BUFFER,R2	;BUFFER POINTER
	MOV	#16384.,R3	;BYTE COUNT
	CMP	OUTDEV,#"DP	;REALLY WRITING TO DP ?
	BNE	1$		;SKIP CHECK IF NOT
	CMP	LOOPCT,LOOTOT	;IS IT THE LAST RECORD ?
	BNE	1$		;SKIP IF NOT
	MOV	#8192.,R3	;ELSE MAKE LAST RECORD HALF SIZE
1$:	CLR	R4		;PAR 3 =0
	MOV	BLKOUT,R5	;PAR 5
	MOV	BLKOHG,PAR4	;PAR 4
	JSR	PC,QIO		;DO READ FOR CHECK
	CLR	PAR4
	CMP	IOSTAT,#1	;READ CHECK OK ?
	BEQ	DPCKOK
	MOV	#30.,R0		;MESS # TO R0
	MOV	BLKOUT,R1	;DIGIT TO R1
	JSR	PC,DPERR	;REPORT ERROR
DPCKOK:	ADD	#32.,BLKOUT	;INCREMENT STARTING BLOCK NUMBER
	ADC	BLKOHG		;DO 2 WORD MATH
	RTS	PC		;AND RETURN
.PAGE
.SBTTL	DP ERROR REPORTING SUB
;
;
;
;SUB TO REPORT DP READ OR WRITE ERROR
;
;
DPERR:	MOV	R0,R5		;SAVE START OF MESS POINTER
	MOV	R1,R0		;BLOCK COUNT TO R0
	MOV	#BLPEND,R3	;R3 POINTS AT END OF ASCII BL #
	MOV	#6,R4		;USE R4 AS COUNTER
LOPCOP:	MOV	R0,R1		;NUMBER INTO R1
	CLR	R0		;CLEAR UPPER REGISTER
	DIV	#10,R0		;DIVIDE
	ADD	#60,R1		;CONVERT REMAINDER TO ASCII
	MOVB	R1,-(R3)	;STORE IN MESSAGE
	SOB	R4,LOPCOP	;DO ANOTHER IF NECC
	MOV	R5,R0		;RESTORE MESSAGE POINTER
	MOV	BLKIHG,R4	;HIGH ORDER BLOCK NUMBER
	BIS	BLKOHG,R4	;USE OR CAUSE MAY NOT BE DP TO DP
	ASH	#1,R4		;NOW IT MATCHES MOST SIGNIF OCTAL DIGIT
	BISB	R4,BLPBUF	;FIRST DIGIT OF BL# NOW FULL 3-BIT SIGNIFICANT
	MOV	#1,R1		;INDICATE INSERTED MESSAGE
	MOV	#BLPBUF,R2	;START INTO R2
	MOV	#7,R3		;BYTE COUNT TO R3
	JSR	PC,ERRQIO	;WRITE ERROR MESSAGE
	INC	ERRCNT		;COUNT THE ERROR
	RTS	PC		;AND RETURN
;
;
BLPBUF:	.ASCII	/000000/
	.EVEN
BLPEND:
.PAGE
.SBTTL	SUBS TO READ/WRITE FOR MT
;SUBROUTINE TO READ FROM MAG-TAPE
MTREAD:	MOV	#IO.RLB,R0	;READ CODE TO R0
	MOV	#2,R1		;INPUT LUN TO R1
	MOV	#BUFFER,R2	;BUFFER START
	MOV	MTSIZE,R3	;BYTE COUNT
	JSR	PC,QIO		;DO QIO
	CMP	IOSTAT,#1	;SUCCESSFUL ?
	BNE	MTRDNG		;NO REPORT ERROR
	RTS	PC		;YES JUST RETURN
MTRDNG:	MOV	#18.,R0		;ERROR MESS # TO R0
	JSR	PC,CONCOD	;CONVERT ERROR CODE -> ASCII
	JSR	PC,ERRQIO	;WRITE ERROR MESS
	INC	ERRCNT		;COUNT AN ERROR
	SEC			;SET ERROR INDICATOR
	RTS	PC		;AND RETURN
;
;
;
;SUBROUTINE TO WRITE TO MAG-TAPE
MTWRIT:	MOV	#IO.WLB,R0	;WRITE IO CODE
	MOV	#1,R1		;OUTPUT LUN TO R1
	MOV	#BUFFER,R2	;BUFFER START
	MOV	MTSIZE,R3	;BYTE COUNT
	JSR	PC,QIO		;DO WRITE
	CMP	IOSTAT,#1	;WENT OK ?
	BNE	MTWTNG		;NO REPORT ERROR
	RTS	PC		;YES RETURN FROM SUB
MTWTNG:	MOV	#16.,R0		;ERROR # TO R0
	JSR	PC,CONCOD	;CONVERT ERROR CODE -> ASCII
	JSR	PC,ERRQIO	;WRITE ERROR MESS
	INC	ERRCNT		;COUNT AN ERROR
	SEC			;SET ERROR INDICATOR
	RTS	PC		;AND RETURN
;
;SUB TO CONVERT ERROR CODE TO ASCII AND SET TO INSERT INTO ERROR MESSAGE
;
CONCOD:	MOV	IOSTAT,R4	;CODE TO R4
	MOV	#6,R3		;CHARACTER COUNT ->R3
	MOV	#NUMBUF+6,R2	;INITIALIZE POINTER
1$:	MOV	R4,R5		;SET FOR DIVIDE
	CLR	R4
	DIV	#10,R4		;REM IN R5
	ADD	#60,R5		;CONVERT TO ASCII
	MOVB	R5,-(R2)	;INSERT IN BUFFER
	SOB	R3,1$		;LOOP TILL 6 DONE
				;R2 ALREADY SET FOR ERROR REPORT SUB
	MOV	#6,R3		;NUMBER OF CHARACTERS TO INSERT IN R3
	MOV	#1,R1		;SET FLAG FOR TEXT TO BE INSERTED
	RTS	PC		;DONE
;
;BUFFER FOR CONVERSION FROM OCTAL TO ASCII
NUMBUF:	.ASCII	/000000/
;
;
;
.PAGE
.SBTTL	DOS/RSX DATE CONVERTER
;
;SUBROUTINE TO CONVERT  RSX DATE TO DOS
;
;RSX DATE FROM SUB IS YEAR (SINCE 1900),MONTH, DAY AS
;SEPERATE OCTAL VARIABLES
;DOS DATE IS AN INTEGER
;DOS DATE=1000*(YEAR-1970)+# OF DAYS SO FAR THIS YEAR
;
;
DOSDAT:	MOV	#DATTIM,R1	;BUFFER START TO R1
	MOV	(R1)+,R5	;YEAR IN R5
	BIT	#3,R5		;IS YEAR DIVISIBLE BY 4?
	BNE	NOTLPY		;NO ITS NOT LEAPYEAR
	INCB	DAYSMO+2	;INCREMENT # OF DAYS IN FEB TO 29
NOTLPY:	SUB	#70.,R5		;SUBTRACT (19)70
	MUL	#1000.,R5	;MUL BY 1000 (DECIMAL)
	MOV	(R1)+,R2	;# OF CURRENT MONTH IN R2
	MOV	#DAYSMO,R3	;USE R3 AS POINTER
ADDAMO:	MOVB	(R3)+,R4	;GET # OF DAYS IN R4
	ADD	R4,R5		;ADD TO DATE
	SOB	R2,ADDAMO	;IF NOT DONE, DO ANOTHER
	MOV	(R1)+,R2	;NOW GET DAY IN R2
	ADD	R2,R5		;AND ADD IT
	MOV	R5,(R0)+	;SAVE DOS DATE
	MOVB	#28.,DAYSMO+2	;SET FEB BACK TO 28 FOR NEXT TIME
	RTS	PC		;AND RETURN
;
;
;TABLE (BYTE OF # OF DAYS TO ADD FOR EACH (COMPLETED) MONTH
;
DAYSMO:	.BYTE	0.,31.,28.,31.,30.,31.,30.,31.,31.,30.,31.,30.
;
;SUBROUTINE TO TRANSFER N ASCII CHARACTERS FROM ONE BUFFER TO ANOTHER
;
;CALLING SEQUENCE
;
;R0	POINTS TO SOURCE CHARACTER BUFFER
;R1	POINTS TO DEST.  CHARACTER BUFFER
;R2	CONTAINS # OF ASCII BYTES TO TRANSFER
;
;
XFERBT:	TST	R2		;CHECK BYTE COUNT
	BEQ	XFEROV		;IF ZERO, JUST RETURN
XFER1B:	MOVB	(R0)+,(R1)+	;TRANSFER A BYTE
	SOB	R2,XFER1B	;IF NOT DONE, XFER ANOTHER
XFEROV:	RTS	PC		;IF DONE, JUST RETURN
;
;
;
;
;
.PAGE
.SBTTL	ERROR MESSAGE ROUTINES
;ROUTINE TO SEND AN ERROR MESSAGE TO THE OPERATOR'S TERMINAL
;ROUTINE WILL SEND A MESSAGE (REFERRED TO BY THE NUMBER OF THE
;MESSAGE IN  THE MESSAGE TABLE) TO THE OPERATOR, OPTIONALLY INCLUDING
;SPECIAL ASCII CODES (SUCH AS A DEVICE AND UNIT NUMBER) IN THE ASCII
;TEXT. CALLING CONDITIONS ARE
;
;R0=	MESSAGE NUMBER
;R1=	1  TO INDICATE AN ASCII STRING SHOULD BE INSERTED INTO
;	THE ERROR MESSAGE
;R2=	POINTER TO STRING TO BE INSERTED
;R3=	NUMBER OF BYTES TO BE INSERTED INTO MESSAGE STRING
;
;THE ROUTINE WILL INSERT TEXT (IF REQUIRED) INTO A POINT IN THE
;MAIN MESSAGE AT A POINT DETERMINED BY THE NEXT ENTRY IN THE 
;MESSAGE START TABLE
;
;
ERRQIO:	TST	R1		;ANY SUB MESSAGE TO BE INSERTED ?
	BEQ	NOINSE		;NOTHING TO INSERT
	MOV	R0,R4		;GET MESSAGE # IN R4
	INC	R4		;BUMP TO NEXT MESSAGE TABLE ENTRY
	ASH	#1,R4		;CONVERT TO A WORD OFFSET
	ADD	#MESSST,R4	;AD BASE OF TABLE
	MOV	(R4),R4		;R4 NOW POINTS AT SUB BUFFER TO BE FILLED
XFERCH:	MOVB	(R2)+,(R4)+	;TRANSFER A CHARACTER
	SOB	R3,XFERCH	;NOT DONE ?, DO ANOTHER
NOINSE:	;HERE IF SUB MESSAGE DONE OR NOT NEEDED
	ASH	#1,R0		;CONVERT R0 TO WORD OFFSET
	MOV	R0,R2		;SET R0 INTO R2
	MOV	R0,R3		;AND INTO R3
	ADD	#MESSST,R2	;ADD MESSAGE START TABLE BASE
	MOV	(R2),R2		;R2 NOW POINTS AT MESSAGE START
	ADD	#MESSLN,R3	;ADD MESSAGE LENGTH TABLE BASE TO R3
	MOV	(R3),R3		;R3 NOW CONTAINS BYTE COUNT
	MOV	#40,R4		;CARRIAGE CTL CODE TO R4
	MOV	#IO.WLB,R0	;SET IO CODE IN R0
	MOV	#3,R1		;SET LOGICAL UNIT # INTO R1
	JSR	PC,QIO		;AND DO A QIO TO THE TTY
	RTS	PC		;AND RETURN WHEN DONE
;
;
.PAGE
.SBTTL	ERROR MESSAGES
;
;FOLLOWING ARE THE MESSAGE BUFFERS
;BUFFERS WITH A TAG OF THE FORM (ERR3BF:) ARE THE SECOND HALF OF
;THE PREVIOUS BUFFER USED FOR LOADING DEVICE NAMES ETC INTO THE MESSAGE
;
PROMPT:	.ASCII	/ROL>/		;#0
ABORT:	.ASCII	/*** ROL Aborted due to error count exceeded/	;#1
	.EVEN
ERR1:	.ASCII	/*** ROL Bad output device name/ ;#2
ERR2:	.ASCII	/*** ROL Bad input device name/ ;#3
ERR3:	.ASCII	/*** ROL Failed to assign  /	;#4
ERR3B:	.ASCII	/XX0:/			;#5
ERR4:	.ASCII	/*** ROL Failed to attach  /	;#6
ERR4B:	.ASCII	/XX0:/			;#7
ERR5:	.ASCII	/*** ROL No such file on tape/	;#8
	.EVEN
ERR6:	.ASCII	/*** ROL Non-dos header--file skipped/	;#9
	.EVEN
ERR7:	.ASCII	/*** ROL Failed to detach  /	;#10.
ERR7B:	.ASCII	/XX0:/			;#11.
ERR10:	.ASCII	/*** ROL Bad device on input line/	;#12.
	.EVEN
ERR11:	.ASCII	\*** ROL Can't find/write eov on magtape\	;#13.
	.EVEN
ERR12:	.ASCII	/*** ROL Bad magtape file name/		;#14.
	.EVEN
ERR13:	.ASCII	/*** ROL Error writing tape header/	;#15.
	.EVEN
ERR14:	.ASCII	/*** ROL Write failure on tape--status= /	;#16.
ERR14P:	.ASCII	/000000/			;#17.
	.EVEN
ERR15:	.ASCII	/*** ROL read  failure on tape--status= /	;#18.
ERR15P:	.ASCII	/000000/			;#19.
	.EVEN
ERR16:	.ASCII	/*** ROL Write failure on disk starting at block #/	;#20.
ERR17:	.ASCII	/ 00000/			;#21.
ERR18:	.ASCII	/*** ROL Read failure on disk starting at block #/	;#22.
ERR19:	.ASCII	/ 00000/			;#23.
ERR20:	.ASCII	/*** ROL Illegal function for non privileged terminal/	;#24.
	.EVEN
ERR21:	.ASCII	?*** ROL Can only xfer DP/DR to DP/DR or MM tape?	;#25.
	.EVEN
ERR22:	.ASCII	?*** ROL Write failure on DP/DR starting at block #?	;#26.
ERR22P:	.ASCII	/000000/			;#27.
	.EVEN
ERR23:	.ASCII	?*** ROL Read  failure on DP/DR starting at block #?	;#28.
ERR23P:	.ASCII	/000000/			;#29.
	.EVEN
ERR24:	.ASCII	?*** ROL Write check error on DP/DR starting at block #?;#30.
ERR24P:	.ASCII	/000000/			;#31.
	.EVEN
ERR25:	.ASCII	/*** ROL Write check error on disk starting at block #/	;#32.
ERR25P:	.ASCII	/000000/			;#33.
	.EVEN
ERR26:	.ASCII	/*** ROL Must have 6-character tape file name/	;#34.
	.EVEN
ERR27:	.ASCII	/*** ROL Can not restore to DP0: or DP1:/	;#35.
	.EVEN
ERR30:	.ASCII	/*** ROL Warning *** last 80 blocks may be lost /
	.ASCII	/if source was DR disk/				;#36.
	.EVEN
ERR31:	.ASCII	/*** ROL Warning unknown switch, ignored/	;#37.
	.EVEN
ERREND:	.WORD	0
.PAGE
.SBTTL	MESSAGE LENGTH TABLE
;
;
;NOW A TABLE OF THE LENGTHS OF THE ABOVE MESSAGES
;
;
MESSLN:	.WORD	ABORT-PROMPT
	.WORD	ERR1-ABORT
	.WORD	ERR2-ERR1
	.WORD	ERR3-ERR2
	.WORD	ERR4-ERR3
	.WORD	0		;A DUMMY FOR ERROR 3B
	.WORD	ERR5-ERR4
	.WORD	0		;A DUMMY FOR ERROR 4B
	.WORD	ERR6-ERR5
	.WORD	ERR7-ERR6
	.WORD	ERR10-ERR7
	.WORD	0		;A DUMMY FOR ERROR 7B
	.WORD	ERR11-ERR10
	.WORD	ERR12-ERR11
	.WORD	ERR13-ERR12
	.WORD	ERR14-ERR13
	.WORD	ERR15-ERR14
	.WORD	0		;DUMMY FOR ERR14P
	.WORD	ERR16-ERR15
	.WORD	0		;DUMMY FOR ERR15P
	.WORD	ERR18-ERR16
	.WORD	0		;DUMMY LENGTH FOR INSERTED TEXT
	.WORD	ERR20-ERR18
	.WORD	0			;A DUMMY FOR THE ADDED MESS
	.WORD	ERR21-ERR20
	.WORD	ERR22-ERR21
	.WORD	ERR23-ERR22
	.WORD	0		;DUMMY
	.WORD	ERR24-ERR23
	.WORD	0		;DUMMY
	.WORD	ERR25-ERR24
	.WORD	0		;DUMMY
	.WORD	ERR26-ERR25
	.WORD	0
	.WORD	ERR27-ERR26
	.WORD	ERR30-ERR27
	.WORD	ERR31-ERR30
	.WORD	ERREND-ERR31
.PAGE
.SBTTL	TABLE OF MESSAGE START POINTERS
;
;
;NOW THE TABLE OF MESSAGE START POINTERS
;
MESSST:	.WORD	PROMPT
	.WORD	ABORT
	.WORD	ERR1
	.WORD	ERR2
	.WORD	ERR3
	.WORD	ERR3B
	.WORD	ERR4
	.WORD	ERR4B
	.WORD	ERR5
	.WORD	ERR6
	.WORD	ERR7
	.WORD	ERR7B
	.WORD	ERR10
	.WORD	ERR11
	.WORD	ERR12
	.WORD	ERR13
	.WORD	ERR14
	.WORD	ERR14P
	.WORD	ERR15
	.WORD	ERR15P
	.WORD	ERR16
	.WORD	ERR17
	.WORD	ERR18
	.WORD	ERR19
	.WORD	ERR20
	.WORD	ERR21
	.WORD	ERR22
	.WORD	ERR22P
	.WORD	ERR23
	.WORD	ERR23P
	.WORD	ERR24
	.WORD	ERR24P
	.WORD	ERR25
	.WORD	ERR25P
	.WORD	ERR26
	.WORD	ERR27
	.WORD	ERR30
	.WORD	ERR31
;
.PAGE
.SBTTL	SUB DO DO QIO'S
;
;
;SUBROUTINE TO SET UP A DIRECTIVE PARAMETER BLOCK AND
;DO A QIO
;USED BY ALL PARTS OF THE PROGRAM
;CALLING SET UP IS
;
;R0=	IO CODE
;R1=	LOGICAL DEVICE NUMBER
;R2=	POINTER TO START OF BUFFER
;R3=	BUFFER LENGTH (IN BYTES)
;R4=	PARAMETER 3
;R5=	PARAMETER 5
;
;
QIO:	MOV	R0,IOCODE	;LOAD IO CODE INTO DPB
	MOV	R1,IOLUN	;AND LUN #
	MOV	R2,PAR1		;LOAD PARAMETER #1
	MOV	R3,PAR2		;LOAD PARAMETER #2
	MOV	R4,PAR3		;LOAD PARAMETER #3
	MOV	R5,PAR5		;LOAD PARAMETER 5
	MOV	#QIOWT,-(SP)	;START OF DPB ONTO STACK
	EMT	377		;GO TRAP
	RTS	PC		;AND RETURN WHEN DONE
;
;
;
;THIS IS THE DIRECTIVE PARAMETER BLOCK FOR THE QIO SUBROUTINE
;
;
QIOWT:	.BYTE	3,12.		;WAIT QIO CODE AND BLOCK SIZE
IOCODE:	.WORD	0		;I/O CODE
IOLUN:	.WORD	0		;LOGICAL UNIT #
IOEVPR:	.BYTE	1,100.		;EVENT FLAG & PRIORITY
IOSADD:	.WORD	IOSTAT		;ADDRESS OF IOSTATUS BLOCK
IODAST:	.WORD	0	
	;NO ASYNC TRAP ON DONE
PAR1:	.WORD	0		;FIRST DEV PARAMETER
PAR2:	.WORD	0		;AND THE REST
PAR3:	.WORD	0
PAR4:	.WORD	0
PAR5:	.WORD	0
PAR6:	.WORD	0
;
.PAGE
.SBTTL	MISC DATA AREAS
;
;
;
;NOW THE DIRECTIVE PARAMETER BLOCK FOR ASSIGN
;
;
ASGDPB:	.BYTE	7,4		;DIRECTIVE CODE & BLOCK SIZE
ASGLUN:	.WORD	0		;LOGICAL UNIT #
ASGNAM:	.WORD	0		;TWO CHAR DEV NAME
ASGNUM:	.WORD	0		;DEVICE NUMBER
;
;
;
;
;
;NOW SOME VARIABLES
;
;
DATTIM:	.BLKW	8.		;BUFFER TO RECEIVE DATE/TIME
DATDOS:	.WORD	0		;BUFFER FOR DOS DATE
OUTATT:	.WORD	0		;ATTACH OUT DEV BUFFER
INPATT:	.WORD	0		;ATTACH INP DEV BUFFER/FLAG
OUTNMO:	.WORD	0		;OCTAL OUTPUT DEV #
INPNMO:	.WORD	0		;INPUT DEV #
OUTDEV:	.WORD	0		;OUTPUT DEVICE NAME (ASCII)
OUTNUM:	.WORD	0		;OUTPUT DEVICE NUMBER (ASCII)
INPDEV:	.WORD	0		;INPUT DEVICE NAME
INPNUM:	.WORD	0		;INPUT DEVICE NUMBER
FILEIN:	.WORD	0,0,0		;INPUT FILE NAME
	.ASCII	/ROL/		;ROLLIN EXTENSION FOR TAPE READ
	.EVEN
FILEOU:	.WORD	0,0,0		;OUTPUT FILE NAME
	.ASCII	/ROL/		;EXT FOR MT WRITE
	.EVEN
MTNAME:	.WORD	0,0,0,0,0	;FOR FILENAME COMPARISON
MTSIZE:	.WORD	8192.		;SIZE OF MT TRANSFER
BLKINP:	.WORD	0		;STARTING BLOCK FOR DK READ
BLKIHG:	.WORD	0		;HIGH BLOCK NUMBER FOR DP READ
BLKOUT:	.WORD	0		;STARTING BLOCK FOR DK WRITE
BLKOHG:	.WORD	0		;HIGH BLOCK NUMBER FOR DP WRITE
OVFLAG:	.WORD	0		;DON'T POSITION TO EOT BEFORE STARTING WRITE
CKFLAG:	.WORD	0		;FLAG FOR DISK READ AFTER WRITE CHECK
LOOPCT:	.WORD	0		;COUNT FO LOOPS
LOOTOT:	.WORD	0		;MAX LOOP COUNT FOR DK/DP
IOSTAT:	.WORD	0		;IO STATUS BLOCK
IOSTA2:	.WORD	0		;2ND HALF
JSTAT:	.WORD	0		;DIRECTIVE STATUS
ERRCNT:	.WORD	0		;IO ERROR COUNTER
UIC:	.BYTE	1,1		;UIC (GROUP, OWNER)
PCODE:	.WORD	233		;PROTECTION CODE
ENDOVF:	.WORD	0		;END OF VOLUME FLAG FOR MT
MCRFLA:	.WORD	0		;FLAG FOR MCR ONE LINE COMMMAND
MCRFL1:	.WORD	0
GETMCR:	GMCR$			;GET MCR DPB AND BUFFER
BUFFER:	.BLKW	8200.		;4K READ/WRITE BUFFER (PLUS 4 EXTRA WORDS)
	.END	START
;
;