.TITLE	XMT
	.IDENT	/01/
;
; COPYRIGHT (C) 1977
; DIGITAL EQUIPMENT CORPORATION
;
; THIS SOFTWARE IS FURNISHED UNDER A LICENSE FOR USE ONLY ON A
; SINGLE COMPUTER SYSTEM AND MAY  BE  COPIED   ONLY  WITH  THE
; INCLUSION OF THE ABOVE COPYRIGHT NOTICE.  THIS SOFTWARE,  OR
; ANY OTHER COPIES THEREOF, MAY NOT BE PROVIDED  OR  OTHERWISE
; MADE AVAILABLE TO ANY OTHER PERSON   EXCEPT FOR  USE ON SUCH
; SYSTEM AND TO ONE WHO AGREES TO THESE LICENSE  TERMS.  TITLE
; TO AND OWNERSHIP OF THE SOFTWARE SHALL AT ALL  TIMES  REMAIN
; IN DEC.
;
; THE INFORMATION IN THIS DOCUMENT IS SUBJECT TO CHANGE WITHOUT
; NOTICE AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL
; EQUIPMENT CORPORATION.
;
; DEC ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF
; ITS SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DEC.
;
; AUTHOR:  P. VAN OOSTRUM, SEPTEMBER 1977.
;
	.SBTTL	MACROS
	.MCALL	GCMLB$,GCML$
	.MCALL	CSI$,CSI$1,CSI$2,CSI$SW,CSI$SV,CSI$ND
	.MCALL	FSRSZ$,FINIT$
	.MCALL	QIOW$,DIR$
	.MCALL	FDBDF$,FDAT$A,FDRC$A,FDOP$A,FDBF$A
	.MCALL	NMBLK$
	.MCALL	OFNB$R,OFNB$W,GET$,PUT$,CLOSE$
;
	.MCALL	ALUN$,QIOW$,DIR$,EXIT$S
;
.MACRO	PRINT	A,B,C
	MOV	A,TIWLB+Q.IOPL
	MOV	B,TIWLB+Q.IOPL+2
	.IF NB	C
	MOV	C,TIWLB+Q.IOPL+4
	.IFF
	MOV	#40,TIWLB+Q.IOPL+4
	.ENDC
	DIR$	#TIWLB
	.ENDM
;
.MACRO	DISPL	A,B
	.PSECT	TEXT
$$1=.
	.ASCII	\A\
$$2=.-$$1
	.PSECT
	PRINT	#$$1,#$$2,B
	.ENDM
;
	.SBTTL	LOCAL DEFINITIONS
;

TILEN=72.
ALU:	ALUN$	1,TI,0
TIWLB:	QIOW$	IO.WLB,5,1,,TISB
TIRLB:	QIOW$	IO.RLB,5,1,,TISB,,<TIBUF,TILEN>
TISB:	.BLKW	2
TIBUF:	.BLKB	TILEN+2
	.EVEN
;
CLEN=82.
CBUF:	.BLKB	CLEN
	FSRSZ$	2
	CSI$
CSIBLK:	.BLKB	C.SIZE
GCLBLK:	GCMLB$	2,XMT,CBUF,1
DSPT=CSIBLK+C.DSDS
CMD=GCLBLK+G.CMLD+2
CMDL=GCLBLK+G.CMLD
;
	.PSECT	BUF,D
BUFLEN=8192.
	.BLKB	2		;MUST BE BEFORE RECBUF!!
RECBUF:	.BLKB	BUFLEN+2
	.EVEN
	.PSECT
;
SWTAB:	CSI$SW	LI,LIMSK,,,,LISV
	CSI$SW	AS,ASMSK
	CSI$SW	EB,EBMSK
	CSI$SW	UCX,UCMK!UCXMK,,,,,EXACT
	CSI$SW	UC,UCMK,,,,,EXACT
	CSI$SW	BL,BLMK,NMASK,CLEAR,NEG
	CSI$SW	FTN,FTNMK,NMASK,CLEAR,NEG,,EXACT
	CSI$SW	CRLF,CRLFMK,NMASK,CLEAR,NEG,,EXACT
	CSI$SW	TR,TRMSK,,,,TRSV
	CSI$SW	RC,RCMK,,,,RCSV,EXACT
	CSI$SW	EOF,EOFMK,NMASK,CLEAR,NEG,,EXACT
	CSI$SW	TM,TMMK,,,,TMSV,EXACT
	CSI$SW	DENS,DENSMK,,,,DENSSV,EXACT
	CSI$SW	RW,RWMK				;REWIND
	CSI$SW	DE,DEMK,NMASK,CLEAR,NEG
	CSI$SW	SP,SPMK,NMASK,CLEAR,NEG
	CSI$SW	P,0,,,,PSV,EXACT
	CSI$ND
;
LIMSK=1
ASMSK=2
EBMSK=4
CONVMK=6
UCMK=10
UCXMK=20
BLMK=40
FTNMK=100
CRLFMK=200
TRMSK=400
RCMK=1000
EOFMK=2000
TMMK=4000
DENSMK=10000
RWMK=20000
DEMK=40000
SPMK=100000
;
DEFSW=CRLFMK		;DEFAULT SWITCH SETTING
;
INLUN=4
OUTLUN=3
FILTP=8.
FILIN=8.
FILOUT=16.
;

RCSV:	CSI$SV	DECIMAL,RCLN,2
	CSI$ND
TMSV:	CSI$SV	DECIMAL,SKIPF,2
	CSI$SV	DECIMAL,READF,2
	CSI$ND
DENSSV:	CSI$SV	DECIMAL,DENS,2
	CSI$ND
LISV:	CSI$SV	DECIMAL,LILN,2
	CSI$ND
TRSV:	CSI$SV	DECIMAL,TRL1,2
	CSI$SV	DECIMAL,TRL2,2
	CSI$ND
PSV:	CSI$SV	ASCII,PARITY,1
	CSI$ND

LILN:	0
TRL1:	0
TRL2:	0
PARITY:	0
RCLN:	0
SKIPF:	0
READF:	0
DENS:	0

DENSTB:	800.,0
	8.,0
	556.,0
	5.,0
	1600.,4000
	16.,4000
	200.,2
	2.,2		;THIS MUST BE THE LAST ONE

PARLST:	'C,PARC
	'S,PARS
	'O,PARO
	'E,PARE
	0,0
;
FDBIN:	FDBDF$
	FDRC$A	,RECBUF,BUFLEN
	FDOP$A	INLUN,DSPT,FNB,FO.RD
	FDBF$A
;
FDBOUT:	FDBDF$
	FDAT$A	R.VAR,FD.CR
	FDRC$A	,RECBUF,BUFLEN
	FDOP$A	OUTLUN,DSPT,FNB,FO.WRT
	FDBF$A
;
FNB:	NMBLK$	,TXT,,SY
;
XMTTYP:	0
MASK:	0
NMASK:	0
SPACE:	0
DELFLG:	0
INFLAG:	0
OUTFLG:	0
RECLEN:	0
INDEV:	0
OUTDEV:	0
ERRCOD:	0
INOPEN:	0
OPOPEN:	0
DVATT:	0
LSTCHR:	0
OUTREC:	0
OUTLEN:	0
NXTREC:	0
RECADD:	0
RESLEN:	0
EOFFLG:	0
DV:	.BYTE	'M,0	;FOR ALL MX: DEVICES (MT: MM:)
INDV:	0		;FLAG FOR INPUT DEVICE
OUTDV:	0		;FLAG FOR OUTPUT DEVICE

;
IRS=36
ESC=33
LF=12
VT=13
FF=14
CR=15
EOF=66
EOT=67
ETX=3
;
	.PAGE
	.SBTTL	COMMAND LINE PROCESSING
XMT::	FINIT$
	DIR$	#ALU		;ASSIGN LUN FOR COMMAND INPUT
;
REXMT:	CLR	XMTTYP
	CLR	NMASK
	CLR	DENS
	CLR	PARITY
	CLR	LILN
	CLR	TRL1
	CLR	TRL2
	CLR	RCLN
	MOV	#-1,SKIPF	;SUPPLY DEFAULTS FOR /TM
	MOV	#-1,READF
	MOV	#DEFSW,MASK	;PRESET DEFAULT SWITCHES
	GCML$	#GCLBLK			;GET COMMAND LINE
	BCS	CMDERX			;ERROR
	TST	CMDL
	BEQ	REXMT			;EMPTY LINE
	CSI$1	#CSIBLK,CMD,CMDL	;PARSE
	BCS	CMDERR			;ERROR IN COMMAND
	CSI$2	#CSIBLK,INPUT,#SWTAB	;GET INPUT FILE
	BCS	CMDER1			;ERROR
	CALL	OPENIN			;OPEN INPUT FILE
	BCS	CMDER1			;ERROR IN OPEN
	BIS	CSIBLK+C.MKW1,MASK
	CSI$2	#CSIBLK,OUTPUT,#SWTAB	;GET OUTPUT FILE
	BCS	CMDER2			;ERROR
	CALL	OPENOU			;OPEN OUTPUT FILE
	BCS	CMDER2
	BIS	CSIBLK+C.MKW1,MASK	;GET SWITCHES
	BR	SETUP
;
	.ENABL	LSB
CMDERX:	CMPB	GCLBLK+G.ERR,#GE.EOF	;END-OF-FILE ON COMMAND
	BNE	CMDERR			;NO, ERROR
	EXIT$S
CMDERR:	DISPL	<XMT - ERROR IN COMMAND LINE>
	BR	99$
CMDERS:	DISPL	<XMT - ILLEGAL SWITCH COMBINATION>
	BR	99$
CMDER1:	DISPL	<XMT - ERROR IN INPUT FILE SPEC>
	BR	99$
CMDER2:	DISPL	<XMT - ERROR IN OUTPUT FILE SPEC>
;
99$:	PRINT	CMD,CMDL
	JMP	CLOFIL			;CLOSE OPENED FILES
	.DSABL	LSB
;
;	SET UP COPY PARAMETERS
;
SETUP:	TST	XMTTYP
	BEQ	CMDERR			;MT:=MT: COPY 
	BIT	#TMMK!RWMK!DENSMK,MASK	;CHECK FOR /TM, /RW , /DENS
	BEQ	25$			;JUMP IF NOT GIVEN
	CMP	XMTTYP,#FILIN+FILOUT	;IS IT A FILE COPY?
	BEQ	CMDERR			;YES, ILLEGAL SWITCH

	BIT	#DENSMK,MASK		;/DENS SPECIFIED?
	BEQ	15$			;NO
	MOV	#DENSTB,R0
5$:	CMP	(R0),DENS		;SEARCH IN TABLE
	BEQ	10$			;FOUND
	CMP	(R0)+,(R0)+		;IS IT THE LAST ONE?
	BNE	5$			;NO, CONTINUE
	BR	CMDERR			;YES, ILLEGAL VALUE
10$:	MOV	2(R0),DENS		;GET MT: PARAMETER

15$:	BIT	#TMMK,MASK		;/TM GIVEN
	BEQ	25$			;NO, USE DEFAULTS
	TST	INDV			;IS IT MT: INPUT
	BNE	CMDERR			;NO, ILLEGAL SWITCH
	TST	READF			;/TM:M:N GIVEN?
	BPL	25$			;YES, O.K
	MOV	SKIPF,READF		;/TM:N WIL BECOME /TM:  :N
	NEG	SKIPF			;M=+1 IF /TM ONLY GIVEN
					;M<0 IF /TM:N GIVEN
25$:	MOV	MASK,R0
	BIC	#^C<CONVMK>,R0		;GET CONVERSION SWITCH
	CMP	R0,#CONVMK		;BOTH /AS AND /EB?
	BEQ	CMDERS			;YES, ERROR
	ADD	XMTTYP,R0
	MOV	TRTBL-FILTP(R0),TRANSL	;GET TRANSLATION ROUTINE
	BIC	NMASK,MASK		;ERASE NEGATED FLAGS
	BIT	#BLMK,NMASK		;/-BL GIVEN
	BEQ	32$			;NO
	BIS	#BLMK,MASK		;SET /BL ALSO
32$:
;
	BIT	#UCMK,MASK		;UPPER CASE CONVERSION?
	BEQ	60$			;NO
	MOV	#UC,TR1
	BIT	#UCXMK,MASK
	BEQ	35$
	MOV	#UCX,TR1		;GET TRANSLATION ROUTINE
35$:	CMP	TRANSL,#NIL		;OTHER TRANSLATION SPECIFIED?
	BNE	40$			;YES
	MOV	TR1,TRANSL		;OVERWRITE THIS
	BR	60$
;
40$:	CMP	TRANSL,#ASTOEB		;EBCDIC OUTPUT?
	BNE	45$			;NO,ASCII
	MOV	TRANSL,TR2		;COMBINE WITH UC
	BR	50$
45$:	MOV	TR1,TR2			;DO UC CONVERSION AFTER
	MOV	TRANSL,TR1		;ASCII CONVERSION
;
50$:	MOV	#TRUC,TRANSL
;
60$:	MOV	#100,SPACE		;EBCDIC SPACE
	TST	OUTDV			;MT: OUTPUT?
	BEQ	70$			;O.K.
	MOV	MASK,R0
	BIC	#^C<CONVMK>,R0		;GET TRANSL SWITCH
	CMP	R0,#EBMSK		;/EB
	BEQ	70$			;YES
	MOV	#40,SPACE		;SET ASCII SPACE
70$:
	MOV	MASK,DELFLG		;GET /DE SWITCH
	BIC	#^C<DEMK>,DELFLG
;
	MOV	#PARLST,R0
75$:	CMP	PARITY,(R0)+		;CHECK /P SWITCH
	BEQ	80$			;FOUND
	TST	(R0)+			;END REACHED?
	BNE	75$			;NO, CONTINUE
78$:	JMP	CMDERR			;ERROR!
80$:	MOV	(R0)+,PARITY		;SET ROUTINE ADDRESS

	CMP	LILN,#80.
	BGT	78$			;ERROR IF /LI:N>80

	BIT	#TRMSK,MASK		;/TR GIVEN?
	BEQ	100$			;NO
	TST	TRL2			;/TR:M:N GIVEN?
	BNE	95$			;YES
	MOV	TRL1,TRL2		;N NOT GIVEN, USE M
	BNE	90$			;IF N GIVEN
	MOV	RCLN,TRL2		;IF ONLY /TR, USE /RC:N PARAMETER
	BEQ	78$			;ERROR IF NOT GIVEN
90$:	CLR	TRL1
95$:	TST	RCLN			;TEST IF /RC:N GIVEN
	BNE	100$			;YES
	MOV	TRL2,RCLN		;NO, USE /TR PARAMETER
100$:
	BIT	#RCMK,MASK		;/RC GIVEN
	BEQ	110$			;NO
	TST	RCLN			;CHECK IF PARAMETER GIVEN
	BEQ	78$			;ERROR IF NOT
110$:
	CLR	OUTFLG
	MOV	#RECBUF,RECADD
	CLR	RESLEN
	CLR	EOFFLG
	JMP	XMTLP			;TRANSFER
;
	.PAGE
;
;
TRANSL:	0				;ADDRESS OF TRANSLATE ROUTINE
TR1:	0
TR2:	0
;
TRTBL:				;MT:=FILE
	NIL		;DEFAULT
	EBTOAS		; /AS
	ASTOEB		; /EB
	NIL
		;FILE=MT:
	NIL		;DEFAULT
	EBTOAS		; /AS
	ASTOEB		; /EB
	NIL	
		;FILE=FILE
	NIL		;DEFAULT
	EBTOAS		; /AS
	ASTOEB		; /EB
	NIL
;
;	SPECIAL CONVERSION ROUTINES
;
NIL:	RETURN
;
;
TRUC:
	MOV	R5,-(SP)		;SAVE PARAMETER LIST
	CALL	@TR1			;FIRST TRANSLATION
	MOV	(SP)+,R5
	JMP	@TR2			;SECOND TRANSLATION
;
UC:	TST	(R5)+
	MOV	(R5)+,R1		;BUFFER ADDRESS
	TST	(R5)+
	MOV	@(R5)+,R3		;BUFFER LENGTH
	BEQ	30$			;EMPTY
;
10$:	MOVB	(R1),R0			;GET BYTE
	BIC	#177600,R0
	CMP	R0,#140
	BLO	20$			;UPPER CASE
	CMP	R0,#177
	BHIS	20$			;DEL
	SUB	#40,R0			;LOWER CASE TO UPPER CASE
20$:	MOVB	R0,(R1)+		;RESTORE BYTE
	DEC	R0
	BNE	10$
30$:	RETURN
;
UCX:	TST	(R5)+
	MOV	(R5)+,R1		;BUFFER ADDRESS
	TST	(R5)+
	MOV	@(R5)+,R3		;BUFFER LENGTH
	BEQ	30$			;EMPTY
;
10$:	MOVB	(R1),R0			;GET BYTE
	BIC	#177600,R0
	CMP	R0,#174			; BAR ?
	BNE	15$			; NO
	MOV	#41,R0			; MAKE !
15$:	CMP	R0,#140
	BLO	20$			;UPPER CASE
	CMP	R0,#177
	BHIS	20$			;DEL
	SUB	#40,R0			;LOWER CASE TO UPPER CASE
20$:	MOVB	R0,(R1)+		;RESTORE BYTE
	DEC	R0
	BNE	10$
30$:	RETURN
;
	.PAGE
	.SBTTL	MAIN LOOP
	.ENABL	LSB

XMTLP:
	CALL	GET			;READ A RECORD
	BCC	5$
	JMP	90$			;ERROR ON INPUT
5$:	CMP	INFLAG,#EOF		;END-OF-FILE?
	BNE	7$
	JMP	ENDFIL			;YES
;
7$:
;
10$:	MOV	#RECBUF,OUTREC
	ADD	TRL1,OUTREC		;SKIP IF NECESSARY
	SUB	TRL1,RECLEN		;ADJUST RECORD LENGTH
	BLT	XMTLP			;SKIP IF TOO SMALL
	TST	TRL2			;TRUNCATION REQUIRED?
	BEQ	20$			;NO.
	CMP	TRL2,RECLEN		;IS IT BIG ENOUGH?
	BGE	20$			;NO, LEAVE IT
	MOV	TRL2,RECLEN		;USE TRUNCATED RECORD LENGTH
20$:	MOV	RECLEN,OUTLEN		;SET DEFAULT OUTPUT
	CMP	INFLAG,#EOF		;END-OF-FILE?
	BNE	70$			;NO
	MOV	#ETX,OUTFLG
	CALL	PUT			;SEND ETX RECORD
	JMP	ENDFIL
;
110$:			;FIXED LENGTH RECORD OUTPUT
	TST	RECLEN
	BEQ	XMTLP		;EMPTY RECORD?
	MOV	RCLN,OUTLEN
	CMP	RCLN,RECLEN	;RECORD IN BLOCK?
	BLE	120$		;YES, OK
	MOV	RECLEN,OUTLEN	;TRUNCATE IF TOO SMALL
120$:	SUB	OUTLEN,RECLEN
	CALL	PUT
	ADD	OUTLEN,OUTREC	;UPDATE ADDRESS
	BR	110$

;
;	COMMON OUTPUT CALL
;
70$:	TST	PARITY			;PARITY HANDLING REQUIRED?
	BEQ	50$			;NO!
	MOV	OUTREC,R0		;GET RECORD ADDRESS
	MOV	RECLEN,R1		;GET RECORD LENGTH
	BEQ	50$			;EMPTY RECORD
25$:	JMP	@PARITY			;JUMP TO PARITY HANDLING

PARC:	BICB	#200,(R0)+		;CLEAR PARITY
	BR	35$
PARS:	BISB	#200,(R0)+		;SET PARITY
	BR	35$
PARO:	MOV	#1,R3			;ODD PARITY
	BR	PARG
PARE:	CLR	R3			;EVEN PARITY
PARG:	MOVB	(R0),R2			;GET CHARACTER
30$:	ASLB	R2
	BEQ	32$			;BRANCH IF DONE
	ASLB	R2			;GET 2 BITS
	BVC	30$			;V=XOR OF 2 BITS
	INC	R3			;COUNT ODD PARITY
	BR	30$			;CONTINUE
32$:	ASLB	(R0)			;REMOVE OLD PARITY BIT
	ASRB	R3			;GET CALCULATED PARITY
	RORB	(R0)+			;SHIFT IN CHARACTER
35$:	SOB	R1,25$			;LOOP FOR ALL CHARACTERS

50$:	MOV	OUTREC,PL2+2
	MOV	OUTREC,PL2+4		;SET UP PARAMETERS FOR TRANSL
	MOV	#PL2,R5
	CALL	@TRANSL			;TRANSLATE ROUTINE
	BIT	#RCMK,MASK		;FIXED LENGTH OUTPUT?
	BNE	110$			;YES
	MOV	INFLAG,OUTFLG
	CALL	PUT			;WRITE THE RECORD
	BCS	80$			;ERROR ON OUTPUT
	JMP	XMTLP			;NEXT RECORD
;
ERREOF:
80$:	;ERROR ON OUTPUT
;
	DISPL	<XMT - ERROR ON OUTPUT FILE>
	BR	99$
;
90$:	;ERROR ON INPUT
;
	DISPL	<XMT - ERROR ON INPUT FILE>
;
99$:	PRINT	CMD,CMDL
	MOV	#ERNO,R0
	CLR	R2
	MOVB	ERRCOD,R1
	CALL	$CBDSG
	SUB	#ERMSG,R0		;LENGTH OF MESSAGE
	PRINT	#ERMSG,R0
;
;	HERE FOR END-OF-FILE
;
CLOFIL:	CLR	DELFLG		;PREVENT DELETE IF ERRORS
ENDFIL:	CALL	CLOSOU
	CALL	CLOSIN			;CLOSE FILES
	JMP	REXMT
	.DSABL	LSB
;
PL1:	3,RECBUF,RECBUF,RECLEN		;PAR LIST FOR TRANSL ROUTINE
PL2:	3,RECBUF,RECBUF,OUTLEN		;IDEM
;
ERMSG:	.ASCII	/ERROR CODE NO. /
ERNO:	.ASCII	/     /
ERMSGL=.-ERMSG
	.EVEN
	.PAGE
	.SBTTL	OPEN AND CLOSE
;
;	OPEN INPUT FILE
;
OPENIN:	MOV	#FDBIN,R0
	MOV	#FDBIN+F.FNB,R1
	MOV	#DSPT,R2
	MOV	#FNB,R3
	CALL	.PARSE			;SET UP FILE NAME BLOCK
	BCS	20$			;ERROR
	MOV	N.DVNM(R1),INDEV
;
	MOV	INDEV,R4
	CALL	CHKDV			;CHECK FOR SPECIAL DEVICE
	MOV	R4,INDV			;SET FLAG
	BEQ	20$			;YES, DON'T OPEN
	ADD	#FILIN,XMTTYP		;INDICATE FILE INPUT
	OFNB$R	#FDBIN			;OPEN INPUT FILE
	BCS	20$			;ERROR
	INC	INOPEN			;SET FLAG
