mirror of
https://github.com/vishapoberon/compiler.git
synced 2026-04-06 05:12:26 +00:00
Replace FetchAddress with (original) SYSTEM.GET.
This commit is contained in:
David Brown
parent
7efd5a0158
commit
a36e04ebd7
7 changed files with 151 additions and 207 deletions
|
|
@ -82,7 +82,6 @@ export LONGINT *Heap__1__typ;
|
|||
static void Heap_CheckFin (void);
|
||||
static void Heap_ExtendHeap (address blksz);
|
||||
export void Heap_FINALL (void);
|
||||
static address Heap_FetchAddress (address pointer);
|
||||
static void Heap_Finalize (void);
|
||||
export void Heap_GC (BOOLEAN markStack);
|
||||
static void Heap_HeapSort (address n, address *a, LONGINT a__len);
|
||||
|
|
@ -188,15 +187,6 @@ static address Heap_NewChunk (address blksz)
|
|||
return _o_result;
|
||||
}
|
||||
|
||||
static address Heap_FetchAddress (address pointer)
|
||||
{
|
||||
address _o_result;
|
||||
address r;
|
||||
__GET(pointer, r, address);
|
||||
_o_result = r;
|
||||
return _o_result;
|
||||
}
|
||||
|
||||
static void Heap_ExtendHeap (address blksz)
|
||||
{
|
||||
address size, chnk, j, next;
|
||||
|
|
@ -212,16 +202,16 @@ static void Heap_ExtendHeap (address blksz)
|
|||
Heap_heap = chnk;
|
||||
} else {
|
||||
j = Heap_heap;
|
||||
next = Heap_FetchAddress(j);
|
||||
__GET(j, next, address);
|
||||
while ((next != 0 && chnk > next)) {
|
||||
j = next;
|
||||
next = Heap_FetchAddress(j);
|
||||
__GET(j, next, address);
|
||||
}
|
||||
__PUT(chnk, next, address);
|
||||
__PUT(j, chnk, address);
|
||||
}
|
||||
if (next == 0) {
|
||||
Heap_heapend = Heap_FetchAddress(chnk + 4);
|
||||
__GET(chnk + 4, Heap_heapend, address);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -232,7 +222,7 @@ SYSTEM_PTR Heap_NEWREC (address tag)
|
|||
address i, i0, di, blksz, restsize, t, adr, end, next, prev;
|
||||
SYSTEM_PTR new;
|
||||
Heap_Lock();
|
||||
blksz = Heap_FetchAddress(tag);
|
||||
__GET(tag, blksz, address);
|
||||
i0 = __ASHR(blksz, 4);
|
||||
i = i0;
|
||||
if (i < 9) {
|
||||
|
|
@ -243,7 +233,7 @@ SYSTEM_PTR Heap_NEWREC (address tag)
|
|||
}
|
||||
}
|
||||
if (i < 9) {
|
||||
next = Heap_FetchAddress(adr + 12);
|
||||
__GET(adr + 12, next, address);
|
||||
Heap_freeList[i] = next;
|
||||
if (i != i0) {
|
||||
di = i - i0;
|
||||
|
|
@ -284,12 +274,12 @@ SYSTEM_PTR Heap_NEWREC (address tag)
|
|||
return _o_result;
|
||||
}
|
||||
}
|
||||
t = Heap_FetchAddress(adr + 4);
|
||||
__GET(adr + 4, t, address);
|
||||
if (t >= blksz) {
|
||||
break;
|
||||
}
|
||||
prev = adr;
|
||||
adr = Heap_FetchAddress(adr + 12);
|
||||
__GET(adr + 12, adr, address);
|
||||
}
|
||||
restsize = t - blksz;
|
||||
end = adr + restsize;
|
||||
|
|
@ -299,7 +289,7 @@ SYSTEM_PTR Heap_NEWREC (address tag)
|
|||
if (restsize > 144) {
|
||||
__PUT(adr + 4, restsize, address);
|
||||
} else {
|
||||
next = Heap_FetchAddress(adr + 12);
|
||||
__GET(adr + 12, next, address);
|
||||
if (prev == 0) {
|
||||
Heap_bigBlocks = next;
|
||||
} else {
|
||||
|
|
@ -355,7 +345,7 @@ static void Heap_Mark (address q)
|
|||
{
|
||||
address p, tag, offset, fld, n, tagbits;
|
||||
if (q != 0) {
|
||||
tagbits = Heap_FetchAddress(q - 4);
|
||||
__GET(q - 4, tagbits, address);
|
||||
if (!__ODD(tagbits)) {
|
||||
__PUT(q - 4, tagbits + 1, address);
|
||||
p = 0;
|
||||
|
|
@ -369,17 +359,17 @@ static void Heap_Mark (address q)
|
|||
}
|
||||
n = q;
|
||||
q = p;
|
||||
tag = Heap_FetchAddress(q - 4);
|
||||
__GET(q - 4, tag, address);
|
||||
tag -= 1;
|
||||
__GET(tag, offset, address);
|
||||
fld = q + offset;
|
||||
p = Heap_FetchAddress(fld);
|
||||
__GET(fld, p, address);
|
||||
__PUT(fld, (SYSTEM_PTR)(address)n, SYSTEM_PTR);
|
||||
} else {
|
||||
fld = q + offset;
|
||||
n = Heap_FetchAddress(fld);
|
||||
__GET(fld, n, address);
|
||||
if (n != 0) {
|
||||
tagbits = Heap_FetchAddress(n - 4);
|
||||
__GET(n - 4, tagbits, address);
|
||||
if (!__ODD(tagbits)) {
|
||||
__PUT(n - 4, tagbits + 1, address);
|
||||
__PUT(q - 4, tag + 1, address);
|
||||
|
|
@ -415,9 +405,9 @@ static void Heap_Scan (void)
|
|||
chnk = Heap_heap;
|
||||
while (chnk != 0) {
|
||||
adr = chnk + 12;
|
||||
end = Heap_FetchAddress(chnk + 4);
|
||||
__GET(chnk + 4, end, address);
|
||||
while (adr < end) {
|
||||
tag = Heap_FetchAddress(adr);
|
||||
__GET(adr, tag, address);
|
||||
if (__ODD(tag)) {
|
||||
if (freesize > 0) {
|
||||
start = adr - freesize;
|
||||
|
|
@ -436,11 +426,11 @@ static void Heap_Scan (void)
|
|||
}
|
||||
tag -= 1;
|
||||
__PUT(adr, tag, address);
|
||||
size = Heap_FetchAddress(tag);
|
||||
__GET(tag, size, address);
|
||||
Heap_allocated += size;
|
||||
adr += size;
|
||||
} else {
|
||||
size = Heap_FetchAddress(tag);
|
||||
__GET(tag, size, address);
|
||||
freesize += size;
|
||||
adr += size;
|
||||
}
|
||||
|
|
@ -460,7 +450,7 @@ static void Heap_Scan (void)
|
|||
Heap_bigBlocks = start;
|
||||
}
|
||||
}
|
||||
chnk = Heap_FetchAddress(chnk);
|
||||
__GET(chnk, chnk, address);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -509,17 +499,17 @@ static void Heap_MarkCandidates (address n, address *cand, LONGINT cand__len)
|
|||
lim = cand[n - 1];
|
||||
while ((chnk != 0 && chnk < lim)) {
|
||||
adr = chnk + 12;
|
||||
lim1 = Heap_FetchAddress(chnk + 4);
|
||||
__GET(chnk + 4, lim1, address);
|
||||
if (lim < lim1) {
|
||||
lim1 = lim;
|
||||
}
|
||||
while (adr < lim1) {
|
||||
tag = Heap_FetchAddress(adr);
|
||||
__GET(adr, tag, address);
|
||||
if (__ODD(tag)) {
|
||||
size = Heap_FetchAddress(tag - 1);
|
||||
__GET(tag - 1, size, address);
|
||||
adr += size;
|
||||
} else {
|
||||
size = Heap_FetchAddress(tag);
|
||||
__GET(tag, size, address);
|
||||
ptr = adr + 4;
|
||||
while (cand[i] < ptr) {
|
||||
i += 1;
|
||||
|
|
@ -534,7 +524,7 @@ static void Heap_MarkCandidates (address n, address *cand, LONGINT cand__len)
|
|||
adr = next;
|
||||
}
|
||||
}
|
||||
chnk = Heap_FetchAddress(chnk);
|
||||
__GET(chnk, chnk, address);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -544,7 +534,7 @@ static void Heap_CheckFin (void)
|
|||
address tag;
|
||||
n = Heap_fin;
|
||||
while (n != NIL) {
|
||||
tag = Heap_FetchAddress(n->obj - 4);
|
||||
__GET(n->obj - 4, tag, address);
|
||||
if (!__ODD(tag)) {
|
||||
n->marked = 0;
|
||||
Heap_Mark(n->obj);
|
||||
|
|
@ -723,7 +713,7 @@ void Heap_RegisterFinalizer (SYSTEM_PTR obj, Heap_Finalizer finalize)
|
|||
void Heap_InitHeap (void)
|
||||
{
|
||||
Heap_heap = Heap_NewChunk(128000);
|
||||
Heap_heapend = Heap_FetchAddress(Heap_heap + 4);
|
||||
__GET(Heap_heap + 4, Heap_heapend, address);
|
||||
__PUT(Heap_heap, 0, address);
|
||||
Heap_allocated = 0;
|
||||
Heap_firstTry = 1;
|
||||
|
|
|
|||
|
|
@ -82,7 +82,6 @@ export LONGINT *Heap__1__typ;
|
|||
static void Heap_CheckFin (void);
|
||||
static void Heap_ExtendHeap (address blksz);
|
||||
export void Heap_FINALL (void);
|
||||
static address Heap_FetchAddress (address pointer);
|
||||
static void Heap_Finalize (void);
|
||||
export void Heap_GC (BOOLEAN markStack);
|
||||
static void Heap_HeapSort (address n, address *a, LONGINT a__len);
|
||||
|
|
@ -188,15 +187,6 @@ static address Heap_NewChunk (address blksz)
|
|||
return _o_result;
|
||||
}
|
||||
|
||||
static address Heap_FetchAddress (address pointer)
|
||||
{
|
||||
address _o_result;
|
||||
address r;
|
||||
__GET(pointer, r, address);
|
||||
_o_result = r;
|
||||
return _o_result;
|
||||
}
|
||||
|
||||
static void Heap_ExtendHeap (address blksz)
|
||||
{
|
||||
address size, chnk, j, next;
|
||||
|
|
@ -212,16 +202,16 @@ static void Heap_ExtendHeap (address blksz)
|
|||
Heap_heap = chnk;
|
||||
} else {
|
||||
j = Heap_heap;
|
||||
next = Heap_FetchAddress(j);
|
||||
__GET(j, next, address);
|
||||
while ((next != 0 && chnk > next)) {
|
||||
j = next;
|
||||
next = Heap_FetchAddress(j);
|
||||
__GET(j, next, address);
|
||||
}
|
||||
__PUT(chnk, next, address);
|
||||
__PUT(j, chnk, address);
|
||||
}
|
||||
if (next == 0) {
|
||||
Heap_heapend = Heap_FetchAddress(chnk + 4);
|
||||
__GET(chnk + 4, Heap_heapend, address);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -232,7 +222,7 @@ SYSTEM_PTR Heap_NEWREC (address tag)
|
|||
address i, i0, di, blksz, restsize, t, adr, end, next, prev;
|
||||
SYSTEM_PTR new;
|
||||
Heap_Lock();
|
||||
blksz = Heap_FetchAddress(tag);
|
||||
__GET(tag, blksz, address);
|
||||
i0 = __ASHR(blksz, 4);
|
||||
i = i0;
|
||||
if (i < 9) {
|
||||
|
|
@ -243,7 +233,7 @@ SYSTEM_PTR Heap_NEWREC (address tag)
|
|||
}
|
||||
}
|
||||
if (i < 9) {
|
||||
next = Heap_FetchAddress(adr + 12);
|
||||
__GET(adr + 12, next, address);
|
||||
Heap_freeList[i] = next;
|
||||
if (i != i0) {
|
||||
di = i - i0;
|
||||
|
|
@ -284,12 +274,12 @@ SYSTEM_PTR Heap_NEWREC (address tag)
|
|||
return _o_result;
|
||||
}
|
||||
}
|
||||
t = Heap_FetchAddress(adr + 4);
|
||||
__GET(adr + 4, t, address);
|
||||
if (t >= blksz) {
|
||||
break;
|
||||
}
|
||||
prev = adr;
|
||||
adr = Heap_FetchAddress(adr + 12);
|
||||
__GET(adr + 12, adr, address);
|
||||
}
|
||||
restsize = t - blksz;
|
||||
end = adr + restsize;
|
||||
|
|
@ -299,7 +289,7 @@ SYSTEM_PTR Heap_NEWREC (address tag)
|
|||
if (restsize > 144) {
|
||||
__PUT(adr + 4, restsize, address);
|
||||
} else {
|
||||
next = Heap_FetchAddress(adr + 12);
|
||||
__GET(adr + 12, next, address);
|
||||
if (prev == 0) {
|
||||
Heap_bigBlocks = next;
|
||||
} else {
|
||||
|
|
@ -355,7 +345,7 @@ static void Heap_Mark (address q)
|
|||
{
|
||||
address p, tag, offset, fld, n, tagbits;
|
||||
if (q != 0) {
|
||||
tagbits = Heap_FetchAddress(q - 4);
|
||||
__GET(q - 4, tagbits, address);
|
||||
if (!__ODD(tagbits)) {
|
||||
__PUT(q - 4, tagbits + 1, address);
|
||||
p = 0;
|
||||
|
|
@ -369,17 +359,17 @@ static void Heap_Mark (address q)
|
|||
}
|
||||
n = q;
|
||||
q = p;
|
||||
tag = Heap_FetchAddress(q - 4);
|
||||
__GET(q - 4, tag, address);
|
||||
tag -= 1;
|
||||
__GET(tag, offset, address);
|
||||
fld = q + offset;
|
||||
p = Heap_FetchAddress(fld);
|
||||
__GET(fld, p, address);
|
||||
__PUT(fld, (SYSTEM_PTR)(address)n, SYSTEM_PTR);
|
||||
} else {
|
||||
fld = q + offset;
|
||||
n = Heap_FetchAddress(fld);
|
||||
__GET(fld, n, address);
|
||||
if (n != 0) {
|
||||
tagbits = Heap_FetchAddress(n - 4);
|
||||
__GET(n - 4, tagbits, address);
|
||||
if (!__ODD(tagbits)) {
|
||||
__PUT(n - 4, tagbits + 1, address);
|
||||
__PUT(q - 4, tag + 1, address);
|
||||
|
|
@ -415,9 +405,9 @@ static void Heap_Scan (void)
|
|||
chnk = Heap_heap;
|
||||
while (chnk != 0) {
|
||||
adr = chnk + 12;
|
||||
end = Heap_FetchAddress(chnk + 4);
|
||||
__GET(chnk + 4, end, address);
|
||||
while (adr < end) {
|
||||
tag = Heap_FetchAddress(adr);
|
||||
__GET(adr, tag, address);
|
||||
if (__ODD(tag)) {
|
||||
if (freesize > 0) {
|
||||
start = adr - freesize;
|
||||
|
|
@ -436,11 +426,11 @@ static void Heap_Scan (void)
|
|||
}
|
||||
tag -= 1;
|
||||
__PUT(adr, tag, address);
|
||||
size = Heap_FetchAddress(tag);
|
||||
__GET(tag, size, address);
|
||||
Heap_allocated += size;
|
||||
adr += size;
|
||||
} else {
|
||||
size = Heap_FetchAddress(tag);
|
||||
__GET(tag, size, address);
|
||||
freesize += size;
|
||||
adr += size;
|
||||
}
|
||||
|
|
@ -460,7 +450,7 @@ static void Heap_Scan (void)
|
|||
Heap_bigBlocks = start;
|
||||
}
|
||||
}
|
||||
chnk = Heap_FetchAddress(chnk);
|
||||
__GET(chnk, chnk, address);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -509,17 +499,17 @@ static void Heap_MarkCandidates (address n, address *cand, LONGINT cand__len)
|
|||
lim = cand[n - 1];
|
||||
while ((chnk != 0 && chnk < lim)) {
|
||||
adr = chnk + 12;
|
||||
lim1 = Heap_FetchAddress(chnk + 4);
|
||||
__GET(chnk + 4, lim1, address);
|
||||
if (lim < lim1) {
|
||||
lim1 = lim;
|
||||
}
|
||||
while (adr < lim1) {
|
||||
tag = Heap_FetchAddress(adr);
|
||||
__GET(adr, tag, address);
|
||||
if (__ODD(tag)) {
|
||||
size = Heap_FetchAddress(tag - 1);
|
||||
__GET(tag - 1, size, address);
|
||||
adr += size;
|
||||
} else {
|
||||
size = Heap_FetchAddress(tag);
|
||||
__GET(tag, size, address);
|
||||
ptr = adr + 4;
|
||||
while (cand[i] < ptr) {
|
||||
i += 1;
|
||||
|
|
@ -534,7 +524,7 @@ static void Heap_MarkCandidates (address n, address *cand, LONGINT cand__len)
|
|||
adr = next;
|
||||
}
|
||||
}
|
||||
chnk = Heap_FetchAddress(chnk);
|
||||
__GET(chnk, chnk, address);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -544,7 +534,7 @@ static void Heap_CheckFin (void)
|
|||
address tag;
|
||||
n = Heap_fin;
|
||||
while (n != NIL) {
|
||||
tag = Heap_FetchAddress(n->obj - 4);
|
||||
__GET(n->obj - 4, tag, address);
|
||||
if (!__ODD(tag)) {
|
||||
n->marked = 0;
|
||||
Heap_Mark(n->obj);
|
||||
|
|
@ -723,7 +713,7 @@ void Heap_RegisterFinalizer (SYSTEM_PTR obj, Heap_Finalizer finalize)
|
|||
void Heap_InitHeap (void)
|
||||
{
|
||||
Heap_heap = Heap_NewChunk(128000);
|
||||
Heap_heapend = Heap_FetchAddress(Heap_heap + 4);
|
||||
__GET(Heap_heap + 4, Heap_heapend, address);
|
||||
__PUT(Heap_heap, 0, address);
|
||||
Heap_allocated = 0;
|
||||
Heap_firstTry = 1;
|
||||
|
|
|
|||
|
|
@ -82,7 +82,6 @@ export LONGINT *Heap__1__typ;
|
|||
static void Heap_CheckFin (void);
|
||||
static void Heap_ExtendHeap (address blksz);
|
||||
export void Heap_FINALL (void);
|
||||
static address Heap_FetchAddress (address pointer);
|
||||
static void Heap_Finalize (void);
|
||||
export void Heap_GC (BOOLEAN markStack);
|
||||
static void Heap_HeapSort (address n, address *a, LONGINT a__len);
|
||||
|
|
@ -188,15 +187,6 @@ static address Heap_NewChunk (address blksz)
|
|||
return _o_result;
|
||||
}
|
||||
|
||||
static address Heap_FetchAddress (address pointer)
|
||||
{
|
||||
address _o_result;
|
||||
address r;
|
||||
__GET(pointer, r, address);
|
||||
_o_result = r;
|
||||
return _o_result;
|
||||
}
|
||||
|
||||
static void Heap_ExtendHeap (address blksz)
|
||||
{
|
||||
address size, chnk, j, next;
|
||||
|
|
@ -212,16 +202,16 @@ static void Heap_ExtendHeap (address blksz)
|
|||
Heap_heap = chnk;
|
||||
} else {
|
||||
j = Heap_heap;
|
||||
next = Heap_FetchAddress(j);
|
||||
__GET(j, next, address);
|
||||
while ((next != 0 && chnk > next)) {
|
||||
j = next;
|
||||
next = Heap_FetchAddress(j);
|
||||
__GET(j, next, address);
|
||||
}
|
||||
__PUT(chnk, next, address);
|
||||
__PUT(j, chnk, address);
|
||||
}
|
||||
if (next == 0) {
|
||||
Heap_heapend = Heap_FetchAddress(chnk + 8);
|
||||
__GET(chnk + 8, Heap_heapend, address);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -232,7 +222,7 @@ SYSTEM_PTR Heap_NEWREC (address tag)
|
|||
address i, i0, di, blksz, restsize, t, adr, end, next, prev;
|
||||
SYSTEM_PTR new;
|
||||
Heap_Lock();
|
||||
blksz = Heap_FetchAddress(tag);
|
||||
__GET(tag, blksz, address);
|
||||
i0 = __ASHR(blksz, 5);
|
||||
i = i0;
|
||||
if (i < 9) {
|
||||
|
|
@ -243,7 +233,7 @@ SYSTEM_PTR Heap_NEWREC (address tag)
|
|||
}
|
||||
}
|
||||
if (i < 9) {
|
||||
next = Heap_FetchAddress(adr + 24);
|
||||
__GET(adr + 24, next, address);
|
||||
Heap_freeList[i] = next;
|
||||
if (i != i0) {
|
||||
di = i - i0;
|
||||
|
|
@ -284,12 +274,12 @@ SYSTEM_PTR Heap_NEWREC (address tag)
|
|||
return _o_result;
|
||||
}
|
||||
}
|
||||
t = Heap_FetchAddress(adr + 8);
|
||||
__GET(adr + 8, t, address);
|
||||
if (t >= blksz) {
|
||||
break;
|
||||
}
|
||||
prev = adr;
|
||||
adr = Heap_FetchAddress(adr + 24);
|
||||
__GET(adr + 24, adr, address);
|
||||
}
|
||||
restsize = t - blksz;
|
||||
end = adr + restsize;
|
||||
|
|
@ -299,7 +289,7 @@ SYSTEM_PTR Heap_NEWREC (address tag)
|
|||
if (restsize > 288) {
|
||||
__PUT(adr + 8, restsize, address);
|
||||
} else {
|
||||
next = Heap_FetchAddress(adr + 24);
|
||||
__GET(adr + 24, next, address);
|
||||
if (prev == 0) {
|
||||
Heap_bigBlocks = next;
|
||||
} else {
|
||||
|
|
@ -355,7 +345,7 @@ static void Heap_Mark (address q)
|
|||
{
|
||||
address p, tag, offset, fld, n, tagbits;
|
||||
if (q != 0) {
|
||||
tagbits = Heap_FetchAddress(q - 8);
|
||||
__GET(q - 8, tagbits, address);
|
||||
if (!__ODD(tagbits)) {
|
||||
__PUT(q - 8, tagbits + 1, address);
|
||||
p = 0;
|
||||
|
|
@ -369,17 +359,17 @@ static void Heap_Mark (address q)
|
|||
}
|
||||
n = q;
|
||||
q = p;
|
||||
tag = Heap_FetchAddress(q - 8);
|
||||
__GET(q - 8, tag, address);
|
||||
tag -= 1;
|
||||
__GET(tag, offset, address);
|
||||
fld = q + offset;
|
||||
p = Heap_FetchAddress(fld);
|
||||
__GET(fld, p, address);
|
||||
__PUT(fld, (SYSTEM_PTR)(address)n, SYSTEM_PTR);
|
||||
} else {
|
||||
fld = q + offset;
|
||||
n = Heap_FetchAddress(fld);
|
||||
__GET(fld, n, address);
|
||||
if (n != 0) {
|
||||
tagbits = Heap_FetchAddress(n - 8);
|
||||
__GET(n - 8, tagbits, address);
|
||||
if (!__ODD(tagbits)) {
|
||||
__PUT(n - 8, tagbits + 1, address);
|
||||
__PUT(q - 8, tag + 1, address);
|
||||
|
|
@ -415,9 +405,9 @@ static void Heap_Scan (void)
|
|||
chnk = Heap_heap;
|
||||
while (chnk != 0) {
|
||||
adr = chnk + 24;
|
||||
end = Heap_FetchAddress(chnk + 8);
|
||||
__GET(chnk + 8, end, address);
|
||||
while (adr < end) {
|
||||
tag = Heap_FetchAddress(adr);
|
||||
__GET(adr, tag, address);
|
||||
if (__ODD(tag)) {
|
||||
if (freesize > 0) {
|
||||
start = adr - freesize;
|
||||
|
|
@ -436,11 +426,11 @@ static void Heap_Scan (void)
|
|||
}
|
||||
tag -= 1;
|
||||
__PUT(adr, tag, address);
|
||||
size = Heap_FetchAddress(tag);
|
||||
__GET(tag, size, address);
|
||||
Heap_allocated += size;
|
||||
adr += size;
|
||||
} else {
|
||||
size = Heap_FetchAddress(tag);
|
||||
__GET(tag, size, address);
|
||||
freesize += size;
|
||||
adr += size;
|
||||
}
|
||||
|
|
@ -460,7 +450,7 @@ static void Heap_Scan (void)
|
|||
Heap_bigBlocks = start;
|
||||
}
|
||||
}
|
||||
chnk = Heap_FetchAddress(chnk);
|
||||
__GET(chnk, chnk, address);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -509,17 +499,17 @@ static void Heap_MarkCandidates (address n, address *cand, LONGINT cand__len)
|
|||
lim = cand[n - 1];
|
||||
while ((chnk != 0 && chnk < lim)) {
|
||||
adr = chnk + 24;
|
||||
lim1 = Heap_FetchAddress(chnk + 8);
|
||||
__GET(chnk + 8, lim1, address);
|
||||
if (lim < lim1) {
|
||||
lim1 = lim;
|
||||
}
|
||||
while (adr < lim1) {
|
||||
tag = Heap_FetchAddress(adr);
|
||||
__GET(adr, tag, address);
|
||||
if (__ODD(tag)) {
|
||||
size = Heap_FetchAddress(tag - 1);
|
||||
__GET(tag - 1, size, address);
|
||||
adr += size;
|
||||
} else {
|
||||
size = Heap_FetchAddress(tag);
|
||||
__GET(tag, size, address);
|
||||
ptr = adr + 8;
|
||||
while (cand[i] < ptr) {
|
||||
i += 1;
|
||||
|
|
@ -534,7 +524,7 @@ static void Heap_MarkCandidates (address n, address *cand, LONGINT cand__len)
|
|||
adr = next;
|
||||
}
|
||||
}
|
||||
chnk = Heap_FetchAddress(chnk);
|
||||
__GET(chnk, chnk, address);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -544,7 +534,7 @@ static void Heap_CheckFin (void)
|
|||
address tag;
|
||||
n = Heap_fin;
|
||||
while (n != NIL) {
|
||||
tag = Heap_FetchAddress(n->obj - 8);
|
||||
__GET(n->obj - 8, tag, address);
|
||||
if (!__ODD(tag)) {
|
||||
n->marked = 0;
|
||||
Heap_Mark(n->obj);
|
||||
|
|
@ -723,7 +713,7 @@ void Heap_RegisterFinalizer (SYSTEM_PTR obj, Heap_Finalizer finalize)
|
|||
void Heap_InitHeap (void)
|
||||
{
|
||||
Heap_heap = Heap_NewChunk(256000);
|
||||
Heap_heapend = Heap_FetchAddress(Heap_heap + 8);
|
||||
__GET(Heap_heap + 8, Heap_heapend, address);
|
||||
__PUT(Heap_heap, 0, address);
|
||||
Heap_allocated = 0;
|
||||
Heap_firstTry = 1;
|
||||
|
|
|
|||
|
|
@ -82,7 +82,6 @@ export LONGINT *Heap__1__typ;
|
|||
static void Heap_CheckFin (void);
|
||||
static void Heap_ExtendHeap (address blksz);
|
||||
export void Heap_FINALL (void);
|
||||
static address Heap_FetchAddress (address pointer);
|
||||
static void Heap_Finalize (void);
|
||||
export void Heap_GC (BOOLEAN markStack);
|
||||
static void Heap_HeapSort (address n, address *a, LONGINT a__len);
|
||||
|
|
@ -188,15 +187,6 @@ static address Heap_NewChunk (address blksz)
|
|||
return _o_result;
|
||||
}
|
||||
|
||||
static address Heap_FetchAddress (address pointer)
|
||||
{
|
||||
address _o_result;
|
||||
address r;
|
||||
__GET(pointer, r, address);
|
||||
_o_result = r;
|
||||
return _o_result;
|
||||
}
|
||||
|
||||
static void Heap_ExtendHeap (address blksz)
|
||||
{
|
||||
address size, chnk, j, next;
|
||||
|
|
@ -212,16 +202,16 @@ static void Heap_ExtendHeap (address blksz)
|
|||
Heap_heap = chnk;
|
||||
} else {
|
||||
j = Heap_heap;
|
||||
next = Heap_FetchAddress(j);
|
||||
__GET(j, next, address);
|
||||
while ((next != 0 && chnk > next)) {
|
||||
j = next;
|
||||
next = Heap_FetchAddress(j);
|
||||
__GET(j, next, address);
|
||||
}
|
||||
__PUT(chnk, next, address);
|
||||
__PUT(j, chnk, address);
|
||||
}
|
||||
if (next == 0) {
|
||||
Heap_heapend = Heap_FetchAddress(chnk + 4);
|
||||
__GET(chnk + 4, Heap_heapend, address);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -232,7 +222,7 @@ SYSTEM_PTR Heap_NEWREC (address tag)
|
|||
address i, i0, di, blksz, restsize, t, adr, end, next, prev;
|
||||
SYSTEM_PTR new;
|
||||
Heap_Lock();
|
||||
blksz = Heap_FetchAddress(tag);
|
||||
__GET(tag, blksz, address);
|
||||
i0 = __ASHR(blksz, 4);
|
||||
i = i0;
|
||||
if (i < 9) {
|
||||
|
|
@ -243,7 +233,7 @@ SYSTEM_PTR Heap_NEWREC (address tag)
|
|||
}
|
||||
}
|
||||
if (i < 9) {
|
||||
next = Heap_FetchAddress(adr + 12);
|
||||
__GET(adr + 12, next, address);
|
||||
Heap_freeList[i] = next;
|
||||
if (i != i0) {
|
||||
di = i - i0;
|
||||
|
|
@ -284,12 +274,12 @@ SYSTEM_PTR Heap_NEWREC (address tag)
|
|||
return _o_result;
|
||||
}
|
||||
}
|
||||
t = Heap_FetchAddress(adr + 4);
|
||||
__GET(adr + 4, t, address);
|
||||
if (t >= blksz) {
|
||||
break;
|
||||
}
|
||||
prev = adr;
|
||||
adr = Heap_FetchAddress(adr + 12);
|
||||
__GET(adr + 12, adr, address);
|
||||
}
|
||||
restsize = t - blksz;
|
||||
end = adr + restsize;
|
||||
|
|
@ -299,7 +289,7 @@ SYSTEM_PTR Heap_NEWREC (address tag)
|
|||
if (restsize > 144) {
|
||||
__PUT(adr + 4, restsize, address);
|
||||
} else {
|
||||
next = Heap_FetchAddress(adr + 12);
|
||||
__GET(adr + 12, next, address);
|
||||
if (prev == 0) {
|
||||
Heap_bigBlocks = next;
|
||||
} else {
|
||||
|
|
@ -355,7 +345,7 @@ static void Heap_Mark (address q)
|
|||
{
|
||||
address p, tag, offset, fld, n, tagbits;
|
||||
if (q != 0) {
|
||||
tagbits = Heap_FetchAddress(q - 4);
|
||||
__GET(q - 4, tagbits, address);
|
||||
if (!__ODD(tagbits)) {
|
||||
__PUT(q - 4, tagbits + 1, address);
|
||||
p = 0;
|
||||
|
|
@ -369,17 +359,17 @@ static void Heap_Mark (address q)
|
|||
}
|
||||
n = q;
|
||||
q = p;
|
||||
tag = Heap_FetchAddress(q - 4);
|
||||
__GET(q - 4, tag, address);
|
||||
tag -= 1;
|
||||
__GET(tag, offset, address);
|
||||
fld = q + offset;
|
||||
p = Heap_FetchAddress(fld);
|
||||
__GET(fld, p, address);
|
||||
__PUT(fld, (SYSTEM_PTR)(address)n, SYSTEM_PTR);
|
||||
} else {
|
||||
fld = q + offset;
|
||||
n = Heap_FetchAddress(fld);
|
||||
__GET(fld, n, address);
|
||||
if (n != 0) {
|
||||
tagbits = Heap_FetchAddress(n - 4);
|
||||
__GET(n - 4, tagbits, address);
|
||||
if (!__ODD(tagbits)) {
|
||||
__PUT(n - 4, tagbits + 1, address);
|
||||
__PUT(q - 4, tag + 1, address);
|
||||
|
|
@ -415,9 +405,9 @@ static void Heap_Scan (void)
|
|||
chnk = Heap_heap;
|
||||
while (chnk != 0) {
|
||||
adr = chnk + 12;
|
||||
end = Heap_FetchAddress(chnk + 4);
|
||||
__GET(chnk + 4, end, address);
|
||||
while (adr < end) {
|
||||
tag = Heap_FetchAddress(adr);
|
||||
__GET(adr, tag, address);
|
||||
if (__ODD(tag)) {
|
||||
if (freesize > 0) {
|
||||
start = adr - freesize;
|
||||
|
|
@ -436,11 +426,11 @@ static void Heap_Scan (void)
|
|||
}
|
||||
tag -= 1;
|
||||
__PUT(adr, tag, address);
|
||||
size = Heap_FetchAddress(tag);
|
||||
__GET(tag, size, address);
|
||||
Heap_allocated += size;
|
||||
adr += size;
|
||||
} else {
|
||||
size = Heap_FetchAddress(tag);
|
||||
__GET(tag, size, address);
|
||||
freesize += size;
|
||||
adr += size;
|
||||
}
|
||||
|
|
@ -460,7 +450,7 @@ static void Heap_Scan (void)
|
|||
Heap_bigBlocks = start;
|
||||
}
|
||||
}
|
||||
chnk = Heap_FetchAddress(chnk);
|
||||
__GET(chnk, chnk, address);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -509,17 +499,17 @@ static void Heap_MarkCandidates (address n, address *cand, LONGINT cand__len)
|
|||
lim = cand[n - 1];
|
||||
while ((chnk != 0 && chnk < lim)) {
|
||||
adr = chnk + 12;
|
||||
lim1 = Heap_FetchAddress(chnk + 4);
|
||||
__GET(chnk + 4, lim1, address);
|
||||
if (lim < lim1) {
|
||||
lim1 = lim;
|
||||
}
|
||||
while (adr < lim1) {
|
||||
tag = Heap_FetchAddress(adr);
|
||||
__GET(adr, tag, address);
|
||||
if (__ODD(tag)) {
|
||||
size = Heap_FetchAddress(tag - 1);
|
||||
__GET(tag - 1, size, address);
|
||||
adr += size;
|
||||
} else {
|
||||
size = Heap_FetchAddress(tag);
|
||||
__GET(tag, size, address);
|
||||
ptr = adr + 4;
|
||||
while (cand[i] < ptr) {
|
||||
i += 1;
|
||||
|
|
@ -534,7 +524,7 @@ static void Heap_MarkCandidates (address n, address *cand, LONGINT cand__len)
|
|||
adr = next;
|
||||
}
|
||||
}
|
||||
chnk = Heap_FetchAddress(chnk);
|
||||
__GET(chnk, chnk, address);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -544,7 +534,7 @@ static void Heap_CheckFin (void)
|
|||
address tag;
|
||||
n = Heap_fin;
|
||||
while (n != NIL) {
|
||||
tag = Heap_FetchAddress(n->obj - 4);
|
||||
__GET(n->obj - 4, tag, address);
|
||||
if (!__ODD(tag)) {
|
||||
n->marked = 0;
|
||||
Heap_Mark(n->obj);
|
||||
|
|
@ -723,7 +713,7 @@ void Heap_RegisterFinalizer (SYSTEM_PTR obj, Heap_Finalizer finalize)
|
|||
void Heap_InitHeap (void)
|
||||
{
|
||||
Heap_heap = Heap_NewChunk(128000);
|
||||
Heap_heapend = Heap_FetchAddress(Heap_heap + 4);
|
||||
__GET(Heap_heap + 4, Heap_heapend, address);
|
||||
__PUT(Heap_heap, 0, address);
|
||||
Heap_allocated = 0;
|
||||
Heap_firstTry = 1;
|
||||
|
|
|
|||
|
|
@ -82,7 +82,6 @@ export LONGINT *Heap__1__typ;
|
|||
static void Heap_CheckFin (void);
|
||||
static void Heap_ExtendHeap (address blksz);
|
||||
export void Heap_FINALL (void);
|
||||
static address Heap_FetchAddress (address pointer);
|
||||
static void Heap_Finalize (void);
|
||||
export void Heap_GC (BOOLEAN markStack);
|
||||
static void Heap_HeapSort (address n, address *a, LONGINT a__len);
|
||||
|
|
@ -188,15 +187,6 @@ static address Heap_NewChunk (address blksz)
|
|||
return _o_result;
|
||||
}
|
||||
|
||||
static address Heap_FetchAddress (address pointer)
|
||||
{
|
||||
address _o_result;
|
||||
address r;
|
||||
__GET(pointer, r, address);
|
||||
_o_result = r;
|
||||
return _o_result;
|
||||
}
|
||||
|
||||
static void Heap_ExtendHeap (address blksz)
|
||||
{
|
||||
address size, chnk, j, next;
|
||||
|
|
@ -212,16 +202,16 @@ static void Heap_ExtendHeap (address blksz)
|
|||
Heap_heap = chnk;
|
||||
} else {
|
||||
j = Heap_heap;
|
||||
next = Heap_FetchAddress(j);
|
||||
__GET(j, next, address);
|
||||
while ((next != 0 && chnk > next)) {
|
||||
j = next;
|
||||
next = Heap_FetchAddress(j);
|
||||
__GET(j, next, address);
|
||||
}
|
||||
__PUT(chnk, next, address);
|
||||
__PUT(j, chnk, address);
|
||||
}
|
||||
if (next == 0) {
|
||||
Heap_heapend = Heap_FetchAddress(chnk + 8);
|
||||
__GET(chnk + 8, Heap_heapend, address);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -232,7 +222,7 @@ SYSTEM_PTR Heap_NEWREC (address tag)
|
|||
address i, i0, di, blksz, restsize, t, adr, end, next, prev;
|
||||
SYSTEM_PTR new;
|
||||
Heap_Lock();
|
||||
blksz = Heap_FetchAddress(tag);
|
||||
__GET(tag, blksz, address);
|
||||
i0 = __ASHR(blksz, 5);
|
||||
i = i0;
|
||||
if (i < 9) {
|
||||
|
|
@ -243,7 +233,7 @@ SYSTEM_PTR Heap_NEWREC (address tag)
|
|||
}
|
||||
}
|
||||
if (i < 9) {
|
||||
next = Heap_FetchAddress(adr + 24);
|
||||
__GET(adr + 24, next, address);
|
||||
Heap_freeList[i] = next;
|
||||
if (i != i0) {
|
||||
di = i - i0;
|
||||
|
|
@ -284,12 +274,12 @@ SYSTEM_PTR Heap_NEWREC (address tag)
|
|||
return _o_result;
|
||||
}
|
||||
}
|
||||
t = Heap_FetchAddress(adr + 8);
|
||||
__GET(adr + 8, t, address);
|
||||
if (t >= blksz) {
|
||||
break;
|
||||
}
|
||||
prev = adr;
|
||||
adr = Heap_FetchAddress(adr + 24);
|
||||
__GET(adr + 24, adr, address);
|
||||
}
|
||||
restsize = t - blksz;
|
||||
end = adr + restsize;
|
||||
|
|
@ -299,7 +289,7 @@ SYSTEM_PTR Heap_NEWREC (address tag)
|
|||
if (restsize > 288) {
|
||||
__PUT(adr + 8, restsize, address);
|
||||
} else {
|
||||
next = Heap_FetchAddress(adr + 24);
|
||||
__GET(adr + 24, next, address);
|
||||
if (prev == 0) {
|
||||
Heap_bigBlocks = next;
|
||||
} else {
|
||||
|
|
@ -355,7 +345,7 @@ static void Heap_Mark (address q)
|
|||
{
|
||||
address p, tag, offset, fld, n, tagbits;
|
||||
if (q != 0) {
|
||||
tagbits = Heap_FetchAddress(q - 8);
|
||||
__GET(q - 8, tagbits, address);
|
||||
if (!__ODD(tagbits)) {
|
||||
__PUT(q - 8, tagbits + 1, address);
|
||||
p = 0;
|
||||
|
|
@ -369,17 +359,17 @@ static void Heap_Mark (address q)
|
|||
}
|
||||
n = q;
|
||||
q = p;
|
||||
tag = Heap_FetchAddress(q - 8);
|
||||
__GET(q - 8, tag, address);
|
||||
tag -= 1;
|
||||
__GET(tag, offset, address);
|
||||
fld = q + offset;
|
||||
p = Heap_FetchAddress(fld);
|
||||
__GET(fld, p, address);
|
||||
__PUT(fld, (SYSTEM_PTR)(address)n, SYSTEM_PTR);
|
||||
} else {
|
||||
fld = q + offset;
|
||||
n = Heap_FetchAddress(fld);
|
||||
__GET(fld, n, address);
|
||||
if (n != 0) {
|
||||
tagbits = Heap_FetchAddress(n - 8);
|
||||
__GET(n - 8, tagbits, address);
|
||||
if (!__ODD(tagbits)) {
|
||||
__PUT(n - 8, tagbits + 1, address);
|
||||
__PUT(q - 8, tag + 1, address);
|
||||
|
|
@ -415,9 +405,9 @@ static void Heap_Scan (void)
|
|||
chnk = Heap_heap;
|
||||
while (chnk != 0) {
|
||||
adr = chnk + 24;
|
||||
end = Heap_FetchAddress(chnk + 8);
|
||||
__GET(chnk + 8, end, address);
|
||||
while (adr < end) {
|
||||
tag = Heap_FetchAddress(adr);
|
||||
__GET(adr, tag, address);
|
||||
if (__ODD(tag)) {
|
||||
if (freesize > 0) {
|
||||
start = adr - freesize;
|
||||
|
|
@ -436,11 +426,11 @@ static void Heap_Scan (void)
|
|||
}
|
||||
tag -= 1;
|
||||
__PUT(adr, tag, address);
|
||||
size = Heap_FetchAddress(tag);
|
||||
__GET(tag, size, address);
|
||||
Heap_allocated += size;
|
||||
adr += size;
|
||||
} else {
|
||||
size = Heap_FetchAddress(tag);
|
||||
__GET(tag, size, address);
|
||||
freesize += size;
|
||||
adr += size;
|
||||
}
|
||||
|
|
@ -460,7 +450,7 @@ static void Heap_Scan (void)
|
|||
Heap_bigBlocks = start;
|
||||
}
|
||||
}
|
||||
chnk = Heap_FetchAddress(chnk);
|
||||
__GET(chnk, chnk, address);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -509,17 +499,17 @@ static void Heap_MarkCandidates (address n, address *cand, LONGINT cand__len)
|
|||
lim = cand[n - 1];
|
||||
while ((chnk != 0 && chnk < lim)) {
|
||||
adr = chnk + 24;
|
||||
lim1 = Heap_FetchAddress(chnk + 8);
|
||||
__GET(chnk + 8, lim1, address);
|
||||
if (lim < lim1) {
|
||||
lim1 = lim;
|
||||
}
|
||||
while (adr < lim1) {
|
||||
tag = Heap_FetchAddress(adr);
|
||||
__GET(adr, tag, address);
|
||||
if (__ODD(tag)) {
|
||||
size = Heap_FetchAddress(tag - 1);
|
||||
__GET(tag - 1, size, address);
|
||||
adr += size;
|
||||
} else {
|
||||
size = Heap_FetchAddress(tag);
|
||||
__GET(tag, size, address);
|
||||
ptr = adr + 8;
|
||||
while (cand[i] < ptr) {
|
||||
i += 1;
|
||||
|
|
@ -534,7 +524,7 @@ static void Heap_MarkCandidates (address n, address *cand, LONGINT cand__len)
|
|||
adr = next;
|
||||
}
|
||||
}
|
||||
chnk = Heap_FetchAddress(chnk);
|
||||
__GET(chnk, chnk, address);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -544,7 +534,7 @@ static void Heap_CheckFin (void)
|
|||
address tag;
|
||||
n = Heap_fin;
|
||||
while (n != NIL) {
|
||||
tag = Heap_FetchAddress(n->obj - 8);
|
||||
__GET(n->obj - 8, tag, address);
|
||||
if (!__ODD(tag)) {
|
||||
n->marked = 0;
|
||||
Heap_Mark(n->obj);
|
||||
|
|
@ -723,7 +713,7 @@ void Heap_RegisterFinalizer (SYSTEM_PTR obj, Heap_Finalizer finalize)
|
|||
void Heap_InitHeap (void)
|
||||
{
|
||||
Heap_heap = Heap_NewChunk(256000);
|
||||
Heap_heapend = Heap_FetchAddress(Heap_heap + 8);
|
||||
__GET(Heap_heap + 8, Heap_heapend, address);
|
||||
__PUT(Heap_heap, 0, address);
|
||||
Heap_allocated = 0;
|
||||
Heap_firstTry = 1;
|
||||
|
|
|
|||
|
|
@ -183,12 +183,6 @@ MODULE Heap;
|
|||
RETURN chnk
|
||||
END NewChunk;
|
||||
|
||||
|
||||
(*
|
||||
PROCEDURE -FetchAddress(pointer: Address): Address "(address)(*((void**)((address)pointer)))";
|
||||
*)
|
||||
PROCEDURE FetchAddress(pointer: Address): Address; VAR r: Address; BEGIN SYSTEM.GET(pointer, r); RETURN r END FetchAddress;
|
||||
|
||||
PROCEDURE ExtendHeap(blksz: Address);
|
||||
VAR size, chnk, j, next: Address;
|
||||
BEGIN
|
||||
|
|
@ -201,14 +195,14 @@ MODULE Heap;
|
|||
IF chnk < heap THEN
|
||||
SYSTEM.PUT(chnk, heap); heap := chnk
|
||||
ELSE
|
||||
j := heap; next := FetchAddress(j);
|
||||
j := heap; SYSTEM.GET(j, next);
|
||||
WHILE (next # 0) & (chnk > next) DO
|
||||
j := next;
|
||||
next := FetchAddress(j)
|
||||
SYSTEM.GET(j, next)
|
||||
END;
|
||||
SYSTEM.PUT(chnk, next); SYSTEM.PUT(j, chnk)
|
||||
END ;
|
||||
IF next = 0 THEN heapend := FetchAddress(chnk+endOff) END
|
||||
IF next = 0 THEN SYSTEM.GET(chnk+endOff, heapend) END
|
||||
END
|
||||
END ExtendHeap;
|
||||
|
||||
|
|
@ -220,7 +214,7 @@ MODULE Heap;
|
|||
new: SYSTEM.PTR;
|
||||
BEGIN
|
||||
Lock();
|
||||
blksz := FetchAddress(tag);
|
||||
SYSTEM.GET(tag, blksz);
|
||||
|
||||
ASSERT((Unit = 16) OR (Unit = 32));
|
||||
ASSERT(SIZE(SYSTEM.PTR) = SIZE(Address));
|
||||
|
|
@ -231,7 +225,7 @@ MODULE Heap;
|
|||
WHILE adr = 0 DO INC(i); adr := freeList[i] END
|
||||
END ;
|
||||
IF i < nofLists THEN (* unlink *)
|
||||
next := FetchAddress(adr + nextOff);
|
||||
SYSTEM.GET(adr + nextOff, next);
|
||||
freeList[i] := next;
|
||||
IF i # i0 THEN (* split *)
|
||||
di := i - i0; restsize := di * Unit; end := adr + restsize;
|
||||
|
|
@ -265,9 +259,9 @@ MODULE Heap;
|
|||
Unlock(); RETURN NIL
|
||||
END
|
||||
END ;
|
||||
t := FetchAddress(adr+sizeOff);
|
||||
SYSTEM.GET(adr+sizeOff, t);
|
||||
IF t >= blksz THEN EXIT END ;
|
||||
prev := adr; adr := FetchAddress(adr + nextOff)
|
||||
prev := adr; SYSTEM.GET(adr + nextOff, adr)
|
||||
END ;
|
||||
restsize := t - blksz; end := adr + restsize;
|
||||
SYSTEM.PUT(end + sizeOff, blksz);
|
||||
|
|
@ -276,7 +270,7 @@ MODULE Heap;
|
|||
IF restsize > nofLists * Unit THEN (*resize*)
|
||||
SYSTEM.PUT(adr + sizeOff, restsize)
|
||||
ELSE (*unlink*)
|
||||
next := FetchAddress(adr + nextOff);
|
||||
SYSTEM.GET(adr + nextOff, next);
|
||||
IF prev = 0 THEN bigBlocks := next
|
||||
ELSE SYSTEM.PUT(prev + nextOff, next);
|
||||
END ;
|
||||
|
|
@ -325,7 +319,7 @@ MODULE Heap;
|
|||
VAR p, tag, offset, fld, n, tagbits: Address;
|
||||
BEGIN
|
||||
IF q # 0 THEN
|
||||
tagbits := FetchAddress(q - SZA); (* Load the tag for the record at q *)
|
||||
SYSTEM.GET(q - SZA, tagbits); (* Load the tag for the record at q *)
|
||||
IF ~ODD(tagbits) THEN (* If it has not already been marked *)
|
||||
SYSTEM.PUT(q - SZA, tagbits + 1); (* Mark it *)
|
||||
p := 0;
|
||||
|
|
@ -336,14 +330,14 @@ MODULE Heap;
|
|||
SYSTEM.PUT(q - SZA, tag + offset + 1); (* Rotate base ptr into tag *)
|
||||
IF p = 0 THEN EXIT END ;
|
||||
n := q; q := p;
|
||||
tag := FetchAddress(q - SZA); DEC(tag, 1);
|
||||
SYSTEM.GET(q - SZA, tag); DEC(tag, 1);
|
||||
SYSTEM.GET(tag, offset); fld := q + offset;
|
||||
p := FetchAddress(fld); SYSTEM.PUT(fld, SYSTEM.VAL(SYSTEM.PTR, n))
|
||||
SYSTEM.GET(fld, p); SYSTEM.PUT(fld, SYSTEM.VAL(SYSTEM.PTR, n))
|
||||
ELSE (* offset references a ptr field *)
|
||||
fld := q + offset; (* Address the pointer *)
|
||||
n := FetchAddress(fld); (* Load the pointer *)
|
||||
SYSTEM.GET(fld, n); (* Load the pointer *)
|
||||
IF n # 0 THEN (* If pointer is not NIL *)
|
||||
tagbits := FetchAddress(n - SZA); (* Consider record pointed to by this field *)
|
||||
SYSTEM.GET(n - SZA, tagbits); (* Consider record pointed to by this field *)
|
||||
IF ~ODD(tagbits) THEN
|
||||
SYSTEM.PUT(n - SZA, tagbits + 1);
|
||||
SYSTEM.PUT(q - SZA, tag + 1);
|
||||
|
|
@ -371,9 +365,9 @@ MODULE Heap;
|
|||
freesize := 0; allocated := 0; chnk := heap;
|
||||
WHILE chnk # 0 DO
|
||||
adr := chnk + blkOff;
|
||||
end := FetchAddress(chnk + endOff);
|
||||
SYSTEM.GET(chnk + endOff, end);
|
||||
WHILE adr < end DO
|
||||
tag := FetchAddress(adr);
|
||||
SYSTEM.GET(adr, tag);
|
||||
IF ODD(tag) THEN (*marked*)
|
||||
IF freesize > 0 THEN
|
||||
start := adr - freesize;
|
||||
|
|
@ -387,11 +381,11 @@ MODULE Heap;
|
|||
END ;
|
||||
DEC(tag, 1);
|
||||
SYSTEM.PUT(adr, tag);
|
||||
size := FetchAddress(tag);
|
||||
SYSTEM.GET(tag, size);
|
||||
INC(allocated, size);
|
||||
INC(adr, size)
|
||||
ELSE (*unmarked*)
|
||||
size := FetchAddress(tag);
|
||||
SYSTEM.GET(tag, size);
|
||||
INC(freesize, size);
|
||||
INC(adr, size)
|
||||
END
|
||||
|
|
@ -406,7 +400,7 @@ MODULE Heap;
|
|||
ELSE SYSTEM.PUT(start + nextOff, bigBlocks); bigBlocks := start
|
||||
END
|
||||
END ;
|
||||
chnk := FetchAddress(chnk)
|
||||
SYSTEM.GET(chnk, chnk)
|
||||
END
|
||||
END Scan;
|
||||
|
||||
|
|
@ -434,14 +428,14 @@ MODULE Heap;
|
|||
chnk := heap; i := 0; lim := cand[n-1];
|
||||
WHILE (chnk # 0 ) & (chnk < lim) DO
|
||||
adr := chnk + blkOff;
|
||||
lim1 := FetchAddress(chnk + endOff);
|
||||
SYSTEM.GET(chnk + endOff, lim1);
|
||||
IF lim < lim1 THEN lim1 := lim END ;
|
||||
WHILE adr < lim1 DO
|
||||
tag := FetchAddress(adr);
|
||||
SYSTEM.GET(adr, tag);
|
||||
IF ODD(tag) THEN (*already marked*)
|
||||
size := FetchAddress(tag-1); INC(adr, size)
|
||||
SYSTEM.GET(tag-1, size); INC(adr, size)
|
||||
ELSE
|
||||
size := FetchAddress(tag);
|
||||
SYSTEM.GET(tag, size);
|
||||
ptr := adr + SZA;
|
||||
WHILE cand[i] < ptr DO INC(i) END ;
|
||||
IF i = n THEN RETURN END ;
|
||||
|
|
@ -450,7 +444,7 @@ MODULE Heap;
|
|||
adr := next
|
||||
END
|
||||
END ;
|
||||
chnk := FetchAddress(chnk)
|
||||
SYSTEM.GET(chnk, chnk)
|
||||
END
|
||||
END MarkCandidates;
|
||||
|
||||
|
|
@ -459,7 +453,7 @@ MODULE Heap;
|
|||
BEGIN
|
||||
n := fin;
|
||||
WHILE n # NIL DO
|
||||
tag := FetchAddress(n.obj - SZA);
|
||||
SYSTEM.GET(n.obj - SZA, tag);
|
||||
IF ~ODD(tag) THEN n.marked := FALSE; Mark(n.obj)
|
||||
ELSE n.marked := TRUE
|
||||
END ;
|
||||
|
|
@ -574,7 +568,7 @@ PROCEDURE -HeapModuleInit 'Heap__init()';
|
|||
initialised, to enable NEW, SYSTEM.NEW *)
|
||||
BEGIN
|
||||
heap := NewChunk(heapSize0);
|
||||
heapend := FetchAddress(heap + endOff);
|
||||
SYSTEM.GET(heap + endOff, heapend);
|
||||
SYSTEM.PUT(heap, AddressZero);
|
||||
allocated := 0; firstTry := TRUE; freeList[nofLists] := 1; lockdepth := 0;
|
||||
FileCount := 0; modules := NIL; heapsize := 0; bigBlocks := 0; fin := NIL;
|
||||
|
|
|
|||
|
|
@ -1 +1 @@
|
|||
14 Sep 2016 13:00:54
|
||||
14 Sep 2016 13:59:08
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue