.TITLE	MTIO NON-FILE STRUCTURED MAG TAPE I/O PROGRAM

;Written by	D. H. Walesby MSc  T63D
;		J.S.R.U. Benhall Cheltenham
;Date		09/10/79 Version 1
;		17/04/80 V2 		Writing facilities
	.IDENT	/VER01A/

	.ENABL	LC
	.NLIST	TTM,BEX,CND,MD
	.MCALL	.EXIT,.FETCH,.PRINT,.LOOKUP,.SPFUN,.CSISPC,.SERR
	.MCALL	.SETTOP,.CLOSE,.WAIT,.WRITW,.GTLIN,.RCTRLO,.ENTER
	.MCALL	.READW

	.SBTTL	MACRO DEFINITIONS
;MACRO TYPETX DEALS WITH A TEXT STRING FOR OUTPUT
;$ADDR	IF PRESENT ADDRESS OF START OF STRING
;$LOC	WORD SELECTING DESTINATION

.MACRO	TYPETX	$ADDR,$LOC,?$LAB
	.IF	NB,$ADDR
	MOV	$ADDR,R0
	.ENDC
	.IF	NB,$LOC
	MOV	$LOC,$LAB
	.ENDC
	JSR	R5,PTOUT
$LAB:	.WORD	TOTERM
	.ENDM	TYPETX

;MACRO TYPEBK DEALS WITH SECTION & BLOCK TITLE FOR OUTPUT
;$LOC	WORD SELECTING DESTINATION

.MACRO	TYPEBK	$LOC
	.IF	NB,$LOC
	MOV	$LOC,PBLDIR
	.IFF
	MOV	#1,PBLDIR
	.ENDC
	JSR	PC,PBLOCK
	.ENDM	TYPEBK

;MACRO TYPENO DEALS WITH A NUMBER TO BE OUPUT AS DECIMAL
;$ADDR	IF PRESENT ADDRESS OF THE NUMBER
;$LOC	WORD SELECTING DESTINATION

.MACRO	TYPENO	$NUMB,$LOC
	.IF	NB,$NUMB
	MOV	$NUMB,R1
	.ENDC
	.IF	NB,$LOC
	MOV	$LOC,VALCDE
	.IFF
	MOV	#TOTERM,VALCDE
	.ENDC
	JSR	PC,VALR1
	.ENDM

;MACRO .CNDEX  TESTS TO SEE IF $FLAG SET IN COMAND, IF IT IS
;IT EXECUTES $PROC ELSE IT AVOIDS IT
;$FLAG	BIT IN FORMAT
;$PROC	APPROPRIATE ROUTINE
;$LAB1	OPTIONAL ADDRESS IF ERROR FROM ROUTINE
;$LAB2	OPTIONAL ADDRESS IF ROUTINE SUCCESSFUL

.MACRO	.CNDEX	$FLAG,$PROC,$LAB1,$LAB2,?B
	BIT	#$FLAG,FORMAT
	BEQ	B
	JSR	PC,$PROC
.IIF NB $LAB1	BCS	$LAB1
.IIF NB $LAB2	BR	$LAB2
B:
	.ENDM	.CNDEX

	.SBTTL	BIT DEFINITIONS
PSW	=	177776	;PROCESSOR STATUS WORD ADDRESS
ERRWRD=	52	;MONITOR'S LOCATION TO GIVE ADDITIONAL ERROR INFO
MTCHAN=	16	;CHANNEL NUMBER MT USED ON
CR	=	15
LF	=	12
SPC	=	40	;SPACE CHARACTER

;CODES USED TO DIRECT ANALYSIS TO DIFFERENT OUTPUT PLACES
TOFILE	=	1	;FLAG TO INDICATE DATA TO OUTPUT FILE
TOTERM	=	2	;FLAG TO INDICATE TEXT TO BE PRINTED
TOSAVE	=	4	;FLAG TO INDICATE TEXT TO BE STORED
EITH	=	10	;FLAG TO INDICATE TXT GOES AS DIRECTED BY USER
FORMNO	=	20	;FLAG TO INCATE FORMATTED NUMBERS REQUIRED
BOTH	=	TOFILE!TOTERM

;CODES USED TO INDICATE FILE FORMATS FOR DUMPING AND OUTPUTTING
OASC	=	1	;ASCII PRINTING
OEBC	=	2	;EBCDIC PRINTING
OBYT	=	4	;BYTE PRINTING
OWRD	=	8.	;WORD PRINTING
OBIT	=	16.	;BIT PRINTING
OIBM	=	32.	;IBM PRINTING
ORAD	=	64.	;RAD50 PRINTING

;FUNCTION IDENTIFIERS FOR REMEMBERING LAST FUNCTION THAT OCCURRED
ZNT	=	1	;NO TAPE
ZTB	=	2	;TAPE BLANK
ZTM	=	4	;TAPE MARK
ZTMET	=	8.	;TAPE MARK & END OF TAPE
ZET	=	16.	;END OF TAPE
ZBT	=	32.	;BEGINNING OF TAPE
ZHW	=	64.	;HARDWARE ERROR
ZWL	=	128.	;TAPE WRITE LOCKED
ZNX	=	256.	;NON EXISTANT MEMORY
ZOT	=	512.	;OTHER
ZOK	=	1024.	;READ OK
ZTS	=	2048.	;NOT ENOUGH MEMORY FOR READ

;BITS TO FLAGS SWITCHES FOUND SO THAT THEY MAY BE DONE IN CORRECT ORDER
BBIT	=	1	;MOVE TO BLOCK
CBIT	=	2	;CLOSE OUTPUT FILE
RBIT	=	4	;READ FROM TAPE
SBIT	=	8.	;WIND TO SECTION
WBIT	=	16.	;WRITE TO TAPE
DBIT	=	32.	;DUMP TAPE
UBIT	=	64.	;CLOSE FILES, REWIND & GO OFF LINE
TBIT	=	128.	;WRITE TAPE MARKS

;BITS TO FLAG DUMP MODE TYPES
ZASC	=	1	;ASCII MODE
ZEBC	=	2	;EBCDIC MODE
ZIBM	=	4	;IBM MODE
ZBIT	=	8.	;BIT DUMP MODE
ZBYT	=	16.	;BYTE MODE
ZWRD	=	32.	;WORD DUMP MODE
ZDEC	=	64.	;DECIMAL DUMP MODE
ZRAD	=	128.	;RAD50 FORMAT
ZSWP	=	256.	;BYTE SWAPPING REQUIRED
ZXDC	=	512.	;EXTENDED DISPLAY CODE
ZFIL	=	1024.	;FILL LAST TAPE BLOCK/WRITE SHORT BLOCK
ZWRN	=	2048.	;WARN USER ABOUT WRITING TO TAPE
	.SBTTL	INITIATION CODE
START::	MOV	SP,SPST		;Save stack pointer
	.SERR			;CATCH SYSTEM SOFTWARE ERRORS
	.PRINT	#TITLE
	.FETCH	MTBUF,#MTNAME	;GET MAG TAPE DRIVER
	BCC	2$		;JUMP IF OK
	TSTB	@#ERRWRD	;WHICH SORT OF ERROR
	BMI	1$		;JUMP FOR SYSTEM ERRORS
	.PRINT	#NODRIV		;ELSE ISSUE MESSAGE
	.EXIT
1$:	.PRINT	#SYSER2		;PRINT MESSAGE
	.EXIT
2$:	MOV	R0,OUTFBF	;FREE CORE, START FIRST BUFFER HERE
	ADD	#1000,R0	;512. FOR THAT BUFFER
	MOV	R0,INFBUF	;SET POINTER IN INPUT FILE
	ADD	#1000,R0	;512. FOR THAT BUFFER
	MOV	R0,DATABF	;SET POINTER FOF DATA BUFFER
	ADD	#1000,R0	;BUFFER 512 LONG
	MOV	R0,MTBUF		;SAVE NEW START OF FREE MEMORY
	.LOOKUP	#EMTBUF,#MTCHAN,#MTNAME,#-1 ;NON-FILE STRUCTURED LOOKUP
	BCC	4$		;JUMP IF NO ERRORS
	MOVB	@#ERRWRD,R1	;SYSTEM ERROR WORD
	BGE	3$		;CHECK FOR SYSTEM ERROR
	.PRINT	#SYSERR		;PRINT MESSAGE FOR SYSTEM ERROR
	.EXIT
3$:	ASL	R1		;DOUBLE FOR WORD OFFSET
	.PRINT	MS1TAB(R1)	;PRINT APPROPRIATE MESSAGE
	.EXIT
4$:	.SPFUN	#EMTBUF,#MTCHAN,#373,#0,#0,#0,#1	;REWIND TAPE
	BCC	AGAIN
	.PRINT	#RWFAIL
	.SBTTL	MAIN COMMAND LOOP & SWITCH HANDLING
AGAIN:	MOV	SPST,SP		;RESET STACK POINTER
	CLR	FVAL		;STARTING POSITION IN BLOCK
	CLR	COMAND		;LAST CONFIGURATION OF SWITCHES
	CLRB	OFLG		;SET IF DUMP TO TERMINAL & FILE
	.RCTRLO
	.CSISPC	#FNAMES,#DEFLT,#0
	BCS	AGAIN
	MOV	(SP)+,R5	;GET NUMBER OF SWITCHES
	BEQ	NOSWTS		;NO SWITCHES SO JUMP
SWTLOP:	MOV	(SP)+,R0
	BPL	1$
	MOV	(SP)+,R1	;GET VALUE INTO R1
1$:	MOVB	R0,R4
	SUB	#'A,R4		;CHECK SWITCH IS IN RANGE
	BLT	SWTERR
	CMPB	#'Z,R4
	BLT	SWTERR
	ASL	R4
	TST	R0		;SET CONDITION FLAGS FOR SWITCH VALUE
	JSR	PC,@SWTAB(R4)	;GO TO RELEVANT SWITCH PROCESSING
	BCC	SWTOK		;CARRY CLEAR FOR NO ERROR

ASWT:ESWT:ISWT:JSWT:KSWT:NSWT:QSWT:XSWT:YSWT:ZSWT:

SWTERR:	.PRINT	#ILLSWT		;NOR RECOGNISED SO ERROR
AGAIN1:	BR	AGAIN
SWTOK:	DEC	R5		;COUNT OF SWITCHES
	BNE	SWTLOP		;ZERO WHEN ALL DONE
	.SBTTL	DATA OUTPUT FILE OPENING
NOSWTS:	TST	FNAMES		;ANY OUTPUT FILE
	BEQ	5$
	.WAIT	#0
	BCS	1$
	JSR	PC,DATACL	;CLOSE LAST DATA FILE & RELEASE DRIVER
1$:	.FETCH	MTBUF,#FNAMES	;GET DRIVER
	BCC	2$
	.PRINT	#NOOUTD		;NO OUTPUT FILE DRIVER
	BR	AGAIN
2$:	MOV	R0,MTBUF	;START OF MAG TAPE BUFFER
	MOV	DATABF,DATAPT	;RESET POSITION IN DATA BUFFER ADDRESS
	CLR	DATABK		;BLOCK NUMBER FOR DATA FILE
	MOV	#512.,DATACT	;COUNT IN DATA BUFFER
	.ENTER	#EMTBUF,#0,#FNAMES,FNAMES+10
	BCC	4$		;JUMP IF NO ERRORS
	MOVB	@#ERRWRD,R0
	BGE	3$
	.PRINT	#DIRERR		;DIRECTORY ERROR
	BR	AGAIN
3$:	.PRINT	#FULUSE		;OUTPUT FILE FULL OR IN USE
	BR	AGAIN
4$:	BIT	#CBIT,COMAND	;HAS CLOSE BEEN SPECIFIED
	BNE	5$		;YSE SO JUMP
	TYPETX	#WARNCL		;WARN USE TO CLOSE FILE

	.SBTTL	DATA INPUT FILE OPENING
5$:	TST	FNAMES+36	;ANY INPUT FILE
	BEQ	9$
	.WAIT	#3
	BCS	6$
	.CLOSE	#3		;CLOSE LAST DATA INPUT FILE
