PR#3
PREFIX /A2OSX.BUILD
LOMEM $A00
INC 1
AUTO 6
*--------------------------------------
* !!!!!! DO NOT USE ZPPtrs !!!!!
*--------------------------------------
ZPMemMgrSPtr 	.EQ ZPMEMMGR			Pointer To Slot selected
ZPMemMgrTmp1	.EQ ZPMEMMGR+2
MemMgr.ReqSize 	.EQ ZPMEMMGR+4			store requested Size
MemMgr.ReqFlags	.EQ ZPMEMMGR+6			store requested Flags
*--------------------------------------
* TODO :
*  - Create a 256 bytes table
*    mapping hMem's to real memory blocks to help 
*    Garbage collector move blocks
*  - mem.ID=0 always used! useful to test if hMem=0
*--------------------------------------
*               PUBLIC
*/--------------------------------------
* # GetMem
* ## In: 
*  PUSHW = Size Requested
*  PUSHB = Options
*   S.MEM.F.INIT0 : init memory with 00
*   S.MEM.F.ALIGN : page aligned
* ## Out:
*  CC : success
*   YA = PTR to Mem
*	X = hMem
*  CS :
*   A = EC
*\--------------------------------------
K.GetMem		>PULLB MemMgr.ReqFlags	store requested flags

				clc
				>PULLA					get requested size LO
				bit #$0F				16 bytes aligned ?
				beq .1					yes, request it	
				
				and #$F0				align on 16 bytes
				adc #$10
				
.1				sta MemMgr.ReqSize		
				
				>PULLA					get requested size HI
				adc #0
				sta MemMgr.ReqSize+1
				
				bit MemMgr.ReqFlags		S.MEM.F.AUX ?
				bpl K.GetMem.I
				
				and #S.MEM.F.AUX
				beq .1

				sta SETREADAUX			Aux Mem requested,switch to AUX
				sta SETWRITEAUX				
				
				jsr K.GetMem.I
				
				sta CLRREADAUX
				sta CLRWRITEAUX
				
.9				rts				
*/--------------------------------------
* # GetMem0.YA
* ## In: 
*  Y,A = Size Requested
* ## Out:
*  CC : success
*   YA = PTR to Mem (ZERO Initialised)
*	X = hMem
*  CS :
*   A = EC
*\--------------------------------------
K.GetMem0.YA		ldx #S.MEM.F.INIT0
				stx MemMgr.ReqFlags
				.HS 2C					bit abs			
*/--------------------------------------
* # GetMem.YA
* ## In: 
*  Y,A = Size Requested
* ## Out:
*  CC : success
*   YA = PTR to Mem (Uninitialised)
*	X = hMem
*  CS :
*   A = EC
*\--------------------------------------
K.GetMem.YA		stz MemMgr.ReqFlags
				sta MemMgr.ReqSize+1
				tya
				bit #$0F				16 bytes aligned ?
				beq .1					yes, request it	
				
				and #$F0				align on 16 bytes
				clc
				adc #$10
				bcc .1
				inc MemMgr.ReqSize+1
				
.1				sta MemMgr.ReqSize
				
K.GetMem.I		>LDYAI MemMgr.Table
				>STYA ZPMemMgrSPtr
				
				ldx #0					Current slot=0

				bra .4					skip slot 0, Check if some free slot to reuse first
				
.1				inx						move to next slot
				jsr MemMgr.NextSlot
				lda (ZPMemMgrSPtr)		Get Flags
				bmi .4					in use ?
				
.2				lda MemMgr.ReqFlags		Found an empty slot
				and #S.MEM.F.ALIGN		is request needs a page align ?
				beq .3
				
				ldy #S.MEM.PTR
				lda (ZPMemMgrSPtr),y	get LO of PTR
				bne .4					not page-aligned
				
.3				ldy #S.MEM.LEN
				lda (ZPMemMgrSPtr),y	get LEN of this block
				cmp MemMgr.ReqSize		compare with requested size
				bne .4
				
				iny
				lda (ZPMemMgrSPtr),y
				cmp MemMgr.ReqSize+1
				beq .7					requested size matches slot size !!!
				
.4				cpx MemMgr.LastSlot		any other slot to check?
				bne .1					last one, create a new slot
				
