Google
 

Trailing-Edge - PDP-10 Archives - bb-4157j-bm_fortran20_v11_16mt9 - fortran-ots-debugger/formem.mac
There are 11 other files named formem.mac in the archive. Click here to see a list.
	SEARCH	MTHPRM,FORPRM
	TV	FORMEM	MEMORY MANAGEMENT,10(4237)
	SUBTTL	CHRIS SMITH/CKS/DAW/JLC/BL/EGM/AHM/PLB

;COPYRIGHT (c) DIGITAL EQUIPMENT CORPORATION 1981, 1987
;ALL RIGHTS RESERVED.
;
;THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND COPIED
;ONLY  IN  ACCORDANCE  WITH  THE  TERMS  OF  SUCH LICENSE AND 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.  NO TITLE TO AND OWNERSHIP OF THE  SOFTWARE  IS  HEREBY
;TRANSFERRED.

;THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT  NOTICE
;AND  SHOULD  NOT  BE  CONSTRUED  AS A COMMITMENT BY DIGITAL EQUIPMENT
;CORPORATION.

;DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY  OF  ITS
;SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DIGITAL.

COMMENT \

***** Begin Revision History *****

1100	CKS	5-Jun-79
	New for version 6

1160	CKS	9-Oct-80	Q1244
	When memory fills up, scrounge pages from STARTP going upward.

1275	DAW	20-Feb-81
	Return whole 30-bit address of memory at %GTBLK

1410	JLC	07-Apr-81
	Change %MVBLK to return new size in T3.

1464	DAW	12-May-81
	Error messages.

1466	CKS	18-May-81
	Add TOPS-20 PSI interface

1510	BL	4-Jun-81	Q10-06197
	Fix IllMemRef bug due to all pages being initialized as existing.

1523	JLC	04-Jul-81
	1022 interface. Rerouted all core expansion and contraction
	requests through one routine (EXPADR), called indirectly
	through %EXPNT, with the desired expansion value in %DESHG.
	Made all references to .JBFF indirect through %JBFPT.

1527	JLC/BL	09-Jul-81
	Fixes to BL's code (VMDDT fix), removal of some crocks.

1531	JLC	10-Jul-81
	Integrated %GTPGS for below and above page 600. Restricted
	page use to below 775.

1542	JLC	17-Jul-81
	Fixed %MVBLK for slightly changed calling sequence in FORIO.

1633	JLC	24-Aug-81
	Cleaned up some comments that were misleading

1667	JLC	9-Sep-81
	One-word patch at GETLP+11 makes lowseg core request work.

1727	JLC	18-Sep-81
	Another fix to low-core memory manager. Free-list was one word off.

1740	JLC	23-Sep-81
	Yet more fixes to low segment memory manager. Fixed so that
	free-list memory is included in larger requests if the
	free-list memory is at .JBFF.

1756	JLC	1-Oct-81
	Fix ots memory manager. For GTPGS, start at STARTP minus number
	of pages desired, and go down. Then at TRYHRD, start at STARTP+1
	minus number of pages desired and go up.

1773	DAW	8-Oct-81
	Change name of error code "CMU" to "IEM", for "internal error in
	memory manager".

2015	DAW	20-Oct-81
	AC T1 was being smashed in CREPG (TOPS-10).

2025	JLC	26-Oct-81
	Fix LSTRIM for the 1022 folks - we were using a non-transparent
	subroutine.

2033	JLC	19-Nov-81
	Incorrect calling sequence for %MVBLK.
	Don't smash LH(back-link) in %FREBLK, it is useful for debugging.

2052	EGM	27-Apr-82
	Add routine to cut back core for the block structured (OTS) core area.
	Cause %FREPGS to kill off pages returned for TOPS-10. Cause CREPGS for
	TOPS-10 to kill off any pages obtained for an incomplete request.
	Make KILPGS for TOPS-10 more forgiving of 'page non existent' errors.

2053	EGM	23-Apr-82
	Improve paged core usage when getting additional pages by:
	1. Trying to get specific pages contiguous with the start of
	   the block list, and
	2. Considering any initial free block size when determining
	   the number of new pages to get.
	Also preserve the saved PC when linking in a new free block.

***** Begin Version 7 *****

3021	JLC	10-Nov-81
	Fix lowseg memory manager bug. %MVBLK was called incorrectly.
	Done in V6 as part of edit 2033.

3026	JLC	24-Nov-81
	Change FUNCT., ALCOR., and DECOR. to call %FSAVE instead of
	%SAVE, to avoid argument copying.

3027	JLC	30-Nov-81
	Fix overlay symbol table problem - we were marking the page(s)
	where the symbol table resides as allocated. This is not necessarily
	true. OVRLAY sometimes purposely uses the area around and in the
	place where the symbol table was. This complex patch marks the
	area between .JBFF and the symbol table as a free list entry,
	and marks just the symbol table as allocated; then if a lowseg
	memory request fails we add the symbol table to the free list
	and try again.

3056	JLC	23-Mar-82
	Remove calls to %FSAVE.

3122	JLC	28-May-82
	Changed some global refs.

3125	JLC	3-Jun-82
	Moved the AC save routine back to the hiseg.

3126	JLC	7-Jun-82
	Fixed ALCOR., which was using AU.ACS with an indirect. Since
	it can be a negative stack pntr, this didn't work too well.

3131	JLC	11-Jun-82
	Install $SNH non-skip return after call to LSFREE in F.GADX,
	was skipping over valuable instruction.

3134	AHM	22-Jun-82
	Make the FUNCT% dispatch table contain IFIWs.

3135	AHM	24-Jun-82
	Make %MEMINI compute global addresses  for .JBFF and EOL,  and
	prevent BLTUP  from trying  to  shift the  free list  by  zero
	words, since the POP dies in a non-zero section.

3136	JLC	26-Jun-82
	Support for moving spaces (rather than nulls) into allocated
	space. Integration of TSG cut-back-core patches.

3141	JLC	2-Jul-82
	Reinsertion of symbol table into free list had too many bounds
	checks. It now just blindly puts it back into the free list.

3176	JLC	9-Sep-82
	Install disk quota exceeded trap in FOROTS. FUNCT% detects
	whether the routine address is that of FOROTS, and allows user
	to overwrite it.

3200	JLC	24-Sep-82
	Install new routines %MRKBL and %UNMBL to mark the pages used
	by layered products in the page table.

3202	JLC	26-Oct-82
	Install code to mark pages allocated or free, and new FUNCT
	calls to utilize it, for SORT and DBMS.

3203	JLC	31-Oct-82
	Fix SPCWD problem.

3211	AHM	10-Nov-82
	Fix alternate return for bad  args in CHKPGA.  Insert  missing
	AC field in SKIPN in F.GPSI.  Speed up some other code.

3223	JLC	22-Nov-82
	Kill pages on %FREPGS calls on both -10 and -20 so that
	we can leave the "don't overlay pages" bit on for DBMS.

3224	AHM	22-Nov-82
	Reverse  the  sense  of  a  test  in  one  of  the   premature
	optimizations in edit 3211.

3226	JLC	29-Nov-82
	Remove check for DBMS in MINILP.

3231	JLC	14-Dec-82
	Use FENTRY for entry points for DBMS interface.

3233	AHM/JLC	14-Dec-82
	Fix extended addressing bug at %FREPGS.

3236	JLC	17-Dec-82
	Move setup of FUNCT in .JBBLT here.

3244	JLC	31-Dec-82
	Moved setup of FUNCT back to FORINI after all.

3245	JLC	5-Jan-83
	Use ENDP for end page of core.

***** End V7 Development *****

3330	TGS	6-Jul-83	SPR:10-33967
	In order to preserve the user symbol table in case of overlays,
	FORMEM resets .JBFF above .JBSYM(rh).  It does not consider the
	case of a program loaded /SYMSEG:HIGH.

3333	TGS	22-Jul-83	SPR:NONE
	Allow Edit 3330 to handle the /OTS:NONSHARE case where there is
	no hiseg (.JBHRL=0)

3345	MRB	29-Aug-83	SPR:10-34134
	The code at CHKPFH: munges the registers before calling INUSCK.

3441	TGS	7-Sep-84	SPR:20-20332
	%MRKPG/%UMKPG use the wrong instruction in their calls to DOPGS when 
	testing whether any page within the range is already allocated or
	non-allocated. Since the instruction skips on the first non-allocated 
	or allocated page, the full range may never be tested.

3442	TGS	17-Sep-84	SPR:20-20357
	Check if DDT is in core at memory initialization time. If it is,
	leave pages above 763  marked as unavailable, as is done now.  If
	no DDT, mark ENDP:777 (TOPS20 only) as available.  This allows
	TOPMEM calls above original ENDP to be honored if DDT is absent.
	(Edit 4200 in V10)


BEGIN V10

4017	PLB	23-Jun-83
	Make Lowseg memory manager (LSGET/LSFREE) return/take
	global addresses.  Lowseg memory comes from FOROTS' section.

4023	JLC	29-Jun-83
	Use F.TOP and F.BOT as the bottom and top of FOROTS,
	both set to zero for /OTS:NONSHARE, set in the CCL
	file for OTS:SHARE.

4035	JLC	22-Jul-83
	Create local AC save routine for
	FUNCT., since it can be called from within an I/O
	statement which does dynamic concatenation.

4044	JLC	19-Sep-83
	Added new variables to keep track of the number of blocks
	and pages allocated, for debugging purposes.

4050	JLC	6-Oct-83
	Changed deallocation error reporting. Fixed MINILP so
	it avoids the bug-halt at KILPGS.

4065	JLC	6-Dec-83
	Make STARTP and ENDP into variables %STRTP and %ENDP.

4105	JLC	28-Feb-84
	Modify the calling sequence for error calls.

4111	JLC	16-Mar-84
	Modify the calling sequence for error calls again.

4120	PLB	26-Apr-84
	Modify %MEMINI to use PDVs for initial memory map.

4122	JLC	2-May-84
	Destroy pages on restart for TOPS-20.

4131	JLC	12-Jun-84
	Modify %GTBLK, %GTSPC, %MVBLK, and %MVSPC so that they have
	non-skip error returns, so that proper diagnostics can be
	given for memory full.

4152	JLC	24-Sep-84
	Add code in PDV checking to fill in .JBSYM with IOWD-format
	symbol table pointer if the symbol table is in the same section,
	or symbol vector if not in the same section.

4156	JLC	25-Oct-84
	Fix day-one problem in F.COR: if the request crossed into
	section 1, the code truncated it to a halfword; it now
	gives an error (not enough memory available).

4170	JLC	20-Nov-84
	Fix another day-one problem in TRYHRD: stop counting down when
	the bottom page is zero.

4174	JLC	9-Jan-85
	Always mark page 0 as used and allocated, since we do not
	want to give it to the memory manager to allocate, and
	LINK does not mark it used for extended addressing programs.

4175	JLC	15-Jan-85
	Fix F.GAD, F.RAD, and F.ROT to accept address arguments
	with section numbers, as long as it is the same section
	as FOROTS.

4200	TGS	28-Jan-85
	Implement V7 edit 3442: Initialize ENDP/%ENDP to 777. In section
	0, set %ENDP for MINILP to 763 if DDT is in core; if not, leave
	at 777. For non-zero sections, simply set page 777 as unavailable,
	unless old UDDT is in core.
	(Modules FORPRM, FORMEM)

4202	JLC	15-Feb-84
	Move ALCHN. and DECHN. to here, so that a local SAVAC routine
	can be called instead of %SAVAC (which turns on %UDBAD, and
	nobody was turning it off). Fix DOPDVS so that it unmaps
	unallocated pages.

4203	JLC	13-Mar-85
	Use FMACS, the local saved AC0, and not @AU.ACS.

4205	JLC	29-Mar-85
	Fix a bug in the page-marking algorithm, and expand
	the PDV scan to all PDVs.

***** End V10 Development *****

4237	MRB	30-DEC-85	SPR:20-20995
	Cant use ddt with extended programs on 5.1 systems.
	There is 1000(8) pages in a section. Rouine DOPDVS.

***** End Revision History *****
\
	SUBTTL	OTS MEMORY MANAGER


	INTERN	%MEMINI,%FUNCX,%MRKPG,%UMKPG,%ALCHF,%DECHF
	INTERN	%GTBLK,%FREBLK,%MVBLK,%GTSPC,%MVSPC
	INTERN	%GTPGS,%FREPGS
	INTERN	%LPAGE,%JBFPT,%DESHG,%EXPNT,%PTAB,%JBASE
	INTERN	%STRTP,%ENDP

	EXTERN	%POPJ,%POPJ1,%POPJ2,%SAVE1,%SAVE2,%SAVE3,%SAVE4
	EXTERN	I.XSIR,%LEVTAB,%CHNTAB,%FCHTB,%BLCNT,%PGCNT,%CHMSK
	EXTERN	I.RUNTM,%FSECT,%SVCNV
IF10,<	EXTERN	I.DEV,I.FILE,I.PPN	>
	EXTERN	%ABORT,%HALT
	EXTERN	F.BOT,F.TOP
	EXTERN	%ABFLG


	SEGMENT	CODE
	COMMENT	&

FOROTS dynamic memory is allocated in pages starting at STARTP (the highest
usable page), growing downward.  Memory for overlays is allocated at .JBREL,
growing upward.  If the two segments meet, the user is out of memory.

The memory from STARTP up to page %ENDP will be used when the rest of memory is
full.  This memory is also used by SORT, RMS, and DDT, and conflicts can occur.
The conflicts are preferable to the alternative, giving up and exiting.

Memory is strung together in blocks, chained in a doubly linked list.  Both
allocated and free blocks are on the list.  All blocks are consecutive, so the
%FREBLK routine can examine the previous and next blocks to see if they should
be coalesced with the block being freed.

Each block is preceded by a two-word header with forward and backward links, a
flag telling whether the block is allocated or free, and the size of the block
if it is free.  The list is terminated by a zero word.

To facilitate debugging, the unused left half of the second word of an
allocated block header is set to the return address in the routine that
allocated the block.  This helps find routines that fail to free their blocks.

	&



;FORMAT OF BLOCK HEADER

HFLNK==0			;(LH) -1 IF BLOCK ALLOCATED, 0 IF FREE
				;(RH) LINK TO FOLLOWING BLOCK
HSIZE==1			;(LH) SIZE OF BLOCK IF FREE, ELSE
				;     RETURN ADDRESS IN ALLOCATING ROUTINE
HBLNK==1			;(RH) LINK TO PRECEDING BLOCK
HLEN==2				;LENGTH OF BLOCK HEADER



M==10				;FREE BLOCK WHICH IS WITHIN M WORDS
				;OF DESIRED SIZE IS CONSIDERED EXACT FIT
				;(MUST BE AT LEAST HLEN)

;THIS IS PART OF THE 1022 INTERFACE
;ALL REFERENCES TO .JBFF ARE INDIRECT REFERENCES THROUGH JBFPNT, WHICH IS 
;SET TO .JBFF IN %MEMINI. 1022 WILL, BEHIND OUR BACKS, CHANGE THE CONTENTS
;OF JBFPNT. LSEXP, THE "CORE UUO" SIMULATOR, IS HANDLED IN A SIMILAR
;FASHION.

	DEFINE	JOBFF	<@%JBFPT>	
	DEFINE	LSEXP	<@%EXPNT>
;ROUTINE TO GET A BLOCK OF MEMORY
;ARGS:	 T1 = LENGTH OF BLOCK
;RETURN: T1 = ADDRESS OF BLOCK, CLEARED TO ZERO

%GTSPC:	SKIPA	T2,SPCWD(D)	;GET A WORD OF SPACES
%GTBLK:	SETZ	T2,		;RETURN BLOCK WITH ZEROES
	MOVEM	T2,BLTWRD	;SET FILL WORD
CGTBLK:	JUMPE	T1,[$SNH]	;ZERO-LENGTH CALL IS A BUG
	PUSHJ	P,GTBLKX	;TRY IT
	 POPJ	P,		;[4131] MEMORY FULL
	MOVE	T2,(P)		;GET RETURN ADDRESS OFF STACK
	HRLM	T2,-1(T1)	;STORE IN BLOCK HEADER FOR DEBUGGING
	JRST	%POPJ1		;[4131]  SKIP RETURN


GTBLKX:	MOVE	T4,FREPTR	;POINT TO START OF LIST
	SETOM	WRAP		;FLAG NO WRAPAROUND YET

GBSRCH:	SKIPGE	T4,(T4)		;GET LINK TO NEXT BLOCK.  IS IT FREE?
	  JRST	GBSRCH		;NO, KEEP LOOKING
	JUMPE	T4,GBEOL	;ZERO MEANS END OF LIST, GO WRAP AROUND
	HRRZ	T2,HBLNK(T4)	;GET START ADDRESS OF THE FREE BLOCK
	HLRZ	T3,HSIZE(T2)	;GET SIZE OF FREE BLOCK
	CAIGE	T3,(T1)		;IS IT BIG ENOUGH?
	  JRST	GBSRCH		;NO, KEEP LOOKING