6$:	.FETCH	MTBUF,#FNAMES+36	;GET DRIVER
	BCC	7$
	.PRINT	#NOIFDR		;NO INPUT FILE DRIVER
	BR	AGAIN1
7$:	MOV	R0,MTBUF	;START OF MAG TAPE BUFFER
	CLR	INFBLK		;BLOCK NUMBER FOR DATA FILE
	CLR	INFCNT		;COUNT IN DATA BUFFER
	.LOOKUP	#EMTBUF,#3,#FNAMES+36
	MOV	R0,FILEN	;STORE FILE LENGTH
	BCC	9$		;JUMP IF NO ERRORS
	MOVB	@#ERRWRD,R0
	BGE	8$
	.PRINT	#IFDERR		;DIRECTORY ERROR
	BR	AGAIN1
8$:	.PRINT	#IFFNF		;INPUT FILE NOT FOUND OR IN USE
	BR	AGAIN1

9$:	BIT	#WBIT!TBIT,COMAND ;CHECK IF WRITING TO TAPE
	BEQ	11$		;JUMP IF NOT
	BIT	#ZWRN,FORMAT	;HAS USER BEEN WARNED
	BNE	12$		;JUMP IF HE HAS
	.PRINT	#WRNDNG		;WARN HIM OF THE DANGER
	BIS	#ZWRN,FORMAT	;PREVENT MESSAGE APPEARING AGAIN
12$:	.GTLIN	#FNAMES,#WTTOTP	;ASK USER IF SURE WANTS TO WRITE TO TAPE
	CMPB	#'Y,FNAMES	;REPLY Y TO CONTINUE
	BEQ	11$
	JMP	AGAIN
11$:	.SETTOP	#-2		;GET ALL AVAILABLE CORE
	SUB	MTBUF,R0	;LENGTH OF BUFFER IN BYTES
	ROR	R0		;IN WORDS
	MOV	R0,MTBLEN
	.SBTTL	S SWITCH-WIND TO SECTION
SCMD:	BIT	#SBIT,COMAND	;WAS S SWITCH TYPED
	BEQ	NOS		;JUMP IF NONE
	CLR	MTBLK		;CLEAR BLOCK NUMBER
	MOV	#376,SPFCDE	;SET SPECIAL FUNCTION CODE
	MOV	SVAL,R4		;GET SWITCH VALUE,REWIND IF ZERO
	BNE	1$		;NOT ZERO SO JUMP
	MOV	#373,SPFCDE	;REWIND CODE
	JSR	PC,MOVTAP	;MOVE TAPE
	BIT	#ZBT,LSTFNC	;THIS SHOULD GIVE BOT ERROR
	BNE	NOS		;YES SO OKAY
	BR	6$		;NO SO ANALYSE ERROR
1$:	SUB	MARKNO,R4	;GET NUMBER OF SECTIONS TO MOVE
	BGT	2$
	MOV	#375,SPFCDE	;SET SPECIAL FUNCTION CODE
	DEC	R4		;ONE EXTRA ON REVERSE
2$:	MOV	#-2,SPFLEN	;SET NUMBER OF SECTIONS TO SPACE OVER
3$:	MOV	R4,-(SP)	;SAVE COUNT
	JSR	PC,MOVTAP	;SKIP ONE TAPE MARK
	MOV	(SP)+,R4	;GET COUNT
	BIT	#^CZTM,LSTFNC	;SHOULD HAVE LAST FUNC AS TAPE MARK
	BNE	6$
	TST	R4		;ARE WE GOING FORWARD OR BAK
	BMI	4$
	INC	MARKNO		;FORWARD SPACE SO UP TAPE MARK COUNT
	DEC	R4		;DEC COUNT OF SKIP COUNT
	BNE	3$
	BR	NOS
4$:	DEC	MARKNO		;REVERSE SPACE SO DEC TAPE MARK COUNT
	INC	R4		;IN SKIP COUNT
5$:	BNE	3$		;LOOP WHILE COUNT NOT ZERO
	JSR	PC,SKIPTM	;PASSED TAPE MARK SO GO BACK OVER IT
	BCS	6$		;ERROR IF CARRY SET
	INC	MARKNO		;GONE BACK OVER REQ ONE
	BR	NOS
6$:	MOV	#SLASHS,R5	;PRINT MESSAGE APPROPRIATE TO ERROR
	JSR	PC,ANAERR

	.SBTTL	B SWITCH-WIND TO BLOCK
NOS:	BIT	#BBIT,COMAND	;WAS B SWITCH TYPED
	BEQ	NOB		;JUMP IF NONE
	MOV	#376,SPFCDE	;SET SPECIAL FUNCTION CODE
	MOV	BVAL,R4		;GET SWITCH VALUE
	SUB	MTBLK,R4	;GET NUMBER OF BLOCKS TO MOVE
	MOV	R4,SPFLEN	;SET NUMBER OF BLOCKS TO SPACE OVER
	BEQ	NOB		;NOTHING TO DO
	BGT	1$
	MOV	#375,SPFCDE	;SET SPECIAL FUNCTION CODE
	NEG	SPFLEN		;MAKE BLOCK SKIP COUNT POSITIVE
1$:	JSR	PC,MOVTAP	;SKIP ONE TAPE MARK
	BIT	#ZOK,LSTFNC	;SHOULD HAVE OK ERROR
	BEQ	2$
	ADD	R4,MTBLK	;UPDATE BLOCK NUMBER
	BR	NOB
2$:	MOV	#SLASHB,R5	;PRINT MESSAGE APPROPRIATE TO ERROR
	JSR	PC,ANAERR
	BIT	#ZTM,LSTFNC	;SHOULD HAVE LAST FUNC AS TAPE MARK
	BEQ	NOB
	TST	R4
	BMI	3$
	INC	MARKNO		;FORWARD SPACE SO UP TAPE MARK COUNT
	BR	NOB
3$:	JSR	PC,SKIPTM	;REVERSED OVER TAPE MARK SO FORWARD
	BCC	NOB		
4$:	MOV	#SLASHB,R5	;PRINT MESSAGE APPROPRIATE TO ERROR
	JSR	PC,ANAERR
	.SBTTL	DUMP COMMAND
;THIS CODE DOES DUMPING TO TERMINAL AND/OR FILE

NOB:	BIT	#DBIT,COMAND	;IS A DUMP REQUIRED
	BNE	2$
1$:	JMP	NOD
2$:	MOV	FVAL,FVALT	;SAVE STARTING VALUE IN BLOCK
	TST	FNAMES+12	;IS THERE A DUMP FILE NAME
	BEQ	6$
	.FETCH	MTBUF,#FNAMES+12;GET DRIVER
	BCC	3$
	.PRINT	#NODMPD		;COMPLAIN TO USER
	JMP	NOCLOD
3$:	MOV	R0,MTBUF	;NEW START
	.SETTOP	#-2		;FIND OUT TOP OF MEMORY
	SUB	MTBUF,R0	;FREE SPACE IN BYTES
	ROR	R0		;HALVE FOR WORDS, CARRY CLEAR
	MOV	R0,MTBLEN	;MAXIMUM READ LENGTH
	.ENTER	#EMTBUF,#1,#FNAMES+12,FNAMES+22	;OPEN DUMP FILE
	BCC	5$
	MOVB	@#ERRWRD,R0	;ANALYSE ERROR
	BGE	4$
	.PRINT	#DDIRER
	BR	1$		;JUMPS TO NOD VIA THIS JUMP
4$:	.PRINT	#DINUSE		;FILE IN USE OR FULL
	BR	1$
5$:	INCB	OUTFLG		;SET FLAG TO SAY THERE IS FILE
	MOV	OUTFBF,OUTPTR	;BUFFER ADDRESS INITIALISED
	MOV	#512.,OUTCNT	;BYTES IN BUFFER COUNTER
	CLR	OUTBLK		;OUTPUT BLOCK COUNTER
6$:	CLR	LINECT		;CLEAR COUNT OF LINES
7$:	JSR	PC,OTCRLF	;THROW LINE
	BCS	NODO
	TYPEBK	#BOTH		;OUTPUT BLOCK NUMBER
	JSR	PC,OTCRLF	
	BCS	NODO		;CARRY SET IF USER ABORTS
	JSR	PC,READ		;GET NEXT BLOCK INTO MEMORY
	BCC	9$		;CARRY SET IF ERROR
	TST	DVAL		;WAS IT NEGATIVE NO BLOCKS DUMP
	BGE	8$		;NO SO JUMP
	BIT	#ZTM,LSTFNC	;WAS LAST FUNCTION TAPE MARK
	BNE	NOD		;YES SO FINISH WITHOUT ERROR MESSAGE
8$:	MOV	#SLASHD,R5	;MESSAGE ADDRESS
	JSR	PC,ANAERR	;ANALYSE ERROR
	BR	NODO
9$:	.CNDEX	ZSWP,DMPSWP	;BYTE SWAPPING REQUIRED ?
	.CNDEX	ZEBC,DMPEBC	;IS EBCDIC DECODING REQUIRED
	.CNDEX	ZXDC,DMPXDC	;CONVERSION FROM EXTENDED DISPLAY CODE
	.CNDEX	ZIBM,DMPIBM	;IS TAPE IN IBM FORMAT
	.CNDEX	ZBIT,DMPBIT,NODO,10$;DUMPED AS BITS
	.CNDEX	ZBYT,DMPBYT,NODO,10$;DUMPED AS BYTES
	.CNDEX	ZWRD,DMPWRD,NODO,10$;DUMPED AS WORDS
	.CNDEX	ZDEC,DMPDEC,NODO,10$;DUMPED IN DECIMAL
	.CNDEX	ZRAD,DMPRAD,NODO,10$;DUMP AS RAD50 CHARS ?
	.CNDEX	ZIBM!ZASC!ZEBC!ZRAD,OUTASC,NODO	;IS BUFFER TO BE PRINTED
10$:	DEC	DVAL		;COUNT OF BLOCKS TO BE DONE
	BNE	7$
NODO:	TYPETX	#EOL,#BOTH	;END LINE IN FILE AND TERMINAL
	TSTB	OUTFLG		;WAS THERE A DUMP FILE
	BEQ	NOCLOD		;NO SO JUMP
	CLR	R0
	MOV	#511.,R1	;ELSE FORCE OUT TEXT REMAINING IN BUFFER
1$:	JSR	PC,CHROUT
	DEC	R1
	BNE	1$
	.CLOSE	#1
NOCLOD:	CLRB	OUTFLG		;INDICATE NO LONGER A FILE
	.SBTTL	READ COMMAND
;THIS CODE COPIES TAPE DATA TO FILE

NOD:	BIT	#RBIT,COMAND	;IS A DUMP REQUIRED
	BEQ	NOR
	MOV	FVAL,FVALT	;SAVE STARTING POSITION IN BLOCK
	CLR	OUTBCT		;COUNT OF PDP BLOCK READ
	.WAIT	#0		;IS THERE A DATA OUTPUT FILE
	BCC	1$
	.PRINT	#NODATF		;NO DATA FILE OPEN
	BR	NOR
1$:	JSR	PC,READ		;GET NEXT BLOCK INTO MEMORY
	BCC	3$		;CARRY SET IF ERROR
	TST	RVAL		;WAS IT NEGATIVE NO BLOCKS DUMP
	BGE	2$		;NO SO JUMP
	BIT	#ZTM,LSTFNC	;WAS LAST FUNCTION TAPE MARK
	BNE	5$		;YES SO FINISH WITHOUT ERROR MESSAGE
2$:	MOV	#SLASHR,R5	;MESSAGE ADDRESS
	JSR	PC,ANAERR	;ANALYSE ERROR
	BR	5$
3$:	.CNDEX	ZSWP,DMPSWP	;BYTE SWAPPING REQUIRED ?
	.CNDEX	ZEBC,DMPEBC	;IS EBCDIC DECODING REQUIRED
	.CNDEX	ZXDC,DMPXDC	;CONVERSION FROM EXTENDED DISPLAY CODE
	.CNDEX	ZIBM,DMPIBM	;IS TAPE IN IBM FORMAT
	.CNDEX	ZRAD,DMPRAD,NOR	;DUMP AS RAD50 CHARS ?
	MOV	MTBUF,R5
	MOV	LSTBLEN,R4
	ADD	FVALT,R5	;ADD BLOCK OFFSET
	SUB	FVALT,R4
	BLT	5$		;BEYOND END OF BLOCK SO JUMP
	CLR	FVALT		;RESET TO BEGINNING OF NEXT BLOCK
