perm filename DTA11.PAL[KL,SYS]2 blob
sn#217471 filedate 1976-05-30 generic text, type C, neo UTF8
COMMENT ā VALID 00027 PAGES
C REC PAGE DESCRIPTION
C00001 00001
C00003 00002 .SBTTL PROGRAM FILE LOADER, 4-SEPT-75
C00008 00003 PROCESS FILENAME.EXT FROM INPUT BUFFER
C00011 00004 DECTAPE/RP04/FLOPPY LOADER START
C00013 00005 LLDONE: MOV R4,DVCNT RESAVE POINTERS
C00015 00006 LDPRO2: JMP ACTLDC LOAD TYPE ERROR
C00017 00007 LDCKSM: TST LDOCTF LOADING OCTAL ?
C00019 00008 LOAD DONE ROUTINE
C00021 00009 3$: TST VERIFY
C00022 00010 PDP-11 BINARY LOAD ROUTINE
C00024 00011 3$: PUSH R0
C00025 00012 KL10 LOAD D-RAM ROUTINE
C00027 00013 KL10 C-RAM ZERO
C00031 00014 2$: MOV LDADR,R0 SELECT C-RAM STARTING ADDRESS
C00032 00015 LOAD TEN CORE ZERO
C00034 00016 LOAD TEN DATA
C00036 00017 LD10VR: BMI LD10ER N-BIT SET DEPOSIT FAILED
C00037 00018 DEVICE FILE DIRECTORY LOOKUP
C00039 00019 1$: MOV (R0)+,DIRST0 STORE RAD50 NAME
C00041 00020 DECTAPE/FLOPPY DIRECTORY ROUTINE
C00042 00021 READ DEVICE FRAME SUBROUTINE
C00044 00022 DVEOF: TST LDCNTL EOF, PRINTING A HELP FILE ?
C00045 00023 RAD50 UNPACK SUBROUTINE
C00047 00024 DECTAPE READ/WRITE FILE ROUTINES
C00048 00025 DECTAPE DEVICE READ/WRITE ROUTINE
C00050 00026 DTSRA: ADD #3,@#TCDT +3 TO TCDT
C00053 00027 .SBTTL ASCR50 ASCII TO RAD50 CONVERSION ROUTINE
C00055 ENDMK
Cā;
.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
; 6 .D10, PDP-11 LOAD DSKDMP BOOTSTRAP .D10 FILE
;ACT10 .BIN LOADED AS .A11
; .SAV LOADED AS .A10
;PROGRAM DETERMINATION & LOAD CONTROL INITIALIZATION
DVLOAD: NAMEXT ;SETUP NAME.EXT
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 LDOVRD,R4 ;ANY LOAD EXT OVERRIDE ?
BLE 53$ ;IF NOT, USE "A10"
CMP #7,R4
BGE 54$ ;BRANCH UNLESS OUT OF BOUNDS
53$: MOV #1,R4
54$: DEC R4 ;RESULT OF 0=A10,1=A11,2,3,4=RAM,5=BIN,6=D10(DSKDMP)
ASL R4 ;DOUBLE R4 (SINCE WE NEED 4 BYTES PER ENTRY)
ASL R4 ;DOUBLE AGAIN
MOV DEFEXT+2(R4),R5 ;SECOND 2 CHARACTERS OF DEFAULT EXT.
MOV DEFEXT(R4),R4
52$: MOV R4,EXTBF
MOV R5,EXTBF+2
4$: MOV #LDCNTL,R3
TST (R3) ;IS THIS "HELP"
BMI 12$ ;BRANCH IF "HELP". NO DEFAULT EXTENSION.
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 66$ ;BR IF YES
CMPB #'D,(R5) ;IS FIRST CHAR A "D" ?
BEQ 21$
5$: TST LDOVRD ;ANY LOAD EXT OVERRIDE ?
BNE 12$ ;YES
BR $$$NAM ;NAME.EXT ERR
6$: CMP #"10,(R4) ;HERE IS IF FIRST CHARACTER IS AN "A"
BEQ 7$ ;BR IF ".A10"
CMP #"11,(R4)
BNE 5$ ;BR IF NOT "A11"
MOV #1,(R3) ;"A11"
BR 12$
7$: CLR (R3) ;A10. SETUP LOAD CONTROL
BR 12$
66$: CMP #"AM,(R4) ;"R" SEEN
BNE 5$ ;BR IF NOT ".RAM"
MOV #2,(R3) ;"RAM"
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$
21$: CMP #"10,(R4) ;IS EXTENSION ".D10" ?
BNE 5$ ;NO, GO REPORT ERROR
MOV #6,(R3) ;YES, SET LOAD CONTROL
BR 12$
DEFEXT: .ASCII /A10 /
.ASCII /A11 /
.ASCII /RAM /
.ASCII /RAM /
.ASCII /RAM /
.ASCII /BIN /
.ASCII /D10 / ;FOR DSKDMP BOOT
;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
CMP LDCNTL,#6 ;D10 FILES ACT LIKE A10
BEQ 1$
TST LDCNTL ;IS THIS .A10 FILE ?
BNE LDPRO2 ;NO, ERROR
1$: 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
0 ;.BIN, DETECTED IN LINE
LDBOOT ;.D10, LOAD DSKDMP BOOT INTO 11 (SAME FORMAT AS A10)
LDLTR: .ASCII /TEZCD T/
$$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
COMMENT ā
RAM file. The RAM file is ascii-ized text. A RAM file consists of a
Z-line, some C-lines, and some D-lines. The Z-line zeros a selected
region of the CRAM. Each C-line loads one or more microcode words
into the CRAM. The D-lines load the DRAM.
Z wc,addr,count,chksum<crlf>
The "Z " and the commas and crlf are literal. WC is ignored
and may be an empty string. ADDR is the first location in
the CRAM to zero; COUNT is the number of words of CRAM to zero.
If COUNT is zero, nothing is zeroed (one Z line must appear
in the file). Chksum, as always, is the negative of the 16-bit
sum of all preceding fields.
C wc,addr,w0pt0,w0pt1,w0pt2,w0pt3,w0pt4,w0pt5,w1pt0....,chksum
WC is a multiple of 6. Six 16-bit fields are loaded into
each CRAM word. Note: In octal format, denoted by CO, the
fields above are partly reversed. They appear in the order:
Pt4,Pt3,Pt2,Pt1,Pt0,Pt5. This is the same format as the
EC and DC commands use.
Pt5 is the spec field. Other fields are:...
A zero WC signifies the CRAM start address is in ADDR, and
that D-lines follow.
D wc,addr,w0pt0,w0pt1,w0pt2,w2tp0,w2pt1,w2pt2,....,chksum
WC must be a multiple of 3. Three 16-bit fields are loaded
into an even-odd pair of DRAM locations specified by addr
(which should be even). WC=0 signifies end of file.
ā
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
.IIF NDF RPASB,RPFIL==$CMDER
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:
.IF DF RPASB
TST DEVTYP
BNE 4$
.ENDC
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
.IF DF RPASB
4$: MOV #FILDSB,R0
RPRDFL ;RP04 FILE DATA BLOCK READ
BCC 2$
CMP #1,R0 ;ERROR, EOF ?
BEQ DVEOF ;YES
RPERROR ;NO, JUST ERROR
.ENDC
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
.SBTTL ASCR50 ASCII TO RAD50 CONVERSION ROUTINE
;CALL:
; ASCR50
; ASCII ADDRESS
; RAD50 ADDRESS
;NINE BYTES OF ASCII INPUT
;THREE WORDS OF RAD50 OUTPUT
$ASCR50:ADD #4,12(SP) ;RETURN OVER TRAILING PARAMETERS
PUSH R0
MOV $EMADR,R5
MOV (R5)+,R1 ;SETUP ASCII ADDRESS
MOV (R5),R4 ;SETUP RAD50 STORAGE ADDRESS
MOV #066600,R3
1$: CLR (R4) ;RESULT WORD
2$: MOV #30$,R0 ;SETUP SCAN TABLE
3$: MOVB (R0)+,R2 ;PUT CONVERSION IN R2
BEQ 20$ ;IF END OF TABLE, ERROR
CMPB (R1),(R0)+ ;COMPARE ASCII CHAR
BLO 20$ ;IF LESS THAN TABLE ENTRY, ERROR
CMPB (R1),(R0)+
BHI 3$ ;LOOP, HAVEN'T FOUND YET
MOVB (R1)+,R0 ;FOUND, ASCII CHAR TO R0
ADD R2,R0 ;CONVERT
ASL (R4)
ASL (R4)
ASL (R4)
ADD (R4),R0
ASL (R4)
ASL (R4)
ADD R0,(R4)
ASL R3 ;SHIFT RAD50 WORD COUNTER
BMI 2$ ;NOT DONE WITH THIS RAD50 YET
BEQ 10$ ;IF 0, ALL DONE
TST (R4)+ ;STEP TO NEXT RAD50 WORD
BR 1$ ;GO DO NEXT
10$: POP R0
EXIT
20$: POP R0
EXITERR
30$: .BYTE -40,' ,' ;SPACE
.BYTE -11,'$,'$ ;DOLLAR SIGN
.BYTE -22,'.,'. ;PERIOD
.BYTE -22,'0,'9 ;DIGITS
.BYTE -100,'A,'Z ;UPPER CASE LETTERS
; .ENABL LC
.BYTE -140,'a,'z ;LOWER CASE LETTERS
.BYTE 0 ;INDICATE THE END OF THE TABLE
.EVEN