.MCALL	.MODULE
.MODULE	LINK,VERSION=45,COMMENT=<Q, Y, U AND V SWITCHES> IDENT=NO,MODNAME=LINK4,GLOBAL=.LINK4

; Copyright (c) 1998 by Mentec, Inc., Nashua, NH.
; All rights reserved
;
; This software is furnished under a license for use only on a
; single computer system and  may  be  copied  only  with  the
; inclusion of the above copyright notice.  This software,  or
; any other copies thereof, may not be provided  or  otherwise
; made available to any other person except for  use  on  such
; system and to one who agrees to these license  terms.  Title
; to  and  ownership of the software shall at all times remain
; in Mentec, Inc.
;
; The information in this document is subject to change without
; notice and should not be construed as a commitment by Digital
; Equipment Corporation, or Mentec, Inc.
;
; Digital and Mentec  assume  no  responsibility for the use or
; reliability of its software on equipment which is not supplied
; by Digital  or Mentec,  and listed  in the  Software  Product
; Description.
.SBTTL	Q, Y, U AND V SWITCHES
.ENABL	GBL

; CER,MAS,DBB

; EDIT HISTORY

; CHANGE TO SUPPORT ABSOLUTE PSECT (ZERO LENGTH & DON'T STORE TEXT)	;CER02
; FIX /S AND STB FILE TEST						;MAS02
; FIX CORE WRAP ON 177777 BASE ADDRESS					;MAS05
; PUT OVERLAY HANDLER IN SYSLIB						;MAS07
; FIX /H FOR OVERLAID PROGRAMS						;MAS14
; XM OVERLAYS ADDED							;MAS15
; ADD /Q SWITCH FOR ROMMING CODE					;MAS20
; ADD SUPPORT FOR GLOBAL SYMBOL CREF					;DBB01
; STANDARDIZE PROGRAMMED REQUESTS					;DBB02
; ADD I-D SPACE VARIABLES						;LB
.SBTTL	SYMBOLIC CONSTANTS

GSD=	1
BYTBLK=	512.		;BYTE BLOCK SIZE

.SBTTL	MISCELLANEOUS MACRO DEFINITIONS

.MCALL	.GTIM,.DATE,.WRITW						;DBB02

.MACRO	ERROR$	ERNB,SEV,ETYP,REG
	.IF NB REG
	.IIF DIF <REG>,<R0> 	MOV 	REG,R0
	.IFF
	.IIF IDN <ETYP>,<E$FIL>	CLR	R0
	.ENDC
	JSR	R5,ERROOT
	.BYTE	ERNB,	SEV*100!ETYP
.ENDM

.MACRO	MAPOUT	MSG
.IF NB MSG
.IIF DIF <MSG>,<R1>	MOV	MSG,R1
.ENDC
	CALL	PUTMSG
.ENDM

.MACRO	SYMADR	R
	ASL	R
	MOV	R,-(SP)
	ASL	R
	ASL	R
	ADD	(SP)+,R
	ADD	SYEN0,R
.ENDM

; IBUF IS USED FOR MAP OUTPUT BUFFER (1 BLOCK)
.PSECT	DATA,D

	.WORD	6	;ERROR HANDLER INDEX(1ST PHYSICAL LOC OF OVLY)
SAVVAL:	.WORD	0	;SAVE R4

.SBTTL	MAP PASS TABLES AND MESSAGES

	.NLIST	BEX
	.ENABL	LC

PTBL:	.RAD50	/$OTABL/	;OVERLAY TABLE PSECT NAME

.SBTTL	TEMPORARY VARIABLES FOR I-D SPACE

ASECAD:	.WORD	0	;/H - SAVE AREA FOR ASECT ADDRESS IN SYMBOL TABLE
BOTADR:	.WORD	0	;/H - SAVE AREA FOR ORIGINAL BOTTOM ADDRESS
OVRREF:	.WORD	0	;NUMBER OF OVERLAY REFERENCES *4 -> $ZTABL SIZE
IR0:	.WORD	0	;I-SPACE PSECT SIZE (/Y,/U)
DR0:	.WORD	0	;D-SPACE PSECT SIZE (/Y,/U)
IR1:	.WORD	0	;I-SPACE SYMTAB ADDR POINTER (/Y,/U)
DR1:	.WORD	0	;D-SPACE SYMTAB ADDR POINTER (/Y,/U)
SAVR3:	.WORD	0	;SAVE R3 FOR /E PROCESSING
SAVRET:	.WORD	0	;SAVE SUBR RETURN ADDRESS (/Y,/U)
SPFLAG:	.WORD	0	;0 -> I-SPACE, NONZERO -> D-SPACE, -1 D PASS DONE (/Y)
TMPEVL:	.WORD	0	;HOLDER FOR I OR D SPACE ESWVAL
TMPHVL:	.WORD	0	;HOLDER FOR I OR D SPACE HSWVAL
TMPUNM:	.WORD	0,0	;HOLDER FOR I OR D SPACE USWNAM
TMPUVL:	.WORD	0	;HOLDER FOR I OR D SPACE USWVAL
TEMP:	.WORD	0	;HOLDER FOR I OR D SPACE BOTTOM ADDRESS (/Y,/U)
ZTABL:	.RAD50	/$ZTABL/ ;I-D SPACE OVERLAY HANDLER PSECT

.PSECT	CODE
.SBTTL	ENDP1	END PASS ONE PROCESSING

;+
; IF THE PROGRAM IS OVERLAYED, GO THROUGH DEFINED SYMBOL TABLE TO
; INDICATE WHICH SYMBOLS GET RESOLVED THROUGH THE OVERLAY HANDLER.
; SYMBOLS THAT DO NOT GO INTO THE OVERLAY HANDLER TABLE ARE:
; 1. SECTION NAME SYMBOLS
; 2. SYMBOLS DEFINED IN ROOT SEGMENT(INCLUDES ABS SYMBOLS)
; 3. SYMBOLS DEFINED IN A "DATA" SECTION (RESOLVED DIRECTLY)
; 4. SYMBOLS NOT REFERENCED OUTSIDE SEGMENT THEY ARE DEFINED
; ALSO, GO THRU SYMBOL TABLE LIST SET ABS PSECT'S TO ZERO LENGTH	;CER02
;-

.ENABL	LSB

ENDP1::	CLRB	PAS1.5		;INIT LIBRARY PASS INDICATOR FOR SAV OUTPUT
;	TSTB	FLGWD		;IS PROGRAM OVERLAYED ?			;CER02
;	BPL	60$		;NO IF +				;CER02
	MOV	#ASECT,R4	;R4 -> ROOT SEGMENT BLK
	MOV	@R4,R1		;GET 1ST SYM PTR
	CLR	R5		;IND PROCESSING ROOT SYMBOLS
	MOV	#SY.IND,R3	;R3 = EXTERNAL REF BIT
	BR	40$		;DON'T ZERO THE LENGTH OF . ABS.

10$:	MOV	S.GNXP(R4),R1	;R1 -> NEXT SEGMENT BLOCK THIS REGION
	BNE	20$		;IF NE THERE IS A NEXT
	INC	R5		;IND NOT PROCESSING ROOT SEGMENT
	MOV	S.GRGP(R4),R4	;R4 -> OVERLAY REGION BLOCK
	MOV	R.GNXP(R4),R4	;NEXT REGION BLOCK ADDRESS
	BEQ	60$		;IF 0 THEN NO MORE REGIONS
	MOV	R.GSGP(R4),R1	;ADR OF SEGMENT BLK THIS REGION
20$:	MOV	R1,R4		;SAVE SEGMENT BLK ADR
30$:	MOV	@R1,R1		;LINK TO NEXT WORD(ENTRY # OF NEXT)
	BIC	#SY.ENB,R1	;MASK OFF SYM PTR INDICATORS
	BEQ	10$		;IF 0 THEN END OF CHAIN FOR SEGMENT
	SYMADR	R1		;CALC. PTR TO SYMB NODE
	MOV	S.YSN(R1),R2	;R2 = CURRENT SECTION FLAG WD
	BIT	#SY.SEC,R2	;BIT SET IF A SECTION?			;CER02+
	BEQ	40$		;NOT A SECTION IF EQ			
	BIT	#CS$REL*400,R2	;ABSOLUTE SECTION?			
	BNE	40$		;NO IF NE				
	CLR	S.YVAL(R1)	;ABS PSECT HAS A LENGTH OF ZERO		;CER02-
40$:	TST	R5		;ROOT SYMBOLS DO NOT GET RESOLVED THRU
	BEQ	50$		;OVERLAY HANDLER
	BIT	#CS$TYP*400!SY.SEC,R2 ;SYM FROM DATA SEC OR SEC NAME NOT AFFECTED
	BNE	50$		;YES IF NE
	BIT	#CS$REL*400,R2	;ABSOLUTE SYMBOL ?
	BEQ	50$		;YES IF 0
	BIT	@R1,R3		;WAS SYMBOL REFERENCED OUTSIDE SEGMENT ?
	BEQ	50$		;NO IF 0
	ADD	#8.,OVCOUN	;SYM GOES IN OVR HNDLR TBL(4 WDS PER ENTRY)
	BIT	SWIT1,#SW.J	;ARE WE ALSO DOING /J?
	BEQ	30$		;BRANCH IF NOT
	SUB	#4,OVCOUN	;REMOVE THE JSR,R5 INST SIZE
	ADD	#4,OVRREF	;ADD 4 BYTES FOR EACH OVERLAY REFERENCE 
	BR	30$		;CONTINUE

50$:	BIC	R3,@R1		;SAY SYMBOL RESOLVED DIRECTLY
	BR	30$		;R1 -> ENTRY # PTR

;+
; NOW LOOKUP IN SYMBOL TABLE FOR THE VIRTUAL SECTION, IF IT IS THERE
; ZERO IT'S VALUE WORD(INDICATES SIZE OF SECTION) SO DOES NOT
; CONTRIBUTE TO SIZE OF PROGRAM DURING MAP PASS
;-

.PSECT	DATA,D

VSEC:	.RAD50	\. VIR.\	;VIRTUAL SECTION SYMBOL NAME

.PSECT	CODE

60$:	MOV	#VSEC,R3	;R3 -> VIRTUAL SECTION SYMBOL
	MOV	#SY.SEC,LKWD	;SECTION NAME LOOKUP
	MOV	#^CSY.SEC,LKMSK	;CARE ABOUT SECTION FLG
	CALL	LOOKUP		;LOOK IT UP BUT DON'T ENTER IT
	BCS	70$		;C=1 IF NOT FOUND
	CLR	-(R0)		;CLEAR IT'S VALUE WORD


;+
; IF /E WAS GIVEN FOR THE EXTEND SECTION THEN LOOK IT UP IN THE
; SYMBOL TABLE TO EXTEND SIZE OF SECTION TO VALUE GIVEN.
;-

70$:	BIT	SWITCH,#SW.E	;WAS /E INDICATED ?
	BEQ	160$		;NO IF 0
	BIT	SWIT1,#SW.J	;ARE WE ALSO DOING /J?
	BEQ	90$		;BRANCH IF NOT
	BIT	#D.SWE,IDSWIT	;D-SPACE SPECIFIED?
	BEQ	90$		;BRANCH IF NOT
	MOV	SP,SPFLAG	;SAY WE'RE PROCESSING D-SPACE
	MOV	#DESWNM,R3	;GET /E D-SPACE NAME ADDRESS
	MOV	DESWVL,TMPEVL	;GET /E D-SPACE VALUE
	CALL	ETEST		;DO /E PROCESSING
80$:	BIT	#I.SWE,IDSWIT	;I-SPACE SPECIFIED?
	BEQ	100$		;BRANCH IF NOT
	CLR	SPFLAG		;SAY WE'RE PROCESSING I-SPACE
90$:	MOV	#ESWNAM,R3	;R3 -> EXTEND SECTION NAME
	MOV	ESWVAL,TMPEVL	;GET /E I-SPACE VALUE
	CALL	ETEST		;DO /E PROCESSING
100$:	BR	160$		;MERGE BELOW


ETEST:	MOV	R3,SAVR3	;SAVE /H VALUE
	CALL	LOOKUP		;SECTION NAME LOOKUP
				; (LKWD & LKMSK ALREADY SETUP)
	MOV	SAVR3,R3	;RESTORE R3 
	BCC	120$		;C=0 IF FOUND
110$:	ERROR$	ERR54,E$W,E$SYM,R3 ;EXTEND SECTION NOT FOUND <SYMBOL>
	BR	150$		;MERGE BELOW

120$:	BIT	#CS$REL*400,S.YSN(R0) ;CAN'T EXTEND THE SIZE OF ABS SECTION ;CER02
	BEQ	110$		;ABS IF EQ SO GIVE ERROR		;CER02
	BIT	SWIT1,#SW.J	;ARE WE ALSO DOING /J?
	BEQ	140$		;BRANCH IF NOT
	BIT	#CS$TYP*400,S.YSN(R0) ;I OR D-SPACE PSECT?
	BEQ	130$		;BRANCH IF I-SPACE
	TST	SPFLAG		;WE HAVE A D-SPACE PSECT, ARE WE PROC D-SPACE?
	BNE	140$		;BRANCH IF YES
	ERROR$	ERR104,E$W,E$SYM,R3 ;EXTEND SECTION NOT IN I-SPACE <SYMBOL>
	BR	150$		;MERGE BELOW

130$:	TST	SPFLAG		;WE HAVE I-SPACE PSECT, ARE WE PROC I-SPACE?
	BEQ	140$		;BRANCH IF YES
	ERROR$	ERR103,E$W,E$SYM,R3 ;EXTEND SECTION NOT IN D-SPACE <SYMBOL>
	BR	150$		;MERGE BELOW

140$:	CMP	TMPEVL,-(R0)	;EXTEND VALUE MUST BE .GT. FORCED SIZE ?
	BLO	150$		;IF LO THEN NO CHANGE
	MOV	TMPEVL,@R0	;UPDATE SIZE
150$:	RETURN			;FROM WHENCE WE CAME

.SBTTL	-	SETUP THE BUFFERS BEFORE GOING TO THE MAP PASS

160$:	MOV	#IBUF,R0	;R0 -> IBUF & 2(R0) -> IBFSIZ
	MOV	HGHLIM,STLML	;MAX # OF SECTIONS IN ANY ONE MODULE(REMEMBER IT)
	MOV	@R0,OBUF	;OUTPUT BUFR STARTS WHERE INPUT DID
	ADD	#512.,(R0)+	;IBUF IS 1 BLOCKSIZE LATER
	SUB	#256.,@R0	;REDUCE INPUT WORD COUNT
	DEC	IBKINC		; & # OF INPUT BLOCKS READ
	MOV	-(R0),EIB512	;DETERMINE THE END OF A 1 BLOCK BUFR
	ADD	#512.,EIB512	;TO BE USED FOR THE MAP OUTPUT.
	TST	MBPTR		;IS A MAP DESIRED ?
	BNE	180$		;YES
	BIT	SWITCH,#SW.S	;IF /S AND STB FILE REQUESTED
	BEQ	170$		;THEN EIB512 GETS IBUF
	BIT	FLGWD,#FG.STB
	BEQ	170$							;MAS02
	MOV	@R0,EIB512	;STB BUFFER USES IBUF AREA
170$:	BR	MAP		;GO TO POST PASS1 ROUTINE

180$:	MOV	@R0,MBPTR	;INIT MAP BUFR PTR TO IBUF
	BR	MAP		;GO TO POST PASS1 ROUTINE

.DSABL	LSB
.SBTTL	MAP	 START PROCESSING FOR MAP, AND Q,U,V,Y SWITCHES

AS2BIG:	ERROR$	ERR14,E$F,E$PRT	;ASECT IS TOO BIG

MAP:	CLR	SEGBAS		;N VALUE (V:N:M) FOR /V REGION FLAG	;MAS15+
	CLR	VIRSIZ		;SIZE OF THE LARGEST PARTITION IN /V REGION
	CLR	HIPHYS		;PARTITION EXTENDED ADDR HIGH LIMIT
	CLR	SEGBLK		;BASE OF PREVIOUS XM PARTITION		;MAS15-
	BIT	FLGWD,#FG.STB	;IS THERE AN STB FILE?
	BEQ	20$		;NO,
	MOV	#TXTBLK+6,R0	;FILL UP PREFIX PART
	MOV	#GSD,(R0)+	;THIS IS A GSD FB BLOCK
	MOV	#MODNAM,R3	;FIRST GSD ENTRY IS MODULE NAME
	MOV	(R3)+,(R0)+	;2 WORDS OF NAME
	MOV	(R3)+,(R0)+
	CLR	(R0)+		;CODE BYTE INDICATES MODULE NAME
	CLR	(R0)+
	TST	@R3		;IS THERE AN IDENTIFICATION?
	BEQ	10$		;NO
	MOV	(R3)+,(R0)+	;YES, PUT IN THE IDENT NAME
	MOV	(R3)+,(R0)+
	MOV	#6*400,(R0)+	;THIS IS AN IDENT
	CLR	(R0)+
10$:	MOV	(PC)+,(R0)+	;EVERYTHING IS IN THE ASECT
	 .RAD50	/. A/
	MOV	#^RBS.,(R0)+
	MOV	#1*400,(R0)+	;THIS IS A SECTION NAME
	CLR	(R0)+		;ZERO LENGTH
	MOV	R0,TXTBLK	;SAVE POINTER TO NEXT FREE
	MOV	#ESWVAL,R0	;INITIALIZE OUTPUT POINTERS
	CLR	(R0)+		;BLOCK 0
	MOV	EIB512,(R0)+	;USE LOAD MODULE OUTPUT AREA FOR BUFR
	MOV	#BYTBLK,@R0	;512 BYTE BUFFER
20$:	MOV	BOTTOM,R4	;GET SPECIFIED BOTTOM ADDRESS
	BIT	SWIT1,#SW.J	;ARE WE ALSO DOING /J?
	BEQ	30$		;BRANCH IF NOT
	MOV	DBOTTM,R4	;.ABS IS D-SPACE FOR I-D SPACE	
30$:	MOV	ASECT,R3	;R3 -> START OF SYMBOL CHAIN
	CMP	-(R3),R4	;IS "BOTTOM" .GE. SIZE OF ASECT ?
	BLOS	50$		;YES
	TSTB	SWITCH		;IF /R  GIVE ERROR
	BMI	AS2BIG		;ASECT IS TOO BIG FOR REL FILES
	MOV	@R3,R4		;NO, USE SIZE OF ASECT
	BIT	SWIT1,#SW.J	;ARE WE ALSO DOING /J?
	BEQ	40$		;BRANCH IF NOT
	MOV	R4,DBOTTM	; AS BOTTOM ADDRESS (D-SPACE)
	BR	50$
	
40$:	MOV	R4,BOTTOM	; AS BOTTOM ADDRESS
50$:	TSTB	FLGWD		;IS PROGRAM OVERLAID?			;MAS07+
	BPL	80$		;NO IF +				
	MOV	R3,-(SP)	;SAVE R3				
	MOV	#SY.SEC,LKWD	;SET UP TO LOOK UP OVERLAY TABLE	
	MOV	#^CSY.SEC,LKMSK	;PSECT AND ENTER CORRECT LENGTH		
	MOV	#PTBL,R3	;R3->$OTABL				
	CALL	LOOKUP		;LOOK IT UP				
	BCC	60$		
	JMP	ILERR		;C=1 NOT FOUND-SHOULDN'T HAPPEN

60$:	MOV	OVCOUN,S.YVAL(R0) ;SPACE FOR WDBS, SEG. DESCS., XFER VECTORS
	BIT	SWIT1,#SW.J	;ARE WE ALSO DOING /J?
	BEQ	70$		;BRANCH IF NOT
	MOV	#SY.SEC,LKWD	;SET UP TO LOOK UP $ZTABL	
	MOV	#^CSY.SEC,LKMSK	;PSECT AND ENTER CORRECT LENGTH		
	MOV	#ZTABL,R3	;R3->$ZTABL
	CALL	LOOKUP		;LOOK IT UP				
	BCS	ILERR		;C=1 NOT FOUND-SHOULDN'T HAPPEN		
	MOV	OVRREF,S.YVAL(R0) ;STORE SIZE OF $OVJSR TABLE
70$:	MOV	(SP)+,R3	;RESTORE R3				;MAS07-
80$:	MOV	R4,(R3)+	;SAVE ASECT TRUE SIZE
.SBTTL	HSWT	PROCESS /H SWITCH

;+
; IF /H WAS GIVEN, ADD UP ALL THE SECTION SIZES IN THE ROOT SEGMENT AND
; THE SIZE OF THE LARGEST SEGMENT OF EACH /O REGION. THIS GIVES THE MINIMUM
; VALUE FOR "HSWVAL". IF /H VALUE WAS LARGE ENOUGH, ADJUST THE VALUE OF
; "BOTTOM" TO EFFECT LINKING TO TOP. (TOP = HIGH LIMIT OF ROOT + /O OVERLAYS.)
; THE ASECT IS I-SPACE.
;
; 	I-D SPACE (/J)
; THE ABOVE ALGORITHM IS USED SEPARATELY FOR EACH SPACE. 
; ADJUST DBOTTM FOR D SPACE.
; I-SPACE OVERLAYS HAVE A 3 WORD ID.  D-SPACE OVERLAYS HAVE NO ID.
; THE ASECT IS D-SPACE 
;
; INPUT: R3 = ADR OF ASECT IN SYMBOL TBL
; OUTPUT: R4 = SIZE OF ASECT (D-SPACE IF /J)
;-

HSWT:	BIT	SWITCH,#SW.H	;WAS THERE A /H VALUE?
	BEQ	UYSWT		;NO, RESOLVE ALL ADDRESSES
	MOV	#BOTTOM,R5	;R5 -> DUMMY OVERLAY REGION BLOCK
	BIT	SWIT1,#SW.J	;ARE WE ALSO DOING /J?
	BEQ	30$		;BRANCH IF NOT
	MOV	R5,BOTADR	;SAVE ORIGINAL BOTTOM ADDRESS
	MOV	R3,ASECAD	;SAVE ORIGINAL ASECT ADDRESS
	BIT	#D.SWH,IDSWIT	;D-SPACE SPECIFIED?
	BEQ	20$		;BRANCH IF NOT
	MOV	SP,SPFLAG	;SAY WE ARE DOING D-SPACE
	MOV	DHSWVL,TMPHVL	;GET /H D-SPACE VALUE
	BR	40$

10$:	BIT	#I.SWH,IDSWIT	;I-SPACE SPECIFIED?
	BEQ	UYSWT		;BRANCH IF NOT, WE'RE DONE
	MOV	BOTADR,R5	;RESTORE ORIGINAL BOTTOM ADDRESS
	MOV	ASECAD,R3	;RESTORE ORIGINAL ASECT ADDRESS
20$:	CLR	SPFLAG		;SAY WE ARE DOING I-SPACE
30$:	MOV	HSWVAL,TMPHVL	;GET /H I-SPACE VALUE
40$:	MOV	TMPHVL,-(SP)	;GET /H VALUE
	MOV	R.GSGP(R5),R1	;SET UP R1				;MAS14
	CLR	R0		;R0 = TOTAL SIZE (NO ID WORD IN ROOT)
	MOV	R3,R2		;R2 -> ASECT TABLE ENTRY
	CLR	-(SP)		;INIT HIGHEST SEGMENT SIZE SO FAR
	CALL	SIZE1		;GET SIZE OF SEGMENT			;MAS15+
	BR	70$		;PROCESS ROOT SEGMENT SIZE

50$:	TST	R.GNB(R5)	;IS THIS A /V REGION?	
	BMI	120$		;- -> /V -> DONE WITH ROUNDING		;MAS15-
	MOV	R.GSGP(R5),R1	;R1 -> FIRST OVERLAY SEGMENT BLOCK
	CLR	-(SP)		;THIS IS THE HIGHEST SEGMENT SIZE SO FAR
60$:	CALL	SIZSEG		;GET SEGMENT SIZE			;MAS15
70$:	CMP	@SP,R0		;IS THIS THE LARGEST SEGMENT THIS REGION
	BHIS	80$		;NO
	MOV	R0,@SP		;YES, REMEMBER THE LARGEST
80$:	MOV	#2,R0		;AND ALL FURTHER SEGMENTS HAVE ID WORD
	BIT	SWIT1,#SW.J	;ARE WE ALSO DOING /J?
	BEQ	90$		;BRANCH IF NOT
	CLR	R0		;ASSUME D-SPACE - NO OVERLAY ID 
	TST	SPFLAG		;ARE WE DOING I-SPACE?
	BNE	90$		;BRANCH IF NOT
	MOV	#6,R0		;I-SPACE HAS 3 WORD ID, D-SPACE NONE
90$:	MOV	S.GNXP(R1),R1	;R1 -> NEXT SEGMENT THIS REGION		;MAS14
	BNE	60$		;GOT ONE (ALWAYS FAILS FOR ROOT)
	BIT	2(SP),TMPHVL	;IS THIS THE FIRST REDUCTION OF /H:0?	;MAS14
	BEQ	100$		;YES, IGNORE ERROR
	SUB	(SP)+,@SP	;DECREASE HIGH LIMIT BY SEGMENT SIZE
	BHIS	110$		;OK
	ERROR$	ERR27,E$F,E$PRT	;/H VAL TOO LOW

100$:	SUB	(SP)+,@SP	;DECREASE /H:0 BY FIRST NON-0 SEGMENT
110$:	MOV	R.GNXP(R5),R5	;POINT TO NEXT OVERLAY REGION
	BNE	50$		;AND PROCESS IT
120$:	BIT	SWIT1,#SW.J	;ARE WE ALSO DOING /J?
	BEQ	140$		;BRANCH IF NOT
	TST	SPFLAG		;ARE WE DOING I-SPACE?
	BEQ	130$		;BRANCH IF YES
	ADD	@SP,DBOTTM	;ADJUST TO GET THE D-SPACE HIGH LIMIT
	ADD	(SP)+,R4	;AND FIX ASECT OVERHEAD
	BR	10$		;GO TRY FOR I-SPACE

130$:	ADD	(SP)+,BOTTOM	;ADJUST TO GET A HIGH LIMIT
	BR	UYSWT

140$:	ADD	@SP,BOTTOM	;ADJUST TO GET A HIGH LIMIT
	ADD	(SP)+,R4	;AND FIX ASECT OVERHEAD

.SBTTL	UYSWT	PROCESS /U & /Q SWITCHES

;+
; SCAN THE ROOT SEGMENT FOR THE SECTION NAME, ADDING UP THE SIZES AS WE GO.
; WHEN A /U OR /Y SECTION IS FOUND, PROCESS SWITCHES AS FOLLOWS:
;
; 1./Y PROCESSING: DETERMINE AMOUNT TO ADD TO PREVIOUS SECTION
;   TO MAKE /Y SECTION START ON MULTIPLE OF VALUE GIVEN.
;
; 2./U PROCESSING: ADD THE /U SWITCH ROUND FACTOR TO ITS SIZE. 
;   IF /H WAS ALSO GIVEN MUST UPDATE "BOTTOM" BY THE AMOUNT ROUNDED.
;
; INPUT: R3 = ADR OF ASECT SYM TBL ENTRY
;-

.ENABL	LSB

UYSWT:	BIT	SWITCH,#SW.U!SW.Y ;/U OR /Y ?
	BNE	10$		;IF YES, BRANCH
	JMP	VRSWT		;NO (BEQ NEXT SWITCH PROCESSING)

;+
; THIS IS THE START OF THE LOOP FOR BOTH I AND D SPACE
;-

10$:	BIT	SWIT1,#SW.J	;ARE WE ALSO DOING I-D SPACE?
	BNE	20$		;BRANCH IF YES
	JMP	200$		;BRANCH IF NOT

ILERR:	ERROR$	ERR0,E$F,E$PRT	;ILLEGAL ERROR				

;+
; D-SPACE FIRST
;-
20$:	BIT	IDSWIT,#<D.SWY!D.SWU> ;ARE WE DOING D-SPACE?
	BEQ	80$		;IF NOT D-SPACE, THEN WE'RE DOING I-SPACE
	MOV	SP,SPFLAG	;SAY WE'RE DOING D-SPACE
	CALL	INIT		;INIT FOR LOOP
	CALL	SECSR1		;SEARCH FOR SECTION NAME
	BCS	70$		;BRANCH IF END OF SYM TAB
	BIT	IDSWIT,#D.SWY	;/Y?
	BEQ	40$		;BRANCH IF NOT
30$:	MOV	R4,SAVVAL	;SAVE R4
	MOV	#DYSWNM,R4	;POINT TO DYSWNM
	CALL	SWYSEC		;D-SPACE ENTRY POINT
40$:	BIT	IDSWIT,#D.SWU	;/U?
	BEQ	50$		;BRANCH IF NOT
	MOV	SP,SPFLAG	;SAY WE'RE DOING D-SPACE
	MOV	DUSWNM,TMPUNM	;WE HAVE D-SPACE	
	MOV	DUSWNM+2,TMPUNM+2 ;WE HAVE D-SPACE	
	CALL	SWUSEC		;SEARCH FOR ROUND SECTION
	TST	R1		;FOUND IT?
	BNE	60$		;BRANCH IF YES
50$:	CALL	SECCHK		;CHECK PSECT SIZE 
	CALL	SECSRH		;SEARCH SYM TAB FOR THE NEXT SECTION
	BCC	30$		;FOUND ONE, GO AGAIN
	BR	70$		;END OF SYM TAB, MERGE BELOW

60$:	CALL	SECCHK		;CHECK PSECT SIZE
70$:	MOV	R0,DR0		;SAVE D-SPACE MAX PSECT SIZE (FROM SECCHK)
	MOV	R1,DR1		;SAVE D-SPACE PTR TO SYMTAB ENTRY FOR PSECT
				; (FROM SWUSEC)
	CALL 	SWYERR		;SEE IF ANY D-SPACE ERRORS

;+
; END OF D-SPACE PASS
;-

;+
; START OF I-SPACE PASS
;-

	BIT	IDSWIT,#<I.SWY!I.SWU> ;ARE WE DOING I-SPACE?
	BEQ	140$		;BRANCH IF NOT, MERGE BELOW
80$:	CLR	SPFLAG		;SAY WE'RE DOING I-SPACE
	CALL	INIT		;INIT FOR LOOP
	CALL	SECSR1		;SEARCH FOR SECTION NAME
	BCS	130$		;BRANCH IF END OF SYM TAB
	BIT	IDSWIT,#I.SWY	;/Y?
	BEQ	100$		;BRANCH IF NOT
90$:	MOV	R4,SAVVAL	;SAVE R4
	MOV	#<YSWNAM-4>,R4	;POINT TO YSWNAM
	CALL	SWYSEC		;I-SPACE ENTRY POINT
100$:	BIT	IDSWIT,#I.SWU	;/U?
	BEQ	110$		;BRANCH IF NOT
	CLR	SPFLAG		;SAY WE'RE DOING I-SPACE
	MOV	USWNAM,TMPUNM	;WE HAVE I-SPACE	
	MOV	USWNAM+2,TMPUNM+2 ;WE HAVE I-SPACE	
	CALL	SWUSEC		;SEARCH FOR ROUND SECTION
	TST	R1		;FOUND IT?
	BNE	120$		;BRANCH IF YES
110$:	CALL	SECCHK		;CHECK PSECT SIZE 
	CALL	SECSRH		;SEARCH SYM TAB FOR THE NEXT SECTION
	BCC	90$		;FOUND ONE, GO AGAIN
	BR	130$		;END OF SYM TAB, MERGE BELOW

120$:	CALL	SECCHK		;CHECK PSECT SIZE
130$:	MOV	R0,IR0		;SAVE I-SPACE MAX PSECT SIZE (FROM SWUCHK)
	MOV	R1,IR1		;SAVE I-SPACE PTR TO SYMTAB ENTRY FOR PSECT
				; (FROM SWUSEC)
	CALL 	SWYERR		;SEE IF ANY I-SPACE ERRORS

;+
; END OF I-SPACE PASS
; END OF LOOP FOR BOTH I AND D SPACE
;-

;+
; 		/U AND /Y CONTINUED 
;
; BOTH I AND D PROCESSING
;-

140$:	BIT	IDSWIT,#<D.SWY!D.SWU> ;ARE WE DOING D-SPACE?
	BEQ	170$		;BRANCH IF NOT
	MOV	SP,SPFLAG	;SAY WE'RE DOING D-SPACE
	MOV	DUSWVL,TMPUVL	;GET D-SPACE ROUNDING FACTOR
	MOV	DR0,R0		;RESTORE D-SPACE PSECT SIZE
	MOV	DR1,R1		;GET PTR TO D-SPACE PSECT SYMTAB ENTRY
	CALL	SWURND		;ROUND THE PSECT
	BCC	150$		;BRANCH IF PSECT FOUND
	CALL	SWUERR		;PRINT ERRORS
	BR	170$		;TRY FOR I-SPACE

150$:	BIT	SWITCH,#SW.H	;/H?
	BEQ	160$		;NO
	MOV	#DBOTTM,TEMP	;GET D-SPACE BOTTOM ADDRESS
	MOV	DBOTTM,R0	;GET DBOTTM
160$:	CALL	SETBOT		;FIX D-SPACE BOTTOM ADDRESS
170$:	BIT	IDSWIT,#<I.SWY!I.SWU> ;ARE WE DOING I-SPACE?
	BEQ	250$		;BR IF NOT, WE'RE DONE, GO OUT TO VRSWT
	CLR	SPFLAG		;SAY WE'RE DOING I-SPACE
	MOV	USWVAL,TMPUVL	;GET I-SPACE ROUNDING FACTOR
	MOV	IR0,R0		;RESTORE I-SPACE PSECT SIZE
	MOV	IR1,R1		;GET PTR TO I-SPACE PSECT SYMTAB ENTRY
	CALL	SWURND		;ROUND THE PSECT
	BCC	180$		;BRANCH IF PSECT FOUND
	CALL	SWUERR		;PRINT ERRORS
	BR	250$		;NO MORE /U, GO OUT

180$:	BIT	SWITCH,#SW.H	;/H?
	BEQ	190$		;NO
	MOV	#BOTTOM,TEMP	;GET I-SPACE BOTTOM ADDRESS
	MOV	BOTTOM,R0	;GET BOTTOM
	MOV	R4,-(SP)	;INPUT R4 IS D-SPACE - SAVE IT
	MOV	R0,R4		;I-SPACE BOTTOM
	CALL	SETBOT		;FIX I-SPACE BOTTOM ADDRESS
	MOV	(SP)+,R4	;RESTORE D-SPACE BOTTOM
	BR	250$		;WE'RE DONE, GO OUT TO VRSWT

190$:	CALL	SETBOT		;FIX I-SPACE BOTTOM ADDRESS
	BR	250$		;WE'RE DONE, GO OUT TO VRSWT

;+
; /U AND /Y NON I-D SPACE PROCESSING
;-

200$:	CALL	INIT		;INIT FOR LOOP
	CALL	SECSR1		;SEARCH FOR SECTION NAME
	BCS	220$		;BRANCH IF END OF SYM TAB
210$:	MOV	R4,SAVVAL	;SAVE R4
	MOV	#<YSWNAM-4>,R4	;POINT TO YSWNAM
	CALL	SWYSEC		;I-SPACE ENTRY POINT
	MOV	USWNAM,TMPUNM	;WE HAVE I-SPACE	
	MOV	USWNAM+2,TMPUNM+2 ;WE HAVE I-SPACE	
	CALL	SWUSEC		;SEARCH FOR ROUND SECTION
	CALL	SECCHK		;CHECK PSECT SIZE
	CALL	SECSRH		;SEARCH SYM TAB FOR THE NEXT SECTION
	BCC	210$		;FOUND ONE, GO AGAIN
220$:	CALL 	SWYERR		;SEE IF ANY I-SPACE ERRORS
	MOV	USWVAL,TMPUVL	;GET I-SPACE ROUNDING FACTOR
	CALL	SWURND		;ROUND THE PSECT
	BCC	230$		;BRANCH IF PSECT FOUND
	CALL	SWUERR		;PRINT ERRORS
	BR	250$		;NO MORE /U, GO OUT

230$:	BIT	SWITCH,#SW.H	;/H?
	BEQ	240$		;NO
	MOV	#BOTTOM,TEMP	;GET I-SPACE BOTTOM ADDRESS
	MOV	BOTTOM,R0	;GET BOTTOM
240$:	CALL	SETBOT		;FIX I-SPACE BOTTOM ADDRESS
250$:	JMP	VRSWT		;CONTINUE

.DSABL	LSB
;+
; /U AND /Y SUPPORT SUBROUTINES
;-

.ENABL	LSB

;+
; INIT - INIT FOR /U AND /Y
;-

INIT:	MOV	(SP)+,SAVRET	;SAVE RETURN ADDRESS
	CLR	R0		;START AT SIZE 0
	BIT	SWIT1,#SW.J	;ARE WE ALSO DOING I-D SPACE?
	BEQ	10$		;BRANCH IF NOT
	TST	SPFLAG		;ARE WE DOING D-SPACE?
	BNE	10$		;BRANCH IF YES
	MOV	BOTTOM,R0	;START AT BOTTOM FOR I SPACE
10$:	CLR	R1		;START AT SECT TO EXTEND NOT FND
	CLR	-(SP)		;START AT SECT TO BOUND NOT FND
	MOV	R3,R2		;R2 -> ROOT'S BEGINNING
	MOV	R3,R5		;INIT PREVIOUS SECTION FOR /Y		;CER02
	MOV	SAVRET,-(SP)	;RESTORE RETURN ADDRESS
	RETURN
.DSABL	LSB

.ENABL	LSB

;+
; SECSRH - SEARCH FOR NEXT SEGMENT 
;-

SECSRH:
10$:	MOV	@R2,R2		;R2 -> NEXT SYMBOL
	BIC	#SY.ENB,R2	;ISOLATE POINTER
	BEQ	40$		;EQ -> DONE SCANNING
	SYMADR	R2		;R2 -> SYMBOL BLOCK
SECSR1:	BIT	S.YSN(R2),#SY.SEC ;SECTION?
	BEQ	10$		;NO
	BIT	SWIT1,#SW.J	;ARE WE ALSO DOING I-D SPACE?
	BEQ	30$		;BRANCH IF NOT
	BIT	S.YSN(R2),#CS$TYP*400 ;IS THIS AN I-SPACE PSECT?
	BEQ	20$		;BRANCH IF YES
	TST	SPFLAG		;WE HAVE A D-SPACE PSECT, ARE WE PROC D-SPACE?
	BEQ	10$		;BRANCH IF NOT
	BR	30$		;MERGE BELOW

20$:	TST	SPFLAG		;WE HAVE I-SPACE PSECT, ARE WE PROC I-SPACE?
	BNE	10$		;BRANCH IF NOT
30$:	TST	(PC)+		;FOUND ONE, C=0
40$:	SEC			;DONE SCANNING
50$:	RETURN

.DSABL	LSB

.ENABL	LSB

;+
; SWYSEC - FIND SEGMENT SPECIFIED IN /Y SWITCH
;-

SWYSEC:	MOV	(SP)+,SAVRET	;SAVE RETURN ADDRESS
	BIT	SWITCH,#SW.Y	;/Y ?
	BEQ	90$		;BRANCH IF NOT
	BIT	SWIT1,#SW.J	;ARE WE DOING I-D SPACE?
	BEQ	10$		;BRANCH IF NOT
	TST	SPFLAG		;ARE WE DOING D-SPACE?
	BNE	30$		;BRANCH IF YES
10$:	TST	(R4)+		;POINT TO SLOT IN ARRAY YSWNAM
20$:	TST	(R4)+		;ARE THERE ANY MORE NAMES?
	BEQ	90$		;IF BLANK, NO MORE, SO BRANCH
30$:	CMP	S.YNAM(R2),(R4)+ ;IS SECTION NAME FOR /Y ?
	BNE	10$		;NO
	CMP	S.YNAM+2(R2),(R4)+
	BNE	20$
	BIT	#CS$REL*400,S.YSN(R5) ;IS PREVIOUS SECTION ABSOLUTE?	;CER02
	BEQ	90$		;YES IF EQ THEN NOT ALLOWED		;CER02
	BIT	SWIT1,#SW.J	;ARE WE ALSO DOING I-D SPACE?
	BEQ	50$		;BRANCH IF NOT
	BIT	S.YSN(R2),#SY.SPA ;IS THIS AN I-SPACE PSECT?
	BEQ	40$		;BRANCH IF YES
	TST	SPFLAG		;WE HAVE A D-SPACE PSECT, ARE WE PROC D-SPACE?
	BNE	50$		;BRANCH IF YES
	BR	20$		;NO, CONTINUE

40$:	TST	SPFLAG		;WE HAVE AN I-SPACE PSECT, ARE WE PROC I-SPACE?
	BNE	20$		;NO, CONTINUE
50$:	INC	@SP		;INDICATE FOUND /Y SECTION
	MOV	R0,-(SP)	;SAVE CURRENT RUNNING SUM
	MOV	@R4,-(SP)	;GET BOUNDARY MULTIPLE (YSWVAL)
	NEG	@SP		;LESS 1 FOR A MASK & NOW FIND
	BIC	(SP)+,R0	; THE ADDITIONAL AMOUNT
	BEQ	60$		;ADD 0, NO CORRECTION
	NEG	R0		;ELSE FIND THE
	ADD	@R4,R0		; ADDITIONAL AMOUNT
60$:	ADD	R0,S.YVAL(R5)	; TO THE SECTION BEFORE THE /Y
	BCC	70$		;C=0 IF OK
	MOV	R0,-(SP)	;SAVE RUNNING SUM
	ADD	#S.YNAM,R0	;R0 -> SECTION NAME
	ERROR$	ERR47,E$W,E$SYM,R0 ;SIZE OVERFLOW OF SECTION <SYMBOL>
	MOV	(SP)+,R0
70$:	ADD	R0,@SP		;ALSO UPDATE RUNNING SUM
	BCC	80$
	TST	(SP)+		;CLEAN UP STACK ON FATAL ERROR
	JMP	TOOBIG		;C=1 IF ADDRESSING OVERFLOW
	
80$:	MOV	(SP)+,R0	;RESTORE RUNNING SUM
90$:	MOV	SAVVAL,R4	;RESTORE R4
100$:	MOV	SAVRET,-(SP)	;RESTORE RETURN ADDRESS
	RETURN

.DSABL	LSB

.ENABL	LSB

;+
; SWUSEC - FIND SEGMENT SPECIFIED IN /U SWITCH
;-

SWUSEC:	BIT	SWITCH,#SW.U	;/U ?
	BEQ	20$		;BRANCH IF NOT
	CMP	S.YNAM(R2),TMPUNM ;YES, OUR NAME?
	BNE	20$		;NO
	CMP	S.YNAM+2(R2),TMPUNM+2 ;MIGHT BE
	BNE	20$		;BUT IT ISN'T
	BIT	#CS$REL*400,S.YSN(R2) ;ROUND SECTION CAN'T BE ABS	;CER02
	BEQ	20$		;ABS IF EQ				;CER02
	MOV	R2,R1		;IT IS, REMEMBER THE POINTER
	BIT	SWIT1,#SW.J	;ARE WE ALSO DOING I-D SPACE?
	BEQ	20$		;BRANCH IF NOT
	BIT	S.YSN(R2),#SY.SPA ;IS THIS AN I-SPACE PSECT?
	BEQ	10$		;BRANCH IF YES
	TST	SPFLAG		;WE HAVE A D-SPACE PSECT, ARE WE PROC D-SPACE?
	BNE	20$		;BRANCH IF YES
	CLR	R1		;SECTION NOT FOUND
	BR	20$

10$:	TST	SPFLAG		;WE HAVE AN I-SPACE PSECT, ARE WE PROC I-SPACE?
	BEQ	20$		;BRANCH IF YES
	CLR	R1		;SECTION NOT FOUND
20$:	RETURN

.DSABL	LSB


.ENABL	LSB

;+
; SECCHK 
;
; CHECK PSECT SIZE
; SAVE SIZE IN R2 FOR /Y
;-

SECCHK:	INC	R0		;WAS EVEN NOW MAKE ODD
	BEQ	TOOBIG		;PREVENT WRAP ON R0=177777		;MAS05
	ADD	S.YVAL(R2),R0	;COLLECT SIZE
	BCS	TOOBIG		;C=1 IF ADDRESSING OVERFLOW
	BIC	#1,R0		;GET RID OF ODD IF ADDED EVEN SIZE
	MOV	R2,R5		;REMEMBER PREVIOUS SECTION FOR /Y
;	JMP	10$		;AND LOOP
	RETURN

.DSABL	LSB

.ENABL	LSB

;+
; SWYERR - /Y ERROR MESSAGES
;-

SWYERR:	MOV	(SP)+,SAVRET	;SAVE RETURN ADDRESS
	BIT	SWITCH,#SW.Y	;WAS THIS FOR /Y
	BEQ	30$		;NO
	TST	(SP)+		;YES, DID WE FIND ITS SECTION
	BNE	30$		;BRANCH IF YES
	BIT	SWIT1,#SW.J	;ARE WE ALSO DOING I-D SPACE?
	BEQ	20$		;BRANCH IF NOT
	TST	SPFLAG		;ARE WE PROCESSING D-SPACE?
	BEQ	10$		;BRANCH IF NOT
	ERROR$	ERR101,E$W,E$PRT ;BOUNDARY SECTION NOT IN D-SPACE
	BR	30$

10$:	ERROR$	ERR102,E$W,E$PRT ;BOUNDARY SECTION NOT IN I-SPACE
	BR	30$

20$:	ERROR$	ERR25,E$W,E$PRT	;BOUNDARY SECTION NOT FOUND
30$:	MOV	SAVRET,-(SP)	;RESTORE RETURN ADDRESS
	RETURN

.DSABL	LSB

.ENABL	LSB

;+
; SWURND - DO /U ROUNDING
;-

SWURND:
	MOV	TMPUVL,R2	;GET ROUNDING FACTOR
	NEG	R2		;LESS 1 FOR A MASK & NOW FIND THE
	BIC	R2,R0		;ADDITIONAL AMOUNT
	BEQ	10$		;ADD 0, NO CORRECTION
	NEG	R0		;ELSE FIND THE
	ADD	TMPUVL,R0	; ADDITIONAL AMOUNT
10$:	TST	R1		;FOUND OUR SECTION?
	BNE	20$		;YES
	SEC			;DIDN'T FIND THE SECTION
20$:	RETURN

.DSABL	LSB


.ENABL	LSB

;+
; SUUERR - /U ERROR MESSAGES
;-

SWUERR:	BIT	SWITCH,#SW.U	;WERE WE PROCESSING A ROUND SECTION?
	BEQ	30$		;NO IF 0				;MAS20
	BIT	SWIT1,#SW.J	;ARE WE ALSO DOING I-D SPACE?
	BEQ	20$		;BRANCH IF NOT
	TST	SPFLAG		;ARE WE PROCESSING D-SPACE?
	BEQ	10$		;BRANCH IF NOT
	ERROR$	ERR105,E$W,E$PRT ;ROUND SECTION NOT IN D-SPACE
	BR	30$		;MERGE BELOW

10$:	ERROR$	ERR106,E$W,E$PRT ;ROUND SECTION NOT IN I-SPACE
	BR	30$		;MERGE BELOW

20$:	ERROR$	ERR30,E$W,E$PRT	;ROUND SECTION NOT FND
30$:	RETURN

.DSABL	LSB


TOOBIG:	ERROR$	ERR50,E$F,E$PRT	;ADDRESS SPACE EXCEEDED

.ENABL	LSB

;+
; SETBOT - SET BOTTOM ADDRESS
;
; INPUT: TEMP CONTAINS BOTTOM VALUE, R4 IS BOTTOM 
;	 FOR /J, MAY BE I OR D SPACE BOTTOM, R4 IS D-SPACE
;-

SETBOT:	BIT	SWITCH,#SW.H	;/H?
	BEQ	10$		;NO
	MOV	TEMP,-(SP)	;GET BOTTOM ADDRESS
	BIC	R2,R0		;AND FIND ADDITIONAL AMOUNT
	SUB	R0,@(SP)+	;YES, CORRECT BOTTOM
	SUB	R0,R4		; ... AND .ASECT FIX
10$:	ADD	R0,S.YVAL(R1)	;O.K., ROUND IT UP IN SYMBOL TBL
	BCC	20$		;C=0 IF OK				;MAS20
	ADD	#S.YNAM,R1	;R1 -> SECTION NAME
	ERROR$	ERR47,E$W,E$SYM,R1 ;SIZE OVERFLOW OF SECTION <SYMBOL>
20$:	RETURN

.DSABL	LSB
.SBTTL	VRSWT	/V AND /R WITH NO /Y HIGH LIMIT ADJUSTMENT

;+
; IF /V OVERLAYS AND /R BUT NO /Y WAS GIVEN, ADD UP ALL THE SECTION
; SIZES IN THE ROOT SEGMENT AND THE SIZE OF THE LARGEST SEGMENT OF
; EACH /O REGION.  THIS GIVES THE LOW MEMORY HIGH LIMIT.  SUBTRACT
; THIS VALUE FROM THE NEAREST (HIGHER THAN OR SAME) 4K WORD BOUNDARY.
; THIS IS THE AMOUNT TO RELOCATE THE ROOT AND /O OVERLAYS IN ORDER TO
; ELIMINATE ANY UNUSED MEMORY BETWEEN THE TOP OF THE /O OVERLAYS AND
; THE BEGINNING OF THE /V OVERLAYS.  ADJUST "BOTTOM" TO EFFECT LINKING
; TO TOP.  (TOP = HIGH LIMIT OF ROOT + /O OVERLAYS.)
; INPUT: R3 = ADR OF ASECT IN SYMBOL TBL
; OUTPUT: R4 = SIZE OF ASECT
;
; NOTE: BOTTOM REMAINS THE POINTER TO THE DUMMY OVERLAY REGION BLOCK 
; FOR I-D SPACE PROCESSING.
;-

VRSWT:	BIT	SWITCH,#SW.Y	;IS THERE A /Y?
	BNE	QSWT		;YES, GO PROCESS /Q
	BIT	SWITCH,#SW.R	;IS THERE A /R?
	BEQ	QSWT		;NO, GO PROCESS /Q
	BIT	FLGWD,#XM.OVR	;IS THERE /V OVERLAYS?
	BEQ	QSWT		;NO, GO PROCESS /Q
	MOV	#BOTTOM,R5	;R5 -> DUMMY OVERLAY REGION BLOCK
	MOV	R.GSGP(R5),R1	;SET UP R1
	CLR	R0		;R0 = TOTAL SIZE (NO ID WORD IN ROOT)
	MOV	R3,R2		;R2 -> ASECT TABLE ENTRY
	CLR	-(SP)		;CURRENT LOW MEMORY HIGH LIMIT
	CLR	-(SP)		;INIT HIGHEST SEGMENT SIZE SO FAR
	CALL	SIZE1		;GET SIZE OF SEGMENT
	BR	30$		;PROCESS ROOT SEGMENT SIZE

10$:	TST	R.GNB(R5)	;IS THIS A /V REGION?	
	BMI	50$		;- -> /V -> DONE WITH ROUNDING
	MOV	R.GSGP(R5),R1	;R1 -> FIRST OVERLAY SEGMENT BLOCK
	CLR	-(SP)		;THIS IS THE HIGHEST SEGMENT SIZE SO FAR
20$:	CALL	SIZSEG		;GET SEGMENT SIZE
30$:	CMP	@SP,R0		;IS THIS THE LARGEST SEGMENT THIS REGION
	BHIS	40$		;NO
	MOV	R0,@SP		;YES, REMEMBER THE LARGEST
40$:	MOV	#2,R0		;AND ALL FURTHER SEGMENTS HAVE ID WORD
	MOV	S.GNXP(R1),R1	;R1 -> NEXT SEGMENT THIS REGION
	BNE	20$		;GOT ONE (ALWAYS FAILS FOR ROOT)
	ADD	(SP)+,@SP	;ADD IN MEMORY SIZE OF THIS REGION
	MOV	R.GNXP(R5),R5	;POINT TO NEXT OVERLAY REGION
	BNE	10$		;AND PROCESS IT
50$:	MOV	@SP,R0		;R0 = HIGH LIMIT
	ADD	#17777,R0	;ROUND TO 4K WORD BOUNDARY
	BIC	#17777,R0
	SUB	(SP)+,R0	;GET AMOUNT TO BIAS HIGH LIMIT
	ADD	R0,BOTTOM	;ADJUST TO GET A HIGH LIMIT
	ADD	R0,R4		;AND FIX ASECT OVERHEAD
	;BR	QSWT		;GO PROCESS /Q
.SBTTL	QSWT	/Q SWITCH PROCESSING

;+
; CODE BASICALLY TAKEN FROM UYSWT ROUTINE.				;MAS20+
;
; SCAN THE ROOT FOR PSECTS AGAIN. 
; EASIER TO REPEAT THIS, SINCE /Y AND /U MUST SCAN TILL BOTH ARE 
; FOUND BEFORE THEY CAN BE RESOLVED, AND /Q WILL RARELY BE USED.
;
; WHEN A PSECT IS ENCOUNTERED IN THE SYMBOL TABLE, CHECK THE /Q 
; LIST AND IF THE PSECT IS:
;
; FOUND -> UPWARD ADJUSTMENT REQUIRED -> ADD TO PREVIOUS PSECT SIZE 
; 	   TO GET ADDRESS SPECIFIED, AND ADD UP PSECT SIZES AS WE GO. 
;	   ALSO DELETE PSECT FOUND FROM /Q PSECT LIST.
;	   NOTE: ABSOLUTE PSECTS WILL BE ADJUSTED IF REQUIRED.
; FOUND	-> DOWNWARD ADJUSTMENT REQUIRED -> PRINT ERROR, AND IGNORE PSECT.
;	   BUT REMOVE PSECT FROM /Q PSECT LIST.
;
; NOT FOUND -> CONTINUE TO NEXT PSECT IN SYMBOL TABLE.
;
; END OF SYMBOL TABLE -> PRINT MESSAGE ABOUT ANY /Q PSECT NAMES NOT FOUND,
;	   AND CONTINUE LINKING.
;
; INPUTS:
;	R3 -> POINTS TO ASECT SYMBOL TABLE ENTRY
;
; REGISTERS USED:
; 	R0 -> PSECT SIZE 
;	R1 -> POINTER TO /Q LIST
;	R2 -> POINTER TO PSECT IN SYMBOL TABLE
;	R5 -> POINTER TO PREVIOUS PSECT
;
; OUTPUT:
; 	R3 - NO CHANGE
;	R0,R1,R2,R5 -> RANDOM VALUES
;-

QSWT:	TST	REGION		;IS /Q SWTICH PROCESSING REQUIRED?	
	BNE	10$		;BRANCH IF YES
	JMP	XMRND		;NO (BEQ NEXT SWITCH PROCESSING)

10$:	CLR	R0		;INITIALIZE SIZE
	MOV	R3,R2		;R2 -> ROOT'S BEGINNING
	MOV	R3,R5		;INIT PREVIOUS SECTION 
	MOV	QSWVAL,R1	;SET UP POINTER TO START OF /Q LIST
	BR	40$		;NOW GO

20$:	MOV	QSWVAL,R1	;RESET POINTER TO START OF /Q LIST
30$:	MOV	@R2,R2		;R2 -> NEXT SYMBOL
	BIC	#SY.ENB,R2	;ISOLATE POINTER
	BEQ	110$		;DONE WITH SYMBOL TABLE, FIND ALL /Q PSECTS?
	SYMADR	R2		;R2 -> SYMBOL BLOCK
40$:	BIT	S.YSN(R2),#SY.SEC ;SECTION?
	BEQ	30$		;NO
50$:	CMP	R1,PA2LML	;ARE WE AT END OF /Q LIST?
	BHIS	100$		;= -> YES, DO NEXT SYMBOL
	CMP	S.YNAM(R2),@R1	;SECTION NAME MATCH?
	BNE	60$		;NO
	CMP	S.YNAM+2(R2),2(R1) ;MAY BE
	BEQ	70$		;= -> FOUND ONE
60$:	ADD	#6,R1		;TRY NEXT SYMBOL IN /Q LIST
	BR	50$		;LOOP TILL ALL /Q PSECTS TESTED

;+
; FOUND A PSECT IN /Q LIST. REMOVE FROM LIST AND ADJUST PREVIOUS 
; PSECT IF REQUIRED.
;-

70$:	CLR	(R1)+		;CLEAR PSECT NAME IN /Q LIST
	CLR	(R1)+		;TO INDICATE IT WAS FOUND
	CMP	@R1,R0		;IS IT AN UPWARD ROUND?
	BHIS	80$		;HIS -> OK FOR ADJUSTMENT
	MOV	R0,-(SP)	;SAVE SINCE ERROR$ USES IT
	MOV	R2,R0		;COPY R2
	ADD	#S.YNAM,R0	;R0 -> SECTION NAME
	ERROR$	ERR63,E$W,E$SYM,R0 ;SECTION ROUND DOWN ERROR
	MOV	(SP)+,R0	;RESTORE R0
	BR	100$		;ADD IN SECTION SIZE AND CONTINUE

80$:	SUB	R0,@R1		;FIND ADDITIONAL AMOUNT REQUIRED, AND ADD
	ADD	@R1,S.YVAL(R5) 	;TO THE SECTION BEFORE THE /Q
	BCC	90$		;C=0 IF OK
	MOV	R0,-(SP)	;SAVE REGISTER USED IN ERROR$
	MOV	R2,R0		;COPY NAME POINTER
	ADD	#S.YNAM,R0	;R0 -> SECTION NAME
	ERROR$	ERR47,E$W,E$SYM,R0 ;SIZE OVERFLOW OF SECTION <SYMBOL>
	MOV	(SP)+,R0	;RESTORE REGISTER
90$:	ADD	@R1,R0		;RESET R0 PROPERLY
	BCS	TOBIG1		;C=1 -> ADDRESS OVERFLOW

; ADD IN CURRENT PSECT SIZE

100$:	INC	R0		;WAS EVEN NOW MAKE ODD
	BEQ	TOBIG1		;PREVENT WRAP ON R0=177777
	ADD	S.YVAL(R2),R0	;COLLECT SIZE
	BCS	TOBIG1		;C=1 IF ADDRESSING OVERFLOW
	BIC	#1,R0		;GET RID OF ODD IF ADDED EVEN SIZE
	MOV	R2,R5		;REMEMBER PREVIOUS SECTION 
	BR	20$		;AND LOOP

; END OF SYMBOL TABLE, DID WE FIND ALL /Q PSECTS?

110$:	MOV	QSWVAL,R1	;SET POINTER TO START OF /Q LIST
120$:	CMP	R1,PA2LML	;ARE WE AT THE END OF THE LIST?	
	BHIS	XMRND		;GE -> ALL DONE WITH /Q PROCESSING
	TST	@R1		;IS WORD A ZERO?
	BNE	130$		;NE -> DIDN'T FIND THIS PSECT
	TST	2(R1)		;MIGHT HAVE FINISHED
	BEQ	140$		;THIS PSECT OK, TRY NEXT
130$:	ERROR$	ERR64,E$W,E$SYM,R1 ;/Q LOAD SECTION NOT FOUND
140$:	ADD	#6,R1		;CHECK NEXT PSECT POSITION
	BR	120$		;FOR SECTION NOT FOUND			;MAS20-

.SBTTL	SIZSEG	FIND SIZE OF AN OVERLAY SEGMENT				

;+
; CODE REMOVED FROM /H SWITCH PROCESSING (HSWT) TO BE SHARED WITH XMRND	;MAS15+
; SIZE1: -> ENTRY POINT USED BY HSWT ON 1ST CALL
; SIZSEG:-> NORMAL ENTRY POINT
;
; INPUT:R1 -> OVERLAY SEGMENT BLOCK POINTER
;	R0 -> RUNNING SUM OF SEGMENT SIZE
; TEMP:	R2 -> POINTER TO NEXT SYMBOL AND SECTION
;
; OUTPUT:R1 -> UNCHANGED
;	 R2 -> POINTER TO LAST SECTION IN SEGMENT (OR 0 IF NONE)
;	 R0 -> THIS SEGMENT SIZE ADDED IN
;-

.ENABL	LSB
SIZE1:	CLR	-(SP)		;RESERVE -> LAST SECTION IN SEGMENT
	BR	20$		;NOW ENTER ROUTINE IN MIDDLE

SIZSEG:	CLR	-(SP)		;RESERVE -> LAST SECTION IN SEGMENT
	MOV	R1,R2		;COPY POINTER
10$:	MOV	@R2,R2		;R2 -> NEXT SYMBOL
	BIC	#SY.ENB,R2	;ISOLATE POINTER
	BEQ	50$		;DONE THIS SEGMENT
	SYMADR	R2		;R2 -> SYMBOL BLOCK
20$:	BIT	S.YSN(R2),#SY.SEC ;IS THIS A SECTION ?
	BEQ	10$		;NO, MOVE ON
	BIT	SWIT1,#SW.J	;ARE WE ALSO DOING I-D SPACE?
	BEQ	40$		;BRANCH IF NOT
	BIT	S.YSN(R2),#CS$TYP*400 ;IS THIS AN I-SPACE PSECT?
	BEQ	30$		;BRANCH IF YES
	TST	SPFLAG		;WE HAVE A D-SPACE PSECT, ARE WE PROC D-SPACE?
	BEQ	10$		;BRANCH IF NOT
	BR	40$		;MERGE BELOW

30$:	TST	SPFLAG		;WE HAVE I-SPACE PSECT, ARE WE PROC I-SPACE?
	BNE	10$		;BRANCH IF NOT
40$:	ADD	S.YVAL(R2),R0	;YES, UPDATE SIZE OF THIS SEGMENT
	INC	R0		;EVEN IT OUT
	BIC	#1,R0
	MOV	R2,@SP		;RESET LINK POINTER TO LAST SECTION DONE
	BR	10$		;AND GO ON

50$:	MOV	(SP)+,R2	;SET R2 TO LAST SECTION IN SEGMENT (OR 0)
	RETURN								;MAS15-
.DSABL	LSB
.SBTTL	XMRND	ROUND ALL XM SEGMENTS TO 32. WORDS

;+
; XM SEGMENT SIZES MUST BE MULTIPLES OF 32. WORDS. THE XM SEGMENTS 	;MAS15+
; WILL ALL BE ROUNDED UP TO 32. WORDS (100 OCTAL BYTES=32. WORDS).
; INPUT:R3 -> ADR ASECT SYM TABLE ENTRY
;	R4 -> SIZE OF ASECT
; TEMP:	R0 -> SEGMENT SIZE 
;	R1 -> OVERLAY SEGMENT DEFINITION BLOCK POINTER
;	R2 -> TEMP SECTION POINTER
;	R5 -> PARTITION DEFINITION BLOCK POINTER
;
; OUTPUT:R3 AND R4 THE SAME
;	 R0, R1, R2 ,R5 ARE DESTROYED
;-

TOBIG1:	JMP TOOBIG		;GIVE ERROR

XMRND:	BITB	#XM.OVR,FLGWD	;/V BIT SET?
	BEQ	60$		;= -> NOT /V
	CLR	REGION		;MAKE SURE THIS IS CLEARED		;MAS20
	MOV	#BOTTOM,R5	;GET 1ST PARTITION BLOCK
10$:	MOV	R.GNXP(R5),R5	;GET NEXT BLOCK (1ST IS ROOT)
	BNE	20$		;= ILLEGAL ERROR
	JMP	ILERR		;SHOULDN'T GET HERE

20$:	TST	R.GNB(R5)	;IS THIS A /V PARTITION?
	BPL	10$		;+ -> NOT /V

	; HAVE FOUND THE 1ST /V OVERLAY PARTITION.
	; START ROUNDING LAST PSECT IN EACH SEGMENT SO THE SEGMENT SIZE
	; (INCLUDING THE ID WORD) COMES TO A 32. WORD BOUNDARY.

	CLR	R0		;R0 -> SEGMENT SIZE
30$:	MOV	R.GSGP(R5),R1	;R1 -> OVERLAY SEGMENT BLK IN 1ST XM PARTITION
40$:	BIT	SWIT1,#SW.J	;ARE WE ALSO DOING I-D SPACE?
	BEQ	50$		;BRANCH IF NOT
	MOV	SP,SPFLAG	;ROUND UP D-SPACE
	CALL	XMRND1		;ROUND PARTITION SEGMENTS (D-SPACE ONLY)
	CLR	SPFLAG		;ROUND UP I-SPACE
50$:	CALL	XMRND1		;ROUND PARTITION SEGMENTS (I-SPACE ONLY IF /J)
	MOV	R.GNXP(R5),R5	;TRY FOR NEXT PARTITION
	BNE	30$		;= -> NO MORE PARTITIONS
60$:	JMP	MAPHDR							;MAS15-

XMRND1:	MOV	R.GSGP(R5),R1	;R1 -> OVERLAY SEGMENT BLK IN 1ST XM PARTITION
10$:	CLR	R0		;R0 -> SEGMENT SIZE
	CALL	SIZSEG		;GET SEGMENT SIZE
	BEQ	30$		;BRANCH IF SEG IS EMPTY (ONLY POSS D-SPACE)
	MOV	R0,-(SP)	;SAVE SIZE
	MOV	#101,-(SP)	;ASSUME NOT I&D SPACE (1 WORD ID)
	BIT	SWIT1,#SW.J	;ARE WE ALSO DOING I-D SPACE?
	BEQ	20$		;BRANCH IF NOT
	SUB	#2,@SP		;ASSUME D-SPACE (NO ID WORD)
	TST	SPFLAG		;ARE WE PROCESSING D-SPACE?
	BNE	20$		;BRANCH IF D-SPACE
	ADD	#6,@SP		;I-SPACE (3 WORD ID ROUTINE)
20$:	ADD	@SP,R0		;ROUND UP TO 32. WORDS, AND ADD IN SEG ID
	BCS	TOBIG1		;C=1 -> SIZE OVERFLOW
	BIS	#77,R0		;SET BITS LESS THAN 32. WORDS
	SUB	(SP)+,R0	;SUB 77 AND POSSIBLE ID WORD(S)
	SUB	(SP)+,R0	;GET DIFF. BET 32. WORD ROUND AND REAL SIZE
	ADD	R0,S.YVAL(R2)	;ADJUST LAST PSECT SIZE TO GET 32. WD BOUNDARY
30$:	MOV	S.GNXP(R1),R1	;GET NEXT SEGMENT IN PARTITION
	BNE	10$		;= -> NO NEXT SEGMENT
	RETURN
.SBTTL	OV4DUM:: DUMMY ENTRY POINT FOR ERROR PROCESSING

OV4DUM::RTS	R5

.PSECT	PATCH			;THIS IS A PATCH PSECT,

	.BLKW	64.		;TO BE USED FOR BUG FIXES

.END