4$:	MOVB	(R5)+,R0
	JSR	PC,DATOUT	;BYTE TO OUTPUT FILE
	DEC	R4
	BNE	4$
	DEC	RVAL		;NUMBER OF BLOCKS TO READ
	BNE	1$
5$:	TYPENO	OUTBCT		;NUMBER OF PDP BLOCKS READ
	TYPETX	#OUTTX

	.SBTTL	CLOSE DATA FILE COMMAND
NOR:	BIT	#CBIT,COMAND	;IS DATA FILE TO BE CLOSED
	BEQ	NOC		;ALSO CALLED BY U SWITCH
	JSR	PC,DATACL

	.SBTTL	WRITE TO TAPE COMMAND
NOC:	BIT	#WBIT,COMAND
	BEQ	NOW
	.WAIT	#3		;IS THERE AN INPUT FILE
	BCC	2$		;YES SO JUMP
	.PRINT	#NOINFL		;GIVE MESSAGE
	BR	NOGO
2$:	CMP	#-2,WVAL	;THIS INDICATES WHOLE FILE REQUIRED
	BNE	1$
	MOV	FILEN,WVAL	;SO PUT FILE LENGTH IN WVAL
1$:	MOV	MTBUF,MBFPTR
	JSR	PC,WRIT		;EXECUTE THE COMMAND
	BCS	NOGO
	
	.SBTTL	WRITE TO TAPE MARKS COMMAND
NOW:	BIT	#TBIT,COMAND
	BEQ	NOT
1$:	MOV	#377,SPFCDE	;CODE FOR WRITE TAPE MARK
	JSR	PC,MOVTAP	;WRITE MARK
	BIT	#ZOK,LSTFNC
	BNE	2$		;CHECK NO ERRORS
	MOV	#SLASHT,R5
	JSR	PC,ANAERR	;DIAGNOSE ERROR FOR USER
	BR	NOGO
2$:	INC	MARKNO		;UP COUNT OF TAPE MARKS
	CLR	MTBLK		;CLEAR BLOCK NUMBER
	DEC	TVAL
	BNE	1$
	
	.SBTTL	UNLOAD TAPE COMMAND
NOT:	BIT	#UBIT,COMAND	;UNLOAD TAPE & EXIT
	BEQ	NOU
	MOV	#372,SPFCDE
	JSR	PC,MOVTAP	;SEND TAPE OFF LINE
	.CLOSE	#MTCHAN
	.EXIT
NOU:

NOGO:	TYPETX	#EOL,#TOTERM
	TYPEBK	#TOTERM		;TYPE BLOCK & SECTION NUMBER
	TYPETX	#EOL,#TOTERM
	JMP	AGAIN

SWTAB:	.WORD	ASWT,BSWT,CSWT,DSWT,ESWT,FSWT
	.WORD	GSWT,HSWT,ISWT,JSWT,KSWT,LSWT
	.WORD	MSWT,NSWT,OSWT,PSWT,QSWT,RSWT,SSWT
	.WORD	TSWT,USWT,VSWT,WSWT,XSWT,YSWT,ZSWT
	.SBTTL	SWITCH INTERPRETER
;SWITCHES ARE ENTERED WITH:
;R0	CONTAINING THE LETTER & VALUE FLAG
;R1	CONTAINING THE VALUE IF PRESENT
;	CONDITION CODES SET SO BPL JUMPS IF NO VALUE
;R5	HAS COUNT OF SWITCHES ON STACK
;ON EXIT:
;	CARRY SET IF ERROR

;MOVE TO BLOCK
BSWT:	BMI	1$
	CLR	R1		;DEFAULT ZERO MOVE TO FIRST BLOCK
1$:	BIS	#BBIT,COMAND
	MOV	R1,BVAL		;SAVE VALUE
	CLC
	RTS	PC

;CLOSE OUTPUT FILE
CSWT:	BIS	#CBIT,COMAND
	CLC
	RTS	PC

;DUMP BLOCK CONTENTS IN PRINTABLE FORM
DSWT:	BMI	1$		;WAS THERE A SWITCH VALUE
	MOV	#-1,R1		;NO SO PUT IN DEFAULT VALUE
1$:	MOV	R1,DVAL		;STORE VALUE AWAY
	BIS	#DBIT,COMAND	;INDICATE D SWITCH RECEIVED
	BIT	#RBIT!TBIT!WBIT,COMAND	;HAS DUMP BEEN REQUESTED AS WELL
	BEQ	2$		;NO SO JUMP
		;GIVE MESSAGE
	SEC			;RETURN ERROR
2$:	RTS	PC

;SET STARTING POSITION IN FIRST BLOCK
FSWT:	BMI	1$
	CLR	R1		;DEFAULT 0
1$:	BIC	#1,R1		;MAKE IT EVEN
	MOV	R1,FVAL		;STORE IT
	RTS	PC

;IGNORE LOGICAL END OF TAPE
GSWT:	INCB	GFLG
	CLC
	RTS	PC

;HELP
HSWT:	.PRINT	#HLPTXT
	CLC
	RTS	PC

;SET BLOCK LENGTH FOR WRITE
LSWT:	BMI	1$		;SWITCH VALUE PRESENT SO JUMP
	MOV	#512.,R1
1$:	MOV	R1,WRTLEN	;SET WRITE LENGTH
	CLC
	BIT	#1,R1		;LENGTH MUST BE EVEN
	BEQ	2$
	.PRINT	#LEVEN		;VALUE MUST BE EVEN
	SEC
2$:	RTS	PC

;MODE OF DATA (ASCII,EBCDIC ETC)
MSWT:	BMI	1$		;JUMP IF SWITCH PRESENT
	MOV	#^RASC,R1
1$:	MOV	#MSTAB,R4	;ADDRESS OF TABLE OF SWITCH VALUES
2$:	CMP	R1,(R4)+	;DOES SWITCH VALUE CORRESPOND
	BEQ	3$		;YES SO JUMP
	CMP	(R4)+,(R4)+	;ON OVER NEXT TWO TABLE ENTRIES
	TST	(R4)		;ZERO TERMINATES TABLE
	BNE	2$
	SEC
	RTS	PC
3$:	BIC	(R4)+,FORMAT	;CLEAR UNWANTED BITS
	BIS	(R4),FORMAT	;SET WANTED BITS
	RTS	PC

;TABLE OF RAD50 SWITCH VALUES FOR M SWITCH, SECOND ENTRY IS FOR
;BIC AND THIRD BIS FOR CORRESPONDING FLAGS

MSTAB:	.WORD	^RASC,ZBIT!ZBYT!ZWRD!ZIBM!ZEBC!ZDEC!ZRAD!ZXDC,ZASC
	.WORD	^RIBM,ZRAD,ZIBM
	.WORD	^RXDC,ZRAD,ZXDC
	.WORD	^REBC,0,ZEBC
	.WORD	^RRAD,ZXDC,ZRAD
	.WORD	^RSWP,0,ZSWP
	.WORD	^RBIT,ZASC!ZBYT!ZWRD!ZDEC,ZBIT
	.WORD	^RBYT,ZASC!ZBIT!ZWRD!ZDEC,ZBYT
	.WORD	^RWRD,ZASC!ZBIT!ZBYT!ZDEC,ZWRD
	.WORD	^RDEC,ZASC!ZBIT!ZWRD!ZBYT,ZDEC
	.WORD	^RNSW,ZSWP,0
	.WORD	^RNFL,0,ZFIL
	.WORD	^RFIL,ZFIL,0
	.WORD	0			;TABLE TERMINATOR

;DUMP TO TERMINAL AND FILE
OSWT:	INCB	OFLG
	RTS	PC

;PADDING BYTE FOR THE END OF FILES
PSWT:	BMI	1$		;SWITCH VALUE PRESENT SO JUMP
	CLR	R1
1$:	MOV	R1,PADBYT	;STORE PADDING CHAR
	CLC
	RTS	PC

;READ FILE
RSWT:	BMI	1$
	MOV	#-1,R1		;DEFAULT -1 (WHOLE FILE)
1$:	BIS	#RBIT,COMAND
	MOV	R1,RVAL
	BIT	#DBIT!WBIT!TBIT,COMAND	;HAS DUMP BEEN REQUESTED
	BEQ	2$		;NO SO JUMP
	.PRINT	#ILLCOM		;YES SO ILLEGAL COMBINATION
	SEC			;RETURN ERROR
2$:	RTS	PC

;MOVE TO SECTION
SSWT:	BMI	1$
	CLR	R1		;DEFAULT BEGINNING OF TAPE
1$:	BIS	#SBIT,COMAND
	MOV	R1,SVAL		;SAVE REQUIRED SECTION NUMBER
	CLC
	RTS	PC

;WRITE TAPE MARKS

TSWT:	BMI	1$		;SWITCH VALUE PRESENT SO JUMP
	MOV	#1,R1
1$:	MOV	R1,TVAL		;STORE NO OF TAPE MARKS TO WRITE
	BIS	#TBIT,COMAND
	CLC
	RTS	PC

;CLOSE FILE, REWIND TAPE AND EXIT
USWT:	BIS	#CBIT!UBIT,COMAND
	RTS	PC

;VERIFY POSITION ON TAPE
VSWT:	.PRINT	#BPB		;BYTES PER BLOCK FOR WRITING
	MOV	WRTLEN,R1
	JSR	PC,VALR1
	.PRINT	#FREMEM		;MT BUFFER SIZE
	MOV	MTBLEN,R1
	JSR	PC,VALR1
	.PRINT	#SLECT		;OPTIONS SELECTED
	MOV	#SLSWP,R0	;BYTE SWAPPING
	.CNDEX	ZSWP,TYSLE
	MOV	#SLEBC,R0	;EBCDIC DECODING/CODING
	.CNDEX	ZEBC,TYSLE
	MOV	#SLIBM,R0	;IBM FORMAT
	.CNDEX	ZIBM,TYSLE
	MOV	#SLRAD,R0	;RAD50 PACKING/UNPACKING
	.CNDEX	ZRAD,TYSLE
	MOV	#SLXDC,R0	;CDC EXTENDED DISPLAY CODE
	.CNDEX	ZXDC,TYSLE
	.PRINT	#SLDMP		;DUNP SELECTED
	MOV	#SLDEC,R0	;DECIMAL WORDS
	.CNDEX	ZDEC,TYSLE
	MOV	#SLBIT,R0	;BITS
	.CNDEX	ZBIT,TYSLE
	MOV	#SLBYT,R0	;BYTES
	.CNDEX	ZBYT,TYSLE
	MOV	#SLWRD,R0	;OCTAL WORDS
	.CNDEX	ZWRD,TYSLE
	MOV	#SLASC,R0	;ASCII
	.CNDEX	ZASC,TYSLE
NEWLIN:	MOV	#EOL,R0
TYSLE:	.PRINT
	CLC
	RTS	PC


;WRITE TO TAPE
WSWT:	BMI	1$
	MOV	#-2,R1	;DEFAULT IS LENGTH OF INPUT FILE
1$:	BIS	#WBIT,COMAND
	MOV	R1,WVAL
	MOV	#512.,BYTCNT	;RESET BYTE IN BLOCK COUNT
	BIT	#RBIT!DBIT,COMAND;HAS DUMP BEEN REQUESTED
	BEQ	2$		;NO SO JUMP
	.PRINT	#ILLCOM		;YES SO ILLEGAL COMBINATION
	SEC
2$:	RTS	PC
	.SBTTL	TAPE MOVEMENT ROUTINE
MOVTAP:	.SPFUN	#EMTBUF,#MTCHAN,SPFCDE,MTBUF,SPFLEN,#SPFBLK,#0
	BCS	1$		;NORMALLY EXPECT ERROR
	MOV	#6,SPFBLK	;IF NOT CREATE ONE
	CLR	SPFBLK+2	;THIS LOOKS LIKE READ OKAY
	CMP	SPFCDE,#373	;WAS THIS A REWIND
	BNE	4$		;YES SO JUMP TO THE ROUTINE
	JMP	BOTONY
