Trailing-Edge
-
PDP-10 Archives
-
decuslib10-04
-
43,50322/loader.mac
There are 9 other files named loader.mac in the archive. Click here to see a list.
L==1 ;LISP SWITCH ON FOR LISP SYSTEM VERSION
TITLE LOADER V.057
SUBTTL RP GRUEN/NGP/WFW/DMN/WJE 25-MAR-75
;COPYRIGHT 1968,1969,1970,1971,1972,1973 DIGITAL EQUIPMENT CORP., MAYNARD, MASS.
VLOADER==57
VUPDATE==0 ;DEC UPDATE LEVEL
VEDIT==151 ;EDIT LEVEL
VCUSTOM==1 ;NON-DEC UPDATE LEVEL
;(UCI LISP MODIFICATIONS)
LOC <.JBVER==137>
<VCUSTOM>B2+<VLOADER>B11+<VUPDATE>B17+VEDIT
RELOC
COMMENT * ASSEMBLY FEATURE SWITCHES (ACTION WHEN NON-ZERO)
SWITCHES ON (NON-ZERO) IN DEC VERSION
PURESW GIVES PURE CODE (VARIABLES IN LOW SEG)
REENT GIVES REENTRANT CAPABILITY PDP-10
(REENT=0 FOR PDP-10/30 OR PDP-6 OR EARLY PDP-10)
RPGSW INCLUDE CCL FEATURE
TEMP INCLUDE TMPCOR FEATURE
DMNSW SYMBOL TABLE WILL BE MOVED DOWN FROM TOP OF CORE
KUTSW GIVES CORE CUTBACK ON /K
EXPAND FOR AUTOMATIC CORE EXPANSION
PP ALLOW PROJ-PROG #
NAMESW USE SETNAM UUO TO CHANGE PROGRAM NAME
DIDAL GIVES DIRECT ACCESS LIBRARY SEARCH MODE
ALGSW WILL LOAD ALGOL OWN BLOCK (TYPE 15)
COBSW WILL LOAD COBAL LOCAL SYMBOLS (BLOCK TYPE 37)
SFDSW NUMBER OF SFDS ALLOWED IF NON-ZERO
CPUSW LOADER WILL TEST FOR KI/KA-10 AND LOAD CORRECT LIB40
FORSW DEFAULT VALUE OF FORSE/FOROTS FORTRAN OTS
B11SW INCLUDE POLISH FIXUP BLOCK (TYPE 11)
SWITCHES OFF (ZERO) IN DEC VERSION
K GIVES SMALLER LOADER - NO F4
L FOR LISP LOADER
SPMON GIVES SPMON LOADER (MONITOR LOADER)
MONLOD GIVES MONITOR LOADER WHICH USES DISK AS CORE IMAGE
TEN30 FOR 10/30 LOADER
STANSW GIVES STANFORD FEATURES
LNSSW GIVES LNS VERSION
FAILSW INCLUDE PROVISIONS FOR SPECIAL FAIL FIXUPS.
LDAC MEANS LOAD CODE INTO ACS
(LDAC DOES NOT WORK WITH KUTSW=1.CORE UUO CLEARS JOBBLT)
WFWSW GIVES BLOCK TYPE 13 (VARIABLS INTO LOW SEG)
SYMARG ACCEPT SYMBOLIC (GLOBAL) ARGUMENTS FOR SWITCHES
SPCHN WILL DO SPECIAL OVERLAYING
NELSW FOR NELIAC COMPILER
SAILSW GIVES BLOCK TYPE 16 (FORCE LOAD OF REL FILES)
AND 17 (FORCE SEARCH OF LIBRARIES) FOR SAIL
MANTIS WILL LOAD BLOCK 401 FOR F4 MANTIS DEBUGGER
SYMDSW LOADER WILL STORE SYMBOLS ON DSK
TENEX SPECIAL CODE IF RUNING UNDER TENEX
*
SUBTTL DEFAULT ASSEMBLY SWITCH SETTINGS
IFNDEF SPMON,<SPMON=0>
IFN SPMON,< TEN30==1
K==1>
IFNDEF L,<L=0>
IFNDEF TEN30,<TEN30=0>
IFN TEN30!L,< RPGSW=0
PP=0
IFNDEF DMNSW,< DMNSW=0>
ALGSW=0
COBSW=0
PURESW=0
REENT=0
LDAC=0
KUTSW=0
NAMESW=0>
IFN TEN30,< EXPAND=0
IFNDEF DIDAL,< DIDAL=0>
>
IFN L,< CPUSW==0
PP==1>
IFNDEF MONLOD,<MONLOD=0>
IFN MONLOD,<K==1
ALGSW=0
COBSW=0
DIDAL=0
REENT=0
B11SW==0
SYMDSW==0
EXPAND==1>
IFNDEF K,<K=0>
IFNDEF STANSW,<STANSW=0>
IFN STANSW,< TEMP==0
REENT==0
FAILSW=1>
IFNDEF LNSSW,<LNSSW=0>
IFN LNSSW,<LDAC=1
PP=0>
IFNDEF FAILSW,<FAILSW==0>
IFN FAILSW,<B11SW==1>
IFNDEF B11SW,<B11SW==1>
IFNDEF RPGSW,<RPGSW==1>
IFN RPGSW,<PP==1> ;REQUIRE DISK FOR CCL
IFE RPGSW,<TEMP=0>
IFNDEF PP,<PP==1>
IFNDEF TEMP,<TEMP==1>
IFNDEF NAMESW,<NAMESW==1>
IFNDEF LDAC,<LDAC=0>
IFN LDAC,<KUTSW=0>
IFNDEF KUTSW,<KUTSW==1>
IFNDEF EXPAND,< IFN K,<EXPAND==0>
IFE K,<EXPAND==1>>
IFNDEF DMNSW,<DMNSW==1>
IFN DMNSW!LDAC,<IFNDEF SYMPAT,<SYMPAT==100>
IFN LDAC,<IFG 20-SYMPAT,<SYMPAT==20>>>
IFNDEF REENT,<REENT==1>
IFNDEF PURESW,<PURESW==1>
IFNDEF WFWSW,<WFWSW==0>
IFN K,<SYMARG=0
SPCHN=0>
IFNDEF SYMARG,<SYMARG==0>
IFNDEF SPCHN,<SPCHN==0>
IFNDEF DIDAL,<DIDAL==1>
IFNDEF ALGSW,<ALGSW==1>
IFNDEF COBSW,<COBSW==1>
IFNDEF SAILSW,<SAILSW==0>
IFNDEF NELSW,<NELSW==0>
IFN K,<MANTIS==0>
IFNDEF MANTIS,<MANTIS==0>
IFE PP,<SFDSW==0>
IFNDEF SFDSW,<SFDSW==5>
IFNDEF CPUSW,<CPUSW==1>
IFNDEF FORSW,<FORSW==2> ;1=FORSE, 2=FOROTS
IFNDEF SYMDSW,<SYMDSW==0>
IFN SYMDSW,<DIDAL==0> ;BOTH USE AUX BUFFER
IFNDEF TENEX,<TENEX==0>
SUBTTL ACCUMULATOR ASSIGNMENTS
F=0 ;FLAGS IN BOTH HALVES OF F
N=1 ;FLAGS IN BOTH HALVES OF N
X=2 ;LOADER OFFSET
H=3 ;HIGHEST LOC LOADED
S=4 ;UNDEFINED POINTER
R=5 ;RELOCATION CONSTANT
B=6 ;SYMBOL TABLE POINTER
D=7 ;COMMAND ARGUMENT (OCTAL) AND WORKSPACE
T=10
V=T+1
W=12 ;VALUE
C=W+1 ;SYMBOL, DECIMAL COMMAND ARGUMENT
E=C+1 ;DATA WORD COUNTER
Q=15 ;RELOCATION BITS
A=Q+1 ;SYMBOL SEARCH POINTER
P=17 ;PUSHDOWN POINTER
;MONITOR LOCATIONS IN THE USER AREA
.JBHDA==10
.JBSDD==114 ;SAVE POINTER TO JOBDDT
.JBS41==122 ;SAVE POINTER TO JOB41
INTERN .JBVER,.JBHDA,.JBSDD,.JBS41
EXTERN .JBDDT,.JBFF,.JBSA,.JBREL,.JBSYM,.JBUSY,.JB41,.JBHRL,.JBCOR
EXTERN .JBCHN,.JBERR,.JBBLT,.JBAPR,.JBDA,.JBHSM
NEGOFF==400 ;NEGATIVE OFFSET OF HIGH SEGMENT
PDLSIZ==40 ;LENGTH OF PUSHDOWN STACK
PPDL==60 ;LENGTH OF PUSHDOWN LIST FOR POLISH FIXUPS
;FLAGS F(0 - 17)
CSW==1 ;ON - COLON SEEN
ESW==2 ;ON - EXPLICIT EXTENSION IDENT.
SKIPSW==4 ;ON - DO NOT LOAD THIS PROGRAM
FSW==10 ;ON - SCAN FORCED TO COMPLETION
FCONSW==20 ;ON - FORCE CONSOLE OUTPUT
HIPROG==40 ;LOADING HI PROGRAM, SET BY HISEG. CLEARED BY EOF
ASW==100 ;ON - LEFT ARROW ILLEGAL
FULLSW==200 ;ON - STORAGE EXCEEDED
SLIBSW==400 ;ON - LIB SEARCH IN THIS PROG
RMSMSW==1000 ;REMEMBER IF LOADING WITH SYMBOLS DURING LIB SEARCH
REWSW==2000 ;ON - REWIND AFTER INIT
LIBSW==4000 ;ON - LIBRARY SEARCH MODE
ISW==20000 ;ON - DO NOT PERFORM INIT
SYMSW==40000 ;ON - LOAD LOCAL SYMBOLS
DSW==100000 ;ON - CHAR IN IDENTIFIER
NSW==200000 ;ON - SUPPRESS LIBRARY SEARCH
SSW==400000 ;ON - SWITCH MODE
;MORE FLAGS IN F (18-35)
SEENHI==1 ;HAVE SEEN HI STUFF
NOHI==2 ;LOAD AS NON-REENTRANT
NOTTTY==4 ;DEV "TTY" IS NOT A TTY
NOHI6==10 ;PDP-6 TYPE SYSTEM
HISYM==20 ;BLT SYMBOLS INTO HIGH SEGMENT
SEGFL==40 ;LOAD INTO HI-SEG
XFLG==100 ;INDEX IN CORE (BLOCK TYPE 14)
LSTLOD==200 ;LAST PROG WAS LOADED
DTAFLG==400 ;LIBRARY DEVICE IS A DTA (NEEDED FOR INDEXING)
DMNFLG==1000 ;SYMBOL TABLE TO BE MOVED DOWN
SFULSW==2000 ;PRINTED SYMBOL OVERLAP ONCE ALREADY
ARGFL==4000 ;TREAT $%. AS RADIX-50 CHAR.
TWOFL==10000 ;TWO SEGMENTS IN THIS BINARY FILE
LOCAFL==20000 ;PRINT LOCAL SYMBOLS IN MAP
TTYFL==40000 ;AUX. DEV. IS TTY
TRMFL==100000 ;END OF LOADING SEEN ($ OR /G)
KICPFL==200000 ;HOST CPU IS A KI-10
LSYMFL==400000 ;STORE LOCAL SYMBOLS ON DSK
;FLAGS N(0 - 17)
ALLFLG==1 ;ON - LIST ALL GLOBALS
ISAFLG==2 ;ON - IGNORE STARTING ADDRESSES
COMFLG==4 ;ON - SIZE OF COMMON SET
IFE K,< F4SW==10 ;F4 IN PROGRESS
RCF==20 ;READ DATA COUNT
SYDAT==40; SYMBOL IN DATA>
IFN MONLOD,<DISW==10 ;DISK IMAGE LOAD IN PROGRESS
WOSW==20 ;WRITE OUT SWITCH, DATA IN WINDOW HAS CHANGED>
SLASH==100 ;SLASH SEEN
IFE K,< BLKD1==200 ;ON- FIRST BLOCK DATA SEEN
PGM1==400 ;ON FIRST F4 PROG SEEN
DZER==1000 ;ON - ZERO SECOND DATA WORD>
EXEQSW==2000 ;IMMEDIATE EXECUTION
DDSW==4000 ;GO TO DDT
RPGF==10000 ;IN RPG MODE
AUXSWI==20000 ;ON - AUX. DEVICE INITIALIZED
AUXSWE==40000 ;ON - AUX. DEVICE ENTERED
PPSW==100000 ;ON - READING PROJ-PROG #
PPCSW==200000 ;ON - READING PROJ #
HSW==400000 ;USED IN BLOCK 11 POLISH FIXUPS
;MORE FLAGS IN N (18-35)
F4FL==400000 ;FORTRAN (F40) SEEN
COBFL==200000 ;COBOL SEEN
ALGFL==100000 ;ALGOL SEEN
NELFL==40000 ;NELIAC SEEN
PL1FL==20000 ;PL/1 SEEN
BLIFL==10000 ;BLISS-10
SAIFL==4000 ;SAIL
FORFL==2000 ;FORTRAN-10
F10TFL==1000 ;FORTRAN-10 CODE FOR THIS FILE SET NOHI (TEMP)
KI10FL==400 ;KI-10 ONLY CODE
KA10FL==200 ;KA-10 ONLY CODE
MANTFL==100 ;MANTIS SEEN, LOAD SPECIAL DATA
SYMFOR==40 ;SYMSW FORCED SET
MAPSUP==20 ;SUPRESS SYBOL TABLE OUTPUT
CHNMAP==10 ;MAP FOR SPCHN ROOT SEGMENT PRINTED
ATSIGN==4 ;AT SIGN - INDIRECT COMMAND
ENDMAP==2 ;DELAY MAP TO END
VFLG==1 ;DEFAULT LOAD REENTRANT OPERATION SYSTEM
COMFLS==F4FL!COBFL!ALGFL!NELFL!PL1FL!BLIFL!SAIFL!FORFL
DEFINE ERROR (X,Y)<
JSP A,ERRPT'X
XLIST
SIXBIT Y
LIST>
IFN TENEX,<
OPDEF JSYS [104B8]
OPDEF SEVEC [JSYS 204]
OPDEF GEVEC [JSYS 205]
OPDEF GET [JSYS 200]
OPDEF GTJFN [JSYS 20]
OPDEF CIS [JSYS 141]
OPDEF DIR [JSYS 130]
>
IFN PURESW,<TWOSEGMENTS
RELOC 400000>
DSKBIT==200000 ;FOR USE WITH DEVCHR
DTABIT==100 ;DITTO
DISIZE=2000 ;CORE WINDOW SIZE
.RBEST==10 ;ESTIMATED SIZE OF BLOCK (SYMBOL)
.RBALC==11 ;ALLOCATED SIZE OF BLOCK (SYMBOL)
DALLOC==^D500 ;PREALLOCATE SOME SPACE
DSKBLK==200 ;LENGTH OF DISK BLOCKS
DTABLK==177 ;LENGTH OF DECTAPE BLOCKS (EXCLUDING LINK WORD)
VECLEN==^D25 ;LENGTH OF VECTOR TABLE FOR OVERLAYS
RELLEN==^D5 ;#NUMBER OF REL FILES OR LIBRARIES (MUST BE SAME)
;BUFFER SIZES
TTYL==52 ;TWO TTY BUFFERS
IFNDEF BUFN,<BUFN==2 ;TWO DATA BUFFERS FOR LOAD>
IFE LNSSW,<
BUFL==BUFN*203 ;'BUFN' DTA BUFFERS FOR LOAD
ABUFL==203 ;ONE DTA BUFFER FOR AUX DEV>
IFN LNSSW,<
IFE K,<BUFL==4*203+1>
IFN K,<BUFL==203+1>
ABUFL==2*203+1>
;CALLI DEFINITIONS
OPDEF RESET [CALLI 0]
OPDEF SETDDT [CALLI 2]
OPDEF DDTOUT [CALLI 3]
OPDEF DEVCHR [CALLI 4]
OPDEF CORE [CALLI 11]
OPDEF EXIT [CALLI 12]
OPDEF UTPCLR [CALLI 13]
OPDEF DATE [CALLI 14]
OPDEF MSTIME [CALLI 23]
OPDEF PJOB [CALLI 30]
OPDEF SETUWP [CALLI 36]
OPDEF REMAP [CALLI 37]
OPDEF GETSEG [CALLI 40]
OPDEF SETNAM [CALLI 43]
OPDEF TMPCOR [CALLI 44]
ASUPPRESS
MLON
SALL
SUBTTL INITIALIZATION
BEG: IFE L,< IFN RPGSW,<
TDZA F,F ;NORMAL START
SETO F, ;CCL START>
SETZM DATBEG ;ZERO FIRST WORD OF DATA STORAGE
MOVE N,[DATBEG,,DATBEG+1]
BLT N,DATEND-1 ;ZERO ENTIRE DATA AREA
IFN RPGSW,< ;IF NO CCL FALL THROUGH TO LD:
JUMPE F,LD ;CCL: IF NORMAL START GO TO LD
RESET ;RESET UUO.
IFN TEMP,<MOVEI F,CTLBUF-1 ;USE CCL BUFFER FOR COMMANDS
HRRM F,CTLIN+1 ;DUMMY UP BYTE POINTER
HRLI F,-200 ;MAKE IT AN IOWD
MOVEM F,TMPFIL+1
MOVSI F,'LOA'
MOVEM F,TMPFIL
MOVE N,[XWD 2,TMPFIL] ;POINTER FOR TMPCOR READ
TMPCOR N, ;READ AND DELETE LOA FILE
JRST RPGTMP ;NO SUCH FILE IN CORE, TRY DISK
IMULI N,5 ;GET CHAR COUNT
ADDI N,1
MOVEM N,CTLIN+2 ;STORE IN BUFFER HEADER
MOVEI N,700 ;BYTE POINTER FOR LOA FILE
HRLM N,CTLIN+1 ;BYTE POINTER NOW COMPLETE
SETOM TMPFLG ;MARK THAT A TMPCOR READ WAS DONE
JRST RPGS3C ;GET BACK IN MAIN STREAM
RPGTMP: ; NOT TMP>
INIT 17,1 ;SET UP DSK FOR COMMAND FILE INPUT.
SIXBIT /DSK/
XWD 0,CTLIN
JRST NUTS ;CAN'T INIT, GET INPUT FROM TTY.
MOVEI F,3
PJOB N, ;GET JOB NUMBER
LUP: IDIVI N,12 ;STRIP OFF LAST DIGIT
ADDI N+1,"0"-40 ;CONVERT TO SIXBIT
LSHC N+1,-6 ;SAVE
SOJG F,LUP ;3 DIGITS YET?
HRRI N+2,'LOA' ;LOADER NAME PART OF FILE NAME.
MOVEM N+2,CTLNAM
MOVSI 'TMP' ;AND EXTENSION.
MOVEM CTLNAM+1
LOOKUP 17,CTLNAM ;FILE THERE?
JRST NUTS ;NO.
INIT 16,1 ;GET SET TO DELETE FILE
SIXBIT /DSK/
0
JRST RPGS3A ;GIVE UP
SETZM CTLNAM+3 ;PUT STUFF BACK AS IT WAS
LOOKUP 16,CTLNAM
JRST RPGS3B
SETZM CTLNAM ;SET FOR RENAME
RENAME 16,CTLNAM
JFCL ;IGNORE FAILURE
RPGS3B: RELEASE 16, ;GET RID OF DEVICE
RPGS3A: ;WE HAVE NOT YET STARTED TO SCAN
;COMMAND IN FILE.
RPGS3: MOVEI CTLBUF
MOVEM .JBFF
INBUF 17,1 ;SET UP BUFFER.
RPGS3C: TTCALL 3,[ASCIZ /LOADING/] ;PRINT MESSAGE THAT WE ARE STARTING.
SKIPE NONLOD ;CONTIUATION OF COMMAND?
JRST RPGS2 ;YES, SPECIAL SETUP.
CCLCHN: MOVSI N,RPGF ;@ CHAIN FILES CYCLE FROM HERE
JRST CTLSET ;SET UP TTY
RPGS1: PUSHJ P,[TLNE F,ESW ;HERE FROM FOO@ COMMAND, STORE NAME.
JRST LDDT3 ;SAVE EXTENSION.
TLZE F,CSW!DSW ;AS NAME
MOVEM W,DTIN ;STORE AS NAME
SETZM W,DTIN1 ;TRY BLANK EXTENSION FIRST.
JRST LDDT4]
MOVEM 0,SVRPG ;SAVE 0 JUST IN CASE
SETZM NONLOD ;DETERMINE IF CONTINUATION.
MOVEI 0,2(B) ;BY SEEING IF ANY SYMBOLS LOADED.
CAME 0,.JBREL
SETOM NONLOD ;SET TO -1 AND SKIP CALLI
IFN TEMP,<SETZM TMPFLG>
MOVE 0,ILD1
MOVEM 0,RPG1
OPEN 17,OPEN1 ;KEEP IT PURE
JRST [MOVE W,RPG1
JRST ILD5]
LOOKUP 17,DTIN ;THE FILE NAME.
JRST [MOVE 0,SVRPG ;RESTORE AC0=F
TLOE F,ESW ;WAS EXT EXPLICIT?
JRST ILD9 ;YES, DON'T TRY AGAIN.
MOVEM 0,SVRPG ;SAVE AC0 AGAIN
MOVSI 0,(SIXBIT /TMP/) ;TRY TMP INSTEAD
MOVEM 0,DTIN1
PUSHJ P,LDDT4 ;SET UP PPN
JRST .-1] ;TRY AGAIN
JRST RPGS3
RPGS2: MOVSI 0,RPGF ;SET FLAG
IORM 0,F.C+N
TLO N,RPGF
MOVE 0,SVRPG
JRST LD2Q ;BACK TO INPUT SCANNING.
NUTS: TTCALL 3,[ASCIZ /?LOADER command file not found/]
EXIT
>;END OF IFN RPGSW
>;END OF IFE L
LD: ;HERE AFTER INITIALIZATION IF NO CCL
IFN L,< HRRZM 0,LSPXIT
HRRZM W,LSPREL# ;SAVE LISP'S RELOCATION
MOVEI 0,0
HRRZM R,RINITL
RESET>
IFE L,<IFN RPGSW,<
HLLZS .JBERR ;MAKE SURE ITS CLEAR.>
RESET ;INITIALIZE THIS JOB
SETZ N, ;CLEAR N
CTLSET: SETZB F,S ;CLEAR THESE AS WELL
IFN TENEX,<TLO F,SYMSW!RMSMSW ;ASSUME /S
TRO F,DMNFLG ;ASSUME /B
SETZM NLSTGL ;PERMIT LST OF UNDEF. GLOBALS>
HLRZ X,.JBSA ;TOP OF LOADER
HRLI X,V ;PUT IN INDEX
HRRZI H,.JBDA(X) ;PROGRAM BREAK
MOVE R,[XWD W,.JBDA] ;INITIAL RELOCATION>
MOVSI E,'TTY'
DEVCHR E,
TLNN E,10 ;IS IT A REAL TTY?
IFN RPGSW,<JRST [TLNN N,RPGF ;IN CCL MODE?>
EXIT ;NO, EXIT IF NOT TTY
IFN RPGSW,< TRO F,NOTTTY ;SET FLAG
JRST LD1] ;SKIP INIT>
INIT 3,1 ;INITIALIZE CONSOLE
SIXBIT /TTY/
XWD BUFO,BUFI
CALLEX: EXIT ;DEVICE ERROR, FATAL TO JOB
MOVEI E,TTY1
MOVEM E,.JBFF
INBUF 3,1
OUTBUF 3,1 ;INITIALIZE OUTPUT BUFFERS
OUTPUT 3, ;DO INITIAL REDUNDANT OUTPUT
LD1:
IFE L,< HRRZ B,.JBREL ;MUST BE JOBREL FOR LOADING REENTRANT>
IFN L,< MOVE B,.JBSYM ;USED INSTEAD OF JOBREL FOR SYMBOL TABLE FIXUPS>
HRRZM B,HISTRT
SUB B,SE3 ;INITIALIZE SYMBOL TABLE POINTER
CAILE H,1(B) ;TEST CORE ALLOCATION
IFE L,< JRST [HRRZ B,.JBREL;TOP OF CORE
ADDI B,2000 ;1K MORE
CORE B, ;TRY TO GET IT>
EXIT ;INSUFFICIENT CORE, FATAL TO JOB
IFE L,< JRST LD1] ;TRY AGAIN>
IFN EXPAND,<MOVE S,[10,,12] ;CORMAX IN NSWTBL
GETTAB S, ;GET MAX CORE ALLOWED TO A JOB
MOVSI S,1 ;SET TO VERY LARGE
IFN REENT,<HLRZ E,.JBHRL ;BUT DON'T INCLUDE HIGH SEGMENT
SUBI S,1(E) ;IN LOW SEGMENT MAX>
IFE REENT,<SUBI S,1 ;ONE LESS FOR K BOUND>
MOVEM S,ALWCOR ;SAVE IT FOR XPAND TEST>
IFN PURESW,<MOVE S,[XWD HICODE,LOWCOD]
BLT S,LOWCOD+CODLN-1>
IFE L,< MOVS E,X ;SET UP BLT POINTER
HRRI E,1(X)>
IFN L,<MOVS E,H
HRRI E,1(H)>
SETZM -1(E) ;ZERO FIRST WORD
BLT E,(B) ;ZERO CORE UP TO THE SYMBOL AREA
HRRZ S,B ;INITIALIZE UNDEF. POINTER
MOVEM S,NAMPTR ;INITIALIZE PROGRAM NAME POINTER
IFE L,< HRRI R,.JBDA ;INITIALIZE THE LOAD ORIGIN
MOVE E,COMM ;SET .COMM. AS THE FIRST PROGRAM
MOVEM E,1(B) ;STORE IN SYMBOL TABLE
HRRZM R,2(B) ;STORE COMMON ORIGIN>
MOVEI E,F.C ;INITIALIZE STATE OF THE LOADER
BLT E,B.C
MOVE W,[ZBEG,,ZBEG+1]
SETZM ZBEG ;CLEAR START OF INITIALIZED DATA
BLT W,ZEND ;AND THE REST
IFN CPUSW,<
MOVNI W,1 ;-1
AOBJN W,.+1 ;STANDARD TEST
JUMPN W,.+2 ;KA-10 (OR PDP-6)
TRO F,KICPFL ;KI-10>
IFN REENT,<MOVSI W,1
MOVEM W,HVAL1
MOVEM W,HVAL
MOVEM X,LOWX
MOVEM R,LOWR
HRRZI W,1
SETUWP W, ;SETUWP UUO.
TRO F,NOHI6 ;PDP-6 COMES HERE.>
IFN REENT!CPUSW,<
MOVEM F,F.C ;PDP-10 COMES HERE.>
IFN SAILSW,<MOVE W,[XWD -RELLEN-1,LIBFLS-1] ;SET UP POINTERS
MOVEM W,LIBPNT# ;IN THE FORM OF AOBJN WORDS
MOVE W,[XWD -RELLEN-1,PRGFLS-1]
MOVEM W,PRGPNT#>
IFE L,< MOVSI W,254200 ;STORE HALT IN .JB41
MOVEM W,.JB41(X) ;...>
IFN L,< MOVE W,.JBREL
HRRZM W,OLDJR>
IFN B11SW,<MOVEI W,440000 ;SET UP THE SPECIAL BITS OF HEADNUM(ADD+POLISH)
MOVEM W,HEADNM
MOVEI W,PDLOV ;ENABLE FOR PDL OV
MOVEM W,.JBAPR
MOVEI W,200000
CALLI W,16
>
IFN DMNSW,<MOVEI W,SYMPAT
MOVEM W,KORSP>
IFN MONLOD,<IFN PURESW,<
MOVEI W,.RBALC ;NUMBER OF WORDS FOR ENTER
MOVEM W,DIOUT
MOVEI W,DALLOC ;NUMBER OF BLOCKS TO ALLOCATE
MOVEM W,DIOUT+.RBEST>>
IFN SFDSW,<GETPPN W, ;GET USER'S PPN
MOVEM W,MYPPN ;SAVE IT FOR [,,] ETC>
IFN FORSW,<MOVEI W,FORSW-1 ;GET DEFAULT
MOVEM W,FORLIB ;INCASE USER DOESN'T SET IT>
;LOADER SCAN FOR FILE NAMES
LD2Q: XOR N,F.C+N ;HERE WE STORE THE TWO BITS FOR
AND N,[AUXSWI!AUXSWE,,ENDMAP] ;THE AUX FILE INTO THE
XORM N,F.C+N ;SAVED REGISTER 'N'
MOVSI B,F.C ;RESTORE ACCUMULATORS
BLT B,B
MOVE P,PDLPT ;INITIALIZE PUSHDOWN LIST
SETZM BUFI2 ;CLEAR INPUT BUFFER POINTER
IFE PP,<SETZM ILD1 ;CLEAR INPUT DEVICE NAME>
IFN PP,<MOVSI T,'DSK' ;ASSUME DSK.
MOVEM T,ILD1>
SETZM OLDDEV ;TO MAKE IT GO BACK AFTER /D FOR LIBSR
LD2B: RELEAS 1, ;RELEASE BINARY INPUT DEVICE
IFN PP,<SETZM PPPN ;CLEAR PERMANENT PPN ON EACH NEW LINE>
IFN RPGSW,< TLNE N,RPGF ;NOT IF DOING CCL STUFF
JRST LD2BA>
MOVEI T,"*"
IDPB T,BUFO1 ;OUTPUT ASTERISK TO START INPUT
OUTPUT 3,
LD2BA: TLZ F,FULLSW+ASW+ISW+CSW+ESW+SKIPSW+SLIBSW+REWSW
LD2BP: TLNE F,LIBSW ;WAS LIBRARY MODE ON?
TLO F,SKIPSW ;YES, NORMAL MODE IS SKIPPING
LD2DD: SETZM DTIN ;CLEAR FILE NAME AFTER , CR-LF, ETC
LD2D: SKIPE W,OLDDEV ;RESET DEVICE IF NEEDED.
CAMN W,ILD1 ;IS IT SAME?
JRST LD2DC ;YES, FORGET IT.
MOVEM W,ILD1
LD2DB: TLZ F,ISW+DSW+FSW+REWSW
LD2DC: IFN PP,<SETZM PPN ;DON'T REMEMBER PPN FROM ONE FILE TO NEXT.>
LD2DA: SETZB W,OLDDEV ;INITIALIZE IDENTIFIER SCAN
MOVEI E,6 ;INITIALIZE CHARACTER COUNTER
MOVE V,LSTPT ;INITIALIZE BYTE POINTER TO W
TLZ F,SSW+DSW+FSW ;LEAVE SWITCH MODE
LD3: IFN RPGSW,<TLNE N,RPGF ;CHECK RPG FEATURE
JRST RPGRD>
SOSGE BUFI2 ;DECREMENT CHARACTER COUNTER
JRST [INPUT 3, ;FILL TTY BUFFER
JRST .-1] ;MAKE SURE NOT A NULL BUFFER
ILDB T,BUFI1 ;LOAD T WITH NEXT CHARACTER
LD3AA: CAIE T,175 ;OLD ALTMOD
CAIN T,176 ;EVEN OLDER ONE
MOVEI T,33 ;NEW ONE
CAIL T,140 ;LOWER CASE?
TRZ T,40 ;CONVERT TO UPPER CASE
MOVE Q,T
HRLM Q,LIMBO ;SAVE THIS CHAR.
MOVSS LIMBO ;AND LAST ONE
IDIVI Q,11 ;TRANSLATE TO 4 BIT CODE
LDB Q,LD8(A) ;LOAD CLASSIFICATION CODE
CAIGE Q,4 ;MODIFY CODE IF .GE. 4
TLNN F,SSW ;MODIFY CODE IF SWITCH MODE OFF
ADDI Q,4 ;MODIFY CLASS. CODE FOR DISPATCH
IFN SYMARG,<CAIL Q,20 ;SKIP UNLESS SECOND FORM OF DISPATCH
JRST LD3AB ;DIFFERENT DISPATCH>
HRRZ A,LD3A(Q) ;LOAD RH DISPATCH ENTRY
CAIL Q,10 ;SKIP IF CORRECT DISPATCH ENTRY
HLRZ A,LD3A-10(Q) ;LOAD LH DISPATCH ENTRY
JRST @A ;JUMP TO INDICATED LOCATION
;HERE ON ERRORS
LD2C: POP P,(P) ;BACKUP ONE LEVEL
LD2: SETZM SBRNAM ;CLEAR BLOCK TYPE 6 SEEN
IFN RPGSW,<TLNE N,RPGF ;IN CCL MODE
TRNN F,TRMFL ;YES, /G SEEN?>
JRST LD2Q ;NO, START A NEW LINE
IFN RPGSW,<POPJ P, ;AND RETURN>
;COMMAND DISPATCH TABLE
LD3A: XWD LD3,LD7B ;IGNORED CHAR, BAD CHAR (SWITCH)
XWD LD6A,LD6 ;</> OR <(>, LETTER (SWITCH)
XWD LD5,LD6C ;<:>, DIGIT (SWITCH ARG.)
XWD LD5A,LD6D ;<.>, ESCAPE SWITCH MODE <)>
XWD LD5C,LD7 ;<=> OR <L. ARROW>, BAD CHAR.
XWD LD5B,LD4 ;<,>, ALPHABETIC CHAR.
XWD LD5D,LD4 ;<CR.>, NUMERIC CHAR.
XWD LD5E1,LD7 ;<ALT MODE>, BAD CHAR. <)>
IFN SYMARG,<XWD LD7,LD10 ;BAD CHAR,&>
IFN SYMARG,<
LD3AB: ROT Q,-1 ;CUT Q IN HALF
HRRZ A,LD3A(Q) ;PULL OFF RIGHT HALF OF TABLE ENTRY
JUMPGE Q,@A ;WHICH IS CORRECT FOR EVEN ENTRIES
HLRZ A,LD3A(Q) ;BUT USE LEFT HALF FOR ODD ENTRIES
JRST @A>
IFN RPGSW,<
RPGRD1: MOVNI T,5
ADDM T,CTLIN+2
AOS CTLIN+1
RPGRD: SOSG CTLIN+2 ;CHECK CHARACTER COUNT.
JRST RPGRD2
IBP CTLIN+1 ;ADVANCE POINTER
MOVE T,@CTLIN+1 ;AND CHECK FOR LINE #
TRNE T,1
JRST RPGRD1
LDB T,CTLIN+1 ;GET CHR
JRST LD3AA ;PASS IT ON
RPGRD2:
IFN TEMP,<SKIPE TMPFLG ;TMPCOR UUO READ DONE?
JRST RPGRD3 ;YES, SO SHOULD NEVER GET HERE>
IN 17,0
JRST RPGRD+2
STATO 17,740000
JRST RPGRD3 ;END OF FILE
ERROR ,</ERROR WHILE READING COMMAND FILE!/>
EXIT ;AND GIVE UP
RPGRD3: ERROR ,</END-OF-FILE ON COMMAND FILE!/>
EXIT
>
SUBTTL CHARACTER HANDLING
;ALPHANUMERIC CHARACTER, NORMAL MODE
LD4: SOJL E,LD3 ;JUMP IF NO SPACE FOR CHAR IN W
CAIGE T,141 ;WORRY ABOUT LOWER CASE LETTERS
SUBI T,40 ;CONVERT FROM ASCII TO SIXBIT
IDPB T,V ;DEPOSIT CHAR OF IDENTIFIER IN W
TLO F,DSW ;SET IDENTIFIER FLAG
JRST LD3 ;RETURN FOR NEXT CHARACTER
;DEVICE IDENTIFIER DELIMITER <:>
LD5: PUSH P,W ;SAVE W
TLOE F,CSW ;TEST AND SET COLON FLAG
PUSHJ P,LDF ;FORCE LOADING
POP P,W ;RESTORE W
TLNE F,ESW ;TEST SYNTAX
JRST LD7A ;ERROR, MISSING COMMA ASSUMED
JUMPE W,LD2DC ;JUMP IF NULL DEVICE IDENTIFIER
EXCH W,ILD1 ;STORE DEVICE IDENTIFIER
MOVEM W,LSTDEV ;SAVE LAST DEVICE SO WE CAN RESTORE IT
JRST LD2DB ;RETURN FOR NEXT IDENTIFIER
;FILE NAME EXTENSION IDENTIFIER DELIMITER <.>
LD5A: IFN SYMARG,<
TRNE F,ARGFL ;IS "." SPECIAL
JRST LD4 ;YES,RADIX-50>
TLOE F,ESW ;TEST AND SET EXTENSION FLAG
JRST LD7A ;ERROR, TOO MANY PERIODS
TLZE F,CSW+DSW ;SKIP IF NULL IDENT AND NO COLON
MOVEM W,DTIN ;STORE FILE IDENTIFIER
JRST LD2DC ;RETURN FOR NEXT IDENTIFIER
;INPUT SPECIFICATION DELIMITER <,>
LD5B:
IFN PP,<TLZE N,PPCSW ;READING PP #?
JRST [
IFN SFDSW,< SKIPN D ;JUST A COMMA SEEN?
HLRZ D,MYPPN ;YES, USE OWN PROJ #>
IFE STANSW,< HRLM D,PPN ;STORE PROJ #
JRST LD6A1 ];GET PROG #>
IFN STANSW,< PUSHJ P,RJUST ;RIGHT JUSTIFY W
HRLM W,PPN ;STORE PROJ NAME
JRST LD2D ];GET PROG NAME>
PUSHJ P,SFDCK ;CHECK FOR SFD DIRECTORY>
SETOM LIMBO ;USED TO INDICATE COMMA SEEN
TLZN F,FSW ;SKIP IF PREV. FORCED LOADING
PUSHJ P,FSCN2 ;LOAD (FSW NOT SET)
JRST LD2BP ;RETURN FOR NEXT IDENTIFIER
LD5B1: TLNE F,ESW ;TEST EXTENSION FLAG
JRST LDDT3 ;EXPLICIT EXTENSION IDENTIFIER
TLZN F,CSW+DSW ;SKIP IF IDENT. OR COLON
POPJ P,
MOVEM W,DTIN ;STORE FILE IDENTIFIER
JRST LDDT2 ;ASSUME <.REL> IN DEFAULT CASE
;OUTPUT SPECIFICATION DELIMITER <=> OR <LEFT ARROW>
;OR PROJ-PROG # BRACKETS <[> AND <]>
LD5C:
IFN SPCHN,<CAIN T,"=" ;DO A /= AS SWITCH
TLNN F,SSW
SKIPA
JRST LD6>
IFN RPGSW,<CAIN T,"@" ;CHECK FOR * COMMAND.
JRST RPGS1>
IFN PP,<CAIN T,"[" ;PROJ-PROG #?
JRST [TLO N,PPSW+PPCSW ;SET FLAGS
MOVEM W,PPNW ;SAVE W
MOVEM E,PPNE ;SAVE E
MOVEM V,PPNV ;SAVE V
IFN SFDSW,< SETZM SFD ;USED AS A FLAG>
IFE STANSW,< JRST LD6A2]> ;READ NUMBERS AS SWITCHES
IFN STANSW,< JRST LD2D]>
CAIN T,"]" ;END OF PP #?
JRST [PUSHJ P,RBRA ;PROCESS RIGHT BRACKET
JRST LD3] ;READ NEXT IDENT>
TLOE F,ASW ;TEST AND SET LEFT ARROW FLAG
JRST LD7A ;ERROR, MISPLACED LEFT ARROW
PUSHJ P,LD5B1 ;STORE IDENTIFIER
TLZN F,ESW ;TEST EXTENSION FLAG
MOVSI W,'MAP' ;ASSUME <.MAP> IN DEFAULT CASE
HRRI W,0 ;CLEAR RIGHT HALF OF EXTENSION
CAMN W,['CHN '] ;TEST FOR <.CHN> EXTENSION
MOVSI W,'MAP' ;AND TURN IT BACK TO MAP
IFN MONLOD,<CAMN W,['XPN '] ;IS EXTENSION 'XPN'?
JRST DIOPEN ;YES, OPEN DISK IMAGE FILE>
IFN SYMDSW,<CAMN W,['SYM '] ;IF EXT IS SYM
JRST SYOPEN ;OPEN AUX FOR SYMBOL FILE>
MOVEM W,DTOUT1 ;STORE FILE EXTENSION IDENTIFIER
MOVE W,DTIN ;LOAD INPUT FILE IDENTIFIER
MOVEM W,DTOUT ;USE AS OUTPUT FILE IDENTIFIER
IFN SPCHN,<MOVEM W,CHNENT ;AND FOR SPECAIL CHAINING>
IFN PP,<SKIPN W,PPN ;PROJ-PROG #
MOVE W,PPPN ;TRY PERMANENT ONE
MOVEM W,DTOUT+3 ;...>
MOVE W,ILD1 ;LOAD INPUT DEVICE IDENTIFIER
MOVEM W,LD5C1 ;USE AS OUTPUT DEVICE IDENTIFIER
IFN SPCHN,<SKIPN CHNACB ;ARE WE DOING A SPECIAL CHAIN?
MOVEM W,CHNOUT+1 ;ALLOW HIM TO CHOOSE SP CHAIN DEV>
SKIPN W,LSTDEV ;RESTORE LAST
IFN PP,<MOVSI W,'DSK' ;RESET DEVICE TO DSK>
SETZM LSTDEV ;BUT ONLY ONCE
MOVEM W,ILD1
;INITIALIZE AUXILIARY OUTPUT DEVICE
IFN SYMDSW,<
TLNN F,LSYMFL ;IGNORE IF ALREADY IN USE
PUSHJ P,AUXINI
JRST LD2DD
AUXINI:>
TRZ F,TTYFL
IFE SYMDSW,<TLZE N,AUXSWI+AUXSWE ;FLUSH CURRENT DEVICE
RELEASE 2, ;...>
MOVE W,LD5C1 ;GET AUX DEVICE
DEVCHR W, ;IS DEVICE A TTY?
TLNE W,10 ;...
TRO F,TTYFL ;YES SET FLAG
TLNE W,(1B4) ;IS IT CONTROLING TTY?
IFE SYMDSW,<JRST LD2DD ;YES, SKIP INIT>
IFN SYMDSW,<POPJ P,>
OPEN 2,OPEN2 ;KEEP IT PURE
JRST ILD5A
TLNE F,REWSW ;REWIND REQUESTED?
UTPCLR 2, ;DECTAPE REWIND
TLZE F,REWSW ;SKIP IF NO REWIND REQUESTED
MTAPE 2,1 ;REWIND THE AUX DEV
MOVEI E,AUX ;SET BUFFER ORIGIN
MOVEM E,.JBFF
OUTBUF 2,1 ;INITIALIZE SINGLE BUFFER
TLO N,AUXSWI ;SET INITIALIZED FLAG
IFN LNSSW,<EXCH E,.JBFF
SUBI E,AUX
IDIV C,E
OUTBUF 2,(C)>
IFE SYMDSW,<JRST LD2DD ;RETURN TO CONTINUE SCAN>
IFN SYMDSW,<POPJ P,>
;RIGHT SQUARE BRACKET (PROJ-PROG NUMBERS)
IFN PP,<
SFDCK: IFN SFDSW,<
TLNN N,PPSW ;READING PP #?
POPJ P, ;NO
SKIPE SFD ;READING SFD YET?
JRST SFDCK1 ;YES
SKIPN D ;NUMBER SEEN?
HRRZ D,MYPPN ;NO, USE MINE
HRRM D,PPN ;STORE IT
MOVEM X,SFD ;NEED AN AC, SETS SFD NON-ZERO
MOVE X,[-SFDSW,,SFD] ;INITIALIZE POINTER
JRST LD2DA ;GET FIRST SFD
SFDCK1: AOBJP X,SFDER ;ERROR IF TOO MANY SFDS
MOVEM W,(X) ;STORE IN SLOT
JRST LD2DA ;GET NEXT SFD
SFDER: MOVE X,SFD ;RESTORE X
ERROR ,</?TOO MANY SFDS SPECIFIED@/>
JRST LD2
>
RBRA: TLZN N,PPSW ;READING PP #?
POPJ P, ;NOPE, RETURN
TLZE N,PPCSW ;COMMA SEEN?
JRST LD7A ;NOPE, INDICATE ERROR
IFN SFDSW,<SKIPN SFD ;A FULL PATH SPECIFIED?
JRST RBRA1 ;NO
AOBJP X,SFDER ;MUST STORE LAST SFD
MOVEM W,(X)
SETZM 1(X) ;END WITH A ZERO
MOVE X,SFD ;RESTORE X
MOVEI W,SFDADD ;POINT TO SFD PATH
EXCH W,PPN
MOVEM W,SFD ;STORE IN BLOCK
JRST RBRA2 ;CONTINUE
RBRA1:>
IFE STANSW,<HRRM D,PPN ;STASH PROG NUMBER
TLZ F,SSW ;AND TURN OFF SWITCH MODE>
IFN STANSW,<PUSHJ P,RJUST ;RIGHT JUSTIFY W
HRRM W,PPN ;STASH PROG NAME>
MOVE W,PPN ;GET PPN
RBRA2: SKIPN DTIN ;FILE NAME SEEN IN THIS SPEC?
SKIPE PPNW ;OR SOMETHING WAITING IN W?
JRST RBRA3 ;YES, SO WE'VE GOT A FILE NAME SOMEWHERE
MOVEM W,PPPN ;NO , SO MAKE PERMANENT PPN
IFN SFDSW,<MOVE W,[SFD,,PSFD]
BLT W,PSFD+SFDSW ;MOVE FULL PATH
MOVEI W,PSFDAD ;POINT TO IT
SKIPE SFD ;BUT NOT IF IT'S ZERO
MOVEM W,PPPN ;AND STORE>
RBRA3: MOVE W,PPNW ;PICKUP OLD IDENT
MOVE E,PPNE ;RESTORE CHAR COUNT
MOVE V,PPNV ;RESTORE BYTE PNTR
POPJ P, ;TRA 1,4
;RIGHT JUSTIFY W
IFN STANSW,<
RJUST: JUMPE W,LD7A ;NOTHING TO RIGHT JUSTIFY
TRNE W,77 ;IS W RJUSTED YET?
POPJ P, ;YES, TRA 1,4
LSH W,-6 ;NOPE, TRY AGAIN
JRST .-3 ;...>>
IFN SYMARG,<
;& SELECTS A SYMBOL RATHER THAN ANUMBER FOR A SWITCH ARGUMENT
;& MUST ALSO FOLLOW THW SYMBOL; THE FORM IS /&SYMBOL&SWITHCH
LD10: TRC F,ARGFL ;SET OR CLEAR SPECIAL CHARS.
TLCE F,SSW ;IF IN SWITCH MODE, EXIT TO GET IDENTIFIER
JRST LD10B
PUSHJ P,ASCR50 ;IF NOT, REENTER IT, CONVERT IDENTIFIER TO R50
PUSHJ P,SDEF ;AND SEE IF IT EXISTS
JRST LD10A ;YES IT DOES
PUSHJ P,PRQ ;NO, COMPLAIN. OUTPUT ?
PUSHJ P,SPACE ;FOLLOWED BY A SPACE
PUSHJ P,PRNAME ;FOLLOWED BY THIS SYMBOL
ERROR 0,</ DOESN'T EXIST@/>
JRST LD2
LD10A: MOVE D,2(A) ;SET D=VALUE OF SYMBOL AS NUMERIC ARG
TLZ F,DSW!FSW
MOVEI E,6 ;INITIALIZE NEW IDENTIFIER SCAN
MOVE V,LSTPT ;(W IS ALREADY 0)
JRST LD3 ;NOW EAT SWITCH AND CONTINUE PROCESSING COMMAND
LD10B: PUSHJ P,FSCN1 ;FORCE SCAN TO COMPLETION TO MAKE SURE FILE IS LOADED
JRST LD2DA>
SUBTTL CONVERT SYMBOL IN W TO RADIX-50 IN C
IFN SYMARG,<
;ALSO USES A
ASCR50: MOVEI A,0
R50A: MOVEI C,0
ROTC W,6 ;C IS NEXT SIXBIT CHAR
CAIGE C,20
JRST R50B ;UNDER 20, MAY BE ., $, OR %
CAILE C,31
JRST R50C ;OVER 31
SUBI C,20-1 ;IS NUMBER
R50D: IMULI A,50
ADD A,C
JUMPN W,R50A ;LOOP FOR ALL CHARS
MOVE C,A ;WIND UP WITH CHAR IN C
TLO C,040000 ;MAKE IT GLOBAL DEFINITION
POPJ P,
R50B: JUMPE C,R50D ;OK IF SPACE
CAIE C,16 ;TEST IF .
JRST .+3 ;NO
MOVEI C,45 ;YES
JRST R50D
CAIE C,4 ;SKIP IF $
R50E: MOVEI C,5 ;ASSUME % IF NOTHING ELSE
ADDI C,42
JRST R50D
R50C: CAIGE C,41
JRST R50E ;BETWEEN 31 AND 41
CAILE C,72
JRST R50E ;OVER 72
SUBI C,41-13 ;IS LETTER
JRST R50D>
;DEFINE PUTS A SYMBOL IN THE UNDEFINED SYMBOL TABLE
;SO LOADER CAN SCAN LIBRARY AND LOAD PROGRAMS BEFORE THEY ARE REQUESTED
;THE FORM IS /&SYMBOL# WHERE SYMBOL IS CONVERTED TO RADIX-50
IFN SYMARG,<
DEFINE: PUSHJ P,ASCR50 ;CONVRT TO R-50
MOVEI W,-2(S) ;WHERE SYMBOL WILL GO
CAIG W,(H) ;ENOUGH ROOM
IFN EXPAND,<PUSHJ P,[PUSHJ P,XPAND
TLOA F,FULLSW
JRST POPJM3
POPJ P,]>
IFE EXPAND,<TLO F,FULLSW>
SUB S,SE3 ;ADJUST POINTER
MOVEM C,1(S) ;R-50 SYMBOL
SETZM 2(S) ;VALUE
TLZ F,DSW!SSW ;TURN OFF SWITCHES
TRZ F,ARGFL ; DITTO
TLZN N,SLASH ;IF NOT /&NAME#
JRST LD6A2 ;MUST BE (&NAME#), GET )
JRST LD2D ;CONTINUE TO SCAN
>
SUBTTL TERMINATION
;LINE TERMINATION <CARRIAGE RETURN>
LD5D:
IFN PP,<PUSHJ P,RBRA ;CHECK FOR UNTERMINATED PP #>
SKIPGE LIMBO ;WAS LAST CHAR. BEFORE CR A COMMA?
TLO F,DSW ;YES ,SO LOAD ONE MORE FILE
PUSHJ P,FSCN ;FORCE SCAN TO COMPLETION
JRST LD2B ;RETURN FOR NEXT LINE
;TERMINATE LOADING <ALT MODE>
LD5E: JUMPE D,LD5E1 ;ENTER FROM G COMMAND
TLO N,ISAFLG ;AND IGNORE ANY STARTING ADDRESS TO COME
HRRZM D,STADDR ;USE NUMERIC STARTING ADDRESS
LD5E1: PUSHJ P,CRLF ;START A NEW LINE
IFN RPGSW,<TRO F,TRMFL ;INDICATE TERMINATION STAGE
RELEASE 17,0 ;RELEASE COMMAND DEVICE>
IFN MANTIS,<TRNN N,MANTFL ;LOADING MANTIS?
JRST LD5E2 ;NO
IFN KUTSW,<SETOM CORSZ ;DON'T KUT BACK CORE>
IFN DMNSW,<TRZ F,DMNFLG ;OR MOVE SYMBOLS>
LD5E2: >
PUSHJ P,SASYM ;SETUP JOBSA,JOBFF,JOBSYM,JOBUSY
IFE NAMESW,<MOVE W,['LOADER'] ;FINAL MESSAGE>
JUMPL S,.+2 ;UNDEFINED SYMBOLS
SKIPE MDG ;OR MULTIPLY DEFINED
PUSHJ P,PRQ ;PRINT "?" FOR BATCH
IFN NAMESW,<HRRZ W,HISTRT ;IN CASE NO NAME SET, USE FIRST LOADED
MOVE W,-1(W)
SKIPN CURNAM
PUSHJ P,LDNAM
MOVE W,CURNAM
CAME W,[SIXBIT /MAIN/] ;FORTRAN MAIN PROG, OR MACRO NO TITLE
JUMPN W,.+3 ;A USEFUL NAME SEEN
SKIPE PRGNAM ;NO, SO TRY BINARY FILE NAME
MOVE W,PRGNAM ;USE BINARY FILE NAME IN EITHER CASE
IFE L,<MOVEM W,CURNAM ;SAVE NAME FOR LATER>
IFN L,<SETNAM W, ;SETNAM>>
IFN MONLOD,<TLNN N,DISW ;SKIP IF LOADING TO DISK?>
PUSHJ P,BLTSET ;SETUP FOR FINAL BLT
RELEASE 2, ;RELEASE AUX. DEV.
RELEASE 1,0 ;INPUT DEVICE
RELEASE 3,0 ;TTY
IFN SPCHN,<RELEASE 4,0 ;SPECIAL CHAINING CHANEL>
IFN L,< MOVE W,LSPREL ;RESTORE LISP'S RELOCATION
JRST @LSPXIT>
IFE L,< ;NONE OF THIS NEEDED FOR LISP
IFN PURESW,<
MOVE V,[XWD HHIGO,HIGO]
BLT V,HIGONE ;MOVE DOWN CODE TO EXIT>
TLNN N,EXEQSW ;DO WE WANT TO START
JRST LD5E3
IFN RPGSW,<HRRZ C,.JBERR ;CHECK FOR ERRORS
IFE MANTIS,<TLNN N,DDSW ;ALLOW EXECUTION IF TO DDT>
IFN MANTIS,<TDNN N,[DDSW,,MANTFL] ;OR MANTIS>
JUMPN C,EXDLTD ;ERRORS AND NOT TO DDT>
IFN MONLOD,<TLNE N,DISW ;DISK IMAGE LOAD IN PROGRESS?
MOVE X,XRES ;YES, GET RESIDENT X>
HRRZ W,.JBSA(X)
IFN MANTIS,<TRNN N,MANTFL ;NO MESSAGE IF STARTING SPECIAL DEBUGGER>
TLNN N,DDSW ;SHOULD WE START DDT??
IFE TENEX,<JRST LD5E2 ;NO>
IFN TENEX,<JRST LD5E2 ;NO
PUSH P,1
MOVEI 1,400000 ;THIS FORK
DIR
CIS
JSYS 147 ;TENEX RESET, NOT CALLI 0. FLUSH PA1050
MOVE 1,.JBSYM(X)
MOVEM 1,@770001 ;GIVE SYMS TO DDT
MOVE 1,.JBUSY(X)
MOVEM 1,@770002 ;AND UNDEF SYMS
POP P,1>
HRRZ W,.JBDDT(X)
TTCALL 3,[ASCIZ /DDT /]
LD5E2: IFN MANTIS,<
SKIPE V,MNTSYM ;SHOULD WE START SPECIAL DEBUGGER?
TRNN N,MANTFL
JRST .+3 ;NO
HRRZ W,.JBREN##(X) ;YES
MOVEM V,.JBCN6##(X) ;SETUP AUXILARY SYMBOL POINTER>
IFN RPGSW,< TLNE N,RPGF ;IF IN RPG MODE
JUMPE W,NOSTAD ;ERROR IF NO STARTING ADDRESS>
JUMPE W,LD5E3 ;ANYTHING THERE?
TLOA W,(JRST) ;SET UP A JRST
LD5E3: SKIPA W,CALLEX ;NO OR NO EXECUTE, SET CALLI 12
IFN MANTIS,<TRNE N,MANTFL ;NO MESSAGE IF STARTING SPECIAL DEBUGGER
CAIA>
TTCALL 3,[ASCIZ /EXECUTION
/]
IFN TENEX,<MOVEM X,V ;SAVE AWAY RELOCATION
MOVE X,.JBSA(X) ;NEW START ADDRESS
HRLI X,<JRST>B53 ;JRST IN LH
MOVEI N,400000 ;THIS FORK
SEVEC ;SET ENTRY VECTOR
MOVE X,V ;UNSAVE RELOCATION>
IFN LDAC,< HRLZ P,BOTACS ;SET UP FOR ACBLT
MOVEM W,.JBBLT+1(X) ;SET JOBBLT
MOVE W,[BLT P,P]
MOVEM W,.JBBLT(X)>
MOVE V,.JBVER(X) ;GET VERSION NUMBER
MOVEM V,.JBVER ;SET IT UP BEFORE SETNAM UUO
IFN MONLOD,<TLNE N,DISW ;LOADING TO DISK?
JRST DIOVER ;YES, CLEAN UP THE XPN FILE>
TLNE F,FULLSW ;DID WE RUN OUT OF CORE?
HRRZ A,Q ;YES, NULIFY BLT
MOVSI LSTAC,LODACS ;SET UP TO BLT BLT CODE INTO ACS
BLT LSTAC,LSTAC
IFN KUTSW,<SKIPGE E,CORSZ ;DO WE WANT CORE ADJUST
MOVE CORAC,JFCLAC ;NO, CLEAR COREUUO>
IFE LDAC,<MOVE LSTAC,W ;SET END CONDITION>
IFN PURESW,<
MOVSI V,LD ;DOES IT HAVE HISEG
JUMPG V,HINOGO ;NO,DON'T DO CORE UUO
MOVSI V,1 ;SET HISEG CORE NONE ZERO
JRST HIGO ;AND GO>
IFE PURESW,<
IFN NAMESW,<MOVE W,CURNAM ;GET PROGRAM NAME
SETNAM W, ;SET IT FOR VERSION WATCHING>
JRST 0>
LODACS: PHASE 0
BLT Q,(A) ;BLT CODE DOWN
IFN KUTSW,<CORAC:! CORE E, ;CUT BACK CORE
JFCLAC:! JFCL ;SHOULD NEVER HAVE AN ERROR SINCE REDUCING CORE>
SETZB 0,7 ;CLEAR ACCS OTHERWISE USER
SETZB 11,17 ;MIGHT BELIEVE GARBAGE THERE
LSTAC:! IFN LDAC,<JRST .JBBLT>
IFE LDAC,<EXIT>
DEPHASE
IFN RPGSW,<
NOSTAD: TTCALL 3,[ASCIZ /NO STARTING ADDRESS
/]
EXDLTD: TTCALL 3,[ASCIZ /?EXECUTION DELETED
/]
JRST LD5E3>
> ;END OF IFE L AT BEGINNING OF THIS PAGE
SUBTTL PRINT FINAL MESSAGE
; SET UP BLT AC'S, SETDDT, RELEAS
BLTSET: IFN RPGSW,<IFE K,<
JUMPE W,BLTST3 ;NO MESSAGE FROM CHAIN IN CCL@>>
IFN MANTIS,<TRNE N,MANTFL ;NO MESSAGES IF SPECIAL DEBUGGER
JRST NOMAX>
PUSHJ P,FCRLF ;A RETURN
MOVNI Q,6 ;SET CHARACTER COUNT TO 6
MOVEI D,77 ;CHARACTER MASK
BLTST1: TDNE W,D ;TEST FOR SIXBIT BLANK
JRST BLTST2 ;NO, SO PRINT THE NAME
LSH D,6 ;SHIFT MASK LEFT ONE CHAR
AOJL Q,BLTST1 ;INCR COUNTER & REPEAT
BLTST2: PUSHJ P,PWORD1 ;OUTPUT PROGRAM NAME
PUSHJ P,SPACE
BLTST3:
IFN FAILSW,<MOVSI Q,-20 ;FINISH UP LINK STUFF
FREND: HLRZ V,LINKTB+1(Q)
JUMPE V,NOEND
HRRZ A,LINKTB+1(Q)
IFN REENT,<CAMGE V,HVAL1
SKIPA X,LOWX
MOVE X,HIGHX>
IFN L,<CAML V,RINITL>
HRRM A,@X ;PUT END OF LINK CHAIN IN PROPER PLACE
NOEND: AOBJN Q,FREND
IFN REENT,<MOVE X,LOWX ;RESET THINGS>>
IFN KUTSW,<
SKIPGE C,CORSZ ;NEG MEANS DO NOT KUT BACK CORE
JRST NOCUT
JUMPE C,MINCUT ;0 IS KUT TO MIN. POSSIBLE
LSH C,12 ;GET AS A NUMBER OF WORDS
SUBI C,1
CAMG C,.JBREL ;DO WE NEED MORE THAN WE HAVE??
JRST TRYSML ;NO, SEE IF NUMBER REQUESTED IS TOO SMALL
MOVEI Q,0
CORE Q,
JFCL ;WE JUST WANT TO KNOW HOW MUCH
HRRZS Q
CAMGE Q,CORSZ
JRST CORERR
JRST NOCUT1 ;SET FOR DO NOT CHANGE SIZE
TRYSML: CAIG C,-1(R) ;IS DESIRED AMOUNT BIGGER THAN NEEDED
IFE TENEX,<MINCUT:>
MOVEI C,-1(R) ;GET MIN AMOUNT
IORI C,1777 ;CONVERT TO A 1K MULTIPLE
IFN DMNSW,< TRNN F,DMNFLG ;DID WE MOVE SYMBOLS??
SKIPN .JBDDT(X) ;IF NOT IS DDT THERE??
JRST .+2>
IFE DMNSW,<SKIPE .JBDDT(X) ;IF NO SYMBOL MOVING JUST CHECK DDT>
JRST NOCUT ;DO NOT CUT IF SYMBOLS AT TOP AND DDT
NOCUT1: MOVEM C,.JBREL(X) ;SAVE FOR CORE UUO
MOVEM C,CORSZ ;SAVE AWAY FOR LATER
JRST .+2
NOCUT: SETOM CORSZ ;SET FOR NO CUT BACK>
IFN RPGSW,<IFE K,<
JUMPE W,NOMAX ;NO MESSAGE IF CHAIN IN CCL@>>
IFN L,<HRRZ Q,.JBREL
SUB Q,OLDJR ;PROPER SIZE>
IFE L,<HRRZ Q,.JBREL(X)>
LSH Q,-12 ;GET CORE SIZE TO PRINT
ADDI Q,1
PUSHJ P,RCNUM
IFN REENT,<MOVE Q,HVAL
SUB Q,HVAL1
HRREI Q,-1(Q) ;SIZE IS ONE TOO BIG
CAIG Q,.JBHDA ;IS THERE ANY CODE LOADED THERE?
SETZB Q,HVAL ;NO , CLEAR ALL INDICATIONS OF IT
JUMPE Q,NOHY ;NO HIGH SEGMENT
MOVEI T,"+"-40 ;THERE IS A HISEG
PUSHJ P,TYPE
LSH Q,-12
ADDI Q,1
PUSHJ P,RCNUM
NOHY:>
MOVE W,[SIXBIT /K CORE/]
PUSHJ P,PWORD
IFE L,<
IFN RPGSW,<TLNN N,RPGF
JRST .+4 ;NOT IN CCL MODE SO GIVE ALL INFO
TLZ F,FCONSW ;ONLY PUT ON MAP IF IN CCL MODE
TLNN N,AUXSWI ;IS THERE AN AUX DEV?
JRST NOMESS ;NO, SO SKIP REST OF THIS STUFF>
MOVSI W,', ' ;SET DELIMITER CHARACTERS
MOVNI Q,2 ;SET COUNT TO 2
PUSHJ P,PWORD1 ;OUTPUT THEM
IFN DMNSW,<TRNN F,DMNFLG>
SKIPN .JBDDT(X)
SKIPA Q,.JBREL(X)
MOVEI Q,1(S) ;FIND THE AMOUNT OF SPACE LEFT OVER
SUB Q,.JBFF(X)
ADDI Q,1 ;ONE TWO SMALL
PUSHJ P,RCNUM
IFN REENT,<
SKIPN HVAL ;CREATING A HIGH SEGMENT?
JRST NOHIFR ;NO
MOVEI T,'+' ;YES, TYPE +
PUSHJ P,TYPE
HLRZ Q,.JBHRL(X) ;GET HISEG BREAK
SUBI Q,1 ;1 TOO HIGH (R=NEXT TO LOAD INTO)
ANDI Q,1777 ;CUT TO WORDS FREE
XORI Q,1777
PUSHJ P,RCNUM ;TYPE
NOHIFR:>
MOVE W,[SIXBIT / WORDS/]
PUSHJ P,PWORD
MOVE W,[SIXBIT / FREE/]
PUSHJ P,PWORD
PUSHJ P,CRLF
ERROR 0,</LOADER USED !/> ;GIVE EXPLANATION
MOVE Q,.JBREL
LSH Q,-12
ADDI Q,1
PUSHJ P,RCNUM ;PRINT MAX LOW CORE SIZE
IFN REENT,< SKIPE Q,.JBHRL ;GET SIZE OF HIGH SEGMENT
PUSHJ P,[MOVEI Q,400001(Q) ;CLEAR HIGH ORDER BIT
MOVEI T,"+"-40 ;PRINT A HIGH CORE PART
PUSHJ P,TYPE
LSH Q,-12
JRST RCNUM]>
MOVE W,[SIXBIT /K CORE/]
PUSHJ P,PWORD
NOMESS: TLO F,FCONSW ;FORCE PRINTING OF CRLF>
PUSHJ P,CRLF
IFE L,<
IFN REENT,<HLRZ A,.JBCOR(X) ;GET HIGHEST ACTUAL DATA
CAIL A,.JBDA ;SEE IF GREATER THAN JOBDAT
JRST NOMAX ;YES, SKIP MESSAGE
ERROR 0,</[NULL LOW SEGMENT]!/>
PUSHJ P,CRLF>
NOMAX:
IFE TENEX,<MOVE W,.JBDDT(X)
SETDDT W,
JUMPN W,DDTSET ;DON'T BOTHER IF DDT SET
HLRE Q,.JBSYM(X) ;GET LENGTH OF SYMBOL TABLE
MOVNS Q ;AS POSITIVE NUMBER
HRRZ W,.JBSYM(X) ;GET START
ADD W,Q ;ADDRESS OF HIGHEST LOCATION
HLRZ Q,.JBSA(X) ;HIGHEST LOCATION SAVED BY MONITOR
IFN MANTIS,<TRNN N,MANTFL ;DONT CHECK ADR IF SPECIAL DEBUGGER>
CAIG W,(Q) ;IN BOUNDS?
JRST DDTSET ;YES, ALL OK
IFN REENT,<TRNE F,SEENHI ;ANY HIGH SEGMENT STUFF?
CAMGE W,HVAL1 ;YES, IN HI-SEG THEN?
JRST .+2 ;NO
JRST DDTSET ;YES, ALL IS WELL>
SETZM .JBSYM(X) ;JOBSYM IS OUT OF BOUNDS
CAIA ;JOBUSY ALSO, SO CLEAR THEM>
DDTSET: SKIPLE .JBUSY(X) ;IF ITS NOT A POINTER
SETZM .JBUSY(X) ;DON'T KEEP ADDRESS
IFE TEN30,<HRLI Q,20(X) ;SET UP BLT FOR CODE
HRRI Q,20>
IFN TEN30,<HRLI Q,.JBDDT(X)
HRRI Q,.JBDDT>
>;END OF IFE L
HRRZ A,R
POPJ P, ;WE HAVE SET R UP BY CLEVER CODE IN SASYM
IFN KUTSW,<CORERR: TTCALL 3,[ASCIZ /?NOT ENOUGH CORE
/]
EXIT>
IFN TENEX,<
;SETUP TO CUT BACK CORE TO MINIMUM
;THIS IS MIN OF R AND TOP OF SYMTAB
MINCUT: HLRE C,.JBSYM(X)
MOVNS C
ADD C,.JBSYM(X)
HRRZS C
JRST TRYSML ;GO COMPARE WITH R
>
SUBTTL SET UP JOBDAT
SASYM: TLNN F,NSW
PUSHJ P,LIBF ;SEARCH LIBRARY IF REQUIRED
PUSHJ P,FSCN ;FORCE END OF SCAN
IFN ALGSW,<MOVE C,[RADIX50 44,%OWN]
MOVE W,%OWN ;GET VALUE
TRNE N,ALGFL ;IF ALGOL PROG LOADED
PUSHJ P,SYMPT ;DEFINE %OWN
IFN REENT,<MOVE X,LOWX ;MAKE SURE X IS CORRECT>>
IFN RPGSW,<HLRE A,S
MOVNS A
LSH A,-1
ADD A,.JBERR
HRRM A,.JBERR>
IFN SYMDSW,<PUSHJ P,READSYM ;READ BACK LOCAL SYMBOLS>
IFN SPCHN,<
SKIPE CHNACB ;TEST FOR SPECIAL CHAINING
TRNN N,CHNMAP ;TEST FOR ROOT SEGMENT PRINTED
JRST NOCHMP ;JUMP IF NO TO EITHER CONDITION
SETZM LINKNR ;CLEAR OVERLAY LINK NUMBER
MOVE A,BEGOV ;GET START OF OVERLAY POINT
IFN REENT,<ADDI A,(X) ;PLUS LOADER CORE BASE
HRRZS A ;CLEAR LEFT HALF OF REGISTER
HRRZ W,HILOW ;GET CURRENT SPOT IN LOW SEGMENT>
IFE REENT,<HRRZ W,R ;GET CURRENT SPOT IN LOW SEGMENT>
CAMN W,R ;TEST FOR ADDED MODULES
TRZ N,ENDMAP ;NO, THEN SUPRESS MAP AT END
NOCHMP: > ;END OF IFN SPCHN
TRNE N,ENDMAP ;WANT MAP AT END?
PUSHJ P,PRTMAP ;YES
TLNN N,AUXSWE ;TEST FOR MAP PRINTED YET
TLZ N,AUXSWI ; NO, THEN DON'T START NOW
TRNN N,ENDMAP ;DON'T PRINT UNDEFS TWICE
PUSHJ P,PMS ;PRINT UNDEFS
HRRZ A,H ;DO NOT CLOBBER H IF STILL INSERTING SYMBOLS
IFN MONLOD,<TLNN N,DISW ;SKIP IF LOADING TO DISK>
SUBI A,(X) ;HIGHEST LOC LOADED INCLUDES LOC STMTS
CAILE A,(R) ;CHECK AGAINST R
HRR R,A ;AND USE LARGER
IFN MONLOD,<TLNE N,DISW ;LOADING TO DISK?
MOVE X,XRES ;YES, GET RESIDENT OFFSET>
IFE L,< HRRZ A,STADDR ;GET STARTING ADDRESS
HRRM A,.JBSA(X) ;STORE STARTING ADDRESS
HRRZM R,.JBFF(X) ;AND CURRENT END OF PROG
HRLM R,.JBSA(X)>
IFN DMNSW,<MOVE C,[RADIX50 44,PAT..] ;MARK PATCH SPACE FOR RPG
MOVEI W,(R)
PUSHJ P,SYMPT
IFN REENT,<TRNE F,HISYM ;SHOULD SYMBOLS GO IN HISEG?
JRST BLTSYM ;YES>>
IFN DMNSW!LDAC,< ;ONLY ASSEMBLE IF EITHER SET
IFN MONLOD,<TLNE N,DISW ;LOADING TO DISK?
JRST SASYM1 ;YES, NO NEED TO EXPAND CORE>
IFE LDAC,< TRNN F,DMNFLG ;GET EXTRA SPACE IF SYMBOLS
JRST NODDT ;MOVED OR IF LOADING ACS>
IFE DMNSW,< MOVEI A,20 ;FOR LOADING ACS>
IFN DMNSW,< MOVE A,KORSP
IFN LDAC,< TRNN F,DMNFLG ;ONLY 20 IF SYMBOLS NOT MOVED
MOVEI A,20>>
ADDI A,(R) ;GET ACTUAL PLACE TO PUT END OF SPACE
ADDI A,(X)
CAIL A,(S) ;DO NOT OVERWRITE SYMBOLS
IFN EXPAND,<JRST [PUSHJ P,XPAND>
PUSHJ P,MORCOR
IFN EXPAND,< JRST .-1]>
IFN LDAC,<HRRM R,BOTACS ;SAVE BOTTOM OF WHERE WE PUT ACS
HRRZ A,R
ADDI A,(X)
HRL A,X ;SET UP BLT FROM (X) TO R(X)
MOVEI Q,17(A)
BLT A,(Q)>>
IFN DMNSW,<TRNN F,DMNFLG ;NOW THE CODE TO MOVE SYMBOLS
JRST NODDT
IFN MONLOD,<SASYM1:>
HRRZ A,R
ADD A,KORSP
MOVE W,A ;SAVE POINTER TO FINAL LOC OF UNDEFS
IFN MONLOD,<TLNE N,DISW ;LOADING TO DISK?
PUSHJ P,DISYM ;YES, GET BREAK ADDRESS INTO CORE>
ADDI A,(X)
HLLZ Q,S ;COMPUTE LENGTH OF SYMBOL TABLE
ADD Q,B
HLROS Q
MOVNS Q
ADDI Q,-1(A) ;GET PLACE TO STOP BLT
HRLI A,1(S) ;WHERE TO BLT FROM
SUBI W,1(S) ;GET AMOUNT TO CHANGE S AND B BY
BLT A,(Q) ;MOVE SYMBOL TABLE
ADD S,W
ADD B,W ;CORRECT S AND B FOR MOVE
HRRI R,1(Q) ;SET R TO POINT TO END OF SYMBOLS
IFN REENT,<HRRM R,HILOW ;SAVE THIS AS HIGHEST LOC IN LOW SEG TO SAVE>
IFN MONLOD,<TLNE N,DISW ;LOADING TO DISK?
MOVE X,XCUR ;GET CURRENT BUFFER OFFSET>
SUBI R,(X)
IFN MONLOD,<TLNE N,DISW ;LOADING TO DISK?
MOVE X,XRES ;SET UP OFFSET FOR RESIDENT PORTION>
HRRM R,.JBFF(X)
HRLM R,.JBSA(X) ;AND SAVE AWAY NEW JOBFF
IFE REENT,<HRRM R,.JBCOR(X) ;DON'T LOSE LOW SEGMENT DATA>
IFN LDAC,<SKIPA> ;SKIP THE ADD TO R
NODDT:>
IFN LDAC,<ADDI R,20> ;MAKE SURE R IS CORRECT FOR BLT
MOVE A,B
ADDI A,1 ;SET UP JOBSYM, JOBUSY
IFE L,<MOVEM A,.JBSYM(X)
IFN REENT,<TRNN A,(1B0) ;SYMBOL TABLE IN HIGH SEGMENT?
JRST NOHYSM ;NO
EXCH X,HIGHX ;RELOCATE TO HIGH SEG.
ADD X,HVAL1 ;ADD IN BASE OF HIGH SEGMENT
MOVEM A,.JBHSM(X) ;SINCE MAY NOT START AT 400000
SUB X,HVAL1 ;BACK AS IT WAS
EXCH X,HIGHX
NOHYSM: >>
IFN L,<MOVEM A,.JBSYM>
MOVE A,S
ADDI A,1
IFE L,<MOVEM A,.JBUSY(X)
MOVE A,HISTRT ;TAKE POSSIBLE REMAP INTO ACCOUNT
IFN MANTIS,<TRNE N,MANTFL ;SPECIAL DEBUGGER?
MOVE A,.JBREL ;YES, USE OUR SEGTOP>
MOVEM A,.JBREL(X) ;SET UP FOR IMEDIATE EXECUTION>
IFN L,<MOVEM A,.JBUSY>
IFN MONLOD,<TLNN N,DISW ;LOADING TO DSK?
JRST NOTDSK ;NO
MOVE A,.JBDDT(X) ;GET DDT STARTING ADDRESS
MOVEM A,.JBSDD(X) ;SO GET WILL RESTORE IT
MOVE A,.JB41(X) ;MAY AS WELL SET UP JOB41
MOVEM A,.JBS41(X) ;ALSO
NOTDSK:>
IFN REENT,<
SKIPE A,HILOW ;SET UP TOP LOC OF LOW CORE EXCLUDING BLOCKS
SUBI A,1(X) ;IF NON-ZERO THEN IT NEEDS RELOCATION
HRLM A,.JBCOR(X)
TRNN F,SEENHI
POPJ P,
HRRZ A,HVAL
HRRM A,.JBHRL(X)
SUB A,HVAL1
IFN DMNSW,<TRNE F,HISYM ;SYMBOLS IN HISEG?
ADDI A,1 ;YES, AT TOP OF CORE ALREADY
;BUT HVAL ONE TOO SMALL>
HRLM A,.JBHRL(X)>
POPJ P,
SUBTTL BLT SYMBOL TABLE INTO HIGH SEGMENT
IFN DMNSW&REENT,<
BLTSYM: MOVE Q,HVAL ;GET ORIGIN OF HISEG
CAMN Q,HVAL1 ;HAS IT CHANGED?
JRST NOBLT ;NO
HLLZ Q,S ;COMPUTE LENGTH OF SYMBOL TABLE
HLRS S ;PUT NEG COUNT IN BOTH HALVES
JUMPE S,.+2 ;SKIP IF S IS ZERO
HRLI S,-1(S) ;SUB 1 FROM LEFT TO FIX CARRY PROBLEM
ADD Q,B
HLROS Q
MOVNS Q
ADD Q,HVAL ;ADD LENGTH OF HISEG
SUB Q,HVAL1 ;BUT REMOVE ORIGIN
ADD Q,HISTRT ;START OF HISEG IN CORE
HRRZS Q ;CLEAR INDEX FROM Q
ADD Q,KORSP ;SAVE SPACE FOR SYMBOL PATCHES
CORE Q, ;EXPAND IF NEEDED
PUSHJ P,MORCOR
PUSH P,B ;SAVE B
SOJ B, ;REMOVE CARRY FROM ADD TO FOLLOW
MOVSS B ;SWAP SYMBOL POINTER
ADD B,.JBREL
HRRM B,(P) ;SAVE NEW B
MOVE Q,.JBREL
ADD B,S ;INCASE ANY UNDEFS.
BLT B,(Q) ;MOVE SYMBOLS
POP P,B ;GET NEW B
SUB B,HISTRT
ADD B,HVAL1
SOJ B, ;REMOVE CARRY
ADDI S,(B) ;SET UP .JBUSY
BLTSY1: MOVE Q,.JBREL
SUB Q,HISTRT
ADD Q,HVAL1
SUBI Q,1 ;ONE TOO HIGH
MOVEM Q,HVAL
JRST NODDT
NOBLT: HRRZ Q,H ;GET HIGHEST LOC LOADED
IORI Q,1777 ;MAKE INTO A K BOUND
MOVEI A,-.JBHDA(S) ;GET BOTTOM OF UNDF SYMBOLS
SUB A,KORSP ;DON'T FORGET PATCH SPACE
CAIG A,(Q) ;ARE THEY IN SAME K
IFN EXPAND,<JRST [PUSHJ P,XPAND>
PUSHJ P,MORCOR
IFN EXPAND,< JRST NOBLT]>
MOVEM Q,HISTRT ;SAVE AS START OF HIGH
MOVEI A,400000 ;HISEG ORIGIN
MOVEM A,HVAL1 ;SAVE AS ORIGIN
SUB S,HISTRT ;GET POSITION OF UNDF POINTER
ADDI S,377777 ;RELATIVE TO ORG
SUB B,HISTRT ;SAME FOR SYM POINTER
ADDI B,377777
SUBI Q,377777
MOVEM Q,HIGHX ;SO WE CAN SET HIGH JOB DATA AREA
TRO F,SEENHI ;SO JOBHRL WILL BE SET UP
JRST BLTSY1 ;AND USE COMMON CODE
>
IFN DMNSW!LDAC!MANTIS!SYMDSW,<
MORCOR: ERROR ,</MORE CORE NEEDED#/>
EXIT>
SUBTTL READ BACK LOCAL SYMBOLS
IFN SYMDSW,<
READSYM:
TRZN F,LSYMFL ;DID WE WRITE A SYMBOL FILE?
POPJ P, ;NO
RELEASE 2, ;CLOSE IT OUT
MOVE W,SYMNAM ;GET NAME
MOVEM W,DTIN
TRNE N,ENDMAP ;MAP STILL REQUIRED?
PUSHJ P,AUXINI ;YES, RE-INIT AUX DEV
MOVE W,SYMEXT ;SEE IF EXTENSION SPECIFIED
HRLZM W,DTIN1
TLZ F,ISW
TLO F,ESW
MOVSI W,'DSK'
MOVEM W,ILD1
PUSHJ P,ILD
PUSH P,S ;SAVE NUMBER OF UNDEFINED SYMBOLS FOR LATER
HLRE V,S ;GET COUNT
MOVMS V ;AND CONVERT TO POSITIVE
HRLI B,V ;PUT V IN INDEX FIELD
HRRZ S,HISTRT ;TOP OF CORE
SUB S,V ;MINUS SIZE
HRLI S,V ;V IN INDEX FIELD
;MOW MOVE FROM S TO B
MOVE W,@B
MOVEM W,@S
SOJG V,.-2 ;FOR ALL ITEMS
HRRM S,(P) ;S IS NOW BOTTOM OF UNDEFINED
POP P,S ;SO PUT COUNT BACK INTO S
HRRZ B,HISTRT ;POINT B TO TOP OF CORE FOR EXPAND
MOVE V,SYMCNT# ;GET NUMBER OF SYMBOLS
LSH V,1 ;2 WORDS PER SYMBOL
SUBI V,(S) ;BOTTOM OF SYMBOL TABLE
ADDI V,(H) ;-TOP OF CODE
JUMPL V,.+3
PUSHJ P,XPAND9
JRST MORCOR
MOVE V,SYMCNT ;GET COUNT AGAIN
LSH V,1
MOVNS V ;NEGATE
HRRZ C,S
ADD C,V ;TO
HRL C,S ;FROM
HLRE W,S ;LENGTH
MOVMS W ;POSITIVE
ADDI W,(C) ;END OF BLT
BLT C,(W) ;MOVE UNDEFS AGAIN
ADD S,V ;FIXUP POINTER
SETZM NAMPTR ;HAVE NOT SEEN A PROG YET
MOVE T,SYMCNT ;NUMBER OF SYMBOL PAIRS TO READ
READS1: PUSHJ P,WORDPR
MOVEM W,(B)
MOVEM C,-1(B)
SUB B,SE3
TLNN C,740000 ;NAME HAS NO CODE BITS SET
JRST READS2 ;YES, HANDLE IT
SOJG T,READS1 ;READ NEXT SYMBOL
JRST READS4 ;ALL DONE
READS2: MOVE W,NAMPTR ;POINT TO PREVIOUS NAME
HRRZM B,NAMPTR ;POINT TO THIS ONE
JUMPE W,READS3 ;FIRST TIME?
MOVE C,W ;GET COPY
SUBM B,W ;COMPUTE RELATIVE POSITION
HRLM W,2(C) ;STORE BACK
READS3: SOJG T,READS1
READS4: MOVEI T,'SYM'
CAMN T,SYMEXT ;IF EXT IS SYM
JRST READS5 ;DON'T DELETE FILE
SETZM DTIN
SETZM DTIN+3
RENAME 1,DTIN
JFCL
READS5: SETOM SYMEXT ;SIGNAL NOT TO INIT SYMBOL FILE AGAIN
POPJ P,
>
SUBTTL WRITE CHAIN FILES
IFE K,< ;DONT INCLUDE IN 1KLOAD
CHNC: SKIPA A,.JBCHN(X) ;CHAIN FROM BREAK OF FIRST BLOCK DATA
CHNR: HLR A,.JBCHN(X) ;CHAIN FROM BREAK OF FIRST F4 PROG
HRRZS A ;ONLY RIGHT HALF IS SIGNIFICANT
JUMPE A,LD7C ;DON'T CHAIN IF ZERO
TLZN N,AUXSWI!AUXSWE ;IS THERE AN AUX DEV?
JRST LD7D ;NO, DON'T CHAIN
PUSH P,A ;SAVE WHEREFROM TO CHAIN
JUMPE D,.+2 ;STARTING ADDR SPECIFIED?
HRRZM D,STADDR ;USE IT
CLOSE 2, ;INSURE END OF MAP FILE
PUSHJ P,SASYM ;DO LIB SEARCH, SETUP JOBSA, ETC.
IFN RPGSW,<TLNE N,RPGF ;IF IN CCL MODE
TDZA W,W ;NO MESSAGES>
MOVE W,[SIXBIT ?CHAIN?] ;FINAL MESSAGE
PUSHJ P,BLTSET ;SETUP BLT PNTR, SETDDT, RELEAS
POP P,A ;GET WHEREFROM
HRRZ W,R ;CALCULATE MIN IOWD NECESSARY
SKIPE .JBDDT(X) ;IF JOBDDT KEEP SYMBOLS
CAILE W,1(S)
JRST CHNLW1
HRRZ W,.JBREL ;NEED SYMBOLS AND THEY HAVE NOT MOVED DOWN
SUBI W,(X) ;BECAUSE WE WILL NOT HAVE BLITTED
SUBI B,-1(X) ;SYMBOL TABLE WILL COME OUT IN A
MOVEM B,.JBSYM(X) ;DIFFERENT PLACE
CHNLW1: MOVNS W
ADDI W,-7(A)
ADDI A,-7(X)
PUSH A,W ;SAVE LENGTH
HRLI W,-1(A)
MOVSM W,IOWDPP ;...
SETZM IOWDPP+1 ;JUST IN CASE
PUSH A,.JBCHN(X)
PUSH A,.JBSA(X) ;SETUP SIX WORD TABLE
PUSH A,.JBSYM(X) ;...
PUSH A,.JB41(X)
PUSH A,.JBDDT(X)
SETSTS 2,17 ;SET AUX DEV TO DUMP MODE
MOVSI W,'CHN' ;USE .CHN AS EXTENSION
MOVEM W,DTOUT1 ;...
PUSHJ P,IAD2 ;DO THE ENTER
JRST LD2 ;ENTER FAILURE
OUTPUT 2,IOWDPP ;WRITE THE CHAIN FILE
STATZ 2,IOBAD!IODEND
JRST LOSEBIG
CLOSE 2,
STATZ 2,IOBAD!IODEND
IFN RPGSW,<JRST LOSEBIG
TLNE N,RPGF ;IF IN CCL MODE
JRST CCLCHN ;LOAD NEXT LINK
EXIT>
LOSEBI: TTCALL 3,[ASCIZ /?DEVICE ERROR/]
EXIT>
SUBTTL SPECIAL CHAINB
IFN SPCHN,<
CHNBG: PUSHJ P,FSCN1A ;FORCE SCAN TO COMPLETION FOR CURRENT FILE
TLNN N,AUXSWI ;IS THERE AN AUX DEV??
JRST CHNBG1 ;NO, SKIP THIS CODE
PUSH P,W ;PRESERVE W
MOVE W,CHNOUT+1 ;GET AUX DEV
DEVCHR W, ;GET ITS CHARACTERISTICS
TLNN W,DSKBIT ;IS IT A REAL DSK?
TLZA N,AUXSWI!AUXSWE ;NO, RELEASE MAP DEVICE
TLNN N,AUXSWE!AUXSWI ;SHOULD AUX DEVICE BE RELEASED?
RELEAS 2, ;YES, RELEAS IT SO ENTER WILL NOT FAIL
POP P,W ;RESTORE W
CHNBG1: ;LABEL TO SKIP AUX DEV. CHECKING
IFN REENT,<TRO N,VFLG ;GIVE HIM REENTRANT FORSE UNLESS /-V SEEN>
HRLZI W,-1(R) ;CHNTAB-L = ADDRESS OF VECTOR TABLE
HRRI W,1 ;CHNTAB-R = NEXT DISK BLOCK TO RITE INTO
MOVEM W,CHNTAB
MOVE C,[RADIX50 4,OVTAB] ;DEFINE GLOBAL SYMBOL OVTAB
MOVEI W,(R) ;TO HAVE VALUE THE BEGINNING OF THE VECTOR TABLE
PUSHJ P,SYMPT
ADDI R,VECLEN ;RESERVE SPACE FOR VECTOR TABLE
MOVE C,[RADIX50 4,OVBEG] ;OVBEG IS BEGINNING OF OVERLAY AREA
MOVEI W,(R)
PUSHJ P,SYMPT
HRRZM R,BEGOV ;AND SAVE IN OVBEG
SETZM LINKNR ;SET CURRENT LINK # TO ZERO
TRZ N,CHNMAP ;SHOW ROOT NOT PRINTED
OPEN 4,CHNOUT ;OPEN FILE FOR CHAIN
JRST ILD5 ;CANT OPEN CHAIN FILE
SKIPE CHNENT ;TEST FOR DEFINED CHAIN-FILE NAME
JRST CHNBG2 ;YES, SKIP
PUSH P,W ;SAVE W
IFN NAMESW,<
SKIPN W,CURNAM ;GET CURRENT NAME & TEST FOR DEFINED >
MOVE W,['CHAIN '] ;SET NAME = 'CHAIN'
MOVEM W,CHNENT ;AND STORE AS FILE NAME
POP P,W ;RESTORE W
CHNBG2: ENTER 4,CHNENT ;ENTER CHAIN FILE
JRST CHNBG3 ;ERROR
HRRZ W,NAMPTR
SUB W,HISTRT ;KEEP N RIGHT HALF AS RELATIVE TO HISTRT
HRRZM W,CHNACN ;SAVE FOR RESTORING
MOVEM B,CHNACB ;ALSO B R IS SAVED IN BEGOV
TRNE N,ENDMAP ;TEST FOR DEFERED MAP REQUEST
PUSHJ P,PRTMAP ;YES, PRINT IT NOW
AOS LINKNR ;SET LINE NUMBER TO 1
POPJ P,
CHNBG3: ERROR ,</ERROR WRITING CHAIN@/>
POPJ P,
CHNENS: TLOA N,PPCSW ;THIS FLAG UNUSED AT THIS POINT
CHNEN: TLZ N,PPCSW ;ON TO NOT DELETE NEW SYMBOLS
SKIPN CHNACB ;WILL BE NON-ZERO IF WE SAW A /< (> TO KEEP MACRO HAPPY)
JRST LD7D ;ERROR MESSAGE
PUSHJ P,FSCN1A ;LOAD LIB (IF DESIRED) AND FORCE SCAN
TRNE N,ENDMAP ;TEST FOR DEFERED MAP REQUEST
PUSHJ P,PRTMAP ;YES, PRINT IT
AOS LINKNR ;INCR TO NEXT LINK NUMBER
SKIPL Q,S ;CHECK SYMBOL TABLE FOR MISSED UNDEFS
JRST NOER ;NONE THERE
MOVEI E,0 ;COUNT OF ERRORS
ONCK:
IFN FAILSW,<SKIPL V,1(Q) ;IF HIGH ORDER BIT IS ON
TLNN V,740000 ;OR IF ALL CODE BITS 0
JRST NXTCK ;THEN NOT TO BE CHECKED>
MOVE V,2(Q) ;GET FIXUP WORD
TLNE V,100000 ;BIT INDICATES SYMBOL TABLE FIXUP
JRST SMTBFX
IFN FAILSW,<TLNE V,40000 ;BIT INDICATES POLISH FIXUP
JRST POLCK>
TLZE V,740000 ;THESE BITS WOULD MEAN ADDITIVE
JRST [JSP A,CORCKL
JRST NXTCK] ;ONLY TRY FIRST LOCATION
CORCK: JSP A,CORCKL
HRRZ V,@X ;THE WAY TO LINK
CORCKL: IFN REENT,<CAMGE V,HVAL1>
CAMGE V,BEGOV
SKIPA ;NOT IN BAD RANGE
JRST ERCK ;BAD, GIVE ERROR
JUMPE V,NXTCK ;CHAIN HAS RUN OUT
IFN REENT,<CAMGE V,HVAL1 ;GET CORRECT LINK
SKIPA X,LOWX
MOVE X,HIGHX>
XCT (A) ;TELLS US WHAT TO DO
JRST CORCKL ;GO ON WITH NEXT LINK
SMTBFX: TLNE N,PPCSW ;IF NOT CUTTING BACK SYMBOL TABLE
JRST NXTCK ;THE ALL OK
ADD V,HISTRT ;GET PLACE TO POINT TO
HRRZS V
HLRE D,CHNACB ;OLD LENGTH OF TABLE (NEGATIVE)
HLRE T,B ;NEW LENGTH
SUB D,T ;-OLD LEN+NEW LEN
ADDI D,(B) ;OLD BOTTOM=NEW BOTTOM+NEW LEN-OLD LEN
CAIG V,(D) ;IS IT IN THE PART WE ARE KEEPING
JRST ERCK
JRST NXTCK ;YES
IFN FAILSW,<POLCK: HLRZ C,V ;FIND HEADER
PUSHJ P,SREQ
SKIPA
JRST LOAD4A ;SHOULD BE THERE
HRL C,2(A) ;NOW FIRST OPERATOR (STORE)
MOVSS C
PUSHJ P,SREQ
SKIPA
JRST LOAD4A
ANDI C,37 ;GET OPERATION
HRRZ V,2(A) ;DESTINATION
JRST @CKSMTB-15(C) ;DISPATCH
CKSMTB: EXP SMTBFX,SMTBFX,SMTBFX,CORCK,LCORCK,CORCK,NXTCK
LCORCK: JSP A,CORCKL
HLRZ V,@X>
ERCK: MOVE C,1(Q) ;GET SYMBOL NAME
PUSHJ P,FCRLF ;FORCE CRLF AND OUTPUT ON TTY
PUSHJ P,PRNAME ;PRINT IT
ADDI E,1 ;MARK ERROR
NXTCK: ADD Q,SE3 ;TRY ANOTHER
JUMPL Q,ONCK
IFN REENT,<PUSHJ P,RESTRX ;GET PROPER X BACK>
JUMPE E,NOER ;DID ANYTHING GO WRONG??
ERROR ,</UNDEFINED GLOBAL(S) IN LINK@/>
TRZE N,ENDMAP ;DELAYED MAP IN PIPELINE
PUSHJ P,PRTMAP ;YES, GO DO IT
JRST LD2 ;GIVE UP
NOER: TRZE N,ENDMAP ;DELAYED MAP IN PIPELINE
PUSHJ P,PRTMAP ;YES, GO DO IT
MOVE A,BEGOV ;GET START OF OVERLAY
ADDI A,(X) ;GET ACTUAL CURRENT LOCATION
IFN REENT,<HRRZ W,HILOW ;AND END OF OVERLAY+1
HRRZM A,HILOW ;RESET>
IFE REENT,<HRRZ W,R
ADDI W,(X) ;A BETTER GUESS>
SUBM A,W ;W=-LENGTH
SUBI A,1 ;SET TO BASE-1 (FOR IOWD)
HRL A,W ;GET COUNT
MOVEM A,IOWDPP
SETZM IOWDPP+1
HRR A,CHNTAB ;BLOCK WE ARE WRITING ON
HLRZ V,CHNTAB ;POINTER TO SEGMENT TABLE
ADDI V,1 ;NEXT LOCATION
HRLM V,CHNTAB ;REMEMBER IT
CAML V,BEGOV ;CHECK FOR OVERRUN
JRST [ERROR ,</?TOO MANY LINKS@/>
JRST LD2];GIVE UP
MOVEM A,@X ;PUT INTO TABLE
MOVN W,W ;GET POSITIVE LENGTH
MOVE C,CHNOUT+1 ;GET CHAIN DEV.
DEVCHR C, ;WHAT IS IT?
MOVEI A,DSKBLK ;ASSUME DSK
TRNE C,DTABIT ;BUT IF DTA
MOVEI A,DTABLK ;BLOCK IS 177
ADDI W,-1(A)
IDIV W,A ;GET NUMBER OF BLOCKS
ADDM W,CHNTAB ;AND UPDATE
TLZE N,PPCSW
JRST NOMVB ;DO NOT ADJUST SYMBOLS
HLRE W,CHNACB ;GET OLD LENGTH OF DEF SYMBOLS
HLRE C,B ;AND NEW LENGTH
SUB W,C ;-OLD LEN+NEW LEN
HRRZ C,B ;SAVE POINTER TO CURRENT S
ADD S,W
HRL W,W
ADD B,W ;UPDATE B (COUNT AND LOC)
JUMPGE S,UNLNKD ;JUST IN CASE NOTHING TO MOVE
HRRZ A,B ;PLACE TO PUT UNDEFS
UNLNK: MOVE W,(C)
MOVEM W,(A) ;TRANSFER
SUBI A,1
CAIE A,(S) ;HAVE WE MOVED LAST WORD??
SOJA C,UNLNK ;NO, CONTINUE
UNLNKD: HRRZ W,CHNACN ;GET SAVED N
ADD W,HISTRT
HRRZM W,NAMPTR ;AND RESET IT
NOMVB: HRR R,BEGOV ;PICK UP BASE OF AREA
SETSTS 4,16 ;SET DUMP MODE IN CASE OF INTERACTION WITH OTHER CHANNELS
OUTPUT 4,IOWDPP ;DUMP IT
STATZ 4,IOBAD!IODEND ;AND ERROR CHECK
JRST LOSEBI
HRRZ V,R ;GET AREA TO ZERO
MOVEI W,@X
CAIL W,1(S) ;MUST MAKE SURE SOME THERE
POPJ P, ;DONE
SETZM (W)
CAIL W,(S)
POPJ P,
HRLS W
ADDI W,1
BLT W,(S) ;ZERO WORLD
POPJ P,
>
SUBTTL EXPAND CORE
IFN EXPAND,<
XPAND: TLNE F,FULLSW ;IF CORE EXCEEDED
POPJ P, ;DON'T WASTE TIME ON CORE UUO
PUSH P,Q
HRRZ Q,.JBREL
ADDI Q,2000
XPAND1: PUSH P,H ;GET SOME REGISTERS TO USE
PUSH P,X
PUSH P,N
PUSH P,.JBREL ;SAVE PREVIOUS SIZE
CAMG Q,ALWCOR ;CHECK TO SEE IF RUNNING OVER
CORE Q,
JRST XPANDE
IFE K,< HRRZ H,MLTP ;GET LOWEST LOCATION
TLNN N,F4SW ;IS FORTRAN LOADING>
MOVEI H,1(S) ;NO, USE S
POP P,X ;LAST .JBREL
HRRZ Q,.JBREL;NEW JOBREL
SUBI Q,(X) ;GET DIFFERENCE
HRLI Q,X ;PUT X IN INDEX FIELD
XPAND2: MOVE N,(X)
MOVEM N,@Q
CAMLE X,H ;TEST FOR END
SOJA X,XPAND2
HRLI H,-1(Q)
TLC H,-1 ;MAKE IT NEGATIVE
SETZM (H) ;ZERO NEW CORE
AOBJN H,.-1
MOVEI H,(Q)
XPAND8: ADD S,H
ADD B,H
ADDM H,HISTRT ;UPDATE START OF HISEG
IFN REENT,<ADDM H,HIGHX ;AND STORE LOCATION
TLNE F,HIPROG
ADDM H,-1(P) ;X IS CURRENTLY IN THE STACK>
POP P,N
ADDM H,NAMPTR
IFE K,<
IFN MANTIS,<SKIPE MNTSYM ;DEBUGGER DATA PRESENT?
ADDM H,MNTSYM>
TLNN N,F4SW ;F4?
JRST XPAND3
ADDM H,PLTP
ADDM H,BITP
ADDM H,SDSTP
ADDM H,MLTP
TLNE N,SYDAT
ADDM H,V>
XPAND3: AOSA -3(P)
XPAND5: POP P,N
POP P,X
POP P,H
POP P,Q
POPJ P,
XPANDE: POP P,A ;CLEAR JOBREL OUT OF STACK
XPAND6: ERROR ,</MORE CORE NEEDED#/>
TLO F,FULLSW ;ONLY ONCE
JRST XPAND5
XPAND7: PUSHJ P,XPAND
JRST SFULLC
IFN MONLOD,<TLNE N,DISW ;LOADING TO DISK?
JRST POPJM3 ;YES, RETURN TO CALL-2>
JRST POPJM2
XPAND9: PUSH P,Q ;SAVE Q
HRRZ Q,.JBREL ;GET CORE SIZE
ADDI Q,(V) ;ADD XTRA NEEDED
JRST XPAND1 ;AND JOIN COMMON CODE
POPJM3: SOS (P) ;POPJ TO CALL-2
POPJM2: SOS (P) ;POPJ TO CALL-1
SOS (P) ;SAME AS POPJ TO
POPJ P, ;NORMAL POPJ MINUS TWO
>
SUBTTL SWITCH HANDLING
;ENTER SWITCH MODE
LD6A: CAIN T,57 ;WAS CHAR A SLASH?
TLO N,SLASH ;REMEBER THAT
LD6A2: TLO F,SSW ;ENTER SWITCH MODE
LD6A1: SETZB D,C ;ZERO TWO REGS FOR DECIMAL AND OCTAL
IFN SYMARG,<TRZ F,ARGFL ;CLEAR SPECIAL SYMBOL SWITCH >
JRST LD3 ;EAT A SWITCH
;ALPHABETIC CHARACTER, SWITCH MODE
LD6:
CAIL T,141 ;ACCEPT LOWER CASE SWITCHES
SUBI T,40
IFN SPCHN,<XCT LD6B-74(T) ;EXECUTE SWITCH FUNCTION>
IFE SPCHN,<XCT LD6B-101(T) ;EXECUTE SWITCH FUNCTION>
TLZE N,SLASH ;SWITCH MODE ENTERED W/ SLASH?
JRST LD6D ;LEAVE SWITCH MODE
JRST LD6A1 ;STAY IN SWITCH MODE
;DISPATCH TABLE FOR SWITCHES
; THE INSTRUCTION AT THE CHARACTER LOCATION IS EXECUTED
LD6B:
IFN SPCHN,<PUSHJ P,CHNBG ;LESS THAN - BEGINNING OF OVERLAY
PUSHJ P,CHNENS ;= - PUT OUT CHAIN RETAINING SYMBOLS
PUSHJ P,CHNEN ;GREATER THAN - END OF OVERLAY
JRST LD7B ;? - ERROR
JRST LD7B ;@ - ERROR>
PUSHJ P,ASWTCH ;A - LIST ALL GLOBALS
IFN DMNSW,<PUSHJ P,DMN2 ;B - BLOCKS DOWN SYMBOL TABLE >
IFE DMNSW,<JRST LD7B ;B - ERROR>
IFE K,< PUSHJ P,CHNC ;C - CHAIN, START W/ COMMON>
IFN K,< JRST LD7B ;C - ILLEGAL IN 1KLOAD>
PUSHJ P,LDDT ;D - DEBUG OPTION, LOAD DDT
TLO N,EXEQSW ;E - LOAD AND GO
PUSHJ P,LIBF0 ;F - LIBRARY SEARCH
PUSHJ P,LD5E ;G - GO INTO EXECUTION
IFN REENT,<PUSHJ P,HSET ;H - REENTRANT. PROGRAM>
IFE REENT,<JFCL ;JUST IGNORE /H>
PUSHJ P,ISWTCH ;I - IGNORE STARTING ADDRESSES
TLZ N,ISAFLG ;J - USE STARTING ADDRESSES
IFE KUTSW,<JRST LD7B ;K - ERROR>
IFN KUTSW,<MOVEM C,CORSZ ;K - SET DESIRED CORE SIZE>
PUSHJ P,LSWTCH ;L - ENTER LIBRARY SEARCH
PUSHJ P,PRMAP ;M - PRINT STORAGE MAP
TLZ F,LIBSW+SKIPSW ;N - LEAVE LIBRARY SEARCH
HRR R,D ;O - NEW PROGRAM ORIGIN
PUSHJ P,PSWTCH ;P - PREVENT AUTO. LIB. SEARCH
TLZ F,NSW ;Q - ALLOW AUTO. LIB. SEARCH
IFE K,< PUSHJ P,CHNR ;R - CHAIN, START W/ RESIDENT>
IFN K,< JRST LD7B ;R - ILLEGAL IN 1KLOAD>
PUSHJ P,SSWTCH ;S - LOAD WITH SYMBOLS
PUSHJ P,LDDTX ;T - LOAD AND GO TO DDT
PUSHJ P,PMSQ ;U - PRINT UNDEFINED LIST
IFN REENT,<PUSHJ P,VSWTCH ;V - LOAD REENTRANT LIB40>
IFE REENT,<JRST LD7B ;V - ERROR>
TLZ F,SYMSW+RMSMSW ;W - LOAD WITHOUT SYMBOLS
TLZ N,ALLFLG ;X - DO NOT LIST ALL GLOBALS
IFE TENEX,<TLO F,REWSW ;Y - REWIND BEFORE USE>
IFN TENEX,<PUSHJ P,NEWPAG ;Y - ORIGIN TO NEXT PAGE BOUNDARY>
IFE L,< JRST LDRSTR ;Z - RESTART LOADER>
IFN L,< JRST LD7B ;Z -- ILLEGAL IN LISP LOADER>
; PAIRED SWITCHES ( +,-)
ASWTCH: JUMPL D,.+2 ;SKIP IF /-A
TLOA N,ALLFLG ;LIST ALL GLOBALS
TLZ N,ALLFLG ;DON'T
POPJ P,
ISWTCH: JUMPL D,.+2 ;SKIP IF /-I
TLOA N,ISAFLG ;IGNORE STARTING ADDRESSES
TLZ N,ISAFLG ;DON'T
POPJ P,
LSWTCH: JUMPL D,.+2 ;SKIP IF /-L
TLOA F,LIBSW!SKIPSW ;ENTER LIBRARY SEARCH
TLZ F,LIBSW!SKIPSW ;DON'T
POPJ P,
PSWTCH: JUMPL D,.+2 ;SKIP IF /-P
TLOA F,NSW ;PREVENT AUTO. LIB SEARCH
TLZ F,NSW ;ALLOW
POPJ P,
SSWTCH: JUMPL D,.+2 ;SKIP IF /-S
TLOA F,SYMSW!RMSMSW ;LOAD WITH SYMBOLS
IFE MANTIS,<TLZ F,SYMSW!RMSMSW ;DON'T>
IFN MANTIS,<TLZA F,SYMSW!RMSMSW ;DON'T
TRZ N,SYMFOR ;SYMBOLS LOAD EXPLICITLY SPECIFIED>
POPJ P,
IFN REENT,<
VSWTCH: JUMPL D,.+2 ;SKIP IF /-V
MOVEI D,1 ;SET VSW = +1 FOR /V
MOVEM D,VSW ; = -1 FOR /-V
POPJ P,>
IFN TENEX,<
;Y SWITCH - START LOADING AT NEXT PAGE BOUNDARY
NEWPAG: JUMPL C,NEWLPG ;/-Y BUMPS LOWSEG LOC
ADDI R,777 ;/Y BUMPS HISEG LOC
ANDCMI R,777
POPJ P,0
NEWLPG: MOVE D,LOWR
ADDI D,777
ANDCMI D,777
MOVEM D,LOWR
POPJ P,0
>
IFN REENT,<
; H SWITCH --- EITHER /H OR /NH
HSET: JUMPE D,SETNUM ;/H ALWAYS LEGAL
CAIGE D,2 ;WANT TO CHANGE SEGMENTS
JRST SETSEG ;YES,GO DO IT
TRNN F,SEENHI ;STARTED TO LOAD YET?
JRST HCONT ;NO, CONTINUE.
IFE TENEX,<ERROR ,<?/H ILLEGAL AFTER FIRST HISEG FILE IS LOADED@?>>
IFN TENEX,<HRRZ C,HVAL
CAIGE D,0(C)
JRST HSET69
HRRM D,HIGHR ;MOVE UP HIGH BREAK
POPJ P,0
HSET69: ERROR ,<?/H ILLEGAL: ATTEMPT TO LOWER HISEG BREAK@?>
POPJ P,0>
>
IFE L,<
LDRSTR: ERROR 0,</LOADER RESTARTED@/>
JRST BEG ;START AGAIN (NO CCL)>
IFN REENT,<
HCONT: HRRZ C,D
IFE TENEX,<ANDCMI C,1777
CAIL C,400000>
CAIG C,(H)
JRST COROVL ;BEING SET LOWER THAN 400000 OR MORE THAN TOP OF LOW SEG
HRRZM C,HVAL1 ;WE HAVE REMOVED THE ODD BITS TO MAKE A 1K MULT
ADDI C,.JBHDA
CAILE C,(D) ;MAKE SURE OF ENOUGH ROOM
MOVE D,C
HRLI D,W ;SET UP W IN LEFT HALF
MOVEM D,HVAL
POPJ P, ;RETURN.
COROVL: ERROR ,</HISEG STARTING ADDRESS TOO LOW@/>
JRST LDRSTR
SETNUM: TRO F,NOHI ;SET NO-HIGH-SEG SWITCH.
POPJ P,>
;SWITCH MODE NUMERIC ARGUMENT
LD6C: LSH D,3 ;BUILD OCTAL NUMERIC ARGUMENT
ADDI D,-60(T)
IMULI C,^D10
ADDI C,-"0"(T) ;ACCUMULATE DEC AND OCTAL
JRST LD3
;EXIT FROM SWITCH MODE
LD6D: TLZ F,SSW ;CLEAR SWITCH MODE FLAG
TLNE F,FSW ;TEST FORCED SCAN FLAG
JRST LD2D ;SCAN FORCED, START NEW IDENT.
JRST LD3 ;SCAN NOT FORCED, USE PREV IDENT
;ILLEGAL CHARACTER, NORMAL MODE
LD7: IFN SYMARG,<
CAIN T,"#" ;DEFINING THIS SYMBOL
JRST DEFINE ;YES
TRNN F,ARGFL ;TREAT AS SPECIAL
JRST .+4 ;NO
CAIE T,"$"
CAIN T,"%"
JRST LD4 ;YES>
CAIN T,"Z"-100 ;TEST FOR ^Z
JRST LD5E1 ;TREAT AS ALTMODE FOR BATCH
ERROR 8,</CHAR.%/>
JRST LD2 ;TRY TO CONTINUE
;SYNTAX ERROR, NORMAL MODE
LD7A: ERROR 8,</SYNTAX%/>
JRST LD2
;ILLEGAL CHARACTER, SWITCH MODE
LD7B: CAIN T,"-" ;SPECIAL CHECK FOR -
JRST [SETOB C,D
JRST LD3]
CAIN T,"Z"-100 ;CHECK FOR /^Z
JRST LD5E1 ;SAME AS ^Z
ERROR 8,</SWITCH%/>
JRST LD2
;ATTEMPT TO CHAIN WITH SPECIFIED HALF OF JOBCHN = 0
IFE K,<
LD7C: ERROR ,<?UNCHAINABLE AS LOADED@?>
JRST LD2
;ATTEMP TO CHAIN WITHOUT SPECIFYING DEVICE
LD7D: ERROR ,<?NO CHAIN DEVICE@?>
JRST LD2>
IFN DMNSW,<
DMN2:
IFN REENT,<CAIN D,1 ;SPECIAL CASE
TROA F,HISYM ;YES ,BLT SYMBOLS INTO HISEG>
JUMPL D,.+2
TROA F,DMNFLG ;TURN ON /B
TRZ F,DMNFLG ;TURN OFF IF /-B
CAMLE D,KORSP
MOVEM D,KORSP
POPJ P, ;RETURN>
SUBTTL CHARACTER CLASSIFICATION TABLE DESCRIPTION:
; EACH CHARACTER HAS ASSOCIATED WITH IT A FOUR BIT BYTE
; PACKED IN THE CHARACTER CLASSIFICATION TABLE. THE CHARACTER
; CLASSIFICATION CODES ARE ORDERED IN SUCH A WAY AS TO GIVE
; DELIMITERS OF HIGHER PRECEDENCE LOWER CLASSIFICATION NUMBERS.
; CERTAIN CHARACTERS HAVE NO EFFECT ON THE COMMAND STRING, AND
; THEREFORE DO NOT EFFECT ORDERING OF DELIMITERS. FOUR CODES
; ARE RESERVED FOR ALTERNATE DISPATCHES WHILE THE SWITCH MODE IS
; IN EFFECT.
;CLASSIFICATION BYTE CODES:
; BYTE DISP CLASSIFICATION
; 00 - 00 ILLEGAL CHARACTER, SWITCH MODE
; 01 - 01 ALPHABETIC CHARACTER, SWITCH MODE
; 02 - 02 NUMERIC CHARACTER, SWITCH MODE
; 03 - 03 SWITCH MODE ESCAPE, SWITCH MODE
; 00 - 04 ILLEGAL CHARACTER, NORMAL MODE
; 01 - 05 ALPHABETIC CHARACTER, NORMAL MODE
; 02 - 06 NUMERIC CHARACTER, NORMAL MODE
; 03 - 07 SWITCH MODE ESCAPE, NORMAL MODE
; 04 - 10 IGNORED CHARACTER
; 05 - 11 ENTER SWITCH MODE CHARACTER
; 06 - 12 DEVICE IDENTIFIER DELIMITER
; 07 - 13 FILE EXTENSION DELIMITER
; 10 - 14 OUTPUT SPECIFICATION DELIMITER
; 11 - 15 INPUT SPECIFICATION DELIMITER
; 12 - 16 LINE TERMINATION
; 13 - 17 JOB TERMINATION
;BYTE POINTERS TO CHARACTER CLASSIFICATION TABLE
LD8: POINT 4,LD9(Q),3
POINT 4,LD9(Q),7
POINT 4,LD9(Q),11
POINT 4,LD9(Q),15
POINT 4,LD9(Q),19
POINT 4,LD9(Q),23
POINT 4,LD9(Q),27
POINT 4,LD9(Q),31
POINT 4,LD9(Q),35
;CHARACTER CLASSIFICATION TABLE
LD9: BYTE (4)4,0,0,0,0,0,0,0,0
BYTE (4)4,4,4,4,12,0,0,0,0
BYTE (4)0,0,0,0,0,0,0,0,0
BYTE (4)13,0,0,0,0,4,0,4,0
IFE SYMARG,< BYTE (4)0,0,0,0,5,3,0,0,11>
IFN SYMARG,< BYTE (4)0,0,14,0,5,3,0,0,11>
BYTE (4)0,7,5,2,2,2,2,2,2
IFE SPCHN,< BYTE (4)2,2,2,2,6,0,0,10,0>
IFN SPCHN,< BYTE (4)2,2,2,2,6,0,1,10,1>
IFE RPGSW,< BYTE (4)0,0,1,1,1,1,1,1,1>
IFN RPGSW,< BYTE (4) 0,10,1,1,1,1,1,1,1>
BYTE (4)1,1,1,1,1,1,1,1,1
BYTE (4)1,1,1,1,1,1,1,1,1
IFE PP,<BYTE (4)1,0,0,0,0,10,0,1,1>
IFN PP,<BYTE (4)1,10,0,10,0,10,0,1,1>
BYTE (4)1,1,1,1,1,1,1,1,1
BYTE (4)1,1,1,1,1,1,1,1,1
BYTE (4)1,1,1,1,1,1,0,0,13
BYTE (4)13,4
SUBTTL INITIALIZE LOADING OF A FILE
ILD: MOVEI W,BUF1 ;LOAD BUFFER ORIGIN
MOVEM W,.JBFF
TLOE F,ISW ;SKIP IF INIT REQUIRED
JRST ILD6 ;DONT DO INIT
ILD7: OPEN 1,OPEN3 ;KEEP IT PURE
JRST ILD5B
ILD6: TLZE F,REWSW ;SKIP IF NO REWIND
MTAPE 1,1 ;REWIND
ILD2: LOOKUP 1,DTIN ;LOOK UP FILE FROM DIRECTORY
JRST ILD3 ;FILE NOT IN DIRECTORY
IFE LNSSW,<
INBUF 1,BUFN ;SET UP BUFFERS>
IFN LNSSW,<INBUF 1,1
MOVEI W,BUF1
EXCH W,.JBFF
SUBI W,BUF1
IFE K,<MOVEI C,4*203+1>
IFN K,<MOVEI C,203+1>
IDIV C,W
INBUF 1,(C)>
TLO F,ASW ;SET LEFT ARROW ILLEGAL FLAG
TLZ F,ESW ;CLEAR EXTENSION FLAG
POPJ P,
; LOOKUP FAILURE
ILD3: TLOE F,ESW ;SKIP IF .REL WAS ASSUMED
JRST ILD4 ;FATAL LOOKUP FAILURE
SETZM DTIN1 ;ZERO FILE EXTENSION
JRST ILD2 ;TRY AGAIN WITH NULL EXTENSION
ILD4:
IFN CPUSW,< ;ALLOW LIB40I OR LIB40A TO FIND LIB40
MOVE W,DTIN ;GET NAME WE TRIED FOR
TRZN W,77 ;DELETE 6TH CHARACTER
JRST ILD4B ;TRIED ALL CASES IF NULL
IFN REENT,<CAME W,['IMP40 '] ;IMP40? REQUESTED?>
CAMN W,['LIB40 '] ;WAS IT SOME FLAVOUR OF LIB40?
JRST [MOVEM W,DTIN ;YES, SALT NEW NAME
PUSHJ P,LDDT2 ;SET .REL AGAIN
TLZ F,ESW
JRST ILD2]
ILD4B:>
IFE REENT,<IFE TEN30,< ;PDP-6 ONLY
MOVE W,[SIXBIT /LIB40/]
CAME W,DTIN ;WAS THIS A TRY FOR LIB40?
JRST ILD4A ;NO
TRZ W,(SIXBIT / 0/) ;YES
MOVEM W,DTIN ;TRY LIB4
PUSHJ P,LDDT2 ;USE .REL EXTENSION
TLZ F,ESW ;...
JRST ILD2 ;GO TRY AGAIN
ILD4A:>>
ILD9: ERROR ,</CANNOT FIND#/>
JRST LD2C
; DEVICE SELECTION ERROR
ILD5A: SKIPA W,LD5C1
ILD5B: MOVE W,ILD1
ILD5: PUSHJ P,PRQ ;START W/ ?
PUSHJ P,PWORD ;PRINT DEVICE NAME
ERROR 7,</UNAVAILABLE@/>
JRST LD2
SUBTTL LIBRARY SEARCH CONTROL AND LOADER CONTROL
LIBF0: IFN FORSW,<
JUMPE D,LIBF ;MAKE /F WORK SAME WAY
SOSGE D ;USER SUPPLIED VALUE?
MOVEI D,FORSW-1 ;NO, SUPPLY DEFAULT
MOVEM D,FORLIB ;STORE VALUE
POPJ P, ;RETURN HAVING SETUP FOR /0F>
LIBF: PUSHJ P,FSCN1 ;FORCE SCAN TO COMPLETION
PUSH P,ILD1 ;SAVE DEVICE NAME
IFN PP,<SETZM PPN ;CLEAR LOCAL PPN
SETZM PPPN ;AND GLOBAL PPN>
PUSHJ P,LIBF1 ;LOAD SYS:JOBDAT.REL
IFN SAILSW,<LIBAGN: PUSHJ P,SALOAD ;LOAD RELS AND SEARCH LIBS>
IFN REENT,<SKIPGE W,VSW ;WAS /-V SEEN
TRZ N,VFLG ;YES, DOES NOT WANT REENTRANT SYSTEM
CAILE W,0 ;SKIP IF HE DOESN'T KNOW OR CARE
TRO N,VFLG ;DEFINITELY WANTS REENTRANT SYSTEM
TRNE F,SEENHI!HISYM ;IF ANY HISEG LOADED NO RE-ENT OP SYSTEM
TRZ N,VFLG!MANTFL ;YES, SO FORCE /-V SWITCH
TRNN N,VFLG
JRST LIBF3
IFN ALGSW,<TRNE N,ALGFL ;SPECIAL ACTION IF LOADING ALGOL
PUSHJ P,SHARE>
IFN FORSW,<TRNN N,FORFL ;FORTRAN-10 ALWAYS WANTS FOROTS
TRNE N,F4FL ;IF F40
SKIPG FORLIB ;AND WANTING FORLIB
JRST LIBF3 ;NOT BOTH TRUE
MOVE C,[RADIX50 04,FOROT%] ;SYMBOL
MOVEI W,400000+.JBHDA ;VALUE
PUSHJ P,SYMPT ;YES, DEFINE SYMBOL>
LIBF3:>
IFN NELSW,<TRNN N,NELFL ;LOADING NELIAC
JRST .+4 ;NO
PUSHJ P,NELGO ;UNDEFINED SYMBOL NELGO
MOVE W,[SIXBIT /LIBNEL/]
PUSHJ P,LIBF2 ;LOAD NELIAC LIBRARY>
IFN ALGSW,<MOVE W,[SIXBIT /ALGLIB/]
IFE NAMESW,<TRNE N,ALGFL ;LOADING ALGOL?>
IFN NAMESW,<TRNN N,ALGFL ;ALGOL?
JRST LIBF5+1 ;NO
SKIPE CURNAM ;SEE MAIN PROG YET?
JRST LIBF5 ;YES
ERROR ,</ALGOL MAIN PROGRAM NOT LOADED!/>
EXIT
LIBF5:>
PUSHJ P,LIBF2 ;YES, LOAD LIBRARY>
IFN COBSW,<MOVE W,[SIXBIT /LIBOL/]
TRNE N,COBFL ;LOADING COBOL?
PUSHJ P,LIBF2 ;YES, SCAN LIBOL>
IFN REENT,<
IFE CPUSW,<MOVE W,[SIXBIT /IMP40/]>
IFN CPUSW,<MOVE W,['IMP40A'] ;ASSUME KA-10
TRNE F,KICPFL ;BUT IS IT?
HRRI W,'40I' ;NO, CHANGE TO IMP40A>
IFN FORSW,<SKIPG FORLIB ;IF LOADING FORLIB WE DON'T WANT IMP40>
TRNE N,COMFLS-F4FL ;ANY OTHER COMPILER ?
JRST LIBF4 ;YES, THEN WE DON'T WANT IMP40
TRNE N,VFLG ;WANT REENTRANT OP SYSTEM?
PUSHJ P,LIBF2 ;YES, TRY REENTRANT FORSE>
LIBF4:
IFE CPUSW,<MOVE W,[SIXBIT /LIB40/]>
IFN CPUSW,<MOVE W,['LIB40A']
TRNE F,KICPFL
HRRI W,'40I'>
IFN FORSW,<SKIPLE FORLIB ;FORSE OR FOROTS
MOVE W,['FORLIB'] ;YOU GET WHAT YOU ASK FOR>
IFN ALGSW,<TRNN N,ALGFL ;DON'T NEED LIB40 FOR ALGOL>
PUSHJ P,LIBF2 ;LOAD LIBRARY
IFN SAILSW,<MOVE W,LIBPNT ;SEE IF ANY MORE TO DO
CAME W,[XWD -RELLEN-1,LIBFLS-1]
JRST LIBAGN
MOVE W,PRGPNT ;IT COULD BE DANGEROUS TO LOAD PROGRAMS HERE
CAME W,[XWD -RELLEN-1,PRGFLS-1]
JRST LIBAGN ;MORE TO DO, TRY AGAIN>
POP P,ILD1 ;CALL TO LDDT1 WILL PUT IT IN OLDDEV
LIBF1: MOVE W,[SIXBIT /JOBDAT/] ;LOAD SYS:JOBDAT.REL
LIBF2: PUSHJ P,LDDT1
LIBGO: JUMPGE S,EOF2 ;JUMP IF NO UNDEFINED GLOBALS
TLO F,SLIBSW+SKIPSW ;ENABLE LIBRARY SEARCH
TLZ F,SYMSW ;DISABLE LOADING WITH SYMBOLS
JRST LDF ;INITIALIZE LOADING LIB4
IFN ALGSW!NELSW,<
IFN NELSW,<
NELGO: SKIPA C,[RADIX50 60,%NELGO]>
SHARE: MOVE C,[RADIX50 60,%SHARE]
MOVEI W,0
JRST SYMPT ;DEFINE IT >
; LIB CONTROLS THE LIBRARY SEARCH OF ONE FILE
LIB: JUMPGE S,EOF1 ;JUMP IF NO UNDEFINED GLOBALS
TLO F,SKIPSW ;SET SKIPSW TO IGNORE MODE
IFN DIDAL,<TRNE F,XFLG ;INDEX IN CORE?
JRST INDEX1 ;YES>
JRST LOAD ;CONTINUE LIB. SEARCH
LIB1: CAIE A,4 ;TEST FOR ENTRY BLOCK
JRST LIB29 ;NOT AN ENTRY BLOCK, IGNORE IT
LIB2: PUSHJ P,RWORD ;READ ONE DATA WORD
MOVE C,W
TLO C,040000 ;SET CODE BITS FOR SEARCH
PUSHJ P,SREQ
TLZA F,SKIPSW ;REQUEST MATCHES ENTRY, LOAD
JRST LIB2 ;NOT FOUND
LIB3: PUSHJ P,RWORD ;READ AND IGNORE ONE DATA WORD
JRST LIB3 ;LOOP TO IGNORE INPUT
LIB29: CAIN A,14 ;INDEX BLOCK?
JRST INDEX0 ;YES
LIB30: HRRZ C,W ;GET WORD COUNT
JUMPE C,LOAD1 ;IF NUL BLOCK RETURN
CAILE C,^D18 ;ONLY ONE SUB-BLOCK
JRST LIB3 ;NO,SO USE OLD SLOW METHOD
ADDI C,1 ;ONE FOR RELOCATION WORD
LIB31: CAML C,BUFR2 ;DOES BLOCK OVERLAP BUFFERS?
SOJA C,LIB32 ;YES,ALLOW FOR INITIAL ILDB
ADDM C,BUFR1 ;ADD TO BYTE POINTER
MOVNS C ;NEGATE
ADDM C,BUFR2 ;TO SUBTRACT C FROM WORD COUNT
JRST LOAD1 ;GET NEXT BLOCK
LIB32: SUB C,BUFR2 ;ACCOUNT FOR REST OF THIS BUFFER
PUSHJ P,WORD+1 ;GET ANOTHER BUFFERFUL
JRST LIB31 ;TRY AGAIN
IFN SAILSW,<
COMMENT * BLOCK TYPE 16 AND 17 USED TO SPECIFY PROGRAMS AND
LIBRARIES WHICH MUST BE LOADED (SEARCHED) IF THE PROGRAM
IN WHICH THE BLOCK APPEARS IS LOADED. IT IS NOW TIME TO
LOAD AND SEARCH THESE FILES. IF ANY MAKE REQUESTS, THEY ARE ADDED
TO THE END. WE WILL COME BACK AND LOOK AGAIN IN CASE A
LIBRARY PROGRAM LOAD A REL PROGRAM. ORIGINAL CODE BY DCS*
SALOAD: MOVE T,[XWD -RELLEN-1,PRGFLS-1] ;TO RESET WITH AT END
MOVEI D,PRGPNT ;OINTER TO UPPER LIMIT
PUSHJ P,PRGPRG ;LOAD THEM IF ANY
;NOW FOR LIBRARY SEARCH
MOVE T,[XWD -RELLEN-1,LIBFLS-1]
MOVEI D,LIBPNT
PRGPRG: MOVEM D,LODLIM# ;SAVE POINTER TO LIMIT
MOVEM T,LODSTP# ;START FOR RESETTING
PRGBAK: MOVEM T,LODPNT# ;AND START
CAMN T,@LODLIM ;GOTTEN TO END YET?
JRST PRGDON ;YES, DUMP IT
SKIPN W,PRGDEV(T) ;IS DEVICE SPECIFIED?
MOVSI W,(SIXBIT /DSK/) ;NO, DSK
MOVEM W,ILD1 ;WHERE WE INIT FROM
MOVSI W,(SIXBIT /REL/) ;EXTENSION
MOVEM W,DTIN1
MOVE W,PRGFIL(T)
MOVEM W,DTIN ;FILE NAME
MOVE W,PRGPPN(T) ;THE PROJECT PROG
MOVEM W,DTIN+3
PUSH P,JRPRG ;A RETURN ADDRESS
TLZ F,ISW ;FORCE NEW INIT
HRRZ T,LODLIM
CAIN T,LIBPNT ;WHICH ONE
JRST LIBGO
JRST LDF
PRGRET: MOVE T,LODPNT ;RETURNS HERE, GET NEXT ONE
AOBJN T,PRGBAK
PRGDON: MOVE T,LODSTP ;RESTE POINTER IN CASE MORE ON OTHER LIBS
MOVEM T,@LODLIM
JRPRG: POPJ P,PRGRET ;PUSHED TO GET A RETURN ADDRESS
PRGFIL==1 ;REL INDEX FOR FILE NAMES
PRGPPN==RELLEN+1 ;AND FOR PPNS
PRGDEV==2*RELLEN+1 ;AND FOR DEVICES
> ;END OF IFN SAILSW
SUBTTL LDDT LOADS <SYS:DDT.REL> AND SETS SYMSW
LDDTX: TLO N,DDSW+EXEQSW ;T - LOAD AND GO TO DDT
LDDT: ;/D - LOAD DDT
IFN TENEX,<PUSH P,1
PUSH P,3
MOVEM 2,3 ; X = 2
MOVSI 1,100001
HRROI 2,[ASCIZ /<SUBSYS>UDDT.SAV/]
GTJFN
JRST LDDTQ
PUSH P,1 ;DDT JFN
MOVEI 1,400000
GEVEC ;LOADER'S EV
POP P,1
PUSH P,2
HRLI 1,400000 ;THIS FORK
GET
MOVEI 1,400000
GEVEC ;DDT'S EV
MOVEM 2,.JBDDT(3) ;3 HAS X IN IT
POP P,2
SEVEC ;RESTORE LOADER'S EVEC
TLO F,SYMSW!RMSMSW ;DO /S PROBABLY ON BY DEFAULT
MOVE 2,3
POP P,3
POP P,1
JRST DMN2
LDDTQ: TTCALL 3,[ASCIZ /
DDT10X NOT AVAILABLE. USING DEC DDT./]
MOVE 2,3
POP P,3
POP P,1>
IFN DMNSW,< PUSH P,D ;SAVE INCASE /NNND >
PUSHJ P,FSCN1 ;FORCE SCAN TO COMPLETION
MOVSI W,'DDT' ;FILE IDENTIFIER <DDT>
TLZ F,SYMSW!RMSMSW ;DON'T LOAD DDT WITH LOCAL SYMBOLS
PUSHJ P,LDDT1
PUSHJ P,LDF ;LOAD <SYS:DDT.REL>
TLO F,SYMSW!RMSMSW ;ENABLE LOADING WITH SYMBOLS
IFN DMNSW,< POP P,D ;RESTORE D
JRST DMN2 ;MOVE SYMBOL TABLE >
IFE DMNSW,< POPJ P,>
LDDT1: MOVEM W,DTIN ;STORE FILE IDENTIFIER
MOVE W,ILD1 ;SAVE OLD DEV
MOVEM W,OLDDEV
IFN PP,<SETZM PPPN ;CLEAR PERM PPN>
MOVSI W,'SYS' ;DEVICE IDENTIFIER <SYS>
MOVEM W,ILD1 ;STORE DEVICE IDENTIFIER
TLZ F,ISW+LIBSW+SKIPSW+REWSW ;CLEAR OLD FLAGS
LDDT2: MOVSI W,'REL' ;EXTENSION IDENTIFIER <.REL>
LDDT3: MOVEM W,DTIN1 ;STORE EXTENSION IDENTIFIER
LDDT4: IFN PP,<
PUSH P,W ;SAVE W
SKIPN W,PPN ;GET TEMP PPN
MOVE W,PPPN ;TRY PERM
MOVEM W,DTIN+3 ;SET PPN
POP P,W ;RESTORE W>
POPJ P,
SUBTTL EOF TERMINATES LOADING OF A FILE
EOF: MOVE P,PDSAV ;RESTORE PUSHDOWN POINTER
EOF1: TLZ F,SLIBSW!SKIPSW ;CLEAR ONE FILE LIB. SEARCH FLAG
IFN DIDAL,<TRZ F,XFLG!LSTLOD ;CLEAR DIDAL FLAGS
IFN SYMDSW,<TRNE F,LSYMFL ;USING AUX BUF FOR LOCAL SYMBOLS?
JRST EOF2 ;YES>
MOVSI W,(1B0) ;FOOL MONITOR THAT WE HAVE NOT USED THIS BUFFER
HLLM W,ABUF ;THEN NEXT OUTPUT WILL BE A "DUMMY OUTPUT"
MOVSI W,700 ;RESET BYTE POINTER TO ASCII
MOVEM W,ABUF1 ;AND HOPE DUMMY OUTPUT WILL CLEAR DIDAL STUFF
SETZM ABUF2 ;ZERO BYTE COUNT TO FORCE DUMMY OUTPUT>
EOF2: TLNE F,RMSMSW ;IF REMEMBER LOADING WITH SYMBOLS IS ON
TLO F,SYMSW ;THEN RESTORE SYMBOL LOADING STATE
POPJ P,
; FORCE SCAN TO COMPLETION, LOAD IF NECESSARY
FSCN: PUSHJ P,FSCN1 ;FORCED LOAD BEFORE TEST
TLNN F,FULLSW ;TEST FOR OVERLAP
POPJ P, ;NO OVERLAP, RETURN
MOVE W,H ;FETCH CORE SIZE REQUIRED
IFN MONLOD,<TLNE N,DISW ;LOADING TO DISK?
MOVE W,DIEND ;YES, GET END OF BUFFER+1>
SUBI W,1(S) ; COMPUT DEFICIENCY
JUMPL W,EOF2 ;JUMP IF NO OVERLAP
PUSHJ P,PRQ ;START WITH ?
PUSHJ P,PRNUM0 ;INFORM USER
ERROR 7,</WORDS OF OVERLAP#/>
JRST LD2 ;ERROR RETURN
IFN SPCHN,<FSCN1A: TLNN F,NSW
PUSHJ P,LIBF>
FSCN1: TLON F,FSW ;SKIP IF NOT FIRST CALL TO FSCN
FSCN2: TLNN F,CSW+DSW+ESW ;TEST SCAN FOR COMPLETION
POPJ P,
PUSHJ P,LD5B1 ;STORE FILE OR EXTENSION IDENT.
; LOADER CONTROL, NORMAL MODE
LDF: PUSHJ P,ILD ;INITIALIZE LOADING
TLNE F,LIBSW ;IN LIBRARY SEARCH MODE?
JRST LIB ;CHECK IF NO UNDFS.
SUBTTL LOAD SUBROUTINE
LOAD: MOVEM P,PDSAV ;SAVE PUSHDOWN POINTER
IFN WFWSW,<SETZM VARLNG ;LENGTH OF VARIABLE AREA-ADDED TO RELOC>
IFN ALGSW,<SETZM OWNLNG ;LENGTH OF OWN AREA-ADDED TO RELOC>
IFN FAILSW,<SETZM LFTHSW ;RESET LOAD LEFT HALF FIXUP SW>
IFN COBSW,<SETZM LOD37. ;CLEAR FLAG>
IFN MANTIS,<TRZE N,SYMFOR ;ZERO LOAD SYMBOLS IF IT WAS FORCED
TLZ F,SYMSW>
IFN TENEX,<SETZM NLSTGL ;ALLOW UNDEF. GLOBALS TO LIST>
LOAD1: MOVE P,PDSAV ;RESTORE PUSHDOWN POINTER
LOAD1A: PUSHJ P,WORD ;INPUT BLOCK HEADER WORD
MOVNI E,400000(W) ;WORD COUNT - FROM RH OF HEADER
HLRZ A,W ;BLOCK TYPE - FROM LH OF HEADER
IFN B11SW,<SKIPN POLSW ;ERROR IF STILL DOING POLISH>
CAIL A,DISPL*2 ;TEST BLOCK TYPE NUMBER
JRST LOAD4 ;ERROR, ILLEGAL BLOCK TYPE
TLNE F,SKIPSW ;BLOCK OK - TEST LOAD STATUS
JRST LIB1 ;RETURN TO LIB. SEARCH CONTROL
HRRZ T,LOAD2(A) ;LOAD RH DISPATCH ENTRY
CAIL A,DISPL ;SKIP IF CORRECT
HLRZ T,LOAD2-DISPL(A);LOAD LH DISPATCH ENTRY
TLNE F,FULLSW ;TEST CORE OVERLAP INDICATOR
SOJG A,HIGH0 ;IGNORE BLOCK IF NOT TYPE 1
JRST @T ;DISPATCH TO BLOCK SUBROUTINE
;DISPATCH TABLE - BLOCK TYPES
IFE B11SW,<POLFIX==LOAD4A>
IFE FAILSW,<LINK==LOAD4A>
IFE WFWSW,<LVARB==LOAD4A>
IFE ALGSW,<ALGBLK==LOAD4A>
IFE SAILSW,<LDPRG==LOAD4A
LDLIB==LOAD4A>
IFE COBSW,<COBSYM==LOAD4A>
LOAD2: COMML,,LIB30 ;20,,0
SPDATA,,PROG ;21,,1
LOAD4A,,SYM ;22,,2
LOAD4A,,HISEG ;23,,3
LOAD4A,,LIB30 ;24,,4
LOAD4A,,HIGH ;25,,5
LOAD4A,,NAME ;26,,6
LOAD4A,,START ;27,,7
LOAD4A,,LOCD ;30,,10
LOAD4A,,POLFIX ;31,,11
LOAD4A,,LINK ;32,,12
LOAD4A,,LVARB ;33,,13
LOAD4A,,INDEX ;34,,14
LOAD4A,,ALGBLK ;35,,15
LOAD4A,,LDPRG ;36,,16
COBSYM,,LDLIB ;37,,17
DISPL==.-LOAD2
;ERROR EXIT FOR BAD HEADER WORDS
LOAD4:
IFN TENEX,<CAIN A,100 ;ASSIGN BLOCK?
JRST ASGSYM ;YES>
IFE K,<CAIN A,400 ;FORTRAN FOUR BLOCK
IFN MANTIS,< JRST F4LD
CAIE A,401 ;MANTIS DEBUGGER DATA PRESENT IN FORTRAN FILE
JRST LOAD4A ;NO
TLON F,SYMSW ;YES, FORCE SYMSW SET
TRO N,SYMFOR>
JRST F4LD>
LOAD4A: MOVE W,A ;GET BLOCK TYPE
ERROR ,</ILL. FORMAT BLOCK TYPE !/>
PUSHJ P,PRNUM ;PRINT BLOCK TYPE
JRST ILC1 ;PRINT SUBROUTINE NAME
SUBTTL LOAD PROGRAMS AND DATA (BLOCK TYPE 1)
;(BLOCK TYPE 37) TREAT AS BLOCK TYPE 1, BUT ONLY LOAD
;IF IN LOCAL SYMBOLS MODE
IFN COBSW,<
COBSYM: TLNN F,SYMSW ;LOCAL SYMBOLS?
JRST LIB30 ;NO, SKIP OVER THIS BLOCK
MOVEI V,-1(W) ;GET BLOCK LENGTH
ADDM V,LOD37. ;COUNT EXTRA CODE>
PROG: MOVEI V,-1(W) ;LOAD BLOCK LENGTH
PUSHJ P,RWORD ;READ BLOCK ORIGIN
SKIPGE W
PUSHJ P,PROGS ;SYMBOLIC IF 36 BITS
ADD V,W ;COMPUTE NEW PROG. BREAK
IFN REENT,<TLNN F,HIPROG
JRST PROGLW ;NOT HIGH SEGMENT
PROG3:
IFN TENEX,<MOVE X,HIGHX>
CAMGE W,HVAL1 ;CHECK TO SEE IF IN TOP SEG
JRST LOWCOR
MOVE T,.JBREL ;CHECK FOR OVERFLOW ON HIGH
CAIL T,@X
JRST PROG2
PUSHJ P,HIEXP
JRST FULLC
JRST PROG3>
IFN MONLOD,<TLNN N,DISW ;LOADING TO DISK?
JRST PROGLW ;NO, GO CHECK NEW BREAK
CAMG H,V ;NEW BREAK?
MOVE H,V ;YES, UPDATE
JRST PROG2 ;NO NEED TO CHECK FOR ROOM>
IFN REENT,<
LOWCOR: SUB V,HIGHX ;RELOC FOR PROPER
ADD V,LOWX ;LOADING OF LOW SEQMENT
SUB W,HIGHX
ADD W,LOWX>
PROGLW: MOVEI T,@X
CAMG H,T ;COMPARE WITH PREV. PROG. BREAK
MOVE H,T
TLNE F,FULLSW
JRST FULLC ;NO ERROR MESSAGE
IFN REENT,<CAML H,HVAL1
JRST COROVL ;WE HAVE OVERFLOWED THE LOW SEGMENT
CAMLE T,HILOW
MOVEM T,HILOW ;HIGHEST LOW CODE LOADED INTO>
CAILE H,1(S) ; SKIP IF SUFFICIENT CORE AVAILABLE
IFN EXPAND,<JRST [PUSHJ P,XPAND>
JRST FULLC
IFN REENT,< TLNE F,HIPROG
SUBI W,2000 ;HISEG LOADING LOW SEG>
IFN EXPAND,< JRST .-1]>
PROG2: MOVE V,W
PROG1: PUSHJ P,RWORD ;READ DATA WORD
IFN TEN30,<CAIN V,41 ;CHANGE FOR 10/30 JOBDAT
MOVEI V,.JB41 ;JOB41 IS DIFFERENT
CAIN V,74 ;SO IS JOBDAT
MOVEI V,.JBDDT>
IFN L,<CAML V,RINITL ;CHECK FOR BAD STORE>
IFN MONLOD,<PUSHJ P,DICHK ;MAKE SURE ADDRESS IS IN CORE>
MOVEM W,@X ;STORE DATA WORD IN PROG. AT LLC
IFN MONLOD,<TLO N,WOSW ;SET SWITCH TO WRITE OUT BUFFER>
AOJA V,PROG1 ;ADD ONE TO LOADER LOC. COUNTER
;HERE TO FIND SYMBOLIC ORIGIN
;W CONTAINS RADIX50 60,ORIGIN
;NEXT WORD CONTAINS OFFSET
;NOTE SYMBOL MUST BE GLOBAL AND DEFINED
PROGS: MOVE C,W ;PUT SYMBOL IN CORRECT SEARCH AC
TLC C,640000 ;PERMUTE FROM 60 TO 04
PUSHJ P,SDEF ;SEE IF DEFINED
SKIPA C,2(A) ;YES, GET VALUE
JRST PROGER ;NO, GIVE WARNING
HRRZ C,C ;CLEAR LEFT HALF IN CASE COMMON
PUSHJ P,RWORD ;GET NEXT WORD
ADD W,C ;FORM ORIGIN
SOJA V,CPOPJ ;BUT NOT SO MANY DATA WORDS
PROGER: MOVEM C,(P) ;REMOVE RETURN, SAVE C
ERROR ,</VALUE NOT DEFINED FOR SYMBOLIC RELOCATION COUNTER !/>
POP P,C
PUSHJ P,PRNAME
JRST LIB3 ;IGNORE THIS BLOCK
SUBTTL LOAD SYMBOLS (BLOCK TYPE 2)
SYM: PUSHJ P,PRWORD ;READ TWO DATA WORDS
PUSHJ P,SYMPT; PUT INTO TABLE
IFN REENT,<PUSHJ P,RESTRX>
JRST SYM
SYMPT: TLNE C,200000 ;GLOBAL REQUEST? WFW
JUMPL C,SYM3 ;CHECK FOR 60 NOT JUST HIGH BIT WFW
TLNN C,40000
JRST SYM1A ;LOCAL SYMBOL
TLNE C,100000
JRST SYM1B
SYMPTQ: PUSHJ P,SREQ ;GLOBAL DEF., SEARCH FOR REQUEST
JRST SYM2 ;REQUEST MATCHES
PUSHJ P,SDEF ;SEARCH FOR MULTIPLE DEFINITIONS
JRST SYM1 ;MULTIPLY DEFINED GLOBAL
JRST SYM1B
; PROCESS MULTIPLY DEFINED GLOBAL
SYM1: CAMN W,2(A) ;COMPARE NEW AND OLD VALUE
POPJ P,;
AOS MDG ;COUNT MULTIPLY DEFINED GLOBALS
PUSHJ P,PRQ ;START W/ ?
PUSHJ P,PRNAM ;PRINT SYMBOL AND VALUE
IFN RPGSW,<MOVE W,.JBERR ;RECORD THIS AS AN ERROR
ADDI W,1
HRRM W,.JBERR>
MOVE W,2(A) ;LOAD OLD VALUE
PUSHJ P,PRNUM ;PRINT OLD VALUE
ERROR 7,</MUL. DEF. GLOBAL IN PROG. !/>
MOVE C,SBRNAM ;GET PROGRAM NAME
PUSHJ P,PRNAME ;PRINT R-50 NAME
ERROR 0,</#/>
POPJ P, ;IGNORE MUL. DEF. GLOBAL SYM
; LOCAL SYMBOL
SYM1A: TLNN F,SYMSW ;SKIP IF LOAD LOCALS SWITCH ON
POPJ P,; IGNORE LOCAL SYMBOLS
IFN SYMDSW,<
IFE MONLOD,<TRNE F,LSYMFL ;ONLY PUT SYMBOLS ON DSK IF EXT SYM>
IFN MONLOD,<TLNN N,DISW ;BUT NOT IF LOADING TO DISK>
JRST SYM1X ;STORE SYMBOL ON DSK>
SYM1B: IFN MONLOD,<TLNE N,DISW ;LOADING TO DISK?
PUSHJ P,SIZCHK ;YES, CHECK FOR OVERLAP>
CAIL H,(S) ;STORE DEFINED SYMBOL
IFN EXPAND,< PUSHJ P,XPAND7>
IFE EXPAND,< JRST SFULLC>
SYM1C: IFE K,<
TLNE N,F4SW; FORTRAN FOUR REQUIRES A BLT
PUSHJ P,MVDWN; OF THE TABLES>
SYM1D: MOVEI A,-2(S) ;LOAD A TO SAVE INST. AT SYM2
SUBI S,2 ;UPDATE UNDEFINED POINTER
POP B,2(A) ;MOVE UNDEFINED VALUE POINTER
POP B,1(A) ;MOVE UNDEFINED SYMBOL
MOVEM W,2(B) ;STORE VALUE
MOVEM C,1(B) ;STORE SYMBOL
IFE SYMDSW,<POPJ P,>
IFN SYMDSW,<
SYM1X:
IFN MONLOD,<SKIPL SYMEXT ;BEEN SETUP ONCE?
TLNE N,DISW ;OR, IF OUTPUTTING TO DSK
POPJ P, ;DON'T BOTHER>
IFE MONLOD,<SKIPL SYMEXT ;BEEN SETUP ONCE?>
TRNN F,LSYMFL ;OUTPUT FILE SET UP?
IFN MONLOD,<PUSHJ P,INITSYM ;NO, DO IT>
IFE MONLOD,<POPJ P, ;NO, DON'T OUTPUT SYMBOLS>
SOSG ABUF2
OUTPUT 2,
IDPB C,ABUF1
SOSG ABUF2
OUTPUT 2,
IDPB W,ABUF1
AOS SYMCNT#
POPJ P,>
IFN SYMDSW,<
SYOPEN: HLRZM W,SYMEXT#
MOVE W,DTIN ;GET FILE NAME
MOVEM W,SYMNAM ;SAVE IT
PUSHJ P,INITSYM ;OPEN FILE
JRST LD2DD ;AND RETURN TO SCAN
INITSYM:
TLZ N,AUXSWI!AUXSWE
INIT 2,14
SIXBIT /DSK/
ABUF,,0
HALT
PUSH P,0
PUSH P,1
PUSH P,2
PUSH P,3
MOVEI 0,AUX
MOVEM 0,.JBFF
OUTBUF 2,1
PJOB 0,
MOVEI 3,3
IDIVI 0,^D10
ADDI 1,"0"-40
LSHC 1,-6
SOJG 3,.-3
HRRI 2,'SYM'
MOVE 0,SYMNAM# ;GET NAME
JUMPN 0,.+3 ;WAS IT SET
MOVS 0,2 ;NO
MOVEM 0,SYMNAM ;STORE IT
SKIPN 1,SYMEXT ;ALREADY SET
MOVEI 1,'TMP'
HRRZM 1,SYMEXT ;STORE FILE EXTENSION
HRLZS 1
SETZB 2,3
ENTER 2,0
HALT
POP P,3
POP P,2
POP P,1
POP P,0
IORI F,LSYMFL ;SYMBOL FILE SETUP NOW
POPJ P,
>
; GLOBAL DEFINITION MATCHES REQUEST
SYM2: PUSH P,SYM2C ;NEXT MUST BE A SUBROUTINE FOR LATER, SET RETURN
SYM2B: MOVE V,2(A) ;LOAD REQUEST POINTER
PUSHJ P,REMSYM
JUMPL V,SYM2W ;ADDITIVE REQUEST? WFW
PUSHJ P,SYM4A ;REPLACE CHAIN WITH DEFINITION
SYM2W1: PUSHJ P,SREQ ;LOOK FOR MORE REQUESTS FOR THIS SYMBOL
JRST SYM2B ;FOUND MORE
SYM2C: POPJ P,SYM1D ;RETURN, SEE SYM2 FOR USE OF ADDRESS
; REQUEST MATCHES GLOBAL DEFINITION
SYM2A: MOVE V,W ;LOAD POINTER TO CHAIN
MOVE W,2(A) ;LOAD VALUE
JUMPL V,FIXWP ;HANDLE ATTITIVE REQUEST WFW
JRST SYM4A
; PROCESS GLOBAL REQUEST
SYM3: TLNE C,040000; COMMON NAME
JRST SYM1B
TLC C,640000; PERMUTE BITS FROM 60 TO 04
PUSHJ P,SDEF ;SEARCH FOR GLOBAL DEFINITION
JRST SYM2A ;MATCHING GLOBAL DEFINITION
JUMPL W,SYM3X1 ;ADDITIVE FIXUP WFW
PUSHJ P,SREQ ;SEARCH FOR EXISTING REQUEST WFW
JRST SYM3A ;EXISTING REQUEST FOUND WFW
SYM3X1: TLNN W,100000 ;CHECK SYMBOL TABLE FIXUP
JRST SYM3X2 ;NO
MOVE V,1(B) ;MUST BE LAST SYMBOL DEFINED. GET SYMBOL
XOR V,W ;CHECK FOR IDENTITY
TDNE V,[XWD 77777,-1] ;BUT IGNORE HIGH 3 BITS
POPJ P, ;NOT SAME, ASSUME NOT LOADED LOCAL
HRRI W,2(B) ;GET LOCATION IN RIGHT HALF
TLO W,1
SUB W,HISTRT ;AND MAKE RELATIVE
IFN B11SW,<TLZ W,040000>
SYM3X2: IFN MONLOD,<TLNE N,DISW ;LOADING TO DISK?
PUSHJ P,SIZCHK ;YES, CHECK FOR OVERLAP>
CAIL H,(S) ;STORE REQUEST IN UNDEF. TABLE WFW
IFN EXPAND,< PUSHJ P,XPAND7>
IFE EXPAND,< JRST SFULLC>
SYM3X: IFE K,<
TLNE N,F4SW; FORTRAN FOUR
PUSHJ P,MVDWN; ADJUST TABLES IF F4>
SUB S,SE3 ;ADVANCE UNDEFINED POINTER
MOVEM W,2(S) ;STORE UNDEFINED VALUE POINTER
MOVEM C,1(S) ;STORE UNDEFINED SYMBOL
POPJ P,;
; COMBINE TWO REQUEST CHAINS
SYM3A: SKIPL 2(A) ;IS IT ADDITIVE WFW
JRST SYM3A1 ;NO, PROCESS WFW
SYM3A4: PUSHJ P,SDEF2 ;YES, CONTINUE WFW
JRST SYM3A ;FOUND ANOTHER WFW
JRST SYM3X2 ;REALLY NO CHAIN THERE WFW
SYM3A1: SKIPE V,2(A) ;IF ADDRESS OF CHAIN IS 0, THROW IT AWAY
JRST SYM3A2 ;AND USE THE NEW ONE, ELSE ADD THE CHAINS
MOVEM W,2(A) ;W IS ADDRESS OF NEW CHAIN,STORE ON TOP OF OLD 0
POPJ P,
SYM3A2:
SYM3A3: MOVE A,2(A)
SYM3B: HRRZ V,A
IFN L,<CAMGE V,RINITL
HALT>
IFN REENT,<CAMGE V,HVAL1
SKIPA X,LOWX
MOVE X,HIGHX>
IFN MONLOD,<PUSHJ P,DICHK ; MAKE SURE ADDRESS IN V IS IN CORE>
HRRZ A,@X ; LOAD NEXT ADDRESS IN CHAIN
JUMPN A,SYM3B ; JUMP IF NOT THE LAST ADDR. IN CHAIN
HRRM W,@X ;COMBINE CHAINS
IFN MONLOD,<TLO N,WOSW ;SET FLAG TO WRITE OUT BUFFER>
POPJ P,;
;WFW PATCH FOR ADDITIVE GLOBAL REQUESTS
FIXWP: TLNN V,100000 ;CHECK FOR SYMBOL TABLE FIXUP
JRST FIXW
MOVE T,1(B) ;SYMBOL FIXUP, MUST BE LAST SYMBOL DEFINED
XOR T,V ;CHECK FO SAME
TDNE T,[XWD 77777,-1] ;EXCEPT FOR HIGH CODE BITS
POPJ P, ;ASSUME NON-LOADED LOCAL
HRRI V,2(B) ;GET LOCATION
SUBI V,(X) ;SO WE CAN USE @X
JRST FIXW1
FIXW: IFN REENT,<HRRZ T,V
CAMGE T,HVAL1
SKIPA X,LOWX
MOVE X,HIGHX>
IFN L,< HRRZ T,V
CAMGE R,RINITL
POPJ P,>
FIXW1: TLNE V,200000 ;IS IT LEFT HALF
JRST FIXWL
IFN MONLOD,<TLNN V,100000 ;SKIP IF USING @X TO FIX SYMBOL TABLE
PUSHJ P,DICHK ;MAKE SURE ADDRESS IN V IS IN CORE>
MOVE T,@X ;GET WORD
ADD T,W ;VALUE OF GLOBAL
HRRM T,@X ;FIX WITHOUT CARRY
IFN MONLOD,<TLNN V,100000 ;SKIP IF JUST FIXED SYMBOL TABLE
TLO N,WOSW ;SET FLAG TO WRITE OUT BUFFER>
MOVSI D,200000 ;SET UP TO REMOVE DEFERED INTERNAL IF THERE
JRST SYMFIX
FIXWL: HRLZ T,W ;UPDATE VALUE OF LEFT HALF
IFN MONLOD,<TLNN V,100000 ;SKIP IF USING @X TO FIX SYMBOL TABLE
PUSHJ P,DICHK ;MAKE SURE ADDRESS IN V IS IN CORE>
ADDM T,@X ;BY VALUE OF GLOBAL
IFN MONLOD,<TLNN V,100000 ;SKIP IF JUST FIXED SYMBOL TABLE
TLO N,WOSW ;SET FLAG TO WRITE OUT BUFFER>
MOVSI D,400000 ;LEFT DEFERED INTERNAL
SYMFIX: TLNN V,100000 ;CHECK FOR SYMBOL TABLE FIXUP
POPJ P, ;NO, RETURN
ADDI V,(X) ;GET THE LOCATION
SYMFX1: MOVE T,-1(V) ;GET THE SYMBOL NAME
TLNN T,40000 ;CHECK TO SEE IF INTERNAL
POPJ P, ;NO, LEAVE
ANDCAB D,-1(V) ;REMOVE PROPER BIT
TLNE D,600000 ;IS IT STILL DEFERED?
POPJ P, ;YES, ALL DONE
EXCH C,D ;NO, CHECK FOR A REQUEST FOR IT
PUSHJ P,SREQ
JRST CHNSYM ;YES, WILL HAVE TO CALL THE FIXUP ROUTINE
MOVE C,D ;GET C BACK
POPJ P,
CHNSYM: PUSH P,D ;HAS THE OLD C IN IT
PUSH P,W ;WE MAY NEED IT LATER
MOVE W,(V) ;GET VALUE
PUSHJ P,SYM2B ;CALL THE FOUND GLOBAL TO MATCH REQUEST ROUTINE
POP P,W
POP P,C ;RESTORE FOR CALLER
POPJ P, ;AND GO AWAY
SYM2W: IFN B11SW,<
TLNE V,40000 ;CHECK FOR POLISH
JRST POLSAT>
TLNN V,100000 ;SYMBOL TABLE?
JRST SYM2WA
ADD V,HISTRT ;MAKE ABSOLUTE
SUBI V,(X) ;GET READY TO ADD X
PUSHJ P,FIXW1
JRST SYM2W1
SYM2WA: PUSHJ P,FIXW ;DO FIXUP
JRST SYM2W1 ;AND LOOK FOR MORE REQUESTS
;END WFW PATCH
;PATCH VALUES INTO CHAINED REQUEST
SYM4: IFN L,<CAMGE V,RINITL
POPJ P,>
IFN REENT,<CAMGE V,HVAL1
SKIPA X,LOWX
MOVE X,HIGHX>
IFN MONLOD,<PUSHJ P,DICHK ;MAKE SURE ADDRESS IN V IS IN CORE>
HRRZ T,@X ;LOAD NEXT ADDRESS IN CHAIN
HRRM W,@X ;INSERT VALUE INTO PROGRAM
IFN MONLOD,<TLO N,WOSW ;SET FLAG TO WRITE OUT BUFFER>
MOVE V,T
SYM4A: JUMPN V,SYM4 ;JUMP IF NOT LAST ADDR. IN CHAIN
POPJ P,
IFE K,<
MVDWN: HRRZ T,MLTP
IFN EXPAND,< SUBI T,2>
CAIG T,(H); ANY ROOM LEFT?
IFN EXPAND,< JRST [PUSHJ P,XPAND>
TLOA F,FULLSW
IFN EXPAND,< JRST MVDWN
POPJ P,]>
TLNE F,SKIPSW+FULLSW
POPJ P, ; ABORT BLT
HRREI T,-2
ADDM T,PLTP; ADJUST PROGRAMMER LABEL POINTER
ADDM T,BITP; AND BIT TABLE POINTER
ADDM T,SDSTP; FIRST DATA STATEMENT
ADDM T,LTC
ADDM T,ITC
TLNE N,SYDAT
ADDM T,V
ADDB T,MLTP; AND FINALLY TO MADE LABEL TABLE
HRLS T; SET UP BLT POINTER
ADD T,[XWD 2,0]
BLT T,(S)
POPJ P,
>
REMSYM: MOVE T,1(S)
MOVEM T,1(A)
MOVE T,2(S)
MOVEM T,2(A)
CAIN S,A ;MOVING TO SELF?
JRST REMSY1 ;YES, DON'T CLEAR
SETZM 1(S) ;CLEAR NAME
SETZM 2(S) ;CLEAR POINTER
REMSY1: ADD S,SE3
POPJ P,
SUBTTL HIGH-SEGMENT (BLOCK TYPE 3)
;THIS PROGRAM IS INTENDED FOR HI SEGMENT IF RUNNING ON A PDP-10.
; THIS BLOCK TYPE OCCURS AFTER ENTRY AND NAME BLOCKS.
HISEG: HRRZ C,W ;GET WORD COUNT
PUSHJ P,WORD ;GOBBLE UP BYTE WORD.
PUSHJ P,WORD ;GET THE HIGH SEG OFSET
SOJE C,.+4 ;FINISHED IF NOT FORTRAN-10
MOVE C,W ;SAVE HIGH INFO
PUSHJ P,WORD ;GET LOW BREAK
EXCH W,C ;SWAP BACK
IFE REENT,<HISEG2==LOAD1A
JUMPGE W,LOAD1A ;NOT TWO SEG PROG.>
IFN REENT,<JUMPE W,HISEG2 ;IGNORE ZERO
IFE TENEX,<JUMPG W,HISEG3 ;NEG. IF TWOSEG PSEUDO-OP>
IFN TENEX,<TLNN W,-1
JRST HISEG3>
>;END OF IFN REENT
TRO F,TWOFL ;SET FLAG
IFN REENT,<
TRNE F,NOHI!NOHI6 ;TWO SEGMENTS LEGAL?
JRST ONESEG ;LOAD AS ONE SEGMENT
HISEG3: HRRZ D,W ;GET START OF HISEG
JUMPE D,.+2 ;NOT SPECIFIED
PUSHJ P,HCONT ;AS IF /H
HISEG2: PUSHJ P,HISEG1
JRST LOAD1 ;GET NEXT BLOCK
FAKEHI: ;AS IF BLOCK TYPE 3
HISEG1: TRNE F,NOHI!NOHI6 ;LOAD REENT?
POPJ P,
TLOE F,HIPROG ;LOADING HI PROG
POPJ P, ;IGNORE 2'ND HISEG
TRON F,SEENHI ;HAVE WE LOADED ANY OTHER HI STUFF?
PUSHJ P,SETUPH ;NO,SET UP HI SEG.
MOVEM R,LOWR
MOVE R,HIGHR
MOVE X,NAMPTR ;GET THE POINTER TO PROGRAM NAME
HRRM R,2(X) ;CALL THIS THE START OF THE PROGRAM
MOVE X,HIGHX
POPJ P,
SETUPH: MOVE X,HVAL1
CAIGE X,-1 ;SEE IF IT HAS BEEN CHANGED FROM ORIG
JRST SEENHS ;YES, MUST HAVE SEEN /H
MOVEI X,400000
MOVEM X,HVAL1
CAIG X,(H) ;HAVE WE RUN OVER WITH THE LOW SEG
JRST COROVL
ADDI X,.JBHDA
HRLI X,W
MOVEM X,HVAL
SEENHS: MOVE X,HVAL
MOVEM X,HIGHR
HRRZ X,.JBREL
SUB X,HVAL1
ADDI X,1
HRLI X,V
MOVEM X,HIGHX
POPJ P,
SETSEG: TRZ F,NOHI!SEGFL ;ALLOW HI-SEG
JUMPL D,.+2 ;/-H TURNS OFF NOHI ONLY
TRO F,SEGFL ;/1H FORCES HI
POPJ P,
>
ONESEG: HLRZ D,W ;GET LENGTH OF HISEG
SUBI D,(W) ;REMOVE OFSET
JUMPLE D,ONELOW ;LENGTH NOT AVAILABLE
MOVEM R,LOWR ;SAVE LOW SEGMENT RELOCATION
ADDM D,LOWR ;ADD TO LOW SEG RELOCATION
HRRZM W,HVAL1 ;SO RELOC WILL WORK
JRST LOAD1 ;GET NEXT BLOCK
ONELOW: HLRZ D,C ;TRY LOW SEG BREAK
SUBI D,(C)
JUMPLE D,TWOERR ;NOT AVAILABLE
MOVEM R,LOWR ;SAVE CURRENT BREAK
ADD R,D ;ADD LOW LENGTH
HRRZM W,HVAL1 ;SO RELOC WILL WORK
JRST LOAD1
TWOERR: ERROR 7,</TWO SEGMENTS ILLEGAL#/>
IFE L,< JRST LDRSTR>
IFN L,< JRST LOAD1>
SUBTTL HIGHEST RELOCATABLE POINT (BLOCK TYPE 5)
HIGH0: CAIE A,4 ; TEST FOR END BLOCK (OVERLAP)
JRST LIB30
HIGH: TRNN F,TWOFL ;IS THIS A TWO SEGMENT PROGRAM?
JRST HIGH2A ;NO
HIGH2: PUSHJ P,RWORD ;GET HISEG BREAK
TRZ F,TWOFL ;CLEAR FLAG NOW
IFE REENT,<MOVE R,LOWR
JRST HIGH2A>
IFN REENT,<TRNE F,NOHI!NOHI6 ;SINGLE SEGMENT LOAD?
JRST [MOVE R,LOWR ;YES,GET LARGER RELOC
CAILE W,(R) ;IF FORTRAN-10
SKIPA C,W ;HISEG CODE IS ON TOP
SETZ C, ;OTHERWISE ZERO ABS VALUE
MOVE W,HVAL ;ORIGINAL VALUE
MOVEM W,HVAL1 ;RESET
PUSHJ P,RWORD ;GET LOW SEG BREAK IN W
CAMGE C,W ;PUT LARGER VALUE
MOVE C,W ;IN C
JRST HIGH2B] ;CONTINUE AS IF LOW ONLY
HRR R,W ;PUT BREAK IN R
CAMLE R,HVAL
MOVEM R,HVAL
MOVEM R,HIGHR
MOVE R,LOWR ;NEXT WORD IS LOW SEG BREAK
TLZ F,HIPROG ;CLEAR HIPROG
PUSHJ P,PRWORD ;GET WORD PAIR
HRR R,C ;GET LOW SEG BREAK
MOVEM R,LOWR ;SAVE IT
MOVE R,HIGHR ;GET HIGH BREAK
JRST HIGHN3 ;AND JOIN COMMON CODE>
HIGH2A: PUSHJ P,PRWORD ;READ TWO DATA WORDS.
HIGH2B: IFN REENT,<
TLZE F,HIPROG
JRST HIGHNP>
IFN WFWSW,<ADD C,VARLNG ;IF LOW SEG THEN VARIABLES GO AT END>
IFN ALGSW,<ADD C,OWNLNG ;ADD IN LENGTH OF OWN BLOCK>
IFN COBSW,<ADD C,LOD37. ;ADD IN LOCAL SYMBOLS
SKIPE LOD37. ;BUT WERE THERE ANY?
SUBI C,3 ;YES SO REMOVE THE 3 WORDS OVERWRITTEN>
IFE TENEX,<CAMGE C,W ;CHECK 2ND WORD (LOC PROG BRK IF PRESENT)
MOVE C,W>
HRR R,C ;SET NEW PROGRAM BREAK
HIGH31: MOVEM R,LOWR ;SAVE NEW VALUE OF R
IFN MONLOD,<TLNN N,DISW ;SKIP IF LOADING TO DISK>
ADDI C,(X)
CAIG H,(C)
MOVEI H,(C) ;SET UP H
IFN MONLOD,<TLNE N,DISW ;LOADING TO DISK?
JRST HIGH3 ;YES, DON'T WORRY ABOUT EXCEEDING CORE>
CAILE H,1(S) ;TEST PROGRAM BREAK
IFN EXPAND,<PUSHJ P,[ PUSHJ P,XPAND
POPJ P,
JRST POPJM2]>
IFE EXPAND,<TLO F,FULLSW>
HIGH3: MOVEI A,F.C
BLT A,B.C
IFN REENT,<TRNE F,NOHI!NOHI6 ;ONE SEGMENT PROGRAM?
JRST HIGHN4 ;YES
HRRZ W,LOWR ;GET LOW PROG BREAK
HRL W,HIGHR ;GET HIGH PROG BREAK
SETZ C, ;ZERO SYMBOL NAME
PUSHJ P,SYM1B ;PUT IN SYMBOL TABLE
MOVEM S,F.C+S ;SAVE NEW S AND B
MOVEM B,F.C+B ;INCASE OF ERROR
HIGHN4:>
TRZE N,F10TFL ;FORTRAN-10 SET NOHI?
TRZ F,NOHI ;YES, CLEAR IT
SETZM SBRNAM ;RELAX, RELOCATION BLOCK FOUND
TLNE F,SLIBSW+LIBSW ;NORMAL MODE EXIT THROUGH LOAD1
JRST LIB ;LIBRARY SEARCH EXIT
JRST LOAD1
IFN REENT,<
HIGHNP: HRR R,C
CAMG W,HVAL1 ;ABS. ADDRESS IN HIGH SEGMENT?
JRST HIGHN1 ;NO
CAIG C,(W) ;YES, GREATER THAN CURRENT HISEG RELOC?
HRR R,W ;YES, USE IT
SETZ W, ;DON'T USE IT AGAIN
HIGHN1: CAMLE R,HVAL
MOVEM R,HVAL
MOVEM R,HIGHR
HIGHN3: PUSH P,W ;SAVE W,CONTAIN HIGHEST ABSOLUTE ADDRESS
ADD W,LOWX ;LOC PROG BRK
CAIGE H,(W) ;CHECK FOR TOP OF LOW CORE
MOVEI H,(W)
POP P,W ;RESTORE
CAML H,HVAL1
JRST COROVL ;OVERFLOW OF LOW SEGMENT
HIGHN2: HRRZ R,HVAL
SUB R,HVAL1
ADD R,HISTRT
CAMLE R,.JBREL
JRST [PUSHJ P,HIEXP
JRST FULLC
JRST HIGHN2]
MOVE R,LOWR
MOVE X,LOWX
IFN WFWSW,<ADD R,VARLNG ;VARIABLES IN LOW SEG>
IFN ALGSW,<ADD R,OWNLNG ;OWN BLOCK IN LOW SEGMENT>
IFN COBSW,<ADD R,LOD37. ;ADD IN LOCAL SYMBOLS
SKIPE LOD37. ;BUT WERE THERE ANY?
SUBI R,3 ;YES SO REMOVE THE 3 WORDS OVERWRITTEN>
HRRZ C,R
CAIGE C,(W) ;IS ABSOLUTE LOCATION GREATER
HRR R,W ;YES USE IT
HRRZ C,R ;SET UP C AGAIN
JRST HIGH31 ;GO CHECK PROGRAM BREAK
>
SFULLC: TROE F,SFULSW ;PREVIOUS OVERFLOW?
JRST FULLC ;YES, DON'T PRINT MESSAGE
ERROR ,<?SYMBOL TABLE OVERLAP#?>
FULLC:
IFE K,< TLNE N,F4SW
POPJ P,>
JRST LIB3 ;LOOK FOR MORE
SUBTTL EXPAND HIGH SEGMENT
IFN REENT,<
HIEXP: TLNE F,FULLSW
POPJ P,
IFN EXPAND,<PUSH P,Q>
PUSH P,H
PUSH P,X
PUSH P,N
IFE K,<HRRZ X,MLTP
TLNN N,F4SW>
MOVEI X,1(S)
HRRZ N,X
SUB N,H
CAILE N,1777
JRST MOVHI
IFE EXPAND,<POPJ P,>
IFN EXPAND,<HRRZ N,.JBREL
ADDI N,2000
CAMG N,ALWCOR
CORE N,
JRST XPAND6
POP P,N
JRST XPAND3>
MOVHI: MOVEI N,-2000(X)
HRL N,X
HRRZ X,.JBREL
BLT N,-2000(X)
MOVNI H,2000
IFN EXPAND,<JRST XPAND8>
IFE EXPAND,<ADDM H,HISTRT
ADDM H,S
ADDM H,B
ADDM H,HIGHX
TLNE F,HIPROG
ADDM H,-1(P)
POP P,N
ADDM H,NAMPTR ;ADJUST POINTER TO NAME
IFE K,< TLNN F4SW
JRST HIXP1
ADDM H,PLTP
ADDM H,BITP
ADDM H,SDSTP
ADDM H,MLTP
TLNE N,SYDAT
ADDM H,V
HIXP1:>
POP P,X
POP P,H
AOS (P)
POPJ P,>
>
SUBTTL PROGRAM NAME (BLOCK TYPE 6)
NAME: SKIPE SBRNAM ;HAVE WE SEEN TWO IN A ROW?
JRST NAMERR ;YES, NO END BLOCK SEEN
NAME0: PUSHJ P,PRWORD ;READ TWO DATA WORDS
MOVEM C,SBRNAM ;SAVE SUBROUTINE NAME
IFN MANTIS,<CAMN C,[RADIX50 0,MANTIS]
CAME R,[W,,.JBDA] ;YES, BUT IS IT TO LOAD AT 140?
CAIA ;NO, NOT A DEBUG /MANTIS COMMAND
TRO N,MANTFL ;HAVE SEEN MANTIS NOW>
NCONT: HLRZ V,W ;GET COMPILER TYPE
ANDI V,7777 ;BITS 6-17
CAILE V,CMPLEN ;ONLY IF LEGAL TYPE
SETZ V, ;MAKE DEFAULT
HLL V,W ;GET CPU TYPE ALSO
TLZ V,7777 ;BITS 0-5
HRRZS W ;CLEAR TYPE
XCT CMPLER(V) ;DO SPECIAL FUNCTION
TLOE N,COMFLG ;SKIP IF COMMON NOT PREV. SET
JRST NAME1 ;SIZE OF COMMON PREV. SET
MOVEM W,COMSAV ;STORE LENGTH OF COMMON
JUMPE W,NAME2 ;JUMP IF NO COMMON IN THIS JOB
HRRI R,@R ;FIRST PROGRAM SET LOAD ORIGIN
NAME1: IFN MONLOD,<TLNE N,DISW ;LOADING TO DISK?
PUSHJ P,SIZCHK ;YES, CHECK FOR OVERLAP>
CAILE H,-1(S) ;TEST FOR AVAIL. SYMBOL SPACE
IFN EXPAND,< PUSHJ P,XPAND7>
IFE EXPAND,< JRST SFULLC>
SUBI S,2 ;UPDATE UNDEF. TABLE POINTER
POP B,2(S)
POP B,1(S)
EXCH N,NAMPTR ;GET NAME POINTER, SAVE N
HRRZ V,N ;POINTER TO PREVIOUS NAME
SUBM B,V ;COMPUTE RELATIVE POSITIONS
HRLM V,2(N) ;STORE FORWARD POINTER
HRRZ N,B ;UPDATE NAME POINTER
EXCH N,NAMPTR ;SWAP BACK
NAME2: MOVEM C,1(B) ;STORE PROGRAM NAME
HRRZM R,2(B) ;STORE PROGRAM ORIGIN
IFN SYMDSW,<PUSH P,W ;SAVE W
HRRZ W,R ;ORIGIN
PUSHJ P,SYM1X ;PUT IN DSK FILE ALSO
POP P,W>
CAMG W,COMSAV ;CHECK COMMON SIZE
IFE REENT,<JRST LIB3 ;COMMON OK>
IFN REENT,<JRST [TRNE F,SEGFL ;LOAD LOW IN HI-SEG
PUSHJ P,FAKEHI ;YES
JRST LIB3]>
SKIPA C,COMM
ILC: MOVE C,1(A) ;NAME
PUSH P,C ;SAVE COMMON NAME
ERROR ,</ILL. COMMON !/>
POP P,C
PUSHJ P,PRNAME
ILC1: SKIPN SBRNAM
JRST ILC2
ERROR 0,</ PROG. !/>
MOVE C,SBRNAM ;RECOVER SUBROUTINE NAME
PUSHJ P,PRNAME
ILC2: ERROR 0,</ #/>
JRST LD2
NAMERR: TLNE F,FULLSW ;IF NOT ENUF CORE
JRST NAME0 ;END BLOCK IS NEVER SEEN
SETZM DTIN ;CLEAR WRONG FILE NAME FOR MESSAGE
ERROR ,</NO END BLOCK !/>
JRST ILC1
;COMPILER TYPE - DO SPECIAL FUNCTION FOR IT
CMPLER:
JFCL ; 0 UNKNOWN
PUSHJ P,F40NAM ; 1 FORTRAN (F40)
TRO N,COBFL!VFLG ; 2 COBOL
PUSHJ P,ALGNAM ; 3 ALGOL-60
TRO N,NELFL ; 4 NELIAC
TRO N,PL1FL ; 5 PL/1
TRO N,BLIFL ; 6 BLISS-10
TRO N,SAIFL ; 7 SAIL
PUSHJ P,FORNAM ;10 FORTRAN-10
;11 MACRO
;12 FAIL
CMPLEN==.-CMPLER
F40NAM: TRNE N,FORFL ;CANNOT MIX OLD & NEW
JRST F40ERR
TRO N,F4FL!VFLG ;SET FLAGS
IFE ALGSW,<ALGNAM:;PUT LABEL ON A POPJ>
POPJ P,
FORNAM: TRNE N,F4FL ;CANNOT MIX OLD & NEW
JRST F40ERR
TRO N,FORFL!VFLG
IFN FORSW,<SKIPG FORLIB ;IF NOT SET FOR FOROTS
AOS FORLIB ;DO SO>
HLLZ V,V ;SEE IF ANY CPU BITS
ROT V,6 ;PUT IN BITS 30-35
CAILE V,2 ;ONLY 0, 1, 2 VALID
SETZ V, ;DEFAULT
PUSHJ P,@[EXP CPOPJ,FORNMA,FORNMI](V)
IFN REENT,<SKIPL VSW ;USER DOES N'T WANT REENT OTS?
TRNE F,NOHI!SEGFL!SEENHI ;USER SET SEGMENT OR HI CODE SEEN?
POPJ P,> ;YES
TRO F,NOHI ;DEFAULT IS ONE SEG
TRO N,F10TFL ;BUT ONLY FOR THIS FILE
IFN FORSW,<HRRZM F,FORLIB> ;SET FOROTS BY DEFAULT (FORLIB .GT. 0)
POPJ P,
FORNMI: TRNE N,KA10FL ;CANNOT MIX KA & KI
JRST FORERR
TRO N,KI10FL ;SET FLAGS
POPJ P,
FORNMA: TRNE N,KA10FL ;CANNOT MIX KA & KI
JRST FORERR
TLO N,KA10FL
POPJ P,
F40ERR: ERROR ,</CANNOT MIX F40 AND FORTRAN-10 COMPILED CODE@/>
FORERR: ERROR ,</CANNOT MIX KA10 AND KI10 FORTRAN-10 COMPILED CODE@/>
IFN ALGSW,<
ALGNAM: TRO N,ALGFL!VFLG ;SET ALGOL SEEN, AND DEFAULT REENT OPSYS
JUMPE W,CPOPJ ;NOT ALGOL MAIN PROGRAM
IFN NAMESW,<
PUSH P,C ;SAVE NAME
MOVE W,C ;EXPECTS NAME IN W
PUSHJ P,LDNAM ;USE THIS A PROGRAM NAME
POP P,C ;RESTORE C>
SETZ W, ;CLEAR COMMON SIZE, ONLY A MARKER
POPJ P, ;RETURN
>
SUBTTL STARTING ADDRESS (BLOCK TYPE 7)
START: PUSHJ P,PRWORD ;READ TWO DATA WORDS
TLNN N,ISAFLG ;SKIP IF IGNORE SA FLAG ON
HRRZM C,STADDR ;SET STARTING ADDRESS
IFN NAMESW,<
MOVE W,DTIN ;PICK UP BINARY FILE NAME
TLNN N,ISAFLG
MOVEM W,PRGNAM ;SAVE IT
MOVE W,NAMPTR ;GET NAME POINTER
MOVE W,1(W) ;SET UP NAME OF THIS PROGRAM
IFE ALGSW,<TLNN N,ISAFLG ;DONT SET NAME IF IGNORING SA'S>
IFN ALGSW,<TDNN N,[ISAFLG,,ALGFL] ;OR ALGOL LOADING>
PUSHJ P,LDNAM>
PUSHJ P,PRWORD ;**OBSCURE RETURN TO LOAD1**
IFN REENT,<
RESTRX: TLNE F,HIPROG
SKIPA X,HIGHX
MOVE X,LOWX
POPJ P,>
SUBTTL ONE PASS LOCAL DEFINITION (BLOCK TYPE 10)
;PMP PATCH FOR LEFT HALF FIXUPS
IFN FAILSW!B11SW!WFWSW,<
LOCDLH: IFN L,<CAMGE V,RINITL
POPJ P,>
IFN REENT,<CAMGE V,HVAL1
SKIPA X,LOWX
MOVE X,HIGHX>
IFN MONLOD,<PUSHJ P,DICHK>
HLRZ T,@X ;LOAD NEXT ADDRESS IN CHAIN
HRLM W,@X ;INSERT VALUE INTO PROGRAM
MOVE V,T
LOCDLF: JUMPN V,LOCDLH ;JUMP IF NOT LAST ADDR. IN CHAIN
POPJ P,>
IFN FAILSW,<
LOCDLI: PUSHJ P,LOCDLF
IFN REENT,<PUSHJ P,RESTRX>
AOSA LFTHSW ;TURN OFF LEFT HALF FIX SW (WAS -1) AND SKIP
LOCDLG: SETOM LFTHSW ;TURN ON LEFT HALF FIX SW>
;END PMP PATCH
LOCD: PUSHJ P,RWORD ;READ ONE DATA WORD
HLRZ V,W ;STORAGE POINTER IN LEFT HALF
IFN FAILSW,<
SKIPE LFTHSW ;LEFT HALF CHAINED? PMP
JRST LOCDLI ;YES PMP
CAMN W,[-1] ;LEFT HALF NEXT? PMP
JRST LOCDLG ;YES, SET SWITCH PMP>
PUSHJ P,SYM4A ;LINK BACK REFERENCES
IFN REENT,<PUSHJ P,RESTRX>
JRST LOCD
SUBTTL LVAR FIX-UP (BLOCK TYPE 13)
IFN WFWSW,<
LVARB: PUSHJ P,PRWORD ;THE FIRST TWO WORDS IN THE BLOCK
MOVEM W,VARLNG ;AR SPECIAL. SECOND IS LENGTH OF VARIABLES
IFN REENT,< TLNE F,HIPROG
MOVE C,LOWR ;USE LOW RELOC IF LOADING HI SEG>
;ELSE C HAS RELOC FOR THIS PROGRAM, USE IT
HRRZM C,VARREL ;THIS IS LOCATION 0 OF VARIABLE AREA
LVLP: PUSHJ P,PRWORD ;THINGS COME IN PAIRS
TLNE C,200000 ;BIT ON IF SYMBOL TABLE FIXUP
JRST LVSYM
HLRZ V,W ;NO GET LOC FROM LEFTH HALF OF SECOND
ADD W,VARREL ;AND RELOCATE VARIABLE
TLNE C,400000 ;ON FOR LEFT HALF
JRST [PUSHJ P,LOCDLF ;TAKE CARE OF IT
IFN REENT,< JRST LVLCOM] ;RESET X>
IFE REENT,< JRST LVLP] ;MUST BE LOW SEG X OK>
PUSHJ P,SYM4A ;RIGHT HALF CHAIN
IFN REENT,<LVLCOM: PUSHJ P,RESTRX>
JRST LVLP
LVSYM: MOVE V,B ;GET SYMBOL TABLE POINTER
ADD C,VARREL ;VALUE IS IN FIRST WORD FOR THESE
TLZ W,740000 ;MAKE SURE NO BITS ON
ADDI V,2 ;CORRECT POINTER TO SYMBOL TABLE
SRSYM: MOVE A,-1(V) ;GET A NAME
TLZN A,740000 ;CHECK FOR PROGRAM NAME
JRST LVLP ;LEAVE (PROBABLY A NON-LOADED LOCAL)
CAMN A,W ;IS IT THE RIGHT ONE??
JRST LVSYMD ;YES
ADD V,SE3 ;CHECK NEXT ONE
JUMPL V,SRSYM ;BUT ONLY IF SOME ARE THERE
JRST LVLP ;GIVE UP
LVSYMD: TLNE C,400000 ;WHICH HALF??
JRST LVSYML ;LEFT
ADD C,(V) ;ADDITIVE FIXUP
HRRM C,(V)
MOVSI D,200000 ;DEFERED BITS
LVSM1: PUSHJ P,COMSFX ;GO TAKE CARE OF IT
JRST LVLP ;NEXT PLEASE
LVSYML: HRLZS C
ADDM C,(V) ;WE DON'T HAVE TO WORRY ABOUT OVERFLOW HERE
MOVSI D,400000 ;LEFT DEFERED BITS
JRST LVSM1 ;GO WORRY ABOUT DEFERED INTERNALS>
SUBTTL FAIL LOADER
;ONLY LIST IF POLISH FIXUPS REQUIRED
XLIST
IFN FAILSW!B11SW,<LIST>
REPEAT 0,<IF POLISH FIXUPS CONTAIN GLOBAL REQUESTS WHICH
CAN NOT BE SATISFIED WHEN THEY ARE SEEN, THEY MUST BE
SAVED UNTIL THESE GLOBAL SYMBOLS BECOME DEFINED.
THE POLISH FIXUP IS SAVED IN THE UNDEFINED TABLE (POINTED
TO BY S). THE FIXUP IS SAVED IN TWO WORD BLOCKS THE FIRST
WORD OF WHICH (THE ONE WHICH WOULD NORMALL CONTAIN THE SYMBOL)
HAS SPECIAL BITS ON SO IT WILL NOT BE FOUND BY A SEARCH FOR
A GLOBAL REQUEST. SINCE THE UNDEFINED TABLE MAY BE
SHUFFELED INTO A RANDOM ORDER, IT IS NOT POSSIBLE TO KEEP
ALL OF A POLISH FIXUP TOGETHER OR TO HAVE POINTERS IN
THE USUAL SENCE FROM ONE TWO WORD BLOCK TO ANOTHER.
SUFFICIENT INFORMATION IS THEREFORE GIVEN TO DETERMINE
WHAT THE FIRST WORD OF THE NEXT DESIRED BLOCK IS AND THIS
BLOCK IS FOUND BY SEARCHING THE UNDEFINED TABLE FOR A MATCH.
EACH POLISH FIXUP WHICH IS ENTERED INTO THE UNDEFINED
TABLE IS GIVEN A UNIQUE NUMBER CALLED THE "HEAD NUMBER".
EACH ELEMENT OF THE FIXUP (EITHER OPERAND OR OPERATOR)
IS ASSIGNED A NUMBER CALLED THE "OP NUMBER". THUS
THE OP NUMBER AND HEAD NUMBER TOGETHER DETERMINE
A SPECIFIC ELEMENT OF A SPECIFIC FIXUP. EACH ELEMENT
(TWO WORD BLOCK) IS ARRANGED AS FOLLOWS:
WORD 1:
BITS 0-4 THESE ARE THE USUAL CODE BITS OF A RADIX50
SYMBOL AND CONTAIN 44 TO DISTINGUISH
AN ELEMENT OF A POLISH FIXUP FROM OTHER
SYMBOLS IN THE UNDEFINED TABLE
BITS 5-17 THE HEAD NUMBER OF THIS FIXUP
BITS 18-30 THE OP NUMBER OF THIS ELEMENT
BITS 31-35 THE OPERAND FOR THIS ELEMENT
OPERAND 2 INDICATES A WORD OF DATA
WORD 2:
IF THE OPERAND IS 2 THIS WORD CONTAINS THE DATA
IF THIS IS NOT A DATA OPERATOR THEN THE LEFT AND
RIGHT HALVES OF THIS WORD POINT TO THE TWO OPERANDS
THE CONTENTS OF THE HALF WORD IS THE RIGHT HALF
OF THE FIRST WORD OF THE BLOCK POINTED
TO. THUS THE LEFT HALF OF THE FIRST WORD COMBINED
WITH ONE OF THESE HALF WORDS IS THE FIRST WORD
OF THE BLOCK POINTED TO AND CAN BE FOUND BY SEARCHING
EACH FIXUP ALSO HAS A HEADER BLOCK. THIS BLOCK CONTAINS THE
FOLLOWING INFORMATION:
WORD 1:
BITS 0-17 0
BITS 18-21 44
BITS 22-35 THE HEAD NUMBER OF THIS FIXUP
WORD 2:
BITS 0-17 A COUNT OF THE NUMBER OF UNDEFINED
GLOBALS REMAINING IN THIS FIXUP
BITS 18-35 A HALF WORD POINTER OF THE
SAME TYPE FOUND IN OTHER ELEMENTS POINTING
TO THE FIRST ELEMENT OF POLISH
WHICH WILL BE THE STORE OPERATOR
THE REQUESTS FOR THE GLOBAL SYMBOLS NEEDED BY THE FIXUP ARE
ENTERED AS FOLLOWS:
WORD 1:
BITS 0-4 04
BITS 5-35 RADIX 50 FOR THE NAME OF THE SYMBOL
(NOTE THIS IS JUST A STANDARD GLOBAL REQUEST)
WORD 2:
BITS 0-4 44 (THIS IDENTIFIES IT AS "ADITIVE TYPE"
AND BIT 4 INDICATES POLISH)
BITS 5-17 THE HEAD NUMBER OF THE FIXUP
(THIS GIVES ENOUGH INFORMATION TO FIND THE HEADER
BLOCK AND UPDATE THE COUNT WHEN THE REQUEST IS
SATISFIED)
BITS 18-35 A HALF WORD POINTER TO THE ELEMENT OF THE
FIXUP INTO WHICH THE VALUE OF
THE SYMBOL SHOULD BE STORED
>
IFN FAILSW!B11SW,<
;POLISH FIXUPS <BLOCK TYPE 11>
PDLOV: SKIPE POLSW ;PDL OV ARE WE DOING POLISH?
JRST COMPOL ;YES
ERROR ,</PUSHDOWN OVERFLOW#/>
JRST LD2
COMPOL: ERROR ,</POLISH TOO COMPLEX#/>
JRST LD2
;READ A HALF WORD AT A TIME
RDHLF: TLON N,HSW ;WHICH HALF
JRST NORD
PUSHJ P,RWORD ;GET A NEW ONE
TLZ N,HSW ;SET TO READ OTEHR HALF
MOVEM W,SVHWD ;SAVE IT
HLRZS W ;GET LEFT HALF
POPJ P, ;AND RETURN
NORD: HRRZ W,SVHWD ;GET RIGHT HALF
POPJ P, ;AND RETURN
POLFIX: MOVE D,[IOWD PPDL,PPDB] ;SET UP THE POLISH PUSHDOWN LIST
MOVEI V,100 ;IN CASE OF ON OPERATORS
MOVEM V,SVSAT
SETOM POLSW ;WE ARE DOING POLISH
TLO N,HSW ;FIX TO READ A WORD THE FIRST TIME
SETOM GLBCNT ;NUMBER OF GLOBALS IN THIS FIXUP
SETOM OPNUM ;NUMBER OF OPERANDS AND OPERATORS THIS FIXUP
PUSH D,[15] ;FAKE OPERATOR SO STORE WILL NOT HACK
RPOL: PUSHJ P,RDHLF ;GET A HLAF WORD
TRNE W,400000 ;IS IT A STORE OP?
JRST STOROP ;YES, DO IT
IFN WFWSW,<CAIN W,15
JRST [PUSHJ P,RDHLF ;THIS TRICK FOR VARIABLES
ADD W,VARREL ;HOPE SOMEONE HAS DONE
HRRZ C,W ;A BLOCK TYPE 13
JRST HLFOP]>
CAIGE W,3 ;0,1,2 ARE OPERANDS
JRST OPND
CAILE W,14 ;14 IS HIGHEST OPERATOR
JRST LOAD4A ;ILL FORMAT
PUSH D,W ;SAVE OPERATOR IN STACK
MOVE V,DESTB-3(W) ;GET NUMBER OF OPERANDS NEEDED
MOVEM V,SVSAT ;ALSO SAVE IT
JRST RPOL ;BACK FOR MORE
;HANDLE OPERANDS. THIS GETS COMPLICATED BECAUSE OF THE PRESENCE OF
;GLOBAL REQUESTS
OPND: MOVE A,W ;GET THE OPERAND TYPE HERE
PUSHJ P,RDHLF ;THIS IS AT LEAST PART OF THE OPERAND
MOVE C,W ;GET IT INTO C
JUMPE A,HLFOP ;0 IS HALF-WORD OPERAND
PUSHJ P,RDHLF ;NEED FULL WORD, GET SECOND HALF
HRL C,W ;GET HALF IN RIGHT PLACE
MOVSS C ;WELL ALMOST RIGHT
SOJE A,HLFOP ;1 IS FULL WORD, 2 IS GLOBAL REQUEST
PUSHJ P,SDEF ;SEE IF IT IS ALREADY DEFINED
JRST [MOVE C,2(A) ;YES, WE WIN
JRST HLFOP]
AOSN GLBCNT ;NO, INCREMENT NUMBER OF GLOBALS THIS FIXUP
AOS HEADNM ;INCREMENT FIXUP NUMBER IF FIRST GLOBAL
AOS W,OPNUM ;GET AN OPERAND NUMBER
LSH W,5 ;SPACE FOR TYPE
IORI W,2 ;TYPE 2 IS GLOBAL
HRL W,HEADNM ;GET FIXUP NUMBER
PUSHJ P,SYM3X2 ;AND PUT INTO UDEFINED AREA ALONG WITH NAME
MOVE C,W ;ALSO PUT THAT PART OF THE FIXUP IN
PUSHJ P,SYM3X2
SKIPA A,[400000] ;SET UP GLOBAL FLAG
HLFOP: MOVEI A,0 ;VALUE OPERAND FLAG
HLFOP1: SOJL V,CSAT ;ENOUGH OPERANDS SEEN?
PUSH D,C ;NO, SAVE VALUE(OR GLOBAL NAME)
HRLI A,400000 ;PUT IN A VALUE MARKER
PUSH D,A ;TO THE STACK
JRST RPOL ;GET MORE POLISH
;HAVE ENOUGH OPERANDS FOR THE CURRENT OPERATOR
CSAT: HRRZS A ;KEEP ONLY THE GLOBAL-VALUE HALF
SKIPN SVSAT ;IS IT UNARY
JRST UNOP ;YES, NO NEED TO GET 2ND OPERAND
HRL A,(D) ;GET GLOBAL VALUE MARKER FOR 2ND OP
POP D,W
POP D,W ;VALUE OR GLOBAL NAME
UNOP: POP D,V ;OPERATOR
JUMPN A,GLOB ;IF EITHER IS A GLOBAL HANDLE SPECIALLY
XCT OPTAB-3(V) ;IF BOTH VALUES JUST XCT
MOVE C,W ;GET THE CURRENT VALUE
SETSAT: SKIPG V,(D) ;IS THERE A VALUE IN THE STACK
MOVE V,-2(D) ;YES, THIS MUST BE THE OPERATOR
MOVE V,DESTB-3(V) ;GET NUMBER OF OPERANDS NEEDED
MOVEM V,SVSAT ;SAVE IT HERE
SKIPG (D) ;WAS THERE AN OPERAND
SUBI V,1 ;HAVE 1 OPERAND ALREADY
JRST HLFOP1 ;GO SEE WHAT WE SHOULD DO NOW
;HANDLE GLOBALS
GLOB: TRNE A,-1 ;IS IT IN RIGHT HALF
JRST TLHG ;NO, NEED TO PUT THIS VALUE INTO THE FIXUP LIST
PUSH P,W ;SAVE FOR A WHILE
MOVE W,C ;THE VALUE
AOS C,OPNUM ;GET AN OPERAND NUMBER
LSH C,5 ;AND PUT IN TYPE
IORI C,2 ;VALUE TYPE
HRL C,HEADNM ;THE FIXUP NUMBER
PUSHJ P,SYM3X2
POP P,W ;RETRIEVE THE OTHER VALUE
TLHG: SKIPE SVSAT ;WAS THIS A UNARY OPERATOR
TLNE A,-1 ;WAS THERE A GLOBAL IN LEFT HALF
JRST GLSET
PUSH P,C ;SAVE THE FIRST OPERAND
AOS C,OPNUM ;SEE ABOVE
LSH C,5
IORI C,2
HRL C,HEADNM
PUSHJ P,SYM3X2
MOVE W,C
POP P,C
GLSET: EXCH C,W ;GET THEM IN THE OTHER ORDER
HRL W,C ;SET UP THE OPERATOR LINK
AOS C,OPNUM
LSH C,5 ;SPACE FOR THYPE
IOR C,V ;THE OPERATOR
HRL C,HEADNM
PUSHJ P,SYM3X2 ;INTO THE UNDEF LIST
MOVEI A,400000 ;SET UP AS A GLOBAL VALUE
JRST SETSAT ;AND SET UP FOR NEXT OPERATOR
;FINALLY WE GET TO STORE THIS MESS
STOROP: MOVE T,-2(D) ;THIS SHOULD BE THE FAKE OPERATOR
CAIE T,15 ;IS IT
JRST LOAD4A ;NO, ILL FORMAT
HRRZ T,(D) ;GET THE VALUE TYPE
JUMPN T,GLSTR ;AND TREAT GLOBALS SPECIAL
MOVE A,W ;THE TYPE OF STORE OPERATOR
CAIGE A,-3
PUSHJ P,FSYMT
PUSHJ P,RDHLF ;GET THE ADDRESS
MOVE V,W ;SET UP FOR FIXUPS
POP D,W ;GET THE VALUE
POP D,W ;AFTER IGNORING THE FLAG
PUSHJ P,@STRTAB+6(A) ;CALL THE CORRECT FIXUP ROUTINE
COMSTR: SETZM POLSW ;ALL DONE WITH POLISH
IFN REENT,<PUSHJ P,RESTRX>
MOVE T,OPNUM ;CHECK ON SIZES
MOVE V,HEADNM
CAIG V,477777
CAILE T,17777
JRST COMPOL ;TOO BIG, GIVE ERROR
PUSHJ P,RWORD ;THIS SHOULD GET US OUT (I.E RUN OUT COUNT)
JRST LOAD4A ;IF NOT, SOMETHING IS WRONG
STRTAB: EXP ALSYM,LFSYM,RHSYM,ALSTR,LOCDLF,SYM4A,FAKESY
GLSTR: MOVE A,W
CAIGE A,-3
PUSHJ P,FSYMT
PUSHJ P,RDHLF ;GET THE STORE LOCATION
MOVEI A,23(A)
POP D,V ;GET VALUE
POP D,V
HRLM V,W ;SET UP STORAGE ELEMENT
AOS C,OPNUM
LSH C,5
IOR C,A
HRL C,HEADNM
PUSHJ P,SYM3X2
MOVE W,C ;NOW SET UP THE HEADER
AOS V,GLBCNT ;WHICH HAS NUMBER OF GLOBALS
HRLM V,W
HRRZ C,HEADNM
PUSHJ P,SYM3X2
JRST COMSTR ;AND FINISH
ALSTR1: IFN L,<CAMGE V,RINITL
POPJ P,>
IFN REENT,<CAMGE V,HVAL1
SKIPA X,LOWX
MOVE X,HIGHX>
IFN MONLOD,<PUSHJ P,DICHK>
HRRZ T,@X
MOVEM W,@X ;FULL WORD FIXUPS
MOVE V,T
ALSTR: JUMPN V,ALSTR1
POPJ P,
DESTB: EXP 1,1,1,1,1,1,1,1,0,0,100
OPTAB: ADD W,C
SUB W,C
IMUL W,C
IDIV W,C
AND W,C
IOR W,C
LSH W,(C)
XOR W,C
SETCM W,C
MOVN W,C
REPEAT 7,<JRST STRSAT>
FSYMT: PUSHJ P,RDHLF ;FIRST HALF OF SYMBOL
HRL V,W
PUSHJ P,RDHLF
HRR V,W
PUSH D,A ;SAVE STORE TYPE
PUSHJ P,RDHLF ;GET BLOCK NAME
HRL C,W
PUSHJ P,RDHLF
HRR C,W
TLO C,140000 ;MAKE BLOCK NAME
PUSHJ P,SDEF ;FIND IT
CAMN A,B
JRST FNOLOC ;MUST NOT BE LOADING LOCALS
FSLP: LDB C,[POINT 32,-1(A),35] ;GET NAME
CAMN C,V
JRST FNDSYM
SUB A,SE3
CAME A,B ;ALL DONE?
JRST FSLP ;NO
FNOLOC: POP D,A
MOVEI A,0 ;SET FOR A FAKE FIXUP
AOS (P)
POPJ P,
FNDSYM: MOVEI W,(A) ;LOC OF SYMBOL
SUB W,HISTRT
POP D,A
AOS (P)
POPJ P,
LFSYM: ADD V,HISTRT
HRLM W,(V)
MOVSI D,400000 ;LEFT HALF
JRST COMSFX
RHSYM: ADD V,HISTRT
HRRM W,(V)
MOVSI D,200000
JRST COMSFX
FAKESY: POPJ P, ;IGNORE
POLSAT: PUSH P,C ;SAVE SYMBOL
MOVE C,V ;POINTER
PUSHJ P,SREQ ;GO FIND IT
SKIPA
JRST LOAD4A ;SOMETHING IS ROTTEN IN DENMARK
MOVEM W,2(A) ;STORE VALUE
HLRZS C ;NOW FIND HEADER
PUSHJ P,SREQ
SKIPA
JRST LOAD4A
HRLZI V,-1 ;AND DECREMENT COUNT
ADDB V,2(A)
TLNN V,-1 ;IS IT NOW 0
JRST PALSAT ;YES, GO DO POLISH
POP P,C ;RESTORE SYMBOL
JRST SYM2W1 ;AND RETURN
PALSAT: PUSH P,W ;SAVE VALUE
MOVEM C,HDSAV ;SAVE THE HEADER NUMBER
MOVE D,[IOWD PPDL,PPDB] ;SET UP A PDL
MOVE C,V ;GET THE POINTER
HRL C,HDSAV ;AND THE FIXUP NUMBER
PUSHJ P,REMSYM ;REMOVE THE HEADER FORM EXISTANCE
PUSHJ P,SREQ ;GO FINE THE NEXT LINK
SKIPA
JRST LOAD4A ;LOSE
ANDI C,37 ;GET OPERATOR TYPE
HRRZ V,2(A) ;PLACE TO STORE
PUSH D,V
PUSH D,[XWD 400000,0]
PUSH D,C ;THIS HAD BETTER BE A STORE OR WE ARE IN TROUBLE
HLRZ C,2(A) ;GET POINTER TO POLISH CHAIN
PSAT1: PUSHJ P,REMSYM ;REMOVE SYMBOL
PSAT2: HRL C,HDSAV ;GET FIXUP NUMBER
PUSHJ P,SREQ ;LOOK FOR IT
SKIPA
JRST LOAD4A
ANDI C,37 ;THE OPERATOR NUMBER
CAIN C,2 ;IS IT AN OPERAND?
JRST PSOPD ;YES, GO PROCESS
PUSH D,C ;YES STORE IT
SKIPN DESTB-3(C) ;IS IT UNARY
JRST PSUNOP ;YES
HLRZ C,2(A) ;GET FIRST OPERAND
HRLI C,600000 ;AND MARK AS VALUE
PUSH D,C
PSUNOP: HRRZ C,2(A) ;OTHER OPERAND
JRST PSAT1 ;AND AWAY WE GO
PSOPD: MOVE C,2(A) ;THIS IS A VALUE
PUSHJ P,REMSYM ;GET RID OF THAT PART OF THE CHAIN
PSOPD1: SKIPG V,(D) ;IS THERE A VALUE IN THE STACK
JRST PSOPD2 ;YES, TAKE GOOD CARE OF IT
COMOP: POP D,V ;NO, GET THAT OPERATOR OUT OF THERE
XCT OPTAB-3(V) ;AND DO IT
MOVE C,W ;GET RESULT IN RIGHT PLACE
JRST PSOPD1 ;AND TRY FOR MORE
PSOPD2: TLNE V,200000 ;IS IT A POINTER
JRST DBLOP ;YES, NEEDS MORE WORK
MOVE W,C ;NO, ONE WE HAVE IS FIRST OPND, GET IT INTO W
POP D,C ;VALUE POINTER
POP D,C ;2ND OPERAND INTO C
JRST COMOP ;GO PROCESS OPERATOR
DBLOP: EXCH C,(D) ;PUT VALUE IN STACK AND RETRIEV POINTER
PUSH D,[XWD 400000,0] ;MARK AS VALUE
JRST PSAT2 ;AND GO LOOK FOR MORE TROUBLE
IFN FAILSW,<
;BLOCK TYPE 12 LINK
LINK: PUSHJ P,PRWORD ;GET TWO WORDS
JUMPLE C,ENDLNK ;THIS IS AN END OF LINK WORD
CAILE C,20 ;IS IT IN RANGE?
JRST LOAD4A
HRRZ V,W ;GET THE ADDRESS
IFN REENT,<
CAMGE V,HVAL1 ;CHECK HISEG ADDRESS
SKIPA X,LOWX ;LOW SEGMENT
MOVE X,HIGHX ;HIGH SEGMENT BASE
>;IF REENT
IFN MONLOD,<PUSHJ P,DICHK>
HRRZ W,LINKTB(C) ;GET CURRENT LINK
IFN L,< CAML V,RINITL ;LOSE>
HRRM W,@X ;PUT INTO CORE
HRRM V,LINKTB(C) ;SAVE LINK FOR NEXT ONE
IFN REENT,<
PUSHJ P,RESTRX ;RESTORE X
>;IF REENT
JRST LINK ;GO BACK FOR MORE
ENDLNK: MOVNS C ;GET ENTRY NUMBER
JUMPE C,LOAD4A ;0 IS A LOSER
CAILE C,20 ;CHECK RANGE
JRST LOAD4A
HRLM W,LINKTB(C) ;SAVE END OF LINK INFO
JRST LINK ;MORE
> ;END OF IFN FAILSW
STRSAT: MOVE W,C ;GET VALUE TO STORE IN W
MOVE C,V ;GET OPERATOR HERE
POP D,V
POP D,V ;GET ADDRESS TO STORE
PUSHJ P,@STRTAB-15(C)
IFN REENT,<PUSHJ P,RESTRX>
POP P,W ;RESTORE THINGS
POP P,C
JRST SYM2W1
ALSYM: ADD V,HISTRT
MOVEM W,(V)
MOVSI D,600000
>
LIST ;END OF FAILSW CODE
IFN FAILSW!B11SW!WFWSW,<
COMSFX: IFN REENT,<PUSHJ P,SYMFX1
JRST RESTRX>
IFE REENT,<JRST SYMFX1>>
SUBTTL LIBRARY INDEX (BLOCK TYPE 14)
COMMENT * DIRECT ACCESS LIBRARY SEARCH MODE
INDEX WRITTEN BY FUDGE2.SEE DIDAL DOC (100-540-001-00)
DESIGN AND CODING BY D.M.NIXON JUL-AUG 1970
*
IFN DIDAL,<
INDEX8: POP P,LSTBLK ;SET UP LSTBLK FOR NEXT PROG
PUSHJ P,WORD ;READ FIRST WORD
HLRZ A,W ;BLOCK TYPE ONLY
CAIE A,14 ;IS IT AN INDEX?
JRST INDEXE ;NO, ERROR
JRST INDEX9 ;DON'T SET FLAG AGAIN
INDEX0: TRO F,XFLG ;SIGNAL INDEX IN CORE
MOVEI A,1 ;START ON BLOCK 1 (DSK)
HRROM A,LSTBLK ;BUT INDICATE AN INDEX
MOVE A,ILD1 ;INPUT DEVICE
DEVCHR A,
TLNE A,DTABIT ;IS IT A DTA?
TRO F,DTAFLG ;YES
INDEX9: MOVEI A,AUX+2 ;AUX BUFFER
HRLI A,4400 ;MAKE BYTE POINTER
MOVEM A,ABUF1 ;AND SAVE IT
HRL A,BUFR1 ;INPUT BUFFER
BLT A,AUX+201 ;STORE BLOCK
TRO F,LSTLOD ;AND FAKE LAST PROG READ
INDEX1: ILDB T,ABUF1
JUMPL T,INDEX3 ;END OF BLOCK IF NEGATIVE
HRRZS T ;WORD COUNT ONLY
INDEX2: ILDB C,ABUF1 ;GET NEXT SYMBOL
TLO C,040000 ;
PUSHJ P,SREQ ;SEARCH FOR IT
SOJA T,INDEX4 ;REQUEST MATCHES
SOJG T,INDEX2 ;KEEP TRYING
ILDB T,ABUF1 ;GET POINTER WORD
TRZN F,LSTLOD ;WAS LAST PROG LOADED?
JRST INDEX1 ;NO
TRNN F,DTAFLG ;ALWAYS SAVE IF DTA???
SKIPL LSTBLK ;SKIP IF LAST BLOCK WAS AN INDEX
MOVEM T,LSTBLK ;SAVE POINTER FOR CALCULATIONS
JRST INDEX1 ;GET NEXT PROG
INDEX4: ADDM T,ABUF1
ILDB A,ABUF1
PUSH P,A ;SAVE THIS BLOCK
TROE F,LSTLOD ;DID WE LOAD LAST PROG?
JRST [SKIPGE LSTBLK ;WAS LAST BLOCK AN INDEX?
JRST NXTBLK ;YES, SO GET NEXT ONE
MOVEM A,LSTBLK
JRST LOAD1] ;NEXT PROG IS ADJACENT
HRRZ T,LSTBLK ;GET LAST BLOCK NUMBER
CAIN T,(A) ;IN THIS BLOCK?
JRST THSBLK ;YES
NXTNDX: TRNE F,DTAFLG ;DIFFERENT TEST FOR DTA
JRST NXTDTA ;CHECK IF NEXT BUFFER IN CORE
CAIN T,-1(A) ;NEXT BLOCK?
JRST NXTBLK ;YES,JUST DO INPUT
INDEX5: USETI 1,(A) ;SET ON BLOCK
WAIT 1, ;LET I/O FINISH
MOVSI C,(1B0) ;CLEAR RING USE BIT IF ON
HRRZ T,BUFR
IORM C,BUFR ;SET UNUSED RING BIT (HELP OUT MONITOR)
SKIPL (T)
JRST NXTBLK ;ALL DONE NOW
ANDCAM C,(T) ;CLEAR USE BIT
HRRZ T,(T) ;GET NEXT BUFFER
JRST .-4 ;LOOP
NXTDTA: WAIT 1, ;LET I/O RUN TO COMPLETION
HRRZ T,BUFR ;GET POINTER TO CURRENT BUFFER
HLRZ T,1(T) ;FIRST DATA WORD IS LINK
CAIE T,(A) ;IS IT BLOCK WE WANT?
JRST INDEX5 ;NO
NXTBLK: IN 1,
JRST NEWBLK ;IT IS NOW
JRST WORD3 ;EOF OR ERROR
NEWBLK: MOVE A,(P) ;GET CURRENT BLOCK
JUMPL A,INDEX8 ;JUST READ AN INDEX
HLRZS A ;GET WORD COUNT
JRST INDEX6 ;WORD COUNT WILL BE CORRECT
THSBLK: SUB A,LSTBLK ;GET WORD DIFFERENCE
MOVSS A ;INTO RIGHT HALF
INDEX6: ADDM A,BUFR1
MOVNS A
ADDM A,BUFR2
INDEX7: POP P,LSTBLK ;STORE THIS AS LAST BLOCK READ
JRST LOAD1
INDEX3: HRRE A,T ;GET BLOCK # OF NEXT INDEX
JUMPL A,EOF ;FINISHED IF -1
PUSH P,T ;STACK THIS BLOCK
HRRZ T,LSTBLK ;GET LAST BLOCK
JRST NXTNDX ;CHECK IF NEXT BUFFER IN CORE
INDEX: PUSHJ P,WORD2 ;READ FIRST WORD OF NEXT BUFFER
INDEXE: TRZE F,XFLG ;INDEX IN CORE?
TTCALL 3,[ASCIZ /LIBRARY INDEX INCONSISTENT - CONTINUING
/] ;WARNING MESSAGE
JRST LOAD1A+1 ;AND CONTINUE
>
IFE DIDAL,<INDEX0:
INDEX: PUSHJ P,WORD2 ;READ FIRST WORD OF NEXT BUFFER
JRST LOAD1A+1>
SUBTTL ALGOL OWN BLOCK (TYPE 15)
IFN ALGSW,<
ALGBLK: SKIPE OWNLNG ;FIRST TIME THIS PROG?
JRST ALGB1 ;NO, JUST CHAINED SYMBOL INFO
PUSHJ P,RWORD ;READ 3RD WORD
IFN REENT,<TLNE F,HIPROG ;LOADING INTO HIGH SEGMENT?
EXCH X,LOWX ;YES, BUT OWN AREAS ARE IN LOW SEG>
HLRZ V,W ;GET START OF OWN BLOCK
IFN REENT,<TLNE F,HIPROG ;LOADING INTO HIGH SEGMENT?
HRRZ V,LOWR ;YES, BUT PUT OWN AREAS IN LOW SEG>
MOVEI C,(W) ;GET LENGTH OF OWN BLOCK
MOVEM C,OWNLNG ;SAVE IT TO FIX RELOC AT END
PUSHJ P,ALGB2 ;FIX AND CHECK PROG BREAK
MOVEI W,(V) ;GET CURRENT OWN ADDRESS
EXCH W,%OWN ;SAVE FOR NEXT TIME
MOVEM W,@X ;STORE LAST OWN ADDRESS IN LEFT HALF
HRLM C,@X ;LENGTH IN LEFT HALF
IFN REENT,<TLNE F,HIPROG ;HI-SEG?
EXCH X,LOWX ;YES, RESTORE X TO POINT TO HIGH SEG>
ALGB1: PUSHJ P,RWORD ;GET DATA WORD
HLRZ V,W ;GET ADDRESS TO FIX UP
ADD W,%OWN ;ADD IN ADDRESS OF OWN BLOCK
PUSHJ P,SYM4A ;FIX UP CHAINED REQUEST
JRST ALGB1 ;LOOP TIL DONE
ALGB2: ADDI H,(W) ;FIX PROG BREAK
IFN REENT,<CAML H,HILOW
MOVEM H,HILOW ;HIGHEST LOW CODE LOADED>
CAILE H,1(S) ;SKIP IF SUFFICIENT CORE AVAILABLE
IFN EXPAND,<JRST [PUSHJ P,XPAND>
JRST FULLC
IFN EXPAND,< JRST .+1]>
POPJ P,
>
SUBTTL SAIL BLOCK TYPES 16 AND 17
COMMENT * BLOCK TYPE 16 AND 17. SIXBIT FOR FIL,PPN,DEV
IN THE BLOCK. SEARCH TABLE FOR ALREADY REQUESTED. IF NOT
ENTER REQUEST. ORIGINAL CODE BY DCS REWRITTEN BY WFW*
IFN SAILSW,<
LDPRG: MOVEI D,PRGFLS-1 ;SET UP SOMETHING WE CAN SEARCH WITH
MOVE W,PRGPNT ;AND CURRENT POINTER
PUSHJ P,LDSAV ;GO ENTER (WILL NOT RETURN IF RUNS OUT)
MOVEM D,PRGPNT
JRST LDPRG ;BACK FOR MORE
LDLIB: MOVEI D,LIBFLS-1
MOVE W,LIBPNT
PUSHJ P,LDSAV
MOVEM D,LIBPNT
JRST LDLIB ;LOOKS JUST LIKE THE LAST ONE, DOESN'T IT
LDSAV: HRLI D,-RELLEN-1 ;GET AOBJN SET UP
MOVEM W,LODPN2# ;SAV IT
PUSHJ P,PRWORD ;GET FILE,PPN
MOVE A,W ;SAVE ONE
PUSHJ P,RWORD ;AND DEVICE
FILSR: CAMN D,LODPN2
JRST FENT ;HAVE GOTTEN THERE, ENTER FILE
CAME C,PRGFIL(D) ;CHECK FOR MATCH
JRST NOMT ;NOT FILE
CAME A,PRGPPN(D)
JRST NOMT ;NO PPN
CAME W,PRGDEV(D)
NOMT: AOBJN D,FILSR ;AND NOT DEVICE SHOULD ALWAYS JUMP
MOVE D,LODPN2
POPJ P, ;JUST RETURN CURRENT POINTER
FENT: MOVE D,LODPN2 ;ENTER IT
AOBJP D,WRONG ;THAT IS IF NOT TOO MANY
MOVEM C,PRGFIL-1(D) ;HAVE ALREADY INDEXED
MOVEM A,PRGPPN-1(D) ;HENCE THE -1
MOVEM W,PRGDEV-1(D)
POPJ P,
WRONG: ERROR ,</TOO MANY DEMANDED FILES#/>
JRST LD2
>
SUBTTL COMMON ALLOCATION (BLOCK TYPE 20)
COMMENT * THIS BLOCK CONSISTS OF WORD PAIRS (SAME AS TYPE 2)
FIRST WORD IS RADIX50 04,SYMBOL
SECOND WORD IS 0,,COMMON LENGTH
COMMON NAME MUST BE GLOBAL AND UNIQUE
IF NOT ALREADY DEFINED LOADER DEFINES SYMBOL AND ALLOCATES
SPACE. IF DEFINED LOADER CHECK FOR TRYING TO INCREASE COMMON
SIZE, AND GIVES ERROR IF SO
NOTE... COMMON BLOCKS MUST COME DEFORE ANY DATA BLOCKS
IE. AFTER BLOCKS 4,6,3 BUT BEFORE 1,2,37,..5
*
IFN K,<COMML==LOAD4A>
IFE K,<
COMML: PUSHJ P,PRWORD ;GET WORD PAIR
TLO C,400000 ;TURN IT INTO 44,SYMBOL (FOR FORTRAN)
TLO N,F4SW ;INHIBITS MATCH WITH 04,SYMBOL
PUSHJ P,SDEF ;SEE IF ALREADY DEFINED
JRST COMMLD ;YES, JUST CHECK SIZE
TLZ N,F4SW ;CLEAR AGAIN
IFN REENT,<TLNN F,HIPROG ;LOADING INTO HIGH SEGMENT?
JRST .+3 ;NO
EXCH R,LOWR ;YES, BUT COMMON ALWAYS GOES TO LOW SEG
EXCH X,LOWX>
HRL W,R ;CURRENT RELOCATION
ADDI R,(W) ;BUMP RELOCATION
MOVS W,W ;LENGTH,,START
PUSH P,W ;STORE COMMON VALUE
HRRZS W ;NORMAL SYMBOL ADDRESS
TLZ C,400000 ;BACK TO 04,SYMBOL
PUSHJ P,SYM1B ;DEFINE IT
POP P,W ;RESTORE VALUE
TLO C,400000 ;AND COMMON SYMBOL
PUSHJ P,SYM1B ;AND STORE IT ALSO
IFN REENT,<TLNN F,HIPROG ;LOADING INTO HIGH SEGMENT?
JRST COMML ;NO
EXCH R,LOWR ;YES, RESTORE RELOCATION TO HIGH
EXCH X,LOWX>
JRST COMML ;GET NEXT SYMBOL
COMMLD: TLZ N,F4SW ;CLEAR AGAIN
HLRZ C,2(A) ;PICK UP DEFINITION
CAMLE W,C ;CHECK SIZE
JRST ILC ;ILLEGAL
JRST COMML ;TRY NEXT
>
SUBTTL SPARSE DATA (BLOCK TYPE 21)
COMMENT *
THIS BLOCK IS SIMILAR TO TYPE 1 DATA
THE DATA WORDS ARE
COUNT,,LOCATION
DATA WORDS (COUNT NUMBER OF TIMES)
COUNT,,LOCATION
DATA WORDS
ETC.
*
SPDATA: PUSHJ P,RWORD ;READ BLOCK ORIGIN
SKIPGE W
PUSHJ P,PROGS ;SYMBOLIC IF 36 BITS
HLRZ C,W ;GET SUB BLOCK COUNT IN C
HRRZS W ;CLEAR IT
HRRZ V,C ;AND IN V (LENGTH WE NEED)
SPDTO: ADD V,W ;COMPUTE NEW PROG. BREAK
IFN REENT,<TLNN F,HIPROG
JRST SPDTLW ;NOT HIGH SEGMENT
SPDT3: CAMGE W,HVAL1 ;CHECK TO SEE IF IN TOP SEG
JRST LOWSPD
MOVE T,.JBREL ;CHECK FOR OVERFLOW ON HIGH
CAIL T,@X
JRST SPDT2
PUSHJ P,HIEXP
JRST FULLC
JRST SPDT3>
IFN MONLOD,<TLNN N,DISW ;LOADING TO DISK?
JRST SPDTLW ;NO, GO CHECK NEW BREAK
CAMG H,V ;NEW BREAK?
MOVE H,V ;YES, UPDATE
JRST SPDT2 ;NO NEED TO CHECK FOR ROOM>
IFN REENT,<
LOWSPD: SUB V,HIGHX ;RELOC FOR PROPER
ADD V,LOWX ;LOADING OF LOW SEQMENT
SUB W,HIGHX
ADD W,LOWX
>
SPDTLW: MOVEI T,@X
CAMG H,T ;COMPARE WITH PREV. PROG. BREAK
MOVE H,T
TLNE F,FULLSW
JRST FULLC ;NO ERROR MESSAGE
IFN REENT,<CAML H,HVAL1
JRST COROVL ;WE HAVE OVERFLOWED THE LOW SEGMENT
CAMLE T,HILOW
MOVEM T,HILOW ;HIGHEST LOW CODE LOADED INTO>
CAILE H,1(S) ; SKIP IF SUFFICIENT CORE AVAILABLE
IFN EXPAND,<JRST [PUSHJ P,XPAND>
JRST FULLC
IFN REENT,< TLNE F,HIPROG
SUBI W,2000 ;HISEG LOADING LOW SEG>
IFN EXPAND,< JRST .-1]>
SPDT2: MOVE V,W
SPDT1: PUSHJ P,RWORD ;READ DATA WORD
IFN L,<CAML V,RINITL ;CHECK FOR BAD STORE>
IFN MONLOD,<PUSHJ P,DICHK ;MAKE SURE ADDRESS IS IN CORE>
MOVEM W,@X ;STORE DATA WORD IN PROG. AT LLC
IFN MONLOD,<TLO N,WOSW ;SET SWITCH TO WRITE OUT BUFFER>
SOJLE C,SPDATA ;SUB-BLOCK RUN OUT, REFILL IT
AOJA V,SPDT1 ;ADD ONE TO LOADER LOC. COUNTER
SUBTTL TENEX ASSIGNMENT (BLOCK TYPE 100)
IFN TENEX,<
;IMPLEMENT THE SPECIAL BLOCK 100 REQUEST FOR ASSIGNING
; AND INCREMENTING OF EXTERNALS
ASGSYM: PUSHJ P,RWORD ;GET FIRST WORD
MOVE V,W ;SAVE SYM2
PUSHJ P,PRWORD ;GET SECOND AND THIRD WORDS
TLO C,040000 ;MAKE INTO GLOBAL
PUSHJ P,SDEF ;SEE IF DEFINED
JRST ASGSY1 ;OK. IT IS
PUSH P,PRQ ;IT'S NOT, GENERATE ERROR COMMENT
PUSHJ P,PRNAME
JSP A,ERRPT7
SIXBIT /UNDEFINED ASSIGN IN #/
ASGSY0: PUSHJ P,RWORD ;SHOULD RETURN TO LOAD1
JRST ASGSY0 ;LOOP UNTIL IT DOES
ASGSY1: ADD W,2(A) ;INCREMENT VALUE
EXCH W,2(A) ;SAVE NEW, GET OLD
MOVE C,V ;GET SYM2
TLO C,040000 ;MAKE INTO GLOBAL
PUSHJ P,SYMPTQ ;AND CONTINUE AS FOR GLOBAL DEF
JRST ASGSY0 ;AND RETURN
>
SUBTTL SYMBOL TABLE SEARCH SUBROUTINES
; ENTERED WITH SYMBOL IN C
; RETURN IS WITH POINTER IN A IF MATCHING SYMBOL FOUND
; OTHERWISE, A SKIP ON RETURN OCCURS
SREQ: JUMPGE S,CPOPJ1 ;JUMP IF NO UNDEF. SYMBOLS
SKIPA A,S ;LOAD REQUEST SEARCH POINTER
SDEF: MOVE A,B ;LOAD DEF. SYMBOL SEARCH POINTER
SDEF1: CAMN C,1(A)
POPJ P, ;SYMBOLS MATCH, RETURN
IFE K,< TLNE N,F4SW ;ARE WE IN FORTRAN?
JRST SDEF2 ;YES,JUST TRY NEXT SYMBOL>
TLC C,400000 ;MIGHT BE SUPPRESSED INTERNAL
CAMN C,1(A) ;WAS IT?
JRST [TLC C,400000 ;BACK AS IT WAS
IORM C,1(A) ;YES, SO ENSURE IT'S SUPPRESSED
POPJ P,] ;EXIT WITH SYMBOL FOUND
TLC C,400000 ;NO, TRY NEXT SYMBOL
SDEF2: ADD A,SE3
JUMPL A,SDEF1
IFE K,< JRST CPOPJ1 ;SYMBOL NOT FOUND SKIPS ON RETURN>
IFN K,<
CPOPJ1: AOS (P)
POPJ P,>
SUBTTL RELOCATION AND BLOCK INPUT
PRWORD: PUSHJ P,RWORD ;READ A WORD PAIR
MOVE C,W ;LOAD C WITH FIRST DATA WORD
TRNE E,377777 ;TEST FOR END OF BLOCK
JRST RWORD1 ;INPUT SECOND WORD OF PAIR
MOVEI W,0 ;NO SECOND WORD, ASSUME ZERO
POPJ P,
RWORD: TRNN E,377777 ;TEST FOR END OF BLOCK
JRST LOAD1 ;RETURN TO LOAD THE NEXT BLOCK
RWORD1: AOBJN E,RWORD2 ;JUMP IF DATA WORD NEXT
PUSHJ P,WORD ;READ CONTROL WORD
MOVE Q,W ;DON'T COUNT RELOCATION WORDS
HRLI E,-22 ;SET RELOCATION WORD BYTE COUNT
RWORD2: PUSHJ P,WORD ;READ INPUT WORD
JUMPGE Q,RWORD3 ;TEST LH RELOCATION BIT
TRNN F,TWOFL ;POSSIBLE TWO SEGMENTS?
JRST RWORD5 ;NO
MOVSS W
PUSHJ P,CHECK ;USE CORRECT RELOCATION
HRRI W,@R
MOVSS W
JRST RWORD3 ;AND TEST RIGHT HALF
RWORD5: HRLZ T,R
ADD W,T ;LH RELOCATION
RWORD3: TLNN Q,200000 ;TEST RH RELOCATION BIT
JRST RWORD4 ;NOT RELOCATABLE
TRNE F,TWOFL ;POSSIBLE TWO SEGMENTS?
PUSHJ P,CHECK ;USE CORRECT RELOCATION
HRRI W,@R ;RH RELOCATION
RWORD4: LSH Q,2
POPJ P,
CHECK: MOVE T,HVAL1 ;START OF HISEGMENT
CAIG T,NEGOFF(W) ;IN HISEG?
JRST [CAILE W,(W) ;IS ADDRESS BELOW HISEG START?
JRST [MOVNS T ;YES
ADDI T,(W) ;THEREFORE WORRY ABOUT CARRY
HRR W,T ;INTO LEFT HALF
POPJ P,]
SUBI W,(T) ;IN HISEG, REMOVE OFSET
POPJ P,]
HRRI W,@LOWR ;USE LOW SEG RELOC
JRST CPOPJ1 ;SKIP RETURN
SUBTTL PRINT STORAGE MAP SUBROUTINE
PRMAP: TRZ F,LOCAFL ;ASSUME LOCAL SYMBOLS SUPPRESSED
CAIE D,1 ;IF /1M PRINT LOCAL SYMBOLS
CAMN D,[-7] ;TEST FOR /-1M ALSO
TRO F,LOCAFL ;YES,TURN ON FLAG
JUMPL D,PRTMAP-1 ;JUMP IF /-M OR /-1M
TRO N,ENDMAP ;ELSE SET DEFERRED MAP FLAG
POPJ P,
TRZ N,ENDMAP ;CLEAR DELAYED MAP FLAG
PRTMAP: PUSHJ P,FSCN1 ;LOAD OTHER FILES FIRST
IFN SPCHN,<TRZ N,MAPSUP ;SET MAP NOT SUPPRESSED
SKIPE CHNACB ;TEST FOR SPECIAL CHAINING
TRNN N,CHNMAP ;TEST FOR ROOT MAP ALREADY PRINTED
JRST PRMP0A ; SKIP IF NO TO EITHER QUESTION
PUSHJ P,CRLFLF ;SPACE TWO LINE AND FORCE TTY OUTPUT
TLZ F,FCONSW ;SUPPRESS TTY OUTPUT
ERROR 0,</******************** !/> ;PRINT SEPARATOR
TLO F,FCONSW ;FORCE TTY OUTPUT AGAIN
ERROR 0,</LINK !/> ;PRINT LINK NUMBER
MOVE W,LINKNR ;GET CURRENT LINK NUMBER
PUSHJ P,RCNUMW ;PRINT IT IN DECIMAL
TLZ F,FCONSW ;SUPPRESS TTY OUTPUT
ERROR 0,</ ********************!/> ;PRINT SEPARATOR
PUSHJ P,CRLF ;PUT BLANK LINE ON MAP FILE ONLY
PUSHJ P,CRLF ; DITTO
TLO F,FCONSW ;FORCE TTY OUTPUT AGAIN
PUSHJ P,CRLF
JRST .+2 ;SKIP NEXT CRLF CALL
PRMP0A: >
PUSHJ P,CRLFLF ;START NEW PAGE
HRRZ W,R
IFN REENT,<CAIG W,.JBDA ;LOADED INTO LOW SEGMENT
JRST NOLOW ;DON'T PRINT IF NOTHING THERE>
PUSHJ P,PRNUM0
IFE REENT,<ERROR 7,<?IS THE PROGRAM BREAK@?>>
IFN REENT,<ERROR 7,<?IS THE LOW SEGMENT BREAK@?>
PUSHJ P,CRLF ;CR-LF ON ALL BUT TTY
NOLOW: MOVE W,HVAL ;HISEG BREAK
CAMG W,HVAL1 ;HAS IT CHANGED
JRST NOHIGH ;NO HI-SEGMENT
TLO F,FCONSW ;FORCE OUT HI-SEG BREAK ALSO
PUSHJ P,PRNUM0
ERROR 7,<?IS THE HIGH SEGMENT BREAK@?>
PUSHJ P,CRLF
NOHIGH:>
IFN SPCHN,<SKIPE CHNACB ;TEST FOR SPECIAL CHAINING
TRNN N,CHNMAP ;TEST FOR ROOT MAP ALREADY PRINTED
JRST .+2 ; NO TO EITHER QUESTION, FALL THRU
JRST NOADDR ; ELSE SKIP HEADING OUTPUT>
IFE NAMESW,< MOVE W,DTOUT ;OUTPUT NAME >
IFN NAMESW,< SKIPN W,DTOUT
MOVE W,CURNAM ;USE PROGRAM NAME>
JUMPE W,.+3 ;DON'T PRINT IF NOT THERE
PUSHJ P,PWORD
PUSHJ P,SPACES ;SOME SPACES
;HERE TO DECODE AND PRINT VERSION NUMBER IN .JBVER
;USES T,V,D,Q
IFN MONLOD,<TLNE N,DISW ;LOADING TO DISK?
MOVE X,XRES ;YES, SETUP X >
IFE L,<
SKIPN V,.JBVER(X) ;GET VERSION NUMBER
JRST NOVER ;WASN'T ONE
ROT V,3 ;PUT USER BITS LAST
MOVEI T,"%" ;TO INDICATE VERSION
PUSHJ P,TYPE2 ;OUTPUT CHARACTER
MOVEI Q,3 ;3 BYTES IN MAJOR FIELD
PUSHJ P,SHFTL ;SHIFT LEFT, SKIP 0 BYTES
JRST .+3 ;NO MAJOR FIELD
MOVEI D,"0" ;CONVERT TO ASCII 0-8
PUSHJ P,OUTVER ;OUTPUT IT
MOVEI Q,2 ;2 DIGITS IN MINOR FIELD
PUSHJ P,SHFTL
JRST .+3 ;NO MINOR FIELD
MOVEI D,"@" ;ALPHABETICAL
PUSHJ P,OUTVER
MOVEI T,"(" ;EDIT NUMBER IN PARENS
TLNN V,-1 ;SEE IF GIVEN
JRST NOEDIT ;NO
PUSHJ P,TYPE2 ;YES
MOVEI Q,6
PUSHJ P,SHFTL ;LEFT JUSTIFY
JRST .+3 ;NEVER GETS HERE
MOVEI D,"0" ;0-7 AGAIN
PUSHJ P,OUTVER
MOVEI T,")" ;CLOSE VERSION
PUSHJ P,TYPE2
NOEDIT: MOVEI T,"-" ;USER FIELD?
JUMPE V,.+4 ;NO
PUSHJ P,TYPE2 ;YES
MOVEI Q,1 ;ONLY ONE DIGIT
PUSHJ P,OUTVER ;OUTPUT IT
PUSHJ P,SPACES ;SOME SPACES
NOVER:>;END OF IFE L
ERROR 0,<?STORAGE MAP!?>
PUSHJ P,SPACES ;SOME SPACES
PUSH P,N
PUSH P,E
MOVE N,[POINT 6,DBUF] ;INITIALIZE DATE POINTER
MSTIME Q, ;GET THE TIME
IDIVI Q,^D60*^D1000
IDIVI Q,^D60
PUSH P,A ;SAVE MINUTES
PUSHJ P,OTOD1 ;STORE HOURS
POP P,Q ;GET MINUTES
PUSHJ P,OTOD ;STORE MINUTES
DATE E, ;GET DATE
IDIVI E,^D31 ;GET DAY
ADDI Q,1
PUSHJ P,OTOD ;STORE DAY
IDIVI E,^D12 ;GET MONTH
ROT Q,-1 ;DIV BY 2
HRR A,DTAB(Q) ;GET MNEMONIC
TLNN Q,400000
HLR A,DTAB(Q) ;OTHER SIDE
HRRM A,DBUF+1 ;STORE IT
MOVEI Q,^D64(E) ;GET YEAR
MOVE N,[POINT 6,DBUF+2]
PUSHJ P,OTOD ;STORE IT
POP P,E
POP P,N
PUSHJ P,DBUF1
PUSHJ P,CRLF
SKIPN STADDR ;PRINT STARTING ADDRESS
JRST NOADDR ;NO ADDRESS SEEN
ERROR 0,</STARTING ADDRESS !/>
PUSHJ P,SP1
MOVE W,STADDR ;GET ST. ADDR.
PUSHJ P,PRNUM0 ;PRINT IT
IFN NAMESW,<
PUSHJ P,SP1
MOVE W,[SIXBIT / PROG /]
PUSHJ P,PWORD
MOVE W,CURNAM ;PROG NAME
PUSHJ P,PWORD
PUSHJ P,SP1
MOVE W,ERRPT6 ;SIXBIT / FILE /
PUSHJ P,PWORD
MOVE W,PRGNAM ;FILE NAME
PUSHJ P,PWORD>
NOADDR: IFN REENT,<
HRRZ A,HVAL1 ;GET INITIAL HIGH START
ADDI A,.JBHDA ;ADD IN OFFSET
IFN SPCHN,<HRL A,BEGOV ;ASSUME NON-ROOT OVERLAY
SKIPE CHNACB ;TEST FOR SPECIAL CHAINING
TRNN N,CHNMAP ;TEST FOR ROOT-MAP PRINTED
;ASSUMPTION CORRECT IF YES TO BOTH
; SKIP NEXT INSTRUCTION IF SO >
HRLI A,.JBDA ;LOW START
MOVSM A,SVBRKS ;INITIAL BREAKS>
HLRE A,B
MOVNS A
ADDI A,(B)
PRMAP1: SUBI A,2
IFN REENT!L,<SKIPN C,1(A) ;LOAD SYMBOL SKIP IF REAL SYMBOL
JRST PRMAP4 ;IGNORE ZERO NAME(TWOSEG BREAKS)>
IFE REENT!L,<MOVE C,1(A) ;LOAD SYMBOL>
TLNN C,300000 ;TEST FOR LOCAL SYMBOL
JRST .+4 ;GLOBAL (NOT LOCAL ANYWAY)
TRNN F,LOCAFL ;PRINT LOCAL SYMBOLS?
JRST PRMAP4 ;IGNORE LOCAL SYMBOLS
TLC C,040000 ;MAKE IT LOOK LIKE INTERN
TLNE C,040000
JRST PRMP1A
IFN SPCHN,<TRZ N,MAPSUP ;SET MAP NOT SUPPRESSED
SKIPE CHNACB ;TEST FOR SPECIAL CHAINING
TRNN N,CHNMAP ;TEST FOR ROOT MAP PRINTED
JRST PRMP0C ; NO TO EITHER TEST, SKIP AROUND
HRRZ T,2(A) ;GET STARTING ADDRESS
CAML T,BEGOV ;TEST FOR BELOW OVERLAY
JRST PRMP0C ;NO,JUMP
TRO N,MAPSUP ;SUPPRESS IF RE-PRINTING ROOT
JRST PRMAP4 ; & SKIP TO NEXT SYMBOL
PRMP0C:>
PUSHJ P,CRLF
PUSHJ P,CRLF
JRST PRMP1B
PRMP1A:
IFN SPCHN,<TRNE N,MAPSUP ;TEST FOR SUPPRESSED MAP
JRST PRMAP4 ; YES, SKIP THIS SYMBOL>
PUSHJ P,TAB
MOVEI T,40 ;SPACE FOR OPEN GLOBAL
TLNE C,100000 ;LOCAL?
MOVEI T,47 ;YES, TYPE '
TLNE C,400000 ;HALF KILLED TO DDT?
ADDI T,3 ;YES, TYPE # FOR GLOBAL, * FOR LOCAL
PUSHJ P,TYPE2 ;PRINT CHARACTER
PRMP1B: PUSHJ P,PRNAM1 ;PRINT SYMBOL AND VALUE
TLNE C,040000
JRST PRMAP4 ;GLOBAL SYMBOL
HLRE C,W ;POINTER TO NEXT PROG. NAME
HRRZS W ;SO WE ONLY HAVE THE HALF WE WANT
PRMAP7: JUMPL C,PRMP7A
IFN REENT,<SKIPN 1(B) ;IS IT A ZERO SYMBOL
JRST [MOVE C,B ;SET UP C
JRST PRMAP2] ;AND GO
HRRZ T,HVAL ;GET TO OF HI PART
CAML W,HVAL1 ;IS PROGRAM START UP THERE??
JRST PRMAP6 ;YES
HRRZ T,HILOW ;GET HIGHEST LOCATION LOADED IN LOW
SUBI T,(X) ;REMOVE OFFSET
CAIE T,(W) ;EQUAL IF ZERO LENGTH PROG>
HRRZ T,R ;GET LOW, HERE ON LAST PROG
JRST PRMAP6 ;GO
PRMP7A: ADDI C,2(A) ;POINTER TO NEXT PROGRAM NAME
PRMAP2: IFN REENT,<
SKIPE 1(C) ;THIS IS A TWO SEG FILE
JRST PRMP2A ;NO
MOVE T,2(C) ;GET PROG BREAKS
TLNN T,-1 ;IF NO HIGH STUFF YET
HLL T,SVBRKS ;FAKE IT
SUB T,SVBRKS ;SUBTRACT LAST BREAKS
HRRZ W,T ;LOW BREAK
PUSH P,T ;SAVE T
PUSHJ P,PRNUM ;PRINT IT
POP P,T ;RESTORE
HLRZ W,T ;GET HIGH BREAK
JUMPE W,.+3 ;SKIP IF NO HIGH CODE
PUSHJ P,TAB ;AND TAB
PUSHJ P,PRNUM
MOVE T,2(C)
CAMN C,B ;EQUAL IF LAST PROG
SETZ C, ;SIGNAL END
TLNN T,-1
HLL T,SVBRKS
IFE TENEX,<CAMN T,SVBRKS ;ZERO LENGTH IF EQUAL
JRST PRMP6A ;SEE IF LIST ALL ON>
MOVEM T,SVBRKS ;SAVE FOR NEXT TIME
JRST PRMAP3 ;AND CONTINUE
PRMP2A:>
HRRZ T,(C) ;GET ITS STARTING ADRESS
PRMAP6: SUBM T,W ;SUBTRACT ORIGIN TO GET LENGTH
PUSHJ P,PRNUM ;PRINT PROGRAM LENGTH
PUSHJ P,CRLF
PRMP6A:
IFE TENEX,<TLNN N,ALLFLG ;SKIP IF LIST ALL MODE IS ON
TRNE W,777777 ;SKIP IF ZERO LENGTH PROGRAM>
IFN TENEX,<TLNE N,ALLFLG ;SKIP IF LIST ALL MODE IS ON>
JRST PRMAP3
HLRE C,2(A) ;GET BACK CORRECT LOCATION IF 0 LENGTH
JUMPE C,PRMAP5 ;JUMP IF LAST PROGRAM
ADDI C,2(A) ;IN CASE WE SKIPPED SOME PROGRAMS
SKIPA A,C ;SKIP GLOBALS, ZERO LENGTH PROG.
PRMAP3: PUSHJ P,CRLF
PRMAP4: CAILE A,(B) ;TEST FOR END OF SYMBOL TABLE
JRST PRMAP1
PRMAP5: PUSHJ P,CRLF ;GIVE AN XTRA CR-LF
IFN SPCHN,<SKIPN CHNACB ;TEST FOR SPECIAL CHAINING
JRST PMS ;NO, SKIP
TRO N,CHNMAP ;YES, SHOW ROOT-PHASE PRINTED
JRST PMS4 ; & EXIT>
IFN TENEX,<JRST PMS ;GO PRINT UNDEFINED GLOBALS>
SUBTTL LIST UNDEFINED AND MULTIPLY DEFINED GLOBALS
;LIST UNDEFINED GLOBALS
PMSQ:
IFN TENEX,<SETZM NLSTGL ;ALLOW UNDEFINED GLOBALS TO LIST>
PMS: PUSHJ P,FSCN1 ;LOAD FILES FIRST
JUMPGE S,PMS4 ;JUMP IF NO UNDEFINED GLOBALS
IFN TENEX,<SKIPE NLSTGL ;HAVE UNDEF GLOBALS BEEN LISTED?
POPJ P,0 ;YES
SETOM NLSTGL ;PREVENT IT FROM HAPPENING AGAIN>
PUSHJ P,FCRLF ;START THE MESSAGE
HLRE W,S ;COMPUTE NO. OF UNDEF. GLOBALS
MOVMS W
LSH W,-1 ;<LENGTH OF LIST>/2
PUSHJ P,RCNUMW ;PRINT AS DECIMAL NUMBER
ERROR 7,</UNDEFINED GLOBAL(S)@/>
MOVE A,S ;LOAD UNDEF. POINTER
PMS2: SKIPL W,1(A)
TLNN W,40000
JRST PMS2A
PUSHJ P,FCRLF
PUSHJ P,PRNAM0 ;PRINT SYMBOL AND POINTER
PMS2A: ADD A,SE3
JUMPL A,PMS2
PUSHJ P,CRLF ;NEW LINE
;LIST NUMBER OF MULTIPLY DEFINED GLOBALS
PMS3: SKIPN W,MDG ;ANY MULTIPLY DEFINED GLOBALS
JRST PMS4 ;NO, EXCELSIOR
PUSHJ P,FCRLF ;ROOM AT THE TOP
PUSHJ P,RCNUMW ;NUMBER OF MULTIPLES IN DECIMAL
ERROR 7,<?MULTIPLY DEFINED GLOBAL(S)@?>
PMS4: TLNE N,AUXSWE ;AUXILIARY OUTPUT DEVICE?
OUTPUT 2, ;INSURE A COMPLETE BUFFER
CPOPJ: POPJ P, ;RETURN
SUBTTL ENTER FILE ON AUXILIARY OUTPUT DEVICE
IAD2:
IFN SYMDSW,<TRNE F,LSYMFL ;ALREADY USING AUX DEV FOR LOCAL SYMBOLS?
POPJ P, ;YES, GIVE ERROR RETURN>
PUSH P,A ;SAVE A FOR RETURN
MOVE A,LD5C1 ;GET AUX. DEV.
DEVCHR A, ;GET DEVCHR
TLNN A,4 ;DOES IT HAVE A DIRECTORY
JRST [SKIPN A,DTOUT ;USE OUTPUT NAME IF GIVEN
JRST IAD2C ;FIND A DEFAULT
JRST IAD2A] ;JUST DO ENTER
MOVE A,DTOUT ;GET OUTPUT NAME
CAME A,[SIXBIT /JOBDAT/] ;DON'T USE JOBDAT
JUMPN A,IAD2A ;USE ANYTHING NON-ZERO
MOVSI A,(SIXBIT /DSK/) ;DEFAULT DEVICE
CAMN A,LD5C1 ;IS IT AUX. DEV.
JRST IAD2C ;YES LEAVE WELL ALONE
CLOSE 2, ;CLOSE OLD AUX. DEV.
MOVEM A,LD5C1 ;SET IT TO DSK
OPEN 2,OPEN2 ;OPEN IT FOR DSK
JRST IMD4 ;FAILED
IAD2C: IFN NAMESW,<
SKIPN A,CURNAM ;USE PROG NAME>
MOVSI A,(SIXBIT /MAP/) ;AN UNLIKELY NAME
MOVEM A,DTOUT ;SO ENTER WILL NOT FAIL
IAD2A:
IFN SPCHN,<MOVE A,CHNOUT+1 ;GET SP CHAIN DEV.
CAMN A,LD5C1 ;IS IT SAME AS AUX. DEV.
SKIPN CHNACB ;YES, ARE WE DOING SP CHAIN?
JRST IAD2B ;NO, PHEW!
DEVCHR A, ;IS IT REALLY A DSK?
TLNE A,DSKBIT
JRST IAD2B ;YES, LEAVE ALONE
RELEAS 2, ;NO, CLEAR OUT ANY RESIDUAL FILE
JRST IMD4 ;AWAY BEFORE SOMETHING TERRIBLE HAPPENS
IAD2B:>
POP P,A ;RECOVER A
SETZM DTOUT+2 ;CLEAR PROTECTION (LEVEL D)
ENTER 2,DTOUT ;WRITE FILE NAME IN DIRECTORY
JRST IMD3 ;NO MORE DIRECTORY SPACE
AOS (P) ;SKIP RETURN IF SUCCESSFUL
POPJ P,
IMD3: ERROR ,</ERROR WRITING FILE@/>
TLZ N,AUXSWE!AUXSWI ;CLEAR AUX DEVICE SWITCHES
JRST LD2
IMD4: MOVE P,PDLPT ;RESTORE STACK
AOBJN P,.+1 ;BUT SAVE RETURN ADDRESS
TLZ N,AUXSWE!AUXSWI ;NO AUX.DEV.NOW
ERROR ,</NO MAP DEVICE@/>
JRST PRMAP5 ;CONTINUE TO LOAD
SUBTTL MONLOD - DISK IMAGE MONITOR LOADER CODE
IFN MONLOD,<
DIOPEN: PUSH P,A ;SAVE AC A
PUSH P,H ;SAVE AC H
PUSH P,N ;SAVE 3 ACC'S
PUSH P,X ;IN A BLOCK
MOVE A,ILD1 ;GET DEVICE
MOVE N,A ;SPARE COPY
DEVCHR A, ;SEE WHAT IT IS
TLNN A,DSKBIT ;IS IT SOME SORT OF DSK?
SKIPA N,DIN1 ;NO, GET THE DEFAULT DEVICE (DSK)
MOVEM N,DIN1 ;YES, OBEY USER AND USE IT
MOVE A,[3,,N] ;SET UP BLOCK
DSKCHR A, ;WAS DSK, BUT SEE IF GENERIC "DSK"
JRST USEDSK ;NO POINT GOING THROUGH WITH THIS
TLNE A,(7B17) ;IS IT GENERIC DSK?
JRST USEDSK ;NO USE WHATS IN DIN1
SETOB N,H ;REQUEST FIRST F/S
MOVE A,[3,,N] ;SET UP A AGAIN
JOBSTR A, ;GET FIRST F/S IN SEARCH LIST
JRST USEDSK ;LEVEL C
JUMPL H,USEDSK ;SWP BIT SET
TLNN H,200000 ;IS NO CREATE BIT SET?
JRST USEDSK ;NO, GENERIC 'DSK' WILL USE THIS F/S
DSKCHR A, ;GET FIRST 3 ARGS
JRST USEDSK ;SHOULD NEVER HAPPEN BUT !!
TLNN A,740200 ;RHB!OFL!HWP!SWP!NNA SET?
CAIGE X,DALLOC ;ENOUGH SPACE?
JRST USEDSK ;CANNOT USE FASTEST F/S
MOVEM N,DIN1 ;USE F/S RATHER THAN 'DSK'
MOVEM N,GENERI ;SAVE F/S INCASE ENTER FAILS
USEDSK: POP P,X ;RESTORE ACC'S
POP P,N
MOVE H,(P) ;RESET H
USDSK2: OPEN 4,OPEN4 ;OPEN DEVICE 'DSK', MODE 16
HALT .-1 ;ERROR, NON-INTELIGENT INDICATION
MOVEM W,DIOUT1+1 ;STORE EXTENSION 'XPN'
MOVE A,DTIN ;GET FILE NAME
MOVEM A,DIOUT1 ;STORE IN 'LOOKUP-ENTER' BLOCK
SETZM DIOUT1+2 ;CLEAR PARAMETERS TO BE SUPPLIED BY MONITOR
SETZM DIOUT1+3 ;ALWAYS USE THIS JOB'S PROJ-PROG NUMBER
SETZM DIOUT+1 ;SAME AGAIN
MOVE A,[17,,11] ;STATES WORD
GETTAB A, ;GET IT
JRST .+3 ;FAILED, NOT LEVEL D FOR SURE
TLNE A,(7B9) ;TEST FOR LEVEL D
TDZA A,A ;YES, THIS IS LEVEL D
MOVEI A,2 ;NOT LEVEL D
ENTER 4,DIOUT(A) ;CREATE OR SUPERCEDE SAVE FILE
JRST ENTFAI ;ERROR, TRY DSK
JUMPE A,LEVELD ;JUMP IF LEVEL D
HRRZ A,.JBREL ;GET CURRENT SIZE
CAIL A,2000 ;NEED AT LEAST 2K
CAILE H,-2000(S) ;CHECK FOR 1K FREE
IFN EXPAND,<JRST [PUSHJ P,XPAND ;GET 1K OF ZEROS, WILL SAVE TIME LATER IN ANYCASE>
JRST FULLC ;NO MORE CORE
IFN EXPAND,< JRST .-1]> ;OK, TRY AGAIN
MOVSI A,-2000 ;FORM IOWD
HRRI A,(H) ;TO 1K OF BLANK
MOVEM A,LOLIST ;STORE IOWD
SETZM LOLIST+1 ;TERMINATE LIST
MOVEI A,DALLOC/10 ;PREALLOCATE THE HARD WAY
OUTPUT 4,LOLIST ;BY DOING OUTPUTS
SOJG A,.-1
MOVEI A,2 ;STILL NOT LEVEL D
LEVELD: CLOSE 4,4 ;WIPE OUT THE OLD FILE IF ONE EXISTS
LOOKUP 4,DIOUT(A) ;LOOKUP FOLLOWED BY ENTER ENABLES UPDATING
HALT .-1 ;ERROR
JUMPN A,ALLOK ;NOT LEVEL D
MOVE A,DIOUT+.RBALC ;SEE WHAT WE GOT
SKIPE GENERI ;IF NOT GENERIC DSK FIRST F/S
CAIL A,DALLOC ;WAS IT ENOUGH
TDZA A,A ;YES, BUT STILL LEVEL D
JRST TRYAGN ;NO JUST USE DSK
ALLOK: ENTER 4,DIOUT(A) ;FILE CAN BE BOTH READ AND WRITTEN
HALT .-1 ;ERROR
MOVE A,H ;GET HIGHEST ADDRESS LOADED SO FAR
SUBI A,-177(X) ;SIZE OF LOW BUFFER MUST BE AN
ANDI A,777600 ;INTEGRAL MULTIPLE OF BLOCK SIZE
MOVEM A,HIRES ;SET UP POINTER FOR LOCATION CHECKING
ADDI A,(X) ;GET ADDRESS OF START OF IMAGE BUFFER
HRRM A,HILIST ;HILIST IS IOWD FOR FILE WINDOW BUFFER
SUBI A,(X) ;A=SIZE OF LOW IMAGE BUFFER (RESIDENT)
MOVN A,A ;GET MINUS BUFFER SIZE
HRLM A,LOLIST ;SET UP WORD COUNT IN LOW IOWD
HRRM X,LOLIST ;ADDRESS FIELD OF IOWD
MOVEM X,XRES ;SAVE OFFSET OF RESIDENT PORTION
MOVE H,HILIST ;GET HIGH BUFFER ADDRESS
MOVNI A,DISIZE ;NEGATIVE SIZE OF FILE WINDOW
HRLM A,HILIST ;SET UP WORD COUNT OF HIGH IOWD
MOVE A,HIRES ;GET HIGHEST ADDRESS IN RESIDENT PORTION+1
LSH A,-7 ;CONVERT TO BLOCK NUMBER
MOVEM A,RESBLK ;STORE NUMBER OF BLOCKS IN RESIDENT PORTION
ADDI H,DISIZE ;H=TOP OF DISK WINDOW BUFFER
MOVEM H,DIEND ;LAST LOCATION IN WINDOW BUFFER+1
CAILE H,1(S) ;SKIP IF SUFFICIENT CORE AVAILABLE
IFN EXPAND,<JRST [PUSHJ P,XPAND>
JRST FULLC
IFN EXPAND,< JRST .-1]>
SOS HILIST ;IOWD POINTS TO BUFFER-1
SOS LOLIST ; "
SETZM HILIST+1 ;TERMINATOR SHOULD BE ZERO
SETZM LOLIST+1 ; "
TLO N,DISW ;SET DISK IMAGE IN USE FLAG
PUSH P,V ;SAVE CURRENT LOADER LOCATION COUNTER
MOVE V,HIRES ;GET FIRST ADDRESS NOT IN RESIDENT BUFFER
PUSHJ P,DICHK2 ;CALL TO INITIALIZE THE BUFFER HANDLER
POP P,V ;RESTORE V
POP P,H ;RESTORE H
SUBI H,(X) ;CONVERT TO ABSOLUTE FOR DISK IMAGE LOAD
POP P,A ;RESTORE AC A
JRST LD2D ;RETURN TO CONTINUE SCAN
DICHK: TLNN N,DISW ;ARE WE DOING A DISK IMAGE LOAD?
POPJ P, ;NO, ALL IS OK
HRRZ X,V ;LEFT HALF OF AC 'V' MAY CONTAIN FLAGS
CAMGE X,HIRES ;SKIP IF ADDRESS NOT IN RESIDENT PORTION
JRST DICHK1 ;ADDRESS IN AC X IS IN RESIDENT PORTION
CAMGE X,DILADD ;SKIP IF ADDRESS ABOVE CORRENT LOWEST WINDOW ADDRESS
JRST DICHK2 ;ADDRESS IS NOT RESIDENT
CAML X,DIHADD ;SKIP IF ADDRESS IS RESIDENT
JRST DICHK2 ;NOT RESIDENT
SKIPA X,XCUR ;GET OFFSET OF CURRENT WINDOW
DICHK1: MOVE X,XRES ;GET OFFSET OF RESIDENT LOW PORTION
POPJ P,
DICHK2: PUSH P,A ;GET ADDRESS IN AC 'V' INTO CORE
PUSH P,Q ;GET SOME AC'S TO WORK WITH
TLZE N,WOSW ;CURRENT BUFFER TO BE WRITTEN OUT?
PUSHJ P,DICHK3 ;YES, GO DO SO
MOVE A,HILIST ;GET ADDRESS-1 OF DISK IMAGE BUFFER
ADDI A,1 ;A NOW POINTS TO START OF BUFFER
SETZM (A) ;CLEAR THE FIRST WORD OF THE BUFFER
MOVS Q,A ;MOVE ADDRESS TO SOURCE FOR BLT
HRRI Q,1(A) ;SOURCE+1 TO DESTINATION
ADDI A,DISIZE ;SET A TO TOP OF BUFFER+1
BLT Q,-1(A) ;CLEAR THE BUFFER
HRRZ Q,V ;GET THE ADDRESS WE'RE LOOKING FOR
SUB Q,HIRES ;ACCOUNT FOR RESIDENT PART
IDIVI Q,DISIZE ;A=Q+1
IMULI Q,DISIZE ;FIRST ADDRESS IN WINDOW
IDIVI Q,^D128 ;GET BLOCK NUMBER (-NUMBER IN RESIDENT PORTION)
ADD Q,RESBLK ;NUMBER OF RESIDENT BLOCKS
USETI 4,1(Q) ;BLOCK 0 DOES NOT EXIST
STATZ 4,20000 ;END OF FILE?
JRST DICHK4 ;YES, NO SENSE READING
INPUT 4,HILIST ;TRY TO FILL THE DISK IMAGE BUFFER
STATZ 4,740000 ;CHECK FOR ERRORS, DON'T CARE ABOUT EOF
HALT .-3 ;TRY AGAIN ON CONTINUE
DICHK4: MOVEM Q,CURSET ;LEAVE BLOCK NUMBER AROUND FOR LATER USETO
IMULI Q,^D128 ;GET ADDRESS OF FIRST WORD IN CURRENT BUFFER
MOVEM Q,DILADD ;STORE FOR FUTURE COMPARES
ADDI Q,DISIZE ;ADD SIZE OF DISK IMAGE BUFFER
MOVEM Q,DIHADD ;STORE HIGH CURRENT ADDRESS+1
HRRZ Q,HILIST ;GET WINDOW ADDRESS-1
ADDI Q,1 ;NOW EQUAL TO ADDRESS
SUB Q,DILADD ;COMPUTE LOADER CURRENT WINDOW OFFSET
HRLI Q,V ;SET UP INDEX REGISTER FOR STORED X
MOVEM Q,XCUR ;STORE CURRENT OFFSET
POP P,Q ;RESTORE
POP P,A ;RESTORE
MOVE X,XCUR ;SET UP LOADER OFFSET REGISTER
POPJ P, ;RETURN, ADDRESS IN 'V' NOW RESIDENT
DICHK3: MOVE Q,CURSET ;GET BLOCK NUMBER FOR USETO
USETO 4,1(Q) ;THERE IS NO BLOCK 0
OUTPUT 4,HILIST ;WRITE OUT HE IMAGE
STATZ 4,740000 ;ERROR?
HALT .-3 ;YES, TRY AGAIN ON CONTINUE
POPJ P, ;RETURN
SIZCHK: EXCH A,DIEND ;SAVE A, GET END OF BUFFER ADDRESS
AOS (P) ;DEFAULT IS SKIP RETURN
CAIGE A,(S) ;IS SYMBOL TABLE ENCROACHING ON BUFFER?
AOS (P) ;NO,DON'T EXPAND CORE
EXCH A,DIEND ;RESTORE BOTH A AND DIEND
POPJ P, ;RETURN
DISYM: PUSH P,V ;SAVE CURRENT ADDRESS
MOVE V,A ;GET ADDRESS WERE LOOGING FOR
PUSHJ P,DICHK ;MAKE SURE IT IS IN CORE
POP P,V ;RESTORE V
POPJ P, ;RETURN
DIOVER: MOVE X,XRES ;CLEAN UP XPN FILE AND EXIT
MOVE A,.JBFF(X) ;GET LAST ADDRESS LOADER
SUB A,DILADD ;SUBTRACT CURRENT LOW ADDRESS
ADDI A,^D128 ;ROUND OFF TO NEAREST BLOCK SIZE
ANDI A,777600 ;FOR IOWD
MOVNS A ;NEGATE
HRLM A,HILIST ;PUT IN WINDOW IOWD
PUSHJ P,DICHK3 ;OUTPUT THE SYMBOL TABLE
USETO 4,1 ;SET UP TO OUTPUT RESIDENT PART
OUTPUT 4,LOLIST ;AND DO SO
STATZ 4,740000 ;ERROR CHECK
HALT .-3 ;IF ERROR TRY AGAIN
CLOSE 4,
EXIT
TRYAGN: PUSH P,DIOUT1 ;SAVE NAME
SETZM DIOUT1
RENAME 4,DIOUT(A) ;GET RID OF FILE
POP P,DIOUT1 ;RESTORE NAME
ENTFAI: SKIPN GENERI ;GENERIC DSK?
HALT . ;NO, JUST GIVE UP
MOVSI A,'DSK' ;TRY WITH JUST DSK
MOVEM A,DIN1
SETZM GENERI
SETZM DIOUT+.RBALC
JRST USDSK2 ;TRY AGAIN
>
SUBTTL PRINT SUBROUTINES
;PRINT THE 6 DIGIT OCTAL ADDRESS IN W
; ACCUMULATORS USED: D,T,V
PRNAM0: MOVE C,1(A) ;LOAD SYMBOL
PRNAM1: MOVE W,2(A) ;LOAD VALUE
PRNAM: PUSHJ P,PRNAME
PRNUM:
TRNN F,TTYFL
PUSHJ P,SP1
PUSHJ P,SP1
PRNUM0: MOVE V,PRNUM2 ;LOAD BYTE POINTER TO RH. OF W
MOVNI D,6 ;LOAD CHAR. COUNT
PRNUM1: ILDB T,V ;LOAD DIGIT TO BE OUTPUT
ADDI T,60 ;CONVERT FROM BINARY TO ASCII
PUSHJ P,TYPE2
AOJL D,PRNUM1 ;JUMP IF MORE DIGITS REMAIN
POPJ P,
PRNUM2: POINT 3,W,17 ;BYTE POINTER FOR OCTAL CONVERSION OF W
;HERE TO LEFT JUSTIFY V, COUNT IN IN Q
LSH V,3 ;STEP LEFT ONE
SHFTL: TLNN V,700000 ;LEFT JUSTIFIED?
SOJGE Q,.-2 ;NO SHIFT IF STILL IN FIELD
JUMPLE Q,CPOPJ ;NOTHING IN THIS FIELD
JRST CPOPJ1 ;SKIP RTETURN, AT LEAST ONE CHAR
;HERE TO OUTPUT CHARACTERS LEFT AFTER SHIFTING LEFT
OUTVER: SETZ T, ;CLEAR T TO REMOVE JUNK
LSHC T,3 ;SHIFT IN FROM T
ADDI T,(D) ;EITHER "0" OR "A"
PUSHJ P,TYPE2 ;PRINT
SOJG Q,OUTVER ;MORE?
POPJ P, ;NO
IFN NAMESW,<
LDNAM: MOVE T,[POINT 6,CURNAM] ;POINTER
SETZM CURNAM ;CLEAR OLD NAME INCASE FEWER CHARS. IN NEW
MOVNI D,6 ;SET COUNT
TLZ W,740000 ;REMOVE CODE BITS
SETNAM: IDIVI W,50 ;CONVERT FROM RAD 50
HRLM C,(P)
AOJGE D,.+2
PUSHJ P,SETNAM
HLRZ C,(P)
JUMPE C,INAM
ADDI C,17
CAILE C,31
ADDI C,7
CAIG C,72 ;REMOVE SPECIAL CHARS. (. $ %)
IDPB C,T
INAM: POPJ P, >
;SPECIAL ENTRY POINT WITH NUMBER IN REGISTER W, FALLS THRU TO RCNUM
RCNUMW: MOVE Q,W ;COPY NUMBER INTO PROPER REGISTER
;YE OLDE RECURSIVE NUMBER PRINTER
;PRINTS Q, WITH LEADING ZEROES SUPPRESSED; USES A AND T
RCNUM: IDIVI Q,12 ;RADIX DECIMAL
ADDI A,"0"
HRLM A,(P)
JUMPE Q,.+2
PUSHJ P,RCNUM
HLRZ T,(P)
JRST TYPE2
SPACES: PUSHJ P,SP1
SP1: PUSHJ P,SPACE
SPACE: MOVEI T,40
JRST TYPE2
; ACCUMULATORS USED: Q,T,D
PWORD: MOVNI Q,6 ;SET CHARACTER COUNT TO SIX
PWORD1: MOVE D,LSTPT ;ENTER HERE WITH Q PRESET
PWORD2: ILDB T,D ;LOAD NEXT CHAR. TO BE OUTPUT
PUSHJ P,TYPE ;OUTPUT CHARACTER
AOJL Q,PWORD2
POPJ P,
;TYPEOUT SUBROUTINE - THE CHARACTER SUPPLIED IN T IS CONVERTED TO ASCII
;AND IS OUTPUT ON THE CONSOLE AND/OR THE SPECIFIED LOADER MAP OUTPUT
;DEVICE
CRLFLF: PUSHJ P,CRLF
FCRLF: TLO F,FCONSW ;INSURE TTY OUTPUT
CRLF: SETZM TABCNT ;RESET TAB COUNT ON NEW LINE
MOVEI T,15 ;CARRIAGE RETURN LINE FEED
PUSHJ P,TYPE2
TRCA T,7 ;CR.XOR.7=LF
TYPE: MOVEI T,40(T) ;CONVERT SIXBIT TO ASCII
TYPE2: TLNN N,AUXSWI ;IS THER AN AUXILIARY DEVICE?
JRST TYPE3 ;NO, DONT OUTPUT TO IT
TLOE N,AUXSWE ;IS AUX. DEV. ENTERED?
JRST TYPE2A ; YES, SKIP
PUSHJ P,IAD2 ;NOPE, DO SO!
JRST TYPE3 ;ERROR RETURN
TYPE2A: SOSG ABUF2 ;SPACE LEFT IN BUFFER?
OUTPUT 2, ;CREATE A NEW BUFFER
IDPB T,ABUF1 ;DEPOSIT CHARACTER
IFN RPGSW,<
TRNN F,NOTTTY ;IF TTY IS ANOTHER DEVICE
;DON'T OUTPUT TO IT>
TLNN F,FCONSW ;FORCE OUTPUT TO CONSOLE TOO?
POPJ P, ;NOPE
TYPE3: SKIPN BUFO2 ;END OF BUFFER
OUTPUT 3, ;FORCE OUTPUT NOW
IDPB T,BUFO1 ;DEPOSIT CHARACTER
CAIN T,12 ;END OF LINE
OUTPUT 3, ;FORCE AN OUTPUT
POPJ P,
SUBTTL SYMBOL PRINT - RADIX 50
; ACCUMULATORS USED: D,T
PRNAME: MOVE T,C ;LOAD SYMBOL
TLZ T,740000 ;ZERO CODE BITS
CAML T,[50*50*50*50*50] ;SYMBOL LEFT JUSTIFIED
JRST SPT0 ;YES
PUSH P,T
PUSH P,C
MOVEI C,6
MOVEI D,1
IDIVI T,50
JUMPN V,.+2
IMULI D,50
SOJN C,.-3
POP P,C
POP P,T
IMUL T,D
SPT0: MOVNI D,6 ;LOAD CHAR. COUNT
SPT: IDIVI T,50 ;THE REMAINDER IS THE NEXT CHAR.
HRLM V,(P) ;STORE IN LH. OF PUSHDOWN LIST
AOJGE D,.+2 ;SKIP IF NO CHARS. REMAIN
PUSHJ P,SPT ;RECURSIVE CALL FOR NEXT CHAR.
HLRZ T,(P) ;LOAD FROM LH. OF PUSHDOWN LIST
JUMPE T,TYPE ;BLANK
ADDI T,60-1
CAILE T,71
ADDI T,101-72
CAILE T,132
SUBI T,134-44
CAIN T,43
MOVEI T,56
JRST TYPE2
TAB1: PUSHJ P,CRLF
TAB: AOS T,TABCNT
CAIN T,5
JRST TAB1
TLNE N,AUXSWI ;TTY BY DEFAULT?
TRNE F,TTYFL
JRST SP1
MOVEI T,11
JRST TYPE2
OTOD: IBP N
OTOD1: IDIVI Q,^D10
ADDI Q,20 ;FORM SIXBIT
IDPB Q,N
ADDI A,20
IDPB A,N
POPJ P,
DTAB: SIXBIT /JANFEB/
SIXBIT /MARAPR/
SIXBIT /MAYJUN/
SIXBIT /JULAUG/
SIXBIT /SEPOCT/
SIXBIT /NOVDEC/
SUBTTL ERROR MESSAGE PRINT SUBROUTINE
; FORM OF CALL:
; JSP A,ERRPT
; SIXBIT /<MESSAGE>/
; ACCUMULATORS USED: T,V,C,W
ERRPT: PUSHJ P,FCRLF ;ROOM AT THE TOP
PUSHJ P,PRQ ;START OFF WITH ?
ERRPT0: PUSH P,Q ;SAVE Q
SKIPA V,ERRPT5
ERRPT1: PUSHJ P,TYPE
ILDB T,V
CAIN T,'@'
JRST ERRPT4
CAIN T,'%'
JRST ERRPT9
CAIN T,'!'
JRST ERRP42 ;JUST RETURN,LEAVE FCONSW ON
CAIE T,'#'
JRST ERRPT1
SKIPN C,DTIN
JRST ERRPT4
MOVNI Q,14
MOVEI W,77
ERRPT2: TDNE C,W
JRST ERRPT3
LSH W,6
AOJL Q,ERRPT2
ERRPT3: MOVE W,ERRPT6
PUSHJ P,PWORD1
SKIPN W,DTIN1
JRST ERRPT4
LSH W,-6
TLO W,160000
MOVNI Q,4
PUSHJ P,PWORD1
ERRPT4: PUSHJ P,CRLF
ERRP41: TLZ F,FCONSW ;ONE ERROR PER CONSOLE
ERRP42: POP P,Q ;***DMN*** FIX FOR ILC MESSAGE
AOJ V, ;PROGRAM BUMMERS BEWARE:
JRST @V ;V HAS AN INDEX OF A
ERRPT5: POINT 6,0(A)
ERRPT6: SIXBIT / FILE /
ERRPT8: PUSHJ P,PRQ ;START WITH ?
CAIGE T,140 ;IS IT A NON-PRINTING CHAR?
CAIL T,40
JRST ERRP8
PUSH P,T
MOVEI T,136 ;UP ARROW
PUSHJ P,TYPE2
POP P,T
TRC T,100 ;CONVERT TO PRINTING CHAR.
ERRP8: PUSHJ P,TYPE2
ERRPT7: PUSHJ P,SPACE
JRST ERRPT0
ERRPT9: MOVEI V,@V
PUSH P,V
ERROR 7,<?ILLEGAL -LOADER@?>
POP P,V
JRST ERRP41
;PRINT QUESTION MARK
PRQ: PUSH P,T ;SAVE
TLO F,FCONSW ;FORCE TTY OUTPUT ON ANY ERROR
MOVEI T,"?" ;PRINT ?
PUSHJ P,TYPE2 ;...
POP P,T ;RESTORE
POPJ P, ;RETURN
SUBTTL INPUT - OUTPUT INTERFACE
;BINARY INPUT SUBROUTINE - RETURNS A WORD IN W
WORDPR: PUSHJ P,WORD ;GET FIRST WORD OF PAIR
MOVE C,W ;KEEP IT HANDY
WORD: SOSGE BUFR2 ;SKIP IF BUFFER NOT EMPTY
JRST WORD2
WORD1: ILDB W,BUFR1 ;PICK UP 36 BIT WORD
POPJ P,
WORD2: IN 1, ;GET NEXT BUFFER LOAD
JRST WORD ;DATA OK - CONTINUE LOADING
WORD3: STATZ 1,IODEND ;TEST FOR EOF
JRST EOF ;END OF FILE EXIT
ERROR ,< /INPUT ERROR#/>
JRST LD2 ;GO TO ERROR RETURN
SE3: XWD 2,2 ;SYMBOL POINTER INCREMENT
PDLPT: IOWD PDLSIZ,PDLST ;INITIAL PUSHDOWN STACK
COMM: SQUOZE 0,.COMM.
LSTPT: POINT 6,W ;CHARACTER POINTER TO W
IOBKTL==40000
IOIMPM==400000
IODERR==200000
IODTER==100000
IODEND==20000
IOBAD==IODERR!IODTER!IOBKTL!IOIMPM
SUBTTL IMPURE CODE
IFN PURESW,< RELOC
LOWCOD: RELOC
HICODE:
PHASE LOWCOD>
DBUF1: JSP A,ERRPT7
DBUF: SIXBIT /TI:ME DY-MON-YR @/
POPJ P,
;DATA FOR PURE OPEN UUO'S
IFN SPCHN,<
CHNENT: 0
SIXBIT .CHN.
0
0
CHNOUT: EXP 16
SIXBIT /DSK/
0
>
IFN RPGSW,<
OPEN1: EXP 1
RPG1: Z
XWD 0,CTLIN
>
OPEN2: EXP 1
LD5C1: Z
XWD ABUF,0
OPEN3: EXP 14
ILD1: Z
XWD 0,BUFR
IFN MONLOD,<
OPEN4: EXP 16
DIN1: SIXBIT /DSK/
Z
>
IFN PURESW,<DEPHASE
CODLN==.-HICODE>
SUBTTL DATA STORAGE
IFN PURESW,< RELOC
LOWCOD: BLOCK CODLN>
DATBEG:! ;STORAGE AREA CLEARED FROM HERE ON INITIALIZATION
ZBEG:! ;CLEARED FROM HERE TO ZEND ON REINITIALIZATION
MDG: BLOCK 1 ;COUNTER FOR MUL DEF GLOBALS
IFN REENT,<HILOW: BLOCK 1 ;HIGHEST NON-BLOCK STMT IN LOW SEG>
STADDR: BLOCK 1 ;HOLDS STARTING ADDRESS
IFN KUTSW,<CORSZ: BLOCK 1>
IFN REENT,<VSW: BLOCK 1>
IFN NAMESW,<CURNAM: BLOCK 1>
IFN B11SW,<POLSW: BLOCK 1>
IFN FAILSW,<LINKTB: BLOCK 21>
IFN SPCHN,<CHNACB: BLOCK 1>
ZEND==.-1
PDSAV: BLOCK 1 ;SAVED PUSHDOWN POINTER
COMSAV: BLOCK 1 ;LENGTH OF COMMON
PDLST: BLOCK PDLSIZ
F.C: BLOCK 1
BLOCK 1 ;STORE N HERE
BLOCK 1 ;STORE X HERE
BLOCK 1 ;STORE H HERE
BLOCK 1 ;STORE S HERE
BLOCK 1 ;STORE R HERE
B.C: BLOCK 1
NAMPTR: BLOCK 1 ;POINTER TO PROGRAM NAME
IFN NAMESW,<
PRGNAM: BLOCK 1 ;STORE BINARY FILE NAME-USED TO MAKE SYSTAT MORE MEANINGFUL
>
IFN REENT,<
HIGHX: BLOCK 1
HIGHR: BLOCK 1 ;HOLD X AND R WHILE LOADING LOW SEG PIECES
LOWX: BLOCK 1
HVAL: BLOCK 1 ;ORG OF HIGH SEG>
HVAL1: BLOCK 1 ;ACTUAL ORG OF HIGH SEG
LOWR: BLOCK 1 ;HOLD X AND R WHILE LOADING HISEG PIECES
IFN COBSW,<LOD37.: BLOCK 1>
IFN DMNSW,<KORSP: BLOCK 1>
IFN LDAC,<BOTACS: BLOCK 1>
IFN WFWSW,<VARLNG: BLOCK 1
VARREL: BLOCK 1>
IFN SAILSW,<LIBFLS: BLOCK RELLEN*3
PRGFLS: BLOCK RELLEN*3>
IFN MONLOD,<
HIRES: BLOCK 1 ;HIGHEST RESIDENT LOADED ADDRESS+1
XRES: BLOCK 1 ;DISPLACEMENT OF RESIDENT PORTION OF LOADED IMAGE
XCUR: BLOCK 1 ;DISPLACEMENT OF CURRENT PORTION OF LOADED IMAGE (WINDOW)
DILADD: BLOCK 1 ;LOWEST ADDRESS IN CURRENT WINDOW
DIHADD: BLOCK 1 ;HIGHEST ADDRESS IN CURRENT WINDOW+1
DIEND: BLOCK 1 ;ADDRESS+1 OF TOP OF WINDOW BUFFER
CURSET: BLOCK 1 ;CURRENT USETI/USETO NUMBER
RESBLK: BLOCK 1 ;NUMBER OF BLOCKS IN RESIDENT PORTION
GENERI: BLOCK 1 ;NAME OF CURRENT F/S
>
IFN TENEX,<
NLSTGL: BLOCK 1 ;FLAG INHIBITS MULT. LIST OF UNDEF. GLOBALS>
PT1: BLOCK 1
IFN RPGSW,<
NONLOD: BLOCK 1
SVRPG: BLOCK 1
IFN TEMP,<
TMPFIL: BLOCK 2
TMPFLG: BLOCK 1>
>
OLDDEV: BLOCK 1 ;OLD DEVICE ON LIBRARY SEARCH
LSTDEV: BLOCK 1 ;LAST DEVICE BEFORE THIS ONE
IFN PP,<
PPPN: BLOCK 1 ;PERM PPN
PPN: BLOCK 1 ;TEMP PPN
PPNE: BLOCK 1
PPNV: BLOCK 1
PPNW: BLOCK 1
IFN SFDSW,<MYPPN: BLOCK 1 ;HOLD USER'S PPN
SFDADD: BLOCK 2 ;DEVICE AND SCAN SWITCH
SFD: BLOCK SFDSW+2 ;TEMP SFD BLOCK
PSFDAD: BLOCK 2 ;DEV AND SCAN SWITCH
PSFD: BLOCK SFDSW+2 ;PERM SFD BLOCK>
>
IFN B11SW,<
GLBCNT: BLOCK 1
HDSAV: BLOCK 1
HEADNM: BLOCK 1
LFTHSW: BLOCK 1
OPNUM: BLOCK 1
SVHWD: BLOCK 1
SVSAT: BLOCK 1
PPDB: BLOCK PPDL+1
>
HISTRT: BLOCK 1 ;JOBREL AT START OF LOADING
IFN L,<
LSPXIT: BLOCK 1
RINITL: BLOCK 1
OLDJR: BLOCK 1>
IFN SPCHN,<
LINKNR: BLOCK 1 ;CURRENT OVERLAY LINK NUMBER
CHNTAB: BLOCK 1 ;CHAIN VECTOR TABLE,, NEXT BLOCK
BEGOV: BLOCK 1 ;RELATIVE ADDRESS OF BEGINNING OF OVERLAY
CHNACN: BLOCK 1 ;RELATIVE POINTER FOR SAVED NAMPTR
>
TABCNT: BLOCK 1
LIMBO: BLOCK 1 ;WHERE OLD CHARS. ARE STORED
IFN DIDAL,<LSTBLK: BLOCK 1 ;POINTER TO LAST PROG LOADED>
IFN EXPAND,<ALWCOR: BLOCK 1 ;CORE AVAILABLE TO USER>
IFN ALGSW,<%OWN: BLOCK 1 ;ADDRESS OF ALGOL OWN AREA
OWNLNG: BLOCK 1 ;LENGTH OF OWN BLOCK>
IFN REENT,<SVBRKS: BLOCK 1 ;XWD HIGH,LOW (PROG BREAKS)>
IFN FORSW,<FORLIB: BLOCK 1 ;0=LIB40,1=FOROTS>
SUBTTL BUFFER HEADERS AND HEADER HEADERS
BUFO: BLOCK 1 ;CONSOLE INPUT HEADER HEADER
BUFO1: BLOCK 1
BUFO2: BLOCK 1
BUFI: BLOCK 1 ;CONSOLE OUTPUT HEADER HEADER
BUFI1: BLOCK 1
BUFI2: BLOCK 1
ABUF: BLOCK 1 ;AUXILIARY OUTPUT HEADER HEADER
ABUF1: BLOCK 1
ABUF2: BLOCK 1
BUFR: BLOCK 1 ;BINARY INPUT HEADER HEADER
BUFR1: BLOCK 1
BUFR2: BLOCK 1
DTIN: BLOCK 1 ;DECTAPE INPUT BLOCK
DTIN1: BLOCK 3
DTOUT: BLOCK 1 ;DECTAPE OUTPUT BLOCK
DTOUT1: BLOCK 3
IFN MONLOD,<
DIOUT:
IFE PURESW,<EXP .RBALC ;DISK IMAGE INPUT/OUTPUT BLOCK>
IFN PURESW,<BLOCK 1>
BLOCK 1
DIOUT1: BLOCK .RBEST-2 ;BIG WASTE OF SPACE IN ORDER TO PRE ALLOCATE SOME DISK
IFE PURESW,<EXP DALLOC ;PRE ALLOCATE SOME BLOCKS>
IFN PURESW,<BLOCK 1> ;.RBEST
BLOCK 1 ;.RBALC
>
TTY1: BLOCK TTYL ;TTY BUFFER AREA
BUF1: BLOCK BUFL ;LOAD BUFFER AREA
AUX: BLOCK ABUFL ;AUX BUFFER AREA
IFN MONLOD,<
LOLIST: BLOCK 2 ;IOLIST FOR LOW PART OF IMAGE
HILIST: BLOCK 2 ;IOLIST FOR HIGH (VIRTUAL) PART OF LOADED IMAGE
>
IFN RPGSW,<
CTLIN: BLOCK 3
CTLNAM: BLOCK 3
CTLBUF: BLOCK 203+1
>
SUBTTL FORTRAN DATA STORAGE
IFN STANSW,<PATCH: BLOCK 20 ;STANFORD HAS SEMI-INFINITE CORE>
SBRNAM: BLOCK 1
IFE K,<
TOPTAB: BLOCK 1 ;TOP OF TABLES
CTAB: BLOCK 1; COMMON
ATAB: BLOCK 1; ARRAYS
STAB: BLOCK 1; SCALARS
GSTAB: BLOCK 1; GLOBAL SUBPROGS
AOTAB: BLOCK 1; OFFSET ARRAYS
CCON: BLOCK 1; CONSTANTS
PTEMP: BLOCK 1; PERMANENT TEMPS
TTEMP: BLOCK 1; TEMPORARY TEMPS
IFN SPCHN,<
SAVBAS: BLOCK 1 ;HIGHEST RELATIVE ADDRESS IN PROGRAM>
COMBAS: BLOCK 1; BASE OF COMMON
LLC: BLOCK 1; PROGRAM ORIGIN
BITP: BLOCK 1; BIT POINTER
BITC: BLOCK 1; BIT COUNT
PLTP: BLOCK 1; PROGRAMMER LABEL TABLE
MLTP: BLOCK 1; MADE LABEL TABLE
SDS: BLOCK 1 ;START OF DATA STATEMENTS
SDSTP: BLOCK 1 ;START OF DATA STATEMENTS POINTER
BLKSIZ: BLOCK 1; BLOCK SIZE
MODIF: BLOCK 1; ADDRESS MODIFICATION +1
SVFORH: BLOCK 1 ;SAVE H WHILE LOADING F4 PROGRAMS
IOWDPP: BLOCK 2
CT1: BLOCK 1 ;TEMP FOR C
LTC: BLOCK 1
ITC: BLOCK 1
ENC: BLOCK 1
WCNT: BLOCK 1 ;DATA WORD COUNT
RCNT: BLOCK 1 ;DATA REPEAT COUNT
LTCTEM: BLOCK 1 ;TEMP FOR LTC
DWCT: BLOCK 1 ;DATA WORD COUNT
IFN MANTIS,<MNTSYM: BLOCK 1 ;HOLDS MANTIS AUX SYMBOL POINTER>
>
VAR ;DUMP VARIABLES
DATEND:! ;END OF AREA CLEARED ON INITIALIZATION
IFN PURESW,<RELOC>
SUBTTL REMAP UUO
IFN PURESW,<HHIGO: PHASE BUF1 ;DON'T NEED BUF1 NOW>
HIGO: CORE V, ;CORE UUO
JFCL ;NEVER FAILS
HINOGO:
IFN REENT,<MOVE D,HVAL ;GET CURRENT HIGH SEG TOP
CAMG D,HVAL1 ;ANYTHING LOADED IN HI-SEG
JRST HIRET ;NO
SUB D,HVAL1 ;SEE HOW MUCH
TRNE D,1777 ;JUST CROSSED A K BOUND?
JRST HIOK ;NO
HRRZ V,D ;LENGTH ONLY
ADD V,HISTRT ;PLUS BASE
CAMGE V,.JBREL ;WE MIGHT HAVE GOT 1K EXTRA
CORE V,
JFCL
HIOK: MOVE V,HISTRT ;NOW REMAP THE HISEG.
REMAP V, ;REMAP UUO.
JRST REMPFL ;FATAL ERROR.>
HIRET: IFN NAMESW,<
IFE TENEX,<MOVE W,CURNAM ;GET PROGRAM NAME>
IFN TENEX,<SKIPA W,.+1
'(PRIV)'>
SETNAM W, ;SET IT FOR VERSION WATCHING>
JRST 0 ;EXECUTE CODE IN ACC'S
IFN REENT,<
REMPFL: TTCALL 3,SEGMES ;PRINT SEGMES
EXIT ;AND DIE
SEGMES: ASCIZ /?REMAP FAILURE/
>
IFN PURESW,<HIGONE: DEPHASE>
SUBTTL LISP LOADER
;END HERE IF 1K LOADER REQUESTED.
IFN K,<IFE L,<END BEG>
IFN L,< XLIST ;THE LITERALS
LIT ;MUST DUMP NOW SO THEY GET OUTPUT
LIST
LODMAK: MOVEI A,LODMAK
MOVEM A,137 ;SET UP TO SAVE THE LISP LOADER
INIT 17
SIXBIT /DSK/
0
HALT
ENTER LMFILE
HALT
OUTPUT LMLST
STATZ 740000
HALT
RELEASE
EXIT
LMFILE: SIXBIT /LISP/
SIXBIT /LOD/
0
0
LMLST: IOWD 1,.+1 ;IOWD
IOWD LODMAK-LD+1,137 ;AND CORE IMAGE
0
END LODMAK>>
SUBTTL FORTRAN FOUR LOADER
F4LD: TLNE F,SKIPSW!FULLSW ;ARE WE IN SKIP MODE
JRST REJECT ;YES,DON'T LOAD ANY OF THIS
MOVEI W,-2(S); GENERATE TABLES
CAIG W,(H) ;NEED TO EXPAND?
IFN EXPAND,<PUSHJ P,[PUSHJ P,XPAND
POPJ P,
JRST POPJM3]>
IFE EXPAND,< TLO F,FULLSW>
TLO N,F4SW; SET FORTRAN FOUR FLAG
HRRZ V,R; SET PROG BREAK INTO V
MOVEM V,LLC; SAVE FIRST WORD ADDRESS
HRRZM W,MLTP; MADE LABELS
HRRZM W,PLTP; PROGRAMMER LABELS
ADD W,[POINT 1,1]; GENERATE BIT-BYTE POINTER
MOVEM W,BITP
MOVEM W,SDSTP; FIRST DATA STATEMENT
AOS SDSTP;
HRREI W,-^D36; BITS PER WORDUM
MOVEM W,BITC; BIT COUNT
PUSHJ P,BITWX ;MAKE SURE OF ENOUGH SPACE
MOVE W,[JRST ALLOVE] ;LAST DATA STATEMENT
MOVEM W,(S)
TEXTR: PUSHJ P,WORD; TEXT BY DEFAULT
HLRZ C,W
CAIN C,-1
JRST HEADER; HEADER
MOVEI C,1; RELOCATABLE
TLNN F,FULLSW!SKIPSW ;DON'T LOAD IF EITHER SET
PUSHJ P,BITW; SHOVE AND STORE
JRST TEXTR; LOOP FOR NEXT WORD
ABS: SOSG BLKSIZ; MORE TO GET
JRST TEXTR; NOPE
ABSI: PUSHJ P,WORD;
MOVEI C,0; NON-RELOCATABLE
TLNN F,FULLSW!SKIPSW ;DON'T LOAD IF EITHER SET
PUSHJ P,BITW; TYPE 0
JRST ABS
SUBTTL PROCESS TABLE ENTRIES
MDLB: TLNE F,FULLSW+SKIPSW; MADE LABEL PROC
JRST GLOBDF; NO ROOM AT THE IN
HLRZ C,MLTP; GET PRESENT SIZE
CAMGE C,BLKSIZ; IF NEW SIZE BIGGER, STR-R-RETCH
PUSHJ P,SMLT
HRRZ C,MLTP; GET BASE
MLPLC: ADD C,BLKSIZ; MAKE INDEX
TLNN F,FULLSW+SKIPSW; DONT LOAD
HRRZM V,(C); PUT AWAY DEFINITION
GLOBDF: PUSHJ P,WORD
TLNE F,FULLSW+SKIPSW ;SKIPPING THIS PROG?
JRST TEXTR ;YES, DON'T DEFINE
MOVEI C,(V); AND LOC
EXCH W,C
PUSHJ P,SYMXX; PUT IN DDT-SYMBOL TABLE
PUSHJ P,BITWX
JRST TEXTR
PLB: TLNE F,FULLSW+SKIPSW
JRST GLOBDF
HLRZ C,PLTP; PRESENT SIZE
CAMGE C,BLKSIZ
PUSHJ P,SPLT
HRRZ C,PLTP
JRST MLPLC
SUBTTL STORE WORD AND SET BIT TABLE
BITW: MOVEM W,@X; STORE AWAY OFFSET
IDPB C,BITP; STORE BIT
AOSGE BITC; STEP BIT COUNT
AOJA V,BITWX; SOME MORE ROOM LEFT
HRREI C,-^D36; RESET COUNT
MOVEM C,BITC
SOS PLTP
SOS BITP; ALL UPDATED
IFE EXPAND,<HRL C,MLTP
SOS MLTP
HRR C,MLTP>
IFN EXPAND,<HRRZ C,MLTP; TO ADDRESS
SUBI C,1
CAIG C,(H)
PUSHJ P,[PUSHJ P,XPAND
POPJ P,
ADDI C,2000
JRST POPJM2]
SOS MLTP
HRLI C,1(C)>
HRRZ T,SDSTP; GET DATA POINTER
BLT C,-1(T); MOVE DOWN LISTS
AOJ V,; STEP LOADER LOCATION
BITWX: IFN REENT,<
TLNE F,HIPROG
JRST FORTHI>
CAIGE H,@X
MOVEI H,@X ;KEEP H SET RIGHT FOR HISEG STUFF
BITWX2: HRRZ T,MLTP
CAIG T,(H); OVERFLOW CHECK
IFE EXPAND,<TLO F,FULLSW>
IFN EXPAND,<PUSHJ P, [PUSHJ P,XPAND
POPJ P,
JRST POPJM3]>
POPJ P,;
SMLT: SUB C,BLKSIZ; STRETCH
MOVS W,MLTP ;LEFT HALF HAS OLD BASE
ADD C,MLTP ;RIGHT HALF HAS NEW BASE
IFN EXPAND,< HRRZS C ;GET RID OF COUNT
CAIG C,(H)
PUSHJ P,[PUSHJ P,XPAND
POPJ P,
ADD W,[XWD 2000,0]
ADDI C,2000
JRST POPJM2]>
HRRM C,MLTP ;PUT IN NEW MLTP
HLL C,W ;FORM BLT POINTER
ADDI W,(C) ;LAST ENTRY OF MLTP
HRL W,BLKSIZ ;NEW SIZE OF MLTP
HLLM W,MLTP ;...
SLTC: BLT C,0(W); MOVE DOWN (UP?)
POPJ P,;
SPLT: SUB C,BLKSIZ
MOVS W,MLTP;
ADDM C,PLTP
ADD C,MLTP
IFN EXPAND,< HRRZS C
CAIG C,(H)
PUSHJ P,[PUSHJ P,XPAND
POPJ P,
ADD W,[XWD 2000,0]
ADDI C,2000
JRST POPJM2]>
HRRM C,MLTP ;PUT IN NEW MLTP
HLL C,W
HLRZ W,PLTP ;OLD SIZE OF PL TABLE
ADD W,PLTP ;NEW BASE OF PL TABLE
HRL W,BLKSIZ ;NEW SIZE OF PL TABLE
HLLM W,PLTP ;INTO POINTER
JRST SLTC
IFN REENT,<
FORTHI: HRRZ T,.JBREL ;CHECK FOR CORE OVERFLOW
CAIGE T,@X
PUSHJ P,[PUSHJ P,HIEXP
POPJ P,
JRST POPJM3] ;CHECK AGAIN
JRST BITWX2>
SUBTTL PROCESS END CODE WORD
ENDS: PUSHJ P,WORD; GET STARTING ADDRESS
JUMPE W,ENDS1; NOT MAIN
ADDI W,(R); RELOCATION OFFSET
TLNE N,ISAFLG; IGNORE STARTING ADDRESS
JRST ENDS1
HRRZM W,STADDR ;STORE STARTING ADDRESS
IFN NAMESW,<MOVE W,NAMPTR ;GET POINTER
MOVE W,1(W) ;SET UP NAME
PUSHJ P,LDNAM
MOVE W,DTIN
MOVEM W,PRGNAM>
ENDS1: PUSHJ P,WORDPR ;DATA STORE SIZE
HRRZM C,PTEMP ;NUMBER OF PERMANENT TEMPS
MOVEM V,CCON; START OF CONSTANTS AREA
JUMPE W,E1; NULL
MOVEM W,BLKSIZ ;SAVE COUNT
MOVEI W,0(V) ;DEFINE CONST.
MOVE C,CNR50 ;...
TLNN F,SKIPSW!FULLSW
PUSHJ P,SYMPT ;...
PUSHJ P,GSWD ;STORE CONSTANT TABLE
E1: MOVEI W,0(V); GET LOADER LOC
EXCH W,PTEMP; STORE INTO PERM TEMP POINTER
ADD W,PTEMP; FORM TEMP TEMP ADDRESS
MOVEM W,TTEMP; POINTER
MOVEM V,GSTAB; STORE LOADER LOC IN GLOBSUB
MOVEM H,SVFORH
MOVE C,TTR50 ;DEFINE %TEMP.
TLNE F,SKIPSW!FULLSW
JRST E1A
PUSHJ P,SYMPT ;...
MOVE C,PTR50 ;DEFINE (IF EXTANT) TEMP.
MOVEI W,0(V) ;...
CAME W,TTEMP ;ANY PERM TEMPS?
PUSHJ P,SYMPT ;YES, DEFINE
E1A: PUSHJ P,WORD; NUMBER OF GLOBSUBS
JUMPE W,E11
MOVEM W,BLKSIZ ;SIZE OF GLOBSUB
PUSHJ P,GSWD ;STORE GLOBSUB TABLE
E11: MOVEM V,STAB; SCALARS
PUSHJ P,WORD; HOW MANY?
JUMPE W,E21; NONE
PUSHJ P,GSWDPR ;STORE SCALAR TABLE
E21: MOVEM V,ATAB; ARRAY POINTER
PUSHJ P,WORD; COMMENTS FOR SCALARS APPLY
JUMPE W,E31
PUSHJ P,GSWDPR ;STORE ARRAY TABLE
E31: MOVEM V,AOTAB; ARRAYS OFFSET
PUSHJ P,WORD; SAME COMMENTS AS ABOVE
JUMPE W,E41
PUSHJ P,GSWDPR ;STORE ARRAY OFFSET TABLE
E41: PUSHJ P,WORD; TEMP, SCALAR, ARRAY SIZE
TLNE F,FULLSW!SKIPSW ;SKIPPING THIS PROG?
MOVEI W,0 ;DON'T ACCEPT GLOB SUBPROG REQUESTS
MOVEM V,CTAB; SETUP COMMON TABLE POINTER
ADD W,GSTAB; GLOBAL SUBPROG BASE
MOVEM W,COMBAS; START OF COMMON
IFN SPCHN,<MOVEM W,SAVBAS ;SAVE AS HIGHEST ADDRESS IN PROGRAM>
PUSHJ P,WORD; COMMON BLOCK SIZE
HRRZM W,BLKSIZ
JUMPE W,PASS2; NO COMMON
COMTOP: PUSHJ P,WORDPR ;GET A COMMON PAIR
TLNE F,SKIPSW!FULLSW ;IF SKIPPING
JRST COMCO1 ;DON'T USE
PUSHJ P,SDEF; SEARCH
JRST COMYES; ALREADY THERE
HRLS W
HRR W,COMBAS; PICK UP THIS COMMON LOC
TLNN F,SKIPSW!FULLSW
PUSHJ P,SYMXX; DEFINE IT
MOVS W,W; SWAP HALFS
ADD W,COMBAS; UPDATE COMMON LOC
HRRM W,COMBAS; OLD BASE PLUS NEW SIZE
HLRZS W; RETURN ADDRESS
TLZ C,400000
TLNN F,SKIPSW!FULLSW
PUSHJ P,SYMXX
COMCOM: PUSHJ P,CWSTWX ;STORE A WORD PAIR
COMCO1: SOS BLKSIZ
SOSLE BLKSIZ
JRST COMTOP
JRST PASS2
COMYES: HLRZ C,2(A); PICK UP DEFINITION
CAMLE W,C; CHECK SIZE
JRST ILC; ILLEGAL COMMON
MOVE C,1(A); NAME
HRRZ W,2(A); BASE
JRST COMCOM
PRSTWX: PUSHJ P,WORDPR ;GET A WORD PAIR
CWSTWX: EXCH C,W ;SPACE TO STORE FIRST WORD OF PAIR?
PUSHJ P,WSTWX ;...
EXCH C,W ;THERE WAS; IT'S STORED
WSTWX: TLNE F,FULLSW!SKIPSW ;SPACE FOR ANOTHER WORD?
POPJ P, ;NOPE, RETURN
MOVEM W,@X ;YES, STORE IT.
AOJA V,BITWX ;TELL THE TABLES ABOUT IT; THEN RETURN
GSWD: PUSHJ P,WORD ;GET WORD FROM TABLE
PUSHJ P,WSTWX ;STASH IT
SOSE BLKSIZ ;FINISHED?
JRST GSWD ;NOPE, LOOP
POPJ P, ;TRA 1,4
GSWDPR: MOVEM W,BLKSIZ ;KEEP COUNT
GSWDP1: PUSHJ P,PRSTWX ;GET AND STASH A PAIR
SOS BLKSIZ ;FINISHED?
SOSLE BLKSIZ ;...
JRST GSWDP1 ;NOPE, LOOP
POPJ P, ;TRA 1,4
SUBTTL BEGIN HERE PASS2 TEXT PROCESSING
PASS2: ADDI V,(X)
IFN REENT,<TLNE F,HIPROG
HRRZ V,H>
MOVEM V,TOPTAB ;SAVE FOR OVERLAP CHECKING
TLNE F,FULLSW+SKIPSW; ABORT?
JRST ALLOVE; YES
MOVE V,LLC ;PICK UP PROGRAM ORIGIN
CAML V,CCON ;IS THIS A PROGRAM?
JRST FBLKD ;NO, GO LOOK FOR FIRST BLK DATA
IFE L,<IFN REENT,<TLNN F,HIPROG ;DON'T BOTHER IF IN HISEG, CHAIN NOT SMART ENOUGH>
TLOE N,PGM1 ;YES, IS THIS FIRST F4 PROG?
JRST NOPRG ;NO
HRR W,COMBAS ;YES, PLACE PROG BREAK IN LH
HRLM W,.JBCHN(X) ;FOR CHAIN>
NOPRG: HRRZ W,PLTP; GET PROG TABLE BASE
HLRZ C,PLTP; AND SIZE
ADD W,C; COMPUTE END OF PROG TABLE
ADD W,[POINT 1,1]; AND BEGINNING OF BIT TABLE
EXCH W,BITP; SWAP POINTERS
PASS2B: ILDB C,BITP; GET A BIT
JUMPE C,PASS2C; NO PASS2 PROCESSING
PUSHJ P,PROC; PROCESS A TAG
JRST PASS2B; MORE TO COME
JRST ENDTP;
PROC: LDB C,[POINT 6,@X,23]; TAG
SETZM MODIF; ZERO TO ADDRESS MODIFIER
TRZE C,40
AOS MODIF
MOVEI W,TABDIS; HEAD OF TABLE
HRLI W,-TABLNG ;SET UP FOR AOBJN
HLRZ T,(W); GET ENTRY
CAME T,C; CHECK
AOBJN W,.-2
JUMPGE W,LOAD4A ;RAN OUT OF ENTRIES
HRRZ W,(W); GET DISPATCH
LDB C,[POINT 12,@X,35]
JRST (W); DISPATCH
PASS2C: PUSHJ P,PASS2A
JRST PASS2B
JRST ENDTP
TABDIS: XWD 11,PCONS; CONSTANTS
XWD 06,PGS; GLOBAL SUBPROGRAMS
XWD 20,PST; SCALARS
XWD 22,PAT; ARRAYS
XWD 01,PATO; ARRAYS OFFSET
XWD 00,PPLT; PROGRAMMER LABELS
XWD 31,PMLT; MADE LABESL
XWD 26,PPT; PERMANENT TEMPORARYS
XWD 27,PTT; TEMPORARY TEMPORARYS
TABLNG==.-TABDIS
;DISPATCH ON A HEADER
HEADER: CAMN W,[EXP -2]; END OF PASS ONE
JRST ENDS
LDB C,[POINT 12,W,35]; GET SIZE
MOVEM C,BLKSIZ
ANDI W,770000
JUMPE W,PLB; PROGRAMMER LABEL
CAIN W,500000; ABSOLUTE BLOCK
JRST ABSI;
CAIN W,310000; MADE LABEL
JRST MDLB; MADE LABEL
CAIN W,600000
JRST GLOBDF
CAIN W,700000; DATA STATEMENT
JRST DATAS
IFN MANTIS,<CAIN W,770000; SPECIAL DEBUGGER DATA
JRST SPECBUG>
JRST LOAD4A; DATA STATEMENTS WILL GO HERE
TTR50: RADIX50 10,%TEMP.
PTR50: RADIX50 10,TEMP.
CNR50: RADIX50 10,CONST.
IFN MANTIS,<
SPECB: CAML W,.JBREL ;ROOM?
AOJA W,[CORE W, ;NO, GET IT
JRST MORCOR
JRST .+1] ;GOT IT
PUSHJ P,WORD ;GET SPECIAL DATA
MOVEM W,@MNTSYM ;DEPOSIT IT
SOSG BLKSIZ ;MORE?
JRST TEXTR ;NO
SPECBUG:TRNN N,MANTFL ;ARE WE LOADING MANTIS DATA?
JRST [PUSHJ P,WORD ;NO, READ A WORD
SOSG BLKSIZ ;AND IGNORE IT
JRST TEXTR ;BLOCK EXHAUSTED?
JRST @.] ;NO, LOOP
AOS W,MNTSYM ;STEP SPECIAL POINTER
SOJG W,SPECB ;LOOP IF SETUP ALREADY
HRRZ W,.JBREL ;SET IT UP NOW
MOVEM W,MNTSYM
JRST SPECBUG ;AND STEP IT>
SUBTTL ROUTINES TO PROCESS POINTERS
PCONS: ADD C,CCON; GENERATE CONSTANT ADDRESS
SOJA C,PCOMX ;ADJUST FOR 1 AS FIRST ENTRY
PSTA: PUSHJ P,SWAPSY ;NON-COMMON SCALARS AND ARRAYS
ADDI C,(R); RELOCATE
PCOM1: PUSHJ P,SYDEF ;...
PCOMX: ADD C,MODIF ;ADDR RELOC FOR DP
HRRM C,@X; REPLACE ADDRESS
PASS2A: AOJ V,; STEP READOUT POINTER
CAML V,CCON ;END OF PROCESSABLES?
CPOPJ1: AOS (P); SKIP
POPJ P,;
PAT: SKIPA W,ATAB ;ARRAY TABLE BASE
PST: MOVE W,STAB ;SCALAR TABLE BASE
ROT C,1 ;SCALE BY 2
ADD C,W ;ADD IN TABLE BASE
ADDI C,-2(X); TABLE ENTRY
HLRZ W,(C); CHECK FOR COMMON
TRNN W,7777 ;IGNORE SIX BITS ;U/O-LKS
JRST PSTA ;NO COMMON ;U/O-LKS
PUSHJ P,COMDID ;PROCESS COMMON
JRST PCOM1
COMDID: ANDI W,7777 ;IGNORE SIX BITS ;U/O-LKS
LSH W,1 ;PROCESS COMMON TABLE ENTRIES
ADD W,CTAB; COMMON TAG
ADDI W,-2(X); OFFSET
PUSHJ P,SWAPSY; GET SYMBOL AND SET TO DEFINED
ADD C,1(W); BASE OF COMMON
POPJ P, ;RETURN
PATO: ROT C,1
ADD C,AOTAB; ARRAY OFFSET
ADDI C,-2(X); LOADER OFFSET
MOVEM C,CT1; SAVE CURRENT POINTER
HRRZ C,1(C); PICK UP REFERENCE POINTER
ANDI C,7777; MASK TO ADDRESS
ROT C,1; ALWAYS A ARRAY
ADDI C,-2(X)
ADD C,ATAB
HLRZ W,(C); COMMON CHECK
TRNN W,7777 ;IGNORE SIX BITS ;U/O-LKS
JRST NCO ;U/O-LKS
PUSHJ P,COMDID ;PROCESS COMMON
PUSHJ P,SYDEF
MOVE C,CT1
HRRE C,(C)
ADD C,1(W)
JRST PCOMX
NCO: PUSHJ P,SWAPSY;
ADDI C,(R) ;DEFINE SYMBOL IN TRUE LOC
PUSHJ P,SYDEF ;...
MOVE C,CT1
HRRZ C,(C) ;OFFSET ADDRESS PICKUP
ADDI C,(R) ;WHERE IT WILL BE
JRST PCOMX ;STASH ADDR AWAY
PTT: ADD C,TTEMP; TEMPORARY TEMPS
SOJA C,PCOMX ;ADJUST FOR 1 AS FIRST ENTRY
PPT: ADD C,PTEMP; PERMANENT TEMPS
SOJA C,PCOMX ;ADJUST FOR 1 AS FIRST ENTRY
PGS: ADD C,GSTAB; GLOBSUBS
ADDI C,-1(X); OFFSET
MOVE C,(C)
TLC C,640000; MAKE A REQUEST
PUSHJ P,TBLCHK ;CHECK FOR OVERLAP
MOVEI W,(V); THIS LOC
HLRM W,@X; ZERO RIGHT HALF
PUSHJ P,SYMXX
JRST PASS2A
SYDEF: TLNE N,SYDAT ;SYMBOL WANTS DEFININITION?
POPJ P, ;NO, GO AWAY
PUSH P,C ;SAVE THE WORLD
PUSH P,W
PUSHJ P,TBLCHK ;CHECK FOR OVERLAP
MOVE W,C
SKIPE C,T ;PICKUP VALUE
PUSHJ P,SYMXX
POP P,W
POP P,C
POPJ P,;
PMLT: ADD C,MLTP
JRST .+2
PPLT: ADD C,PLTP
HRRZ C,(C)
JRST PCOMX
SYMXX: PUSH P,V
PUSHJ P,SYMPT
POP P,V
IFE REENT,<POPJ P,>
IFN REENT,<JRST RESTRX>
SWAPSY: MOVEI T,0; SET TO EXCHANGE DEFS
EXCH T,1(C); GET NAME
IFN MANTIS,<TRNE N,MANTFL ;LOADING MANTIS DATA?
SKIPA C,(C) ;YES, GET FULLWORD VALUE>
HRRZ C,(C) ;GET HALFWORD VALUE
POPJ P,
TBLCHK: HRRZ W,MLTP ;GETT TOP OV TABLES
SUBI W,2
CAMG W,TOPTAB ;WILL IT OVERLAP
IFE EXPAND,<TLO F,FULLSW>
IFN EXPAND,<JRST [PUSHJ P,XPAND
POPJ P,
JRST TBLCHK]>
POPJ P,
SUBTTL END OF PASS2
ALLOVE: TLZ N,F4SW ;END OF F4 PROG
HRRZ V,SDSTP ;GET READY TO ZERO OUT DATA STMTS
SETZM (V) ;AT LEAST ONE THERE
CAIL V,(S) ;IS THERE MORE THAN ONE??
JRST NOMODS ;NO
HRLS V
ADDI V,1 ;SET UP BLT
BLT V,(S) ;ZERO OUT ALL OF IT
NOMODS: MOVE H,SVFORH
TLNE F,FULLSW!SKIPSW
JRST HIGH3A
HRR R,COMBAS ;TOP OF THE DATA
CAMG H,SDS ;HIGHEST LOC GREATER THAN DATA STATEMENTS?
JRST HIGH3A ;NO, RETURN
ADDI H,1(S) ;YES, SET UP MEANINGFUL ERROR COMMENT
SUB H,SDS ;...
TLO F,FULLSW ;INDICATE OVERFLO
HIGH3A: IFN REENT,<SETZ W, ;CAUSES TROUBLE OTHERWISE
TLZE F,HIPROG
JRST HIGHN1
IFE SPCHN,<HRRZ V,GSTAB>
IFN SPCHN,<HRRZ V,SAVBAS ;GET END OF PROGRAM RELATIVE ADDRESS
;THIS MEANS THAT WITH SPECIAL CHAINING THE
;ENTIRE LAST PROGRAM OF A LINK WILL BE SAVED
;BUT COMMON DECLARED FOR THE FIRST TIME
;IN THAT PROGRAM WON'T BE. THIS SHOULD NOT
;CAUSE PROBLEMS BECAUSE IF COMMON APPEARS HERE
;NOBODY ELSE CAN REFERENCE IT ANYWAY. >
MOVEI V,@X
CAMLE V,HILOW
MOVEM V,HILOW>
HRRZ C,R
JRST HIGH31 ;RETURN
DATAS: TLNE F,FULLSW+SKIPSW
JRST DAX
MOVEI C,(S) ;ADDR OF WORD UNDER SYMBOL TABLE
MOVN W,BLKSIZ ;HOW FAR DOWN TO BLT
ADDM W,PLTP ;UPDATE TABLE POINTERS
ADDM W,BITP ;...
ADDM W,SDSTP ;...
ADD C,W ;RH(C):= WHEN TO STOP BLT
HRL C,MLTP ;SOURCE OF BLTED DATA
ADD W,MLTP ;UPDATE, GET DESTINATION OF BLT DATA
IFN EXPAND,< HRRZS W ;GET RID OF LEFT HALF
CAIG W,(H)
PUSHJ P,[PUSHJ P,XPAND
POPJ P,
ADDI W,2000
ADD C,[XWD 2000,2000]
JRST POPJM2]>
HRRM W,MLTP ;NO SET THIS SO EXTRA CORE NOT ZEROED
HLL W,C ;FORM BLT POINTER
BLT W,-1(C) ;MOVE TABLES DOWN (BUT NOT JRST ALLOVE)
PUSHJ P,BITWX
DAX: PUSHJ P,WORD; READ ONE WORD
TLNN F,FULLSW+SKIPSW
MOVEM W,(C)
SOSLE BLKSIZ ;COUNT OF DATA SEQUENCE SIZE
AOJA C,DAX ;INCREMENT DATA SEQUENCE DEPOSIT LOC
JRST TEXTR; DONE
FBLKD: IFE L,<IFN REENT,<
TLNN F,HIPROG>
TLOE N,BLKD1 ;IS THIS FIRST BLOCK DATA?
JRST ENDTP ;NO
HRR V,COMBAS ;PLACE PROG BREAK IN RH FOR
HRRM V,.JBCHN(X) ;CHAIN>
ENDTP: TLNE F,FULLSW+SKIPSW
JRST ALLOVE
HRR V,GSTAB
ENDTP0: CAML V,STAB; ANY MORE GLOBSUBS
JRST ENDTP2; NO
MOVE C,@X; GET SUBPROG NAME
PUSHJ P,SREQ; IS IT ALLREADY REQUESTED
AOJA V,ENDTP0; YES
PUSHJ P,SDEF; OR DEFINED
AOJA V,ENDTP0; YES
PUSHJ P,TBLCHK
MOVEI W,0 ;PREPARE DUMMY LINK
TLNN F,FULLSW+SKIPSW ;ABORT
PUSHJ P,SYM3X; PUT IN DUMMY REQUEST
PUSHJ P,BITWX; OVERLAP CHECK
AOJA V,ENDTP0
ENDTP2: SETZM PT1
ENDTPW: HRRZ V,SDSTP
IFN EXPAND,<IFN REENT,<TLNE F,HIPROG
JRST ENDTPI>
SUBI V,(X)
CAMG V,COMBAS
PUSHJ P,[SUB V,COMBAS
MOVNS V
JRST XPAND9]
JFCL ;FOR ERROR RETURN FROM XPAND
ENDTPH: HRR V,SDSTP>
HRRZM V,SDS ;DATA STATEMENT LOC
ENDTP1: SUBI V,(X); COMPENSATE FOR OFFSET
MOVE W,@X; GET WORD
TLNE W,-1; NO LEFT HALF IMPLIES COUNT
JRST DODON; DATA DONE
ADD W,[MOVEI W,3]
ADDI W,@X
EXCH W,@X
AOJ V,
ADD W,@X; ITEMS COUNT
MOVEM W,ITC
MOVE W,[MOVEM W,LTC]
MOVEM W,@X; SETUP FOR DATA EXECUTION
AOJ V,
MOVSI W,(MOVEI W,0)
EXCH W,@X
MOVEM W,ENC; END COUNT
AOJ V,
MOVEI W,@X
ADDM W,ITC
LOOP: MOVE W,@X
HLRZ T,W; LEFT HALF INST.
ANDI T,777000
CAIN T,254000 ;JRST?
JRST WRAP ;END OF DATA
CAIN T,260000 ;PUSHJ?
JRST PJTABL(W) ;DISPATCH VIA TABLE
CAIN T,200000; MOVE?
AOJA V,INNER
CAIN T,270000; ADD?
JRST ADDOP
CAIN T,221000; IMULI?
AOJA V,LOOP
CAIE T,220000; IMUL?
JRST LOAD4A; NOTA
INNER: HRRZ T,@X; GET ADDRESS
TRZE T,770000; ZERO TAG?
SOJA T,CONPOL; NO, CONSTANT POOL
JUMPE T,FORCNF
SUB T,PT1; SUBTRACT INDUCTION NUMBER
ASH T,1
SUBI T,1
HRRM T,@X
HLRZ T,@X
ADDI T,P
HRLM T,@X
AOJA V,LOOP
IFN EXPAND,<IFN REENT,<
ENDTPI: HRRZ V,COMBAS
MOVEI V,@X
CAMLE V,.JBREL
JRST [PUSHJ P,HIEXP
JRST ENDTPH
JRST ENDTPI]
JRST ENDTPH>>
FORCNF: ERROR ,</FORTRAN CONFUSED ABOUT DATA STATEMENTS!/>
JRST ILC1
CONPOL: ADD T,ITC; CONSTANT BASE
HRRM T,@X
AOJA V,LOOP
ADDOP: HRRZ T,@X
TRZE T,770000
SOJA T,CONPOL
SKIPIN: AOJA V,LOOP
PJTABL: JRST DWFS ;PUSHJ 17,0
AOSA PT1 ;INCREMENT DO COUNT
SOSA PT1; DECREMENT DO COUNT
SKIPA W,[EXP DOINT.]
MOVEI W,DOEND.
HRRM W,@X
AOJA V,SKIPIN ;SKIP A WORD
DWFS: MOVEI W,DWFS.
HRRM W,@X
AOJ V,
TLO N,SYDAT
PUSHJ P,PROC; PROCESS THE TAG
JUMPGE V,DATAOV ;DATA STATEMENT BELOW CODE TOP
JRST LOOP ;PROPER RETURN
DOINT.: POP P,V; GET ADDRESS OF INITIAL VALUE
PUSH P,(V); STORE INDUCTION VARIABLE
AOJ V,
PUSH P,V; INITIAL ADDRESS
JRST (V)
DOEND.: HLRE T,@(P) ;RETAIN SIGN OF INCREMENT
ADDM T,-2(P); INCREMENT
HRRE T,@(P); GET FINAL VALUE
SUB T,-2(P) ;FINAL - CURRENT
IMUL T,@(P) ;INCLUDE SIGN OF INCREMENT
JUMPL T,DODONE ;SIGN IS ONLY IMPORTANT THING
POP P,(P); BACK UP POINTER
JRST @(P)
DODONE: POP P,-1(P); BACK UP ADDRESS
POP P,-1(P)
JRST CPOPJ1 ;RETURN
WRAP: MOVE W,ENC; NUMBER OF CONSTANTS
ADD W,ITC; CONSTANT BASE
MOVEI C,(W); CHAIN
HRRM C,@X
MOVEI V,(W); READY TO GO
JRST ENDTP1
DODON: TLZ N,RCF!SYDAT!DZER ;DATA STATEMENT FLAGS
MOVE W,PTEMP ;TOP OF PROG
ADDI W,(X) ;+OFFSET
HRRZ C,SDS
IFE EXPAND,<SUBI C,(X) ;CHECK FOR ROOM
CAMGE C,COMBAS ;IS IT THERE
TLO F,FULLSW ;NO (DONE EARLIER IF EXPAND)
HRRZ C,SDS>
SUBI C,1 ;GET ONE LESS (TOP LOCATION TO ZERO)
IFN REENT,<TLNE F,HIPROG
MOVE C,.JBREL>
SECZER: CAMLE W,C ;ANY DATA TO ZERO?
JRST @SDS ;NO, DO DATA STATEMENTS
;FULLSW IS ON IF COMBAS GT. SDS
TLNN F,FULLSW+SKIPSW ;SHOULD WE ZERO?
SETZM (W) ;YES, DO SO
TLON N,DZER ;GO BACK FOR MORE?
AOJA W,SECZER ;YES, PLEASE
HRLI W,-1(W) ;SET UP BLT POINTER TO ZERO DATA
TLNN F,FULLSW+SKIPSW ;SHOULD WE ZERO?
BLT W,(C) ;YES, DO SO
JRST @SDS ;GO DO DATA STATEMENTS
DATAOV: ERROR 0,</DATA STATEMENT OVERFLOW!/>
JRST ILC1
DREAD: TLNE N,RCF; NEW REPEAT COUNT NEEDED
JRST FETCH; NO
MOVE W,LTC
MOVEM W,LTCTEM
MOVE W,@LTC; GET A WORD
HLRZM W,RCNT; SET REPEAT COUNT
HRRZM W,WCNT; SET WORD COUNT
POP W,(W); SUBTRACT ONE FROM BOTH HALFS
HLLM W,@LTC; DECREMENT REPEAT COUNT
AOS W,LTC; STEP READOUT
TLO N,RCF
FETCH: MOVE W,@LTC
AOS LTC
SOSE WCNT
POPJ P,;
SOSN RCNT
JRST DOFF.
MOVE V,LTCTEM; RESTORE READOUT
MOVEM V,LTC
DOFF.: TLZ N,RCF; RESET DATA REPEAT FLAG
POPJ P,;
DWFS.: MOVE T,(P)
AOS (P)
MOVE T,(T); GET ADDRESS
HLRZM T,DWCT; DATA WORD COUNT
HRRZS T
ADDI T,(W); OFFSET
IFN REENT,<HRRZS T ;CLEAR LEFT HALF INCASE OF CARRY
CAML T,HVAL1
JRST [ADD T,HIGHX
HRRZS T ;MUST GET RID OF LEFT HALF
CAMLE T,.JBREL
JRST DATAOV ;IN CASE FORTRAN GOOFS ON LIMITS
JRST DWFS.1]
ADD T,LOWX>
HRRZS T
IFE REENT,<ADDI T,(X)>
CAML T,SDS
JRST DATAOV
DWFS.1: PUSHJ P,DREAD ;GET A DATA WORD
HRRZS T
IFN REENT,<CAMG T,.JBREL ;JUST TO MAKE SURE>
CAMN T,SDS
JRST DATAOV
TLNN F,FULLSW+SKIPSW ;LOAD THE NEXT DATA ITEM?
MOVEM W,(T) ;YES, STORE IT
SOSE W,DWCT; STEP DOWN AND TEST
AOJA T,DWFS.1 ;ONE MORE TIME, MOZART BABY!
POPJ P,
SUBTTL ROUTINE TO SKIP FORTRAN OUTPUT
;SUBSECTION OF THE ROUTINE TO HANDLE OUTPUT FROM THE
;FORTRAN IV COMPILER. THE MAIN OBJECT OF THE ROUTINE IS TO
;LOOK FOR THE END BLOCK. CODE TAKEN FROM FUDGE2.
MACHCD: HRRZ C,W ;GET THE WORD COUNT
PUSHJ P,WORD ;INPUT A WORD
SOJG C,.-1 ;LOOP BACK FOR REST OF THE BLOCK
;GO LOOK FOR NEXT BLOCK
REJECT: PUSHJ P,WORD ;READ A FORTRAN BLOCK HEADER
TLC W,-1 ;TURN ONES TO ZEROES IN LEFT HALF
TLNE W,-1 ;WAS LEFT HALF ALL ONES?
JRST REJECT ;NO, IT WAS CALCULATED MACHINE CODE
CAIN W,-2 ;YES, IS RIGHT HALF = 777776?
JRST ENDST ;YES, PROCESS F4 END BLOCK
LDB C,[POINT 6,W,23];GET CODE BITS FROM BITS 18-23
TRZ W,770000 ;THEN WIPE THEM OUT
CAIN C,77 ;IS IT SPECIAL DEBUGGER DATA?
JRST MACHCD ;YES, TREAT IT LIKE DATA
CAIE C,70 ;IS IT A DATA STATEMENT?
CAIN C,50 ;IS IT ABSOLUTE MACHINE CODE?
JRST MACHCD ;YES, TREAT IT LIKE DATA STATEMENTS
PUSHJ P,WORD ;NO, ITS A LABEL OF SOME SORT
JRST REJECT ;WHICH CONSISTS OF ONE WORD
;LOOK FOR NEXT BLOCK HEADER
ENDST: MOVEI C,1 ;TWO WORDS, FIVE TABLES, ONE WORD, ONE TABLE
MOVEI T,6 ;TO GO
F4LUP1: PUSHJ P,WORD ;GET TABLE MEMBER
F4LUP3: SOJGE C,F4LUP1 ;LOOP WITHIN A TABLE
JUMPL T,LOAD1 ;LAST TABLE - RETURN
SOJG T,F4LUP2 ;FIRST TWO WORDS AND FIVE TABLES
JUMPE T,F4LUP1 ;COMMON LENGTH WORD
F4LUP2: PUSHJ P,WORD ;READ HEADER WORD
MOVE C,W ;COUNT TO COUNTER
JRST F4LUP3 ;STASH
SUBTTL LISP LOADER
IFE L,< END BEG>
IFN L,< XLIST
LIT
LIST
LODMAK: MOVEI A,LODMAK
MOVEM A,137 ;SET UP TO SAVE THE LISP LOADER
INIT 17
SIXBIT /DSK/
0
HALT
ENTER LMFILE
HALT
OUTPUT LMLST
STATZ 740000
HALT
RELEASE
EXIT
LMFILE: SIXBIT /LISP/
SIXBIT /LOD/
0
0
LMLST: IOWD 1,.+1 ;IOWD
IOWD LODMAK-LD+1,137 ;AND CORE IMAGE
0
END LODMAK>