20$:	RETURN
;
;	OPEN OUTPUT FILE
;
OPENOU:	MOV	#FDBOUT,R0
	MOV	#FDBOUT+F.FNB,R1
	MOV	#DSPT,R2
	MOV	#FNB,R3
	CALL	.PARSE			;SET UP FILE NAME BLOCK
	BCS	20$			;ERROR
	MOV	N.DVNM(R1),OUTDEV
;
	MOV	OUTDEV,R4
	CALL	CHKDV			;CHECK FOR SPECIAL DEVICE
	MOV	R4,OUTDV		;SET FLAG
	BEQ	20$			;YES, DON'T OPEN
	ADD	#FILOUT,XMTTYP		;INDICATE FILE OUTPUT
	MOVB	#R.VAR,FDBOUT+F.RTYP
	CLR	FDBOUT+F.RSIZ
	MOVB	#FD.CR,FDBOUT+F.RATT	;SET UP DEFAULT TYPE
	BIT	#RCMK,MASK		;FIXED LENGTH RECORDS?
	BEQ	5$			;NO
	MOVB	#R.FIX,FDBOUT+F.RTYP
	MOV	RCLN,FDBOUT+F.RSIZ	;YES, SETUP PARAMETERS
5$:	BIT	#FTNMK,MASK		;FORTRAN CONTROL CHARS?
	BEQ	10$			;NO
	MOVB	#FD.FTN,FDBOUT+F.RATT
10$:	OFNB$W	#FDBOUT			;OPEN OUTPUT FILE
	BCS	20$			;ERROR
	INC	OPOPEN			;SET FLAG
20$:	RETURN
;
;	CLOSE INPUT FILE
;
	.ENABL	LSB
CLOSIN:	TST	INOPEN			;IS FILE OPENED?
	BNE	5$			;YES
	TST	INDV			;MT: INPUT?
	BEQ	50$			;YES, CHECK ATTACH
	BR	20$			;NO, RETURN
5$:	CLR	INOPEN
	TST	INDV			;MT:?
	BNE	10$			;NO, FILE
;
60$:	MOV	#IO.DET,R0
	CALL	DVQIO			;DETACH
	CLR	DVATT
	BR	20$
;
10$:	TST	DELFLG			;DELETE INPUT?
	BEQ	15$			;NO
	MOV	#FDBIN,R0
	CALL	.DLFNB			;DELETE FILE
	BCC	20$			;O.K.
15$:	CLOSE$	#FDBIN
20$:	RETURN
;
;	CLOSE OUTPUT FILE
;
CLOSOU:	TST	OPOPEN			;IS FILE OPENED
	BEQ	40$			;NO
	CLR	OPOPEN
	TST	OUTDV			;MT:?
	BEQ	55$			;YES
;
	BIT	#SPMK,MASK		;SPOOL OUTPUT?
	BEQ	25$			;NO
	MOV	#FDBOUT,R0
	CALL	.PRINT			;REQUEST SPOOLING
	BCC	30$			;O.K.
;
25$:	CLOSE$	#FDBOUT			;CLOSE FILE
	BCC	30$			;SUCCESSFUL
	CLR	DELFLG			;PREVENT DELETE
30$:	RETURN
;
40$:	TST	OUTDV	
	BNE	20$			;FILE OUTPUT
50$:	TST	DVATT			;MT: ATTACHED
	BNE	60$			;YES, DETACH
	BR	20$			;NO, RETURN

55$:	BIT	#EOFMK,NMASK		;/-EOF GIVEN?
	BNE	60$			;YES, DON'T WRITE TAPEMARK
	MOV	#IO.EOF,R0
	CALL	DVQIO			;WRITE 2 TAPEMARKS
	BCS	80$			;IF ERROR,  STOP
	CALL	DVQIO
	BCS	80$
	MOV	#IO.SPF,R0		;SPACE BACKWARDS
	MOV	#-1,QIODV+Q.IOPL
	CALL	DVQIO
	BCC	60$			;O.K FINISHED
80$:	TST	(SP)+			;DELETE RETURN ADDRESS
	JMP	ERREOF

	.DSABL	LSB
;
	.PAGE
	.SBTTL	MT: QIO HANDLING

;	OPEN FOR MT;

DVOPN:	INC	DVATT			;SET ATTACHED FLAG
	MOV	#IO.ATT,R0
	CALL	DVQIO			;ATTACH MT:
	BCS	9$			;ERROR ON ATTACH
	BIT	#RWMK,MASK		;REWIND?
	BEQ	5$			;NO
	MOV	#IO.RWD,R0
	CALL	DVQIO			;REWIND MT:
	BCS	9$			;ERROR ON REWIND
5$:	BIT	#DENSMK,MASK		;/DENS SPECIFIED?
	BEQ	7$			;NO
	MOV	DENS,QIODV+Q.IOPL	;SELECT DENSITY
	MOV	#IO.STC,R0
	CALL	DVQIO
	BCS	9$			;IF ERROR
7$:	MOV	SKIPF,QIODV+Q.IOPL	;NBR OF TAPE MARKS TO BE SKIPPED
	BLE	9$			;NONE
	MOV	#IO.SPF,R0
	CALL	DVQIO			;ISSUE SKIP
9$:	RETURN

DVWLB:	MOV	OUTLEN,QIODV+Q.IOPL+2
	MOV	OUTREC,QIODV+Q.IOPL
;
DVQIO:	MOV	R0,QIODV+Q.IOFN
	DIR$	#QIODV
	BCS	20$			;ERROR
	TSTB	DVSB
	BMI	20$			;ERROR
	CLC
	RETURN
20$:	SEC				;RETURN ERROR CODE
	RETURN
;
QIODV:	QIOW$	0,0,1,,DVSB,,<RECBUF,BUFLEN>
;
DVSB:	.BLKW	2
;	SUBROUTINE CHKDV
;	CHECK DEVICE NAME FOR SPECIAL NON FILES-11 DEVICE
;	(E.G. MM: OR MT:), SPECIFIED IN DV
;	IF THE SECOND BYTE OF DV IS 0, ONLY THE FIRST BYTE IS CHECKED
;	SO ALL DEVICES MX: CAN BE TREATED AS SPECIAL
;
CHKDV:	TSTB	DV+1			;TEST IF GENERIC DEVICE
	BNE	10$			;NO, NORMAL TEST
	BIC	#^C377,R4		;YES, DON'T CHECK SECOND BYTE
10$:	CMP	R4,DV			;IS IT SPECIAL DEVICE
	BNE	15$			;NO, LEAVE WITH R4 .NE. 0
	CLR	R4			;YES, LEAVE WITH R4=0
15$:	RETURN
	.PAGE
	.SBTTL	GET
;
;	READ A RECORD
;
GET:
	CLR	INFLAG
	CLR	RECLEN			;RECORD LENGTH
	TST	INDV			;MT: INPUT?
	BNE	20$			;NO, FILE READ
;
;	MT: INPUT
;
	TST	INOPEN			;MT: OPENED
	BNE	5$			;YES
;
	MOV	#INLUN,QIODV+Q.IOLU
	CALL	DVOPN			;OPEN MT:
	BCS	9$			;ERROR
	INC	INOPEN			;SET OPEN FLAG
	MOV	#RECBUF,QIODV+Q.IOPL
	MOV	#BUFLEN,QIODV+Q.IOPL+2
;
5$:	MOV	#IO.RLB,R0
	CALL	DVQIO			;READ
	BCC	10$			;O.K.
	CMPB	#IE.EOF,DVSB		;EOF RECEIVED?
	BNE	9$			;NO, ERROR
	DEC	READF			;COUNT THIS TAPE MARK
	BGT	5$			;CONTINUE
7$:	MOV	#EOF,INFLAG		;SET EOF FLAG
	JMP	40$
9$:	JMP	90$
;
10$:
	MOV	DVSB+2,RECLEN		;RECORD LENGTH
	BR	40$
;
;	FILE READ
;
20$:	MOV	RECADD,R2
	MOV	#RECBUF,R1		;INITIALIZE
	MOV	R1,RECADD
	MOV	RESLEN,R0
	MOV	R0,RECLEN		;ANYTHING LEFT?
	BEQ	34$			;NO, GET INPUT
	BIT	#CRLFMK,MASK		;SEARCH FOR CRLF?
	BEQ	34$			;NO
;
30$:	MOVB	(R2)+,(R1)+
	DEC	R0
	BNE	30$			;MOVE RECORD BACK
	MOV	RESLEN,R0
	MOV	#RECBUF,R1		;RESTORE REGS
32$:	CMPB	(R1),#LF		;SEARCH FOR END CHAR
	BEQ	36$
	CMPB	(R1),#FF
	BEQ	36$
	CMPB	(R1),#VT
	BEQ	36$
	INC	R1			;NEXT CHAR
	DEC	R0
	BNE	32$
	MOV	R1,RECADD		;END OF BUFFER
	CLR	RESLEN			;NO RESIDUE
;
33$:	TST	EOFFLG			;END OF FILE?
	BNE	38$			;YES, STOP
	BITB	#FD.CR!FD.FTN,FDBIN+F.RATT	;END OF LINE?
	BEQ	34$			;NO, GET MORE INPUT
	BR	38$			;YES, RETURN
;
34$:	TST	EOFFLG			;END-OF-FILE?
	BNE	45$			;YES, SET FLAG
;
	MOV	#RECBUF+BUFLEN,R2
	SUB	R1,R2			;CALCULATE BUFFER SPACE
	BLOS	80$			;NO SPACE LEFT
	GET$	#FDBIN,R1,R2		;GET RECORD
	BCC	35$			;O.K.
	CMPB	FDBIN+F.ERR,#IE.EOF	;END-OF-FILE?
	BNE	80$			;NO, ERROR
	INC	EOFFLG			;YES, SET FLAG
	TST	RECLEN			;RECORD EMPTY?
	BEQ	45$			;YES, IGNORE
	BR	38$
35$:
	ADD	FDBIN+F.NRBD,RECLEN	;UPDATE RECORD LENGTH
	BIT	#CRLFMK,MASK		;CR-LF INTERPR.
	BEQ	38$			;NO
	MOV	RECADD,R1		;SET PARAMETERS
	MOV	FDBIN+F.NRBD,R0		;LENGTH OF INPUT RECORD
	BEQ	33$			;EMPTY RECORD
	BR	32$			;RESUME SCAN
;
36$:	DEC	R0			;SKIP END CHARACTER
	MOV	R0,RESLEN		;SAVE RESIDUE LENGTH
	SUB	R0,RECLEN		;UPDATE RECORD LENGTH
	INC	R1
	MOV	R1,RECADD		;SAVE FOR NEXT CALL
	CMPB	-(R1),#LF		;WAS LF?
	BNE	38$			;NOW, O.K. NOW
	DEC	RECLEN			;DELETE LF
	CMPB	-(R1),#CR		;WAS CR-LF?
	BNE	38$			;NO, ONLY LF
	DEC	RECLEN			;DELETE CR-LF
38$:
40$:	CLC
	RETURN
;
45$:	MOV	#EOF,INFLAG
	BR	40$
;
80$:	MOVB	FDBIN+F.ERR,ERRCOD
	BR	95$
;
90$:	MOVB	$DSW,ERRCOD
	BMI	95$
	MOVB	DVSB,ERRCOD
;
95$:	SEC
	RETURN
	.PAGE
	.SBTTL	PUT
;
;	WRITE A RECORD
;
PUT:
	TST	OUTDV			;MT: OUTPUT?
	BNE	20$			;NO FILE
;
;	MT: OUTPUT
;
	TST	OPOPEN			;OPENED?
	BNE	5$			;YES
	MOV	#OUTLUN,QIODV+Q.IOLU
	CALL	DVOPN			;OPEN MT:
	BCS	90$			;ERROR
	INC	OPOPEN			;SET OPEN FLAG
;
5$:	BIT	#BLMK,MASK		;BLANKS INTERPR.
	BEQ	7$			;NO
	CALL	BLSUP
7$:	MOV	#IO.WLB,R0
	CMP	OUTFLG,#ETX		;WRITE ETX?
	BNE	10$			;NO
	CLR	OUTFLG			;INDICATE ACCEPTED
	BIS	#10,R0			;SET ETX WRITE
10$:
12$:	CALL	DVWLB
	BCS	90$			;ERROR
	RETURN
;
;	FILE WRITE
;
20$:	CMP	OUTFLG,#ETX		;ETX WRITE?
	BNE	25$			;NO
	TST	RECLEN
	BEQ	40$			;YES, DON'T WRITE EMPTY REC
;
25$:	BIT	#BLMK,MASK
	BEQ	27$
	CALL	BLSUP
27$:	PUT$	#FDBOUT,OUTREC,OUTLEN
	BCS	80$			;ERROR
40$:	RETURN
;
80$:	MOVB	FDBOUT+F.ERR,ERRCOD
	BR	95$
;
90$:	MOVB	$DSW,ERRCOD
	BMI	95$			;DSW ERROR
	MOVB	DVSB,ERRCOD
;
95$:	SEC
	RETURN
;
	.PAGE
	.SBTTL	MISCELLANEOUS ROUTINES
;
;
BLSUP:
	BIT	#BLMK,NMASK		;-BL SPECIFIED?
	BNE	20$			;YES
	TST	OUTLEN			;EMPTY RECORD?
	BNE	50$			;NO, O.K.
	INC	OUTLEN			;OUTLEN=1
	MOV	#SPACE,OUTREC		;OUTPUT SPACE
	BR	50$
;
20$:	MOV	OUTLEN,R0
	ADD	OUTREC,R0		;POINT BEYOND BUFFER
25$:	DEC	R0			;LAST CHARACTER
	CMP	R0,OUTREC		;ALL CHARS PROCESSED?
	BLO	30$			;YES,STOP
	CMPB	(R0),SPACE		;IS SPACE?
	BEQ	25$			;YES, CONTINUE
30$:	SUB	OUTREC,R0
	INC	R0			;CALC. NEW LENGTH
	MOV	R0,OUTLEN
50$:	RETURN
;
;
	.END	XMT