1$:	MOVB	@#ERRWRD,R1	;SYSTEM ERROR WORD
	BEQ	EOFCDE		;END OF FILE, JUMP TO ANALYSE
	BGT	2$		;MINUS MEANS SYSTEM ERROR
	MOV	#ZOT,LSTFNC	;INDICATE OTHER ERROR
	TYPEBK	#TOTERM		;OUTPUT SECTION AND BLOCK NUMBER
	TYPETX	#SYSER1,#TOTERM	;PRINT MESSAGE
	RTS	PC
2$:	CMPB	#2,R1		;IS IT CHAN NOT OPEN
	BGT	4$		;JUMP FOR ERROR 1 - HARD ERROR
	BLT	3$		;NO SO JUMP
	MOV	#ZOT,LSTFNC	;INDICATE OTHER ERROR
	TYPEBK	#TOTERM		;OUTPUT SECTION AND BLOCK NUMBER
	TYPETX	#CHNCLO,#TOTERM
	RTS	PC
3$:	MOV	#ZOT,LSTFNC	;INDICATE OTHER ERROR
	TYPEBK	#TOTERM		;OUTPUT SECTION AND BLOCK NUMBER
	TYPETX	#UNDEF,#TOTERM
	RTS	PC
4$:	MOV	SPFBLK,R1	;GET EXTRA ERROR INFORMATION
	BLT	UNROC		;POSITIVE ERRORS OKAY
	CMP	#6,R1		;ERRORS LIMITED 0 TO 6 ALLOWED
	BLT	UNROC		;>6 SO GIVE ERROR MESSAGE
	ASL	R1		;WORD OFFSET
	JMP	@HRDTAB(R1)

EOFCDE:	MOV	SPFBLK,R1
	BLE	UNROC		;SHOULD NOT BE LESS THAN 0
	CMP	#4,R1
	BLT	UNROC
	ASL	R1		;WORD OFFSET
	JMP	@EOFTAB-2(R1)

UNROC:	TYPEBK	#TOTERM		;OUTPUT SECTION AND BLOCK NUMBER
	TYPETX	#UNREC,#TOTERM	;GIVE MESSAGE
	MOV	#ZOT,LSTFNC	;INDICATE OTHER ERROR
	RTS	PC
	.SBTTL	ANALYSIS OF TAPE MOVEMENT
;TABLE FOR JUMP TO HARDWARE ERROR ROUTINES
;NOTE THESE ROUTINES CAN CALL MOVTAP OR JUMP TO MOVTAP

HRDTAB:	.WORD	BASERR,NOTAV,TPLOST
	.WORD	ILLMEM,WRTLCK,TOOLIT
	.WORD	TOOMCH

;HARDWARE ERROR ROUTINES

BASERR:	INC	HRDCNT		;COUNT OF HARDWARE ERRORS
1$:	.GTLIN	#FNAMES,#HERR1	;TELL USER HARD ERROR
	CMPB	#'A,FNAMES	;ABANDON THIS READ
	BEQ	3$		;YES SO JUMP
	CMPB	#'U,FNAMES	;USE WHAT WE'VE GOT
	BEQ	LENQ
	CMPB	#'T,FNAMES	;TRY AGAIN ?
	BNE	2$		;NO SO JUMP
	MOV	SPFCDE,-(SP)
	MOV	SPFLEN,-(SP)	;SAVE LAST OPERATION
	MOV	#375,SPFCDE	;SPACE BACKWARD
	MOV	#1,SPFLEN	;BY ONE BLOCK
	JSR	PC,MOVTAP	;GO BACK ONE BLOCK
	MOV	(SP)+,SPFLEN
	MOV	(SP)+,SPFCDE	;RESTORE PREVIOUS OPERATION
	BIT	#ZOK,LSTFNC	;CHECK OKAY
	BEQ	4$		;NOT OKAY SO GIVE UP
	JMP	MOVTAP		;GO AND READ BLOCK AGAIN
2$:	CMPB	#'I,FNAMES	;IGNORE THE BLOCK WITH HARD ERROR
	BNE	1$		;REPLY NOT RECOGNISED SO ASK AGAIN
	INC	MTBLK		;UP BLOCK COUNT AS NOW READ NEXT BLOCK
	JMP	MOVTAP		;AND READ NEXT BLOCK, FALLING THROUGH
3$:	MOV	#ZHW,LSTFNC	;INDICATE HARDWARE ERROR
4$:	RTS	PC

NOTAV:	MOV	#ZNT,LSTFNC	;TAPE DRIVE LOST (1)
	RTS	PC

TPLOST:	MOV	#ZTB,LSTFNC	;TAPE POSITION LOST (2)
	RTS	PC

ILLMEM:	MOV	#ZNX,LSTFNC	;NON EXISTANT MEMORY ACCESSED (3)
	RTS	PC

WRTLCK:	MOV	#ZWL,LSTFNC	;TAPE WRITE LOCKED (4)
	RTS	PC

TOOLIT:	TYPETX	#EISTM		;TELL USER INSUFFICIENT SPACE
	ADD	MTBLEN,SPFBLK+2
	TYPENO	SPFBLK+2	;TELL HIM BLOCK LENGTH
	.GTLIN	#FNAMES,#EISTM1	;ASK HIM IF IT RIGHT
	CMPB	#'Y,FNAMES	;JUMP IF IT WAS RIGHT
	BEQ	LENOK
LENQ:	TYPETX	#EISTM2		;ASK FOR ESTIMATED LENGTH
	.CSISPC	#FNAMES,#DEFLT,#0;GET LENGTH
	DEC	(SP)+		;SHOULD BE 1 SWITCH
	BNE	TYPBAD
	TST	(SP)+		;EXPECT SWITCH TO HAVE VALUE
	BPL	LENQ		;RETRY IF IT HAS NOT
	MOV	MTBLEN,SPFBLK+2
	ASR	(SP)		;HALVE FOR WORDS
	SUB	(SP)+,SPFBLK+2	;FROM TYPED VALUE CONVERT FOR USE
	BR	TOOMCH		;TREAT AS OKAY NOW
LENOK:	MOV	#ZTS,LSTFNC	;NOT ALL READ, GET LENGTH OF BLOCK (5)
	RTS	PC
TYPBAD:	BMI	LENQ		;NO SWITCHES SO OKAY
	TYPETX	#ESTERR		;STACK IN MESS SO ABORT
	INC	MTBLK		;KEEP BLOCK NUMBER CORRECT
	JMP	NOGO

TOOMCH:	MOV	#ZOK,LSTFNC	;ALL READ, CALC LENGTH OF BLOCK (6)
	RTS	PC

;TABLE FOR JUMP TO END OF FILE ERROR ROUTINES

EOFTAB:	.WORD	EOFONY,EOTONY,EOTEOF,BOTONY

EOFONY:	INCB	TMFG		;SET TAPE MARK FLAG FOR LOGIGAL EOT
	CLR	MTBLK		;BLOCK NUMBER 0 
	MOV	#ZTM,LSTFNC	;SET FUNCTION CODE
	RTS	PC

EOTONY:	INCB	PEOT		;INDICATE PHYSICAL END OF TAPE
	MOV	#ZET,LSTFNC	;SET FUNCTION CODE
	RTS	PC

EOTEOF:	INCB	TMFG		;SET TAPE MARK FLAG FOR LOGIGAL EOT
	INCB	PEOT		;INDICATE PHYSICAL END OF TAPE
	CLR	MTBLK		;BLOCK NUMBER 0 
	MOV	#ZTM!ZET,LSTFNC	;SET FUNCTION CODE
	RTS	PC

BOTONY:	CLR	MARKNO	;BEGINNING OF TAPE (4)
	CLR	MTBLK
	MOV	#ZBT,LSTFNC	;SET FUNCTION CODE
	RTS	PC
	.SBTTL	SPECIAL TAPE MOVEMENT FUNCTIONS
;THESE ROUTINES MOVE THE TAPE ABOUT

;THIS ROUTINE SKIPS FORWARD OVER TAPE AFTER A REVERSE OVER A TAPE MARK

SKIPTM:	MOV	#376,SPFCDE	;FORWARD SPACE CODE
	MOV	#1,SPFLEN	;OVER ONE BLOCK
	JSR	PC,MOVTAP	;DO IT
	BIT	#ZTM,LSTFNC	;SHOULD HAVE READ TAPE MARK
	BEQ	1$		;NO SO ERROR JUMP
	CLC
	RTS	PC
1$:	SEC			;ERROR RETURN
	RTS	PC

;THIS ROUTINE READS NEXT BLOCK ON TAPE

READ:	MOV	#370,SPFCDE
	MOV	MTBLEN,SPFLEN	;TENTATIVE LENGTH OF BLOCK
	JSR	PC,MOVTAP	;DO FUNCTION
	BIT	#ZOK!ZHW!ZTS,LSTFNC;ALL THESE BITS INDICATE BLOCK READ
	BEQ	1$
	INC	MTBLK		;SO UP BLOCK COUNT
1$:	BIT	#ZOK,LSTFNC	;SHOULD HAVE THIS BIT SET FOR OKAY READ
	BEQ	2$
	MOV	SPFBLK+2,R0	;GET READ LENGTH
	NEG	R0
	ADD	MTBLEN,R0
	ASL	R0		;DOUBLE FOR BYTES
	MOV	R0,LSTBLEN	;LENGTH OF BLOCK READ
	CLC
	RTS	PC
2$:	BIT	#ZTM,LSTFNC	;TAPE MARK READ
	BEQ	3$		;NO SO JUMP
	INC	MARKNO		;UP COUNT OF TAPE MARKS
3$:	SEC
	RTS	PC
	.SBTTL	DATA FILE HANDLING
;THIS ROUTINE EXPECTS A BYTE IN R0 WHICH IT TRANSFERS TO THE DATA
;OUTPUT FILE
;IF OUTPUT FILE BECOMES FULL USER IS GIVEN OPTION OF OPENING AN
;ALTERNATIVE ONE TO COMPLETE OUTPUT

DATOUT:	MOVB	R0,@DATAPT
	INC	DATAPT		;POINTER IN DATA BUFFER
	DEC	DATACT		;COUNT IN OUTPUT BUFFER
	BNE	8$
	INC	OUTBCT		;COUNT OF BLOCKS FOR /R
	MOV	#512.,DATACT	;RESET COUNT IN BUFFER
	MOV	DATABF,DATAPT	;RESET POINTER IN DATA BUFFER
1$:	.WRITW	#EMTBUF,#0,DATABF,#256.,DATABK
	BCC	7$
	MOVB	@#ERRWRD,R0
	BEQ	3$
	ASL	R0
	.PRINT	OUERR(R0)
2$:	JMP	NOGO
3$:	.CLOSE	#0		;FILE FULL SO CLOSE
	CLR	DATABK		;RESET BLOCK COUNTER
4$:	.PRINT	#NEWFIL		;ASK USER FOR ALTENATIVE FILE
	.CSISPC	#FNAMES,#DEFLT,#0 ;GET ANOTHER FILE NAME
	BCS	4$
	TST	(SP)+		;CAN'T DEAL WITH SWITCHES HERE
	BEQ	5$		;NO SWITCHES SO JUMP
	.PRINT	#ILLSWT
	BR	2$		;CANNOT PROCESS SWITCHES HERE
5$:	TST	FNAMES		;WAS FILE NAME TYPED
	BEQ	2$		;NO SO JUMP
	.ENTER	#EMTBUF,#0,#FNAMES,FNAMES+10	;OPEN ALT FILE
	BCC	1$		;OPEN OKAY SO WRITE OU LAST BLOCK
	TSTB	@#ERRWRD	;WHICH ERROR IS IT
	BGE	6$
	.PRINT	#DIRERR		;DIRECTORY ERROR
	BR	4$
6$:	.PRINT	#FULUSE
	BR	4$
7$:	INC	DATABK
8$:	RTS	PC

;THIS ROUTINE CLOSES THE DATA FILE & RELEASES THE DRIVER

DATACL:	.WAIT	#0		;IS THERE AN OUTPUT FILE
	BCS	2$
	MOV	#511.,R1