GOTBLK:	CAIG	T3,M(T1)	;IS SIZE CLOSE ENOUGH?
	  JRST	GBFIT		;YES, DON'T SPLIT BLOCK
	SUBI	T3,HLEN(T1)	;COMPUTE LENGTH OF REMAINING FREE BLOCK
	HRLM	T3,HSIZE(T2)	;STORE IN HEADER
	ADDI	T3,HLEN(T2)	;GET START ADDRESS OF ALLOCATED BLOCK
	HRROM	T4,HFLNK(T3)	;FIX UP POINTERS
	HRRZM	T2,HBLNK(T3)
	HRRZM	T3,HFLNK(T2)
	HRRM	T3,HBLNK(T4)
	MOVEM	T2,FREPTR	;START NEXT SEARCH AT NEW FREE BLOCK
	MOVEI	T1,HLEN(T3)	;GET ADDRESS OF NEW ALLOCATED BLOCK
	JRST	GBZERO		;GO CLEAR NEW BLOCK, RETURN

GBFIT:	HRROM	T4,HFLNK(T2)	;JUST MARK WHOLE BLOCK ALLOCATED
	MOVEM	T4,FREPTR	;START NEXT SEARCH AT FOLLOWING BLOCK
	MOVEI	T1,HLEN(T2)	;POINT TO BLOCK

GBZERO:	MOVE	T2,BLTWRD	;SET 1ST WORD TO DESIRED QUANTITY
	MOVEM	T2,(T1)
	MOVSI	T2,(T1)		;MAKE BLT POINTER TO CLEAR BLOCK
	HRRI	T2,1(T1)
	CAILE	T4,(T2)		;CHECK FOR 1-WORD BLOCK
	  BLT	T2,-1(T4)	;CLEAR REST OF BLOCK
	XMOVEI	T1,(T1)		;Section number in left half
	AOS	%BLCNT		;INCREMENT # BLOCKS ALLOCATED
	JRST	%POPJ1		;SUCCESS RETURN
GBEOL:	HRRZ	T4,BEGPTR	;RESET FREE POINTER TO START OF LIST
	MOVEM	T4,FREPTR
	AOSG	WRAP		;ALREADY LOOKED THROUGH WHOLE LIST?
	  JRST	GBSRCH		;NO, DO SO

	STKVAR	<SAVET,NP,SAVEP,> ;[2053] ALLOCATE SPACE ON STACK
	MOVEM	T1,SAVET	;SAVE T1
	HRRZ	T2,BEGPTR	;[2053] Get beginning of list
	SKIPN	(T2)		;[2053] EOL?
	JRST	GBANYP		;[2053] Yes - Get any pages, mark initial hole
	SKIPG	(T2)		;[2053] Is first block free?
	JRST	GBSSIZ		;[2053] No - use same size
	HLRZ	T3,HSIZE(T2)	;[2053] Free block size
	SUBI	T1,HLEN(T3)	;[2053] Reduce words needed
GBSSIZ:	DMOVEM	P1,SAVEP	;[2053] Save P ACs
	MOVEI	P1,(T2)		;[2053] Free block address, always top of page
	MOVEI	P2,HLEN+777(T1)	;[2053] Size + header, rounded to page
	LSHC	P1,-^D9		;[2053] Last page number + 1/no. of pages
	SUBI	P1,(P2)		;[2053] First page number
	PUSHJ	P,CREPGS	;[2053] Try to get prefered pages
	  JRST	[DMOVE	P1,SAVEP ;[2053] No luck, restore P ACs
		 MOVE	T1,SAVET ;[2053] Get original size
		 JRST	GBANYP]	 ;[2053] Get any pages, mark hole
	MOVEI	T1,(P1)		;[2053] Got them, get first page number
	LSH	T1,^D9		;[2053] New free block address
	HRRZ	T4,BEGPTR	;[2053] First block contiguous with new one
	SKIPL	(T4)		;[2053] Is first block free?
	HRRZ	T4,HFLNK(T4)	;[2053] Yes - new core ends at successor
	DMOVE	P1,SAVEP	;[2053] Restore P ACs
	JRST	GBCONT		;[2053] Use prefered pages
GBANYP:	MOVEI	T1,2*HLEN+777(T1) ;[2053] ADD 2 HEADERS, ROUND UP TO PAGE BOUND
	LSH	T1,-9		;CONVERT TO PAGES
	MOVEM	T1,NP		;SAVE PAGES TO ALLOCATE
	PUSHJ	P,%GTPGS	;GET SOME PAGES
	  JRST	[UNSTK		;CAN'T, GIVE ERROR RETURN
		 POPJ P,]

	MOVE	T2,NP		;GET LENGTH IN PAGES
	LSHC	T1,9		;CONVERT ADDRESS, LENGTH TO WORDS
	ADDI	T2,(T1)		;GET END+1 ADDRESS OF NEW CORE
	HRRZ	T3,BEGPTR	;GET POINTER TO START OF OLD CORE
				;[2053]

GBHOLE:	MOVEI	T4,-HLEN(T2)	;MAKE HOLE LOOK LIKE PERMANENTLY ALLOCATED BLOCK
	HRLI	T3,400000	;[2052] Unique hole marker for CBC function
	MOVEM	T3,HFLNK(T4)	;[2052] Set forward link of hole
	HRRM	T4,HBLNK(T3)	;SET BACKWARD LINK

GBCONT:	HRROM	T1,BEGPTR	;NEW START OF LIST IS START OF NEW CORE
	MOVEM	T1,FREPTR	;ALSO START NEXT SEARCH THERE
	HRRZM	T4,HFLNK(T1)	;POINT FREE BLOCK TO ITS SUCCESSOR
	HRRM	T1,HBLNK(T4)	;[2053] POINT SUCCESSOR BACK TO NEW FREE BLOCK
	MOVEI	T3,BEGPTR	;POINT FREE BLOCK BACK TO LIST HEAD
	HRRZM	T3,HBLNK(T1)

	MOVEI	T3,(T4)		;COMPUTE LENGTH OF FREE BLOCK
	SUBI	T3,HLEN(T1)

	MOVEI	T2,(T1)		;PUT POINTER TO FREE BLOCK IN RIGHT AC
	MOVE	T1,SAVET	;RESTORE T1
	UNSTK			;RESTORE P
	JRST	GOTBLK		;DONE, RETURN TO MAIN CODE
;ROUTINE TO FREE A BLOCK OF MEMORY
;ARGS:	T1 = ADDRESS OF BLOCK TO BE FREED (AS RETURNED BY %GTBLK)

%FREBL:	SKIPE	%ABFLG		;ABORTING?
	 POPJ	P,		;YES. DO NOT DEALLOCATE CORE

	CAIN	T1,0		;BAD CALL IF ARG=0
	 $ECALL	IEM,%ABORT		;REPORT ERROR
	SOSGE	%BLCNT		;DECREMENT COUNT OF BLOCKS ALLOCATED
	 $ECALL	IEM,%ABORT	;DEALLOCATED MORE THAN WE ALLOCATED!
	HRRZ	T2,HBLNK-HLEN(T1) ;POINT TO PREDECESSOR BLOCK
	HRRZ	T3,HFLNK-HLEN(T1) ;POINT TO SUCCESSOR BLOCK

	HRRZ	T4,HFLNK(T2)	;GET FWD LINK OF PREDECESSOR
	CAIE	T4,-HLEN(T1)	;DOES IT POINT TO CURRENT BLOCK?
	 $ECALL	IEM,%ABORT	;No, error
	HRRZ	T4,HBLNK(T3)	;GET BACK LINK OF SUCCESSOR
	CAIE	T4,-HLEN(T1)	;CHECK IT
	 $ECALL	IEM,%ABORT	;WRONG, ERROR

	SKIPGE	HFLNK(T2)	;IF PREDECESSOR IS FREE, POINT TO IT
	  HRRZ	T2,HFLNK(T2)	; ELSE POINT TO BLOCK BEING FREED
	SKIPLE	HFLNK(T3)	;IF SUCCESSOR IS FREE, POINT TO ITS SUCCESSOR
	  HRRZ	T3,HFLNK(T3)
	HRRZM	T3,HFLNK(T2)	;FIX POINTERS
	HRRM	T2,HBLNK(T3)	;(LH = return address of GTBLK caller..)

	CAMGE	T2,FREPTR	;DOES FREPTR POINT TO INTERIOR OF NEW BLOCK?
	CAMG	T3,FREPTR
	  JRST	.+2		;NO, OK
	MOVEM	T2,FREPTR	;MAKE SURE FREPTR POINTS TO START OF SOME BLOCK

	SUBI	T3,HLEN(T2)	;COMPUTE LENGTH OF NEW FREE BLOCK
	HRLM	T3,HSIZE(T2)	;STORE IN BLOCK HEADER
	JUMPG	T3,%POPJ	;AND RETURN
	$SNH			;NEGATIVE FREE BLOCK SIZE!
;ROUTINE TO MOVE A CORE BLOCK INTO A BIGGER BLOCK
;ARGS:	 T1 = OLD ADDRESS
;	 T2 = OLD LENGTH
;	 T3 = NEW LENGTH
;RETURN: T1 = NEW ADDRESS
;	 T2 = END+1 ADDR OF OLD DATA IN NEW BLOCK (I.E. NEW ADDR + OLD LENGTH)
;	 T3 = NEW LENGTH (FOR CONVENIENCE IN EXPRB)

%MVSPC:	MOVE	T4,SPCWD(D)	;GET A WORD OF SPACES
	MOVEM	T4,BLTWRD	;RETURN NEW BLOCK WITH SPACES
	JRST	CMVBLK		;JOIN COMMON CODE

%MVBLK:	SETZM	BLTWRD		;RETURN NEW BLOCK WITH ZEROES
CMVBLK:	EXCH	T1,T3		;GET NEW LENGTH IN T1, OLD ADDR IN T3
	MOVEM	T1,NLEN		;SAVE NEW LENGTH FOR LATER
	MOVEM	T2,OLEN		;SAVE OLD LENGTH
	MOVEM	T3,OADR		;SAVE OLD ADDRESS
	PUSHJ	P,CGTBLK	;GET NEW BLOCK
	 POPJ	P,		;[4131] CAN'T. NON-SKIP RETURN

	MOVE	T2,OLEN		;GET OLD LENGTH BACK
	HRLZ	T3,OADR		;GET OLD ADDRESS IN LH
	HRRI	T3,(T1)		;NEW ADDRESS IN RH
	ADDI	T2,(T1)		;NEW ADDRESS + OLD LENGTH
	BLT	T3,-1(T2)	;MOVE OLD DATA TO NEW BLOCK

	EXCH	T1,OADR		;SAVE NEW ADDRESS, GET OLD ADDRESS
	MOVEM	T2,OLEN		;SAVE NEW END+1 ADDRESS ON STACK

	PUSHJ	P,%FREBLK	;FREE OLD BLOCK

	MOVE	T1,OADR		;GET NEW ADDR FOR RETURN
	MOVE	T2,OLEN		;GET ADDR OF 1ST FREE WORD IN EXPANDED AREA
	MOVE	T3,NLEN		;GET NEW LENGTH
	JRST	%POPJ1		;[4131] SKIP RETURN FOR SUCCESS

	SEGMENT	DATA

%STRTP:	BLOCK	1		;START PAGE FOR TOP OF MEMORY
%ENDP:	BLOCK	1		;LAST-DITCH TOP OF MEMORY
OADR:	BLOCK	1		;OLD ADDRESS OF DATA
OLEN:	BLOCK	1		;OLD LENGTH
NLEN:	BLOCK	1		;NEW LENGTH
BLTWRD:	BLOCK	1		;BLOCK INITIALIZATION VALUE

	SEGMENT	CODE
;ROUTINE TO FIND AND ALLOCATE CONSECUTIVE PAGES OF MEMORY
;ARGS:	 T1 = NUMBER OF PAGES TO GET
;RETURN: T1 = PAGE NUMBER OF FIRST PAGE
;NONSKIP RETURN IF CAN'T, SKIP IF OK

%GTPGS:	PUSHJ	P,%SAVE3	;SAVE P ACS

	MOVE	P1,%STRTP	;START LOOKING AT THE TOP OF FOROTS DATA AREA
	SUBI	P1,-1(T1)	;MINUS # PAGES DESIRED
	MOVEI	P2,(T1)		;SET NUMBER OF PAGES TO GET

GETPLP:	MOVEI	T1,1		;GET PAGE-ALLOCATED BIT
	PUSHJ	P,DOPGS		;MOVE BIT THROUGH PAGE BIT MAP
	  TDNN	T1,PTAB(T2)	;SEE IF PAGES ARE ALL NOT ALLOCATED
	   JRST	TRYRET		;ALL FREE, FINE
	SOJGE	P1,GETPLP	;SOME PAGE ALLOCATED, TRY AGAIN

;HERE WHEN REQUEST CAN'T BE SATISFIED USING PAGES 0 THROUGH STARTP.
;LOOK FROM STARTP+1 TO ENDP FOR ENOUGH CONSECUTIVE PAGES.

TRYHRD:	MOVE	P1,%ENDP	;START AT THE END OF CORE
	SUBI	P1,-1(P2)	;FIND BASE PAGE # WE WANT

TRYLP2:	MOVEI	T1,(P1)		;COPY TEST PAGE BOTTOM
	ADDI	T1,-1(P2)	;GET TOP PAGE DESIRED
	CAMG	T1,%STRTP	;REACH WHERE WE FAILED BEFORE?
	  POPJ	P,		;YES, GIVE UP
	MOVEI	T1,1		;GET PAGE-ALLOCATED BIT
	PUSHJ	P,DOPGS		;MOVE BIT THROUGH PAGE BIT MAP
	  TDNN	T1,PTAB(T2)	;SEE IF PAGES ARE ALL NOT ALLOCATED
	   JRST	TRYRET		;ALL FREE, FINE
	SOJGE	P1,TRYLP2	;[4170] SOME PAGE ALLOCATED, TRY AGAIN
	 POPJ	P,		;[4170] DON'T GO BELOW PAGE 0, HOWEVER

TRYRET:	PUSHJ	P,CREPGX	;CREATE THE PAGES
	  POPJ	P,		;CAN'T, TOO BAD

	MOVEI	T1,(P1)		;RETURN STARTING PAGE TO CALLER
	OR	T1,PAGSEC	;In current section
	JRST	%POPJ1		;SUCCESS


;MARK A BLOCK OF CORE ALLOCATED IN THE PAGE TABLE. THIS ROUTINE
;IS CALLED WHENEVER A SHARABLE SEGMENT OF A LAYERED PRODUCT
;IS LOADED VIA GET% (GETSEG) BY FOROTS. THIS SHOULD PROBABLY
;BE MADE A FUNCT. CALL EVENTUALLY.
;[3441] ARGS:	T1 = STARTING PAGE
;[3441]	T2 = NUMBER OF PAGES

%MRKPG:	PUSHJ	P,%SAVE4	;SAVE P1-P4
	DMOVE	P1,T1		;GET INTO THE CORRECT ACS
				;[3441]
	MOVEI	T1,3		;CHECK IF USED ALREADY
	PUSHJ	P,DOPGS		;MOVE THROUGH THE BIT MAP
	 TDNN	T1,PTAB(T2)	;[3441] WITH THIS INSTRUCTION
	  TRNA			;[3441] NONE ALLOCATED IN RANGE, OK
	 POPJ	P,		;[3441] AT LEAST ONE ALLOCATED, ERROR
	MOVEI	T1,3		;SET PAGE-ALLOCATED AND PAGE-EXIST
	PUSHJ	P,DOPGS		;MOVE THROUGH THE BIT MAP
	 IORM	T1,PTAB(T2)	;WITH THIS INSTRUCTION
	JRST	%POPJ1		;SKIP RETURN

;UNMARK A BLOCK OF CORE IN THE PAGE TABLE. WHEN A LAYERED PRODUCT
;DECIDES TO LEAVE (SUCH AS SORT), THE USER SHOULD BE ABLE TO GET
;THE PAGES USED BY IT.

%UMKPG:	PUSHJ	P,%SAVE4	;SAVE P1-P4
	DMOVE	P1,T1		;GET INTO THE CORRECT ACS
	MOVEI	T1,1		;CHECK IF THEY ARE INDEED ALLOCATED
	PUSHJ	P,DOPGS		;MOVE THROUGH BITMAP
	 TDNE	T1,PTAB(T2)	;[3441] WITH THIS INSTRUCTION
	  TRNA			;[3441] ALL ALLOCATED, OK
	 POPJ	P,		;[3441] SKIP MEANS AT LEAST ONE WASN'T
	MOVEI	T1,3		;NOW FREE THEM
	PUSHJ	P,DOPGS		;MOVE THROUGH BITMAP
	 ANDCAM	T1,PTAB(T2)	;WITH THIS INSTRUCTION
	JRST	%POPJ1		;SKIP RETURN


;ROUTINE TO FREE PAGES
;ARGS:	 T1 = FIRST PAGE
;	 T2 = NUMBER OF PAGES
;[2052] On Return, pages are marked free in bit map for TOPS-20,
;[2052] or have been removed and marked free/non existent for TOPS-10

%FREPGS:
	PUSHJ	P,%SAVE2	;SAVE P1-P2
	DMOVE	P1,T1		;PUT ARGS IN RIGHT ACS
	ANDI	P1,777		;[3233] MAKE PAGE LOCAL
	PJRST	KILPGS		;[2052] Remove the pages and update bit map
