From 65a770e91f2fc8e0857598314d38628b495968c4 Mon Sep 17 00:00:00 2001 From: Richard Brooksby Date: Tue, 19 Apr 2016 22:29:57 +0100 Subject: [PATCH] Avoid using "class" as an identifier, since tools like lldb parse expressions as c++, and it can't be named. Copied from Perforce Change: 191304 ServerID: perforce.ravenbrook.com --- mps/code/arena.c | 92 +++++++++++++------------- mps/code/arenacl.c | 22 +++---- mps/code/arenacv.c | 8 +-- mps/code/arenavm.c | 28 ++++---- mps/code/buffer.c | 116 ++++++++++++++++----------------- mps/code/cbs.c | 46 ++++++------- mps/code/check.h | 26 ++++---- mps/code/dbgpool.c | 40 ++++++------ mps/code/dbgpool.h | 2 +- mps/code/eventrep.c | 2 +- mps/code/failover.c | 28 ++++---- mps/code/finaltest.c | 4 +- mps/code/fmtdy.c | 10 +-- mps/code/format.c | 4 +- mps/code/fotest.c | 10 +-- mps/code/freelist.c | 30 ++++----- mps/code/land.c | 90 +++++++++++++------------- mps/code/locus.c | 6 +- mps/code/locus.h | 2 +- mps/code/message.c | 58 ++++++++--------- mps/code/messtest.c | 4 +- mps/code/mpm.h | 40 ++++++------ mps/code/mpmst.h | 4 +- mps/code/mpmtypes.h | 2 +- mps/code/pool.c | 96 +++++++++++++-------------- mps/code/poolabs.c | 150 +++++++++++++++++++++---------------------- mps/code/poolamc.c | 96 +++++++++++++-------------- mps/code/poolams.c | 84 ++++++++++++------------ mps/code/poolams.h | 2 +- mps/code/poolawl.c | 60 ++++++++--------- mps/code/poollo.c | 52 +++++++-------- mps/code/poolmfs.c | 28 ++++---- mps/code/poolmrg.c | 46 ++++++------- mps/code/poolmv.c | 40 ++++++------ mps/code/poolmv2.c | 32 ++++----- mps/code/poolmvff.c | 46 ++++++------- mps/code/pooln.c | 46 ++++++------- mps/code/poolncv.c | 4 +- mps/code/poolsnc.c | 58 ++++++++--------- mps/code/protocol.c | 74 ++++++++++----------- mps/code/protocol.h | 96 +++++++++++++-------------- mps/code/seg.c | 150 +++++++++++++++++++++---------------------- mps/code/segsmss.c | 34 +++++----- 43 files changed, 934 insertions(+), 934 deletions(-) diff --git a/mps/code/arena.c b/mps/code/arena.c index 6ca6a604f22..3ed4c7b5b5d 100644 --- a/mps/code/arena.c +++ b/mps/code/arena.c @@ -121,57 +121,57 @@ static void ArenaNoDestroy(Arena arena) NOTREACHED; } -DEFINE_CLASS(Inst, ArenaClass, class) +DEFINE_CLASS(Inst, ArenaClass, klass) { - INHERIT_CLASS(class, ArenaClass, InstClass); + INHERIT_CLASS(klass, ArenaClass, InstClass); } /* AbstractArenaClass -- The abstract arena class definition */ -DEFINE_CLASS(Arena, AbstractArena, class) +DEFINE_CLASS(Arena, AbstractArena, klass) { - INHERIT_CLASS(&class->protocol, AbstractArena, Inst); - class->size = sizeof(ArenaStruct); - class->varargs = ArgTrivVarargs; - class->init = ArenaAbsInit; - class->finish = ArenaAbsFinish; - class->create = ArenaNoCreate; - class->destroy = ArenaNoDestroy; - class->purgeSpare = ArenaNoPurgeSpare; - class->extend = ArenaNoExtend; - class->grow = ArenaNoGrow; - class->free = ArenaNoFree; - class->chunkInit = ArenaNoChunkInit; - class->chunkFinish = ArenaNoChunkFinish; - class->compact = ArenaTrivCompact; - class->describe = ArenaTrivDescribe; - class->pagesMarkAllocated = ArenaNoPagesMarkAllocated; - class->sig = ArenaClassSig; + INHERIT_CLASS(&klass->protocol, AbstractArena, Inst); + klass->size = sizeof(ArenaStruct); + klass->varargs = ArgTrivVarargs; + klass->init = ArenaAbsInit; + klass->finish = ArenaAbsFinish; + klass->create = ArenaNoCreate; + klass->destroy = ArenaNoDestroy; + klass->purgeSpare = ArenaNoPurgeSpare; + klass->extend = ArenaNoExtend; + klass->grow = ArenaNoGrow; + klass->free = ArenaNoFree; + klass->chunkInit = ArenaNoChunkInit; + klass->chunkFinish = ArenaNoChunkFinish; + klass->compact = ArenaTrivCompact; + klass->describe = ArenaTrivDescribe; + klass->pagesMarkAllocated = ArenaNoPagesMarkAllocated; + klass->sig = ArenaClassSig; } /* ArenaClassCheck -- check the consistency of an arena class */ -Bool ArenaClassCheck(ArenaClass class) +Bool ArenaClassCheck(ArenaClass klass) { - CHECKD(InstClass, &class->protocol); - CHECKL(class->size >= sizeof(ArenaStruct)); - CHECKL(FUNCHECK(class->varargs)); - CHECKL(FUNCHECK(class->init)); - CHECKL(FUNCHECK(class->finish)); - CHECKL(FUNCHECK(class->create)); - CHECKL(FUNCHECK(class->destroy)); - CHECKL(FUNCHECK(class->purgeSpare)); - CHECKL(FUNCHECK(class->extend)); - CHECKL(FUNCHECK(class->grow)); - CHECKL(FUNCHECK(class->free)); - CHECKL(FUNCHECK(class->chunkInit)); - CHECKL(FUNCHECK(class->chunkFinish)); - CHECKL(FUNCHECK(class->compact)); - CHECKL(FUNCHECK(class->describe)); - CHECKL(FUNCHECK(class->pagesMarkAllocated)); - CHECKS(ArenaClass, class); + CHECKD(InstClass, &klass->protocol); + CHECKL(klass->size >= sizeof(ArenaStruct)); + CHECKL(FUNCHECK(klass->varargs)); + CHECKL(FUNCHECK(klass->init)); + CHECKL(FUNCHECK(klass->finish)); + CHECKL(FUNCHECK(klass->create)); + CHECKL(FUNCHECK(klass->destroy)); + CHECKL(FUNCHECK(klass->purgeSpare)); + CHECKL(FUNCHECK(klass->extend)); + CHECKL(FUNCHECK(klass->grow)); + CHECKL(FUNCHECK(klass->free)); + CHECKL(FUNCHECK(klass->chunkInit)); + CHECKL(FUNCHECK(klass->chunkFinish)); + CHECKL(FUNCHECK(klass->compact)); + CHECKL(FUNCHECK(klass->describe)); + CHECKL(FUNCHECK(klass->pagesMarkAllocated)); + CHECKS(ArenaClass, klass); return TRUE; } @@ -379,13 +379,13 @@ failLandInit: return res; } -Res ArenaCreate(Arena *arenaReturn, ArenaClass class, ArgList args) +Res ArenaCreate(Arena *arenaReturn, ArenaClass klass, ArgList args) { Arena arena; Res res; AVER(arenaReturn != NULL); - AVERT(ArenaClass, class); + AVERT(ArenaClass, klass); AVERT(ArgList, args); /* We must initialise the event subsystem very early, because event logging @@ -393,14 +393,14 @@ Res ArenaCreate(Arena *arenaReturn, ArenaClass class, ArgList args) to the EventLast pointers. */ EventInit(); - res = class->create(&arena, args); + res = klass->create(&arena, args); if (res != ResOK) goto failInit; /* TODO: Consider how each of the stages below could be incorporated into arena initialization, rather than tacked on here. */ - /* Grain size must have been set up by class->create() */ + /* Grain size must have been set up by klass->create() */ if (ArenaGrainSize(arena) > ((Size)1 << arena->zoneShift)) { res = ResMEMORY; /* size was too small */ goto failStripeSize; @@ -428,7 +428,7 @@ failControlInit: arenaFreeLandFinish(arena); failFreeLandInit: failStripeSize: - class->destroy(arena); + klass->destroy(arena); failInit: return res; } @@ -541,17 +541,17 @@ void ControlFinish(Arena arena) Res ArenaDescribe(Arena arena, mps_lib_FILE *stream, Count depth) { Res res; - ArenaClass class; + ArenaClass klass; if (!TESTC(AbstractArena, arena)) return ResPARAM; if (stream == NULL) return ResPARAM; - class = ClassOfPoly(Arena, arena); + klass = ClassOfPoly(Arena, arena); res = WriteF(stream, depth, "Arena $P {\n", (WriteFP)arena, " class $P (\"$S\")\n", - (WriteFP)class, (WriteFS)ClassName(class), + (WriteFP)klass, (WriteFS)ClassName(klass), NULL); if (res != ResOK) return res; diff --git a/mps/code/arenacl.c b/mps/code/arenacl.c index 283c562e7c2..97b3b757929 100644 --- a/mps/code/arenacl.c +++ b/mps/code/arenacl.c @@ -431,18 +431,18 @@ static void ClientArenaFree(Addr base, Size size, Pool pool) /* ClientArenaClass -- The Client arena class definition */ -DEFINE_CLASS(Arena, ClientArena, this) +DEFINE_CLASS(Arena, ClientArena, klass) { - INHERIT_CLASS(this, ClientArena, AbstractArena); - this->size = sizeof(ClientArenaStruct); - this->varargs = ClientArenaVarargs; - this->create = ClientArenaCreate; - this->destroy = ClientArenaDestroy; - this->extend = ClientArenaExtend; - this->pagesMarkAllocated = ClientArenaPagesMarkAllocated; - this->free = ClientArenaFree; - this->chunkInit = ClientChunkInit; - this->chunkFinish = ClientChunkFinish; + INHERIT_CLASS(klass, ClientArena, AbstractArena); + klass->size = sizeof(ClientArenaStruct); + klass->varargs = ClientArenaVarargs; + klass->create = ClientArenaCreate; + klass->destroy = ClientArenaDestroy; + klass->extend = ClientArenaExtend; + klass->pagesMarkAllocated = ClientArenaPagesMarkAllocated; + klass->free = ClientArenaFree; + klass->chunkInit = ClientChunkInit; + klass->chunkFinish = ClientChunkFinish; } diff --git a/mps/code/arenacv.c b/mps/code/arenacv.c index c8420503385..4f7e0dc05dd 100644 --- a/mps/code/arenacv.c +++ b/mps/code/arenacv.c @@ -402,7 +402,7 @@ static void testAllocAndIterate(Arena arena, Pool pool, } -static void testPageTable(ArenaClass class, Size size, Addr addr, Bool zoned) +static void testPageTable(ArenaClass klass, Size size, Addr addr, Bool zoned) { Arena arena; Pool pool; Size pageSize; @@ -412,7 +412,7 @@ static void testPageTable(ArenaClass class, Size size, Addr addr, Bool zoned) MPS_ARGS_ADD(args, MPS_KEY_ARENA_SIZE, size); MPS_ARGS_ADD(args, MPS_KEY_ARENA_CL_BASE, addr); MPS_ARGS_ADD(args, MPS_KEY_ARENA_ZONED, zoned); - die(ArenaCreate(&arena, class, args), "ArenaCreate"); + die(ArenaCreate(&arena, klass, args), "ArenaCreate"); } MPS_ARGS_END(args); die(PoolCreate(&pool, arena, PoolClassMV(), argsNone), "PoolCreate"); @@ -446,14 +446,14 @@ static void testPageTable(ArenaClass class, Size size, Addr addr, Bool zoned) static void testSize(Size size) { - ArenaClass class = (ArenaClass)mps_arena_class_vm(); + ArenaClass klass = (ArenaClass)mps_arena_class_vm(); Arena arena; Res res; do { MPS_ARGS_BEGIN(args) { MPS_ARGS_ADD(args, MPS_KEY_ARENA_SIZE, size); - res = ArenaCreate(&arena, class, args); + res = ArenaCreate(&arena, klass, args); } MPS_ARGS_END(args); if (res == ResOK) ArenaDestroy(arena); diff --git a/mps/code/arenavm.c b/mps/code/arenavm.c index a715b9df339..dfa54d457bd 100644 --- a/mps/code/arenavm.c +++ b/mps/code/arenavm.c @@ -1182,21 +1182,21 @@ mps_res_t mps_arena_vm_growth(mps_arena_t mps_arena, /* VMArenaClass -- The VM arena class definition */ -DEFINE_CLASS(Arena, VMArena, this) +DEFINE_CLASS(Arena, VMArena, klass) { - INHERIT_CLASS(this, VMArena, AbstractArena); - this->size = sizeof(VMArenaStruct); - this->varargs = VMArenaVarargs; - this->create = VMArenaCreate; - this->destroy = VMArenaDestroy; - this->purgeSpare = VMPurgeSpare; - this->grow = VMArenaGrow; - this->free = VMFree; - this->chunkInit = VMChunkInit; - this->chunkFinish = VMChunkFinish; - this->compact = VMCompact; - this->describe = VMArenaDescribe; - this->pagesMarkAllocated = VMPagesMarkAllocated; + INHERIT_CLASS(klass, VMArena, AbstractArena); + klass->size = sizeof(VMArenaStruct); + klass->varargs = VMArenaVarargs; + klass->create = VMArenaCreate; + klass->destroy = VMArenaDestroy; + klass->purgeSpare = VMPurgeSpare; + klass->grow = VMArenaGrow; + klass->free = VMFree; + klass->chunkInit = VMChunkInit; + klass->chunkFinish = VMChunkFinish; + klass->compact = VMCompact; + klass->describe = VMArenaDescribe; + klass->pagesMarkAllocated = VMPagesMarkAllocated; } diff --git a/mps/code/buffer.c b/mps/code/buffer.c index 66a0040023c..779d31e448b 100644 --- a/mps/code/buffer.c +++ b/mps/code/buffer.c @@ -122,20 +122,20 @@ Bool BufferCheck(Buffer buffer) Res BufferDescribe(Buffer buffer, mps_lib_FILE *stream, Count depth) { Res res; - BufferClass class; + BufferClass klass; if (!TESTC(Buffer, buffer)) return ResPARAM; if (stream == NULL) return ResPARAM; - class = ClassOfPoly(Buffer, buffer); + klass = ClassOfPoly(Buffer, buffer); res = WriteF(stream, depth, "Buffer $P ($U) {\n", (WriteFP)buffer, (WriteFU)buffer->serial, " class $P (\"$S\")\n", - (WriteFP)class, (WriteFS)ClassName(class), + (WriteFP)klass, (WriteFS)ClassName(klass), " Arena $P\n", (WriteFP)buffer->arena, " Pool $P\n", (WriteFP)buffer->pool, " ", buffer->isMutator ? "Mutator" : "Internal", " Buffer\n", @@ -228,11 +228,11 @@ static Res BufferAbsInit(Buffer buffer, Pool pool, Bool isMutator, ArgList args) return ResOK; } -static Res BufferInit(Buffer buffer, BufferClass class, +static Res BufferInit(Buffer buffer, BufferClass klass, Pool pool, Bool isMutator, ArgList args) { - AVERT(BufferClass, class); - return class->init(buffer, pool, isMutator, args); + AVERT(BufferClass, klass); + return klass->init(buffer, pool, isMutator, args); } @@ -241,7 +241,7 @@ static Res BufferInit(Buffer buffer, BufferClass class, * See . */ -Res BufferCreate(Buffer *bufferReturn, BufferClass class, +Res BufferCreate(Buffer *bufferReturn, BufferClass klass, Pool pool, Bool isMutator, ArgList args) { Res res; @@ -250,19 +250,19 @@ Res BufferCreate(Buffer *bufferReturn, BufferClass class, void *p; AVER(bufferReturn != NULL); - AVERT(BufferClass, class); + AVERT(BufferClass, klass); AVERT(Pool, pool); arena = PoolArena(pool); /* Allocate memory for the buffer descriptor structure. */ - res = ControlAlloc(&p, arena, class->size); + res = ControlAlloc(&p, arena, klass->size); if (res != ResOK) goto failAlloc; buffer = p; /* Initialize the buffer descriptor structure. */ - res = BufferInit(buffer, class, pool, isMutator, args); + res = BufferInit(buffer, klass, pool, isMutator, args); if (res != ResOK) goto failInit; @@ -270,7 +270,7 @@ Res BufferCreate(Buffer *bufferReturn, BufferClass class, return ResOK; failInit: - ControlFree(arena, buffer, class->size); + ControlFree(arena, buffer, klass->size); failAlloc: return res; } @@ -731,7 +731,7 @@ Bool BufferTrip(Buffer buffer, Addr p, Size size) b = PoolFormat(&format, buffer->pool); if (b) { - clientClass = format->class(p); + clientClass = format->klass(p); } else { clientClass = (Addr)0; } @@ -1022,21 +1022,21 @@ static Res bufferTrivDescribe(Buffer buffer, mps_lib_FILE *stream, Count depth) /* BufferClassCheck -- check the consistency of a BufferClass */ -Bool BufferClassCheck(BufferClass class) +Bool BufferClassCheck(BufferClass klass) { - CHECKD(InstClass, &class->protocol); - CHECKL(class->size >= sizeof(BufferStruct)); - CHECKL(FUNCHECK(class->varargs)); - CHECKL(FUNCHECK(class->init)); - CHECKL(FUNCHECK(class->finish)); - CHECKL(FUNCHECK(class->attach)); - CHECKL(FUNCHECK(class->detach)); - CHECKL(FUNCHECK(class->seg)); - CHECKL(FUNCHECK(class->rankSet)); - CHECKL(FUNCHECK(class->setRankSet)); - CHECKL(FUNCHECK(class->reassignSeg)); - CHECKL(FUNCHECK(class->describe)); - CHECKS(BufferClass, class); + CHECKD(InstClass, &klass->protocol); + CHECKL(klass->size >= sizeof(BufferStruct)); + CHECKL(FUNCHECK(klass->varargs)); + CHECKL(FUNCHECK(klass->init)); + CHECKL(FUNCHECK(klass->finish)); + CHECKL(FUNCHECK(klass->attach)); + CHECKL(FUNCHECK(klass->detach)); + CHECKL(FUNCHECK(klass->seg)); + CHECKL(FUNCHECK(klass->rankSet)); + CHECKL(FUNCHECK(klass->setRankSet)); + CHECKL(FUNCHECK(klass->reassignSeg)); + CHECKL(FUNCHECK(klass->describe)); + CHECKS(BufferClass, klass); return TRUE; } @@ -1045,26 +1045,26 @@ Bool BufferClassCheck(BufferClass class) * * See . */ -DEFINE_CLASS(Inst, BufferClass, class) +DEFINE_CLASS(Inst, BufferClass, klass) { - INHERIT_CLASS(class, BufferClass, InstClass); + INHERIT_CLASS(klass, BufferClass, InstClass); } -DEFINE_CLASS(Buffer, Buffer, class) +DEFINE_CLASS(Buffer, Buffer, klass) { - INHERIT_CLASS(&class->protocol, Buffer, Inst); - class->size = sizeof(BufferStruct); - class->varargs = ArgTrivVarargs; - class->init = BufferAbsInit; - class->finish = BufferAbsFinish; - class->attach = bufferTrivAttach; - class->detach = bufferTrivDetach; - class->describe = bufferTrivDescribe; - class->seg = bufferNoSeg; - class->rankSet = bufferTrivRankSet; - class->setRankSet = bufferNoSetRankSet; - class->reassignSeg = bufferNoReassignSeg; - class->sig = BufferClassSig; + INHERIT_CLASS(&klass->protocol, Buffer, Inst); + klass->size = sizeof(BufferStruct); + klass->varargs = ArgTrivVarargs; + klass->init = BufferAbsInit; + klass->finish = BufferAbsFinish; + klass->attach = bufferTrivAttach; + klass->detach = bufferTrivDetach; + klass->describe = bufferTrivDescribe; + klass->seg = bufferNoSeg; + klass->rankSet = bufferTrivRankSet; + klass->setRankSet = bufferNoSetRankSet; + klass->reassignSeg = bufferNoReassignSeg; + klass->sig = BufferClassSig; } @@ -1259,19 +1259,19 @@ static Res segBufDescribe(Buffer buffer, mps_lib_FILE *stream, Count depth) * Supports an association with a single segment when attached. See * . */ -DEFINE_CLASS(Buffer, SegBuf, class) +DEFINE_CLASS(Buffer, SegBuf, klass) { - INHERIT_CLASS(class, SegBuf, Buffer); - class->size = sizeof(SegBufStruct); - class->init = segBufInit; - class->finish = segBufFinish; - class->attach = segBufAttach; - class->detach = segBufDetach; - class->describe = segBufDescribe; - class->seg = segBufSeg; - class->rankSet = segBufRankSet; - class->setRankSet = segBufSetRankSet; - class->reassignSeg = segBufReassignSeg; + INHERIT_CLASS(klass, SegBuf, Buffer); + klass->size = sizeof(SegBufStruct); + klass->init = segBufInit; + klass->finish = segBufFinish; + klass->attach = segBufAttach; + klass->detach = segBufDetach; + klass->describe = segBufDescribe; + klass->seg = segBufSeg; + klass->rankSet = segBufRankSet; + klass->setRankSet = segBufSetRankSet; + klass->reassignSeg = segBufReassignSeg; } @@ -1323,11 +1323,11 @@ static Res rankBufInit(Buffer buffer, Pool pool, Bool isMutator, ArgList args) * * Supports initialization to a rank supplied at creation time. */ -DEFINE_CLASS(Buffer, RankBuf, class) +DEFINE_CLASS(Buffer, RankBuf, klass) { - INHERIT_CLASS(class, RankBuf, SegBuf); - class->varargs = rankBufVarargs; - class->init = rankBufInit; + INHERIT_CLASS(klass, RankBuf, SegBuf); + klass->varargs = rankBufVarargs; + klass->init = rankBufInit; } diff --git a/mps/code/cbs.c b/mps/code/cbs.c index e725b4e6dcc..76148c292b1 100644 --- a/mps/code/cbs.c +++ b/mps/code/cbs.c @@ -215,7 +215,7 @@ static void cbsUpdateZonedNode(SplayTree splay, Tree tree) ARG_DEFINE_KEY(cbs_block_pool, Pool); -static Res cbsInitComm(Land land, LandClass class, +static Res cbsInitComm(Land land, LandClass klass, Arena arena, Align alignment, ArgList args, SplayUpdateNodeFunction update, Size blockStructSize) @@ -255,7 +255,7 @@ static Res cbsInitComm(Land land, LandClass class, METER_INIT(cbs->treeSearch, "size of tree", (void *)cbs); - SetClassOfPoly(land, class); + SetClassOfPoly(land, klass); cbs->sig = CBSSig; AVERC(CBS, cbs); @@ -1130,34 +1130,34 @@ static Res cbsDescribe(Land land, mps_lib_FILE *stream, Count depth) return res; } -DEFINE_CLASS(Land, CBS, class) +DEFINE_CLASS(Land, CBS, klass) { - INHERIT_CLASS(class, CBS, Land); - class->size = sizeof(CBSStruct); - class->init = cbsInit; - class->finish = cbsFinish; - class->sizeMethod = cbsSize; - class->insert = cbsInsert; - class->delete = cbsDelete; - class->iterate = cbsIterate; - class->iterateAndDelete = cbsIterateAndDelete; - class->findFirst = cbsFindFirst; - class->findLast = cbsFindLast; - class->findLargest = cbsFindLargest; - class->findInZones = cbsFindInZones; - class->describe = cbsDescribe; + INHERIT_CLASS(klass, CBS, Land); + klass->size = sizeof(CBSStruct); + klass->init = cbsInit; + klass->finish = cbsFinish; + klass->sizeMethod = cbsSize; + klass->insert = cbsInsert; + klass->delete = cbsDelete; + klass->iterate = cbsIterate; + klass->iterateAndDelete = cbsIterateAndDelete; + klass->findFirst = cbsFindFirst; + klass->findLast = cbsFindLast; + klass->findLargest = cbsFindLargest; + klass->findInZones = cbsFindInZones; + klass->describe = cbsDescribe; } -DEFINE_CLASS(Land, CBSFast, class) +DEFINE_CLASS(Land, CBSFast, klass) { - INHERIT_CLASS(class, CBSFast, CBS); - class->init = cbsInitFast; + INHERIT_CLASS(klass, CBSFast, CBS); + klass->init = cbsInitFast; } -DEFINE_CLASS(Land, CBSZoned, class) +DEFINE_CLASS(Land, CBSZoned, klass) { - INHERIT_CLASS(class, CBSZoned, CBSFast); - class->init = cbsInitZoned; + INHERIT_CLASS(klass, CBSZoned, CBSFast); + klass->init = cbsInitZoned; } diff --git a/mps/code/check.h b/mps/code/check.h index ae3feb99902..9d57678d9ea 100644 --- a/mps/code/check.h +++ b/mps/code/check.h @@ -64,9 +64,9 @@ #define ASSERT_TYPECHECK(type, val) \ ASSERT(ASSERT_ISTYPE(type, val), "TypeCheck " #type ": " #val) -#define ASSERT_ISCLASS(class, val) (class ## Check(CouldBeA(class, val))) -#define ASSERT_CLASSCHECK(class, val) \ - ASSERT(ASSERT_ISCLASS(class, val), "ClassCheck " #class ": " #val) +#define ASSERT_ISCLASS(klass, val) (klass ## Check(CouldBeA(klass, val))) +#define ASSERT_CLASSCHECK(klass, val) \ + ASSERT(ASSERT_ISCLASS(klass, val), "ClassCheck " #klass ": " #val) #define ASSERT_NULLCHECK(type, val) \ ASSERT((val) != NULL, "NullCheck " #type ": " #val) @@ -140,7 +140,7 @@ extern unsigned CheckLevel; #define AVER(cond) DISCARD(cond) #define AVERT(type, val) DISCARD(ASSERT_ISTYPE(type, val)) -#define AVERC(class, val) DISCARD(ASSERT_ISCLASS(class, val)) +#define AVERC(klass, val) DISCARD(ASSERT_ISCLASS(klass, val)) #define AVERP(cond, dflt) (DISCARD_EXP(cond), dflt) #define AVERPC(cond, condstring, dflt) (DISCARD_EXP(cond), dflt) @@ -166,7 +166,7 @@ extern unsigned CheckLevel; #define AVER_CRITICAL DISCARD #define AVERT_CRITICAL(type, val) DISCARD(ASSERT_ISTYPE(type, val)) -#define AVERC_CRITICAL(class, val) DISCARD(ASSERT_ISCLASS(class, val)) +#define AVERC_CRITICAL(klass, val) DISCARD(ASSERT_ISCLASS(klass, val)) #define AVERP_CRITICAL(cond, dflt) (DISCARD_EXP(cond), dflt) #define AVERPC_CRITICAL(cond, condstring, dflt) (DISCARD_EXP(cond), dflt) @@ -207,7 +207,7 @@ extern unsigned CheckLevel; * TODO: Does this need to be thread safe like TESTT? */ -#define TESTC(class, val) ((val) != NULL && IsA(class, val)) +#define TESTC(klass, val) ((val) != NULL && IsA(klass, val)) /* CHECKS, CHECKC -- Check Signature, Check Class @@ -217,12 +217,12 @@ extern unsigned CheckLevel; #if defined(AVER_AND_CHECK_NONE) #define CHECKS(type, val) DISCARD(TESTT(type, val)) -#define CHECKC(class, val) DISCARD(MustBeA(class, val)) +#define CHECKC(klass, val) DISCARD(MustBeA(klass, val)) #else #define CHECKS(type, val) \ ASSERT(TESTT(type, val), "SigCheck " #type ": " #val) -#define CHECKC(class, val) \ - ASSERT(TESTC(class, val), "ClassCheck " #class ": " #val) +#define CHECKC(klass, val) \ + ASSERT(TESTC(klass, val), "ClassCheck " #klass ": " #val) #endif @@ -296,10 +296,10 @@ extern unsigned CheckLevel; ASSERT_NULLCHECK(type, val), \ ASSERT_TYPECHECK(type, val)) -#define CHECKD_CLASS(class, val) \ +#define CHECKD_CLASS(klass, val) \ CHECK_BY_LEVEL(NOOP, \ - CHECKC(class, val) \ - ASSERT_CLASSCHECK(class, val)) + CHECKC(klass, val) \ + ASSERT_CLASSCHECK(klass, val)) #define CHECKU(type, val) \ CHECK_BY_LEVEL(NOOP, \ @@ -320,7 +320,7 @@ extern unsigned CheckLevel; #define CHECKL(cond) DISCARD(cond) #define CHECKD(type, val) DISCARD(TESTT(type, val)) #define CHECKD_NOSIG(type, val) DISCARD((val) != NULL) -#define CHECKD_CLASS(class, val) DISCARD((val) != NULL) +#define CHECKD_CLASS(klass, val) DISCARD((val) != NULL) #define CHECKU(type, val) DISCARD(TESTT(type, val)) #define CHECKU_NOSIG(type, val) DISCARD((val) != NULL) diff --git a/mps/code/dbgpool.c b/mps/code/dbgpool.c index abc5a7267e0..8068dc64b97 100644 --- a/mps/code/dbgpool.c +++ b/mps/code/dbgpool.c @@ -127,7 +127,7 @@ static PoolDebugOptionsStruct debugPoolOptionsDefault = { "POST", 4, "DEAD", 4, }; -static Res DebugPoolInit(Pool pool, Arena arena, PoolClass class, ArgList args) +static Res DebugPoolInit(Pool pool, Arena arena, PoolClass klass, ArgList args) { Res res; PoolDebugOptions options = &debugPoolOptionsDefault; @@ -138,7 +138,7 @@ static Res DebugPoolInit(Pool pool, Arena arena, PoolClass class, ArgList args) AVER(pool != NULL); AVERT(Arena, arena); - AVERT(PoolClass, class); + AVERT(PoolClass, klass); AVERT(ArgList, args); if (ArgPick(&arg, args, MPS_KEY_POOL_DEBUG_OPTIONS)) @@ -150,11 +150,11 @@ static Res DebugPoolInit(Pool pool, Arena arena, PoolClass class, ArgList args) /* not been published yet. */ tagInit = NULL; tagSize = 0; - res = SuperclassPoly(Pool, class)->init(pool, arena, class, args); + res = SuperclassPoly(Pool, klass)->init(pool, arena, klass, args); if (res != ResOK) return res; - SetClassOfPoly(pool, class); + SetClassOfPoly(pool, klass); debug = DebugPoolDebugMixin(pool); AVER(debug != NULL); @@ -206,7 +206,7 @@ static Res DebugPoolInit(Pool pool, Arena arena, PoolClass class, ArgList args) return ResOK; tagFail: - SuperclassPoly(Pool, class)->finish(pool); + SuperclassPoly(Pool, klass)->finish(pool); AVER(res != ResOK); return res; } @@ -217,7 +217,7 @@ tagFail: static void DebugPoolFinish(Pool pool) { PoolDebugMixin debug; - PoolClass class; + PoolClass klass; AVERT(Pool, pool); @@ -228,8 +228,8 @@ static void DebugPoolFinish(Pool pool) SplayTreeFinish(&debug->index); PoolDestroy(debug->tagPool); } - class = ClassOfPoly(Pool, pool); - SuperclassPoly(Pool, class)->finish(pool); + klass = ClassOfPoly(Pool, pool); + SuperclassPoly(Pool, klass)->finish(pool); } @@ -407,12 +407,12 @@ static Res freeCheckAlloc(Addr *aReturn, PoolDebugMixin debug, Pool pool, { Res res; Addr new; - PoolClass class; + PoolClass klass; AVER(aReturn != NULL); - class = ClassOfPoly(Pool, pool); - res = SuperclassPoly(Pool, class)->alloc(&new, pool, size); + klass = ClassOfPoly(Pool, pool); + res = SuperclassPoly(Pool, klass)->alloc(&new, pool, size); if (res != ResOK) return res; if (debug->freeSize != 0) @@ -429,11 +429,11 @@ static Res freeCheckAlloc(Addr *aReturn, PoolDebugMixin debug, Pool pool, static void freeCheckFree(PoolDebugMixin debug, Pool pool, Addr old, Size size) { - PoolClass class; + PoolClass klass; if (debug->freeSize != 0) freeSplat(debug, pool, old, AddrAdd(old, size)); - class = ClassOfPoly(Pool, pool); - SuperclassPoly(Pool, class)->free(pool, old, size); + klass = ClassOfPoly(Pool, pool); + SuperclassPoly(Pool, klass)->free(pool, old, size); } @@ -772,13 +772,13 @@ void DebugPoolCheckFreeSpace(Pool pool) /* PoolClassMixInDebug -- mix in the debug support for class init */ -void PoolClassMixInDebug(PoolClass class) +void PoolClassMixInDebug(PoolClass klass) { - /* Can't check class because it's not initialized yet */ - class->init = DebugPoolInit; - class->finish = DebugPoolFinish; - class->alloc = DebugPoolAlloc; - class->free = DebugPoolFree; + /* Can't check klass because it's not initialized yet */ + klass->init = DebugPoolInit; + klass->finish = DebugPoolFinish; + klass->alloc = DebugPoolAlloc; + klass->free = DebugPoolFree; } diff --git a/mps/code/dbgpool.h b/mps/code/dbgpool.h index e01d8c3b650..051582121b0 100644 --- a/mps/code/dbgpool.h +++ b/mps/code/dbgpool.h @@ -59,7 +59,7 @@ extern Bool PoolDebugOptionsCheck(PoolDebugOptions opt); extern Bool PoolDebugMixinCheck(PoolDebugMixin dbg); -extern void PoolClassMixInDebug(PoolClass class); +extern void PoolClassMixInDebug(PoolClass klass); extern void DebugPoolCheckFences(Pool pool); extern void DebugPoolCheckFreeSpace(Pool pool); diff --git a/mps/code/eventrep.c b/mps/code/eventrep.c index 6098e52c5bb..9f3017e28a0 100644 --- a/mps/code/eventrep.c +++ b/mps/code/eventrep.c @@ -257,7 +257,7 @@ static void poolRecreate(void *logPool, void *logArena, found = TableLookup(&entry, arenaTable, (TableKey)logArena); verify(found); va_start(args, bufferClassLevel); - eres = mps_pool_create_v(&pool, (mps_arena_t)entry, class, args); + eres = mps_pool_create_v(&pool, (mps_arena_t)entry, klass, args); verifyMPS(eres); va_end(args); rep = malloc(sizeof(poolRepStruct)); diff --git a/mps/code/failover.c b/mps/code/failover.c index 6fe92b80faf..a48a6d04f66 100644 --- a/mps/code/failover.c +++ b/mps/code/failover.c @@ -269,21 +269,21 @@ static Res failoverDescribe(Land land, mps_lib_FILE *stream, Count depth) } -DEFINE_CLASS(Land, Failover, class) +DEFINE_CLASS(Land, Failover, klass) { - INHERIT_CLASS(class, Failover, Land); - class->size = sizeof(FailoverStruct); - class->init = failoverInit; - class->finish = failoverFinish; - class->sizeMethod = failoverSize; - class->insert = failoverInsert; - class->delete = failoverDelete; - class->iterate = failoverIterate; - class->findFirst = failoverFindFirst; - class->findLast = failoverFindLast; - class->findLargest = failoverFindLargest; - class->findInZones = failoverFindInZones; - class->describe = failoverDescribe; + INHERIT_CLASS(klass, Failover, Land); + klass->size = sizeof(FailoverStruct); + klass->init = failoverInit; + klass->finish = failoverFinish; + klass->sizeMethod = failoverSize; + klass->insert = failoverInsert; + klass->delete = failoverDelete; + klass->iterate = failoverIterate; + klass->findFirst = failoverFindFirst; + klass->findLast = failoverFindLast; + klass->findLargest = failoverFindLargest; + klass->findInZones = failoverFindInZones; + klass->describe = failoverDescribe; } diff --git a/mps/code/finaltest.c b/mps/code/finaltest.c index e505ac98ae4..e262dc588b4 100644 --- a/mps/code/finaltest.c +++ b/mps/code/finaltest.c @@ -149,13 +149,13 @@ static void test_trees(int mode, const char *name, mps_arena_t arena, size_t finals = 0; size_t i; int object_alloc; - PoolClass class = ClassOfPoly(Pool, pool); + PoolClass klass = ClassOfPoly(Pool, pool); object_count = 0; printf("---- Mode %s, pool class %s, %s trees ----\n", mode == ModePARK ? "PARK" : "POLL", - ClassName(class), name); + ClassName(klass), name); mps_arena_park(arena); /* make some trees */ diff --git a/mps/code/fmtdy.c b/mps/code/fmtdy.c index 35f2c9e11cd..dee04c673a4 100644 --- a/mps/code/fmtdy.c +++ b/mps/code/fmtdy.c @@ -96,7 +96,7 @@ int dylan_wrapper_check(mps_word_t *w) mps_word_t vh; mps_word_t version; mps_word_t reserved; - mps_word_t class; + mps_word_t klass; mps_word_t fh, fl, ff; mps_word_t vb, es, vf; mps_word_t vt, t; @@ -129,8 +129,8 @@ int dylan_wrapper_check(mps_word_t *w) /* Unpack the wrapper. */ - class = w[WC]; /* class */ - unused(class); + klass = w[WC]; /* class */ + unused(klass); fh = w[WF]; /* fixed part header word */ fl = fh >> 2; /* fixed part length */ ff = fh & 3; /* fixed part format code */ @@ -152,8 +152,8 @@ int dylan_wrapper_check(mps_word_t *w) /* The second word is the class of the wrapped object. */ /* It would be good to check which pool this is in. */ - assert(class != 0); /* class exists */ - assert((class & 3) == 0); /* class is aligned */ + assert(klass != 0); /* class exists */ + assert((klass & 3) == 0); /* class is aligned */ /* The third word contains the fixed part format and length. */ /* The only illegal format is 3. Anything else is possible, although */ diff --git a/mps/code/format.c b/mps/code/format.c index 4fd62ac5e22..fadeadce489 100644 --- a/mps/code/format.c +++ b/mps/code/format.c @@ -32,7 +32,7 @@ Bool FormatCheck(Format format) CHECKL(FUNCHECK(format->move)); CHECKL(FUNCHECK(format->isMoved)); CHECKL(FUNCHECK(format->pad)); - CHECKL(FUNCHECK(format->class)); + CHECKL(FUNCHECK(format->klass)); return TRUE; } @@ -148,7 +148,7 @@ Res FormatCreate(Format *formatReturn, Arena arena, ArgList args) format->move = fmtFwd; format->isMoved = fmtIsfwd; format->pad = fmtPad; - format->class = fmtClass; + format->klass = fmtClass; format->sig = FormatSig; format->serial = arena->formatSerial; diff --git a/mps/code/fotest.c b/mps/code/fotest.c index c7029c54d58..33ec227b19a 100644 --- a/mps/code/fotest.c +++ b/mps/code/fotest.c @@ -61,12 +61,12 @@ static Res oomAlloc(Addr *pReturn, Pool pool, Size size) } DECLARE_CLASS(Pool, OOMPool, AbstractPool); -DEFINE_CLASS(Pool, OOMPool, this) +DEFINE_CLASS(Pool, OOMPool, klass) { - INHERIT_CLASS(this, OOMPool, AbstractPool); - this->alloc = oomAlloc; - this->free = PoolTrivFree; - this->size = sizeof(PoolStruct); + INHERIT_CLASS(klass, OOMPool, AbstractPool); + klass->alloc = oomAlloc; + klass->free = PoolTrivFree; + klass->size = sizeof(PoolStruct); } diff --git a/mps/code/freelist.c b/mps/code/freelist.c index f935886cc3a..7a58032f508 100644 --- a/mps/code/freelist.c +++ b/mps/code/freelist.c @@ -776,22 +776,22 @@ static Res freelistDescribe(Land land, mps_lib_FILE *stream, Count depth) } -DEFINE_CLASS(Land, Freelist, class) +DEFINE_CLASS(Land, Freelist, klass) { - INHERIT_CLASS(class, Freelist, Land); - class->size = sizeof(FreelistStruct); - class->init = freelistInit; - class->finish = freelistFinish; - class->sizeMethod = freelistSize; - class->insert = freelistInsert; - class->delete = freelistDelete; - class->iterate = freelistIterate; - class->iterateAndDelete = freelistIterateAndDelete; - class->findFirst = freelistFindFirst; - class->findLast = freelistFindLast; - class->findLargest = freelistFindLargest; - class->findInZones = freelistFindInZones; - class->describe = freelistDescribe; + INHERIT_CLASS(klass, Freelist, Land); + klass->size = sizeof(FreelistStruct); + klass->init = freelistInit; + klass->finish = freelistFinish; + klass->sizeMethod = freelistSize; + klass->insert = freelistInsert; + klass->delete = freelistDelete; + klass->iterate = freelistIterate; + klass->iterateAndDelete = freelistIterateAndDelete; + klass->findFirst = freelistFindFirst; + klass->findLast = freelistFindLast; + klass->findLargest = freelistFindLargest; + klass->findInZones = freelistFindInZones; + klass->describe = freelistDescribe; } diff --git a/mps/code/land.c b/mps/code/land.c index 1df0964a201..fa8c00d6e29 100644 --- a/mps/code/land.c +++ b/mps/code/land.c @@ -57,12 +57,12 @@ static void landLeave(Land land) Bool LandCheck(Land land) { - LandClass class; + LandClass klass; /* .enter-leave.simple */ CHECKS(Land, land); CHECKC(Land, land); - class = ClassOfPoly(Land, land); - CHECKD(LandClass, class); + klass = ClassOfPoly(Land, land); + CHECKD(LandClass, klass); CHECKU(Arena, land->arena); CHECKL(AlignCheck(land->alignment)); CHECKL(BoolCheck(land->inLand)); @@ -103,15 +103,15 @@ static void LandAbsFinish(Land land) * See */ -Res LandInit(Land land, LandClass class, Arena arena, Align alignment, void *owner, ArgList args) +Res LandInit(Land land, LandClass klass, Arena arena, Align alignment, void *owner, ArgList args) { Res res; AVER(land != NULL); - AVERT(LandClass, class); + AVERT(LandClass, klass); AVERT(Align, alignment); - res = class->init(land, arena, alignment, args); + res = klass->init(land, arena, alignment, args); if (res != ResOK) return res; @@ -126,7 +126,7 @@ Res LandInit(Land land, LandClass class, Arena arena, Align alignment, void *own * See */ -Res LandCreate(Land *landReturn, Arena arena, LandClass class, Align alignment, void *owner, ArgList args) +Res LandCreate(Land *landReturn, Arena arena, LandClass klass, Align alignment, void *owner, ArgList args) { Res res; Land land; @@ -134,14 +134,14 @@ Res LandCreate(Land *landReturn, Arena arena, LandClass class, Align alignment, AVER(landReturn != NULL); AVERT(Arena, arena); - AVERT(LandClass, class); + AVERT(LandClass, klass); - res = ControlAlloc(&p, arena, class->size); + res = ControlAlloc(&p, arena, klass->size); if (res != ResOK) goto failAlloc; land = p; - res = LandInit(land, class, arena, alignment, owner, args); + res = LandInit(land, klass, arena, alignment, owner, args); if (res != ResOK) goto failInit; @@ -149,7 +149,7 @@ Res LandCreate(Land *landReturn, Arena arena, LandClass class, Align alignment, return ResOK; failInit: - ControlFree(arena, land, class->size); + ControlFree(arena, land, klass->size); failAlloc: return res; } @@ -438,20 +438,20 @@ Bool LandFlush(Land dest, Land src) /* LandClassCheck -- check land class */ -Bool LandClassCheck(LandClass class) +Bool LandClassCheck(LandClass klass) { - CHECKL(InstClassCheck(&class->protocol)); - CHECKL(class->size >= sizeof(LandStruct)); - CHECKL(FUNCHECK(class->init)); - CHECKL(FUNCHECK(class->finish)); - CHECKL(FUNCHECK(class->insert)); - CHECKL(FUNCHECK(class->delete)); - CHECKL(FUNCHECK(class->findFirst)); - CHECKL(FUNCHECK(class->findLast)); - CHECKL(FUNCHECK(class->findLargest)); - CHECKL(FUNCHECK(class->findInZones)); - CHECKL(FUNCHECK(class->describe)); - CHECKS(LandClass, class); + CHECKL(InstClassCheck(&klass->protocol)); + CHECKL(klass->size >= sizeof(LandStruct)); + CHECKL(FUNCHECK(klass->init)); + CHECKL(FUNCHECK(klass->finish)); + CHECKL(FUNCHECK(klass->insert)); + CHECKL(FUNCHECK(klass->delete)); + CHECKL(FUNCHECK(klass->findFirst)); + CHECKL(FUNCHECK(klass->findLast)); + CHECKL(FUNCHECK(klass->findLargest)); + CHECKL(FUNCHECK(klass->findInZones)); + CHECKL(FUNCHECK(klass->describe)); + CHECKS(LandClass, klass); return TRUE; } @@ -544,7 +544,7 @@ static Res landNoFindInZones(Bool *foundReturn, Range rangeReturn, Range oldRang static Res LandAbsDescribe(Land land, mps_lib_FILE *stream, Count depth) { - LandClass class; + LandClass klass; Res res; if (!TESTC(Land, land)) @@ -556,38 +556,38 @@ static Res LandAbsDescribe(Land land, mps_lib_FILE *stream, Count depth) if (res != ResOK) return res; - class = ClassOfPoly(Land, land); + klass = ClassOfPoly(Land, land); return WriteF(stream, depth + 2, "class $P (\"$S\")\n", - (WriteFP)class, (WriteFS)ClassName(class), + (WriteFP)klass, (WriteFS)ClassName(klass), "arena $P\n", (WriteFP)land->arena, "align $U\n", (WriteFU)land->alignment, "inLand $S\n", WriteFYesNo(land->inLand), NULL); } -DEFINE_CLASS(Inst, LandClass, class) +DEFINE_CLASS(Inst, LandClass, klass) { - INHERIT_CLASS(class, LandClass, InstClass); + INHERIT_CLASS(klass, LandClass, InstClass); } -DEFINE_CLASS(Land, Land, class) +DEFINE_CLASS(Land, Land, klass) { - INHERIT_CLASS(&class->protocol, Land, Inst); - class->size = sizeof(LandStruct); - class->init = LandAbsInit; - class->sizeMethod = landNoSize; - class->finish = LandAbsFinish; - class->insert = landNoInsert; - class->delete = landNoDelete; - class->iterate = landNoIterate; - class->iterateAndDelete = landNoIterateAndDelete; - class->findFirst = landNoFind; - class->findLast = landNoFind; - class->findLargest = landNoFind; - class->findInZones = landNoFindInZones; - class->describe = LandAbsDescribe; - class->sig = LandClassSig; + INHERIT_CLASS(&klass->protocol, Land, Inst); + klass->size = sizeof(LandStruct); + klass->init = LandAbsInit; + klass->sizeMethod = landNoSize; + klass->finish = LandAbsFinish; + klass->insert = landNoInsert; + klass->delete = landNoDelete; + klass->iterate = landNoIterate; + klass->iterateAndDelete = landNoIterateAndDelete; + klass->findFirst = landNoFind; + klass->findLast = landNoFind; + klass->findLargest = landNoFind; + klass->findInZones = landNoFindInZones; + klass->describe = LandAbsDescribe; + klass->sig = LandClassSig; } diff --git a/mps/code/locus.c b/mps/code/locus.c index c368d3aa72c..e05267c5ec9 100644 --- a/mps/code/locus.c +++ b/mps/code/locus.c @@ -312,7 +312,7 @@ GenDesc ChainGen(Chain chain, Index gen) * accounting */ -Res PoolGenAlloc(Seg *segReturn, PoolGen pgen, SegClass class, Size size, +Res PoolGenAlloc(Seg *segReturn, PoolGen pgen, SegClass klass, Size size, ArgList args) { LocusPrefStruct pref; @@ -324,7 +324,7 @@ Res PoolGenAlloc(Seg *segReturn, PoolGen pgen, SegClass class, Size size, AVER(segReturn != NULL); AVERT(PoolGen, pgen); - AVERT(SegClass, class); + AVERT(SegClass, klass); AVER(size > 0); AVERT(ArgList, args); @@ -336,7 +336,7 @@ Res PoolGenAlloc(Seg *segReturn, PoolGen pgen, SegClass class, Size size, pref.high = FALSE; pref.zones = zones; pref.avoid = ZoneSetBlacklist(arena); - res = SegAlloc(&seg, class, &pref, size, pgen->pool, args); + res = SegAlloc(&seg, klass, &pref, size, pgen->pool, args); if (res != ResOK) return res; diff --git a/mps/code/locus.h b/mps/code/locus.h index 649820a1433..68211007789 100644 --- a/mps/code/locus.h +++ b/mps/code/locus.h @@ -95,7 +95,7 @@ extern Res ChainDescribe(Chain chain, mps_lib_FILE *stream, Count depth); extern Bool PoolGenCheck(PoolGen pgen); extern Res PoolGenInit(PoolGen pgen, GenDesc gen, Pool pool); extern void PoolGenFinish(PoolGen pgen); -extern Res PoolGenAlloc(Seg *segReturn, PoolGen pgen, SegClass class, +extern Res PoolGenAlloc(Seg *segReturn, PoolGen pgen, SegClass klass, Size size, ArgList args); extern void PoolGenFree(PoolGen pgen, Seg seg, Size freeSize, Size oldSize, Size newSize, Bool deferred); diff --git a/mps/code/message.c b/mps/code/message.c index 8cc78c8a9a8..51c483417e5 100644 --- a/mps/code/message.c +++ b/mps/code/message.c @@ -47,14 +47,14 @@ Bool MessageTypeCheck(MessageType type) /* See .message.clocked. Currently finalization messages are the */ /* only ones that can be numerous. */ -#define MessageIsClocked(message) ((message)->class->type \ - != MessageTypeFINALIZATION) +#define MessageIsClocked(message) \ + ((message)->klass->type != MessageTypeFINALIZATION) Bool MessageCheck(Message message) { CHECKS(Message, message); CHECKU(Arena, message->arena); - CHECKD(MessageClass, message->class); + CHECKD(MessageClass, message->klass); CHECKD_NOSIG(Ring, &message->queueRing); /* postedClock is uncheckable for clocked message types, */ /* but must be 0 for unclocked message types: */ @@ -63,32 +63,32 @@ Bool MessageCheck(Message message) return TRUE; } -Bool MessageClassCheck(MessageClass class) +Bool MessageClassCheck(MessageClass klass) { - CHECKS(MessageClass, class); - CHECKL(class->name != NULL); - CHECKL(MessageTypeCheck(class->type)); - CHECKL(FUNCHECK(class->delete)); - CHECKL(FUNCHECK(class->finalizationRef)); - CHECKL(FUNCHECK(class->gcLiveSize)); - CHECKL(FUNCHECK(class->gcCondemnedSize)); - CHECKL(FUNCHECK(class->gcNotCondemnedSize)); - CHECKL(FUNCHECK(class->gcStartWhy)); - CHECKL(class->endSig == MessageClassSig); + CHECKS(MessageClass, klass); + CHECKL(klass->name != NULL); + CHECKL(MessageTypeCheck(klass->type)); + CHECKL(FUNCHECK(klass->delete)); + CHECKL(FUNCHECK(klass->finalizationRef)); + CHECKL(FUNCHECK(klass->gcLiveSize)); + CHECKL(FUNCHECK(klass->gcCondemnedSize)); + CHECKL(FUNCHECK(klass->gcNotCondemnedSize)); + CHECKL(FUNCHECK(klass->gcStartWhy)); + CHECKL(klass->endSig == MessageClassSig); return TRUE; } -void MessageInit(Arena arena, Message message, MessageClass class, +void MessageInit(Arena arena, Message message, MessageClass klass, MessageType type) { AVERT(Arena, arena); AVER(message != NULL); - AVERT(MessageClass, class); + AVERT(MessageClass, klass); AVERT(MessageType, type); message->arena = arena; - message->class = class; + message->klass = klass; RingInit(&message->queueRing); message->postedClock = 0; message->sig = MessageSig; @@ -281,20 +281,20 @@ void MessageDiscard(Arena arena, Message message) /* Message Methods, Generic * - * (Some of these dispatch on message->class). + * (Some of these dispatch on message->klass). */ /* Return the type of a message */ MessageType MessageGetType(Message message) { - MessageClass class; + MessageClass klass; AVERT(Message, message); - class = message->class; - AVERT(MessageClass, class); + klass = message->klass; + AVERT(MessageClass, klass); - return class->type; + return klass->type; } /* Return the class of a message */ @@ -302,7 +302,7 @@ MessageClass MessageGetClass(Message message) { AVERT(Message, message); - return message->class; + return message->klass; } Clock MessageGetClock(Message message) @@ -316,7 +316,7 @@ static void MessageDelete(Message message) { AVERT(Message, message); - (*message->class->delete)(message); + (*message->klass->delete)(message); } @@ -333,7 +333,7 @@ void MessageFinalizationRef(Ref *refReturn, Arena arena, AVERT(Message, message); AVER(MessageGetType(message) == MessageTypeFINALIZATION); - (*message->class->finalizationRef)(refReturn, arena, message); + (*message->klass->finalizationRef)(refReturn, arena, message); return; } @@ -343,7 +343,7 @@ Size MessageGCLiveSize(Message message) AVERT(Message, message); AVER(MessageGetType(message) == MessageTypeGC); - return (*message->class->gcLiveSize)(message); + return (*message->klass->gcLiveSize)(message); } Size MessageGCCondemnedSize(Message message) @@ -351,7 +351,7 @@ Size MessageGCCondemnedSize(Message message) AVERT(Message, message); AVER(MessageGetType(message) == MessageTypeGC); - return (*message->class->gcCondemnedSize)(message); + return (*message->klass->gcCondemnedSize)(message); } Size MessageGCNotCondemnedSize(Message message) @@ -359,7 +359,7 @@ Size MessageGCNotCondemnedSize(Message message) AVERT(Message, message); AVER(MessageGetType(message) == MessageTypeGC); - return (*message->class->gcNotCondemnedSize)(message); + return (*message->klass->gcNotCondemnedSize)(message); } const char *MessageGCStartWhy(Message message) @@ -367,7 +367,7 @@ const char *MessageGCStartWhy(Message message) AVERT(Message, message); AVER(MessageGetType(message) == MessageTypeGCSTART); - return (*message->class->gcStartWhy)(message); + return (*message->klass->gcStartWhy)(message); } diff --git a/mps/code/messtest.c b/mps/code/messtest.c index 5090a5d4c11..1203a825072 100644 --- a/mps/code/messtest.c +++ b/mps/code/messtest.c @@ -71,7 +71,7 @@ static void topMessageType(MessageType *typeReturn, Arena arena) /* postDummyMessage -- post a dummy message */ -static void postDummyMessage(Arena arena, MessageClass class, +static void postDummyMessage(Arena arena, MessageClass klass, MessageType type) { void *p; @@ -80,7 +80,7 @@ static void postDummyMessage(Arena arena, MessageClass class, die((mps_res_t)ControlAlloc(&p, arena, sizeof(MessageStruct)), "AllocMessage"); message = (Message)p; - MessageInit(arena, message, class, type); + MessageInit(arena, message, klass, type); MessagePost(arena, message); return; } diff --git a/mps/code/mpm.h b/mps/code/mpm.h index a0551df0ef5..847b43a4613 100644 --- a/mps/code/mpm.h +++ b/mps/code/mpm.h @@ -190,9 +190,9 @@ extern char *MPSVersion(void); /* Pool Interface -- see impl.c.pool */ -extern Res PoolInit(Pool pool, Arena arena, PoolClass class, ArgList args); +extern Res PoolInit(Pool pool, Arena arena, PoolClass klass, ArgList args); extern void PoolFinish(Pool pool); -extern Bool PoolClassCheck(PoolClass class); +extern Bool PoolClassCheck(PoolClass klass); extern Bool PoolCheck(Pool pool); extern Res PoolDescribe(Pool pool, mps_lib_FILE *stream, Count depth); @@ -213,7 +213,7 @@ extern Bool PoolOfRange(Pool *poolReturn, Arena arena, Addr base, Addr limit); extern Bool PoolHasAddr(Pool pool, Addr addr); extern Bool PoolHasRange(Pool pool, Addr base, Addr limit); -extern Res PoolCreate(Pool *poolReturn, Arena arena, PoolClass class, +extern Res PoolCreate(Pool *poolReturn, Arena arena, PoolClass klass, ArgList args); extern void PoolDestroy(Pool pool); extern BufferClass PoolDefaultBufferClass(Pool pool); @@ -239,7 +239,7 @@ extern void PoolFreeWalk(Pool pool, FreeBlockVisitor f, void *p); extern Size PoolTotalSize(Pool pool); extern Size PoolFreeSize(Pool pool); -extern Res PoolAbsInit(Pool pool, Arena arena, PoolClass class, ArgList arg); +extern Res PoolAbsInit(Pool pool, Arena arena, PoolClass klass, ArgList arg); extern void PoolAbsFinish(Pool pool); extern Res PoolNoAlloc(Addr *pReturn, Pool pool, Size size); extern Res PoolTrivAlloc(Addr *pReturn, Pool pool, Size size); @@ -290,10 +290,10 @@ extern Size PoolNoSize(Pool pool); /* Abstract Pool Classes Interface -- see */ -extern void PoolClassMixInBuffer(PoolClass class); -extern void PoolClassMixInScan(PoolClass class); -extern void PoolClassMixInFormat(PoolClass class); -extern void PoolClassMixInCollect(PoolClass class); +extern void PoolClassMixInBuffer(PoolClass klass); +extern void PoolClassMixInScan(PoolClass klass); +extern void PoolClassMixInFormat(PoolClass klass); +extern void PoolClassMixInCollect(PoolClass klass); DECLARE_CLASS(Inst, PoolClass, InstClass); DECLARE_CLASS(Pool, AbstractPool, Inst); DECLARE_CLASS(Pool, AbstractBufferPool, AbstractPool); @@ -307,10 +307,10 @@ DECLARE_CLASS(Pool, AbstractCollectPool, AbstractScanPool); /* Message Interface -- see */ /* -- Internal (MPM) Interface -- functions for message originator */ extern Bool MessageCheck(Message message); -extern Bool MessageClassCheck(MessageClass class); +extern Bool MessageClassCheck(MessageClass klass); extern Bool MessageTypeCheck(MessageType type); extern void MessageInit(Arena arena, Message message, - MessageClass class, MessageType type); + MessageClass klass, MessageType type); extern void MessageFinish(Message message); extern Arena MessageArena(Message message); extern Bool MessageOnQueue(Message message); @@ -477,10 +477,10 @@ extern void TraceScanSingleRef(TraceSet ts, Rank rank, Arena arena, DECLARE_CLASS(Inst, ArenaClass, InstClass); DECLARE_CLASS(Arena, AbstractArena, Inst); -extern Bool ArenaClassCheck(ArenaClass class); +extern Bool ArenaClassCheck(ArenaClass klass); extern Bool ArenaCheck(Arena arena); -extern Res ArenaCreate(Arena *arenaReturn, ArenaClass class, ArgList args); +extern Res ArenaCreate(Arena *arenaReturn, ArenaClass klass, ArgList args); extern void ArenaDestroy(Arena arena); extern Res ArenaDescribe(Arena arena, mps_lib_FILE *stream, Count depth); extern Res ArenaDescribeTracts(Arena arena, mps_lib_FILE *stream, Count depth); @@ -654,7 +654,7 @@ extern Bool LocusCheck(Arena arena); /* Segment interface */ -extern Res SegAlloc(Seg *segReturn, SegClass class, LocusPref pref, +extern Res SegAlloc(Seg *segReturn, SegClass klass, LocusPref pref, Size size, Pool pool, ArgList args); extern void SegFree(Seg seg); @@ -675,11 +675,11 @@ extern void SegSetBuffer(Seg seg, Buffer buffer); extern Addr SegBufferScanLimit(Seg seg); extern Bool SegCheck(Seg seg); extern Bool GCSegCheck(GCSeg gcseg); -extern Bool SegClassCheck(SegClass class); +extern Bool SegClassCheck(SegClass klass); DECLARE_CLASS(Inst, SegClass, InstClass); DECLARE_CLASS(Seg, Seg, Inst); DECLARE_CLASS(Seg, GCSeg, Seg); -extern void SegClassMixInNoSplitMerge(SegClass class); +extern void SegClassMixInNoSplitMerge(SegClass klass); extern Size SegSize(Seg seg); extern Addr (SegBase)(Seg seg); @@ -712,7 +712,7 @@ extern Addr (SegLimit)(Seg seg); /* Buffer Interface -- see */ -extern Res BufferCreate(Buffer *bufferReturn, BufferClass class, +extern Res BufferCreate(Buffer *bufferReturn, BufferClass klass, Pool pool, Bool isMutator, ArgList args); extern void BufferDestroy(Buffer buffer); extern Bool BufferCheck(Buffer buffer); @@ -782,7 +782,7 @@ extern void BufferRampReset(Buffer buffer); extern Res BufferFramePush(AllocFrame *frameReturn, Buffer buffer); extern Res BufferFramePop(Buffer buffer, AllocFrame frame); -extern Bool BufferClassCheck(BufferClass class); +extern Bool BufferClassCheck(BufferClass klass); DECLARE_CLASS(Inst, BufferClass, InstClass); DECLARE_CLASS(Buffer, Buffer, Inst); DECLARE_CLASS(Buffer, SegBuf, Buffer); @@ -964,8 +964,8 @@ extern Bool LandCheck(Land land); #define LandArena(land) ((land)->arena) #define LandAlignment(land) ((land)->alignment) extern Size LandSize(Land land); -extern Res LandInit(Land land, LandClass class, Arena arena, Align alignment, void *owner, ArgList args); -extern Res LandCreate(Land *landReturn, Arena arena, LandClass class, Align alignment, void *owner, ArgList args); +extern Res LandInit(Land land, LandClass klass, Arena arena, Align alignment, void *owner, ArgList args); +extern Res LandCreate(Land *landReturn, Arena arena, LandClass klass, Align alignment, void *owner, ArgList args); extern void LandDestroy(Land land); extern void LandFinish(Land land); extern Res LandInsert(Range rangeReturn, Land land, Range range); @@ -980,7 +980,7 @@ extern Res LandDescribe(Land land, mps_lib_FILE *stream, Count depth); extern Bool LandFlush(Land dest, Land src); extern Size LandSlowSize(Land land); -extern Bool LandClassCheck(LandClass class); +extern Bool LandClassCheck(LandClass klass); DECLARE_CLASS(Inst, LandClass, InstClass); DECLARE_CLASS(Land, Land, Inst); diff --git a/mps/code/mpmst.h b/mps/code/mpmst.h index 59bffe9b97f..e1da4e7618b 100644 --- a/mps/code/mpmst.h +++ b/mps/code/mpmst.h @@ -201,7 +201,7 @@ typedef struct MessageClassStruct { typedef struct mps_message_s { Sig sig; /* */ Arena arena; /* owning arena */ - MessageClass class; /* Message Class Structure */ + MessageClass klass; /* Message Class Structure */ Clock postedClock; /* mps_clock() at post time, or 0 */ RingStruct queueRing; /* Message queue ring */ } MessageStruct; @@ -389,7 +389,7 @@ typedef struct mps_fmt_s { mps_fmt_fwd_t move; mps_fmt_isfwd_t isMoved; mps_fmt_pad_t pad; - mps_fmt_class_t class; /* pointer indicating class */ + mps_fmt_class_t klass; /* pointer indicating class */ Size headerSize; /* size of header */ } FormatStruct; diff --git a/mps/code/mpmtypes.h b/mps/code/mpmtypes.h index 82a8da5936b..281431c0947 100644 --- a/mps/code/mpmtypes.h +++ b/mps/code/mpmtypes.h @@ -187,7 +187,7 @@ typedef Res (*BufferDescribeMethod)(Buffer buffer, mps_lib_FILE *stream, Count d /* Order of types corresponds to PoolClassStruct in */ typedef void (*PoolVarargsMethod)(ArgStruct args[], va_list varargs); -typedef Res (*PoolInitMethod)(Pool pool, Arena arena, PoolClass class, ArgList args); +typedef Res (*PoolInitMethod)(Pool pool, Arena arena, PoolClass klass, ArgList args); typedef void (*PoolFinishMethod)(Pool pool); typedef Res (*PoolAllocMethod)(Addr *pReturn, Pool pool, Size size); typedef void (*PoolFreeMethod)(Pool pool, Addr old, Size size); diff --git a/mps/code/pool.c b/mps/code/pool.c index 46b7af181b1..e00cbedd236 100644 --- a/mps/code/pool.c +++ b/mps/code/pool.c @@ -35,41 +35,41 @@ SRCID(pool, "$Id$"); /* PoolClassCheck -- check a pool class */ -Bool PoolClassCheck(PoolClass class) +Bool PoolClassCheck(PoolClass klass) { - CHECKD(InstClass, &class->protocol); - CHECKL(class->size >= sizeof(PoolStruct)); - CHECKL(AttrCheck(class->attr)); - CHECKL(!(class->attr & AttrMOVINGGC) || (class->attr & AttrGC)); - CHECKL(FUNCHECK(class->varargs)); - CHECKL(FUNCHECK(class->init)); - CHECKL(FUNCHECK(class->finish)); - CHECKL(FUNCHECK(class->alloc)); - CHECKL(FUNCHECK(class->free)); - CHECKL(FUNCHECK(class->bufferFill)); - CHECKL(FUNCHECK(class->bufferEmpty)); - CHECKL(FUNCHECK(class->access)); - CHECKL(FUNCHECK(class->whiten)); - CHECKL(FUNCHECK(class->grey)); - CHECKL(FUNCHECK(class->blacken)); - CHECKL(FUNCHECK(class->scan)); - CHECKL(FUNCHECK(class->fix)); - CHECKL(FUNCHECK(class->fixEmergency)); - CHECKL(FUNCHECK(class->reclaim)); - CHECKL(FUNCHECK(class->traceEnd)); - CHECKL(FUNCHECK(class->rampBegin)); - CHECKL(FUNCHECK(class->rampEnd)); - CHECKL(FUNCHECK(class->framePush)); - CHECKL(FUNCHECK(class->framePop)); - CHECKL(FUNCHECK(class->addrObject)); - CHECKL(FUNCHECK(class->walk)); - CHECKL(FUNCHECK(class->freewalk)); - CHECKL(FUNCHECK(class->bufferClass)); - CHECKL(FUNCHECK(class->describe)); - CHECKL(FUNCHECK(class->debugMixin)); - CHECKL(FUNCHECK(class->totalSize)); - CHECKL(FUNCHECK(class->freeSize)); - CHECKS(PoolClass, class); + CHECKD(InstClass, &klass->protocol); + CHECKL(klass->size >= sizeof(PoolStruct)); + CHECKL(AttrCheck(klass->attr)); + CHECKL(!(klass->attr & AttrMOVINGGC) || (klass->attr & AttrGC)); + CHECKL(FUNCHECK(klass->varargs)); + CHECKL(FUNCHECK(klass->init)); + CHECKL(FUNCHECK(klass->finish)); + CHECKL(FUNCHECK(klass->alloc)); + CHECKL(FUNCHECK(klass->free)); + CHECKL(FUNCHECK(klass->bufferFill)); + CHECKL(FUNCHECK(klass->bufferEmpty)); + CHECKL(FUNCHECK(klass->access)); + CHECKL(FUNCHECK(klass->whiten)); + CHECKL(FUNCHECK(klass->grey)); + CHECKL(FUNCHECK(klass->blacken)); + CHECKL(FUNCHECK(klass->scan)); + CHECKL(FUNCHECK(klass->fix)); + CHECKL(FUNCHECK(klass->fixEmergency)); + CHECKL(FUNCHECK(klass->reclaim)); + CHECKL(FUNCHECK(klass->traceEnd)); + CHECKL(FUNCHECK(klass->rampBegin)); + CHECKL(FUNCHECK(klass->rampEnd)); + CHECKL(FUNCHECK(klass->framePush)); + CHECKL(FUNCHECK(klass->framePop)); + CHECKL(FUNCHECK(klass->addrObject)); + CHECKL(FUNCHECK(klass->walk)); + CHECKL(FUNCHECK(klass->freewalk)); + CHECKL(FUNCHECK(klass->bufferClass)); + CHECKL(FUNCHECK(klass->describe)); + CHECKL(FUNCHECK(klass->debugMixin)); + CHECKL(FUNCHECK(klass->totalSize)); + CHECKL(FUNCHECK(klass->freeSize)); + CHECKS(PoolClass, klass); return TRUE; } @@ -78,14 +78,14 @@ Bool PoolClassCheck(PoolClass class) Bool PoolCheck(Pool pool) { - PoolClass class; + PoolClass klass; /* Checks ordered as per struct decl in */ CHECKS(Pool, pool); CHECKC(AbstractPool, pool); /* Break modularity for checking efficiency */ CHECKL(pool->serial < ArenaGlobals(pool->arena)->poolSerial); - class = ClassOfPoly(Pool, pool); - CHECKD(PoolClass, class); + klass = ClassOfPoly(Pool, pool); + CHECKD(PoolClass, klass); CHECKU(Arena, pool->arena); CHECKD_NOSIG(Ring, &pool->arenaRing); CHECKD_NOSIG(Ring, &pool->bufferRing); @@ -121,13 +121,13 @@ ARG_DEFINE_KEY(INTERIOR, Bool); * init. See . */ -Res PoolInit(Pool pool, Arena arena, PoolClass class, ArgList args) +Res PoolInit(Pool pool, Arena arena, PoolClass klass, ArgList args) { Res res; - AVERT(PoolClass, class); + AVERT(PoolClass, klass); - res = class->init(pool, arena, class, args); + res = klass->init(pool, arena, klass, args); if (res != ResOK) return res; @@ -140,7 +140,7 @@ Res PoolInit(Pool pool, Arena arena, PoolClass class, ArgList args) /* PoolCreate: Allocate and initialise pool */ Res PoolCreate(Pool *poolReturn, Arena arena, - PoolClass class, ArgList args) + PoolClass klass, ArgList args) { Res res; Pool pool; @@ -148,17 +148,17 @@ Res PoolCreate(Pool *poolReturn, Arena arena, AVER(poolReturn != NULL); AVERT(Arena, arena); - AVERT(PoolClass, class); + AVERT(PoolClass, klass); /* .space.alloc: Allocate the pool instance structure with the size */ /* requested in the pool class. See .space.free */ - res = ControlAlloc(&base, arena, class->size); + res = ControlAlloc(&base, arena, klass->size); if (res != ResOK) goto failControlAlloc; pool = (Pool)base; /* Initialize the pool. */ - res = PoolInit(pool, arena, class, args); + res = PoolInit(pool, arena, klass, args); if (res != ResOK) goto failPoolInit; @@ -166,7 +166,7 @@ Res PoolCreate(Pool *poolReturn, Arena arena, return ResOK; failPoolInit: - ControlFree(arena, base, class->size); + ControlFree(arena, base, klass->size); failControlAlloc: return res; } @@ -472,19 +472,19 @@ Res PoolDescribe(Pool pool, mps_lib_FILE *stream, Count depth) { Res res; Ring node, nextNode; - PoolClass class; + PoolClass klass; if (!TESTC(AbstractPool, pool)) return ResPARAM; if (stream == NULL) return ResPARAM; - class = ClassOfPoly(Pool, pool); + klass = ClassOfPoly(Pool, pool); res = WriteF(stream, depth, "Pool $P ($U) {\n", (WriteFP)pool, (WriteFU)pool->serial, " class $P (\"$S\")\n", - (WriteFP)class, (WriteFS)ClassName(class), + (WriteFP)klass, (WriteFS)ClassName(klass), " arena $P ($U)\n", (WriteFP)pool->arena, (WriteFU)pool->arena->serial, " alignment $W\n", (WriteFW)pool->alignment, diff --git a/mps/code/poolabs.c b/mps/code/poolabs.c index 86d1360f272..8f1f1831d62 100644 --- a/mps/code/poolabs.c +++ b/mps/code/poolabs.c @@ -42,58 +42,58 @@ SRCID(poolabs, "$Id$"); /* PoolClassMixInBuffer -- mix in the protocol for buffer reserve / commit */ -void PoolClassMixInBuffer(PoolClass class) +void PoolClassMixInBuffer(PoolClass klass) { - /* Can't check class because it's not initialized yet */ - class->bufferFill = PoolTrivBufferFill; - class->bufferEmpty = PoolTrivBufferEmpty; + /* Can't check klass because it's not initialized yet */ + klass->bufferFill = PoolTrivBufferFill; + klass->bufferEmpty = PoolTrivBufferEmpty; /* By default, buffered pools treat frame operations as NOOPs */ - class->framePush = PoolTrivFramePush; - class->framePop = PoolTrivFramePop; - class->bufferClass = BufferClassGet; + klass->framePush = PoolTrivFramePush; + klass->framePop = PoolTrivFramePop; + klass->bufferClass = BufferClassGet; } /* PoolClassMixInScan -- mix in the protocol for scanning */ -void PoolClassMixInScan(PoolClass class) +void PoolClassMixInScan(PoolClass klass) { - /* Can't check class because it's not initialized yet */ - class->access = PoolSegAccess; - class->blacken = PoolTrivBlacken; - class->grey = PoolTrivGrey; + /* Can't check klass because it's not initialized yet */ + klass->access = PoolSegAccess; + klass->blacken = PoolTrivBlacken; + klass->grey = PoolTrivGrey; /* scan is part of the scanning protocol, but there is no useful default method */ - class->scan = PoolNoScan; + klass->scan = PoolNoScan; } /* PoolClassMixInFormat -- mix in the protocol for formatted pools */ -void PoolClassMixInFormat(PoolClass class) +void PoolClassMixInFormat(PoolClass klass) { - /* Can't check class because it's not initialized yet */ - class->attr |= AttrFMT; + /* Can't check klass because it's not initialized yet */ + klass->attr |= AttrFMT; /* walk is part of the format protocol, but there is no useful default method */ - class->walk = PoolNoWalk; + klass->walk = PoolNoWalk; } /* PoolClassMixInCollect -- mix in the protocol for GC */ -void PoolClassMixInCollect(PoolClass class) +void PoolClassMixInCollect(PoolClass klass) { - /* Can't check class because it's not initialized yet */ - class->attr |= AttrGC; - class->whiten = PoolTrivWhiten; + /* Can't check klass because it's not initialized yet */ + klass->attr |= AttrGC; + klass->whiten = PoolTrivWhiten; /* fix, fixEmergency and reclaim are part of the collection protocol, but there are no useful default methods for them */ - class->fix = PoolNoFix; - class->fixEmergency = PoolNoFix; - class->reclaim = PoolNoReclaim; - class->rampBegin = PoolTrivRampBegin; - class->rampEnd = PoolTrivRampEnd; + klass->fix = PoolNoFix; + klass->fixEmergency = PoolNoFix; + klass->reclaim = PoolNoReclaim; + klass->rampBegin = PoolTrivRampBegin; + klass->rampEnd = PoolTrivRampEnd; } @@ -104,14 +104,14 @@ void PoolClassMixInCollect(PoolClass class) static Res PoolAutoSetFix(Pool pool, ScanState ss, Seg seg, Ref *refIO); -Res PoolAbsInit(Pool pool, Arena arena, PoolClass class, ArgList args) +Res PoolAbsInit(Pool pool, Arena arena, PoolClass klass, ArgList args) { ArgStruct arg; AVER(pool != NULL); AVERT(Arena, arena); UNUSED(args); - UNUSED(class); /* used for debug pools only */ + UNUSED(klass); /* used for debug pools only */ /* Superclass init */ InstInit(CouldBeA(Inst, pool)); @@ -177,69 +177,69 @@ void PoolAbsFinish(Pool pool) EVENT1(PoolFinish, pool); } -DEFINE_CLASS(Inst, PoolClass, class) +DEFINE_CLASS(Inst, PoolClass, klass) { - INHERIT_CLASS(class, PoolClass, InstClass); + INHERIT_CLASS(klass, PoolClass, InstClass); } -DEFINE_CLASS(Pool, AbstractPool, class) +DEFINE_CLASS(Pool, AbstractPool, klass) { - INHERIT_CLASS(&class->protocol, AbstractPool, Inst); - class->size = sizeof(PoolStruct); - class->attr = 0; - class->varargs = ArgTrivVarargs; - class->init = PoolAbsInit; - class->finish = PoolAbsFinish; - class->alloc = PoolNoAlloc; - class->free = PoolNoFree; - class->bufferFill = PoolNoBufferFill; - class->bufferEmpty = PoolNoBufferEmpty; - class->access = PoolNoAccess; - class->whiten = PoolNoWhiten; - class->grey = PoolNoGrey; - class->blacken = PoolNoBlacken; - class->scan = PoolNoScan; - class->fix = PoolNoFix; - class->fixEmergency = PoolNoFix; - class->reclaim = PoolNoReclaim; - class->traceEnd = PoolTrivTraceEnd; - class->rampBegin = PoolNoRampBegin; - class->rampEnd = PoolNoRampEnd; - class->framePush = PoolNoFramePush; - class->framePop = PoolNoFramePop; - class->addrObject = PoolNoAddrObject; - class->walk = PoolNoWalk; - class->freewalk = PoolTrivFreeWalk; - class->bufferClass = PoolNoBufferClass; - class->describe = PoolTrivDescribe; - class->debugMixin = PoolNoDebugMixin; - class->totalSize = PoolNoSize; - class->freeSize = PoolNoSize; - class->sig = PoolClassSig; + INHERIT_CLASS(&klass->protocol, AbstractPool, Inst); + klass->size = sizeof(PoolStruct); + klass->attr = 0; + klass->varargs = ArgTrivVarargs; + klass->init = PoolAbsInit; + klass->finish = PoolAbsFinish; + klass->alloc = PoolNoAlloc; + klass->free = PoolNoFree; + klass->bufferFill = PoolNoBufferFill; + klass->bufferEmpty = PoolNoBufferEmpty; + klass->access = PoolNoAccess; + klass->whiten = PoolNoWhiten; + klass->grey = PoolNoGrey; + klass->blacken = PoolNoBlacken; + klass->scan = PoolNoScan; + klass->fix = PoolNoFix; + klass->fixEmergency = PoolNoFix; + klass->reclaim = PoolNoReclaim; + klass->traceEnd = PoolTrivTraceEnd; + klass->rampBegin = PoolNoRampBegin; + klass->rampEnd = PoolNoRampEnd; + klass->framePush = PoolNoFramePush; + klass->framePop = PoolNoFramePop; + klass->addrObject = PoolNoAddrObject; + klass->walk = PoolNoWalk; + klass->freewalk = PoolTrivFreeWalk; + klass->bufferClass = PoolNoBufferClass; + klass->describe = PoolTrivDescribe; + klass->debugMixin = PoolNoDebugMixin; + klass->totalSize = PoolNoSize; + klass->freeSize = PoolNoSize; + klass->sig = PoolClassSig; } -DEFINE_CLASS(Pool, AbstractBufferPool, class) +DEFINE_CLASS(Pool, AbstractBufferPool, klass) { - INHERIT_CLASS(class, AbstractBufferPool, AbstractPool); - PoolClassMixInBuffer(class); + INHERIT_CLASS(klass, AbstractBufferPool, AbstractPool); + PoolClassMixInBuffer(klass); } -DEFINE_CLASS(Pool, AbstractSegBufPool, class) +DEFINE_CLASS(Pool, AbstractSegBufPool, klass) { - INHERIT_CLASS(class, AbstractSegBufPool, AbstractBufferPool); - class->bufferClass = SegBufClassGet; + INHERIT_CLASS(klass, AbstractSegBufPool, AbstractBufferPool); + klass->bufferClass = SegBufClassGet; } -DEFINE_CLASS(Pool, AbstractScanPool, class) +DEFINE_CLASS(Pool, AbstractScanPool, klass) { - INHERIT_CLASS(class, AbstractScanPool, AbstractSegBufPool); - PoolClassMixInScan(class); + INHERIT_CLASS(klass, AbstractScanPool, AbstractSegBufPool); + PoolClassMixInScan(klass); } -DEFINE_CLASS(Pool, AbstractCollectPool, class) +DEFINE_CLASS(Pool, AbstractCollectPool, klass) { - INHERIT_CLASS(class, AbstractCollectPool, AbstractScanPool); - PoolClassMixInCollect(class); + INHERIT_CLASS(klass, AbstractCollectPool, AbstractScanPool); + PoolClassMixInCollect(klass); } diff --git a/mps/code/poolamc.c b/mps/code/poolamc.c index 3d0d0411dd9..23c9dfeb612 100644 --- a/mps/code/poolamc.c +++ b/mps/code/poolamc.c @@ -331,13 +331,13 @@ static Res AMCSegDescribe(Seg seg, mps_lib_FILE *stream, Count depth) /* amcSegClass -- Class definition for AMC segments */ -DEFINE_CLASS(Seg, amcSeg, class) +DEFINE_CLASS(Seg, amcSeg, klass) { - INHERIT_CLASS(class, amcSeg, GCSeg); - SegClassMixInNoSplitMerge(class); /* no support for this (yet) */ - class->size = sizeof(amcSegStruct); - class->init = AMCSegInit; - class->describe = AMCSegDescribe; + INHERIT_CLASS(klass, amcSeg, GCSeg); + SegClassMixInNoSplitMerge(klass); /* no support for this (yet) */ + klass->size = sizeof(amcSegStruct); + klass->init = AMCSegInit; + klass->describe = AMCSegDescribe; } @@ -522,12 +522,12 @@ static void AMCBufFinish(Buffer buffer) /* amcBufClass -- The class definition */ -DEFINE_CLASS(Buffer, amcBuf, class) +DEFINE_CLASS(Buffer, amcBuf, klass) { - INHERIT_CLASS(class, amcBuf, SegBuf); - class->size = sizeof(amcBufStruct); - class->init = AMCBufInit; - class->finish = AMCBufFinish; + INHERIT_CLASS(klass, amcBuf, SegBuf); + klass->size = sizeof(amcBufStruct); + klass->init = AMCBufInit; + klass->finish = AMCBufFinish; } @@ -682,7 +682,7 @@ static void AMCVarargs(ArgStruct args[MPS_ARGS_MAX], va_list varargs) * See . * Shared by AMCInit and AMCZinit. */ -static Res amcInitComm(Pool pool, Arena arena, PoolClass class, +static Res amcInitComm(Pool pool, Arena arena, PoolClass klass, RankSet rankSet, ArgList args) { AMC amc; @@ -699,8 +699,8 @@ static Res amcInitComm(Pool pool, Arena arena, PoolClass class, AVER(pool != NULL); AVERT(Arena, arena); AVERT(ArgList, args); - AVERT(PoolClass, class); - AVER(IsSubclass(class, AMCZPool)); + AVERT(PoolClass, klass); + AVER(IsSubclass(klass, AMCZPool)); if (ArgPick(&arg, args, MPS_KEY_CHAIN)) chain = arg.val.chain; @@ -723,7 +723,7 @@ static Res amcInitComm(Pool pool, Arena arena, PoolClass class, * assertion catches this bad case. */ AVER(largeSize >= extendBy); - res = PoolAbsInit(pool, arena, class, args); + res = PoolAbsInit(pool, arena, klass, args); if (res != ResOK) return res; amc = CouldBeA(AMCZPool, pool); @@ -755,7 +755,7 @@ static Res amcInitComm(Pool pool, Arena arena, PoolClass class, amc->extendBy = SizeArenaGrains(extendBy, arena); amc->largeSize = largeSize; - SetClassOfPoly(pool, class); + SetClassOfPoly(pool, klass); amc->sig = AMCSig; AVERC(AMCZPool, amc); @@ -810,15 +810,15 @@ failGensAlloc: specialize, but amcInitComm creates forwarding buffers that copy the rank set from the pool, making this awkward. */ -static Res AMCInit(Pool pool, Arena arena, PoolClass class, ArgList args) +static Res AMCInit(Pool pool, Arena arena, PoolClass klass, ArgList args) { - UNUSED(class); /* used for debug pools only */ + UNUSED(klass); /* used for debug pools only */ return amcInitComm(pool, arena, CLASS(AMCPool), RankSetSingle(RankEXACT), args); } -static Res AMCZInit(Pool pool, Arena arena, PoolClass class, ArgList args) +static Res AMCZInit(Pool pool, Arena arena, PoolClass klass, ArgList args) { - UNUSED(class); /* used for debug pools only */ + UNUSED(klass); /* used for debug pools only */ return amcInitComm(pool, arena, CLASS(AMCZPool), RankSetEMPTY, args); } @@ -2011,41 +2011,41 @@ static Res AMCDescribe(Pool pool, mps_lib_FILE *stream, Count depth) /* AMCZPoolClass -- the class definition */ -DEFINE_CLASS(Pool, AMCZPool, this) +DEFINE_CLASS(Pool, AMCZPool, klass) { - INHERIT_CLASS(this, AMCZPool, AbstractSegBufPool); - PoolClassMixInFormat(this); - PoolClassMixInCollect(this); - this->size = sizeof(AMCStruct); - this->attr |= AttrMOVINGGC; - this->varargs = AMCVarargs; - this->init = AMCZInit; - this->finish = AMCFinish; - this->bufferFill = AMCBufferFill; - this->bufferEmpty = AMCBufferEmpty; - this->whiten = AMCWhiten; - this->fix = AMCFix; - this->fixEmergency = AMCFixEmergency; - this->reclaim = AMCReclaim; - this->rampBegin = AMCRampBegin; - this->rampEnd = AMCRampEnd; - this->addrObject = AMCAddrObject; - this->walk = AMCWalk; - this->bufferClass = amcBufClassGet; - this->totalSize = AMCTotalSize; - this->freeSize = AMCFreeSize; - this->describe = AMCDescribe; + INHERIT_CLASS(klass, AMCZPool, AbstractSegBufPool); + PoolClassMixInFormat(klass); + PoolClassMixInCollect(klass); + klass->size = sizeof(AMCStruct); + klass->attr |= AttrMOVINGGC; + klass->varargs = AMCVarargs; + klass->init = AMCZInit; + klass->finish = AMCFinish; + klass->bufferFill = AMCBufferFill; + klass->bufferEmpty = AMCBufferEmpty; + klass->whiten = AMCWhiten; + klass->fix = AMCFix; + klass->fixEmergency = AMCFixEmergency; + klass->reclaim = AMCReclaim; + klass->rampBegin = AMCRampBegin; + klass->rampEnd = AMCRampEnd; + klass->addrObject = AMCAddrObject; + klass->walk = AMCWalk; + klass->bufferClass = amcBufClassGet; + klass->totalSize = AMCTotalSize; + klass->freeSize = AMCFreeSize; + klass->describe = AMCDescribe; } /* AMCPoolClass -- the class definition */ -DEFINE_CLASS(Pool, AMCPool, this) +DEFINE_CLASS(Pool, AMCPool, klass) { - INHERIT_CLASS(this, AMCPool, AMCZPool); - PoolClassMixInScan(this); - this->init = AMCInit; - this->scan = AMCScan; + INHERIT_CLASS(klass, AMCPool, AMCZPool); + PoolClassMixInScan(klass); + klass->init = AMCInit; + klass->scan = AMCScan; } diff --git a/mps/code/poolams.c b/mps/code/poolams.c index acf5a578875..1137c1864b3 100644 --- a/mps/code/poolams.c +++ b/mps/code/poolams.c @@ -613,16 +613,16 @@ static Res AMSSegDescribe(Seg seg, mps_lib_FILE *stream, Count depth) /* AMSSegClass -- Class definition for AMS segments */ -DEFINE_CLASS(Seg, AMSSeg, class) +DEFINE_CLASS(Seg, AMSSeg, klass) { - INHERIT_CLASS(class, AMSSeg, GCSeg); - class->size = sizeof(AMSSegStruct); - class->init = AMSSegInit; - class->finish = AMSSegFinish; - class->merge = AMSSegMerge; - class->split = AMSSegSplit; - class->describe = AMSSegDescribe; - AVERT(SegClass, class); + INHERIT_CLASS(klass, AMSSeg, GCSeg); + klass->size = sizeof(AMSSegStruct); + klass->init = AMSSegInit; + klass->finish = AMSSegFinish; + klass->merge = AMSSegMerge; + klass->split = AMSSegSplit; + klass->describe = AMSSegDescribe; + AVERT(SegClass, klass); } @@ -770,7 +770,7 @@ static void AMSDebugVarargs(ArgStruct args[MPS_ARGS_MAX], va_list varargs) ARG_DEFINE_KEY(AMS_SUPPORT_AMBIGUOUS, Bool); -static Res AMSInit(Pool pool, Arena arena, PoolClass class, ArgList args) +static Res AMSInit(Pool pool, Arena arena, PoolClass klass, ArgList args) { Res res; Chain chain; @@ -781,7 +781,7 @@ static Res AMSInit(Pool pool, Arena arena, PoolClass class, ArgList args) AVER(pool != NULL); AVERT(Arena, arena); AVERT(ArgList, args); - UNUSED(class); /* used for debug pools only */ + UNUSED(klass); /* used for debug pools only */ if (ArgPick(&arg, args, MPS_KEY_CHAIN)) chain = arg.val.chain; @@ -796,7 +796,7 @@ static Res AMSInit(Pool pool, Arena arena, PoolClass class, ArgList args) /* .ambiguous.noshare: If the pool is required to support ambiguous */ /* references, the alloc and white tables cannot be shared. */ - res = AMSInitInternal(PoolAMS(pool), arena, class, + res = AMSInitInternal(PoolAMS(pool), arena, klass, chain, gen, !supportAmbiguous, args); if (res == ResOK) { EVENT3(PoolInitAMS, pool, PoolArena(pool), pool->format); @@ -807,7 +807,7 @@ static Res AMSInit(Pool pool, Arena arena, PoolClass class, ArgList args) /* AMSInitInternal -- initialize an AMS pool, given the format and the chain */ -Res AMSInitInternal(AMS ams, Arena arena, PoolClass class, +Res AMSInitInternal(AMS ams, Arena arena, PoolClass klass, Chain chain, unsigned gen, Bool shareAllocTable, ArgList args) { @@ -818,7 +818,7 @@ Res AMSInitInternal(AMS ams, Arena arena, PoolClass class, pool = AMSPool(ams); AVERT(Arena, arena); - res = PoolAbsInit(pool, arena, class, args); + res = PoolAbsInit(pool, arena, klass, args); if (res != ResOK) goto failAbsInit; AVER(ams == CouldBeA(AMSPool, pool)); @@ -1753,29 +1753,29 @@ static Res AMSDescribe(Pool pool, mps_lib_FILE *stream, Count depth) /* contains the type definition. Hence the use */ /* of DEFINE_CLASS rather than DEFINE_POOL_CLASS */ -DEFINE_CLASS(Pool, AMSPool, this) +DEFINE_CLASS(Pool, AMSPool, klass) { - INHERIT_CLASS(this, AMSPool, AbstractCollectPool); - PoolClassMixInFormat(this); - this->size = sizeof(AMSStruct); - this->varargs = AMSVarargs; - this->init = AMSInit; - this->finish = AMSFinish; - this->bufferClass = RankBufClassGet; - this->bufferFill = AMSBufferFill; - this->bufferEmpty = AMSBufferEmpty; - this->whiten = AMSWhiten; - this->blacken = AMSBlacken; - this->scan = AMSScan; - this->fix = AMSFix; - this->fixEmergency = AMSFix; - this->reclaim = AMSReclaim; - this->walk = PoolNoWalk; /* TODO: job003738 */ - this->freewalk = AMSFreeWalk; - this->totalSize = AMSTotalSize; - this->freeSize = AMSFreeSize; - this->describe = AMSDescribe; - AVERT(PoolClass, this); + INHERIT_CLASS(klass, AMSPool, AbstractCollectPool); + PoolClassMixInFormat(klass); + klass->size = sizeof(AMSStruct); + klass->varargs = AMSVarargs; + klass->init = AMSInit; + klass->finish = AMSFinish; + klass->bufferClass = RankBufClassGet; + klass->bufferFill = AMSBufferFill; + klass->bufferEmpty = AMSBufferEmpty; + klass->whiten = AMSWhiten; + klass->blacken = AMSBlacken; + klass->scan = AMSScan; + klass->fix = AMSFix; + klass->fixEmergency = AMSFix; + klass->reclaim = AMSReclaim; + klass->walk = PoolNoWalk; /* TODO: job003738 */ + klass->freewalk = AMSFreeWalk; + klass->totalSize = AMSTotalSize; + klass->freeSize = AMSFreeSize; + klass->describe = AMSDescribe; + AVERT(PoolClass, klass); } @@ -1795,13 +1795,13 @@ static PoolDebugMixin AMSDebugMixin(Pool pool) /* AMSDebugPoolClass -- the class definition for the debug version */ -DEFINE_CLASS(Pool, AMSDebugPool, this) +DEFINE_CLASS(Pool, AMSDebugPool, klass) { - INHERIT_CLASS(this, AMSDebugPool, AMSPool); - PoolClassMixInDebug(this); - this->size = sizeof(AMSDebugStruct); - this->varargs = AMSDebugVarargs; - this->debugMixin = AMSDebugMixin; + INHERIT_CLASS(klass, AMSDebugPool, AMSPool); + PoolClassMixInDebug(klass); + klass->size = sizeof(AMSDebugStruct); + klass->varargs = AMSDebugVarargs; + klass->debugMixin = AMSDebugMixin; } diff --git a/mps/code/poolams.h b/mps/code/poolams.h index c856570624f..db01a94503f 100644 --- a/mps/code/poolams.h +++ b/mps/code/poolams.h @@ -168,7 +168,7 @@ typedef struct AMSSegStruct { /* the rest */ -extern Res AMSInitInternal(AMS ams, Arena arena, PoolClass class, +extern Res AMSInitInternal(AMS ams, Arena arena, PoolClass klass, Chain chain, unsigned gen, Bool shareAllocTable, ArgList args); extern void AMSFinish(Pool pool); diff --git a/mps/code/poolawl.c b/mps/code/poolawl.c index e136265c527..c989e1107d1 100644 --- a/mps/code/poolawl.c +++ b/mps/code/poolawl.c @@ -272,13 +272,13 @@ static void AWLSegFinish(Seg seg) /* AWLSegClass -- Class definition for AWL segments */ -DEFINE_CLASS(Seg, AWLSeg, class) +DEFINE_CLASS(Seg, AWLSeg, klass) { - INHERIT_CLASS(class, AWLSeg, GCSeg); - SegClassMixInNoSplitMerge(class); /* no support for this (yet) */ - class->size = sizeof(AWLSegStruct); - class->init = AWLSegInit; - class->finish = AWLSegFinish; + INHERIT_CLASS(klass, AWLSeg, GCSeg); + SegClassMixInNoSplitMerge(klass); /* no support for this (yet) */ + klass->size = sizeof(AWLSegStruct); + klass->init = AWLSegInit; + klass->finish = AWLSegFinish; } @@ -507,7 +507,7 @@ static Addr awlNoDependent(Addr addr) ARG_DEFINE_KEY(AWL_FIND_DEPENDENT, Fun); -static Res AWLInit(Pool pool, Arena arena, PoolClass class, ArgList args) +static Res AWLInit(Pool pool, Arena arena, PoolClass klass, ArgList args) { AWL awl; FindDependentFunction findDependent = awlNoDependent; @@ -519,7 +519,7 @@ static Res AWLInit(Pool pool, Arena arena, PoolClass class, ArgList args) AVER(pool != NULL); AVERT(Arena, arena); AVERT(ArgList, args); - UNUSED(class); /* used for debug pools only */ + UNUSED(klass); /* used for debug pools only */ if (ArgPick(&arg, args, MPS_KEY_AWL_FIND_DEPENDENT)) findDependent = (FindDependentFunction)arg.val.addr_method; @@ -532,7 +532,7 @@ static Res AWLInit(Pool pool, Arena arena, PoolClass class, ArgList args) if (ArgPick(&arg, args, MPS_KEY_GEN)) gen = arg.val.u; - res = PoolAbsInit(pool, arena, class, args); + res = PoolAbsInit(pool, arena, klass, args); if (res != ResOK) goto failAbsInit; awl = CouldBeA(AWLPool, pool); @@ -1193,28 +1193,28 @@ static Size AWLFreeSize(Pool pool) /* AWLPoolClass -- the class definition */ -DEFINE_CLASS(Pool, AWLPool, this) +DEFINE_CLASS(Pool, AWLPool, klass) { - INHERIT_CLASS(this, AWLPool, AbstractCollectPool); - PoolClassMixInFormat(this); - this->size = sizeof(AWLPoolStruct); - this->varargs = AWLVarargs; - this->init = AWLInit; - this->finish = AWLFinish; - this->bufferClass = RankBufClassGet; - this->bufferFill = AWLBufferFill; - this->bufferEmpty = AWLBufferEmpty; - this->access = AWLAccess; - this->whiten = AWLWhiten; - this->grey = AWLGrey; - this->blacken = AWLBlacken; - this->scan = AWLScan; - this->fix = AWLFix; - this->fixEmergency = AWLFix; - this->reclaim = AWLReclaim; - this->walk = AWLWalk; - this->totalSize = AWLTotalSize; - this->freeSize = AWLFreeSize; + INHERIT_CLASS(klass, AWLPool, AbstractCollectPool); + PoolClassMixInFormat(klass); + klass->size = sizeof(AWLPoolStruct); + klass->varargs = AWLVarargs; + klass->init = AWLInit; + klass->finish = AWLFinish; + klass->bufferClass = RankBufClassGet; + klass->bufferFill = AWLBufferFill; + klass->bufferEmpty = AWLBufferEmpty; + klass->access = AWLAccess; + klass->whiten = AWLWhiten; + klass->grey = AWLGrey; + klass->blacken = AWLBlacken; + klass->scan = AWLScan; + klass->fix = AWLFix; + klass->fixEmergency = AWLFix; + klass->reclaim = AWLReclaim; + klass->walk = AWLWalk; + klass->totalSize = AWLTotalSize; + klass->freeSize = AWLFreeSize; } diff --git a/mps/code/poollo.c b/mps/code/poollo.c index 4097543ed90..ec5552f1a56 100644 --- a/mps/code/poollo.c +++ b/mps/code/poollo.c @@ -66,13 +66,13 @@ static Count loSegGrains(LOSeg loseg); /* LOSegClass -- Class definition for LO segments */ -DEFINE_CLASS(Seg, LOSeg, class) +DEFINE_CLASS(Seg, LOSeg, klass) { - INHERIT_CLASS(class, LOSeg, GCSeg); - SegClassMixInNoSplitMerge(class); - class->size = sizeof(LOSegStruct); - class->init = loSegInit; - class->finish = loSegFinish; + INHERIT_CLASS(klass, LOSeg, GCSeg); + SegClassMixInNoSplitMerge(klass); + klass->size = sizeof(LOSegStruct); + klass->init = loSegInit; + klass->finish = loSegFinish; } @@ -441,7 +441,7 @@ static void LOVarargs(ArgStruct args[MPS_ARGS_MAX], va_list varargs) /* LOInit -- initialize an LO pool */ -static Res LOInit(Pool pool, Arena arena, PoolClass class, ArgList args) +static Res LOInit(Pool pool, Arena arena, PoolClass klass, ArgList args) { LO lo; Res res; @@ -452,9 +452,9 @@ static Res LOInit(Pool pool, Arena arena, PoolClass class, ArgList args) AVER(pool != NULL); AVERT(Arena, arena); AVERT(ArgList, args); - UNUSED(class); /* used for debug pools only */ + UNUSED(klass); /* used for debug pools only */ - res = PoolAbsInit(pool, arena, class, args); + res = PoolAbsInit(pool, arena, klass, args); if (res != ResOK) goto failAbsInit; lo = CouldBeA(LOPool, pool); @@ -760,24 +760,24 @@ static Size LOFreeSize(Pool pool) /* LOPoolClass -- the class definition */ -DEFINE_CLASS(Pool, LOPool, this) +DEFINE_CLASS(Pool, LOPool, klass) { - INHERIT_CLASS(this, LOPool, AbstractSegBufPool); - PoolClassMixInFormat(this); - PoolClassMixInCollect(this); - this->size = sizeof(LOStruct); - this->varargs = LOVarargs; - this->init = LOInit; - this->finish = LOFinish; - this->bufferFill = LOBufferFill; - this->bufferEmpty = LOBufferEmpty; - this->whiten = LOWhiten; - this->fix = LOFix; - this->fixEmergency = LOFix; - this->reclaim = LOReclaim; - this->walk = LOWalk; - this->totalSize = LOTotalSize; - this->freeSize = LOFreeSize; + INHERIT_CLASS(klass, LOPool, AbstractSegBufPool); + PoolClassMixInFormat(klass); + PoolClassMixInCollect(klass); + klass->size = sizeof(LOStruct); + klass->varargs = LOVarargs; + klass->init = LOInit; + klass->finish = LOFinish; + klass->bufferFill = LOBufferFill; + klass->bufferEmpty = LOBufferEmpty; + klass->whiten = LOWhiten; + klass->fix = LOFix; + klass->fixEmergency = LOFix; + klass->reclaim = LOReclaim; + klass->walk = LOWalk; + klass->totalSize = LOTotalSize; + klass->freeSize = LOFreeSize; } diff --git a/mps/code/poolmfs.c b/mps/code/poolmfs.c index aa03a24fd67..15b915fd872 100644 --- a/mps/code/poolmfs.c +++ b/mps/code/poolmfs.c @@ -79,7 +79,7 @@ static void MFSVarargs(ArgStruct args[MPS_ARGS_MAX], va_list varargs) ARG_DEFINE_KEY(MFS_UNIT_SIZE, Size); ARG_DEFINE_KEY(MFSExtendSelf, Bool); -static Res MFSInit(Pool pool, Arena arena, PoolClass class, ArgList args) +static Res MFSInit(Pool pool, Arena arena, PoolClass klass, ArgList args) { Size extendBy = MFS_EXTEND_BY_DEFAULT; Bool extendSelf = TRUE; @@ -91,7 +91,7 @@ static Res MFSInit(Pool pool, Arena arena, PoolClass class, ArgList args) AVER(pool != NULL); AVERT(Arena, arena); AVERT(ArgList, args); - UNUSED(class); /* used for debug pools only */ + UNUSED(klass); /* used for debug pools only */ ArgRequire(&arg, args, MPS_KEY_MFS_UNIT_SIZE); unitSize = arg.val.size; @@ -104,7 +104,7 @@ static Res MFSInit(Pool pool, Arena arena, PoolClass class, ArgList args) AVER(extendBy > 0); AVERT(Bool, extendSelf); - res = PoolAbsInit(pool, arena, class, args); + res = PoolAbsInit(pool, arena, klass, args); if (res != ResOK) return res; SetClassOfPoly(pool, CLASS(MFSPool)); @@ -366,18 +366,18 @@ static Res MFSDescribe(Pool pool, mps_lib_FILE *stream, Count depth) } -DEFINE_CLASS(Pool, MFSPool, this) +DEFINE_CLASS(Pool, MFSPool, klass) { - INHERIT_CLASS(this, MFSPool, AbstractPool); - this->size = sizeof(MFSStruct); - this->varargs = MFSVarargs; - this->init = MFSInit; - this->finish = MFSFinish; - this->alloc = MFSAlloc; - this->free = MFSFree; - this->totalSize = MFSTotalSize; - this->freeSize = MFSFreeSize; - this->describe = MFSDescribe; + INHERIT_CLASS(klass, MFSPool, AbstractPool); + klass->size = sizeof(MFSStruct); + klass->varargs = MFSVarargs; + klass->init = MFSInit; + klass->finish = MFSFinish; + klass->alloc = MFSAlloc; + klass->free = MFSFree; + klass->totalSize = MFSTotalSize; + klass->freeSize = MFSFreeSize; + klass->describe = MFSDescribe; } diff --git a/mps/code/poolmrg.c b/mps/code/poolmrg.c index 8e3bb0bbb4f..4d73a3f25be 100644 --- a/mps/code/poolmrg.c +++ b/mps/code/poolmrg.c @@ -298,23 +298,23 @@ static Res MRGRefSegInit(Seg seg, Pool pool, Addr base, Size size, ArgList args) /* MRGLinkSegClass -- Class definition */ -DEFINE_CLASS(Seg, MRGLinkSeg, class) +DEFINE_CLASS(Seg, MRGLinkSeg, klass) { - INHERIT_CLASS(class, MRGLinkSeg, Seg); - SegClassMixInNoSplitMerge(class); /* no support for this */ - class->size = sizeof(MRGLinkSegStruct); - class->init = MRGLinkSegInit; + INHERIT_CLASS(klass, MRGLinkSeg, Seg); + SegClassMixInNoSplitMerge(klass); /* no support for this */ + klass->size = sizeof(MRGLinkSegStruct); + klass->init = MRGLinkSegInit; } /* MRGRefSegClass -- Class definition */ -DEFINE_CLASS(Seg, MRGRefSeg, class) +DEFINE_CLASS(Seg, MRGRefSeg, klass) { - INHERIT_CLASS(class, MRGRefSeg, GCSeg); - SegClassMixInNoSplitMerge(class); /* no support for this */ - class->size = sizeof(MRGRefSegStruct); - class->init = MRGRefSegInit; + INHERIT_CLASS(klass, MRGRefSeg, GCSeg); + SegClassMixInNoSplitMerge(klass); /* no support for this */ + klass->size = sizeof(MRGRefSegStruct); + klass->init = MRGRefSegInit; } @@ -378,7 +378,7 @@ static Link MRGLinkOfRefPart(RefPart refPart, Arena arena) b = SegOfAddr(&seg, arena, (Addr)refPart); AVER(b); - AVER(SegPool(seg)->class == PoolClassMRG()); + AVER(SegPool(seg)->klass == PoolClassMRG()); refseg = Seg2RefSeg(seg); AVERT(MRGRefSeg, refseg); refPartBase = (RefPart)SegBase(seg); @@ -625,7 +625,7 @@ static Res MRGRefSegScan(ScanState ss, MRGRefSeg refseg, MRG mrg) /* MRGInit -- init method for MRG */ -static Res MRGInit(Pool pool, Arena arena, PoolClass class, ArgList args) +static Res MRGInit(Pool pool, Arena arena, PoolClass klass, ArgList args) { MRG mrg; Res res; @@ -633,10 +633,10 @@ static Res MRGInit(Pool pool, Arena arena, PoolClass class, ArgList args) AVER(pool != NULL); AVERT(ArgList, args); UNUSED(args); - UNUSED(class); /* used for debug pools only */ + UNUSED(klass); /* used for debug pools only */ /* FIXME: These lines are often repeated */ - res = PoolAbsInit(pool, arena, class, args); + res = PoolAbsInit(pool, arena, klass, args); if (res != ResOK) return res; mrg = CouldBeA(MRGPool, pool); @@ -876,16 +876,16 @@ static Res MRGScan(Bool *totalReturn, ScanState ss, Pool pool, Seg seg) } -DEFINE_CLASS(Pool, MRGPool, this) +DEFINE_CLASS(Pool, MRGPool, klass) { - INHERIT_CLASS(this, MRGPool, AbstractPool); - this->size = sizeof(MRGStruct); - this->init = MRGInit; - this->finish = MRGFinish; - this->grey = PoolTrivGrey; - this->blacken = PoolTrivBlacken; - this->scan = MRGScan; - this->describe = MRGDescribe; + INHERIT_CLASS(klass, MRGPool, AbstractPool); + klass->size = sizeof(MRGStruct); + klass->init = MRGInit; + klass->finish = MRGFinish; + klass->grey = PoolTrivGrey; + klass->blacken = PoolTrivBlacken; + klass->scan = MRGScan; + klass->describe = MRGDescribe; } diff --git a/mps/code/poolmv.c b/mps/code/poolmv.c index f11a8ac34a1..55538d65601 100644 --- a/mps/code/poolmv.c +++ b/mps/code/poolmv.c @@ -221,7 +221,7 @@ static void MVDebugVarargs(ArgStruct args[MPS_ARGS_MAX], va_list varargs) /* MVInit -- init method for class MV */ -static Res MVInit(Pool pool, Arena arena, PoolClass class, ArgList args) +static Res MVInit(Pool pool, Arena arena, PoolClass klass, ArgList args) { Align align = MV_ALIGN_DEFAULT; Size extendBy = MV_EXTEND_BY_DEFAULT; @@ -235,7 +235,7 @@ static Res MVInit(Pool pool, Arena arena, PoolClass class, ArgList args) AVERT(Arena, arena); AVER(pool != NULL); AVERT(ArgList, args); - UNUSED(class); /* used for debug pools only */ + UNUSED(klass); /* used for debug pools only */ if (ArgPick(&arg, args, MPS_KEY_ALIGN)) align = arg.val.align; @@ -254,7 +254,7 @@ static Res MVInit(Pool pool, Arena arena, PoolClass class, ArgList args) AVER(maxSize > 0); AVER(extendBy <= maxSize); - res = PoolAbsInit(pool, arena, class, args); + res = PoolAbsInit(pool, arena, klass, args); if (res != ResOK) return res; mv = CouldBeA(MVPool, pool); @@ -859,18 +859,18 @@ static Res MVDescribe(Pool pool, mps_lib_FILE *stream, Count depth) /* Pool class MV */ -DEFINE_CLASS(Pool, MVPool, this) +DEFINE_CLASS(Pool, MVPool, klass) { - INHERIT_CLASS(this, MVPool, AbstractBufferPool); - this->size = sizeof(MVStruct); - this->varargs = MVVarargs; - this->init = MVInit; - this->finish = MVFinish; - this->alloc = MVAlloc; - this->free = MVFree; - this->totalSize = MVTotalSize; - this->freeSize = MVFreeSize; - this->describe = MVDescribe; + INHERIT_CLASS(klass, MVPool, AbstractBufferPool); + klass->size = sizeof(MVStruct); + klass->varargs = MVVarargs; + klass->init = MVInit; + klass->finish = MVFinish; + klass->alloc = MVAlloc; + klass->free = MVFree; + klass->totalSize = MVTotalSize; + klass->freeSize = MVFreeSize; + klass->describe = MVDescribe; } @@ -882,13 +882,13 @@ PoolClass PoolClassMV(void) /* Pool class MVDebug */ -DEFINE_CLASS(Pool, MVDebugPool, this) +DEFINE_CLASS(Pool, MVDebugPool, klass) { - INHERIT_CLASS(this, MVDebugPool, MVPool); - PoolClassMixInDebug(this); - this->size = sizeof(MVDebugStruct); - this->varargs = MVDebugVarargs; - this->debugMixin = MVDebugMixin; + INHERIT_CLASS(klass, MVDebugPool, MVPool); + PoolClassMixInDebug(klass); + klass->size = sizeof(MVDebugStruct); + klass->varargs = MVDebugVarargs; + klass->debugMixin = MVDebugMixin; } diff --git a/mps/code/poolmv2.c b/mps/code/poolmv2.c index 99387702918..3b74ce7aa62 100644 --- a/mps/code/poolmv2.c +++ b/mps/code/poolmv2.c @@ -31,7 +31,7 @@ SRCID(poolmv2, "$Id$"); typedef struct MVTStruct *MVT; static void MVTVarargs(ArgStruct args[MPS_ARGS_MAX], va_list varargs); -static Res MVTInit(Pool pool, Arena arena, PoolClass class, ArgList arg); +static Res MVTInit(Pool pool, Arena arena, PoolClass klass, ArgList arg); static Bool MVTCheck(MVT mvt); static void MVTFinish(Pool pool); static Res MVTBufferFill(Addr *baseReturn, Addr *limitReturn, @@ -136,19 +136,19 @@ typedef struct MVTStruct } MVTStruct; -DEFINE_CLASS(Pool, MVTPool, this) +DEFINE_CLASS(Pool, MVTPool, klass) { - INHERIT_CLASS(this, MVTPool, AbstractBufferPool); - this->size = sizeof(MVTStruct); - this->varargs = MVTVarargs; - this->init = MVTInit; - this->finish = MVTFinish; - this->free = MVTFree; - this->bufferFill = MVTBufferFill; - this->bufferEmpty = MVTBufferEmpty; - this->totalSize = MVTTotalSize; - this->freeSize = MVTFreeSize; - this->describe = MVTDescribe; + INHERIT_CLASS(klass, MVTPool, AbstractBufferPool); + klass->size = sizeof(MVTStruct); + klass->varargs = MVTVarargs; + klass->init = MVTInit; + klass->finish = MVTFinish; + klass->free = MVTFree; + klass->bufferFill = MVTBufferFill; + klass->bufferEmpty = MVTBufferEmpty; + klass->totalSize = MVTTotalSize; + klass->freeSize = MVTFreeSize; + klass->describe = MVTDescribe; } /* Macros */ @@ -219,7 +219,7 @@ ARG_DEFINE_KEY(MVT_MAX_SIZE, Size); ARG_DEFINE_KEY(MVT_RESERVE_DEPTH, Count); ARG_DEFINE_KEY(MVT_FRAG_LIMIT, double); -static Res MVTInit(Pool pool, Arena arena, PoolClass class, ArgList args) +static Res MVTInit(Pool pool, Arena arena, PoolClass klass, ArgList args) { Size align = MVT_ALIGN_DEFAULT; Size minSize = MVT_MIN_SIZE_DEFAULT; @@ -236,7 +236,7 @@ static Res MVTInit(Pool pool, Arena arena, PoolClass class, ArgList args) AVER(pool != NULL); AVERT(Arena, arena); AVERT(ArgList, args); - UNUSED(class); /* used for debug pools only */ + UNUSED(klass); /* used for debug pools only */ if (ArgPick(&arg, args, MPS_KEY_ALIGN)) align = arg.val.align; @@ -277,7 +277,7 @@ static Res MVTInit(Pool pool, Arena arena, PoolClass class, ArgList args) if (abqDepth < 3) abqDepth = 3; - res = PoolAbsInit(pool, arena, class, args); + res = PoolAbsInit(pool, arena, klass, args); if (res != ResOK) goto failAbsInit; mvt = CouldBeA(MVTPool, pool); diff --git a/mps/code/poolmvff.c b/mps/code/poolmvff.c index 135b30b9bc7..f0e6635deaf 100644 --- a/mps/code/poolmvff.c +++ b/mps/code/poolmvff.c @@ -442,7 +442,7 @@ ARG_DEFINE_KEY(MVFF_SLOT_HIGH, Bool); ARG_DEFINE_KEY(MVFF_ARENA_HIGH, Bool); ARG_DEFINE_KEY(MVFF_FIRST_FIT, Bool); -static Res MVFFInit(Pool pool, Arena arena, PoolClass class, ArgList args) +static Res MVFFInit(Pool pool, Arena arena, PoolClass klass, ArgList args) { Size extendBy = MVFF_EXTEND_BY_DEFAULT; Size avgSize = MVFF_AVG_SIZE_DEFAULT; @@ -458,7 +458,7 @@ static Res MVFFInit(Pool pool, Arena arena, PoolClass class, ArgList args) AVER(pool != NULL); AVERT(Arena, arena); AVERT(ArgList, args); - UNUSED(class); /* used for debug pools only */ + UNUSED(klass); /* used for debug pools only */ /* .arg: class-specific additional arguments; see */ /* */ @@ -501,7 +501,7 @@ static Res MVFFInit(Pool pool, Arena arena, PoolClass class, ArgList args) AVERT(Bool, arenaHigh); AVERT(Bool, firstFit); - res = PoolAbsInit(pool, arena, class, args); + res = PoolAbsInit(pool, arena, klass, args); if (res != ResOK) goto failAbsInit; mvff = CouldBeA(MVFFPool, pool); @@ -721,21 +721,21 @@ static Res MVFFDescribe(Pool pool, mps_lib_FILE *stream, Count depth) } -DEFINE_CLASS(Pool, MVFFPool, this) +DEFINE_CLASS(Pool, MVFFPool, klass) { - INHERIT_CLASS(this, MVFFPool, AbstractPool); - PoolClassMixInBuffer(this); - this->size = sizeof(MVFFStruct); - this->varargs = MVFFVarargs; - this->init = MVFFInit; - this->finish = MVFFFinish; - this->alloc = MVFFAlloc; - this->free = MVFFFree; - this->bufferFill = MVFFBufferFill; - this->bufferEmpty = MVFFBufferEmpty; - this->totalSize = MVFFTotalSize; - this->freeSize = MVFFFreeSize; - this->describe = MVFFDescribe; + INHERIT_CLASS(klass, MVFFPool, AbstractPool); + PoolClassMixInBuffer(klass); + klass->size = sizeof(MVFFStruct); + klass->varargs = MVFFVarargs; + klass->init = MVFFInit; + klass->finish = MVFFFinish; + klass->alloc = MVFFAlloc; + klass->free = MVFFFree; + klass->bufferFill = MVFFBufferFill; + klass->bufferEmpty = MVFFBufferEmpty; + klass->totalSize = MVFFTotalSize; + klass->freeSize = MVFFFreeSize; + klass->describe = MVFFDescribe; } @@ -747,13 +747,13 @@ PoolClass PoolClassMVFF(void) /* Pool class MVFFDebug */ -DEFINE_CLASS(Pool, MVFFDebugPool, this) +DEFINE_CLASS(Pool, MVFFDebugPool, klass) { - INHERIT_CLASS(this, MVFFDebugPool, MVFFPool); - PoolClassMixInDebug(this); - this->size = sizeof(MVFFDebugStruct); - this->varargs = MVFFDebugVarargs; - this->debugMixin = MVFFDebugMixin; + INHERIT_CLASS(klass, MVFFDebugPool, MVFFPool); + PoolClassMixInDebug(klass); + klass->size = sizeof(MVFFDebugStruct); + klass->varargs = MVFFDebugVarargs; + klass->debugMixin = MVFFDebugMixin; } diff --git a/mps/code/pooln.c b/mps/code/pooln.c index f36b3e05819..66986dafc0d 100644 --- a/mps/code/pooln.c +++ b/mps/code/pooln.c @@ -34,7 +34,7 @@ DECLARE_CLASS(Pool, NPool, AbstractPool); /* NInit -- init method for class N */ -static Res NInit(Pool pool, Arena arena, PoolClass class, ArgList args) +static Res NInit(Pool pool, Arena arena, PoolClass klass, ArgList args) { PoolN poolN; Res res; @@ -42,10 +42,10 @@ static Res NInit(Pool pool, Arena arena, PoolClass class, ArgList args) AVER(pool != NULL); AVERT(Arena, arena); AVERT(ArgList, args); - UNUSED(class); /* used for debug pools only */ + UNUSED(klass); /* used for debug pools only */ /* FIXME: Reduce this boilerplate. */ - res = PoolAbsInit(pool, arena, class, args); + res = PoolAbsInit(pool, arena, klass, args); if (res != ResOK) goto failAbsInit; poolN = CouldBeA(NPool, pool); @@ -248,27 +248,27 @@ static void NTraceEnd(Pool pool, Trace trace) /* NPoolClass -- pool class definition for N */ -DEFINE_CLASS(Pool, NPool, this) +DEFINE_CLASS(Pool, NPool, klass) { - INHERIT_CLASS(this, NPool, AbstractPool); - this->size = sizeof(PoolNStruct); - this->attr |= AttrGC; - this->init = NInit; - this->finish = NFinish; - this->alloc = NAlloc; - this->free = NFree; - this->bufferFill = NBufferFill; - this->bufferEmpty = NBufferEmpty; - this->whiten = NWhiten; - this->grey = NGrey; - this->blacken = NBlacken; - this->scan = NScan; - this->fix = NFix; - this->fixEmergency = NFix; - this->reclaim = NReclaim; - this->traceEnd = NTraceEnd; - this->describe = NDescribe; - AVERT(PoolClass, this); + INHERIT_CLASS(klass, NPool, AbstractPool); + klass->size = sizeof(PoolNStruct); + klass->attr |= AttrGC; + klass->init = NInit; + klass->finish = NFinish; + klass->alloc = NAlloc; + klass->free = NFree; + klass->bufferFill = NBufferFill; + klass->bufferEmpty = NBufferEmpty; + klass->whiten = NWhiten; + klass->grey = NGrey; + klass->blacken = NBlacken; + klass->scan = NScan; + klass->fix = NFix; + klass->fixEmergency = NFix; + klass->reclaim = NReclaim; + klass->traceEnd = NTraceEnd; + klass->describe = NDescribe; + AVERT(PoolClass, klass); } diff --git a/mps/code/poolncv.c b/mps/code/poolncv.c index a8173246589..1f1d08ec2fc 100644 --- a/mps/code/poolncv.c +++ b/mps/code/poolncv.c @@ -13,14 +13,14 @@ #include /* printf */ -static void testit(ArenaClass class, ArgList args) +static void testit(ArenaClass klass, ArgList args) { Arena arena; Pool pool; Res res; Addr p; - die(ArenaCreate(&arena, class, args), "ArenaCreate"); + die(ArenaCreate(&arena, klass, args), "ArenaCreate"); die(PoolCreate(&pool, arena, PoolClassN(), argsNone), "PoolNCreate"); res = PoolAlloc(&p, pool, 1); diff --git a/mps/code/poolsnc.c b/mps/code/poolsnc.c index f1b745d4f9d..d7ce8d1ff03 100644 --- a/mps/code/poolsnc.c +++ b/mps/code/poolsnc.c @@ -154,12 +154,12 @@ static void SNCBufFinish(Buffer buffer) /* SNCBufClass -- The class definition */ -DEFINE_CLASS(Buffer, SNCBuf, class) +DEFINE_CLASS(Buffer, SNCBuf, klass) { - INHERIT_CLASS(class, SNCBuf, RankBuf); - class->size = sizeof(SNCBufStruct); - class->init = SNCBufInit; - class->finish = SNCBufFinish; + INHERIT_CLASS(klass, SNCBuf, RankBuf); + klass->size = sizeof(SNCBufStruct); + klass->init = SNCBufInit; + klass->finish = SNCBufFinish; } @@ -226,12 +226,12 @@ static Res sncSegInit(Seg seg, Pool pool, Addr base, Size size, ArgList args) /* SNCSegClass -- Class definition for SNC segments */ -DEFINE_CLASS(Seg, SNCSeg, class) +DEFINE_CLASS(Seg, SNCSeg, klass) { - INHERIT_CLASS(class, SNCSeg, GCSeg); - SegClassMixInNoSplitMerge(class); /* no support for this (yet) */ - class->size = sizeof(SNCSegStruct); - class->init = sncSegInit; + INHERIT_CLASS(klass, SNCSeg, GCSeg); + SegClassMixInNoSplitMerge(klass); /* no support for this (yet) */ + klass->size = sizeof(SNCSegStruct); + klass->init = sncSegInit; } @@ -347,7 +347,7 @@ static void SNCVarargs(ArgStruct args[MPS_ARGS_MAX], va_list varargs) /* SNCInit -- initialize an SNC pool */ -static Res SNCInit(Pool pool, Arena arena, PoolClass class, ArgList args) +static Res SNCInit(Pool pool, Arena arena, PoolClass klass, ArgList args) { SNC snc; Res res; @@ -355,9 +355,9 @@ static Res SNCInit(Pool pool, Arena arena, PoolClass class, ArgList args) AVER(pool != NULL); AVERT(Arena, arena); AVERT(ArgList, args); - UNUSED(class); /* used for debug pools only */ + UNUSED(klass); /* used for debug pools only */ - res = PoolAbsInit(pool, arena, class, args); + res = PoolAbsInit(pool, arena, klass, args); if (res != ResOK) return res; snc = CouldBeA(SNCPool, pool); @@ -664,23 +664,23 @@ static Size SNCFreeSize(Pool pool) /* SNCPoolClass -- the class definition */ -DEFINE_CLASS(Pool, SNCPool, this) +DEFINE_CLASS(Pool, SNCPool, klass) { - INHERIT_CLASS(this, SNCPool, AbstractScanPool); - PoolClassMixInFormat(this); - this->size = sizeof(SNCStruct); - this->varargs = SNCVarargs; - this->init = SNCInit; - this->finish = SNCFinish; - this->bufferFill = SNCBufferFill; - this->bufferEmpty = SNCBufferEmpty; - this->scan = SNCScan; - this->framePush = SNCFramePush; - this->framePop = SNCFramePop; - this->walk = SNCWalk; - this->bufferClass = SNCBufClassGet; - this->totalSize = SNCTotalSize; - this->freeSize = SNCFreeSize; + INHERIT_CLASS(klass, SNCPool, AbstractScanPool); + PoolClassMixInFormat(klass); + klass->size = sizeof(SNCStruct); + klass->varargs = SNCVarargs; + klass->init = SNCInit; + klass->finish = SNCFinish; + klass->bufferFill = SNCBufferFill; + klass->bufferEmpty = SNCBufferEmpty; + klass->scan = SNCScan; + klass->framePush = SNCFramePush; + klass->framePop = SNCFramePop; + klass->walk = SNCWalk; + klass->bufferClass = SNCBufClassGet; + klass->totalSize = SNCTotalSize; + klass->freeSize = SNCFreeSize; } diff --git a/mps/code/protocol.c b/mps/code/protocol.c index fe57a187f0a..84f8002f506 100644 --- a/mps/code/protocol.c +++ b/mps/code/protocol.c @@ -16,59 +16,59 @@ SRCID(protocol, "$Id$"); /* The class definitions for the root of the hierarchy */ -static void InstClassInitInternal(InstClass class); +static void InstClassInitInternal(InstClass klass); -DEFINE_CLASS(Inst, Inst, class) +DEFINE_CLASS(Inst, Inst, klass) { - InstClassInitInternal(class); - class->instStruct.class = CLASS(InstClass); + InstClassInitInternal(klass); + klass->instStruct.klass = CLASS(InstClass); } -DEFINE_CLASS(Inst, InstClass, class) +DEFINE_CLASS(Inst, InstClass, klass) { - /* Can't use INHERIT_CLASS(class, InstClass, Inst) here because it + /* Can't use INHERIT_CLASS(klass, InstClass, Inst) here because it causes infinite regression, so we have to set this one up by hand. */ - InstClassInitInternal(class); - class->superclass = &CLASS_STATIC(Inst); - class->name = "InstClass"; - class->level = ClassLevelInstClass; - class->display[ClassLevelInstClass] = CLASS_ID(InstClass); + InstClassInitInternal(klass); + klass->superclass = &CLASS_STATIC(Inst); + klass->name = "InstClass"; + klass->level = ClassLevelInstClass; + klass->display[ClassLevelInstClass] = CLASS_ID(InstClass); } -static void InstClassInitInternal(InstClass class) +static void InstClassInitInternal(InstClass klass) { ClassLevel i; - class->name = "Inst"; - class->superclass = NULL; + klass->name = "Inst"; + klass->superclass = NULL; for (i = 0; i < ClassDEPTH; ++i) - class->display[i] = NULL; - class->level = 0; - class->display[class->level] = CLASS_ID(Inst); + klass->display[i] = NULL; + klass->level = 0; + klass->display[klass->level] = CLASS_ID(Inst); /* We can't call CLASS(InstClass) here because it causes a loop back to here, so we have to tie this knot specially. */ - class->instStruct.class = &CLASS_STATIC(InstClass); + klass->instStruct.klass = &CLASS_STATIC(InstClass); - class->sig = InstClassSig; - AVERT(InstClass, class); + klass->sig = InstClassSig; + AVERT(InstClass, klass); } /* InstClassCheck -- check a protocol class */ -Bool InstClassCheck(InstClass class) +Bool InstClassCheck(InstClass klass) { ClassLevel i; - CHECKS(InstClass, class); - CHECKL(class->name != NULL); - CHECKL(class->level < ClassDEPTH); - for (i = 0; i <= class->level; ++i) { - CHECKL(class->display[i] != NULL); + CHECKS(InstClass, klass); + CHECKL(klass->name != NULL); + CHECKL(klass->level < ClassDEPTH); + for (i = 0; i <= klass->level; ++i) { + CHECKL(klass->display[i] != NULL); } - for (i = class->level + 1; i < ClassDEPTH; ++i) { - CHECKL(class->display[i] == NULL); + for (i = klass->level + 1; i < ClassDEPTH; ++i) { + CHECKL(klass->display[i] == NULL); } return TRUE; } @@ -84,7 +84,7 @@ Bool InstClassCheck(InstClass class) void InstInit(Inst inst) { AVER(inst != NULL); - inst->class = CLASS(Inst); + inst->klass = CLASS(Inst); AVERC(Inst, inst); } @@ -107,7 +107,7 @@ static InstClassStruct invalidClassStruct = { void InstFinish(Inst inst) { AVERC(Inst, inst); - inst->class = &invalidClassStruct; + inst->klass = &invalidClassStruct; } @@ -115,35 +115,35 @@ void InstFinish(Inst inst) Bool InstCheck(Inst inst) { - CHECKD(InstClass, inst->class); + CHECKD(InstClass, inst->klass); return TRUE; } -void ClassRegister(InstClass class) +void ClassRegister(InstClass klass) { Word classId; /* label the pool class with its name */ EventInit(); - classId = EventInternString(ClassName(class)); + classId = EventInternString(ClassName(klass)); /* NOTE: this breaks */ - EventLabelAddr((Addr)class, classId); + EventLabelAddr((Addr)klass, classId); } Res InstDescribe(Inst inst, mps_lib_FILE *stream, Count depth) { - InstClass class; + InstClass klass; if (!TESTC(Inst, inst)) return ResPARAM; if (stream == NULL) return ResPARAM; - class = ClassOfPoly(Inst, inst); + klass = ClassOfPoly(Inst, inst); return WriteF(stream, depth, - "$S $P\n", (WriteFS)ClassName(class), inst, + "$S $P\n", (WriteFS)ClassName(klass), inst, NULL); } diff --git a/mps/code/protocol.h b/mps/code/protocol.h index e48e3e1cb2b..bbdcfc33983 100644 --- a/mps/code/protocol.h +++ b/mps/code/protocol.h @@ -57,17 +57,17 @@ * is implemented by the canonical "LandClassClass". */ -#define INST_TYPE(ident) ident -#define INST_STRUCT(ident) ident ## Struct -#define INST_CHECK(ident) ident ## Check -#define CLASS_TYPE(ident) ident ## Class -#define CLASS_STRUCT(ident) ident ## ClassStruct -#define CLASS_ENSURE(ident) ident ## ClassGet -#define CLASS_INIT(ident) ident ## ClassInit -#define CLASS_CHECK(ident) ident ## ClassCheck -#define CLASS_GUARDIAN(ident) ClassGuardian ## ident -#define CLASS_STATIC(ident) ClassStatic ## ident -#define KIND_CLASS(ident) ident ## Class +#define INST_TYPE(klass) klass +#define INST_STRUCT(klass) klass ## Struct +#define INST_CHECK(klass) klass ## Check +#define CLASS_TYPE(klass) klass ## Class +#define CLASS_STRUCT(klass) klass ## ClassStruct +#define CLASS_ENSURE(klass) klass ## ClassGet +#define CLASS_INIT(klass) klass ## ClassInit +#define CLASS_CHECK(klass) klass ## ClassCheck +#define CLASS_GUARDIAN(klass) ClassGuardian ## klass +#define CLASS_STATIC(klass) ClassStatic ## klass +#define KIND_CLASS(klass) klass ## Class /* ClassId -- static identity of a class @@ -79,7 +79,7 @@ */ typedef struct ClassIdStruct *ClassId; -#define CLASS_ID(ident) ((ClassId)&CLASS_STATIC(ident)) +#define CLASS_ID(klass) ((ClassId)&CLASS_STATIC(klass)) /* DECLARE_CLASS -- declare the existence of a protocol class @@ -89,11 +89,11 @@ typedef struct ClassIdStruct *ClassId; * design.mps.protocol.if.declare-class. */ -#define DECLARE_CLASS(kind, ident, super) \ - extern CLASS_TYPE(kind) CLASS_ENSURE(ident)(void); \ - extern void CLASS_INIT(ident)(CLASS_TYPE(kind) var); \ - extern CLASS_STRUCT(kind) CLASS_STATIC(ident); \ - enum { ClassLevel ## ident = ClassLevel ## super + 1 } +#define DECLARE_CLASS(kind, klass, super) \ + extern CLASS_TYPE(kind) CLASS_ENSURE(klass)(void); \ + extern void CLASS_INIT(klass)(CLASS_TYPE(kind) var); \ + extern CLASS_STRUCT(kind) CLASS_STATIC(klass); \ + enum { ClassLevel ## klass = ClassLevel ## super + 1 } /* DEFINE_CLASS -- define a protocol class @@ -105,29 +105,29 @@ typedef struct ClassIdStruct *ClassId; * design.mps.protocol.if.define-class. */ -#define DEFINE_CLASS(kind, ident, var) \ - static Bool CLASS_GUARDIAN(ident) = FALSE; \ - CLASS_STRUCT(kind) CLASS_STATIC(ident); \ - CLASS_TYPE(kind) CLASS_ENSURE(ident)(void) \ +#define DEFINE_CLASS(kind, className, var) \ + static Bool CLASS_GUARDIAN(className) = FALSE; \ + CLASS_STRUCT(kind) CLASS_STATIC(className); \ + CLASS_TYPE(kind) CLASS_ENSURE(className)(void) \ { \ - CLASS_TYPE(kind) class = &CLASS_STATIC(ident); \ - if (CLASS_GUARDIAN(ident) == FALSE) { \ + CLASS_TYPE(kind) klass = &CLASS_STATIC(className); \ + if (CLASS_GUARDIAN(className) == FALSE) { \ LockClaimGlobalRecursive(); \ - if (CLASS_GUARDIAN(ident) == FALSE) { \ - CLASS_INIT(ident)(class); \ + if (CLASS_GUARDIAN(className) == FALSE) { \ + CLASS_INIT(className)(klass); \ /* Prevent infinite regress. */ \ - if (CLASS_ID(ident) != CLASS_ID(InstClass) && \ - CLASS_ID(ident) != CLASS_ID(Inst)) \ - SetClassOfPoly(class, CLASS(KIND_CLASS(kind))); \ - AVER(CLASS_CHECK(kind)(class)); \ - CLASS_GUARDIAN(ident) = TRUE; \ - ClassRegister(MustBeA(InstClass, class)); \ + if (CLASS_ID(className) != CLASS_ID(InstClass) && \ + CLASS_ID(className) != CLASS_ID(Inst)) \ + SetClassOfPoly(klass, CLASS(KIND_CLASS(kind))); \ + AVER(CLASS_CHECK(kind)(klass)); \ + CLASS_GUARDIAN(className) = TRUE; \ + ClassRegister(MustBeA(InstClass, klass)); \ } \ LockReleaseGlobalRecursive(); \ } \ - return class; \ + return klass; \ } \ - void CLASS_INIT(ident)(CLASS_TYPE(kind) var) + void CLASS_INIT(className)(CLASS_TYPE(kind) var) /* CLASS -- expression for getting a class @@ -136,7 +136,7 @@ typedef struct ClassIdStruct *ClassId; * DEFINE_CLASS directly. See design.mps.protocol.if.class. */ -#define CLASS(ident) (CLASS_ENSURE(ident)()) +#define CLASS(klass) (CLASS_ENSURE(klass)()) /* INHERIT_CLASS -- inheriting from a superclass @@ -169,7 +169,7 @@ typedef struct InstStruct *Inst; typedef struct InstClassStruct *InstClass; typedef struct InstStruct { - InstClass class; + InstClass klass; /* Do not add permanent fields here. Introduce a subclass. */ } InstStruct; @@ -192,7 +192,7 @@ enum {ClassLevelNoSuper = -1}; DECLARE_CLASS(Inst, Inst, NoSuper); DECLARE_CLASS(Inst, InstClass, Inst); -extern Bool InstClassCheck(InstClass class); +extern Bool InstClassCheck(InstClass klass); extern Bool InstCheck(Inst inst); extern void InstInit(Inst inst); extern void InstFinish(Inst inst); @@ -205,7 +205,7 @@ extern Res InstDescribe(Inst inst, mps_lib_FILE *stream, Count depth); * is not intended for use outside this file. */ -extern void ClassRegister(InstClass class); +extern void ClassRegister(InstClass klass); /* IsSubclass, IsA -- fast subclass test @@ -219,11 +219,11 @@ extern void ClassRegister(InstClass class); (((InstClass)(sub))->display[ClassLevel ## super] == CLASS_ID(super)) #define IsA(_class, inst) \ - IsSubclass(CouldBeA(Inst, inst)->class, _class) + IsSubclass(CouldBeA(Inst, inst)->klass, _class) #define IsNonNullAndA(_class, inst) \ ((inst) != NULL && \ - CouldBeA(Inst, inst)->class != NULL && \ + CouldBeA(Inst, inst)->klass != NULL && \ IsA(_class, inst)) @@ -242,7 +242,7 @@ extern void ClassRegister(InstClass class); * design.mps.protocol.if.must-be-a.critical. */ -#define CouldBeA(class, inst) ((INST_TYPE(class))(inst)) +#define CouldBeA(klass, inst) ((INST_TYPE(klass))(inst)) #define MustBeA(_class, inst) \ CouldBeA(_class, \ @@ -264,11 +264,11 @@ extern void ClassRegister(InstClass class); * design.mps.protocol.introspect. */ -#define SuperclassPoly(kind, class) \ - MustBeA(KIND_CLASS(kind), MustBeA(InstClass, class)->superclass) +#define SuperclassPoly(kind, klass) \ + MustBeA(KIND_CLASS(kind), MustBeA(InstClass, klass)->superclass) #define ClassOfPoly(kind, inst) \ - MustBeA(KIND_CLASS(kind), MustBeA(Inst, inst)->class) + MustBeA(KIND_CLASS(kind), MustBeA(Inst, inst)->klass) /* ClassName -- get the human readable name of a class @@ -277,7 +277,7 @@ extern void ClassRegister(InstClass class); * we don't use MustBeA. */ -#define ClassName(class) RVALUE(CouldBeA(InstClass, class)->name) +#define ClassName(klass) RVALUE(CouldBeA(InstClass, klass)->name) /* SetClassOfPoly -- set the class of an object @@ -288,7 +288,7 @@ extern void ClassRegister(InstClass class); */ #define SetClassOfPoly(inst, _class) \ - BEGIN MustBeA(Inst, inst)->class = MustBeA(InstClass, _class); END + BEGIN MustBeA(Inst, inst)->klass = MustBeA(InstClass, _class); END /* Method -- method call @@ -313,10 +313,10 @@ extern void ClassRegister(InstClass class); * hierarchy are inconsistent. Revisit this later. */ -#define SUPERCLASS(kind, ident) \ - MustBeA(KIND_CLASS(kind), CouldBeA(InstClass, CLASS(ident))->superclass) +#define SUPERCLASS(kind, klass) \ + MustBeA(KIND_CLASS(kind), CouldBeA(InstClass, CLASS(klass))->superclass) -#define NextMethod(kind, ident, meth) (SUPERCLASS(kind, ident)->meth) +#define NextMethod(kind, klass, meth) (SUPERCLASS(kind, klass)->meth) #endif /* protocol_h */ diff --git a/mps/code/seg.c b/mps/code/seg.c index 3bf8343f214..fbdec1d1784 100644 --- a/mps/code/seg.c +++ b/mps/code/seg.c @@ -33,7 +33,7 @@ SRCID(seg, "$Id$"); static void SegFinish(Seg seg); -static Res SegInit(Seg seg, SegClass class, Pool pool, +static Res SegInit(Seg seg, SegClass klass, Pool pool, Addr base, Size size, ArgList args); @@ -42,7 +42,7 @@ static Res SegInit(Seg seg, SegClass class, Pool pool, /* SegAlloc -- allocate a segment from the arena */ -Res SegAlloc(Seg *segReturn, SegClass class, LocusPref pref, +Res SegAlloc(Seg *segReturn, SegClass klass, LocusPref pref, Size size, Pool pool, ArgList args) { Res res; @@ -52,7 +52,7 @@ Res SegAlloc(Seg *segReturn, SegClass class, LocusPref pref, void *p; AVER(segReturn != NULL); - AVERT(SegClass, class); + AVERT(SegClass, klass); AVERT(LocusPref, pref); AVER(size > (Size)0); AVERT(Pool, pool); @@ -67,12 +67,12 @@ Res SegAlloc(Seg *segReturn, SegClass class, LocusPref pref, goto failArena; /* allocate the segment object from the control pool */ - res = ControlAlloc(&p, arena, class->size); + res = ControlAlloc(&p, arena, klass->size); if (res != ResOK) goto failControl; seg = p; - res = SegInit(seg, class, pool, base, size, args); + res = SegInit(seg, klass, pool, base, size, args); if (res != ResOK) goto failInit; @@ -81,7 +81,7 @@ Res SegAlloc(Seg *segReturn, SegClass class, LocusPref pref, return ResOK; failInit: - ControlFree(arena, seg, class->size); + ControlFree(arena, seg, klass->size); failControl: ArenaFree(base, size, pool); failArena: @@ -173,14 +173,14 @@ static Res SegAbsInit(Seg seg, Pool pool, Addr base, Size size, ArgList args) return ResOK; } -static Res SegInit(Seg seg, SegClass class, Pool pool, Addr base, Size size, ArgList args) +static Res SegInit(Seg seg, SegClass klass, Pool pool, Addr base, Size size, ArgList args) { Res res; - AVERT(SegClass, class); + AVERT(SegClass, klass); - /* Class specific initialization comes last */ - res = class->init(seg, pool, base, size, args); + /* Klass specific initialization comes last */ + res = klass->init(seg, pool, base, size, args); if (res != ResOK) return res; @@ -379,7 +379,7 @@ Res SegDescribe(Seg seg, mps_lib_FILE *stream, Count depth) { Res res; Pool pool; - SegClass class; + SegClass klass; if (!TESTC(Seg, seg)) return ResPARAM; @@ -387,13 +387,13 @@ Res SegDescribe(Seg seg, mps_lib_FILE *stream, Count depth) return ResPARAM; pool = SegPool(seg); - class = ClassOfPoly(Seg, seg); + klass = ClassOfPoly(Seg, seg); res = WriteF(stream, depth, "Segment $P [$A,$A) {\n", (WriteFP)seg, (WriteFA)SegBase(seg), (WriteFA)SegLimit(seg), " class $P (\"$S\")\n", - (WriteFP)class, (WriteFS)ClassName(class), + (WriteFP)klass, (WriteFS)ClassName(klass), " pool $P ($U)\n", (WriteFP)pool, (WriteFU)pool->serial, " depth $U\n", seg->depth, @@ -578,7 +578,7 @@ Bool SegNext(Seg *segReturn, Arena arena, Seg seg) Res SegMerge(Seg *mergedSegReturn, Seg segLo, Seg segHi) { - SegClass class; + SegClass klass; Addr base, mid, limit; Arena arena; Res res; @@ -586,8 +586,8 @@ Res SegMerge(Seg *mergedSegReturn, Seg segLo, Seg segHi) AVER(NULL != mergedSegReturn); AVERT(Seg, segLo); AVERT(Seg, segHi); - class = ClassOfPoly(Seg, segLo); - AVER(ClassOfPoly(Seg, segHi) == class); + klass = ClassOfPoly(Seg, segLo); + AVER(ClassOfPoly(Seg, segHi) == klass); AVER(SegPool(segLo) == SegPool(segHi)); base = SegBase(segLo); mid = SegLimit(segLo); @@ -605,7 +605,7 @@ Res SegMerge(Seg *mergedSegReturn, Seg segLo, Seg segHi) EVENT2(SegMerge, segLo, segHi); /* Deallocate segHi object */ - ControlFree(arena, segHi, class->size); + ControlFree(arena, segHi, klass->size); AVERT(Seg, segLo); *mergedSegReturn = segLo; return ResOK; @@ -626,7 +626,7 @@ failMerge: Res SegSplit(Seg *segLoReturn, Seg *segHiReturn, Seg seg, Addr at) { Addr base, limit; - SegClass class; + SegClass klass; Seg segNew; Arena arena; Res res; @@ -635,7 +635,7 @@ Res SegSplit(Seg *segLoReturn, Seg *segHiReturn, Seg seg, Addr at) AVER(NULL != segLoReturn); AVER(NULL != segHiReturn); AVERT(Seg, seg); - class = ClassOfPoly(Seg, seg); + klass = ClassOfPoly(Seg, seg); arena = PoolArena(SegPool(seg)); base = SegBase(seg); limit = SegLimit(seg); @@ -653,7 +653,7 @@ Res SegSplit(Seg *segLoReturn, Seg *segHiReturn, Seg seg, Addr at) AVER(SegSM(seg) == SegPM(seg)); /* Allocate the new segment object from the control pool */ - res = ControlAlloc(&p, arena, class->size); + res = ControlAlloc(&p, arena, klass->size); if (ResOK != res) goto failControl; segNew = p; @@ -671,7 +671,7 @@ Res SegSplit(Seg *segLoReturn, Seg *segHiReturn, Seg seg, Addr at) return ResOK; failSplit: - ControlFree(arena, segNew, class->size); + ControlFree(arena, segNew, klass->size); failControl: AVERT(Seg, seg); /* check the original seg is still valid */ return res; @@ -951,7 +951,7 @@ static Res segTrivSplit(Seg seg, Seg segHi, { Pool pool = SegPool(MustBeA(Seg, seg)); Arena arena = PoolArena(pool); - SegClass class; + SegClass klass; Tract tract; Addr addr; @@ -1000,8 +1000,8 @@ static Res segTrivSplit(Seg seg, Seg segHi, } AVER(addr == segHi->limit); - class = ClassOfPoly(Seg, seg); - SetClassOfPoly(segHi, class); + klass = ClassOfPoly(Seg, seg); + SetClassOfPoly(segHi, klass); segHi->sig = SegSig; AVERC(Seg, segHi); @@ -1591,49 +1591,49 @@ static Res gcSegDescribe(Seg seg, mps_lib_FILE *stream, Count depth) /* SegClassCheck -- check a segment class */ -Bool SegClassCheck(SegClass class) +Bool SegClassCheck(SegClass klass) { - CHECKD(InstClass, &class->protocol); - CHECKL(class->size >= sizeof(SegStruct)); - CHECKL(FUNCHECK(class->init)); - CHECKL(FUNCHECK(class->finish)); - CHECKL(FUNCHECK(class->setGrey)); - CHECKL(FUNCHECK(class->setWhite)); - CHECKL(FUNCHECK(class->setRankSet)); - CHECKL(FUNCHECK(class->setRankSummary)); - CHECKL(FUNCHECK(class->merge)); - CHECKL(FUNCHECK(class->split)); - CHECKL(FUNCHECK(class->describe)); - CHECKS(SegClass, class); + CHECKD(InstClass, &klass->protocol); + CHECKL(klass->size >= sizeof(SegStruct)); + CHECKL(FUNCHECK(klass->init)); + CHECKL(FUNCHECK(klass->finish)); + CHECKL(FUNCHECK(klass->setGrey)); + CHECKL(FUNCHECK(klass->setWhite)); + CHECKL(FUNCHECK(klass->setRankSet)); + CHECKL(FUNCHECK(klass->setRankSummary)); + CHECKL(FUNCHECK(klass->merge)); + CHECKL(FUNCHECK(klass->split)); + CHECKL(FUNCHECK(klass->describe)); + CHECKS(SegClass, klass); return TRUE; } /* SegClass -- the vanilla segment class definition */ -DEFINE_CLASS(Inst, SegClass, class) +DEFINE_CLASS(Inst, SegClass, klass) { - INHERIT_CLASS(class, SegClass, InstClass); + INHERIT_CLASS(klass, SegClass, InstClass); } -DEFINE_CLASS(Seg, Seg, class) +DEFINE_CLASS(Seg, Seg, klass) { - INHERIT_CLASS(&class->protocol, Seg, Inst); - class->size = sizeof(SegStruct); - class->init = SegAbsInit; - class->finish = SegAbsFinish; - class->setSummary = segNoSetSummary; - class->buffer = segNoBuffer; - class->setBuffer = segNoSetBuffer; - class->setGrey = segNoSetGrey; - class->setWhite = segNoSetWhite; - class->setRankSet = segNoSetRankSet; - class->setRankSummary = segNoSetRankSummary; - class->merge = segTrivMerge; - class->split = segTrivSplit; - class->describe = segTrivDescribe; - class->sig = SegClassSig; - AVERT(SegClass, class); + INHERIT_CLASS(&klass->protocol, Seg, Inst); + klass->size = sizeof(SegStruct); + klass->init = SegAbsInit; + klass->finish = SegAbsFinish; + klass->setSummary = segNoSetSummary; + klass->buffer = segNoBuffer; + klass->setBuffer = segNoSetBuffer; + klass->setGrey = segNoSetGrey; + klass->setWhite = segNoSetWhite; + klass->setRankSet = segNoSetRankSet; + klass->setRankSummary = segNoSetRankSummary; + klass->merge = segTrivMerge; + klass->split = segTrivSplit; + klass->describe = segTrivDescribe; + klass->sig = SegClassSig; + AVERT(SegClass, klass); } @@ -1641,23 +1641,23 @@ DEFINE_CLASS(Seg, Seg, class) typedef SegClassStruct GCSegClassStruct; -DEFINE_CLASS(Seg, GCSeg, class) +DEFINE_CLASS(Seg, GCSeg, klass) { - INHERIT_CLASS(class, GCSeg, Seg); - class->size = sizeof(GCSegStruct); - class->init = gcSegInit; - class->finish = gcSegFinish; - class->setSummary = gcSegSetSummary; - class->buffer = gcSegBuffer; - class->setBuffer = gcSegSetBuffer; - class->setGrey = gcSegSetGrey; - class->setWhite = gcSegSetWhite; - class->setRankSet = gcSegSetRankSet; - class->setRankSummary = gcSegSetRankSummary; - class->merge = gcSegMerge; - class->split = gcSegSplit; - class->describe = gcSegDescribe; - AVERT(SegClass, class); + INHERIT_CLASS(klass, GCSeg, Seg); + klass->size = sizeof(GCSegStruct); + klass->init = gcSegInit; + klass->finish = gcSegFinish; + klass->setSummary = gcSegSetSummary; + klass->buffer = gcSegBuffer; + klass->setBuffer = gcSegSetBuffer; + klass->setGrey = gcSegSetGrey; + klass->setWhite = gcSegSetWhite; + klass->setRankSet = gcSegSetRankSet; + klass->setRankSummary = gcSegSetRankSummary; + klass->merge = gcSegMerge; + klass->split = gcSegSplit; + klass->describe = gcSegDescribe; + AVERT(SegClass, klass); } @@ -1667,11 +1667,11 @@ DEFINE_CLASS(Seg, GCSeg, class) * may mix this in to ensure that erroneous calls are checked. */ -void SegClassMixInNoSplitMerge(SegClass class) +void SegClassMixInNoSplitMerge(SegClass klass) { /* Can't check class because it's not initialized yet */ - class->merge = segNoMerge; - class->split = segNoSplit; + klass->merge = segNoMerge; + klass->split = segNoSplit; } diff --git a/mps/code/segsmss.c b/mps/code/segsmss.c index 251d10235d0..f816748114a 100644 --- a/mps/code/segsmss.c +++ b/mps/code/segsmss.c @@ -266,15 +266,15 @@ failSuper: /* AMSTSegClass -- Class definition for AMST segments */ -DEFINE_CLASS(Seg, AMSTSeg, class) +DEFINE_CLASS(Seg, AMSTSeg, klass) { - INHERIT_CLASS(class, AMSTSeg, AMSSeg); - class->size = sizeof(AMSTSegStruct); - class->init = amstSegInit; - class->finish = amstSegFinish; - class->split = amstSegSplit; - class->merge = amstSegMerge; - AVERT(SegClass, class); + INHERIT_CLASS(klass, AMSTSeg, AMSSeg); + klass->size = sizeof(AMSTSegStruct); + klass->init = amstSegInit; + klass->finish = amstSegFinish; + klass->split = amstSegSplit; + klass->merge = amstSegMerge; + AVERT(SegClass, klass); } @@ -312,7 +312,7 @@ static Res AMSTSegSizePolicy(Size *sizeReturn, /* AMSTInit -- the pool class initialization method */ -static Res AMSTInit(Pool pool, Arena arena, PoolClass class, ArgList args) +static Res AMSTInit(Pool pool, Arena arena, PoolClass klass, ArgList args) { AMST amst; AMS ams; Chain chain; @@ -323,7 +323,7 @@ static Res AMSTInit(Pool pool, Arena arena, PoolClass class, ArgList args) AVER(pool != NULL); AVERT(Arena, arena); AVERT(ArgList, args); - UNUSED(class); /* used for debug pools only */ + UNUSED(klass); /* used for debug pools only */ if (ArgPick(&arg, args, MPS_KEY_CHAIN)) chain = arg.val.chain; @@ -335,7 +335,7 @@ static Res AMSTInit(Pool pool, Arena arena, PoolClass class, ArgList args) gen = arg.val.u; /* FIXME: Generalise to next-method call */ - res = AMSInitInternal(PoolAMS(pool), arena, class, + res = AMSInitInternal(PoolAMS(pool), arena, klass, chain, gen, FALSE, args); if (res != ResOK) return res; @@ -658,13 +658,13 @@ static void AMSTStressBufferedSeg(Seg seg, Buffer buffer) /* AMSTPoolClass -- the pool class definition */ -DEFINE_CLASS(Pool, AMSTPool, this) +DEFINE_CLASS(Pool, AMSTPool, klass) { - INHERIT_CLASS(this, AMSTPool, AMSPool); - this->size = sizeof(AMSTStruct); - this->init = AMSTInit; - this->finish = AMSTFinish; - this->bufferFill = AMSTBufferFill; + INHERIT_CLASS(klass, AMSTPool, AMSPool); + klass->size = sizeof(AMSTStruct); + klass->init = AMSTInit; + klass->finish = AMSTFinish; + klass->bufferFill = AMSTBufferFill; }