1$:	MOV	PADBYT,R0	;PADDING TO END OF BLOCK CHAR
	JSR	PC,DATOUT    ;OUTPUT PADDING TO FORCE LAST BLOCK TO DISC
	DEC	R1
	BNE	1$
	.CLOSE	#0		;CLOSE THE FILE
2$:	RTS	PC
	.SBTTL	DUMP SUBROUTINES
;THESE ROUTINES PERFORM DUMPS IN VARIOUS FORMATS

;DUMPS IN EBCDIC MODE- USES A LOOKUP TABLE TO GO FROM EBCDIC TO ASCII

DMPEBC:	MOV	MTBUF,R0	;ADDRESS OF DATA READ
	MOV	LSTBLEN,R1	;LENGTH OF BLOCK READ
1$:	MOVB	(R0),R2		;GET NEXT CHAR IN BUFFER
	BIC	#177400,R2	;CLEAR OFF SIGN EXTENSION
	MOVB	EBCTAB(R2),(R0)+;CONVERT TO ASCII & STORE
	DEC	R1		;COUNT
	BGT	1$
2$:	RTS	PC

;TREATS TAPE AS IBM FORMAT- THESE ARE NORMALLY 80 BYTE BLOCKS ALTHOUGH
;THE LENGTH IS IRRELEVANT IN THIS ROUTINE, IN TEXT FORMAT, ONE LINE
;PER BLOCK, PADDED WITH SPACES TO MAKE 80 CHARS. THE ROUTINE REMOVES
;TRAILING SPACES FROM THE RECORD AND INSERTS CRLF

DMPIBM:	MOV	MTBUF,R2	;ADDRESS OF DATA READ FROM TAPE
	MOV	LSTBLEN,R1	;LENGTH OF DATA
	ADD	R1,R2		;END OF BUFFER
1$:	CMPB	#SPC,-(R2)	;REVERSE OVER SPACES IN BUFFER
	BNE	2$		;
	DEC	R1
	BNE	1$
	DEC	R2
2$:	INC	R2		;BACK ONE CHAR
	MOVB	#CR,(R2)+	;NOW PUT IN CRLF
	MOVB	#LF,(R2)+
	ADD	#2,R1
	MOV	R1,LSTBLEN	;NEW LENGTH OF DATA
	RTS	PC

;DUMPS DATA AS BITS

DMPBIT:	JSR	PC,SETREG	;SET UP REGISTERS R5 & R4
	BHIS	4$		;ALL DONE SO RETURN
1$:	MOV	#4,R3		;NUMBER OF WORDS PER LINE
	TYPENO	R4,#BOTH
	MOVB	#HT,R0		;TAB AFTER WORD NUMBER
2$:	JSR	PC,OUTCHR	;OUTPUT CHAR IN R0
	BCS	4$		;CARRY SET IF USER DOESN'T CONTINUE
	MOV	#16.,R2		;BITS IN WORD
	MOV	(R5)+,R1	;GET NEXT WORD
3$:	MOVB	#'0,R0
	ASL	R1
	ADC	R0		;CONSTRUCT ASCII 1 OR 0
	JSR	PC,OUTCHR	;OUTPUT IT
	DEC	R2		;COUNT OF BITS IN WORD
	BNE	3$
	TST	(R4)+		;UP COUNT OF WORDS OUTPUT
	CMP	R4,LSTBLEN	;END OF BUFFER YET
	BHIS	4$		;ALL DONE SO RETURN
	MOVB	#SPC,R0		;SPACE BETWEEN CHARACTERS
	DEC	R3		;COUNT OF NO WORDS ON LINE
	BNE	2$
	JSR	PC,OTCRLF	;THROW LINE
	BCC	1$
4$:	RTS	PC

;DUMPS DATA AS BYTES

DMPBYT:	JSR	PC,SETREG	;SET UP REGISTERS R5 & R4
	BHIS	3$		;ALL DONE SO RETURN
1$:	MOV	#16.,R3		;NUMBER OF WORDS PER LINE
	TYPENO	R4,#BOTH
	MOVB	#HT,R0		;TAB AFTER WORD NUMBER
2$:	JSR	PC,OUTCHR	;OUTPUT CHAR IN R0
	BCS	3$		;CARRY SET IF USER DOESN'T CONTINUE
	MOVB	(R5),R1		;GET NEXT BYTE
	ASR	R1		;SHIFT TO ISOLATE INDIVIDUAL OCTAL DIGIT
	ASR	R1
	ASR	R1
	MOV	R1,R0
	ASR	R0
	ASR	R0
	ASR	R0
	BIC	#^C3,R0
	ADD	#'0,R0
	JSR	PC,OUTCHR	;OUTPUT IT
	MOV	R1,R0
	BIC	#^C7,R0
	ADD	#'0,R0
	JSR	PC,OUTCHR	;OUTPUT IT
	MOVB	(R5)+,R0
	BIC	#^C7,R0
	ADD	#'0,R0
	JSR	PC,OUTCHR	;OUTPUT IT
	INC	R4		;UP COUNT OF WORDS OUTPUT
	CMP	R4,LSTBLEN	;END OF BUFFER YET
	BGE	3$		;ALL DONE SO RETURN
	MOVB	#SPC,R0		;SPACE BETWEEN CHARACTERS
	DEC	R3		;COUNT OF NO WORDS ON LINE
	BNE	2$
	JSR	PC,OTCRLF	;THROW LINE
	BCC	1$
3$:	RTS	PC

;DUMPS DATA AS WORDS

DMPWRD:	JSR	PC,SETREG	;SET UP REGISTERS R5 & R4
	BHIS	5$		;ALL DONE SO RETURN
1$:	MOV	#10.,R3		;NUMBER OF WORDS PER LINE
	TYPENO	R4,#BOTH
	MOVB	#HT,R0		;TAB AFTER WORD NUMBER
2$:	JSR	PC,OUTCHR	;OUTPUT CHAR IN R0
	BCS	5$		;CARRY SET IF USER DOESN'T CONTINUE
	MOV	#6.,R2		;BITS IN WORD
	MOV	(R5)+,R1	;GET NEXT WORD
	CLR	R0
	BR	4$
3$:	BIC	R0,R0		;DOESN'T AFFECT CARRY
	ROL	R1
	ROL	R0
	ROL	R1
	ROL	R0
4$:	ROL	R1
	ROL	R0
	ADD	#'0,R0
	JSR	PC,OUTCHR	;OUTPUT IT
	DEC	R2		;COUNT OF BITS IN WORD
	BNE	3$
	TST	(R4)+		;UP COUNT OF WORDS OUTPUT
	CMP	R4,LSTBLEN	;END OF BUFFER YET
	BGE	5$		;ALL DONE SO RETURN
	MOVB	#SPC,R0		;SPACE BETWEEN CHARACTERS
	DEC	R3		;COUNT OF NO WORDS ON LINE
	BNE	2$
	JSR	PC,OTCRLF	;THROW LINE
	BCC	1$
5$:	RTS	PC

;DUMPS DATA IN DECIMAL

DMPDEC:	JSR	PC,SETREG	;SET UP REGISTERS R5 & R4
	BHIS	3$		;ALL DONE SO RETURN
1$:	MOV	#10.,R3		;NUMBER OF WORDS PER LINE
	TYPENO	R4,#BOTH
	MOVB	#HT,R0		;TAB AFTER WORD NUMBER
2$:	JSR	PC,OUTCHR	;OUTPUT CHAR IN R0
	BCS	3$		;CARRY SET IF USER DOESN'T CONTINUE
	MOV	(R5)+,R1	;GET NEXT WORD
	TYPENO	,#BOTH!FORMNO	;PRINT NUMBER IN FORMATTED MODE
	TST	(R4)+		;UP COUNT OF WORDS OUTPUT
	CMP	R4,LSTBLEN	;END OF BUFFER YET
	BGE	3$		;ALL DONE SO RETURN
	MOVB	#SPC,R0		;SPACE BETWEEN CHARACTERS
	DEC	R3		;COUNT OF NO WORDS ON LINE
	BNE	2$
	JSR	PC,OTCRLF	;THROW LINE
	BCC	1$
3$:	RTS	PC

;CONVERTS DATA FROM TAPE TO RAD50 FORMAT

DMPRAD:	MOV	MTBUF,R5	;ADDRESS OF DATA READ FROM TAPE
	MOV	LSTBLEN,R4	;NUMBER OF BYTES READ
	MOV	R4,R3
	ASR	R3
	ADD	R4,R3		;NO OF BYTE CONVERTED DATA WILL OCCUPY
	CMP	R3,MTBLEN	;IS THIS MORE SPACE THAN AVAILABLE
	BGT	6$		;YES SO JUMP
	MOV	R3,LSTBLEN	;THIS IS NOW NEW AMOUNT OT DATA
	ADD	R5,R4		;END OF DATA READ FROM TAPE
	ADD	R5,R3		;END OF CONVERTED DATA
1$:	MOV	-(R4),R2	;GET LAST WORD
	CMP	#64000.,R2	;IS IT LEGAL RAD50
	BHI	2$		;JUMP IF IT IS
	MOV	#'&,R0		;DUMMY CHAR TO INDICATE ILLEGAL
	MOVB	R0,-(R3)	;STORE IT
	MOVB	R0,-(R3)	;STORE IT
	MOVB	R0,-(R3)	;STORE IT
	BR	5$
2$:	CLR	R0		;FOR CONSTRUCTING RAD50 CHAR
3$:	INC	R0		;COUNT
	SUB	#1600.,R2	;FIRST CHAR
	BCC	3$
	CLR	R1		;SECOND CHAR BASE
	ADD	#1600.,R2	;ADD BACK LAST SUBTRACTION
4$:	INC	R1		;SECOND CHAR COUNT
	SUB	#40.,R2
	BCC	4$
	MOVB	RADTAB+40.(R2),-(R3)	;LAST CHAR TO BUFFER
	MOVB	RADTAB-1(R1),-(R3)	;MIDDLE CHAR
	MOVB	RADTAB-1(R0),-(R3)	;FIRST CHAR
5$:	CMP	R3,R5		;REACHED BEGINNING OF BUFFER
	BNE	1$		;NO SO LOOP
	RTS	PC
6$:	TYPETX	#NOEXP		;TELL USER NOT ENOUGH MEMORY
	SEC
	RTS	PC

;THIS ROUTINE SETS UP R5 WITH BUFFER ADDRESS OF START OF DATA
;READ FROM TAPE MODIFIED BY OFFSET FOR FIRST BLOCK
;AND R4 WITH WORD COUNT

SETREG:	MOV	MTBUF,R5	;ADDRESS OF DATA READ FROM TAPE
	MOV	FVALT,R4	;COUNT OF WORDS OUTPUT
	CLR	FVALT		;START FROM BEGINNING NEXT TIME
	ADD	R4,R5		;STARTING POSITION IN BUFFER
	CMP	R4,LSTBLEN	;END OF BUFFER YET
	RTS	PC
;OUTPUTS CHARACTERS FROM THE BUFFER, CALLED BY DUMP ROUTINES

OUTASC:	JSR	PC,SETREG	;SET UP REGISTERS R5 & R4
	BHIS	7$		;ALL DONE SO RETURN
	NEG	R4
	ADD	LSTBLEN,R4	;LENGTH OF BLOCK READ-STARTING OFFSET
	CLR	R3		;COUNT OF CHARACTERS ON A LINE
1$:	MOVB	(R5)+,R0	;GET NEXT CAHARCTER
	BLT	2$		;NON ASCII CHARACTER IF NEGATIVE
	CMPB	#40,R0		;IS CAHARCTER VALUE LESS THAN SPACE
	BLE	5$		;NO SO JUMP-THIS IS PRINTABLE
	CMPB	#CR,R0		;CARRIAGE RETURN
	BEQ	5$		;YES SO JUMP
	CMPB	#LF,R0		;LINE FEED ?
	BEQ	4$		;YES SO JUMP
	CMPB	#HT,R0		;TAB ?
	BEQ	3$		;YES SO JUMP
2$:	MOVB	#'.,R0		;UNPRINTABLE SO CONVERT TO .
	BR	4$
3$:	BIS	#7,R3		;TAB SO UP CHAR ON LINE COUNT
	INC	R3
4$:	CMP	#132.,R3	;MAX NUMBER CHARS ON LINE EXCEEDED
	BGE	6$		;NO SO JUMP
	MOV	R0,R3		;YES SO FORCE CRLF,SAVE CHAR
	JSR	PC,OTCRLF	;OUTPUT CRLF
	BCS	7$		;CARRY SET IF USER ABORTED DUMP
	MOV	R3,R0		;RESTORE CHAR TO BE PRINTED
5$:	CLR	R3		;RESET CHARS ON A LINE COUNT
6$:	JSR	PC,OUTCHR	;SEND CHAR IN BUFFER TO OUTPUT
	BCS	7$		;CARRY SET IF USER ABORTED
	DEC	R4		;COUNT OF CHARS IN BUFFER
	BNE	1$
7$:	RTS	PC

;FORMATS THE PAGE FOR DUMP ROUTINES

OUTCHR:	MOVB	R0,PNTPL
	TYPETX	#PNTPL,#BOTH	;SEND TO TERMINAL AND OR FILE
	CMPB	#LF,PNTPL
	BNE	2$		;JUMP IF NOT LINE FEED
	INC	LINECT		;UP LINE COUNT
	CMP	#20.,LINECT	;EXCEEDED NO OF LINES ON VDU
	BGT	2$		;NO SO JUMP
	CLR	LINECT
	TSTB	OUTFLG		;IS THERE A FILE
	BEQ	1$		;NO SO JUMP
	TSTB	OFLG		;YES SO OUTPUT TO TERM REQUIRED
	BEQ	2$		;NO SO DON'T QUERY
1$:	.GTLIN	#FNAMES,#NWPGQ
	CMPB	#'A,FNAMES	;WAS ABORT RECIEVED
	BEQ	3$		;YES SO JUMP
	.PRINT	#EOL		;GIVE A LINE SPACE
2$:	CLC
	RTS	PC
3$:	SEC
	RTS	PC

;SWAP BYTES FOR DUMP AND OUTPUT ROUTINES

DMPSWP:	MOV	MTBUF,R5	;ADDRESS OF DATA READ FROM TAPE
	MOV	LSTBLEN,R4	;NUMBER OF BYTES READ
1$:	SWAB	(R5)+		;SWAP THE BYTES
	DEC	R4
	DEC	R4
	BNE	1$		;LOOP ON COUNT
	RTS	PC

;CONVERTS CDC EXTENDED DISPLAY CODE TO ASCII (AFTER EJL)

DMPXDC:	MOV	MTBUF,R5	;ADDRESS OF BLOCK READ FROM TAPE
	MOV	LSTBLEN,R4	;LENGTH OF BLOCK READ FROM TAPE
	MOV	R5,R3		;ADDRESS FOR PLACING CONVERTED CHARS
	CLR	LSTBLEN		;COUNT FOR REVISED BLOCK LENGTH
	JMP	@(PC)+		;CONTINUE ON FROM WHERE WE GOT TO LAST
LSTREQ:	.WORD	XDCLOP		;ADDRESS OF INITIAL ENTRY TO LOOP
XDCLOP:	MOV	#XDCLOP,LSTREQ	;REMEMBER WHERE WE START AGAIN NEXT TIME
	DEC	R4
	BLT	11$
	MOVB	(R5)+,R1	;GET NEXT CHAR
	CMPB	#'^,R1
	BNE	3$
1$:	MOV	#1$,LSTREQ	;REMEMBER WHERE WE START AGAIN NEXT TIME
	DEC	R4
	BLT	11$
	MOVB	(R5)+,R1	;GET NEXT CHAR
;	CMPB	R1,#'=		;IS IT FORM FEED
;	BNE	2$
;	MOVB	#FF,R1
;	BR	10$
2$:	ADD	#40,R1
	CMPB	R1,#'a
	BGE	10$
	ADD	#53,R1
	BPL	10$
	CLRB	R1
	BR	10$
3$:	CMPB	#'@,R1
	BNE	9$
4$:	MOV	#4$,LSTREQ	;REMEMBER WHERE WE START AGAIN NEXT TIME
	DEC	R4
	BLT	11$
	MOVB	(R5)+,R1	;GET NEXT CHAR
	CMPB	#'A,R1
	BNE	5$
	MOVB	#'@,R1
	BR	10$
5$:	CMPB	#'B,R1
	BNE	6$
	MOVB	#'^,R1
	BR	10$
6$:	CMPB	#'D,R1
	BNE	7$
	MOVB	#':,R1	;THERE IS CONFUSION HERE
	BR	10$
7$:	CMPB	#'G,R1
	BNE	8$
	MOVB	#'`,R1
	BR	10$
8$:	CLRB	R1
	BR	10$
9$:	CMPB	#'%,R1
	BNE	10$
	MOVB	#'%,R1	;THERE IS CONFUSION HERE
10$:	MOVB	R1,(R3)+
	INC	LSTBLEN		;UP COUNT OF NEW BLOCK LENGTH
	BR	XDCLOP
11$:	RTS	PC

;PRINTS CRLF FOR DUMP ROUTINES

OTCRLF:	MOV	#CR,R0
	JSR	PC,OUTCHR	;SEND CR TO OUTPUT
	BCS	1$
	MOV	#LF,R0
	JSR	PC,OUTCHR	;SEND CR TO OUTPUT
1$:	RTS	PC
	.SBTTL	TAPE ERROR ANALYSIS
;ANALYSES ERROR WHICH ARE NOT EXPECTED

ANAERR:	MOV	R1,-(SP)
	MOV	R2,-(SP)
	CLR	R1
	MOV	LSTFNC,R2	;CODE FOR LAST TAPE FUNCTION DETECTED
1$:	ASR	R2
	BCC	2$
	TYPETX	R5,#TOTERM
	TYPETX	#UNEXP,#TOTERM
	TYPETX	ANATAB(R1),#TOTERM
2$:	INC	R1
	INC	R1
	TST	R2
	BNE	1$
3$:	CLR	COMAND		;STOP ANY FURTHER EXECUTION OF THIS COMMAND
	MOV	(SP)+,R2
	MOV	(SP)+,R1
	RTS	PC

ANATAB:	.WORD	ZNTM,ZTBM,ZTMM,ZTMETM,ZETM,ZBTM,ZHWM,ZWLM,ZNXM
	.WORD	ZOTM,ZOKM,ZTSM

PBLOCK:	TYPETX	#FILEM,PBLDIR	;IDENTIFY FILE & BLOCK FOR USER
	TYPENO	MARKNO,PBLDIR	;GET CURRENT TAPE MARK NUMBER
	TYPETX	#BLCKM,PBLDIR
	MOV	MTBLK,R1	;CURRENT BLOCK NUMBER IN FILE
	TYPENO	,PBLDIR
	TYPETX	#SPACE,PBLDIR
	RTS	PC

	.SBTTL	DUMP OUTPUTTING ROUTINES
PTOUT:	BIT	#TOFILE,(R5)	;HAS THIS TEXT TO GO TO OUTPUT FILE
	BEQ	4$		;NO SO JUMP
	MOV	R1,-(SP)	;SAVE R1
	MOV	R0,-(SP)	;SAVE ADDRESS OF TEXT
	MOV	R0,R1		;ADDRESS OF TEXT TO R1
1$:	MOVB	(R1)+,R0	;GET NEXT CHARACTER
	BLE	2$		;IS THE END
	JSR	PC,CHROUT
	BR	1$
2$:	BNE	3$		;0 MEANS APPEND CRLF
	MOVB	#CR,R0
	JSR	PC,CHROUT	;SEND CR TO OUTPUT FILE
	MOVB	#LF,R0
	JSR	PC,CHROUT	;SEND LF TO OUTPUT FILE
3$:	MOV	(SP)+,R0	;RESTORE ADDRESS OF TEXT
	MOV	(SP)+,R1	;RESTORE R1
	TSTB	OUTFLG		;IS THERE AN OUTPUT FILE
	BEQ	4$		;NO SO JUMP
	TSTB	OFLG		;THIS IS SET IF DUMP TO TERM & FILE
	BEQ	5$		;NOT SET SO SEND ONLY TO FILE
4$:	BIT	#TOTERM,(R5)	;HAS TEXT TO GO TO TERMINAL
	BEQ	5$		;NO SO JUMP
	.PRINT
5$:	TST	(R5)+		;OVER PARAMETER
	RTS	R5

CHROUT:	TSTB	OUTFLG		;IS THERE AN OUTPUT FILE
	BEQ	2$		;NO SO JUMP
	MOVB	R0,@OUTPTR
	INC	OUTPTR
	DEC	OUTCNT
	BNE	2$
	MOV	#512.,OUTCNT
	MOV	OUTFBF,OUTPTR
	.WRITW	#EMTBUF,#1,OUTFBF,#256.,OUTBLK
	BCC	1$
	MOVB	@#ERRWRD,R0
	ASL	R0
	.PRINT	OUERR(R0)
	JMP	NOGO
1$:	INC	OUTBLK
2$:	RTS	PC
	.SBTTL	WRITING TO TAPE ROUTINE	/W
WRIT:	CMP	NSOFAR,WRTLEN	;HAVE WE A FULL BUFFER
	BLT	1$
	JSR	PC,WRTAPE
	MOV	MTBUF,MBFPTR
	BCS	WRTERR
1$:	DEC	BYTCNT		;COUNT OF NUMBER OF BYTES TO PUT ON TAPE
	BGE	2$
	DEC	WVAL		;DEC NUMBER OF PDP BLOCKS ON TAPE REQ
	BLOS	WDONE
	MOV	#511.,BYTCNT
2$:	JSR	PC,REDBLK	;GET NEXT BYTE FROM FILE
	BCS	WRTERR
	BIT	#ZIBM,FORMAT
	BEQ	4$
	CMPB	#CR,R0		;IN IBM FORMAT IGNORE CR'S
	BEQ	1$
	CMPB	#LF,R0
	BNE	4$
3$:	MOVB	#SPC,@MBFPTR	;PAD WITH SPACES TO FILL LINE
	INC	MBFPTR
	INC	NSOFAR
	CMP	NSOFAR,WRTLEN
	BLT	3$
	BR	WRIT
4$:	MOVB	R0,@MBFPTR	;SAVE BYTE IN BUFFER
	INC	MBFPTR
	INC	NSOFAR
	BR	WRIT
WDONE:	CMP	MTBUF,MBFPTR	;HAVE WE JUST WRITTEN OUT A BUFFER
	BEQ	3$
2$:	CMP	NSOFAR,WRTLEN	;HAVE WE A FULL BUFFER
	BEQ	1$
	TST	FILEN		;HAS WHOLE FILE BEEN COPIED
	BNE	3$		;JUMP IF NOT
	BIT	#ZFIL,FORMAT	;IS LAST BLOCK TO BE FILLED
	BNE	1$		;JUMP IF SHORT LAST BLOCK REQUIRED
	MOVB	PADBYT,@MBFPTR	;PAD LAST BLOCK
	INC	MBFPTR
	INC	NSOFAR
	BR	2$
1$:	JSR	PC,WRTAPE	;WRITE THIS BUFFER TO TAPE
	MOV	MTBUF,MBFPTR	;RESET POINTER
3$:	CLC
WRTERR:	RTS	PC

WRTAPE:	MOV	NSOFAR,LSTBLEN
	BIT	#ZEBC,FORMAT	;EBCDIC CONVERSION REQUIRED
	BEQ	1$
	MOV	R5,-(SP)
	MOV	R4,-(SP)
	MOV	MTBUF,R5
6$:	MOV	#255.,R4	;LENGTH OF EBCDIC TABLE
	BICB	#200,(R5)
2$:	CMPB	(R5),EBCTAB(R4)	;GO THROUGH TABLE FOR THIS VALUE
	BEQ	4$		;JUMP IF FOUND
	DEC	R4
	BGE	2$		;REACHED END OF TABLE
	INC	R4		;NOT FOUND SO USE LAST TABLE VALUE
4$:	MOVB	R4,(R5)+
	DEC	NSOFAR		;REACHED END OF BUFFER TO BE CONVERTED
	BNE	6$
	MOV	(SP)+,R4
	MOV	(SP)+,R5
1$:	.CNDEX	ZSWP,DMPSWP	;SWAP BYTES IF REQUIRED
	MOV	#371,SPFCDE	;SET WRITE TO TAPE CODE
	MOV	LSTBLEN,SPFLEN
	ASR	SPFLEN		;SET LENGTH OF BLOCK IN WORDS
	CLR	NSOFAR
	JSR	PC,MOVTAP	;WRITE DATA TO TAPE
	BIT	#ZOK,LSTFNC	;TEST FUNCTION PERFORMED OK
	BEQ	11$
	INC	MTBLK		;UP BLOCK COUNT
	CLC
	RTS	PC
11$:	MOV	#SLASHW,R5	;MESSAGE ADDRESS
	JSR	PC,ANAERR
	SEC
	RTS	PC

	.SBTTL	READING FROM INPUT FILE
;READS NEXT CHAR FROM INPUT FILE

REDBLK:	DEC	INFCNT		;NO OF CHARS LEFT IN BUFFER
	BGT	2$		;BRANCH IF SOME LEFT
	.READW	#EMTBUF,#3,INFBUF,#256.,INFBLK
	BCC	1$
	MOVB	@#ERRWRD,R0	;GET ERROR CODE
	ASL	R0
	.PRINT	INERR(R0)
	SEC
	BR	3$
1$:	INC	INFBLK
	DEC	FILEN		;DECREMENT FILE LENGTH LEFT
	MOV	INFBUF,INFPTR
	MOV	#512.,INFCNT
2$:	MOVB	@INFPTR,R0	;GET NEXT BYTE
	INC	INFPTR		;UPDATE POINTER
	.CNDEX	ZXDC,ASCXDC	;CONVERT TO EXTENDED DISPLAY CODE IF REQ
	CLC
3$:	RTS	PC

;CALLED BY REDBLK TO CONVERT ASCII TO CDC EXTENDED DISPLAY CODE
;BYTE IN R0

ASCXDC:	BIC	#177600,R0	;REMOVE PARITY
	TST	XDCFLG		;WAS LAST CHAR AN ESCAPE CODE
	BNE	40$		
	DEC	XDCFLG		;YES SO RESET FLAG
	RTS	PC		;AND EXIT
40$:	CMPB	#'@,R0		;SPECIAL CHARACTER
	BNE	1$
	MOVB	#'A,R0		;NEW CHARACTER + @
	BR	20$
1$:	CMPB	#'^,R0		;SPECIAL CHARACTER
	BNE	2$
	MOVB	#'B,R0		;NEW CHARACTER + @
	BR	20$
2$:	CMPB	#':,R0		;SPECIAL CHARACTER
	BNE	3$
	MOVB	#'D,R0		;NEW CHARACTER + @
	BR	20$
3$:	CMPB	#'`,R0		;SPECIAL CHARACTER
	BNE	4$
	MOVB	#'G,R0		;NEW CHARACTER + @
	BR	20$
4$:	CMPB	#CR,R0
	BEQ	30$
	CMPB	#LF,R0
	BEQ	30$
;	CMPB	#HT,R0		;TAB IS NOT CONVERTED
;	BEQ	30$
	CMPB	#' ,R0
	BGT	5$		;VALUE LESS THAN SPACE SO ESCAPE CODE
	CMPB	#'_,R0
	BGE	30$		;VALUE BETWEEN SPACE AND [ SO NOT ESCAPE
5$:	SUB	#'a-'A,R0
	BLT	21$
	CMPB	#'[,R0
	BGE	22$
21$:	ADD	#125,R0
22$:	MOV	#'^,-(SP)	;ESCAPE CODE WITH ^ PRECEDING
	BR	23$
20$:	MOV	#'@,-(SP)	;ESCAPE CODE WITH @ PRECEDING
23$:	DEC	INFPTR
	MOVB	R0,@INFPTR
	INC	INFCNT
	INC	BYTCNT
	MOV	(SP)+,R0
	CLR	XDCFLG		;SET FLAG TO INDICATE ESCAPE SEQUENCE
	BIC	#177600,R0	;REMOVE WRAP ROUND
30$:	RTS	PC
	.SBTTL	DECIMAL PRINT ROUTINE
;THIS ROUTINE CONVERTS TO ASCII A NUMBER CONTAINED IN R1 AND PRINTS IT
;VALR1 GIVES SIGNED NUMBER, NUMBR1 GIVES UNSIGNED
;R0 AND R1 ARE USED

VALR1:	TST	R1
	BGE	1$
	TYPETX	#ASCMIN,VALCDE	;SEND MINUS TO OUTPUT  PLACE
	NEG	R1
	BR	NUMR1
1$:	BIT	#FORMNO,VALCDE	;IS FORMATTED OUTPUT REQUIRED
	BEQ	NUMR1
	TYPETX	#SPACE,VALCDE
NUMR1:	MOV	R5,-(SP)
	MOV	R4,-(SP)
	MOV	#NUMTXT,R5
	JSR	R3,COUNT
	.WORD	10000.		;SUBROUTINE PARAMETER
	JSR	R3,COUNT
	.WORD	1000.		;SUBROUTINE PARAMETER
	JSR	R3,COUNT
	.WORD	100.		;SUBROUTINE PARAMETER
	JSR	R3,COUNT
	.WORD	10.		;SUBROUTINE PARAMETER
	ADD	#'0,R1		;REMAINDER TO ASCII
	MOVB	R1,(R5)		;STORE IT
	MOV	#NUMTXT,R0	;REMOVE LEADING ZEROES
1$:	CMPB	#'0,(R0)+	;KEEP GOING WHILE 0
	BEQ	1$
	CMPB	#200,-(R0)	;WAS THIS LAST DIGIT
	BNE	2$		;NO SO JUMP
	DEC	R0		;YES SO MAKE SURE IT IS PRINTED
2$:	BIT	#FORMNO,VALCDE	;IS FORMATTING REQUIRED
	BEQ	4$		;NO SO JUMP
3$:	CMP	R0,#NUMTXT	;BACK FILL WITH SPACES
	BEQ	4$
	MOVB	#SPC,-(R0)
	BR	3$
4$:	TYPETX	,VALCDE
	MOV	(SP)+,R4
	MOV	(SP)+,R5
	RTS	PC

;THIS ROUTINE IS USED TO WORK OUT INDIVIDUAL DIGITS FOR PRINTING NUMBER

COUNT:	MOV	(R3)+,R4	;SUBROUTINE PARAMETER
	CLR	R0		;CLEAR COUNT
1$:	INC	R0		;INCREMENT COUNT
	SUB	R4,R1		;SUBTRACT OFF DIVISOR
	BPL	1$		;KEEP GOING IF POSITIVE
	ADD	R4,R1		;ADD BACK LAST ONE WHEN NEGATIVE
	ADD	#'0-1,R0	;ANSWER TO ASCII
	MOVB	R0,(R5)+	;STORE FOR PRINTING
	RTS	R3
ASCMIN:	.ASCII	/-/<200>	;NEGATIVE SIGN FOR NUMBER
NUMTXT:	.ASCII	/00000/<200>	;SPACE FOR CONSTRUCTING ASCII NUMBER
	.EVEN
	.SBTTL	EBCDIC TO ASCII CONVERSION TABLE
	DEL=177
	SOH=1
	STX=2
	ETX=3
	EOT=4
	ENQ=5
	ACK=6
	BEL=7
	BS=10
	HT=11
	LF=12
	VT=13
	FF=14
	CR=15
	SO=16
	SI=17
	DLE=20
	DC1=21
	DC2=22
	DC3=23
	DC4=24
	NAK=25
	SYN=26
	ETB=27
	CAN=30
	EM=31
	SUB=32
	ESC=33
	FS=34
	GS=35
	RS=36
	US=37
	SPC=40
EBCTAB:	.BYTE	-1,-1,-1,-1,-1,HT,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
	.BYTE	-1,-1,-1,-1,-1,LF,BS,-1,-1,DC1,DC2,DC3,DC4,-1,-1,-1
	.BYTE	'[,'],-1,-1,-1,-1,-1,-1,-1,-1,-1,VT,FF,CR,SO,SI ;[ & ] NOT EBC
	.BYTE	-1,-1,-1,-1,-1,-1,-1,-1,-1,EM,SUB,ESC,FS,GS,RS,US
	.BYTE	SPC,-1,-1,-1,-1,-1,-1,-1,-1,-1
	.ASCII	/\.<(+|&/
	.BYTE	-1,-1,-1,-1,-1,-1,-1,-1,-1
	.ASCII	.!$*);~-/.
	.BYTE	-1,-1,-1,-1,-1,-1,-1,-1
	.ASCII	/^,%_>?/
	.BYTE	-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
	.ASCII	/:#@'="/<0>/abcdefghi/
	.BYTE	-1,-1,-1,-1,-1,-1,-1
	.ASCII	/jklmnopqr/
	.BYTE	-1,-1,-1,-1,-1,-1,-1,-1
	.ASCII	/stuvwxyz/
	.BYTE	SOH,DLE,CAN,NAK,SYN,ETB,-1,-1,-1,-1,-1
	.BYTE	-1,-1,-1,-1,-1,STX,ETX,EOT,ENQ,ACK,BEL,-1
	.BYTE	'A,'B,'C,'D,'E,'F,'G,'H,'I,-1,-1,-1,-1,-1,-1,-1
	.BYTE	'J,'K,'L,'M,'N,'O,'P,'Q,'R,-1,-1,-1,-1,-1,-1,-1,-1
	.BYTE	'S,'T,'U,'V,'W,'X,'Y,'Z,-1,-1,-1,-1,-1,-1
	.BYTE	'0,'1,'2,'3,'4,'5,'6,'7,'8,'9,-1,-1,-1,-1,-1,DEL
	.SBTTL	PRINT MESSAGES
MS1TAB:	.WORD	MS1T0,MS1T1,MS1T2
INERR:	.WORD	INMS0,INMS1,INMS2
OUERR:	.WORD	OUTMS0,OUTMS1,OUTMS2

TITLE:	.ASCIZ	;Magnetic tape I/O (/H for help);
NODRIV:	.ASCIZ	/MT driver not found - check it has been installed/
SYSERR:	.ASCIZ	/Open MT failed, check tape mounted/
SYSER1:	.ASCIZ	/System error while reading MT/
SYSER2:	.ASCIZ	/MT driver not found - may assigned to FG/
CHNCLO:	.ASCIZ	/MT read - channel not open/
MS1T0:	.ASCIZ	/MT open - channel in use/
MS1T1:	.ASCIZ	/MT open - file not found/
MS1T2:	.ASCIZ	/MT driver already in use/
UNDEF:	.ASCIZ	/Undefined error (>2) on MT read/
UNREC:	.ASCIZ	/Undefined hard error on MT read <0 or >6/
NOTAPE:	.ASCIZ	;No tape/Off line;
FILEM:	.ASCII	/Section  /<200>
TOBLK:	.ASCII	/no. blocks /<200>
BLCKM:	.ASCII	/	Block/
SPACE:	.ASCII	/ /<200>
LENMSS:	.ASCII	/length /<200>
WRDMSS:	.ASCIZ	/ bytes/
LEOT:	.ASCIZ	/*** LOGICAL END OF TAPE ***/
EOL:	.BYTE	0	;END OF LINE
NOIFDR:	.ASCIZ	/Input driver not found/
IFFNF:	.ASCIZ	;Input file not found/in use;
IFDERR:	.ASCIZ	/Input file directory error/
INMS0:	.ASCIZ	/Input file too short/
INMS1:	.ASCIZ	/Input file hardware error/
INMS2:	.ASCIZ	/Input file fault!/
WRNDNG:	.ASCIZ	/Take care when writing to tape. Terminate tape with double tape mark/
WTTOTP:	.ASCII	;Write to tape, are you sure? (Y/N) ;<200>
NOINFL:	.ASCIZ	/No input file/
OUTMS0:	.ASCIZ	/Output file too short/
OUTMS1:	.ASCIZ	/Output file hardware error/
OUTMS2:	.ASCIZ	/Output file fault!/
RWFAIL:	.ASCIZ	/Rewind failure/
ILLSWT:	.ASCIZ	/Illegal switch/
ILLCOM:	.ASCII	;/D,/R & /W in combination - ;<200>
LEVEN:	.ASCII	;/L value must be even - ;<200>
NWPGQ:	.ASCII	/Type A to abort dump, anything else to continue: /<7><200>
NOOUTD:	.ASCIZ	/No output data file driver/
DIRERR:	.ASCIZ	/Data file directory error/
FULUSE:	.ASCIZ	;Insufficient space for file or device in use;
NEWFIL:	.ASCII	;Data file full;<15><12>
	.ASCIZ	;Enter another file name only to continue (eg OVFW.DAT[-1]=) or CR not to;
EISTM:	.ASCIi	;Length of block: ;<200>
EISTM1:	.ASCII	; bytes exceeds available memory;<15><12>
	.ASCII	;Is this length correct (Y or N) ?;<200>
EISTM2:	.ASCII	;Please estimate length (n) in bytes of last block read (/Z:n) ;<200>
ESTERR:	.ASCIZ	;Illegal input causes operation abortion;
HERR1:	.ASCII	;Hardware read error;<15><12>
	.ASCII	;Type:	T	to try the read again;<15><12>
	.ASCII	;	A	to abandon operation;<15><12>
	.ASCII	;	U	to use what we've got;<15><12>
	.ASCIZ	;	I	ignore this block & continue;
OUTTX:	.ASCIZ	; PDP blocks output in this read;
WARNCL:	.ASCIZ	;Don't forget to close file (/C);
NODMPD:	.ASCIZ	;Dump device error;
DDIRER:	.ASCIZ	;Dump file directory error;
DINUSE:	.ASCIZ	;Dump file full/in use;
NOEXP:	.ASCIZ	;Insufficient memory for RAD50 unpack;
RADTAB:	.ASCII	; ABCDEFGHIJKLMNOPQRSTUVWXYZ$.%0123456789;
NODATF:	.ASCIZ	;/R	No output file open;
SLASHS:	.ASCII	;/S;<200>
SLASHD:	.ASCII	;/D;<200>
SLASHR:	.ASCII	;/R;<200>
SLASHB:	.ASCII	;/B;<200>
SLASHT:	.ASCII	;/T;<200>
SLASHW:	.ASCII	;/W;<200>
UNEXP:	.ASCII	/	Unexpected error condition- /<200>
ZNTM:	.ASCIZ	/No tape/
ZTBM:	.ASCIZ	/Tape blank/
ZTMM:	.ASCIZ	/Tape mark read/
ZTMETM:	.ASCIZ	/Tape mark at end of tape/
ZETM:	.ASCIZ	/End of tape/
ZBTM:	.ASCIZ	/Beginning of tape/
ZHWM:	.ASCIZ	/Hardware error/
ZWLM:	.ASCIZ	/Tape write locked/
ZNXM:	.ASCIZ	/Memory error/
ZOTM:	.ASCIZ	/Other/
ZOKM:	.ASCIZ	/Read okay/
ZTSM:	.ASCIZ	/Insufficient memory for read/
BPB:	.ASCII	;Bytes/block for writing: ;<200>
FREMEM:	.ASCII	<CR><LF>/Max tape block readable: /<200>
SLECT:	.ASCII	/ bytes/<CR><LF>/Selected data processing modes: /<200>
SLDMP:	.ASCII	<CR><LF>/Dump selected as /<200>
SLASC:	.ASCII	/ASCII./<200>
SLXDC:	.ASCII	/CDC X Display code, /<200>
SLEBC:	.ASCII	/EBCDIC conversion, /<200>
SLIBM:	.ASCII	/IBM, /<200>
SLSWP:	.ASCII	/Byte swapping, /<200>
SLWRD:	.ASCIZ	/octal words./
SLBIT:	.ASCIZ	/bits./
SLBYT:	.ASCIZ	/octal bytes./
SLRAD:	.ASCII	/RAD50 unpacking, /<200>
SLDEC:	.ASCIZ	/decimal words./
HLPTXT:	.ASCII	;Type file & switches, braces indicate optional parameters;<CR><LF>
	.ASCII	;(datafile.DAT)(,dumpfile.DMP)=(inputfile.DAT)(/Switches);<CR><LF>
	.ASCII	;Switches:;<CR><LF>
	.ASCII	;/B:n	Move to block n in current section (default 0);<CR><LF>
	.ASCII	;/C	Close current output file;<CR><LF>
	.ASCII	;/D:n	Dump n blocks (Default to next tape mark);<CR><LF>
	.ASCII	;/F	First byte in block (even, default 0);<CR><LF>
	.ASCII	;/G	Ignore logical end of tape;<CR><LF>
	.ASCII	;/H	Produces this listing;<CR><LF>
	.ASCII	;/L:n	Block length default 512 bytes (/W);<CR><LF>
.ASCII ;/M	:ASC ASCII data (/D)	:BIT bit dump(/D)	:BYT byte dump(/D);<CR><LF>
.ASCII ;	:EBC EBCDIC data(/D/R)	:IBM IBM format(/R)	:WRD word dump(/D);<CR><LF>
.ASCII ;	:RAD RAD50 dump (/D)	:DEC decimal dump(/D)	:XDC Dis Code(/D/R);<CR><LF>
.ASCII ;	:SWP swap bytes (/D/R)	:NSW noswap bytes(/D/R);<CR><LF>
.ASCII ;	:FIL fill last blk (/W)	:NFL Don't fill last block (/W);<CR><LF>
	.ASCII	;/O	Output dump to file & terminal;<CR><LF>
	.ASCII	;/P:n	Fill last data file block with bytes of value n (default 0);<CR><LF>
	.ASCII	;/R:n	Read n blocks (Default to next tape mark);<CR><LF>
	.ASCII	;/S:n	Move to section n (default 0);<CR><LF>
	.ASCII	;/T:n	Write n tape marks (default 1);<CR><LF>
	.ASCII	;/U	Close files, unload tape & exit;<CR><LF>
	.ASCII	;/V	Verify current status;<CR><LF>
	.ASCIZ	;/W:n	Write n PDP blocks to tape (default file);
	.EVEN

MTNAME:	.RAD50	/MT    /
DEFLT:	.RAD50	/DATDATDMPNON/	;DEFAULT EXTENSIONS FOR CSIGEN

	.SBTTL	DATA STORAGE
TMFG:	.BYTE	0,0	;USED FOR DETECTING LOGICAL END OF TAPE
PBDONE:	.BYTE	0	;FLAG TO CONTROL PRINTING BLOCK NUMBER
OUTFLG:	.BYTE	0	;NON ZERO IF OUTPUT FILE
GFLG:	.BYTE	0	;IGNORE END OF TAPE IF NON ZERO
PEOT:	.BYTE	0	;MADE NO ZERO AT PHYSICAL END OF TAPE
EFLG:	.BYTE	0	;NO ZERO IF E SWITCH OCCURRED
PNTPL:	.BYTE	0,200	;FOR CONSTUCTING TEXT IN BYTPNT
AFLG:	.BYTE	0	;NON ZERO FOR A SWITCH
OFLG:	.BYTE	0	;SET IF DUMP TO FILE & TERMINAL
	.EVEN

INFCNT:	.WORD	0	;NUMBER OF CHARS IN INPUT FILE BUFFER
INFBLK:	.WORD	0	;BLOCK NUMBER IN INPUT FILE
INFBUF:	.WORD	0	;ADDRESS OF 512 BYTE BUFFER FOR INPUT FILE
INFPTR:	.WORD	0	;CURRENT POSDITION IN INPUT FILE BUFFER
OUTBCT:	.WORD	0	;COUNT OF PDP BLOCKS FOR EACH OUTPUT /R
DATABF:	.WORD 	0	;ADDRESS OF DATA BUFFER
DATAPT:	.WORD	0	;CURRENT POSITION IN DATA BUFFER
DATACT:	.WORD	512.	;COUNT IN DATA FILE BUFFER
DATABK:	.WORD	0	;BLOCK NUMBER FOR DATA FILE
DTYPE:	.WORD	0	;TYPE OP DISPLAY OR PROCESSING FOR DATA
SPFLEN:	.WORD	0	;LENGTH PARAMETER FOR SPFUN CALL
SPFCDE:	.WORD	0	;CODE FOR SPFUN CALL
COMAND:	.WORD	0	;FLAGS FOR SWITCHES RECEIVED
BVAL:	.WORD	0	;RECIEVES VALUE TYPE WITH B SWITCH
DVAL:	.WORD	0	;RECIEVES VALUE TYPE WITH D SWITCH
FVAL:	.WORD	0	;VALUE OF F SWITCH-STARTING BYTE POSITION
RVAL:	.WORD	0	;RECIEVES VALUE TYPE WITH R SWITCH
SVAL:	.WORD	0	;RECIEVES VALUE TYPE WITH S SWITCH
WVAL:	.WORD	0	;RECIEVES VALUE TYPE WITH W SWITCH
TVAL:	.WORD	1	;NUMBER OF TAPE MARKS TO WRITE
SPST:	.WORD	0	;SYSTEM ASSIGNED STACK POINTER
FVALT:	.WORD	0	;TEMPORARY STORE FOR FVAL
OUTFBF:	.WORD	0	;ADDRESS OF 256 WORD OUTPUT BUFFER
MTBLEN:	.WORD	0	;NUMBER OF WORDS TO READ MT BLOCKS
MTBLK:	.WORD	0	;CURRENT MT BLOCK NUMBER IN FILE
SPFBLK:	.WORD	0,0,0,0	;AREA FOR RECEIVING ADDITIONAL DATA FROM MT
EMTBUF:	.BLKW	10	;SPACE FOR EMT CALLS
MARKNO:	.WORD	0	;CURRENT TAPE MARK NUMBER
PENDPT:	.WORD	PENDBF
PENDBF:	.BLKB	160.	;FOR TWO LINES OF TEXT
LSTBLK:	.WORD	0	;NUMBER OF LAST BLOCK READ
LSTBLEN:.WORD	0	;LENGTH OF LAST BLOCK READ
VALCDE:	.WORD	0	;CODE FOR VALR1 TO DIRECT OUTPUT TEXT
PLACE:	.WORD	TOTERM	;OUTPUT PLACE FOR TEXT TERMINAL OR BUFFER
HRDCNT:	.WORD	0	;COUNT OF HARDWARE ERRORS
TOTBLK:	.WORD	0	;TOTAL NUMBER OF BLOCKS ON TAPE
OUTBLK:	.WORD	0	;OUTPUT BLOCK NUMBER
OUTCNT:	.WORD	512.	;COUNT IN OUTPUT BUFFER
OUTPTR:	.WORD	0	;CURRENT POSITION IN OUTPUT BLOCK
PBLDIR:	.WORD	0	;PLACE FOR PBLOCK TO SEND OUTPUT TO
LSTFNC:	.WORD	0	;LAST TAPE ERROR FUNCTION ANALYSED
WRTLEN:	.WORD	512.	;LENGTH OF BLOCKS ON WRITE
PADBYT:	.WORD	0	;VALUE TO PAD SHORT BLOCKS WITH
FNAMES:	.BLKW	39.	;FOR FILENAMES FROM CSISPC
DISLEN:	.WORD	0	;?
LINECT:	.WORD	0	;COUNT OF LINES WHEN DUMPING
FORMAT:	.WORD	ZASC	;FORMAT OF TAPE FOR DUMPING
NSOFAR:	.WORD	0	;COUNT OF BYTES WHEN CONSTRUCTING WRITE BUFFER
MBFPTR:	.WORD	0	;BUFFER ADDRESS WHEN CONSTRUCTING WRITE BUFFER
BYTCNT:	.WORD	0	;COUNT DOWN FOR BYTES WHEN READING FROM FILE
FILEN:	.WORD	-2	;LENGTH OF INPUT FILE
XDCFLG:	.WORD	-1	;FLAG FOR ESCAPE CODE WITH CDC EXTENDED D CODE
MTBUF:	.WORD	.+2	;CURRENT LOWER LIMIT ON LOWER SPACE
			;ADDRESS OF MAG TAPE BUFFER START
	.END	START