;ROUTINE TO CREATE PAGES
;ARGS:	 P1 = FIRST PAGE TO ALLOCATE
;	 P2 = NUMBER OF PAGES TO ALLOCATE
;ERROR RETURN IF PAGES ARE ALLREADY ALLOCATED
;OR (10 ONLY) IF PAGES CAN'T BE CREATED (CORE LIMIT EXCEEDED OR SOMETHING)

CREPGS:	MOVEI	T1,1		;GET PAGE-ALLOCATED BIT
	PUSHJ	P,DOPGS		;MOVE THROUGH BIT MAP
	  TDNN	T1,PTAB(T2)	;ARE PAGES ALREADY ALLOCATED?
	   JRST	CREPGX		;ALL FREE, FINE
	POPJ	P,		;SOME PAGE ALLOCATED, ERROR

CREPGX:				;ENTRY POINT FOR PAGES ALREADY CHECKED
	ADDM	P2,%PGCNT	;INCREMENT ALLOCATED PAGE COUNT

IF20,<
	DMOVE	T1,P1		;TOUCH THE PAGE
	LSH	T1,9
	XMOVEI	T1,(T1)		;In current section
CR20LP:	SKIP	(T1)		;TO CREATE IT
	ADDI	T1,1000
	SOJG	T2,CR20LP

>;END IF20

IF10,<
	PUSHJ	P,%SAVE4	;SAVE P1-P4
	MOVEI	P3,(P1)		;INITIALIZE P3, NUMBER OF PAGE BEING CREATED
	MOVE	P4,[-PLEN,,1]	;GET AOBJN POINTER TO PAGE. BLOCK
	MOVEI	T1,2		;GET PAGE-EXISTS BIT
	PUSHJ	P,DOPGS		;MOVE BIT THROUGH BIT MAP
	  PUSHJ	P,CREPG		;GO CREATE PAGE IF IT DOESN'T EXIST
	   JRST	.+2		;CREATED OK, SKIP
	PJRST	KILPGS		;[2052] Can't get them all, kill any created

	TRNE	P4,-2		;IF ARG BLOCK IS NONEMPTY,
	PUSHJ	P,PGUUO		;DO FINAL UUO
	  JRST	.+2		;WORKED, FINE
	PJRST	KILPGS		;[2052] Can't get them all, kill any created
>

	MOVEI	T1,3		;GET PAGE-ALLOCATED AND PAGE-EXISTS BITS
	PUSHJ	P,DOPGS		;MOVE THROUGH BIT MAP
	  IORM	T1,PTAB(T2)	;MARK PAGE EXISTING AND ALLOCATED

	JRST	%POPJ1		;SUCCESS RETURN
IF10,<

;ROUTINE TO CREATE A PAGE IF NECESSARY
;CALLED FROM INSIDE DOPGS, SO MUST BE CAREFUL
;ARGS:	 T1, T2 = BIT AND OFFSET FROM DOPGS
;		  (TO CHECK IF PAGE IS MARKED NONEXISTENT IN BIT MAP)
;	 P3 = PAGE NUMBER TO CREATE
;	 P4 = AOBJN POINTER TO PAGE. ARG BLOCK
;RETURN: P1-P2, T1-T4 UNCHANGED
;	 P3, P4 UPDATED FOR NEXT ITERATION OF DOPGS
;NONSKIP RETURN IF PAGE CREATED OK
;SKIP RETURN (TO TERMINATE DOPGS) IF PAGE COULDN'T BE CREATED

CREPG:	TDNE	T1,PTAB(T2)	;DOES PAGE EXIST ALREADY?
	  AOJA	P3,%POPJ	;YES, FINE

	HLL	P3,VRTBIT	;SET PA.GCD IF WANT A VIRTUAL PAGE
	MOVEM	P3,PBLK(P4)	;PUT PAGE NUMBER IN ARG BLOCK
	ADDI	P3,1		;INCREMENT FOR NEXT TIME
	AOBJN	P4,%POPJ	;RETURN IF BLOCK NOT FULL YET

PGUUO:	SUBI	P4,1		;UNDO EXTRA INCREMENT FROM AOBJN
	HRRZM	P4,PBLK		;STORE COUNT WORD
PGUUO1:	MOVE	P4,[.PAGCD,,PBLK] ;POINT TO ARG BLOCK
	PAGE.	P4,		;TRY TO CREATE PAGES
	  JRST	VIRT		;DIDN'T WORK, GO TRY TO GO VIRTUAL
	MOVE	P4,[-PLEN,,1]	;RESET AOBJN POINTER
	POPJ	P,		;DONE

VIRTER:	MOVE	T1,PBLK+1	;T1:= page number (for ERR call)
;	  ERR	(CCP,999,106,?,Can't create page $O (PAGE. error $O),<T1,P4>)
	$ECALL	CCP,%ABORT	;"?Can't create page n"

VIRT:	CAIN	P4,PAGNX%	;NO VIRTUAL PRIVS?
	  JRST	%POPJ1		;YES, GIVE UP ON CREATING PAGE
	CAIE	P4,PAGLE%	;Skip if "Core limit exceeded"
	 JRST	VIRTER		;NO, all other errors are fatal
	SKIPE	VRTBIT		;ALREADY WENT VIRTUAL?
	  JRST	%POPJ1		;YES, GIVE UP.  PAGE CAN'T BE CREATED

	MOVSI	T0,(PA.GCD)	;GET VIRTUAL BIT
	MOVEM	T0,VRTBIT	;SET FOR FUTURE CALLS
	MOVE	P4,[-PLEN,,1]	;MAKE AOBJN POINTER TO PAGE. ARG BLOCK
	HLLM	T0,PBLK(P4)	;PUT BIT INTO ARG BLOCK
	  AOBJN	P4,.-1

	SKIPE	.JBPFH		;PFH ALREADY READ IN, OR USER PFH?
	  JRST	PGUUO1		;YES, WONDERFUL, GO TRY AGAIN
;NOW THE TRICK IS TO MAKE ROOM FOR THE PAGE FAULT HANDLER.  PHYSICAL
;MEMORY IS FULL, BUT THE PFH MUST RESIDE IN PHYSICAL MEMORY.  THEREFORE
;PAGE OUT 1 OR 2 PAGES TO MAKE ROOM FOR IT.  THEN TOUCH ONE OF THE
;PAGED-OUT PAGES TO FORCE THE MONITOR TO READ IN THE PFH NOW.  THE ONLY
;PURPOSE FOR THAT IS TO CATCH MONITOR AND FOROTS BUGS HERE, NOT IN SOME
;RANDOM MEMORY REFERENCE SOMEWHERE ELSE.

	STKVAR	<SAVEP,,PCNT>	;ALLOCATE SOME TEMP VARIABLES
	DMOVEM	P1,SAVEP	;SAVE P1-P2
	SETOM	PCNT		;PCNT WILL GO POSITIVE AFTER 2 PAGES
	MOVEI	P2,1		;FIRST PAGE NUMBER IS 1

VIRTLP:	TRNE	P2,777000	;PAGE NUMBER OVER 1000?
	  JRST	VRTRET		;YES, RAN OUT OF PAGES.  NICE TRY

	MOVSI	P1,.PAGCA	;SET TO CHECK PAGE ACCESS BITS
	HRRI	P1,(P2)		;PUT IN PAGE NUMBER
	PAGE.	P1,		;GET BITS FOR THE PAGE
	 $SNH			;Shouldn't fail
	TXNE	P1,PA.GNE+PA.GPO+PA.GCP ;CHECK EXISTING PAGE, IN CORE, CAN BE PAGED OUT
	  AOJA	P2,VIRTLP	;NO DICE, TRY NEXT PAGE

	MOVE	P4,[.PAGIO,,P1] ;POINT TO ARG BLOCK
	MOVEI	P1,1		;SET COUNT WORD TO 1
	TXO	P2,PA.GAF	;SET TO PAGE THE PAGE OUT
	PAGE.	P4,		;DO IT
	  JRST	VRTRET		;DIDN'T MAKE IT, GIVE UP
	AOSG	PCNT		;INCREMENT COUNT OF PAGES WE'VE DONE
	  AOJA	P2,VIRTLP	;NOT ENOUGH YET, LOOP

	LSH	P2,9		;CONVERT PAGE NUMBER TO ADDRESS
	SKIP	(P2)		;READ IN PFH

VRTRET:	DMOVE	P1,SAVEP	;RESTORE P1-P2
	UNSTK			;RESTORE P
	JRST	PGUUO1		;GO TRY UUO AGAIN

>;END IF10
;ROUTINE TO DESTROY PAGES
;ARGS:	 P1 = FIRST PAGE TO DESTROY
;	 P2 = NUMBER OF PAGES TO DESTROY
;ON RETURN, PAGES ARE GONE

KILPGS:	MOVN	T1,P2		;GET NEGATIVE # PAGES TO DESTROY
	ADDB	T1,%PGCNT	;DECREMENT ALLOCATED PAGE COUNT
	JUMPGE	T1,KILPGX	;OK
	$ECALL	PGD,%ABORT	;TRYING TO DEALLOCATE MORE THAN ALLOCATED
KILPGX:
IF20,<
	SETO	T1,		;UNMAP THE PAGES
	MOVSI	T2,.FHSLF	;FROM THIS FORK
	HRRI	T2,(P1)		;STARTING AT GIVEN PAGE NUMBER
	MOVSI	T3,(PM%CNT)	;WE ARE GIVING A COUNT
	HRRI	T3,(P2)		;WHICH IS IN P2
	PMAP%			;DESTROY THE PAGES
>

IF10,<
	STKVAR	<SAVEP,>	;SAVE P1-P2
	DMOVEM	P1,SAVEP
KILLP:	MOVE	T3,[-PLEN,,1]	;[2052] GET AOBJN POINTER TO PAGE. BLOCK
KILLP0:	MOVE	T1,T3		;[2052] Get working AOBJN pointer
	HRLI	P1,(PA.GAF)	;SET TO DESTROY THE PAGES
KILLP1:	MOVEM	P1,PBLK(T1)	;PUT PAGE NUMBER IN BLOCK
	ADDI	P1,1		;INCREMENT PAGE NUMBER
	SOJLE	P2,EKILLP	;IF COUNT HIT 0, DONE
	AOBJN	T1,KILLP1	;KEEP GOING UNTIL BLOCK FILLS UP
	SUBI	T1,1		;UNDO EXTRA INCREMENT FROM AOBJN

EKILLP:	HRRZM	T1,PBLK		;SET COUNT IN ARG BLOCK
	MOVE	T1,[.PAGCD,,PBLK] ;SET TO DESTROY PAGES
	MOVE	T2,PBLK+1	;Get page number incase error
	PAGE.	T1,		;DO IT
	  JRST	[CAIE	T1,PAGME%	;[2052] Page does not exist?
;[2052]	  ERR	(CDP,999,106,?,<Can't destroy page $O (PAGE. error $O)>,<T2,T1>)
		 $ECALL	CDP,%ABORT	;[2052] No - some fatal error
		 HRRZ	T1,PBLK		;[2052] Get number of pages
		 CAIN	T1,1		;[2052] Doing 1 page at a time?
		 JRST	.+1		;[2052] Yes - just continue loop
					;[2052] Don't know which page had error
		 SUBI	P1,(T1)		;[2052] Back to first page
		 ADDI	P2,(T1)		;[2052] Reset count
		 MOVE	T3,[-1,,1]	;[2052] Use single step AOBJN ptr.
		 JRST	KILLP0]		;[2052] From this page on
	JUMPG	P2,KILLP0	;[2052] IF MORE LEFT TO DO, DO THEM

	DMOVE	P1,SAVEP	;RESTORE P1-P2
	UNSTK
>

	MOVEI	T1,3		;GET BOTH BITS
	PUSHJ	P,DOPGS		;MOVE T1 THROUGH BITS IN PTAB
	  ANDCAM T1,PTAB(T2)	;MARK PAGES FREE AND NONEXISTENT
	POPJ	P,		;DONE
;ROUTINE TO HANDLE PAGE BIT MAP
;CALL:
;	MOVEI	P1,FIRSTPAGE	;FIRST PAGE TO DO
;	MOVEI	P2,NPAGES	;NUMBER OF PAGES TO DO
;	MOVEI	T1,N		;BIT PATTERN
;	PUSHJ	P,DOPGS		;MOVE IT THROUGH BIT MAP
;	  INST	T1,PTAB(T2)	;ANY INSTRUCTION
;	    <INST DIDN'T SKIP, EVER>
;	<INST SKIPPED, AT LEAST ONCE>
;
;THE INSTRUCTION AFTER THE CALL IS EXECUTED REPEATEDLY WITH T1
;CONTAINING THE ORIGINAL BIT PATTERN, SHIFTED OVER APPROPRIATELY, AND
;T2 CONTAINING THE APPROPRIATE INDEX INTO PTAB.  IF THE INSTRUCTION
;SKIPS, CONTROL RETURNS FROM DOPGS IMMEDIATELY; IF IT NEVER SKIPS,
;THE INSTRUCTION IS EXECUTED FOR ALL PAGES FROM P1 TO P1+P2-1.

DOPGS:	STKVAR	<FIRSTP,NP,BITPAT> ;ALLOCATE SPACE ON STACK
	DMOVEM	P1,FIRSTP	;SAVE FIRST PAGE, NUMBER OF PAGES
	MOVEM	T1,BITPAT	;SAVE BIT PATTERN
	IDIVI	P1,^D18		;GET BYTE POS WITHIN WORD
	LSH	P2,1		;BYTES ARE 2 BITS LONG
	LSH	T1,(P2)		;MOVE BIT PATTERN TO RIGHT POSITION
	MOVEI	T2,(P1)		;GET OFFSET WITHIN TABLE
	MOVE	P2,NP		;GET COUNT BACK
	JRST	DOPLP1		;START AT BEGINNING

DOPLP:	LSH	T1,2		;MOVE BIT PATTERN OVER
	JUMPN	T1,DOPLP1	;LOOP IF STILL IN WORD
	MOVE	T1,BITPAT	;RESET T1 TO BEGINNING OF NEXT WORD
	ADDI	T2,1		;BUMP INDEX TO NEXT WORD
DOPLP1:	SOJL	P2,DOPRET	;QUIT WHEN DONE
	XCT	@-.L(P)		;DO THE INSTRUCTION
	  JRST	DOPLP		;NONSKIP

	AOS	-.L(P)		;PASS ON SKIP RETURN
DOPRET:	DMOVE	P1,FIRSTP	;RESTORE P1-P2
	UNSTK			;RESTORE P
	JRST	%POPJ1		;RETURN, SKIPPING OVER INST
;[2052]Routine to trim block structured (OTS) core area
;[2052]No arguments
;[2052]
;[2052] Trim back the block structured core area by removing all free pages
;[2052] at the beginning of the list. Stop triming when an allocated block
;[2052] or EOL is found, or after having split a block such that there are
;[2052] no more free pages at the beginning of the list.

PGTRIM:	STKVAR	<NXTBLK>	;[2052] Place to save pointer to next block
	HRRZ	T1,BEGPTR	;[2052] Start with first block
PGTNXT:	SKIPG	T2,(T1)		;[2052] Is it free, and not EOL?
	JRST	PGTDON		;[2052] No - finished
	HLRZ	T3,HSIZE(T1)	;[2052] Get block size for later
	HLRZ	T4,(T2)		;[2052] Get allocated marker for next block
	CAIE	T4,400000	;[2052] Is it a hole?
	JRST	PGTNHL		;[2052] No - just look at this block
	ADDI	T3,HLEN		;[2052] Yes - absorb its length
	HRLM	T3,HSIZE(T1)	;[2052] Into current block
	HRRZ	T2,HFLNK(T2)	;[2052] Get its successor
	HRRM	T2,HFLNK(T1)	;[2052] Link hole out of the
	HRRM	T1,HBLNK(T2)	;[2052] Block structure entirely
	JRST	PGTPGS		;[2052] Go release some pages
PGTNHL:	MOVEI	T4,HLEN(T3)	;[2052] Actual block size
	CAIGE	T4,^D512	;[2052] Have at least a page?
	JRST	PGTDON		;[2052] No - nothing more to do
	TRZ	T4,777000	;[2052] Excess words in next page
	JUMPE	T4,PGTNSU	;[2052] None - release some pages from 1 block
	CAIG	T4,HLEN		;[2052] Enough room for a block of 1 word?
	ADDI	T4,^D512	;[2052] No - one less page to free
	SUBI	T3,(T4)		;[2052] Reduce current block size
	JUMPLE	T3,PGTDON	;[2052] If no words left forget it
	HRLM	T3,HSIZE(T1)	;[2052] Save new block size
	ADDI	T3,HLEN(T1)	;[2052] Excess block address
	HRRZM	T2,HFLNK(T3)	;[2052] Setup forward link
	HRRM	T1,HBLNK(T3)	;[2052] Back link
	SUBI	T4,HLEN		;[2052] Actual size
	HRLM	T4,HSIZE(T3)	;[2052] Save away
	HRRM	T3,HFLNK(T1)	;[2052] Update predecessor pointer
	HRRM	T3,HBLNK(T2)	;[2052] And successor back pointer
PGTNSU:	SETZ	T2,		;[2052] No successor block to consider
PGTPGS:	HRRZM	T2,NXTBLK	;[2052] Save next block address
	HRRZ	T3,HBLNK(T1)	;[2052] Get block predecessor
	HRRZ	T4,HFLNK(T1)	;[2052] And successor
	HRRM	T4,HFLNK(T3)	;[2052] Link pages out of
	HRRM	T3,HBLNK(T4)	;[2052] Block structure
	CAMN	T1,FREPTR	;[2052] Giving up first free block?
	MOVEM	T4,FREPTR	;[2052] Yes - advance to next block
	HLRZ	T2,HSIZE(T1)	;[2052] Get size of block to free
	ADDI	T2,HLEN		;[2052] Actual size
	LSHC	T1,-^D9		;[2052] Page number/no. of pages
	PUSHJ	P,%FREPGS	;[2052] Free pages
	SKIPE	T1,NXTBLK	;[2052] Get next block to do if any
	JRST	PGTNXT		;[2052] Check further
PGTDON:	UNSTK			;[2052] Free local storage
	POPJ	P,		;[2052] Done
;ROUTINE TO INITIALIZE MEMORY

;CALLED FROM INIT. ON PROGRAM START OR RESTART

;PUTS MEMORY INTO A KNOWN, CONSISTENT STATE BY DELETING ALL
;PAGES IT DOESN'T LIKE.  IT LIKES PAGES BELOW .JBFF, PAGES
;BETWEEN RH(.JBHRL)-LH(.JBHRL)+1 AND RH(.JBHRL), PAGES IN FOROTS,
;AND PAGES ABOVE STARTP.  ALL OTHERS GO.
;[4120] DELETION OCCURS ONLY UNDER TOP-10

;ALSO SETS UP FREE LIST POINTERS BEGPTR, FREPTR, AND FLBEG,
;AND THE PAGE BIT MAP PTAB.

%MEMINI:
	PUSHJ	P,%SAVE4	;SAVE P1-P4

	XMOVEI	T2,.		;Get section number
	HLRZ	T2,T2
	LSH	T2,^D9		;Get page # to "OR"
	MOVEM	T2,PAGSEC	;Page # of start of this section

	XMOVEI	T1,.JBFF	;[3135] SETUP .JBFF PNTR
	MOVEM	T1,%JBFPT
	XMOVEI	T1,EXPADR	;SETUP ADDR OF MEMORY EXPANDER/CONTRACTOR
	MOVEM	T1,%EXPNT
	SETZM	EOL		;MAKE A ZERO TO END FREE LIST
	XMOVEI	T1,EOL		;[3135] POINT TO THE ZERO
	MOVEM	T1,FREPTR	;START SEARCHING THERE
	HRROM	T1,BEGPTR	;IT'S ALSO START OF FREE LIST

	SETZM	FLBEG		;NO LOW SEG FREE LIST YET

	SETZM	VRTBIT		;START BY TRYING FOR PHYSICAL PAGES

	SKIPN	.JBCOR		;[4120] DO WE HAVE A LINK CREATED LOCAL JOBDAT?
	 PJRST	DOPDVS		;[4120] NO, MUST SCAN FOR PDVS

	MOVE	T1,[252525,,252525] ;INIT TO '010101....010101'
	MOVEM	T1,PTAB		;PAGE BIT TABLE = ALL UAVAILABLE & NONEXISTENT
	MOVE	T1,[PTAB,,PTAB+1]
	BLT	T1,PTAB+^D28

	SETZM	SYMFP		;CLEAR "BETWEEN .JBFF AND .JBSYM" PNTR
	SKIPN	.JBSYM		;SYMBOL TABLE?
	 JRST	SETJFF		;NO
	HRRZ	T1,.JBSYM	;YES. GET ITS ADDR
	CAMG	T1,JOBFF	;HOLE BETWEEN JBFF AND JBSYM?
	 JRST	MRKSYM		;NO. JUST START MINILP ABOVE TABLE
	HRRZ	T2,.JBHRL	;[3330] GET HIGHSEG BREAK
	JUMPE	T2,MRKHOL	;[3333] NO HISEG?
	HLRZ	T1,.JBHRL	;[3330] GET SEG SIZE
	SUBI	T2,-1(T1)	;[3330] T2/ BEGINNING OF HISEG
	ANDI	T2,777000	;[3330] ROUNDED DOWN TO PAGE BOUNDARY
	HRRZ	T1,.JBSYM	;GET THE TABLE ADDR AGAIN
	CAML	T1,T2		;[3330] IS IT IN THE HISEG?
	 JRST	SETJFF		;[3330] YES, DON'T POINT .JBFF INTO HISEG
MRKHOL:	HRL	T1,JOBFF	;[3333] GET FIRST FREE LOC IN HOLE
	MOVEM	T1,SYMFP	;SAVE FUTURE FREE LIST ENTRY
MRKSYM:	HRRZ	T1,.JBSYM	;GET SYMBOL TABLE PNTR AGAIN
	HLRE	T2,.JBSYM	;CALC TOP OF TABLE+1
	SUB	T1,T2		;P1 NOW POINTS TO TOP OF SYMTAB+1
	CAMLE	T1,JOBFF	;IF GREATER THAN CURRENT .JBFF
	 MOVEM	T1,JOBFF	;SAVE AS NEW .JBFF
	HRL	T1,.JBSYM	;CREATE A SYMBOL TABLE FREE LIST ENTRY
	MOVEM	T1,SYMTP	;TO USE IF A CORE REQUEST FAILS
SETJFF:	MOVE	P1,JOBFF	;GET END+1 OF LOW SEGMENT
	MOVEM	P1,%JBASE	;SAVE FOR MEMORY MANAGER DEBUGGER
	ADDI	P1,777		;ROUND UP TO A PAGE BOUNDARY
	LSH	P1,-9		;GET FIRST PAGE AFTER LOW SEGMENT
	MOVEM	P1,LPAGE	;SAVE IT FOR LOW SEG CORE ALLOCATION
;PTAB NOW HAS ALL PAGES MARKED AS UNAVAILABLE.  GO THROUGH IT, PAGE
;BY PAGE, AND MARK EACH PAGE AVAILABLE IF IT PASSES ALL THE TESTS.
;THE LOOP GOES FROM .JBFF TO PAGE %ENDP, CHECKING EACH PAGE TO SEE IF
;IT'S IN THE DATA AREA OR IN FOROTS OR IN VMDDT OR IN THE PFH OR IN
;THE SYMBOL TABLE.

	PUSHJ	P,DDTCHK	;[4200] CHECK IF DDT IS IN CORE AND SET %ENDP
MINILP:	CAMG	P1,%ENDP	;[4200] HAVE WE HIT TOP OF OUR CORE?
	 JRST	NOTTOP		;NO

	SKIPN	SYMFP		;ANY SPACE BETWEEN .JBFF AND .JBSYM?
	 POPJ	P,		;NO
	PUSHJ	P,LSINIT	;YES. MUST MARK A FREE BLOCK
	AOS	FLLEN		;MAKE AN ENTRY
	MOVE	T1,SYMFP	;GET THE FREE LIST ENTRY
	MOVEM	T1,(P3)		;STORE IT
	POPJ	P,

NOTTOP:	HRRZ	T1,.JBHRL	;GET HS BREAK
	MOVEI	T2,(T1)		;COPY IT
	HLRZ	T3,.JBHRL	;GET HS LENGTH
	SUBI	T1,-1(T3)	;SUBTRACT, GIVING HS ORIGIN
	JUMPL	T1,CHKDAT	;NO HS. CHECK DATA AREA
	PUSHJ	P,INUSCK	;CHECK FOR IN USE
	 AOJA	P1,MINILP	;IN USE. DON'T BOTHER

CHKDAT:
	CAIGE	P1,F.TOP/1000
	CAIGE	P1,F.BOT/1000	;IS PAGE IN FOROTS?
	  JRST	CHKDDT		;NO
	AOJA	P1,MINILP	;YES, LEAVE IT

CHKDDT:	HRRZ	T1,JOBDDT	;[4200] DDT ADDR
	JUMPE	T1,CHKPFH	;NO DDT. GO CHECK PFH
	HLRZ	T2,JOBDDT	;[4200] HIGH ADDR
	PUSHJ	P,INUSCK	;PAGE IN DDT?
	 AOJA	P1,MINILP	;YES, LEAVE IT

CHKPFH:	HRRZ	T1,.JBPFH	;[3345]FIRST PFH ADDR
	JUMPE	T1,PAGOK	;[3345]NO PFH IF ZERO
	HLRZ	T2,.JBPFH	;[3345]LAST PFH ADDR
	PUSHJ	P,INUSCK	;PAGE IN PFH?
	 AOJA	P1,MINILP	;YES, LEAVE IT

PAGOK:	MOVEI	P2,1		;SET LENGTH OF 1 PAGE
	MOVEI	T1,(P1)		;COPY PAGE NUMBER FOR CHKNEX
	PUSHJ	P,CHKNEX	;SEE IF PAGE EXISTS
	  PUSHJ	P,KILPGX	;YES, MAKE IT NOT EXIST
	MOVEI	T1,3		;MARK PAGE AVAILABLE AND NONEXISTENT
	PUSHJ	P,DOPGS		;SHIFT T1 TO RIGHT PLACE IN BIT MAP
	  ANDCAM T1,PTAB(T2)

	AOJA	P1,MINILP	;LOOP ON TO NEXT PAGE

;ROUTINE TO CHECK IF PAGE IS WITHIN GIVEN BOUNDARIES
;
;	CALLED WITH LOW ADDR IN T1, HIGH ADDR IN T2, PAGE NUMBER IN P1
;	SKIP RETURN IF PAGE IS FREE

INUSCK:	LSH	T1,-9		;TO PAGE
	LSH	T2,-9		;TO PAGE
	CAMG	P1,T2		;PAGE IN USE?
	CAMGE	P1,T1
	 JRST	%POPJ1		;NO
	POPJ	P,		;YES
;DDTCHK
;[4200] ROUTINE TO CHECK IF DDT IS IN CORE
; PURPOSE: TO DETERMINE WHETHER MINILP SHOULD LEAVE DDT PAGES IN-
; VIOLATE (I.E. UNAVAILABLE AND NONEXISTENT) OR AVAILABLE IN THE BITMAP,
; DEPENDING ON WHETHER DDT IS PART OF THE CORE IMAGE.  IT SETS %ENDP
; (MINILP LOOP LIMIT) AND A FAKE JOBDDT.
; ON TOPS10, THIS ROUTINE SIMPLY SETS UP JOBDDT WITH .JBDDT FOR USE BY
; CHKDDT.
; ON TOPS20, WE CHECK IF DDT IS IN CORE. IF IT IS NOT, LEAVE %ENDP AT 777
; AND RETURN. IF DDT IS MAPPED, SETUP JOBDDT FOR CHKDDT WITH TOP,,START
; ADDRESSES OF DDT AND SET %ENDP TO 763 (I.E. LEAVE DDT INVIOLATE)


IF10,<				;[4200] Created this routine
DDTCHK:	MOVE	T1,.JBDDT	;IF10, JUST SET JOBDDT TO .JBDDT
	MOVEM	T1,JOBDDT
	POPJ	P,		;AND RETURN
>;END IF10

IF20,<				;[4200] Created this routine
DDTCHK:	SETZM	JOBDDT		;ASSUME DDT ABSENT
	PUSHJ	P,DDTINC	;SEE IF DDT IS REALLY THERE
	 POPJ	P,		;NO DDT, LEAVE %ENDP AT TOP OF CORE
	MOVEI	T1,763		;DDT IS THERE, SET TOP OF RANGE TO
	MOVEM	T1,%ENDP	; 763, NOT TOP OF CORE
	MOVE	T1,[777000,,764000] ;AND SET JOBDDT TO DDT RANGE
	MOVEM	T1,JOBDDT
	POPJ	P,		;RETURN

>;END IF20

;[4200] ROUTINE TO CHECK IF DDT'S ENTRY VECTOR IS PRESENT
; RETURNS +1 IF DDT IS NOT IN CORE
; RETURNS +2 IF DDT IS PRESENT

IF20,<				;[4200] Created this routine
DDTINC:	MOVE	T1,[.FHSLF,,770] ;SEE IF DDT'S PAGE EXISTS
	RPACS%			;GET ACCESS BITS FOR THE PAGE
	TXNN	T2,PA%PEX	;DOES IT EXIST?
	 POPJ	P,		;NO, NO DDT
	MOVE	T1,770000	;YES, SEE IF IT LOOKS LIKE DDT
	CAME	T1,[JRST 770002] ;SAME BIRTHMARK?
	 POPJ	P,		;NO, NO DDT
	JRST	%POPJ1		;YES,  SKIP RETURN
>;END IF20
	SUBTTL	DOPDVS - Process PDVs to set up PTAB and JOBDAT

;++
; FUNCTIONAL DESCRIPTION:
;
;	New in 4120 /PLB
;
;	The PDV scan works as following: The memory bit map PTAB in
;	intialized to all available.  Then all PDVs located within the
;	current (FOROTS) section are stepped through.  If the .PVMEM
;	pointer is present, then we scan all subtables, marking all
;	pages indicated in the current section as allocated in PTAB.
;	Lastly we scan upwards through PTAB looking for the first
;	suitable unused page.  Local JOBDAT locations .JBFF, .JBREL,
;	and .JBSA<LH> will be set up pointing to this page.
;
; CALLING SEQUENCE:
;
;	PUSHJ	P,DOPDVS
;	(ONLY CALL IS A PJRST FROM %MEMINI)
;
; INPUT PARAMETERS:
;
;	None
;
; IMPLICIT INPUTS:
;
;	PDVs in current section
;
; OUTPUT PARAMETERS:
;
;	None
;
; IMPLICIT OUTPUTS:
;
;	Sets up PTAB, the memory bitmap, as well as .JBFF, .JBREL,
;	and .JBSA<LH> of the section local JOBDAT for use by FOROTS.
;
; FUNCTION VALUE:
;
;	None
;
; SIDE EFFECTS:
;
;	Yes
;
;--

IF10,<
DOPDVS:	POPJ	P,		;DOES NOTHING ON TOPS-10
> ;END IF10

IF20,<
DOPDVS:	SETZM	PTAB		;[4200] CLEAR BIT TABLE
	MOVE	T1,[PTAB,,PTAB+1] ;[4200]
	BLT	T1,PTAB+^D28	;[4200]

	MOVEI	T1,1		;[4174] BUT EXCLUDE PAGE 0 NO MATTER WHAT
	IORM	T1,PTAB		;[4174] BECAUSE ALLOCATING PAGE 0 IS A BIG MISTAKE!

	SETZM	PDVCNT		;NO PDVS SEEN YET
	SETZM	PDVTTL		;NO TOTAL YET

	MOVSI	T1,1		;[4205] START IN SECTION 1
	MOVEM	T1,PDVBLK+.POADR ;[4205] FOR PDV SEARCH
	HRLOI	T1,777		;[4205] END IN SECTION 777
	MOVEM	T1,PDVBLK+.POADE ;[4205]
	XMOVEI	T1,.		;[4205] GET SECTION,,.
	HLLZM	T1,LOWADR	;[4205] SAVE LOWEST ADDR IN THIS SECTION
	HLLOM	T1,HIADR	;[4205] AND HIGHEST ADDR IN THIS SECTION

PDVGET:	MOVEI	T1,.POADE+1	;GET PDVOP% ARG BLOCK LENGTH
	MOVEI	T2,.FHSLF	;AND FORK HANDLE (US)
	DMOVEM	T1,PDVBLK+.POCT1 ;STORE
	MOVEI	T1,MAXPDV	;GET LENGTH
	XMOVEI	T2,PDVA		;AND ADDR OF PDVA BLOCK
	DMOVEM	T1,PDVBLK+.POCT2 ;STORE
	MOVEI	T1,.POGET	;FUNCTION TO GET PDVA'S
	XMOVEI	T2,PDVBLK	;GET BLOCK ADDR
	PDVOP%			;GO FISH
	 ERJMP	NOMORE		;FAILED, END OF THE LINE
	HRRZ	P4,PDVBLK+.POCT2 ;GET NUMBER RETURNED
	JUMPE	P4,NOMORE	;GET ANY?
	HLRZ	T1,PDVBLK+.POCT2 ;GET NUMBER EXISTING
	SKIPN	PDVTTL		;SEEN THE TOTAL YET?
	 MOVEM	T1,PDVTTL	;STORE AS TOTAL

	MOVN	P4,P4		;GET -COUNT OF PDVS
	MOVSI	P4,(P4)		;GET -COUNT,,0
PDVCHK:	MOVE	P2,PDVA(P4)	;GET PDV -- TOP OF PDV LOOP
	MOVE	T2,.PVCNT(P2)	;GET COUNT OF WORDS IN PDV
	CAIGE	T2,.PVMEM+1	;LONG ENOUGH FOR US?
	 JRST	NXTPDV		;NOPE.
	SKIPG	.PVSYM(P2)	;DOES IT HAVE A GLOBAL SYMBOL VECTOR ADDRESS?
	 JRST	PDVNS		;NO. SKIP IT FOR .JBSYM
	XMOVEI	T1,@.PVSYM(P2)	;YES. GET ITS GLOBAL ADDRESS
	MOVEM	T1,.JBSYM	;SAVE FOR FORERR AND FORDDT
	PUSHJ	P,%SVCNV	;CONVERT TO ADDRESS AND LENGTH
	HLLZ	T0,T1		;GET JUST SECTION NUMBER
	CAMN	T0,%FSECT	;SAME AS THIS SECTION?
	 CAILE	T2,777000	;AND IS SYMBOL TABLE .LE. 511 PAGES?
	  JRST	PDVNS		;NO
	MOVNI	T2,(T2)		;YES. MAKE LENGTH NEGATIVE
	HRLI	T1,(T2)		;MAKE IT AN IOWD
	MOVEM	T1,.JBSYM	;SAVE IT AGAIN

PDVNS:	XMOVEI	P3,@.PVNAM(P2)	;GET ADDRESS OF NAME STRING
	$BLDBP	P3		;MAKE ME A BP!
	MOVE	T1,P3		;GET COPY OF BP
	HRROI	T2,[ASCIZ 'FOROTS%'] ;GET OFFICIAL NAME
	STCMP			;COMPARE STRINGS
	JUMPE	T1,NXTPDV	;A PERFECT MATCH! - IGNORE THIS PDV
	MOVE	T1,P3		;GET BP AGAIN
	HRROI	T2,[ASCIZ 'FOROTS'] ;GET LESS OFFICIAL NAME
	STCMP			;COMPARE AGAIN
	JUMPE	T1,NXTPDV	;LOOKS LIKE FOROTS... IGNORE
				;SINCE THE LOW SEG INFO IS WRONG

	XMOVEI	P3,@.PVMEM(P2)	;GET MEMORY BLOCK ADDR
	JUMPE	P3,NXTPDV	;NONE
	MOVN	T2,.PMCNT(P3)	;GET -BLOCK COUNT
	AOJE	T2,NXTPDV	;REMOVE COUNT WORD
	MOVEM	T2,MEMCNT	;STORE WORDS LEFT
	ADDI	P3,1		;POINT TO FIRST SUB-TABLE
MEMLOP:	XMOVEI	P1,@.PMLOW(P3)	;GET LOW ADDR
	CAMN	P1,[1,,0]	;[4205] WAS IT AN IFIW 0?
	HLL	P1,P3		;[4205] YES. GET PDV SECTION
	CAMLE	P1,HIADR	;[4205] COMPARE TO OUR HIGH
	 JRST	NXTBLK		; WHOLE BLOCK IS ABOVE US
	CAMGE	P1,LOWADR	;COMPARE TO OUR LOW
	 MOVE	P1,LOWADR	; TAKE LARGER OF THE TWO
	XMOVEI	P2,@.PMHI(P3)	;GET HI ADDR
	CAMGE	P2,LOWADR	;COMPARE TO LOW RANGE
	 JRST	NXTBLK		; WHOLE BLOCK IS BELOW US
	CAMLE	P2,HIADR	;[4205] COMPARE TO HIGH LIMIT
	 MOVE	P2,HIADR	;[4205] TAKE SMALLER OF THE TWO
;; NOTE THAT WE ROUND THE WORD ADDRESS TO PAGE ADDRESSES
;; IT IS POSSIBLE TO ADD THE UNUSED FRAGMENT TO THE FREE-LIST.
	MOVEI	P1,(P1)		;GET LOCAL ADDR
	LSH	P1,-^D9		;GET LOW PAGE
	MOVEI	P2,(P2)		;GET LOCAL ADDR
	LSH	P2,-^D9		;GET HIGH PAGE
	SUBI	P2,(P1)		;[4205] GET PAGE COUNT
	ADDI	P2,1		;[4205]
	MOVEI	T1,3		;BIT PATTERN (EXISTS + ALLOCATED)
	PUSHJ	P,DOPGS		;CALL BIT MAP HACKER
	 IORM	T1,PTAB(T2)	;MARK AS IN USE
NXTBLK:	HRRZ	T1,.PMDAT(P3)	;GET CURRENT SUBTABLE LENGTH
	ADDI	P3,(T1)		;BUMP SUBTABLE POINTER BY THAT MUCH
	ADDB	T1,MEMCNT	;INCREMENT WORDS SEEN BY THAT MUCH
	JUMPL	T1,MEMLOP	;STILL MORE WORDS? LOOP.
NXTPDV:	AOS	T1,PDVCNT	;SAY WE HAVE SEEN ONE MORE PDV
	AOBJN	P4,PDVCHK	;LOOP FOR NEXT PDV

; NO MORE PDVAs IN THIS BATCH, DO WE NEED TO DO ANOTHER PDVOP%???
; I DON'T KNOW HOW YOU GOT THAT MANY PDV'S BUT IT WAS
; EASY ENOUGH TO ADD THE CODE TO DO IT RIGHT.

	CAML	T1,PDVTTL	;MORE TO GO?
	 JRST	NOMORE		;NOPE.. SEEN IT ALL
	MOVE	T1,PDVA+MAXPDV-1 ;GET LAST PDVA
	ADDI	T1,1		;GET LAST PDVA+1
	MOVEM	T1,PDVBLK+.POADR ;STORE AS LOW ADDRESS
	JRST	PDVGET		;GO LOOK FOR MORE

; HERE WHEN NO MORE PDV'S ARE TO BE FOUND; MARK PAGES USED BY DDT
NOMORE:	PUSHJ	P,DDTCHK	;[4200] SET %ENDP FOR UDDT 
	MOVE	P1,%ENDP	;[4200] GET TOP OF CORE
	MOVEI	P2,1000		;[4237] Get total pages in section.
	SUB	P2,P1		;[4200] IN P2
	SKIPN	P2		;[4200] BUT MARK AT LEAST ONE
	 MOVEI	P2,1		;[4200]
	MOVEI	T1,3		;GET BITS (EXISTS + ALLOCATED)
	PUSHJ	P,DOPGS		;HACK THE BITMAP
	 IORM	T1,PTAB(T2)	;INSTRUCTION TO SET BITS

; MARK FOROTS PAGES
	MOVEI	P1,F.BOT/1000	;GET FOROTS START PAGE
	JUMPE	P1,DOSEAR	;ZERO? MUST BE NONSHARE
	MOVEI	P2,<<F.TOP-F.BOT>/1000> ;GET LENGTH
	MOVEI	T1,3		;GET BITS (EXISTS + ALLOCATED)
	PUSHJ	P,DOPGS		;HACK THE BITMAP
	 IORM	T1,PTAB(T2)	;INSTRUCTION TO SET BITS

;NOW SEARCH FOR THE FIRST FREE GAP, AND SET UP LOCAL JOBDAT
DOSEAR:	MOVEI	P1,1		;START AT PAGE 1
;;;	MOVEI	P2,1		;GAP NEED ONLY BE ONE PAGE LONG
	MOVEI	P2,2		;EXPERIMENT: REQUIRE GAP TO BE 2 PAGES
	MOVEI	P3,F.BOT/1000	;GET BOTTOM OF FOROTS
	JUMPN	P3,SRCLOP	;OK?
	MOVEI	P3,ENDP		;NO, MUST BE NONSHARE: SEARCH ALL
SRCLOP:	CAIL	P1,(P3)		;ARE WE AT END OF ROPE?
	 $ECALL	MFU,%ABORT	; MEMORY FULL
	MOVEI	T1,1		;GET PAGE-ALLOCATED BIT
	PUSHJ	P,DOPGS		;MOVE THROUGH BIT MAP
	 TDNE	T1,PTAB(T2)	;ALLOCATED?
	  AOJA	P1,SRCLOP	; YES, KEEP LOOKING

	MOVEI	T1,(P1)		;NO, COPY PAGE NUMBER
	LSH	T1,^D9		;MAKE INTO ADDRESS
	CAIGE	T1,1000		;ABOVE PAGE 1?
	 MOVEI	T1,.JBDA	;NO!! START ABOVE JOBDAT
	MOVEM	T1,.JBFF	;STORE AS NEXT WORD TO USE
	HRLM	T1,.JBSA	;AND INITIAL VALUE THEREOF
	SUBI	T1,1		;GET END OF LAST PAGE
	ORI	T1,777		;MAKE SURE IT LOOKS GOOD
	MOVEM	T1,.JBREL	;STORE AS LIMIT WORD

;[4202] NOW WE MUST UNMAP ALL THE PAGES FROM THIS SECTION THAT
;HAVE BEEN MAPPED BEFORE BY FOROTS. WE GO THROUGH THE BITMAP,
;A PAGE AT A TIME, AND CALL KILPGX FOR ALL PAGES FOR WHICH
;THE PAGE IS NOT ALLOCATED.

	MOVEI	P1,777		;START AT THE TOP
	MOVEI	P2,1		;1 PAGE AT A TIME
RUNMLP:	MOVEI	T1,1		;USE ALLOCATED BIT AS THE MASK
	PUSHJ	P,DOPGS		;ONLY 1 PAGE AT A TIME, THOUGH
	 TDNN	T1,PTAB(T2)	;CHECK IF ALLOCATED
	  PUSHJ	P,KILPGX	;NOT ALLOCATED. KILL IT!
	SOJGE	P1,RUNMLP	;LOOP DOWN TO 0
	RET			;OUR WORK IS DONE

> ;IF20
;ROUTINE TO CHECK IF A PAGE EXISTS
;ARGS:	 T1 = PAGE NUMBER
;SKIP RETURN IF PAGE IS NONEXISTENT

IF20,<
CHKNEX:	HRLI	T1,.FHSLF	;THIS FORK, PAGE NUMBER IS IN T1
	RPACS%			;READ PAGE ACCESS
	TXNN	T2,P1%PEX	;CHECK PAGE-EXISTS BIT (IN RH SO UNWRITTEN
				;  FILE PAGES ARE CONSIDERED TO EXIST)
	  AOS	(P)		;PAGE NONEXISTENT
	POPJ	P,		;PAGE EXISTS
>

IF10,<
CHKNEX:	HRLI	T1,.PAGCA	;CHECK ACCESS
	PAGE.	T1,		;TO PAGE NUMBER IN T1
	 $SNH			;SHOULD NEVER FAIL
	TXNE	T1,PA.GNE	;CHECK PAGE-NONEXISTENT BIT
	  AOS	(P)		;PAGE NONEXISTENT
	POPJ	P,		;PAGE EXISTS
>
	SEGMENT	DATA

REQBOT:	BLOCK	1		;BOTTOM OF CORE REQUEST
REQTOP:	BLOCK	1		;TOP+1 OF CORE REQUEST
JOBDDT:	BLOCK	1		;[4200] FAKE .JBDDT
%JBASE:	BLOCK	1		;.JBFF POINTING AFTER SYMBOL TABLE
SYMFP:	BLOCK	1		;SPACE BETWEEN .JBFF AND SYMTAB
SYMTP:	BLOCK	1		;BOTTOM,,TOP+1 OF SYMBOL TABLE
BEGPTR:	BLOCK	1		;POINTER TO START OF LIST
FREPTR:	BLOCK	1		;POINTER TO BLOCK TO START SEARCH AT
EOL:	BLOCK	2		;THE ZERO WORD AT END OF LIST

WRAP:	BLOCK	1		;-1 IF FIRST PASS THROUGH LIST

PAGSEC:	BLOCK	1		;Page # of start of this section

%PTAB:
PTAB:	BLOCK	^D29		;THE BIT TABLE
				;2 BITS PER PAGE. 01 = PAGE ALLOCATED
				;		  10 = PAGE EXISTS (TOPS-10)
				;		       OR IS USED (TOPS-20)
				;PAGE 0 IS RIGHT 2 BITS OF FIRST WORD

VRTBIT:	BLOCK	1		;0 IF TRYING FOR PHYSICAL PAGES,
				; PA.GCD IF TRYING FOR VIRTUAL PAGES

IF10,<
PBLK:	BLOCK	1		;ARG COUNT WORD
	BLOCK	PLEN		;ARGS

> ;END IF10

IF20,<				;[4120]
PDVBLK:	BLOCK	.POADE+1	;[4120] BLOCK FOR PDVOP%
PDVA:	BLOCK	MAXPDV		;[4120] BLOCK OF PDVA'S
PDVCNT:	BLOCK	1		;[4120] NUMBER OF PDV'S SEEN
PDVTTL:	BLOCK	1		;[4120] TOTAL PDVS IN RANGE
LOWADR:	BLOCK	1		;[4120] LOWEST ADDR IN SECTION
HIADR:	BLOCK	1		;[4205] HIGHEST ADDR IN SECTION
MEMCNT:	BLOCK	1		;[4120] COUNT OF WORDS LEFT IN .PVMEM BLOCK
> ;END IF20
	SUBTTL	OVERLAY (LOW SEGMENT) MEMORY MANAGER

	SEGMENT	CODE

	COMMENT	&

"Low segment" in these routines means the pages between 0 and .JBREL which
are used to hold the root segment and all of the user's overlays.  Note that
in the strict TOPS-10 sense, the low segment is these pages and also the
pages at the top of core with the OTS free storage and data in them.

The free list for the low segment is kept in one contiguous block of memory
in OTS free core.  Each word in the list gives the start and end address of
one block of free memory, the start address in the left half and the end
address + 1 in the right half.  The list is in increasing order on address.
All blocks are disjoint and not contiguous.

The free list table is pointed to by FLBEG and its length is in FLLEN.  The
maximum size of the free list is determined by the size of the table; this
number is in FLMAX.

	&
;ROUTINE TO MARK A BLOCK OF THE LOW SEG "ALLOCATED"
;ARGS:	 T1 = ADDRESS OF BEGINNING OF BLOCK
;	 T2 = ADDRESS OF END+1 OF BLOCK
;NONSKIP RETURN:  NOT ENOUGH MEMORY
;1 SKIP:  	  BLOCK ALREADY ALLOCATED OR OVERLAPS ALLOCATED BLOCK
;2 SKIPS:	  OK, BLOCK ALLOCATED

LSGET:	PUSHJ	P,%SAVE4	;SAVE P1-P4
	SKIPN	P3,FLBEG	;POINT TO START OF FREE LIST
	  PUSHJ	P,LSINIT	;NONE YET, GO MAKE ONE

	MOVE	P4,FLLEN	;GET LENGTH OF FREE LIST
GETLP:	SOJGE	P4,EXPRET	;IF ONE THERE, WE'RE OK
	CAMGE	T2,JOBFF	;TRYING TO ALLOCATE BELOW .JBFF?
	 JRST	%POPJ1		;YES. ALREADY ALLOCATED
	MOVEM	T1,DESLOW	;SAVE T1,T2 FOR EXPAND ROUTINE
	MOVEM	T2,DESHGH
	PUSHJ	P,LSEXP		;GO EXPAND CORE
	 POPJ	P,		;NON-SKIP MEANS CAN'T (INSUFFICIENT MEMORY)
	MOVE	T1,DESLOW	;RESTORE T1,T2
	MOVE	T2,DESHGH
	MOVE	P2,T2		;COPY HIGH ADDR + 1
	ADDI	P2,777		;ROUND END+1 UP TO MULTIPLE OF 1000
	TRZ	P2,777

	HRRZ	P1,-1(P3)	;GET END+1 OF TOP EXISTING FREE BLOCK
	CAML	P1,JOBFF	;DOES BLOCK END AT .JBFF?
	  SOJA P3,EXPMRG	;YES, MERGE IN THE NEW CORE WITH TOP BLOCK
	MOVE	P1,JOBFF	;NO, NEW CORE IS A NEW FREE BLOCK
	PUSHJ	P,BLTUP		;MOVE LIST UP TO MAKE ROOM FOR NEW BLOCK
	HRLZM	P1,(P3)		;STORE START ADDRESS OF NEW FREE BLOCK
EXPMRG:	HRRM	P2,(P3)		;STORE NEW END+1 ADDRESS OF FREE BLOCK
	MOVEM	P2,JOBFF	;STORE UPDATED .JBFF
	ADDI	P2,777		;WANT PAGE BEYOND ALLOCATED CORE
IF20,<	TRZ	P2,777		;MAKE IT A PAGE
	MOVEI	P1,-1(P2)	;TOPS-10 PROGS NEED .JBREL, SO KEEP IT RIGHT
	MOVEM	P1,.JBREL  >
	LSH	P2,-9		;GET HIGHEST PAGE + 1 THAT WE ALLOCATED
	MOVEM	P2,LPAGE	;REMEMBER IT

EXPRET:	HLRZ	P1,(P3)		;GET BEG ADRESS OF A FREE BLOCK
	HRRZ	P2,(P3)		;GET END+1

	CAIGE	P2,(T2)		;DOES FREE BLOCK END BEFORE ALLOCATED BLOCK?
	  AOJA	P3,GETLP	;YES, SEARCH FOR ONE WITH HIGH ENOUGH END ADDR

	CAILE	P1,(T1)		;DOES FREE BLOCK START AFTER ALLOCATED BLOCK?
	  JRST	%POPJ1		;YES, ALREADY ALLOCATED

	MOVEI	T3,(P2)		;CALCULATE MAX SIZE OF BLOCK ALLOCATABLE
	SUBI	T3,(T1)		; AT THIS ADDRESS FOR FUNCT.
	MOVEM	T3,BLKSIZ

	CAIE	P1,(T1)		;DO BLOCKS BEGIN AT SAME PLACE?
	  JRST	GECHK		;YES, GO COMPARE END POINTERS
	CAIE	P2,(T2)		;DO BLOCKS END AT SAME PLACE?
	  JRST	GTOP		;NO, ALLOCATE TOP PART OF BLOCK

;BLOCK TO BE ALLOCATED IS ALL OF AN EXISTING FREE BLOCK
GALL:	PUSHJ	P,BLTDWN	;ALLOCATE WHOLE BLOCK BY REMOVING IT
	XMOVEI	T1,(T1)		;[4017] GET GLOBAL ADDRESS
	JRST	%POPJ2		; COMPLETELY FROM THE FREE LIST

;BLOCK TO BE ALLOCATED IS TOP OF AN EXISTING FREE BLOCK
GTOP:	HRLM	T2,(P3)		;END ADDRESS OF ALLOCATED BLOCK IS NEW
	XMOVEI	T1,(T1)		;[4017] GET GLOBAL ADDRESS
	JRST	%POPJ2		; START ADDRESS OF FREE BLOCK

GECHK:	CAIE	P2,(T2)		;DO BLOCKS END AT SAME PLACE?
	  JRST	GMIDDL		;NO, ALLOCATE CHUNK FROM MIDDLE

;BLOCK TO BE ALLOCATED IS BOTTOM OF AN EXISTING FREE BLOCK
GBOT:	HRRM	T1,(P3)		;START ADDRESS OF ALLOCATED BLOCK IS NEW
	XMOVEI	T1,(T1)		;[4017] GET GLOBAL ADDRESS
	JRST	%POPJ2		; END ADDRESS OF FREE BLOCK

;BLOCK TO BE ALLOCATED IS IN MIDDLE OF AN EXISTING FREE BLOCK
GMIDDL:	PUSHJ	P,BLTUP		;MAKE A HOLE IN THE FREE LIST
	HRRM	T1,(P3)		;SET NEW END ADDRESS
	HRLM	T2,1(P3)	;AND NEW START ADDRESS
	XMOVEI	T1,(T1)		;[4017] GET GLOBAL ADDRESS
	JRST	%POPJ2		;DONE
;HERE WHEN LOW SEG MUST BE EXPANDED TO ALLOCATE CORE.  FAKE A CORE UUO

EXPADR:	MOVE	T2,DESHGH	;GET DESIRED HIGH ADDR

	MOVE	P1,LPAGE	;GET HIGHEST PAGE NUMBER IN LOW SEG
	MOVEI	P2,777(T2)	;ROUND TOP ADDRESS TO ALLOCATE UP TO A PAGE
	LSH	P2,-9		;GIVING TOP PAGE TO ALLOCATE
	SUBI	P2,(P1)		;COMPUTE NUMBER OF PAGES TO CREATE
	JUMPE	P2,%POPJ1	;IF NONE, SKIP
	JUMPL	P2,DEALC	;CORE HAS TO BE REDUCED
	  PUSHJ	P,CREPGS	;CREATE THE PAGES
	 POPJ	P,		;INSUFFICIENT MEMORY
	JRST	%POPJ1		;OK. DONE

DEALC:	ADD	P1,P2		;GET LOWEST PAGE TO KILL
	MOVM	P2,P2		;MAKE COUNT POSITIVE
	PUSHJ	P,KILPGS	;KILL THE PAGES
	JRST	%POPJ1		;SKIP RETURN, LIKE ABOVE
LSINIT:	STKVAR	<SAVET,>	;ALLOCATE SPACE ON STACK
	DMOVEM	T1,SAVET	;SAVE T1-T2
	MOVEI	T1,FLSIZE+1	;GET INITIAL SIZE OF FREE LIST BLOCK
	PUSHJ	P,%GTBLK	;GET CORE FOR FREE LIST
	 $ECALL	MFU,%ABORT	;[4131] CAN'T
	MOVEI	P3,1(T1)	;PUT IN RIGHT AC
	MOVEM	P3,FLBEG	;SAVE START ADDRESS
	SETZM	FLLEN		;TABLE HAS ZERO LENGTH INITIALLY
	SETZM	-1(P3)		;MAKE A FAKE FREE BLOCK STARTING AT 0 AND
				; ENDING AT 0 FOR BOUNDARY CONDITION IN LSFREE
	MOVEI	T1,FLSIZE	;SET FLMAX
	MOVEM	T1,FLMAX
	DMOVE	T1,SAVET	;RESTORE T1-T2
	UNSTK			;FIX STACK
	POPJ	P,		;ALL DONE
;ROUTINE TO MARK A BLOCK IN THE LOW SEGMENT "FREE"
;ARGS:	 T1 = BEG ADDRESS
;	 T2 = END+1 ADDRESS
;NONSKIP RETURN IF BLOCK WASN'T ALLOCATED, ELSE SKIP RETURN

LSFREE:	PUSHJ	P,%SAVE4	;SAVE P1-P4
	SKIPN	P3,FLBEG	;POINT TO FREE LIST
	  POPJ	P,		;NONE SET UP, ERROR RETURN

	MOVEI	T1,(T1)		;[4017] MAKE LOCAL ADDRESS
	MOVEI	T2,(T2)		;[4017] MAKE LOCAL ADDRESS
	SKIPA	P4,FLLEN	;GET LENGTH OF FREE LIST
FREELP:	ADDI	P3,1		;BUMP TO NEXT ENTRY IN FREE LIST
	SOJL	P4,FREEFF	;END OF FREE LIST, GO CHECK .JBFF
	HRRZ	P1,-1(P3)	;GET START ADDRESS OF ALLOCATED BLOCK
	HLRZ	P2,(P3)		;GET END ADDRESS OF SAME ALLOCATED BLOCK

	CAIGE	P2,(T2)		;DOES ALLOCATED BLOCK END BEFORE FREE BLOCK?
	  JRST	FREELP		;YES, SEARCH FOR ONE WITH HIGH ENOUGH END ADR
	CAILE	P1,(T1)		;DOES ALLOCATED BLOCK START AFTER FREE BLOCK?
	  POPJ	P,		;YES, FREE BLOCK IS ALREADY FREE

	CAIE	P1,(T1)		;DO BLOCKS START AT SAME PLACE?
	  JRST	FECHK		;NO, GO COMPARE END POINTERS
	CAIE	P2,(T2)		;DO BLOCKS START AT SAME PLACE?
	  JRST	FTOP		;NO, FREE TOP PART OF BLOCK

;BLOCK TO BE FREED IS ALL OF AN EXISTING ALLOCATED BLOCK
	HRRZ	T2,(P3)		;SAVE POINTER TO END OF FREE BLOCK
	PUSHJ	P,BLTDWN	;REMOVE FREE BLOCK FROM LIST
;	HRRM	T2,-1(P3)	;COMBINE PREVIOUS AND FOLLOWING FREE BLOCKS
;	JRST	%POPJ1		;BLOCK FREED

;BLOCK TO BE FREED IS TOP OF AN EXISTING FREE BLOCK
FTOP:	HRRM	T2,-1(P3)	;NEW START ADDRESS OF FOLLOWING FREE BLOCK
	JRST	%POPJ1		; IS START ADDRESS OF BLOCK BEING FREED

FECHK:	CAIE	P2,(T2)		;DO BLOCKS END AT SAME PLACE?
	  JRST	FMIDDL		;NO, FREE BLOCK IN MIDDLE

;BLOCK TO BE FREED IS BOTTOM OF AN EXISTING ALLOCATED BLOCK
FBOT:	HRLM	T1,(P3)		;NEW END ADDRESS OF FREE BLOCK IS START
	JRST	%POPJ1		; ADDRESS OF BLOCK BEING FREED

;BLOCK TO BE FREED IS IN MIDDLE OF AN EXISTING ALLOCATED BLOCK
FMIDDL:	PUSHJ	P,BLTUP		;MAKE A HOLE IN THE FREE LIST
	HRLM	T1,(P3)		;PUT A NEW ENTRY IN THE LIST
	HRRM	T2,(P3)
	JRST	%POPJ1		;BLOCK FREED
;HERE WHEN USER FREES A BLOCK ABOVE THE TOP EXISTING FREE BLOCK.
;SEE IF IT IS BELOW .JBFF AND IF SO, FREE IT

FREEFF:	CAMLE	T2,JOBFF	;TRYING TO FREE BLOCK ABOVE .JBFF?
	  POPJ	P,		;YES, ALREADY FREE
	SUBI	P3,1		;POINT TO TOP EXISTING FREE BLOCK

	HRRZ	P1,(P3)		;GET END ADDRESS OF TOP BLOCK
	CAILE	P1,(T1)		;DOES IT END AFTER THE ONE USER IS FREEING?
	  POPJ	P,		;YES, USER'S BLOCK IS ALREADY FREE

	CAIE	P1,(T1)		;IS USER'S BLOCK CONTIGUOUS WITH TOP BLOCK?
	  JRST	FNEW		;NO, GO CREATE NEW ENTRY IN FREE LIST
	HRRM	T2,(P3)		;MERGE FREE BLOCKS TOGETHER
	JRST	%POPJ1		;RETURN

FNEW:	PUSHJ	P,BLTUP		;MAKE NEW ENTRY IN FREE LIST
	HRLZM	T1,1(P3)	;BEG ADDRESS IS IN T1
	HRRM	T2,1(P3)	;END+1 ADDRESS IS IN T2
	JRST	%POPJ1		;ALL DONE
;ROUTINE TO LOCATE A FREE BLOCK OF SUFFICIENT SIZE
;ARGS:	 T2 = SIZE OF BLOCK TO FIND
;RETURN: T1 = ADDRESS OF A BLOCK TO ALLOCATE
;	 T2 UNCHANGED

LSFIND:	PUSHJ	P,%SAVE4	;SAVE P1-P4
	MOVE	T1,JOBFF	;IF ALL ELSE FAILS, ALLOCATE AT .JBFF
	SKIPN	P3,FLBEG	;POINT TO FREE LIST
	  POPJ	P,		;NO FREE LIST, USE .JBFF
	MOVE	P4,FLLEN	;GET LENGTH OF LIST
FINDLP:	SOJL	P4,TOPCOR	;NO NEXT ENTRY, CHECK LAST ENTRY
	HLRZ	P1,(P3)		;GET START OF FREE BLOCK
	HRRZ	P2,(P3)		;AND END+1
	SUBI	P2,(P1)		;COMPUTE LENGTH
	CAIGE	P2,(T2)		;BIG ENOUGH?
	  AOJA	P3,FINDLP	;NO, KEEP LOOKING
	MOVEI	T1,(P1)		;PUT ADDRESS IN RIGHT AC
	POPJ	P,		;RETURN

TOPCOR:	HRRZ	P1,-1(P3)	;GET TOP+1 OF LAST FREE BLOCK
	CAMN	P1,JOBFF	;IS IT .JBFF?
	 HLRZ	T1,-1(P3)	;YES. USE BOTTOM OF BLOCK AS BASE LOC
	POPJ	P,
;ROUTINE TO CUT BACK THE LOW SEG SIZE TO MINIMUM
;NO ARGS

LSTRIM:	PUSHJ	P,%SAVE2	;SAVE P1-P2
	MOVE	P1,JOBFF	;GET HIGHEST ADDRESS WE NEED TO KEEP
	SKIPG	T1,FLLEN	;GET FREE LIST LENGTH
	  JRST	CALEXP		;NO FREE LIST, USE .JBFF
	ADD	T1,FLBEG	;POINT TO END OF FREE LIST
	HRRZ	T2,-1(T1)	;GET END+1 ADDRESS OF TOP FREE BLOCK
	CAIGE	T2,(P1)		;DOES TOP BLOCK END AT .JBFF?
	  JRST	CALEXP		;NO, CUT BACK TO .JBFF
	HLRZ	P1,-1(T1)	;CUT BACK TO START OF TOP FREE BLOCK
	SOS	FLLEN		;DELETE BLOCK FROM FREE LIST
CALEXP:	MOVEM	P1,DESHGH	;TELL LSEXP WE WANT TO SHRINK
	PUSHJ	P,LSEXP
	JFCL			;WILL ALWAYS SKIP RETURN

TRIMFF:	MOVE	P1,DESHGH	;GET NEW HIGH ADDR
	MOVEM	P1,JOBFF	;STORE NEW .JBFF
	ADDI	P1,777		;ROUND UP TO PAGE NUMBER
IF20,<	TRZ	P1,777		;ON TOPS-20, STORE .JBREL TOO
	MOVEI	P2,-1(P1)	; FOR OLD PROGS
	MOVEM	P2,.JBREL  >
	LSH	P1,-9		;GET FIRST PAGE GIVEN BACK
	MOVEM	P1,LPAGE	;STORE NEW HIGHEST PAGE+1
	POPJ	P,		;DONE
;ROUTINES TO EXPAND AND CONTRACT THE FREE LIST
;ARGS:	 P3 = ADDRESS IN LIST TO EXPAND OR CONTRACT AT
;RETURN: P3 UNCHANGED, T1-T4 UNCHANGED

;TO BE PRECISE:
;
;	BEFORE		  BLTUP		  BLTDWN
;
;   !-------------!  !-------------!  !-------------!
;   !             !  !             !  !             !  <-- FLBEG
;   !             !  !             !  !             !
;   !             !  !             !  !             !
;   !------!------!  !------!------!  !------!------!
;   !  B1  !  E1  !  !  B1  !  E1  !  !  B1  !  E1  !
;   !------!------!  !------!------!  !------!------!
;   !  B2  !  E2  !  !  B2  !  E2  !  !  B3  !  E3  !  <-- P3
;   !------!------!  !------!------!  !------!------!
;   !  B3  !  E3  !  !  B2  !  E2  !  !             !
;   !------!------!  !------!------!  !             !
;   !             !  !  B3  !  E3  !  !             !
;   !             !  !------!------!  !             !
;   !             !  !             !  !-------------!
;   !             !  !             !
;   !-------------!  !             !
;                    !             !
;                    !-------------!


BLTDWN:	STKVAR	<SAVET,>	;ALLOCATE SPACE ON STACK
	DMOVEM	T1,SAVET	;SAVE T1-T2
	SOSG	T1,FLLEN	;DECREMENT LS TABLE LENGTH
	  JRST	BLTRET		;ZERO LENGTH, ALL DONE
	ADD	T1,FLBEG	;COMPUTE END+1 OF TABLE
	MOVSI	T2,1(P3)	;SET BLT FROM ADDRESS
	HRRI	T2,(P3)		;AND BLT TO ADDRESS
	CAILE	T1,(T2)		;CHECK FOR 1-WORD TABLE
	  BLT	T2,-1(T1)	;MOVE THE TABLE DOWN ONE
	JRST	BLTRET		;ALL DONE

BLTUP:	STKVAR	<SAVET,>	;ALLOCATE SPACE ON STACK
	DMOVEM	T1,SAVET	;SAVE T1-T2
	AOS	T1,FLLEN	;INCREMENT TABLE LENGTH
	CAMLE	T1,FLMAX	;IN BOUNDS?
	  PUSHJ	P,BLTEXP	;NO, GO MOVE TO BIGGER TABLE
	ADD	T1,FLBEG	;COMPUTE END+1 OF NEW TABLE
	MOVEI	T2,-2(T1)	;GET END ADDR OF OLD TABLE
	SUBI	T2,(P3)		;COMPUTE LENGTH-1 WE NEED TO POP
	JUMPL	T2,BLTRET	;[3135] Don't try to do 0 POPs
	HRLI	T1,400000(T2)	;PUT INTO POP POINTER
	HRRI	T1,-2(T1)	;MAKE RH OF POINTER
	POP	T1,1(T1)	;BACKWARDS BLT
	JUMPL	T1,.-1

BLTRET:	DMOVE	T1,SAVET	;RESTORE T1-T2
	UNSTK
	POPJ	P,		;ALL DONE
;HERE WHEN FREE LIST TABLE FILLS UP
;MOVE THE FREE LIST INTO A BIGGER BLOCK.  FIX ALL POINTERS INTO THE FREE LIST
;TO POINT TO THE NEW BLOCK.  (THE ONLY THINGS THAT POINT TO THE FREE LIST ARE
;FLBEG AND P3.)

BLTEXP:	STKVAR	<SAVET,>	;ALLOCATE SPACE ON STACK
	DMOVEM	T3,SAVET	;SAVE T3-T4

	MOVE	T2,FLMAX	;GET OLD LENGTH OF TABLE
	MOVEI	T3,FLSIZE(T2)	;GET NEW LENGTH
	MOVEM	T3,FLMAX	;SAVE NEW LENGTH
	MOVE	T1,FLBEG	;GET OLD ADDRESS
	ADDI	T3,1		;FIX THINGS UP BECAUSE OF PHANTOM 0 WORD
	ADDI	T2,1		; BEFORE START OF LIST.  IT'S THERE BECAUSE
	SUBI	T1,1		; LSFREE USES -1(P3) SOMETIMES

	SUBI	P3,(T1)		;UNRELOCATE P3
	PUSHJ	P,%MVBLK	;MOVE TABLE TO BIGGER BLOCK
	 $ECALL	MFU,%ABORT	;[4131] CAN'T. OUT OF MEMORY
	ADDI	P3,(T1)		;RERELOCATE P3

	ADDI	T1,1		;SKIP PAST PHANTOM 0 WORD AT START OF TABLE
	MOVEM	T1,FLBEG	;STORE NEW ADDRESS OF TABLE

	MOVE	T1,FLLEN	;RESTORE T1
	DMOVE	T3,SAVET	;RESTORE T3-T4
	UNSTK			;FIX UP STACK POINTER
	POPJ	P,		;RETURN
	SEGMENT	DATA

FLBEG:	BLOCK	1		;START ADDRESS OF LS FREE STORAGE TABLE
FLLEN:	BLOCK	1		;LENGTH
FLMAX:	BLOCK	1		;MAX LENGTH

%EXPNT:	BLOCK	1		;ADDRESS OF "CORE UUO" SIMULATOR
%JBFPT:	BLOCK	1		;ADDRESS OF .JBFF
%LPAGE:
LPAGE:	BLOCK	1		;HIGHEST PAGE + 1 ALLOCATED IN LOW SEG
DESLOW:	BLOCK	1		;BOTTOM OF DESIRED BLOCK
%DESHG:
DESHGH:	BLOCK	1		;TOP OF DESIRED BLOCK

BLKSIZ:	BLOCK	1		;MAX SIZE OF ALLOCATABLE BLOCK FROM LSGET
	SUBTTL	ALCOR. AND DECOR.

	SEGMENT	CODE

;ROUTINES TO PROVIDE STANDARD INTERFACE TO FOROTS CORE MANAGEMENT FOR
;MACRO PROGRAMS.  STANDARD FORTRAN CALLING SEQUENCE, WITH ONE ARGUMENT
;POINTED TO BY AC 16.  RESULT RETURNED IN AC 0.


;ALCOR.  ALLOCATE A BLOCK OF CORE
;ARG:	 SIZE TO ALLOCATE
;RETURN: AC 0 = ADDRESS OF BLOCK, OR -1 IF NONE AVAILABLE

	FENTRY	(ALCOR)
	PUSHJ	P,SAVAC		;SAVE USER'S ACS
	MOVE	T1,@(L)		;GET NUMBER OF WORDS TO ALLOCATE
	PUSHJ	P,GTBLKX	;ALLOCATE A BLOCK
	  SETO	T1,		;NONE AVAILABLE
	MOVEM	T1,FMACS	;GIVE ADDRESS TO USER IN AC0
	JUMPL	T1,%POPJ	;DONE NOW IF ERROR
	MOVE	T2,-1(P)	;GET RETURN ADDRESS OFF STACK
	HRLM	T2,-1(T1)	;STORE IN BLOCK HEADER FOR DEBUGGING
	POPJ	P,		;RETURN



;DECOR.  DEALLOCATE A BLOCK OF CORE
;ARG:	ADDRESS OF BLOCK

	FENTRY	(DECOR)
	PUSHJ	P,SAVAC		;SAVE USER'S ACS
	MOVE	T1,@(L)		;GET ADDRESS OF BLOCK
	PJRST	%FREBLK		;FREE IT AND RETURN


IF10,<

;ALLOCATE I/O CHANNEL

;TWO ENTRY POINTS:

;ALCHN.: STANDARD FORTRAN CALLING SEQUENCE, ONE ARG POINTED TO BY L
;	 ARG = 0 TO FIND A FREE CHANNEL, 1-17 TO ALLOCATE THAT SPECIFIC CHANNEL
;RETURN: T0 = CHANNEL NUMBER ALLOCATED, OR -1 IF NO FREE CHANNELS

;%ALCHF: T1 =  0 TO FIND A FREE CHANNEL, 1-17 TO ALLOCATE THAT SPECIFIC CHANNEL
;RETURN: T1 = CHANNEL NUMBER ALLOCATED.  NONSKIP RETURN IF NO FREE CHANNELS

	FENTRY	(ALCHN)
	PUSHJ	P,SAVAC		;SAVE USER'S ACS
	MOVE	T1,@0(L)	;GET USER'S ARG
	TDNE	T1,[-20]	;IF NEGATIVE OR OVER 17, ERROR
	  JRST	ALCHNX
	PUSHJ	P,%ALCHF	;TRY TO ALLOCATE CHANNEL
ALCHNX:	  SETO	T1,		;CAN'T
	MOVEM	T1,FMACS	;[4203] STORE FOR USER
	POPJ	P,		;RETURN


%ALCHF:	JUMPN	T1,ALCHN1	;IF SPECIFIC REQUEST, GO TRY TO ALLOCATE IT

ALCHN:	MOVE	T0,%CHMSK	;GET ALLOCATED CHANNEL MASK
	JFFO	T0,ALCHN1	;FIND FIRST FREE CHANNEL
	  POPJ	P,		;NONE, ERROR RETURN

ALCHN1:	MOVNI	T3,(T1)		;GET SHIFT COUNT FOR CHANNEL
	MOVSI	T2,(1B0)	;GET A 1 BIT
	LSH	T2,(T3)		;SHIFT INTO POSITION
	TDNN	T2,%CHMSK	;CHANNEL FREE?
	  POPJ	P,		;NO, ERROR RETURN
	ANDCAM	T2,%CHMSK	;MARK IT ALLOCATED
	JRST	%POPJ1		;SUCCESS RETURN
;DEALLOCATE CHANNEL

;TWO ENTRY POINTS:

;DECHN.: STANDARD FORTRAN CALLING SEQUENCE, ONE ARG POINTED TO BY L
;	 ARG = CHANNEL NUMBER TO DEALLOCATE
;RETURN: T0 = 0 IF DEALLOCATED OK, -1 IF CHANNEL WASN'T ALLOCATED

;%DECHF: T1 = CHANNEL NUMBER TO DEALLOCATE
;NONSKIP RETURN IF CHANNEL NOT ALLOCATED, SKIP RETURN IF OK

	FENTRY	(DECHN)
	PUSHJ	P,SAVAC		;SAVE USER'S ACS
	MOVE	T1,@0(L)	;GET ARG
	TDNE	T1,[-20]	;RANGE CHECK
	  JRST	DECHNX		;ILLEGAL CHANNEL, ERROR
	PUSHJ	P,%DECHF	;DEALLOCATE THE CHANNEL
DECHNX:	  SKIPA	T1,[-1]		;CAN'T
	SETZ	T1,		;CAN, DID
	MOVEM	T1,FMACS	;[4203] STORE FOR RETURN TO USER
	POPJ	P,		;RETURN

%DECHF:	MOVNI	T1,(T1)		;GET SHIFT COUNT
	MOVSI	T2,(1B0)	;GET A 1 BIT
	LSH	T2,(T1)		;SHIFT INTO POSITION
	TDNE	T2,%CHMSK	;CHANNEL ALLOCATED?
	  POPJ	P,		;NO, ERROR
	IORM	T2,%CHMSK	;DEALLOCATE IT
	JRST	%POPJ1		;SUCCESS


>;END IF10
IF20,<

	FENTRY	(ALCHN)
	SETO	T0,		;NO CHANNELS AVAILABLE ON -20
%ALCHF:	POPJ	P,		;SAY SO AND RETURN

	FENTRY	(DECHN)
	SETO	T0,		;NO CHANNEL CAN BE ALLOCATED
%DECHF:	POPJ	P,		;ERROR RETURN

>;END IF20

;SAVAC - SAVE THE AC'S LOCALLY IN FORMEM, AS THESE ROUTINES CAN BE
;CALLED WITHIN I/O STATEMENTS.
SAVAC:	POP	P,RETA		;SAVE THE RETURN ADDR
	MOVEM	0,FMACS		;SAVE AC 0
	MOVE	0,[1,,FMACS+1]	;SAVE THE REST
	BLT	0,FMACS+17
	PUSHJ	P,@RETA		;RETURN TO FOROTS, LEAVE RESTORE RETURN ADDR
	HRLZI	16,FMACS	;RESTORE THE ACS
	BLT	16,16		;WITH A BLT
	POPJ	P,		;RETURN TO USER'S PROGRAM

	SEGMENT	DATA

FMACS:	BLOCK	20		;LOCAL AC SAVE AREA
RETA:	BLOCK	1		;RETURN ADDRESS
	SUBTTL	FUNCT.

	SEGMENT	CODE

;GENERAL-PURPOSE OTS INTERFACE.  USES STANDARD FORTRAN CALLING SEQUENCE,
;WITH ARG BLOCK POINTED TO BY AC 16.  THE FIRST THREE ARGS ARE STANDARD,
;THE REST ARE FUNCTION-SPECIFIC.  THIS ROUTINE DOES NOT CHECK THAT IT IS
;GIVEN THE CORRECT NUMBER OF ARGUMENTS, OR THAT THEY HAVE THE CORRECT TYPE.

;FUNCT. ARGS

	FN==0			;FUNCTION CODE
	ERRPFX==1		;3-CHAR PREFIX FOR ERRORS, ASCIZ
	STATUS==2		;RETURNED STATUS, NONZERO MEANS ERROR
	ARG1==3			;FUNCTION-DEPENDENT ARGS
	ARG2==4
	ARG3==5

;FUNCTION DISPATCH TABLE

FDISP:	IFIW	F.ILL		;0  ILLEGAL
	IFIW	F.GAD		;1  GET LS MEMORY AT ADDRESS
	IFIW	F.COR		;2  GET LS MEMORY ANYWHERE
	IFIW	F.RAD		;3  RETURN LS MEMORY
	IFIW	F.GCH		;4  GET I/O CHANNEL
	IFIW	F.RCH		;5  RETURN I/O CHANNEL
	IFIW	F.GOT		;6  GET OTS MEMORY
	IFIW	F.ROT		;7  RETURN OTS MEMORY
	IFIW	F.RNT		;10 GET INITIAL RUNTIME
	IFIW	F.IFS		;11 GET INITIAL RUN FILESPEC
	IFIW	F.CBC		;12 CUT BACK LS TO MINIMUM
	IFIW	F.RRS		;13 READ RETAIN STATUS (DBMS)
	IFIW	F.WRS		;14 WRITE RETAIN STATUS (DBMS)
	IFIW	F.GPG		;15 GET PAGES
	IFIW	F.RPG		;16 RETURN PAGES
	IFIW	F.GPSI		;17 GET TOPS-20 PSI CHANNEL
	IFIW	F.RPSI		;20 RETURN TOPS-20 PSI CHANNEL
	IFIW	F.MPG		;21 SET PAGES USED
	IFIW	F.UPG		;22 SET PAGES FREE
	IFIW	F.USD		;23 GET # PAGES USED
	IFIW	F.MAP		;24 GET CORE BITMAP
LDISP==.-FDISP-1		;MAX LEGAL FUNCTION CODE


;HERE IT IS

	FENTRY	(FUNCT)
FUNCT:	PUSHJ	P,SAVAC		;SAVE USER'S ACS
%FUNCX:	SKIPLE	T1,@FN(L)	;GET FUNCTION CODE
	CAILE	T1,LDISP	;LEGAL?
	  SETZ	T1,		;NO, SET TO ILLEGAL FUNCTION
	JRST	@FDISP(T1)	;DISPATCH
;FUNCTION 0:  ILLEGAL
;
;RETURNS STATUS -1 (NOT IMPLEMENTED)


F.ILL:	SETOM	@STATUS(L)	;SET RETURN STATUS TO -1
	POPJ	P,		;AND RETURN





;FUNCTION 1:  GET LOW SEGMENT MEMORY AT GIVEN ADDRESS
;
;ARG1:	ADDRESS
;ARG2:	SIZE
;
;RETURNS STATUS 0 IF ALLOCATED OK
;		1 IF INSUFFICIENT MEMORY
;		2 IF ALREADY ALLOCATED AT THAT ADDRESS
;		3 IF ARGUMENT ERROR


F.GAD:	MOVE	T1,@ARG1(L)	;GET ADDRESS
	SKIPG	T2,@ARG2(L)	;AND LENGTH
	  JRST	GADX		;NEGATIVE LENGTH MEANS GET BIG BLOCK
	TLNN	T1,-1		;CHECK FOR REASONABLE ADDRESS
	 JRST	GADOK1		;[4175] LOCAL ADDR IS ALWAYS AN OK ARG
	HLLZ	T3,T1		;[4175] GET THE SECTION NUMBER
	XMOVEI	T4,.		;[4175] GET FOROTS' SECTION NUMBER
	HLLZ	T4,T4		;[4175] 
	CAME	T3,T4		;[4175] THE SAME?
	 JRST	ERR3		;[4175] NO. JUNK CALL
	MOVEI	T1,(T1)		;[4175] YES. JUST GET LOCAL ADDRESS
GADOK1:	ADD	T2,T1		;[4175] COMPUTE END+1 OF REQUESTED CORE
	TLNE	T2,-1		;CHECK END+1 FOR REASONABLE ADDRESS
	 JRST	ERR3		;JUNK CALL, REJECT IT

	DMOVEM	T1,REQBOT	;SAVE BOTTOM, TOP+1 OF REQUEST
	PUSHJ	P,LSGET		;ALLOCATE THE CORE
	  JRST	ERR1		;NOT ENOUGH MEMORY
	  JRST	TRYSYM		;ALREADY ALLOCATED. SEE IF SYMBOL TABLE
	JRST	OKRET		;ALLOCATED


;HERE IF F.GAD CALL FAILS WITH CORE ALREADY ALLOCATED.
;IF THE TOP OF THE CORE REQUEST IS WITHIN THE BOUNDS OF THE
;ORIGINAL SYMBOL TABLE, RECORDED AS ALLOCATED, THE SYMBOL
;TABLE IS INSERTED INTO THE FREE-CORE LIST. IT IS ASSUMED
;THAT THE USER (OR OVRLAY) KNOWS WHAT HE/SHE/IT IS DOING...
TRYSYM:	SKIPN	SYMTP		;ANY OLD SYMBOL TABLE?
	 JRST	ERR2		;NO
	SKIPE	FLLEN		;ANY ENTRIES IN FREE-LIST YET?
	 JRST	INSSYM		;YES. GO INSERT THE SYMTAB ENTRY
	PUSHJ	P,LSINIT	;NO. CREATE A FREE LIST
	AOS	FLLEN		;INCR # ENTRIES
	MOVE	T1,SYMTP	;GET THE SYMBOL TABLE ENTRY
	MOVEM	T1,(P3)		;DROP IT INTO THE FREE LIST
	JRST	GADAGN		;GO TRY AGAIN

INSSYM:	HLRZ	T1,SYMTP	;GET BOTTOM OF OLD SYMBOL TABLE
	HRRZ	T2,SYMTP	;GET TOP+1 OF OLD SYMBOL TABLE
	PUSHJ	P,LSFREE	;PUT THE SYMBOL TABLE IN THE FREE-LIST
	 $SNH			;BETTER BE A FREE-LIST!
GADAGN:	SETZM	SYMTP		;DON'T TRY THIS AGAIN
	DMOVE	T1,REQBOT	;GET THE ORIGINAL CORE REQUEST PARAMS
	PUSHJ	P,LSGET		;TRY TO GET IT
	 JRST	ERR1		;MEMORY FULL
	 JRST	ERR2		;ALREADY ALLOCATED
	JRST	OKRET		;GOT IT!

GADX:	AOJN	T2,ERR3		;ONLY LEGAL NEGATIVE ARG IS -1
	MOVEI	T2,1(T1)	;TRY TO ALLOCATE 1 WORD
	DMOVEM	T1,DTEMP	;SAVE BEG AND END+1 OF BLOCK
	PUSHJ	P,LSGET		;TRY FOR 1 WORD AT GIVEN ADDRESS
	  JRST	ERR1		;NOT ENOUGH MEMORY
	  JRST	TRYSYM		;ALREADY ALLOCATED. TRY FREEING SYMBOLS

	DMOVE	T1,DTEMP	;GET BEG AND END+1 OF THE WORD
	PUSHJ	P,LSFREE	;FREE THE 1 WORD
	 $SNH			;Not allocated, internal error

	MOVE	T1,DTEMP	;GET ADDRESS
	MOVE	T2,BLKSIZ	;AND SIZE, RETURNED BY FIRST LSGET
	MOVEM	T2,@ARG2(L)	;GIVE ALLOCATED LENGTH TO USER
	ADDI	T2,(T1)		;COMPUTE END+1 OF BLOCK
	PUSHJ	P,LSGET		;ALLOCATE MAX SPACE
	  $SNH			;Not enough memory
	  $SNH			;Already allocated

	JRST	OKRET		;ALL OK





;FUNTION 2:  GET LOW SEGMENT MEMORY AT ANY ADDRESS
;
;ARG2:	SIZE
;
;RETURNS ARG1 = ADDRESS OF ALLOCATED MEMORY
;	 STATUS 0 IF ALLOCATED OK
;		1 IF INSUFFICIENT MEMORY
;		3 IF ARGUMENT ERROR


F.COR:	SKIPLE	T2,@ARG2(L)	;GET SIZE
	TLNE	T2,-1		;CHECK IT
	  JRST	ERR3		;WRONG

	PUSHJ	P,LSFIND	;FIND A SPOT WITH ENOUGH SPACE
	ADD	T2,T1		;COMPUTE END+1 OF CORE TO ALLOCATE
	TLNE	T2,-1		;DID WE GO TO THE NEXT SECTION?
	 JRST	ERR1		;YES. WE CAN'T DO THAT!
	PUSHJ	P,LSGET		;ALLOCATE IT
	 JRST	ERR1		;NOT ENOUGH MEMORY
	  $SNH			;Already allocated, internal error
	MOVEM	T1,@ARG1(L)	;STORE ADDRESS FOR CALLER
	JRST	OKRET		;RETURN




;FUNCTION 3:  RETURN LOW SEGMENT MEMORY
;
;ARG1:	ADDRESS
;ARG2:	SIZE
;
;RETURNS STATUS 0 IF DEALLOCATED OK
;		1 IF MEMORY WASN'T ALLOCATED
;		3 IF ARGUMENT ERROR


F.RAD:	MOVE	T1,@ARG1(L)	;GET ADDRESS
	SKIPG	T2,@ARG2(L)	;AND SIZE
	  JRST	ERR3		;ILLEGAL SIZE
	TLNN	T1,-1		;CHECK ARGS
	 JRST	RADOK1		;[4175] LOCAL ADDR IS ALWAYS AN OK ARG
	HLLZ	T3,T1		;[4175] GET THE SECTION NUMBER
	XMOVEI	T4,.		;[4175] GET FOROTS' SECTION NUMBER
	HLLZ	T4,T4		;[4175] 
	CAME	T3,T4		;[4175] THE SAME?
	 JRST	ERR3		;[4175] NO. JUNK CALL
	MOVEI	T1,(T1)		;[4175] YES. JUST GET LOCAL ADDRESS
RADOK1:	ADD	T2,T1		;[4175] COMPUTE END+1 OF REQUESTED CORE
	TLNE	T2,-1
	  JRST	ERR3		;BAD

	PUSHJ	P,LSFREE	;DEALLOCATE BLOCK
	  JRST	ERR1		;WASN'T ALLOCATED
	JRST	OKRET		;OK, RETURN





;FUNCTION 4:  GET I/O CHANNEL
;
;RETURNS ARG1 = CHANNEL NUMBER
;	 STATUS 0 IF CHANNEL ALLOCATED OK
;		1 IF NO CHANNEL AVAILABLE (OR TOPS-20)


F.GCH:	SETZ	T1,		;REQUEST ANY AVAILABLE CHANNEL
	PUSHJ	P,%ALCHF	;ALLOCATE CHANNEL
	  JRST	ERR1		;NONE AVAILABLE
	MOVEM	T1,@ARG1(L)	;GIVE TO USER
	JRST	OKRET		;OK, RET





;FUNCTION 5:  RETURN I/O CHANNEL
;
;ARG1:	CHANNEL NUMBER
;
;RETURNS STATUS 0 IF DEALLOCATED OK
;		1 IF CHANNEL WASN'T ALLOCATED


F.RCH:	MOVE	T1,@ARG1(L)	;GET CHANNEL NUMBER
	TDNN	T1,[-20]	;ERROR IF ARG NOT IN 0-17
	PUSHJ	P,%DECHF	;FREE THE CHANNEL
	  JRST	ERR1		;WASN'T ALLOCATED
	JRST	OKRET		;OK




;FUNCTION 6:  GET MEMORY FROM OTS LIST
;
;ARG2:	SIZE
;
;RETURNS ARG1 = ADDRESS OF ALLOCATED MEMORY
;	 STATUS 0 IF ALLOCATED OK
;		1 IF NOT ENOUGH MEMORY
;		3 IF ARGUMENT ERROR


F.GOT:	SKIPLE	T1,@ARG2(L)	;GET SIZE
	TLNE	T1,-1		;CHECK FOR LEGALITY
	  JRST	ERR3		;BAD ARG
	PUSHJ	P,GTBLKX	;GET IT
	  JRST	ERR1		;NOT ENOUGH MEMORY
	MOVEM	T1,@ARG1(L)	;TELL USER THE ADDRESS
	MOVE	T2,-1(P)	;GET RETURN ADDRESS OFF STACK
	HRLM	T2,-1(T1)	;STORE IN BLOCK HEADER FOR DEBUGGING
	JRST	OKRET		;OK





;FUNTION 7:  RETURN MEMORY TO OTS LIST
;
;ARG1:	ADDRESS
;ARG2:	SIZE
;
;RETURNS STATUS 0 IF DEALLOCATED OK
;		1 IF WASN'T ALLOCATED
;		3 IF ARGUMENT ERROR


F.ROT:	SKIPLE	T1,@ARG1(L)	;GET ADDRESS
	TLNN	T1,-1		;[4175] CHECK
	 JRST	ROTOK1		;[4175] LOCAL ADDR IS ALWAYS AN OK ARG
	HLLZ	T3,T1		;[4175] GET THE SECTION NUMBER
	XMOVEI	T4,.		;[4175] GET FOROTS' SECTION NUMBER
	HLLZ	T4,T4		;[4175] 
	CAME	T3,T4		;[4175] THE SAME?
	 JRST	ERR3		;[4175] NO. JUNK CALL
	MOVEI	T1,(T1)		;[4175] YES. JUST GET LOCAL ADDRESS
ROTOK1:	PUSHJ	P,%FREBLK	;FREE BLOCK
	JRST	OKRET		;OK





;FUNCTION 10:  GET PROGRAM INITIAL RUNTIME
;
;RETURNS ARG1 = JOB (FORK) RUNTIME WHEN PROGRAM STARTED, IN MILLISECONDS
;	 STATUS 0, ALWAYS


F.RNT:	MOVE	T1,I.RUNTM	;GET RUNTIME
	MOVEM	T1,@ARG1(L)	;RETURN IT TO USER
	JRST	OKRET		;RETURN





;FUNCTION 11:  GET RUN FILESPEC (TOPS-10 ONLY)
;
;RETURNS ARG1 = DEVICE, SIXBIT
;	 ARG2 = FILENAME, SIXBIT
;	 ARG3 = PPN
;	 STATUS 0, ALWAYS


IF20,<
F.IFS==F.ILL			;NO RUNTIME FILESPEC AVAILABLE ON 20
>

IF10,<
F.IFS:	MOVE	T1,I.DEV	;GET DEVICE
	MOVEM	T1,@ARG1(L)
	MOVE	T1,I.FILE	;AND FILENAME
	MOVEM	T1,@ARG2(L)
	MOVE	T1,I.PPN	;AND PPN
	MOVEM	T1,@ARG3(L)
	JRST	OKRET		;OK, RET
>





;FUNCTION 12:  CUT BACK CORE TO MINIMUM
;
;[2052] Returns status 0 always, with low seg and OTS core shrunk if possible


F.CBC:	PUSHJ	P,LSTRIM	;TRIM LS SIZE, IF POSSIBLE
	PUSHJ	P,PGTRIM	;[2052] Trim OTS core size if possible
	JRST	OKRET		;RETURN OK ALWAYS





;FUNCTIONS 13-14:  READ AND WRITE RETAIN STATUS (RESERVED FOR DBMS)
;
;RETURNS ARG1 = 0
;	 STATUS 0, ALWAYS


F.RRS:
F.WRS:	SETZM	@ARG1(L)	;SET ARG TO ZERO
	JRST	OKRET		;OK RETURN





;FUNCTION 15:  GET PAGES
;
;ARG2:	SIZE TO BE ALLOCATED, WORDS
;
;RETURNS ARG1 = ADDRESS OF ALLOCATED MEMORY, ON PAGE BOUNDARY
;	 STATUS 0 IF ALLOCATED OK
;		1 IF NOT ENOUGH MEMORY
;		3 IF ARGUMENT ERROR

F.GPG:	SKIPG	T1,@ARG2(L)	;GET SIZE
	  JRST	ERR3		;BAD ARG
	ADDI	T1,777		;ROUND UP TO NUMBER OF PAGES
	LSH	T1,-9		;CONVERT WORDS TO PAGES
	TDNE	T1,[777777777000] ;CHECK
	  JRST	ERR3		;BAD ARG
	PUSHJ	P,%GTPGS	;ALLOCATE SOME PAGES
	  JRST	ERR1		;NOT ENOUGH MEMORY
	LSH	T1,9		;CONVERT PAGE NUMBER TO WORD ADDRESS
	MOVEM	T1,@ARG1(L)	;GIVE TO CALLER
	JRST	OKRET		;OK





;FUNCTION 16:  RETURN PAGES
;
;ARG1:	ADDRESS (WORD)
;ARG2:	SIZE (WORDS)
;
;RETURNS STATUS 0 IF DEALLOCATED OK
;		1 IF WASN'T ALLOCATED
;		3 IF ARGUMENT ERROR

F.RPG:	MOVE	T1,@ARG1(L)	;GET ADDRESS
	SKIPG	T2,@ARG2(L)	;AND SIZE
	  JRST	ERR3		;BAD SIZE, ERROR
	ADDI	T2,777		;ROUND SIZE UP TO MULTIPLE OF 1 PAGE
	LSH	T1,-9		;CONVERT ADDRESS TO PAGE
	LSH	T2,-9		;CONVERT SIZE
	TDNN	T1,[777777777000] ;RANGE CHECK
	TDNE	T2,[777777777000]
	  JRST	ERR3		;BAD
	PUSHJ	P,%FREPGS	;FREE THE PAGES
	JRST	OKRET		;OK



;FUNCTION 17:  GET TOPS-20 PSI CHANNEL
;
;ARG1:	CHANNEL NUMBER, OR -1 TO ALLOCATE ANY USER-ASSIGNABLE CHANNEL
;ARG2:	LEVEL NUMBER
;ARG3:	ADDRESS OF INTERRUPT ROUTINE
;
;RETURNS ARG1 = CHANNEL NUMBER ALLOCATED (IF -1 WAS SENT)
;	 STATUS 0 IF OK
;		1 IF CHANNEL WAS ALREADY ASSIGNED
;	 	2 IF NO FREE CHANNELS
;		3 IF ARGUMENT ERROR
;
;THIS ENTRY POINT PROVIDES ONLY CONTROLLED ACCESS TO THE PSI TABLES.
;IT WILL ARRANGE THAT THE TABLES EXIST AND THAT SIR AND EIR HAVE BEEN DONE
;BUT DOES NOT DO AIC OR ANY OTHER JSYS NECESSARY TO SET UP THE CHANNEL (ATI
;OR MTOPR, FOR EXAMPLE). IF FOROTS WAS THE PREVIOUS OWNER OF
;THE CHANNEL (BY EVIDENCE OF THE %FCHTB ENTRY BEING IDENTICAL
;TO THE %CHNTAB ENTRY), IT IS NOT CONSIDERED AN ERROR CONDITION.

F.GPSI:	SKIPL	T1,@ARG1(L)	;GET CHANNEL NUMBER
	  JRST	GPSI1
	PUSHJ	P,GETPSI	;ALLOCATE A USER-ASSIGNABLE PSI CHANNEL
	  JRST	ERR2		;CAN'T
GPSI1:	CAIL	T1,^D36		;IN RANGE?
	  JRST	ERR3		;NO, BAD ARG
	SKIPN	T2,%CHNTAB(T1)	;[3211] CHANNEL IN USE?
	 JRST	GPNIU		;NO. OK
	CAME	T2,%FCHTB(T1)	;WAS FOROTS USING IT?
	 JRST	ERR1		;NO. GENUINE ERROR
GPNIU:	SKIPLE	T2,@ARG2(L)	;GET PSI LEVEL
	CAILE	T2,3		;RANGE CHECK
	  JRST	ERR3		;BAD
	MOVE	T3,@ARG3(L)	;GET ADDRESS
	MOVEI	T4,-1		;ASSUME ADDRESS MUST FIT IN 18 BITS
	SKIPE	I.XSIR		;XSIR FORMAT TABLES?
	  MOVEI	T4,770000	;YES, ADDRESS MUST FIT IN 30 BITS
	TLNE	T3,(T4)		;DOES ADDRESS FIT?
	  JRST	ERR3		;DOESN'T, BAD ARGUMENT

	MOVEM	T1,@ARG1(L)	;RETURN CHANNEL TO USER
	MOVEM	T3,%CHNTAB(T1)	;STORE LEVEL AND ADDRESS IN TABLE
	SKIPN	I.XSIR		;SIR FORMAT?
	  HRLM	T2,%CHNTAB(T1)	;YES
	SKIPE	I.XSIR		;XSIR FORMAT?
	  DPB	T2,[POINT 6,%CHNTAB(T1),5] ;YES

	JRST	OKRET		;OK



;FUNCTION 20:  RETURN TOPS-20 PSI CHANNEL
;
;ARG1:	CHANNEL NUMBER
;
;RETURNS STATUS 0 IF OK
;		1 IF CHANNEL WASN'T IN USE
;		3 IF ARGUMENT ERROR
;
;THIS ENTRY POINT PROVIDES ONLY CONTROLLED ACCESS TO THE PSI TABLES.
;IT DOES NOT DO DIC OR ANY OTHER JSYS NECESSARY TO RELEASE A CHANNEL,
;IT JUST CLEARS THE LEVEL AND INTERRUPT ADDRESS FIELDS IN CHNTAB.

F.RPSI:	SKIPL	T1,@ARG1(L)	;GET ARG
	CAIL	T1,^D36		;RANGE CHECK
	  JRST	ERR3		;BAD
	SKIPN	%CHNTAB(T1)	;CHANNEL IN USE?
	  JRST	ERR1		;NO
	SETZM	%CHNTAB(T1)	;MARK CHANNEL FREE
	JRST	OKRET		;OK


;ROUTINE TO FIND A FREE PSI CHANNEL
;RETURNS T1 = CHANNEL NUMBER, IN 0:5 OR 23:35, THE USER-ASSIGNABLE CHANNELS

GETPSI:	MOVSI	T1,-6		;TRY 0-5 FIRST
	PUSHJ	P,GPSIX
	  JRST	%POPJ1		;WON, RETURN
	MOVE	T1,[-^D13,,^D23] ;NOW 23-35
	PUSHJ	P,GPSIX
	  JRST	%POPJ1		;SUCCEED
	POPJ	P,		;FAIL

GPSIX:	SKIPE	%CHNTAB(T1)	;TRY ONE
	  AOBJN	T1,.-1
	JUMPGE	T1,%POPJ1	;IF WE RAN OUT, FAILURE RETURN
	MOVEI	T1,(T1)		;CLEAR COUNT OUT OF LH
	POPJ	P,		;SUCCESS RETURN


;FUNCTION 21: MARK PAGES USED IN BITMAP
;
;ARG1: 1ST PAGE NUMBER, IN RANGE [0:777]
;ARG2: NUMBER OF PAGES, IN RANGE [1:777]
;(ALSO, ARG1+ARG2 MUST BE IN RANGE[1:1000])
;
;RETURNS STATUS 0 IF OK
;		1 IF ONE OR MORE PAGES ALREADY MARKED ALLOCATED
;		3 IF ARGUMENT ERROR
;
F.MPG:	PUSHJ	P,CHKPGA	;CHECK PAGE ARGS
	 JRST	ERR3		;[3211] Invalid args, punt
	PUSHJ	P,%MRKPG	;MARK THE PAGES USED
	 JRST	ERR1		;AT LEAST ONE PAGE ALREADY IN USE
	JRST	OKRET		;MARKED

;FUNCTION 22: MARK PAGES FREE IN BITMAP
;
;ARG1: 1ST PAGE NUMBER, IN RANGE [0:777]
;ARG2: NUMBER OF PAGES, IN RANGE [1:777]
;(ALSO, ARG1+ARG2 MUST BE IN RANGE[1:1000])
;
;RETURNS STATUS 0 IF OK
;		1 IF ONE OR MORE PAGES ALREADY MARKED FREE
;		3 IF ARGUMENT ERROR
;

F.UPG:	PUSHJ	P,CHKPGA	;CHECK PAGE ARGUMENTS
	 JRST	ERR3		;[3211] Invalid args, punt
	PUSHJ	P,%UMKPG	;MARK PAGES FREE
	 JRST	ERR1		;AT LEAST ONE WAS ALREADY FREE
	JRST	OKRET		;ALL MARKED FREE


CHKPGA:	SKIPL	T1,@ARG1(L)	;[3211] GET PAGE #
	 CAILE	T1,777		;[3211] MUST BE A LOCAL PAGE ADDR
	  POPJ	P,		;[3211] BAD CALL
	SKIPG	T2,@ARG2(L)	;[3224] GET # PAGES
	 POPJ	P,		;[3211] BAD CALL
	MOVE	T3,T1		;CHECK TOTAL
	ADD	T3,T2		;[3211] COMPUTE TOP+1
	CAILE	T3,1000		;[3211] TOP PAGE+1 MUST BE IN RANGE [1:1000]
	 POPJ	P,		;[3211] BAD CALL
	JRST	%POPJ1		;[3211] All OK, give skip return

;FUNCTION 23 - RETURN USED CORE INFO - NOT IMPLEMENTED
;RETURNS STATUS 3 FOR NOW
F.USD:	JRST	ERR3

;FUNCTION 24 - RETURN MEMORY BITMAP - NOT IMPLEMENTED
;RETURNS STATUS 3 FOR NOW
F.MAP:	JRST	ERR3
;EXIT ROUTINES


OKRET:	SETZM	@STATUS(L)	;NORMAL RETURN
	POPJ	P,

ERR1:	MOVEI	T1,1		;ERROR RETURN 1
	MOVEM	T1,@STATUS(L)
	POPJ	P,

ERR2:	MOVEI	T1,2		;ERROR RETURN 2
	MOVEM	T1,@STATUS(L)
	POPJ	P,

ERR3:	MOVEI	T1,3		;ERROR RETURN 3
	MOVEM	T1,@STATUS(L)
	POPJ	P,


	SEGMENT	DATA

DTEMP:	BLOCK	2		;TEMP DOUBLEWORD

	SEGMENT	CODE

	END