mirror of
https://github.com/vishapoberon/compiler.git
synced 2026-04-06 04:02:25 +00:00
Uppercase internal SYSTEM.H types address, int*, uint*. Phase 1.
This commit is contained in:
David Brown
parent
1935f63cd6
commit
baeb2db81f
205 changed files with 8388 additions and 8311 deletions
|
|
@ -1,9 +1,9 @@
|
|||
/* voc 1.95 [2016/10/28]. Bootstrapping compiler for address size 8, alignment 8. tsSfF */
|
||||
/* voc 1.95 [2016/11/08]. Bootstrapping compiler for address size 8, alignment 8. tsSfF */
|
||||
|
||||
#define SHORTINT int8
|
||||
#define INTEGER int16
|
||||
#define LONGINT int32
|
||||
#define SET uint32
|
||||
#define SHORTINT INT8
|
||||
#define INTEGER INT16
|
||||
#define LONGINT INT32
|
||||
#define SET UINT32
|
||||
|
||||
#include "SYSTEM.h"
|
||||
|
||||
|
|
@ -40,7 +40,7 @@ typedef
|
|||
typedef
|
||||
struct Heap_FinDesc {
|
||||
Heap_FinNode next;
|
||||
int32 obj;
|
||||
INT32 obj;
|
||||
BOOLEAN marked;
|
||||
Heap_Finalizer finalize;
|
||||
} Heap_FinDesc;
|
||||
|
|
@ -55,53 +55,53 @@ typedef
|
|||
struct Heap_ModuleDesc {
|
||||
Heap_Module next;
|
||||
Heap_ModuleName name;
|
||||
int32 refcnt;
|
||||
INT32 refcnt;
|
||||
Heap_Cmd cmds;
|
||||
int32 types;
|
||||
INT32 types;
|
||||
Heap_EnumProc enumPtrs;
|
||||
int32 reserved1, reserved2;
|
||||
INT32 reserved1, reserved2;
|
||||
} Heap_ModuleDesc;
|
||||
|
||||
|
||||
export SYSTEM_PTR Heap_modules;
|
||||
static int32 Heap_freeList[10];
|
||||
static int32 Heap_bigBlocks;
|
||||
export int32 Heap_allocated;
|
||||
static INT32 Heap_freeList[10];
|
||||
static INT32 Heap_bigBlocks;
|
||||
export INT32 Heap_allocated;
|
||||
static BOOLEAN Heap_firstTry;
|
||||
static int32 Heap_heap, Heap_heapend;
|
||||
export int32 Heap_heapsize;
|
||||
static INT32 Heap_heap, Heap_heapend;
|
||||
export INT32 Heap_heapsize;
|
||||
static Heap_FinNode Heap_fin;
|
||||
static int16 Heap_lockdepth;
|
||||
static INT16 Heap_lockdepth;
|
||||
static BOOLEAN Heap_interrupted;
|
||||
export int16 Heap_FileCount;
|
||||
export INT16 Heap_FileCount;
|
||||
|
||||
export address *Heap_ModuleDesc__typ;
|
||||
export address *Heap_CmdDesc__typ;
|
||||
export address *Heap_FinDesc__typ;
|
||||
export address *Heap__1__typ;
|
||||
export ADDRESS *Heap_ModuleDesc__typ;
|
||||
export ADDRESS *Heap_CmdDesc__typ;
|
||||
export ADDRESS *Heap_FinDesc__typ;
|
||||
export ADDRESS *Heap__1__typ;
|
||||
|
||||
static void Heap_CheckFin (void);
|
||||
static void Heap_ExtendHeap (int32 blksz);
|
||||
static void Heap_ExtendHeap (INT32 blksz);
|
||||
export void Heap_FINALL (void);
|
||||
static void Heap_Finalize (void);
|
||||
export void Heap_GC (BOOLEAN markStack);
|
||||
static void Heap_HeapSort (int32 n, int32 *a, LONGINT a__len);
|
||||
static void Heap_HeapSort (INT32 n, INT32 *a, LONGINT a__len);
|
||||
export void Heap_INCREF (Heap_Module m);
|
||||
export void Heap_InitHeap (void);
|
||||
export void Heap_Lock (void);
|
||||
static void Heap_Mark (int32 q);
|
||||
static void Heap_MarkCandidates (int32 n, int32 *cand, LONGINT cand__len);
|
||||
static void Heap_Mark (INT32 q);
|
||||
static void Heap_MarkCandidates (INT32 n, INT32 *cand, LONGINT cand__len);
|
||||
static void Heap_MarkP (SYSTEM_PTR p);
|
||||
static void Heap_MarkStack (int32 n, int32 *cand, LONGINT cand__len);
|
||||
export SYSTEM_PTR Heap_NEWBLK (int32 size);
|
||||
export SYSTEM_PTR Heap_NEWREC (int32 tag);
|
||||
static int32 Heap_NewChunk (int32 blksz);
|
||||
static void Heap_MarkStack (INT32 n, INT32 *cand, LONGINT cand__len);
|
||||
export SYSTEM_PTR Heap_NEWBLK (INT32 size);
|
||||
export SYSTEM_PTR Heap_NEWREC (INT32 tag);
|
||||
static INT32 Heap_NewChunk (INT32 blksz);
|
||||
export void Heap_REGCMD (Heap_Module m, Heap_CmdName name, Heap_Command cmd);
|
||||
export SYSTEM_PTR Heap_REGMOD (Heap_ModuleName name, Heap_EnumProc enumPtrs);
|
||||
export void Heap_REGTYP (Heap_Module m, int32 typ);
|
||||
export void Heap_REGTYP (Heap_Module m, INT32 typ);
|
||||
export void Heap_RegisterFinalizer (SYSTEM_PTR obj, Heap_Finalizer finalize);
|
||||
static void Heap_Scan (void);
|
||||
static void Heap_Sift (int32 l, int32 r, int32 *a, LONGINT a__len);
|
||||
static void Heap_Sift (INT32 l, INT32 r, INT32 *a, LONGINT a__len);
|
||||
export void Heap_Unlock (void);
|
||||
|
||||
extern void *Heap__init();
|
||||
|
|
@ -157,9 +157,9 @@ void Heap_REGCMD (Heap_Module m, Heap_CmdName name, Heap_Command cmd)
|
|||
m->cmds = c;
|
||||
}
|
||||
|
||||
void Heap_REGTYP (Heap_Module m, int32 typ)
|
||||
void Heap_REGTYP (Heap_Module m, INT32 typ)
|
||||
{
|
||||
__PUT(typ, m->types, int32);
|
||||
__PUT(typ, m->types, INT32);
|
||||
m->types = typ;
|
||||
}
|
||||
|
||||
|
|
@ -168,25 +168,25 @@ void Heap_INCREF (Heap_Module m)
|
|||
m->refcnt += 1;
|
||||
}
|
||||
|
||||
static int32 Heap_NewChunk (int32 blksz)
|
||||
static INT32 Heap_NewChunk (INT32 blksz)
|
||||
{
|
||||
int32 chnk;
|
||||
INT32 chnk;
|
||||
chnk = Heap_OSAllocate(blksz + 12);
|
||||
if (chnk != 0) {
|
||||
__PUT(chnk + 4, chnk + (12 + blksz), int32);
|
||||
__PUT(chnk + 12, chnk + 16, int32);
|
||||
__PUT(chnk + 16, blksz, int32);
|
||||
__PUT(chnk + 20, -4, int32);
|
||||
__PUT(chnk + 24, Heap_bigBlocks, int32);
|
||||
__PUT(chnk + 4, chnk + (12 + blksz), INT32);
|
||||
__PUT(chnk + 12, chnk + 16, INT32);
|
||||
__PUT(chnk + 16, blksz, INT32);
|
||||
__PUT(chnk + 20, -4, INT32);
|
||||
__PUT(chnk + 24, Heap_bigBlocks, INT32);
|
||||
Heap_bigBlocks = chnk + 12;
|
||||
Heap_heapsize += blksz;
|
||||
}
|
||||
return chnk;
|
||||
}
|
||||
|
||||
static void Heap_ExtendHeap (int32 blksz)
|
||||
static void Heap_ExtendHeap (INT32 blksz)
|
||||
{
|
||||
int32 size, chnk, j, next;
|
||||
INT32 size, chnk, j, next;
|
||||
if (blksz > 160000) {
|
||||
size = blksz;
|
||||
} else {
|
||||
|
|
@ -195,30 +195,30 @@ static void Heap_ExtendHeap (int32 blksz)
|
|||
chnk = Heap_NewChunk(size);
|
||||
if (chnk != 0) {
|
||||
if (chnk < Heap_heap) {
|
||||
__PUT(chnk, Heap_heap, int32);
|
||||
__PUT(chnk, Heap_heap, INT32);
|
||||
Heap_heap = chnk;
|
||||
} else {
|
||||
j = Heap_heap;
|
||||
__GET(j, next, int32);
|
||||
__GET(j, next, INT32);
|
||||
while ((next != 0 && chnk > next)) {
|
||||
j = next;
|
||||
__GET(j, next, int32);
|
||||
__GET(j, next, INT32);
|
||||
}
|
||||
__PUT(chnk, next, int32);
|
||||
__PUT(j, chnk, int32);
|
||||
__PUT(chnk, next, INT32);
|
||||
__PUT(j, chnk, INT32);
|
||||
}
|
||||
if (next == 0) {
|
||||
__GET(chnk + 4, Heap_heapend, int32);
|
||||
__GET(chnk + 4, Heap_heapend, INT32);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
SYSTEM_PTR Heap_NEWREC (int32 tag)
|
||||
SYSTEM_PTR Heap_NEWREC (INT32 tag)
|
||||
{
|
||||
int32 i, i0, di, blksz, restsize, t, adr, end, next, prev;
|
||||
INT32 i, i0, di, blksz, restsize, t, adr, end, next, prev;
|
||||
SYSTEM_PTR new;
|
||||
Heap_Lock();
|
||||
__GET(tag, blksz, int32);
|
||||
__GET(tag, blksz, INT32);
|
||||
i0 = __ASHR(blksz, 4);
|
||||
i = i0;
|
||||
if (i < 9) {
|
||||
|
|
@ -229,17 +229,17 @@ SYSTEM_PTR Heap_NEWREC (int32 tag)
|
|||
}
|
||||
}
|
||||
if (i < 9) {
|
||||
__GET(adr + 12, next, int32);
|
||||
__GET(adr + 12, next, INT32);
|
||||
Heap_freeList[i] = next;
|
||||
if (i != i0) {
|
||||
di = i - i0;
|
||||
restsize = __ASHL(di, 4);
|
||||
end = adr + restsize;
|
||||
__PUT(end + 4, blksz, int32);
|
||||
__PUT(end + 8, -4, int32);
|
||||
__PUT(end, end + 4, int32);
|
||||
__PUT(adr + 4, restsize, int32);
|
||||
__PUT(adr + 12, Heap_freeList[di], int32);
|
||||
__PUT(end + 4, blksz, INT32);
|
||||
__PUT(end + 8, -4, INT32);
|
||||
__PUT(end, end + 4, INT32);
|
||||
__PUT(adr + 4, restsize, INT32);
|
||||
__PUT(adr + 12, Heap_freeList[di], INT32);
|
||||
Heap_freeList[di] = adr;
|
||||
adr += restsize;
|
||||
}
|
||||
|
|
@ -268,31 +268,31 @@ SYSTEM_PTR Heap_NEWREC (int32 tag)
|
|||
return NIL;
|
||||
}
|
||||
}
|
||||
__GET(adr + 4, t, int32);
|
||||
__GET(adr + 4, t, INT32);
|
||||
if (t >= blksz) {
|
||||
break;
|
||||
}
|
||||
prev = adr;
|
||||
__GET(adr + 12, adr, int32);
|
||||
__GET(adr + 12, adr, INT32);
|
||||
}
|
||||
restsize = t - blksz;
|
||||
end = adr + restsize;
|
||||
__PUT(end + 4, blksz, int32);
|
||||
__PUT(end + 8, -4, int32);
|
||||
__PUT(end, end + 4, int32);
|
||||
__PUT(end + 4, blksz, INT32);
|
||||
__PUT(end + 8, -4, INT32);
|
||||
__PUT(end, end + 4, INT32);
|
||||
if (restsize > 144) {
|
||||
__PUT(adr + 4, restsize, int32);
|
||||
__PUT(adr + 4, restsize, INT32);
|
||||
} else {
|
||||
__GET(adr + 12, next, int32);
|
||||
__GET(adr + 12, next, INT32);
|
||||
if (prev == 0) {
|
||||
Heap_bigBlocks = next;
|
||||
} else {
|
||||
__PUT(prev + 12, next, int32);
|
||||
__PUT(prev + 12, next, INT32);
|
||||
}
|
||||
if (restsize > 0) {
|
||||
di = __ASHR(restsize, 4);
|
||||
__PUT(adr + 4, restsize, int32);
|
||||
__PUT(adr + 12, Heap_freeList[di], int32);
|
||||
__PUT(adr + 4, restsize, INT32);
|
||||
__PUT(adr + 12, Heap_freeList[di], INT32);
|
||||
Heap_freeList[di] = adr;
|
||||
}
|
||||
}
|
||||
|
|
@ -301,69 +301,69 @@ SYSTEM_PTR Heap_NEWREC (int32 tag)
|
|||
i = adr + 16;
|
||||
end = adr + blksz;
|
||||
while (i < end) {
|
||||
__PUT(i, 0, int32);
|
||||
__PUT(i + 4, 0, int32);
|
||||
__PUT(i + 8, 0, int32);
|
||||
__PUT(i + 12, 0, int32);
|
||||
__PUT(i, 0, INT32);
|
||||
__PUT(i + 4, 0, INT32);
|
||||
__PUT(i + 8, 0, INT32);
|
||||
__PUT(i + 12, 0, INT32);
|
||||
i += 16;
|
||||
}
|
||||
__PUT(adr + 12, 0, int32);
|
||||
__PUT(adr, tag, int32);
|
||||
__PUT(adr + 4, 0, int32);
|
||||
__PUT(adr + 8, 0, int32);
|
||||
__PUT(adr + 12, 0, INT32);
|
||||
__PUT(adr, tag, INT32);
|
||||
__PUT(adr + 4, 0, INT32);
|
||||
__PUT(adr + 8, 0, INT32);
|
||||
Heap_allocated += blksz;
|
||||
Heap_Unlock();
|
||||
return (SYSTEM_PTR)(address)(adr + 4);
|
||||
}
|
||||
|
||||
SYSTEM_PTR Heap_NEWBLK (int32 size)
|
||||
SYSTEM_PTR Heap_NEWBLK (INT32 size)
|
||||
{
|
||||
int32 blksz, tag;
|
||||
INT32 blksz, tag;
|
||||
SYSTEM_PTR new;
|
||||
Heap_Lock();
|
||||
blksz = __ASHL(__ASHR(size + 31, 4), 4);
|
||||
new = Heap_NEWREC((address)&blksz);
|
||||
tag = ((int32)(address)new + blksz) - 12;
|
||||
__PUT(tag - 4, 0, int32);
|
||||
__PUT(tag, blksz, int32);
|
||||
__PUT(tag + 4, -4, int32);
|
||||
__PUT((int32)(address)new - 4, tag, int32);
|
||||
tag = ((INT32)(address)new + blksz) - 12;
|
||||
__PUT(tag - 4, 0, INT32);
|
||||
__PUT(tag, blksz, INT32);
|
||||
__PUT(tag + 4, -4, INT32);
|
||||
__PUT((INT32)(address)new - 4, tag, INT32);
|
||||
Heap_Unlock();
|
||||
return new;
|
||||
}
|
||||
|
||||
static void Heap_Mark (int32 q)
|
||||
static void Heap_Mark (INT32 q)
|
||||
{
|
||||
int32 p, tag, offset, fld, n, tagbits;
|
||||
INT32 p, tag, offset, fld, n, tagbits;
|
||||
if (q != 0) {
|
||||
__GET(q - 4, tagbits, int32);
|
||||
__GET(q - 4, tagbits, INT32);
|
||||
if (!__ODD(tagbits)) {
|
||||
__PUT(q - 4, tagbits + 1, int32);
|
||||
__PUT(q - 4, tagbits + 1, INT32);
|
||||
p = 0;
|
||||
tag = tagbits + 4;
|
||||
for (;;) {
|
||||
__GET(tag, offset, int32);
|
||||
__GET(tag, offset, INT32);
|
||||
if (offset < 0) {
|
||||
__PUT(q - 4, (tag + offset) + 1, int32);
|
||||
__PUT(q - 4, (tag + offset) + 1, INT32);
|
||||
if (p == 0) {
|
||||
break;
|
||||
}
|
||||
n = q;
|
||||
q = p;
|
||||
__GET(q - 4, tag, int32);
|
||||
__GET(q - 4, tag, INT32);
|
||||
tag -= 1;
|
||||
__GET(tag, offset, int32);
|
||||
__GET(tag, offset, INT32);
|
||||
fld = q + offset;
|
||||
__GET(fld, p, int32);
|
||||
__GET(fld, p, INT32);
|
||||
__PUT(fld, (SYSTEM_PTR)(address)n, SYSTEM_PTR);
|
||||
} else {
|
||||
fld = q + offset;
|
||||
__GET(fld, n, int32);
|
||||
__GET(fld, n, INT32);
|
||||
if (n != 0) {
|
||||
__GET(n - 4, tagbits, int32);
|
||||
__GET(n - 4, tagbits, INT32);
|
||||
if (!__ODD(tagbits)) {
|
||||
__PUT(n - 4, tagbits + 1, int32);
|
||||
__PUT(q - 4, tag + 1, int32);
|
||||
__PUT(n - 4, tagbits + 1, INT32);
|
||||
__PUT(q - 4, tag + 1, INT32);
|
||||
__PUT(fld, (SYSTEM_PTR)(address)p, SYSTEM_PTR);
|
||||
p = q;
|
||||
q = n;
|
||||
|
|
@ -379,12 +379,12 @@ static void Heap_Mark (int32 q)
|
|||
|
||||
static void Heap_MarkP (SYSTEM_PTR p)
|
||||
{
|
||||
Heap_Mark((int32)(address)p);
|
||||
Heap_Mark((INT32)(address)p);
|
||||
}
|
||||
|
||||
static void Heap_Scan (void)
|
||||
{
|
||||
int32 chnk, adr, end, start, tag, i, size, freesize;
|
||||
INT32 chnk, adr, end, start, tag, i, size, freesize;
|
||||
Heap_bigBlocks = 0;
|
||||
i = 1;
|
||||
while (i < 9) {
|
||||
|
|
@ -396,58 +396,58 @@ static void Heap_Scan (void)
|
|||
chnk = Heap_heap;
|
||||
while (chnk != 0) {
|
||||
adr = chnk + 12;
|
||||
__GET(chnk + 4, end, int32);
|
||||
__GET(chnk + 4, end, INT32);
|
||||
while (adr < end) {
|
||||
__GET(adr, tag, int32);
|
||||
__GET(adr, tag, INT32);
|
||||
if (__ODD(tag)) {
|
||||
if (freesize > 0) {
|
||||
start = adr - freesize;
|
||||
__PUT(start, start + 4, int32);
|
||||
__PUT(start + 4, freesize, int32);
|
||||
__PUT(start + 8, -4, int32);
|
||||
__PUT(start, start + 4, INT32);
|
||||
__PUT(start + 4, freesize, INT32);
|
||||
__PUT(start + 8, -4, INT32);
|
||||
i = __ASHR(freesize, 4);
|
||||
freesize = 0;
|
||||
if (i < 9) {
|
||||
__PUT(start + 12, Heap_freeList[i], int32);
|
||||
__PUT(start + 12, Heap_freeList[i], INT32);
|
||||
Heap_freeList[i] = start;
|
||||
} else {
|
||||
__PUT(start + 12, Heap_bigBlocks, int32);
|
||||
__PUT(start + 12, Heap_bigBlocks, INT32);
|
||||
Heap_bigBlocks = start;
|
||||
}
|
||||
}
|
||||
tag -= 1;
|
||||
__PUT(adr, tag, int32);
|
||||
__GET(tag, size, int32);
|
||||
__PUT(adr, tag, INT32);
|
||||
__GET(tag, size, INT32);
|
||||
Heap_allocated += size;
|
||||
adr += size;
|
||||
} else {
|
||||
__GET(tag, size, int32);
|
||||
__GET(tag, size, INT32);
|
||||
freesize += size;
|
||||
adr += size;
|
||||
}
|
||||
}
|
||||
if (freesize > 0) {
|
||||
start = adr - freesize;
|
||||
__PUT(start, start + 4, int32);
|
||||
__PUT(start + 4, freesize, int32);
|
||||
__PUT(start + 8, -4, int32);
|
||||
__PUT(start, start + 4, INT32);
|
||||
__PUT(start + 4, freesize, INT32);
|
||||
__PUT(start + 8, -4, INT32);
|
||||
i = __ASHR(freesize, 4);
|
||||
freesize = 0;
|
||||
if (i < 9) {
|
||||
__PUT(start + 12, Heap_freeList[i], int32);
|
||||
__PUT(start + 12, Heap_freeList[i], INT32);
|
||||
Heap_freeList[i] = start;
|
||||
} else {
|
||||
__PUT(start + 12, Heap_bigBlocks, int32);
|
||||
__PUT(start + 12, Heap_bigBlocks, INT32);
|
||||
Heap_bigBlocks = start;
|
||||
}
|
||||
}
|
||||
__GET(chnk, chnk, int32);
|
||||
__GET(chnk, chnk, INT32);
|
||||
}
|
||||
}
|
||||
|
||||
static void Heap_Sift (int32 l, int32 r, int32 *a, LONGINT a__len)
|
||||
static void Heap_Sift (INT32 l, INT32 r, INT32 *a, LONGINT a__len)
|
||||
{
|
||||
int32 i, j, x;
|
||||
INT32 i, j, x;
|
||||
j = l;
|
||||
x = a[j];
|
||||
for (;;) {
|
||||
|
|
@ -464,9 +464,9 @@ static void Heap_Sift (int32 l, int32 r, int32 *a, LONGINT a__len)
|
|||
a[i] = x;
|
||||
}
|
||||
|
||||
static void Heap_HeapSort (int32 n, int32 *a, LONGINT a__len)
|
||||
static void Heap_HeapSort (INT32 n, INT32 *a, LONGINT a__len)
|
||||
{
|
||||
int32 l, r, x;
|
||||
INT32 l, r, x;
|
||||
l = __ASHR(n, 1);
|
||||
r = n - 1;
|
||||
while (l > 0) {
|
||||
|
|
@ -482,25 +482,25 @@ static void Heap_HeapSort (int32 n, int32 *a, LONGINT a__len)
|
|||
}
|
||||
}
|
||||
|
||||
static void Heap_MarkCandidates (int32 n, int32 *cand, LONGINT cand__len)
|
||||
static void Heap_MarkCandidates (INT32 n, INT32 *cand, LONGINT cand__len)
|
||||
{
|
||||
int32 chnk, adr, tag, next, lim, lim1, i, ptr, size;
|
||||
INT32 chnk, adr, tag, next, lim, lim1, i, ptr, size;
|
||||
chnk = Heap_heap;
|
||||
i = 0;
|
||||
lim = cand[n - 1];
|
||||
while ((chnk != 0 && chnk < lim)) {
|
||||
adr = chnk + 12;
|
||||
__GET(chnk + 4, lim1, int32);
|
||||
__GET(chnk + 4, lim1, INT32);
|
||||
if (lim < lim1) {
|
||||
lim1 = lim;
|
||||
}
|
||||
while (adr < lim1) {
|
||||
__GET(adr, tag, int32);
|
||||
__GET(adr, tag, INT32);
|
||||
if (__ODD(tag)) {
|
||||
__GET(tag - 1, size, int32);
|
||||
__GET(tag - 1, size, INT32);
|
||||
adr += size;
|
||||
} else {
|
||||
__GET(tag, size, int32);
|
||||
__GET(tag, size, INT32);
|
||||
ptr = adr + 4;
|
||||
while (cand[i] < ptr) {
|
||||
i += 1;
|
||||
|
|
@ -515,17 +515,17 @@ static void Heap_MarkCandidates (int32 n, int32 *cand, LONGINT cand__len)
|
|||
adr = next;
|
||||
}
|
||||
}
|
||||
__GET(chnk, chnk, int32);
|
||||
__GET(chnk, chnk, INT32);
|
||||
}
|
||||
}
|
||||
|
||||
static void Heap_CheckFin (void)
|
||||
{
|
||||
Heap_FinNode n;
|
||||
int32 tag;
|
||||
INT32 tag;
|
||||
n = Heap_fin;
|
||||
while (n != NIL) {
|
||||
__GET(n->obj - 4, tag, int32);
|
||||
__GET(n->obj - 4, tag, INT32);
|
||||
if (!__ODD(tag)) {
|
||||
n->marked = 0;
|
||||
Heap_Mark(n->obj);
|
||||
|
|
@ -571,10 +571,10 @@ void Heap_FINALL (void)
|
|||
}
|
||||
}
|
||||
|
||||
static void Heap_MarkStack (int32 n, int32 *cand, LONGINT cand__len)
|
||||
static void Heap_MarkStack (INT32 n, INT32 *cand, LONGINT cand__len)
|
||||
{
|
||||
SYSTEM_PTR frame;
|
||||
int32 inc, nofcand, sp, p, stack0;
|
||||
INT32 inc, nofcand, sp, p, stack0;
|
||||
struct Heap__1 align;
|
||||
if (n > 0) {
|
||||
Heap_MarkStack(n - 1, cand, cand__len);
|
||||
|
|
@ -591,7 +591,7 @@ static void Heap_MarkStack (int32 n, int32 *cand, LONGINT cand__len)
|
|||
inc = -inc;
|
||||
}
|
||||
while (sp != stack0) {
|
||||
__GET(sp, p, int32);
|
||||
__GET(sp, p, INT32);
|
||||
if ((p > Heap_heap && p < Heap_heapend)) {
|
||||
if (nofcand == cand__len) {
|
||||
Heap_HeapSort(nofcand, (void*)cand, cand__len);
|
||||
|
|
@ -613,8 +613,8 @@ static void Heap_MarkStack (int32 n, int32 *cand, LONGINT cand__len)
|
|||
void Heap_GC (BOOLEAN markStack)
|
||||
{
|
||||
Heap_Module m;
|
||||
int32 i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23;
|
||||
int32 cand[10000];
|
||||
INT32 i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23;
|
||||
INT32 cand[10000];
|
||||
if (Heap_lockdepth == 0 || (Heap_lockdepth == 1 && !markStack)) {
|
||||
Heap_Lock();
|
||||
m = (Heap_Module)(address)Heap_modules;
|
||||
|
|
@ -694,7 +694,7 @@ void Heap_RegisterFinalizer (SYSTEM_PTR obj, Heap_Finalizer finalize)
|
|||
{
|
||||
Heap_FinNode f;
|
||||
__NEW(f, Heap_FinDesc);
|
||||
f->obj = (int32)(address)obj;
|
||||
f->obj = (INT32)(address)obj;
|
||||
f->finalize = finalize;
|
||||
f->marked = 1;
|
||||
f->next = Heap_fin;
|
||||
|
|
@ -704,8 +704,8 @@ void Heap_RegisterFinalizer (SYSTEM_PTR obj, Heap_Finalizer finalize)
|
|||
void Heap_InitHeap (void)
|
||||
{
|
||||
Heap_heap = Heap_NewChunk(128000);
|
||||
__GET(Heap_heap + 4, Heap_heapend, int32);
|
||||
__PUT(Heap_heap, 0, int32);
|
||||
__GET(Heap_heap + 4, Heap_heapend, INT32);
|
||||
__PUT(Heap_heap, 0, INT32);
|
||||
Heap_allocated = 0;
|
||||
Heap_firstTry = 1;
|
||||
Heap_freeList[9] = 1;
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue