.SBTTL	PROGRAM FILE LOADER, 4-SEPT-75

;LOAD CONTROL FLAG WORD "LDCNTL"
;BIT15=1 IS HELP, PRINT FILE READ
;WORD = 0	.A10, PDP-10 LOAD
;	1	.A11, PDP-11 LOAD
;	2	.RAM, KL10 C-RAM ZERO
;	3	.RAM, KL10 C-RAM LOAD
;	4	.RAM, KL10 D-RAM LOAD
;	5	.BIN, PDP-11 BIN LOAD
;ACT10		.BIN LOADED AS .A11
;		.SAV LOADED AS .A10

;PROGRAM DETERMINATION & LOAD CONTROL INITIALIZATION

DVLOAD:	NAMEXT			;SETUP NAME.EXT

96$:	TST	R0		;ANY EXT ?
	BNE	4$		;YES
	TSTB	JFILEF		;DOING "J" COMMAND ?
	BEQ	50$		;NO
	MOV	#"CM,R4		;YES, DEFAULT EXT IS "CMD"
	MOV	#"D ,R5
	BR	52$
50$:	TSTB	IFILEF		;DOING "I" COMMAND ?
	BEQ	51$		;NO
	MOV	#"CC,R4		;YES, DEFAULT EXT IS "CCL"
	MOV	#"L ,R5
	BR	52$
51$:	MOV	#"A1,R4		;IF NO EXT, USE "A10"
	MOV	#"0 ,R5
52$:	MOV	R4,EXTBF
	MOV	R5,EXTBF+2

4$:	MOV	#LDCNTL,R3
	TST	(R3)		;IS THIS "HELP"
	BMI	12$		;BR IF YES
	MOV	#TEMP+1,R4
	MOV	#EXTBF+2,R5
	MOVB	(R5),(R4)	;MAKE A WORD OUT OF 2ND & 3RD CHAR
	MOVB	-(R5),-(R4)
	CMPB	#'A,-(R5)	;IS FIRST CHAR AN "A" ?
	BEQ	6$		;BR IF YES
	CMPB	#'B,(R5)	;IS FIRST CHAR A "B" ?
	BEQ	14$		;BR IF YES
	CMPB	#'S,(R5)	;IS FIRST CHAR AN "S" ?
	BEQ	16$		;BR IF YES
	CMPB	#'R,(R5)	;IS FIRST CHAR AN "R" ?
	BEQ	6$		;BR IF YES
5$:	TST	LDOVRD		;ANY LOAD EXT OVERRIDE ?
	BNE	12$		;YES
	BR	$$$NAM		;NAME.EXT ERR

6$:	CMP	#"10,(R4)
	BEQ	7$		;BR IF ".A10"
	CMP	#"11,(R4)
	BEQ	8$		;BR IF ".A11"
	CMP	#"AM,(R4)
	BEQ	9$		;BR IF ".RAM"
	BR	5$		;NONE, REPORT ERROR

7$:	CLR	(R3)		;SETUP LOAD CONTROL
	BR	12$
8$:	MOV	#1,(R3)
	BR	12$
9$:	MOV	#2,(R3)
12$:	TST	LDOVRD		;ANY LOAD EXT OVERRIDE ?
	BEQ	20$		;NO
	MOV	LDOVRD,R0	;SET LOAD CONTROL ACCORDINGLY
	DEC	R0
	MOV	R0,(R3)
20$:	JMP	DEVFIL		;GO GET FILE & LOAD

14$:	CMP	#"IN,(R4)	;IS EXTENSION ".BIN" ?
	BNE	5$		;BR IF NO
	MOV	#5,(R3)		;YES, SET LOAD CONTROL
	BR	12$

16$:	CMP	#"AV,(R4)	;IS EXTENSION ".SAV" ?
	BEQ	7$		;YES, ACT10 TREATS AS ".A10"
	BR	5$
;PROCESS FILENAME.EXT FROM INPUT BUFFER

$NAMEXT:MOV	#NAMBF,R0	;CLEAR NAME LOOKUP BUFFER
	MOV	#20040,R1	;TO SPACES
	MOV	#5,R2
70$:	MOV	R1,(R0)+	;UP TO 9 CHARS
	DEC	R2
	BGT	70$

	MOV	#NAMBF,R2	;LOOKUP NAME
	MOV	#7,R1		;MAXIMUM OF 6 CHARS IN NAME
	TTISDL
	BCS	99$		;LETTER, ALREADY IN R0
1$:	TTICHR			;GET CHAR FROM TTY BUFFER
	BCS	5$
99$:	CMPB	#'.,R0
	BEQ	2$		;BR IF PERIOD, NAME.EXT SEPARATOR
	CMPB	#33,R0
	BEQ	97$		;ALTMODE, SELF START
	CMPB	#15,R0
	BEQ	96$		;CR, NO EXTENSION
	CMPB	#SPACE,R0	;IF SPACE, NO EXT
	BEQ	96$
	DEC	R1
	BEQ	5$		;BR IF MORE THAN 6 CHARS
	MOVB	R0,(R2)+	;STORE CHAR
	BR	1$

2$:	MOV	#EXTBF,R2	;GET EXTENSION
	MOV	#4,R1
3$:	TTICHR
	BCS	5$
	CMPB	#33,R0
	BEQ	13$		;BR IF ALTMODE
	CMPB	#15,R0
	BEQ	98$		;BR IF CR
	CMPB	#SPACE,R0	;BR IF SPACE
	BEQ	98$
	DEC	R1
	BEQ	5$		;BR IF MORE THAN 3 CHARS
	MOVB	R0,(R2)+	;STORE CHAR
	BR	3$
97$:	COM	SRTFLG		;SET SELF START FLAG
	BR	96$

13$:	COM	SRTFLG

98$:	CMP	#4,R1
	BNE	10$
96$:	CLR	R0
10$:	EXIT

$$$NAM=.
5$:	$PMSG			;NAME.EXT ERR
	  $$NAM
	JMP	$CNTLC

$$NAM:	.ASCIZ	/NAME.EXT ERR/
.EVEN
;DECTAPE/RP04/FLOPPY LOADER START

DTRPLD:	CMP	#5,LDCNTL	;PDP-11 .BIN FILE LOAD ?
	BNE	LLD1
	JMP	LDBIN

LLD1:	DVDATA			;LOAD FIRST BUFFER
	 BCC	LLD2
	JMP	DVEOF		;EOF

LLD2:	TST	DEVTYP
	BPL	1$
	JMP	ACTLD2		;ACT10 PROCESS

1$:	MOV	#$INBUF,R5	;SET UP START OF CHAR BUFFER
	MOV	R5,$INPTC

LLD3:	MOV	DVCNT,R4	;SETUP DEVICE BYTE COUNTER
	MOV	DVADR,R3	;SETUP DEVICE DATA BLOCK ADDRESS

LLD4:	TST	R4		;ANY DATA REMAINING ?
	BGT	2$		;YES

	DVDATA			;NO, READ NEXT DEVICE BLOCK
	 BCC	LLD3
	JMP	DVEOF		;END OF FILE ?

2$:	MOVB	(R3)+,R0	;GET FRAME, ONE 7 BIT CHAR
	DEC	R4		;COUNT IT
	BIC	#177600,R0
	TST	R0		;IS FRAME A NULL ?
	BEQ	LLD4		;BR IF YES, DON'T STORE
	MOVB	R0,(R5)+	;STORE IN BUFFER
	CMP	R5,#$INBUF+140.
	BLE	1$		;BR IF BUFFER DIDN'T OVERFLOW
	JMP	$LINERR		;REPORT BUFFER OVERFLOW
1$:	CMP	#12,R0		;IS CHAR A LINE FEED ?
	BEQ	LLDONE		;BR IF LINE DONE
	BR	LLD4		;LOOP TILL LF FOUND
LLDONE:	MOV	R4,DVCNT	;RESAVE POINTERS
	MOV	R3,DVADR
	CLRB	(R5)		;STORE A NULL TO END STRING
	MOV	R5,$INPTR
	INC	DEVLC		;COUNT LINE
	MOV	DEVLC,SWR	;DISPLAY
	TST	LDCNTL		;IS HELP FLAG SET ?
	BPL	LDPROC		;BR IF NO
	JMP	DAHLP		;DTA/ACT HELP

LDPROC:	CLR	LDOCTF		;CLEAR OCTAL LOAD FLAG
	CLR	LDZBLK
	MOV	LDCNTL,R1	;GET LOAD CONTROL
	MOV	$INPTC,R5	;SETUP INPUT POINTER
	MOVB	(R5)+,R0	;GET FIRST CHAR FROM FILE
	CMPB	#';,R0		;IS FIRST CHAR A SEMICOLON ?
	BEQ	LDPRO1		;YES, PROCESS COMMENT LINE
	CMPB	LDLTR(R1),R0	;DOES 1ST CHAR MATCH LOAD TYPE ?
	BEQ	LDPRO3		;YES
	TST	LDCNTL		;IS THIS .A10 FILE ?
	BNE	LDPRO2		;NO, ERROR
	CMPB	#'Z,R0		;YES, IS FIRST CHAR A "Z" ?
	BNE	LDPRO2		;NO, ERROR
	COM	LDZBLK		;YES, SET CORE ZERO FLAG
	BR	LDPRO3

LDPRO1:	TST	DEVLC		;COMMENT, IS THIS FIRST LINE ?
	BNE	LLD2		;NO
	PUSH	PCMDNF		;SAVE PGM CMD NO PRINT FLAG
	SWITCH
	BIT	R0,#CHAIN	;IS CHAIN SWITCH SET ?
	BEQ	1$		;NO
	MOV	#-1,PCMDNF	;YES, PREVENT FILE ID PRINTOUT

1$:	MOVB	(R5)+,R1	;PUT FILE ID LINE IN OUTPUT BUFFER
	BEQ	2$		;NULL, DONE
	PLDBUF
	BR	1$
2$:	POP	PCMDNF		;RESTORE FLAG
	PNTRST			;RESET OUTPUT POINTERS ANYWAY
	BR	LLD2
LDPRO2:	JMP	ACTLDC		;LOAD TYPE ERROR

LDPRO3:	MOVB	(R5)+,R0	;GET 2ND CHAR
	CMPB	#'O,R0		;IS IT AN O ?
	BEQ	LDOCT		;YES, OCTAL DATA FORMAT LOAD
	CMPB	#40,R0		;IS IT A SPACE ?
	BNE	LDPRO2		;BR IF NO

LDCLR:	MOV	#LDCNT,R1	;SETUP CONVERTED STORAGE ADDRESS
LDCNV:	CLR	R2		;CLEAR WORD FORMER
1$:	MOVB	(R5)+,R0	;GET CHAR
	CMP	#15,R0		;IS IT A CR ?
	BEQ	1$		;YES, IGNORE
	CMP	#12,R0		;IS IT A LF ?
	BEQ	LDEOL		;YES, END OF LINE
	CMP	#54,R0		;IS IT A COMMA ?
	BEQ	2$		;YES, GO STORE WORD
	TST	LDOCTF		;LOADING OCTAL ?
	BNE	3$		;YES
	SL	R2,6		;SHIFT WORD FORMER LEFT 6
	BIC	#100,R0		;CLEAR ASCIIZED BIT
4$:	BIS	R0,R2		;INSERT NEW OIT
	BR	1$		;LOOP TILL WORD FORMED

2$:	MOV	R2,(R1)+	;STORE 16 BIT WORD
	BR	LDCNV		;GO DO NEXT

3$:	SL	R2,3		;OCTAL LOAD
	BIC	#177770,R0	;CLEAR ALL BUT NUMBER PART
	BR	4$

LDOCT:	COM	LDOCTF		;OCTAL LOAD, SET FLAG
	BR	LDCLR

LDERR:	JMP	ACTLDF		;LOAD ERROR

LDEOL:	MOV	R2,(R1)		;STORE CHECKSUM
LDCKSM:	TST	LDOCTF		;LOADING OCTAL ?
	BNE	2$		;YES, NO CHECKSUM
	MOV	#LDCNT,R2	;CHECKSUM LOAD STORAGE
	CLR	R0
1$:	ADD	(R2)+,R0
	CMP	R2,R1
	BLE	1$
	TST	R0		;IS CHECKSUM = 0 ?
	BEQ	2$		;BR IF 0
	JMP	ACTBCK		;BAD CHECKSUM

2$:	MOV	LDCNTL,R0	;DISPATCH TO PROPER LOAD ROUTINE
	SL	R0,1		;DETERMINED FROM LDCNTL WORD
	JMP	@LDTYPE(R0)

LDTYPE:	LDTEN			;.A10, LOAD TEN
	LDELVN			;.A11, LOAD ELEVEN
	LDCZRO			;.RAM, ZERO C-RAM
	LDCRAM			;.RAM, LOAD C-RAM
	LDDRAM			;.RAM, LOAD D-RAM

LDLTR:	.ASCII	/TEZCD/

$$LD11:	.ASCIZ	/11 ERR,ADR=/
$$COR:	.ASCIZ	/COR=/
$$ACT:	.ASCIZ	/ACT=/
$$RAM:	.ASCIZ	/\RAM ERR,COR=/
$$TEN:	.ASCIZ	/\10 ERR,ADR=/
	.EVEN

$LINERR:PMSG	<?LINE TOO LONG>
	JMP	$CNTLC
;LOAD DONE ROUTINE

LDDONE:	TST	DEVTYP		;LOAD DONE
	BMI	1$		;BR IF ACT10 MODE
	JMP	DADONE

1$:	JMP	ACTDON		;ACT10 PROCESS

;PDP-11 CORE LOAD ROUTINE

LDELVN:	MOV	LDCNT,R0	;GET LOAD WORD COUNT
	BEQ	2$		;IF 0, THIS IS TRANSFER BLOCK
	MOV	#LDATA,R2	;SETUP DATA PICKUP POINTER
	MOV	LDADR,R1	;GET LOAD MEMORY ADDRESS
	BIT	#1,R1		;LOAD WORD OR BYTE ?
	BNE	3$		;BYTE LOAD

1$:	TST	VERIFY
	BNE	11$
19$:	MOV	(R2)+,(R1)+	;MOVE WORD FROM STOR TO MEMORY
13$:	DEC	R0		;DECREMENT WORD COUNT
	BGT	1$		;LOOP TILL ALL WORDS MOVED
18$:	JMP	LLD2		;GO DO NEXT LOAD LINE

11$:	CMP	(R2),(R1)	;COMPARE CURRENT AGAINST FILE
	BEQ	12$
	PUSH	R0
	$PMSG
	$$LD11			;"11 ERR,ADR="
	MOV	R1,R0
	PNTOCT

	$PMSG
	$$COR			;"COR="
	MOV	(R2),R0
	PNTOCT

	$PMSG
	$$ACT			;"ACT="
	MOV	(R1),R0
	PNTOCT
	PCRLF
	POP	R0

12$:	TST	(R2)+
	TST	(R1)+
	BR	13$
3$:	TST	VERIFY
	BNE	31$

39$:	MOVB	(R2)+,(R1)+	;ODD ADDRESS, BYTE LOAD
	MOVB	(R2)+,(R1)+	;2 BYTES PER WORD
38$:	DEC	R0		;DECREMENT WORD COUNT
	BGT	3$		;LOOP TILL ALL BYTES MOVED
	BR	18$		;GO ON TO NEXT


31$:	CLR	R5
32$:	PUSH	R0
	CMPB	(R2),(R1)
	BEQ	33$

	$PMSG
	$$LD11			;"11 ERR,ADR="
	MOV	R1,R0
	PNTOCT

	$PMSG
	$$COR			;"COR="
	MOVB	(R2),R0
	BIC	#177400,R0
	PNTOCS

	PSPACE
	$PMSG
	$$ACT			;"ACT="
	MOVB	(R1),R0
	BIC	#177400,R0
	PNTOCS
	PCRLF
33$:	POP	R0
	INC	R2
	INC	R1
	TST	R5
	BNE	38$
	INC	R5
	BR	32$

2$:	MOV	LDADR,R0
LD11DN:	MOV	R0,PGOADR
	CLR	PGOCTL
	BR	LDDONE
;PDP-11 BINARY LOAD ROUTINE

LDBIN:	DVDATA			;LOAD DEVICE BUFFER
LDBIN1:	CLR	$CKS11		;INIT CHECKSUM
	DVFRAM			;READ FRAME
	DECB	R0		;CHECK FOR BLOCK START
	BNE	LDBIN1		;NOT YET
	DVFRAM			;READ ANOTHER FRAME

	DVWRD			;GET FULL BYTE COUNT
	MOV	R0,LBC
	SUB	#6,LBC
	BEQ	LJMP		;BYTE COUNT OF 6 IS XFER BLOCK
	DVWRD			;GET LOAD ADDRESS
	MOV	R0,R5		;STORE LOAD ADDRESS

LDBIN2:	DVFRAM			;READ DATA FRAME
	DEC	LBC
	BGE	LDBIN3		;BR IF MORE DATA REMAINS 
	TSTB	$CKS11		;CORRECT CHECKSUM ?
	BEQ	LDBIN1		;BR IF GOOD CHECKSUM
LDBINE:	PMSG	<\CKSUM ERR>
$LDBNE:	JMP	$CNTLC

LDBIN3:	TST	VERIFY
	BNE	1$
	CMP	R5,#PRGSRT	;TRYING TO LOAD INTO KLDCP ?
	BLO	10$		;NO
	PMSG	<\ADR ERR>
	BR	$LDBNE		;YES, BAD !!
10$:	MOVB	R0,(R5)+	;STORE DATA 1 BYTE AT A TIME
	BR	LDBIN2		;LOOP

1$:	CMPB	R0,(R5)
	BNE	3$
2$:	INC	R5
	BR	LDBIN2
3$:	PUSH	R0
	$PMSG
	$$LD11			;"11 ERR,ADR="

	MOV	R5,R0
	PNTOCT

	$PMSG
	$$COR			;"COR="
	POP	R0
	PNTOCS

	PSPACE
	$PMSG
	$$ACT			;"ACT="
	MOVB	(R5),R0
	BIC	#177400,R0
	PNTOCS
	PCRLF
	BR	2$

LJMP:	DVWRD			;GET POSSIBLE XFER ADDRESS
	PUSH	R0
	DVFRAM
	TSTB	$CKS11		;CORRECT CHECKSUM ?
	BNE	LDBINE		;BR IF BAD
	POP	R0		;SETUP START ADDRESS
	BR	LD11DN
;KL10 LOAD D-RAM ROUTINE

;CALLS "WDRAM" WITH R0 = D-RAM ADDRESS
;		    R1 = LOAD DATA ADDRESS

LDDRAM:	MOV	LDCNT,R2	;GET LOAD WORD COUNT
	BEQ	2$		;WC = 0, TRANSFER BLOCK
	MOV	LDADR,R3	;SETUP D-RAM ADDRESS
	MOV	#LDATA,R4	;DATA PICKUP ADDRESS

1$:	MOV	R3,R0		;D-RAM ADDRESS TO R0
	MOV	R4,R1		;DATA ADDRESS TO R1

	TST	VERIFY
	BNE	11$		;VERIFY D-RAM
	WDRAM			;WRITE D-RAM

11$:	MOV	R3,R0
	RDRAM			;READ D-RAM
	MOV	R0,R5
	BIC	#20,(R0)	;CLEAR COMPUTED PARITY
	CMP	(R0)+,(R1)+	;COMPARE EVEN WORD
	BNE	20$
	BIC	#20,(R0)	;CLEAR COMPUTED PARITY
	CMP	(R0)+,(R1)+	;COMPARE ODD WORD
	BNE	20$
	CMP	(R0),(R1)	;COMPARE COMMON WORD
	BNE	20$
21$:	ADD	#2,R3		;TO NEXT EVEN D-RAM ADDRESS
	ADD	#6,R4		;SETUP NEXT DATA PICKUP ADR
	SUB	#3,R2		;DECREMENT WORD COUNT
	BGT	1$		;BR IF NOT DONE YET
	BR	$LLD2		;BACK FOR NEXT LOAD FILE LINE

2$:	JMP	LDDONE		;LOAD FINISHED

20$:	$PMSG
	$$RAM			;"RAM ERR,COR="
	MOV	R3,R0
	MOV	R4,R1
	PNTDRM			;PRINT CORRECT D-RAM

	$PMSG
	$$ACT			;"ACT="
	MOV	R3,R0
	MOV	R5,R1
	PNTDRM			;PRINT ACTUAL D-RAM
	BR	21$		;CONTINUE
;KL10 C-RAM ZERO

LDCZRO:	MRESET			;MASTER RESET
	TST	VERIFY
	BNE	2$		;NO ZEROING IF VERIFY
	MOV	LDATA,R1	;GET C-RAM ZERO COUNT
	BEQ	2$		;0 ZERO COUNT, BYPASS ZEROING C-RAM
	MOV	LDADR,R0	;SETUP STARTING ADDRESS

	MICNUL			;ZERO C-RAM
2$:	INC	LDCNTL		;ADVANCE LOAD CONTROL TO C-RAM LOAD
	BR	$LLD2

;KL10 LOAD C-RAM ROUTINE

;CALLS "WCRAM" WITH R0 = C-RAM ADDRESS
;		    R1 = DATA PICKUP ADDRESS

LDCRAM:	MOV	LDCNT,R2	;GET LOAD WORD COUNT
	BEQ	2$		;WC = 0, TRANSFER BLOCK
	MOV	LDADR,R3	;SETUP C-RAM ADDRESS
	BIS	#BIT14,R3	;SET SPECIAL RESET BIT
	MOV	#LDATA,R4	;DATA PICKUP ADDRESS

1$:	TST	LDOCTF		;LOADING OCTAL ?
	BNE	3$		;YES
4$:	MOV	R3,R0		;C-RAM ADDRESS TO R0
	MOV	R4,R1		;DATA PICKUP ADDRESS TO R1

	TST	VERIFY
	BNE	41$
	WCRAM			;WRITE C-RAM
41$:	MOV	R3,R0
	RCRAM			;READ C-RAM BACK

	MOV	#6,R5
	MOV	R4,R1