*-------------- Create a New SLOT
				lda MemMgr.ReqFlags
				and #S.MEM.F.ALIGN		is request needs a page align ?
				beq .6
				
				lda MemMgr.Free			target PTR will be page aligned ?
				sec
				sbc MemMgr.ReqSize
				beq .6					yes, allocate
				
				tay						no, reserve a free slot to fill gap
				lda #0
				jsr MemMgr.AddSlot		X = new slot
				bcs .9
				
.6				>LDYA MemMgr.ReqSize
				jsr MemMgr.AddSlot		X = new slot
				bcs .9
				
*-------------- Reuse this SLOT
.7				lda MemMgr.ReqFlags		get requested flags
				ora #S.MEM.F.INUSE		mark as in use
				sta (ZPMemMgrSPtr)
				
				and #S.MEM.F.INIT0
				beq .8

				jsr MemMgr.Init0		X not modified
				
.8				lda #0
				ldy #S.MEM.BIN
				sta (ZPMemMgrSPtr),y
				
				inc						Mark this slot used by one process
				ldy #S.MEM.REFCNT
				sta (ZPMemMgrSPtr),y
				
				ldy #S.PS.PID
				lda (pPs),y
				ldy #S.MEM.OWNERPID
				sta (ZPMemMgrSPtr),y
				
				ldy #S.MEM.PTR
				lda (ZPMemMgrSPtr),y
				pha
				iny
				lda (ZPMemMgrSPtr),y	A = HI PTR
				ply						Y = LO PTR	
				clc						X = Current hMem
				
.9				rts						
*--------------------------------------
* MemMgr.AddSlot
*  In:
*   Y,A = Requested size
*  Out: 
*--------------------------------------
MemMgr.AddSlot  >STYA ZPMemMgrTmp1		save req size
				ldx MemMgr.LastSlot		
				inx
				beq .99					> 255 ERR:OUT OF SLOT
				
				lda MemMgr.Free			Compute base PTR=FREE-REQ size
				sec
				sbc ZPMemMgrTmp1
				tay						save new MemMgr.Free LO
				lda MemMgr.Free+1
				sbc ZPMemMgrTmp1+1
				pha						save new MemMgr.Free HI				

				cpy MemMgr.LoMem
				sbc MemMgr.LoMem+1
				bcc .98					ERR out of mem

				jsr MemMgr.NextSlot		X,Y unmodified
				
				tya						get back MemMgr.Free LO
				
				ldy #S.MEM.PTR
				sta MemMgr.Free			set as system MemMgr.Free value
				sta (ZPMemMgrSPtr),y	store is as base address of new slot
				iny
				pla						get back MemMgr.Free HI
				sta MemMgr.Free+1
				sta (ZPMemMgrSPtr),y

				iny
				lda ZPMemMgrTmp1		get requested size
				sta (ZPMemMgrSPtr),y	setup slot LEN
				iny	
				lda ZPMemMgrTmp1+1
				sta (ZPMemMgrSPtr),y

				stx MemMgr.LastSlot		mark this slot allocated
				clc
				rts
				
.98				pla						discard new MemMgr.Free HI
				lda #MemMgr.ERROOM
				sec
				rts
				
.99				lda #MemMgr.ERROOH
				sec
				rts	
*--------------------------------------
MemMgr.NextSlot	lda ZPMemMgrSPtr
				clc
				adc #S.MEM
				sta ZPMemMgrSPtr
				bcc .8
				inc ZPMemMgrSPtr+1
.8				rts								
*--------------------------------------
MemMgr.Init0	ldy #S.MEM.PTR
				lda (ZPMemMgrSPtr),y	ZPMemMgrSPtr already set
				sta .2+1
				iny
				lda (ZPMemMgrSPtr),y
				sta .2+2
				
				ldy #S.MEM.LEN			
				lda (ZPMemMgrSPtr),y
				eor #$ff
				pha
				
				iny
				lda (ZPMemMgrSPtr),y
				eor #$ff				a=not hi count			

				ply						y=not lo count
				
				phx
				ldx #0
				
.1				iny
				bne .2
				inc
				beq .8
				
.2				stz $ffff,x
				inx
				bne .1
				inc .2+2
				bne .1
				
.8				plx
				rts
*/--------------------------------------
* # FreeMem.A
* ## In:
*  A = hMem To Free
* ## Out:
*  none.
*  (X,Y unmodified)
*\--------------------------------------
K.FreeMem.A	    phy
				tay
				
				beq *					Slot=0, reserved by Kernel
				
				jsr K.GetMemByID.A		X unmodified
				lda (ZPMemMgrSPtr)
				bpl .9					In use ?
				
				ldy #S.MEM.REFCNT
				lda (ZPMemMgrSPtr),y	Get count of those referencing this hMem
				dec						only one left ?	
				sta (ZPMemMgrSPtr),y
				bne .8					no, must be a code segment loaded several times
				
				lda #0					mark this slot as free
				sta (ZPMemMgrSPtr)

				ldy #S.MEM.BIN
				lda (ZPMemMgrSPtr),y	Any BINPATH to discard ?		
				beq .1
				
				jsr K.GetMemByID.A		X unmodified
				lda (ZPMemMgrSPtr)
				bpl *					***MUST BE ALLOCATED***
				
				lda #0					mark BINPATH slot as free
				sta (ZPMemMgrSPtr)
				
.1				lda MemMgr.LastSlot
				beq .8
				
				jsr K.GetMemByID.A		X unmodified
				lda (ZPMemMgrSPtr)
				bmi .8
				
				ldy #S.MEM.LEN
				lda (ZPMemMgrSPtr),y	give back LEN bytes
				clc
				adc MemMgr.Free			to MemMgr.Free
				sta MemMgr.Free
				iny
				lda (ZPMemMgrSPtr),y
				adc MemMgr.Free+1
				sta MemMgr.Free+1
				
				dec	MemMgr.LastSlot		discard last slot	
				bne .1					no slot left, exit

.8				ply
				clc
				rts
*--------------------------------------				
.9				ply						discard	saved Y

				lda $D000
				sta .91+1
				bit RRAMWRAMBNK2
				bit RRAMWRAMBNK2		
				
				>LDYAI TskMgr.Table		Delect PS0 for proper In/out devices
				>STYA pPs
				
				jsr DevMgr.SYS.Control
				
				pla						Get PC and sub 2 for calling address
				sec
				sbc #2
				tay
				pla
				sbc #0

				>PUSHYA
				
				>LDYAI K.FreeMem.A.ERR
				jsr K.PrintF.YA
				
.91				ldx #$ff				
				bit $C000,x
				bit $C000,x
				bra *
*--------------------------------------
K.FreeMem.A.ERR	>CSTR "***MemMgr:Attempt to Free an already freed hMem at $%H"
*/--------------------------------------
* # GetMemPtr.A
* ## In:
*  A = hMem
* ## Out:
*  Y,A = PTR to MemBlock
*  (X unmodified)
*\--------------------------------------
K.GetMemPtr.A	jsr K.GetMemByID.A
				ldy #S.MEM.PTR
				lda (ZPMemMgrSPtr),y
				pha
				iny
				lda (ZPMemMgrSPtr),y
				ply
				rts
*/--------------------------------------
* # GetMemByID.A
* ## In:
*  A = hMem
* ## Out:
*  Y,A = ZPMemMgrSPtr = PTR to S.MEM
*  X unmodified
*\--------------------------------------
* Optimized for :
* MemMgr.Table is page aligned at $1800
* S.MEM is 8 bytes
*--------------------------------------
				.DO MemMgr.Table=$1800
				.ELSE
				!!!!!WARNING!!!!!
				.FIN
				.DO S.MEM=8
				.ELSE
				!!!!!WARNING!!!!!
				.FIN
*--------------------------------------
K.GetMemByID.A	sta ZPMemMgrSPtr
				lda /MemMgr.Table/8
				asl ZPMemMgrSPtr
				rol
				asl ZPMemMgrSPtr
				rol
				asl ZPMemMgrSPtr
				rol
				sta ZPMemMgrSPtr+1
				ldy ZPMemMgrSPtr
				rts
*--------------------------------------
* OLD CODE
*--------------------------------------
*				stz ZPMemMgrSPtr+1
*				asl
*				rol ZPMemMgrSPtr+1
*				asl
*				rol ZPMemMgrSPtr+1
*				asl
*				rol ZPMemMgrSPtr+1
**				clc						IMPLICIT
*				adc #MemMgr.Table
*				tay
*				lda ZPMemMgrSPtr+1
*				adc /MemMgr.Table				
*				sty ZPMemMgrSPtr
*				sta ZPMemMgrSPtr+1
*				rts
*/--------------------------------------
* # NewStr.YA
* Create a new copy of this C-String
* ## In:
*  Y,A = Ptr to source C-String
* ## Out:
*  CC : success 
*   Y,A = PTR to String
*   X = hMem (PSTR)
*  CS : error
*   A = SYS error code
*\--------------------------------------
K.NewStr.YA		>STYA .1+1
				>STYA .4+1
				
				ldy #0
				stz MemMgr.ReqFlags
				stz MemMgr.ReqSize+1
				
.1				lda $ffff,y
				beq .2
				iny
				bne .1
				inc MemMgr.ReqSize+1
				inc .1+2
				bne .1
				
.2				iny
				bne .3
				inc MemMgr.ReqSize+1
				
.3				sty	MemMgr.ReqSize
							
				jsr K.GetMem.I
				bcs .9
				>STYA .5+1
				
				phy
				pha
				
				ldy #0
				
.4				lda $ffff,y			
.5				sta $ffff,y
				beq .8
				iny
				bne .4
				
				inc .4+2
				inc .5+2
				bne .4
				
.8				pla
				ply
				clc
.9				rts				
*--------------------------------------
K.LoadStkObj.YA
*--------------------------------------
K.GetStkObj.A
*--------------------------------------
K.FreeStkObj.A
*--------------------------------------
K.SetLoMem
				clc
				rts
*/--------------------------------------
* # GetMemStat.YA
* ## In:
*  Y,A = Ptr to 24 bytes buffer
* ## Out:
*  Buffer filled with memory stats
*\--------------------------------------
K.GetMemStat.YA	>STYA ZPMemMgrTmp1
				
				ldy #6
				
.1				lda MemMgr.Table,y
				sta (ZPMemMgrTmp1),y
				dey
				bpl .1
				
				
				ldx #6
				ldy #14
				
				sta SETREADAUX
				
.2				lda MemMgr.Table,x
				sta (ZPMemMgrTmp1),y
				dey
				dex
				bpl .2
				
				sta CLRREADAUX
				
				ldx #6
				ldy #22

.3				lda DevMgr.Stat,x
				sta (ZPMemMgrTmp1),y
				dey
				dex
				bpl .3
				
				rts
*--------------------------------------
* In:
*	Y,A = BINPATH (C-String)
* Out:
*	Y,A = ZPMemMgrSPtr = PTR to S.MEM
*   X = hMem
*--------------------------------------
MEM.GetMemByNameYA
				ldx MemMgr.LastSlot
				beq .9

				>STYA .2+1
				>LDYAI MemMgr.Table
				>STYA ZPMemMgrTmp1		

				ldx #0
				
.1				lda (ZPMemMgrTmp1)
				bpl .6					In Use?
				
				ldy #S.MEM.BIN			any BIN PATH in this slot?	
				lda (ZPMemMgrTmp1),y
				beq .6
				
				jsr K.GetMemPtr.A		get pathname
				>STYA .3+1

				ldy #0
				
.2				lda $ffff,y
.3				cmp $ffff,y
				bne .6
				iny
				ora #0
				bne .2
				
				>LDYA ZPMemMgrTmp1
				
				clc
				rts
				
.6				lda ZPMemMgrTmp1
				clc
				adc #S.MEM
				sta ZPMemMgrTmp1
				bcc .7
				inc ZPMemMgrTmp1+1
				
.7				inx
				cpx MemMgr.LastSlot
				bne .1
				
.9				sec
				rts
*--------------------------------------
MEM.GarbageCollector
				clc
				rts
*--------------------------------------
MAN
SAVE /A2OSX.SRC/SYS/KERNEL.S.MEM
LOAD /A2OSX.SRC/SYS/KERNEL.S
ASM