11$:	CMP	(R0)+,(R1)+	;RAM LOADED PROPERLY ?
	BNE	12$		;NO
	DEC	R5
	BNE	11$
42$:	INC	R3		;TO NEXT C-RAM ADDRESS
	ADD	#12.,R4		;TO NEXT PICKUP ADDRESS
	SUB	#6,R2		;DECREMENT WORD COUNT, 6 11 WDS PER
	BGT	1$		;BR IF NOT DONE YET
$LLD2=.
	JMP	LLD2		;GET NEXT LOAD FILE LINE
2$:	MOV	LDADR,R0	;SELECT C-RAM STARTING ADDRESS
	WWADR			;WRITE ADDRESS TO C-RAM
	INC	LDCNTL		;ADVANCE LOAD CONTROL TO D-RAM LOAD
	BR	$LLD2

;OCTAL C-RAM LOAD, DATA IS BACKWARDS FROM UPSIDE DOWN NORMAL

3$:	MOV	(R4),R0		;GET WORD 0
	MOV	10(R4),(R4)	;PUT WORD 5 IN 0'S PLACE
	MOV	R0,10(R4)	;PUT WORD 0 IN 5'S PLACE
	MOV	2(R4),R0	;GET WORD 1
	MOV	6(R4),2(R4)	;PUT WORD 4 IN 1'S PLACE
	MOV	R0,6(R4)	;PUT WORD 1 IN 4'S PLACE
	BR	4$		;NOW GO LOAD IN C-RAM

12$:	$PMSG			;"RAM ERR,COR="
	$$RAM
	MOV	R3,R0
	MOV	R4,R1
	PNTCRM
	PCRLF
	$PMSG
	$$ACT			;"ACT="
	MOV	R3,R0
	MOV	#$BUFRC,R1
	PNTCRM
	PCRLF
	BR	42$
;LOAD TEN CORE ZERO

;  START ADDRESS, LOW 16 BITS IN LDADR
;               , BITS 18 & 19 IN HI-BYTE OF LDCNT
;  ZERO COUNT IN LDATA
;  WORD COUNT SIGNIFIES NUMBER OF LDATA WORDS USED FOR ZEROING
;  "D10ZRO" - INCREMENTS PDP-10 ADDRESS WHILE ZEROING

LDTEN:	MOV	#L10ADR+2,R3	;SETUP BLOCK START ADDRESS POINTER
	CLR	(R3)
	MOVB	LDCNT+1,(R3)	;HI-BYTE OF LDCNT IS ADR BITS 18 & 19
	MOV	LDADR,-(R3)	;SETUP ADR BITS 20-35

	TST	LDZBLK		;TEN CORE ZERO BLOCK ?
	BEQ	LDRDIN		;NO, LOAD DATA

LDTENZ:	SM			;START MACHINE
	 BCC	3$
	JMP	.XCTER		;FAILED
3$:	TST	VERIFY
	BNE	2$		;DON'T ZERO IF VERIFY
	MOV	#LDATA,R4
	MOVB	LDCNT,R2	;IS WC = 0 ?
	BEQ	2$		;YES, NO ZEROING
	MOV	R3,R1		;SETUP ADDRESS
1$:	MOV	(R4)+,R0	;SETUP ZERO COUNT
	D10ZRO			;DEPOSIT ZEROS, CLEARING CORE
	BCS	LD10ER
	MOV	#.DPXAD,R1
	DEC	R2		;COMPLETED ALL ZEROS ?
	BNE	1$		;NOT YET

2$:	BR	$LLD2		;ALL REQUESTED CORE ZEROED.
;LOAD TEN DATA

;CALLS "DPOSVR" WITH R0 = LOAD DATA ADDRESS
;		     R1 = PDP-10 ADDRESS

LDRDIN:	MOVB	LDCNT,R2	;GET LOAD WORD COUNT
	BEQ	2$		;WC = 0, TRANSFER BLOCK
	MOV	#LDATA,R4	;DATA PICKUP ADDRESS

1$:	MOV	R3,R1
	MOV	R4,R0		;SETUP DATA PICKUP ADDRESS

	TST	VERIFY
	BNE	LD10V
	DPOSVR			;DEPOSIT & VERIFY
	BCS	LD10VR		;FAILED
$LRDIN=.
	ADD	#1,(R3)+	;INCREMENT 10 ADDRESS
	ADC	(R3)
	TST	-(R3)
	ADD	#6,R4		;SETUP NEXT DATA PICKUP ADDRESS
	SUB	#3,R2		;DECREMENT WORD COUNT
	BGT	1$		;BR IF NOT DONE YET
	BR	$LLD2		;BACK FOR NEXT LOAD FILE LINE

2$:	MOV	#PGOADR,R4
	MOV	(R3)+,(R4)+	;TRANSFER START ADDRESS
	MOV	(R3),(R4)	;TO GO ADDRESS
	MOV	#2,PGOCTL
	JMP	LDDONE
LD10VR:	BMI	LD10ER		;N-BIT SET DEPOSIT FAILED
	BEQ	LD10ER		;Z-BIT SET, EXAMINE FAILED
LD10VE=.
	PUSH	R0
	$PMSG			;"10 ERR,ADR="
	$$TEN
	MOV	#L10ADR,R0
	PNTADR

	$PMSG
	$$COR			;"COR="
	MOV	R4,R0
	PNT36

	$PMSG
	$$ACT			;"ACT="
	POP	R0
	PNT36
	PCRLF
	BR	$LRDIN

LD10V:	MOV	R1,R0
	EXAM			;EXAMINE PRESENT CONTENTS
	BCS	LD10ER		;CAN'T EXAMINE
	MOV	R0,R1
	MOV	R4,R0
	CMPR36			;COMPARE WITH LOAD FILE
	BCC	$LRDIN		;OK
	BR	LD10VE		;BAD

LD10ER:	$PMSG			;"10 ERR,ADR="  
	$$TEN
	MOV	#L10ADR,R0
	PNTADR
	JMP	$CNTLC
;DEVICE FILE DIRECTORY LOOKUP

DEVFIL:	SETFLG			;INIT DEVICE LINE COUNT
	  DEVLC
	TTPINI			;INIT TTY POINTERS
	CLR	$OUTBF
	TST	DEVTYP		;LOAD FROM WHAT DEVICE ?
	BEQ	DTFIL		;  0 = DECTAPE
	BMI	1$		; -1 = ACT10
	JMP	RPFIL		;  1 = RP04
1$:	JMP	ACTFIL

DTFIL:	TST	FLOPPY
	BEQ	10$
	RXFILE			;FLOPPY
	BR	11$
10$:	DTAFILE
11$:	BCS	1$
	JMP	DTRPLD
1$:	JMP	$NONXF		;NON-EX FILE

;DECTAPE FORMAT
;FIRST DIRECTORY BLOCK = 102 (8)

;FILE DIRECTORY BLOCK
;	LINK TO NEXT BLOCK
;	1 - FILE NAME 1
;	2 - FILE NAME 2
;	3 - FILE EXTENSION
;	4 - DATE
;	5 - SPARE
;	6 - START BLOCK #
;	7 - LENGTH
;	8 - END BLOCK #
;	9 - SPARE
;FILE DATA BLOCK
;	LINK TO NEXT BLOCK
;	255 DATA WORDS

;DECTAPE PROGRAM FILE SEARCH

$DTAFILE:DTINIT			;DECTAPE INITIALIZATION
DTAFL1:	TST	FLOPPY
	BEQ	20$
	RXRDFL			;FLOPPY READ FILE
	BR	21$
20$:	DTRDFL			;READ UFD DIRECTORY BLOCK
21$:	BCS	11$		;EOF, CAN'T FIND FILE
	MOV	(R0),R0		;PUT FIRST BUFFER ADR IN R0
	MOV	#28.,R1		;28 ENTRIES IN DIRECTORY
1$:	MOV	(R0)+,DIRST0	;STORE RAD50 NAME
	MOV	(R0)+,DIRST1
	MOV	(R0)+,DTEXT	;STORE RAD50 EXT
	CMP	(R0)+,(R0)+	;SKIP 2 WORDS
	MOV	(R0)+,DTSTRT	;SAVE STARTING BLOCK #
	MOV	(R0)+,DTLNGTH	;SAVE LENGTH
	CMP	(R0)+,(R0)+	;MOVE TO NEXT ENTRY
	PUSH	<R0,R1>
	R50UPK			;UNPACK NAME
	 DIRST0,DIRST2
	BCS	10$
	R50UPK
	 DIRST1,DIRST3+1
	BCS	10$
	R50UPK			;UNPACK EXTENSION
	 DTEXT,DTEXTS
	BCS	10$		;ERROR RETURN

	TST	DVDIRF		;DOING "DIR" ?
	BNE	$DTDI1		;YES

	MOV	#NAMBF,R3	;LOAD ADDRESS OF INPUT DATA
	MOV	#DIRST2,R4	;LOAD ADDRESS OF TABLE
	MOV	#6,R0		;SET COUNT
3$:	CMPB	(R3)+,(R4)+	;CHECK NAME DATA
	BNE	10$		;BR IF NOT SAME
	DEC	R0		;DONE 6 TIMES ?
	BNE	3$		;BR IF NOT
	MOV	#EXTBF,R3	;LOAD ADDRESS OF EXT INPUT
	MOV	#DTEXTS,R4	;LOAD ADDRESS OF EXT STOR
	MOV	#3,R0		;SET COUNT 3 CHARS
6$:	CMPB	(R3)+,(R4)+	;CHECK EXT DATA
	BNE	10$		;BR IF NOT SAME
	DEC	R0		;DONE 3 TIMES ?
	BNE	6$		;BR IF NOT
	POP	<R1,R0>
	MOV	DTSTRT,DVBUF	;LOAD STARTING BLOCK
	EXIT			;NOW GO LOAD FILE
$DTDI2=.
10$:	POP	<R1,R0>
	DEC	R1		;BEEN THRU 28 ENTRIES ?
	BNE	1$		;NOT YET
	BR	DTAFL1		;TRY NEXT UFD BLOCK

11$:	EXITERR
;DECTAPE/FLOPPY DIRECTORY ROUTINE

$DTDI1:	CLR	NAMBF
	CLR	DTEXT
	CMP	#020040,DIRST2	;DON'T PRINT SPACES
	BEQ	1$

	$PMSG			;PRINT "FILE"
	  DIRST2

	PSPACE

	$PMSG			;PRINT "EXT"
	  DTEXTS

	MOV	#TAB,R0
	PNTCHR
	MOV	DTLNGTH,R0
	PNTDEC			;PRINT NUMBER OF BLOCKS

	PCRLF
1$:	BR	$DTDI2		;GO DO NEXT

$DI:	TTITRM
	PNORML
	TST	DEVTYP
	BEQ	$DTDIR		;DECTAPE
	BMI	1$		;ILLEGAL ON ACT10
	JMP	$RPDIR		;RP04

1$:	JMP	$CMDE

$DTDIR:	SETFLG
	  DVDIRF		;SET DIRECTORY FLAG
	TST	FLOPPY
	BEQ	1$
	RXFILE			;FLOPPY
	BR	2$
1$:	DTAFILE
2$:	JMP	$CONSL
;READ DEVICE FRAME SUBROUTINE

$DVFRAM:TST	DVCNT		;USED ALL DATA ?
	BGT	1$		;NO

	DVDATA			;YES, READ NEXT BLOCK
	BCS	DVEOF		;EOF

1$:	MOVB	@DVADR,R0	;GET ONE BYTE
	INC	DVADR		;INCREMENT PICKUP ADDRESS
	DEC	DVCNT		;COUNT IT
	BIC	#177400,R0	;CLEAR JUNK, CHAR IS 8 BITS
	ADD	R0,$CKS11
	BR	$$DVX

;READ DEVICE BUFFER SUBROUTINE

$DVDATA:TST	DEVTYP
	BNE	4$

	TST	FLOPPY
	BEQ	1$
	RXRDFL			;FLOPPY
	BR	11$
1$:	DTRDFL			;DECTAPE READ
11$:	BCS	3$		;EOF
2$:	MOV	(R0)+,DVADR	;SAVE BUFFER ADDRESS
	MOV	(R0),DVCNT	;SAVE BUFFER BYTE COUNT
	BR	$$DVX

3$:	EXITERR			;EOF

4$:	MOV	#FILDSB,R0
	RPRDFL			;RP04 FILE DATA BLOCK READ
	BCC	2$

	CMP	#1,R0		;ERROR, EOF ?
	BEQ	DVEOF		;YES
	RPERROR			;NO, JUST ERROR
DVEOF:	TST	LDCNTL		;EOF, PRINTING A HELP FILE ?
	BMI	1$		;YES
	PMSG	<\EOF ?>
	JMP	$CNTLC
1$:	JMP	DAHLPD

;ASSEMBLE ONE 16 BIT DATA WORD

$DVWRD:	DVFRAM			;READ FRAME
	MOV	R0,LTMP
	DVFRAM			;GET ANOTHER FRAME
	SWAB	R0		;PLACE IN HIGH ORDER BYTE
	BIS	R0,LTMP		;PUT 2 BYTES TOGETHER
	MOV	LTMP,R0		;PUT BACK IN R0
	BR	$$DVX

;DECTAPE INITIALIZATION

$DTINIT:MOV	#102,DVBUF	;SET STARTING BLOCK NUMBER
$$DVX:	EXIT

;FILE NOT FOUND

$NONXF:	TST	DIAFLG		;DOING "DIAMON" FILE SELECTION ?
	BEQ	1$		;NO
	JMP	DIANF		;YES, "DIAMON" FILE NOT FOUND

1$:	PMSG	<NON-EX FILE>
	JMP	$CNTLC
;RAD50 UNPACK SUBROUTINE

$R50UPK:ADD	#4,12(SP)	;RETURN OVER TRAILING PARAMETERS
	PUSH	R0
	MOV	$EMADR,R5
	MOV	(R5)+,R4	;RAD50 ADDRESS TO R4
	MOV	(R4),R4		;RAD50 VALUE TO R4
	MOV	(R5),R3		;STORE ADDRESS TO R3
	MOV	#2,R1
	MOV	#-1,-(6)	;SET STACK STOP
1$:	MOV	R4,-(6)		;SAVE PREVIOUS VALUE
	CLR	R4		;CLEAR R4 FOR NEXT REMAINDER
2$:	MOV	(6),R0		;TAKE 3/4 OF VALUE
	BISB	@PC,R0		;???????
	MOV	R0,R2
	ROR	R2
	ASR	R2
	SUB	R2,R0
	BIC	#37,R0		;PREPARE TO TAKE 1/4 OF RESULT
	SUB	R0,(6)		;BUT REDUCE ORIGINAL BY 3/4
	ROR	R0		;GET 3/16 OF ORIGINAL
	ASR	R0
	SUB	R0,(6)
	ADD	R0,R4		;THIS GIVES 1ST APPROXIMATION
	CMP	(6),#47		;LOW AS POSSIBLE ?
	BHI	2$		;IF SO THIS IS BYTE REQUIRED
	ASR	R4
	ASR	R4
	ASR	R4
	DEC	R1		;DONE 2 BYTES ?
	BNE	1$		;BR IF NOT
	CMPB	R4,#47		;LAST BYTE TOO BIG ?
	BHI	4$		;IF YES, ERROR
3$:	TSTB	R4		;SPACE ?
	BEQ	6$		;IF YES, ADD 40
	CMPB	R4,#35		;IF UNUSED CODE ....
	BNE	5$
4$:	MOV	#'X,R4		;ASCII X TO R4
	BR	9$		;GO TO ERROR EXIT
5$:	CMPB	R4,#33		;$ ?
	BEQ	8$		;IF YES, GO ADD 11
	BHI	7$		;FOR DIGIT OR DOT ADD 22
	ADD	#40,R4		;FOR LETTER ADD 100
6$:	ADD	#16,R4
7$:	ADD	#11,R4
8$:	ADD	#11,R4
9$:	MOVB	R4,(3)+		;STORE RESULT
	MOV	(6)+,R4		;GET NEXT BYTE
	BPL	3$		;BR IF NOT STACK STOP
	POP	R0
$$$DVX:	BR	$$DVX
;DECTAPE READ/WRITE FILE ROUTINES

$DTRDFL:TST	DVBUF		;ANY DATA BLOCKS REMAINING ?
	BNE	$DTRFL		;YES
$$DTXE:	EXITERR			;NO

$DTRFL:	MOV	DVBUF,DTBLK	;SET REQUESTED BLOCK
	MOV	#DVBUF,CASAV	;SET BUFFER ADDRESS
	MOV	#-256.,WCSAV	;SET WORD COUNT

	DTREAD			;DECTAPE READ
	 BCS	$$DTXC		;FAILED

	MOV	#$DTINFO,R0
$$DTX:	EXIT

$$DTXC:	JMP	$CNTLC		;FAILED

$DTWTFL:MOV	#DVBUF,CASAV
	MOV	#-256.,WCSAV

	DTWRT			;WRITE DECTAPE
	 BCC	$$DTX		;OK
	BR	$$DTXC		;FAILED

$DTINFO:DVBUF+2			;FIRST USABLE DATA WORD
	510.			;BYTE COUNT

$DTBASE:MOV	#DTBLK,R0	;RETURN PARAMETER BASE ADDRESS
	BR	$$DTX
;DECTAPE DEVICE READ/WRITE ROUTINE

$DTREAD:MOV	#TCRDATA+TCDO,R0
	BR	$DTXFR

$DTWRT:	MOV	#TCWDATA+TCDO,R0

$DTXFR:	MOV	R0,DTXCMD	;SAVE COMMAND
	MOV	#3,TRYCTR	;SET MAXIMUM TRY COUNT, 3.

$DTXF1:	MOVB	DTUNIT+1,R4	;SETUP UNIT
	MOV	WCSAV,@#TCWC	;SETUP WORD COUNT
	MOV	CASAV,@#TCBA	;SETUP READ ADDRESS
	MOV	#TCRNUM+TCDO,R0
	MOV	#TCCM,R1
	MOV	#TCREV,R3
	MOV	DTBLK,R2	;SETUP BLOCK # AND DIRECTION
	BPL	$DTXF2
	NEG	R2
	ADD	#10,R4		;REVERSE, SET REV INDICATOR
	BIS	R3,R0		;START UP IN REVERSE

$DTXF2:	MOV	#6,REVCNT	;SET MAXIMUM REVERSAL COUNT, 6.
	CLR	INTSW		;SET INTSW FOR SEARCH

$DTXF3:	PUSH	R3
	JSR	PC,$TIRDY	;ANY OPERATOR INTERRUPTS ?
	BCS	2$		;NO
	MOVB	$TICHR,R3	;GET CHAR
	BICB	#200,R3
	CMPB	#CNTRLC,R3	;IS IT CONTROL C ?
	BNE	2$		;NO
	BIC	#116,(R1)	;YES, STOP DECTAPE
	JMP	$TICC		;AND ABORT
2$:	POP	R3
	BIS	DTUNIT,R0	;SELECT UNIT
	MOV	R0,(R1)		;SET TCCM
1$:	BIT	#TCERR+TCRDY,(R1) ;WAIT FOR DONE OR ERROR
	BEQ	1$
	BMI	DTER		;BR IF ERROR
	TSTB	INTSW		;SEARCH OR TRANSFER ?
	BNE	DATINT		;BR IF TRANSFER
	CMP	@#TCDT,R2	;BLOCK MATCH ?
	BEQ	DTSRF		;BR IF YES
	BGT	DTSRE		;BR IF LARGER
	BIT	R3,(R1)		;SMALLER, REVERSE ?
	BEQ	$DTXF3		;FORWARD, CONTINUE DIRECTION
DTSRA:	ADD	#3,@#TCDT	;+3 TO TCDT
	CMP	@#TCDT,R2	;LOWER BY 3 OR MORE ?
	BLOS	DTREV		;YES, GO REVERSE
	BR	$DTXF3		;NO, CONTINUE DIRECTION

DTSRE:	BIT	R3,(R1)		;BLK HIGH, CHECK DIRECTION
	BNE	$DTXF3		;BR IF REV, CONTINUE DIRECTION
	SUB	#3,@#TCDT	;FWD, -3 TO TCDT
	CMP	R2,@#TCDT	;HIGHER BY 3 OR MORE ?
	BLE	DTREV		;REVERSE IF HIGHER BY 3 OR MORE
	BR	$DTXF3		;NO, CONTINUE DIRECTION

DTSRF:	CMPB	@#TCCM1,R4	;BLOCK SAME, SAME DIRECTION ?
	BNE	$DTXF3		;BR IF NOT, CONTINUE SEARCH
$DTXF4:	COMB	INTSW		;WANTED ???
	MOVB	DTXCMD,R0	;SET UP XFER COMMAND
	TST	DTBLK
	BPL	$DTXF3		;FORWARD READ
	BIS	R3,R0		;REVERSE READ
	BR	$DTXF3

DTER:	TSTB	INTSW		;SEARCH OR XFER ?
	BNE	DTERA		;BR IF XFER
	TST	@#TCST		;END ZONE ?
	BMI	DTREV		;BR IF YES, TO REVERSE
DTERA:	BIT	#TCSOFT,@#TCST	;CHECK FOR SOFT ERROR
	BEQ	DTHDER		;BR IF NOT SOFT ERROR
	DECB	TRYCTR		;3RD TRY ?
	BEQ	$DTXF3		;BR IF YES
	BR	$DTXF1		;GO TRY AGAIN

DTERB:	BIC	#116,(R1)	;STOP DECTAPE
	PMSG	<?SOFT>
DTERC:	PMSG	< DTA ERR>
	EXITERR

DTHDER:	BIC	#116,(R1)	;STOP DECTAPE
	PMSG	<?HARD>
	BR	DTERC

DTREV:	ADD	R3,R0		;CHANGE DIRECTION
	BIC	#BIT12,R0
DTREVC:	DECB	REVCNT		;6TH REVERSAL ?
	BNE	$DTXF3		;BR IF NOT
	BIC	#116,(R1)	;STOP DECTAPE
	PMSG	<?REV>
	BR	DTERC

DATINT:	BIC	#116,(R1)	;STOP DECTAPE
	EXIT			;DONE