/***************************************************
NAME : BsaveDefinstances
DESCRIPTION : Bsaves a definstances
INPUTS : 1) The definstances
2) Output data file pointer
RETURNS : Nothing useful
SIDE EFFECTS : Definstances saved
NOTES : None
***************************************************/
static void BsaveDefinstances(
void *theEnv,
struct constructHeader *theDefinstances,
void *userBuffer)
{
DEFINSTANCES *dptr = (DEFINSTANCES *) theDefinstances;
BSAVE_DEFINSTANCES dummy_df;
AssignBsaveConstructHeaderVals(&dummy_df.header,&dptr->header);
if (dptr->mkinstance != NULL)
{
dummy_df.mkinstance = ExpressionData(theEnv)->ExpressionCount;
ExpressionData(theEnv)->ExpressionCount += ExpressionSize(dptr->mkinstance);
}
else
dummy_df.mkinstance = -1L;
GenWrite((void *) &dummy_df,(unsigned long) sizeof(BSAVE_DEFINSTANCES),(FILE *) userBuffer);
}
/***************************************************
NAME : BsaveDefgenericHeader
DESCRIPTION : Bsaves a generic function header
INPUTS : 1) The defgeneric
2) Output data file pointer
RETURNS : Nothing useful
SIDE EFFECTS : Defgeneric header saved
NOTES : None
***************************************************/
static void BsaveDefgenericHeader(
struct constructHeader *theDefgeneric,
void *userBuffer)
{
DEFGENERIC *gfunc = (DEFGENERIC *) theDefgeneric;
BSAVE_GENERIC dummy_generic;
AssignBsaveConstructHeaderVals(&dummy_generic.header,&gfunc->header);
dummy_generic.mcnt = gfunc->mcnt;
if (gfunc->methods != NULL)
{
dummy_generic.methods = MethodCount;
MethodCount += gfunc->mcnt;
}
else
dummy_generic.methods = -1L;
GenWrite((void *) &dummy_generic,(unsigned long) sizeof(BSAVE_GENERIC),(FILE *) userBuffer);
}
/***************************************************
NAME : BsaveDeffunction
DESCRIPTION : Bsaves a deffunction
INPUTS : 1) The deffunction
2) Output data file pointer
RETURNS : Nothing useful
SIDE EFFECTS : Deffunction saved
NOTES : None
***************************************************/
static void BsaveDeffunction(
struct constructHeader *theDeffunction,
void *userBuffer)
{
DEFFUNCTION *dptr = (DEFFUNCTION *) theDeffunction;
BSAVE_DEFFUNCTION dummy_df;
AssignBsaveConstructHeaderVals(&dummy_df.header,&dptr->header);
dummy_df.minNumberOfParameters = dptr->minNumberOfParameters;
dummy_df.maxNumberOfParameters = dptr->maxNumberOfParameters;
dummy_df.numberOfLocalVars = dptr->numberOfLocalVars;
if (dptr->code != NULL)
{
dummy_df.code = ExpressionCount;
ExpressionCount += ExpressionSize(dptr->code);
}
else
dummy_df.code = -1L;
GenWrite((void *) &dummy_df,(unsigned long) sizeof(BSAVE_DEFFUNCTION),(FILE *) userBuffer);
}
static void BsaveDisjuncts(
FILE *fp,
struct defrule *theDefrule)
{
struct defrule *theDisjunct;
struct bsaveDefrule tempDefrule;
long int disjunctExpressionCount = 0L;
#if CERTAINTY_FACTORS
long int disjunctExpressionCountCF = 0L;
#endif
int first;
/*=========================================*/
/* Loop through each disjunct of the rule. */
/*=========================================*/
for (theDisjunct = theDefrule, first = TRUE;
theDisjunct != NULL;
theDisjunct = theDisjunct->disjunct, first = FALSE)
{
NumberOfDefrules++;
/*======================================*/
/* Set header and miscellaneous values. */
/*======================================*/
AssignBsaveConstructHeaderVals(&tempDefrule.header,
&theDisjunct->header);
tempDefrule.salience = theDisjunct->salience;
tempDefrule.localVarCnt = theDisjunct->localVarCnt;
tempDefrule.complexity = theDisjunct->complexity;
tempDefrule.autoFocus = theDisjunct->autoFocus;
/*=======================================*/
/* Set dynamic salience data structures. */
/*=======================================*/
#if DYNAMIC_SALIENCE
if (theDisjunct->dynamicSalience != NULL)
{
if (first)
{
tempDefrule.dynamicSalience = ExpressionCount;
disjunctExpressionCount = ExpressionCount;
ExpressionCount += ExpressionSize(theDisjunct->dynamicSalience);
}
else
{ tempDefrule.dynamicSalience = disjunctExpressionCount; }
}
else
#endif
{ tempDefrule.dynamicSalience = -1L; }
#if CERTAINTY_FACTORS
if (theDisjunct->dynamicCF != NULL)
{
if (first)
{
tempDefrule.dynamicCF = ExpressionCount;
disjunctExpressionCountCF = ExpressionCount;
ExpressionCount += ExpressionSize(theDisjunct->dynamicCF);
}
else
{ tempDefrule.dynamicCF = disjunctExpressionCountCF; }
}
else
{ tempDefrule.dynamicCF = -1L; }
#endif
/*==============================================*/
/* Set the index to the disjunct's RHS actions. */
/*==============================================*/
if (theDisjunct->actions != NULL)
{
tempDefrule.actions = ExpressionCount;
ExpressionCount += ExpressionSize(theDisjunct->actions);
}
else
{ tempDefrule.actions = -1L; }
/*=================================*/
/* Set the index to the disjunct's */
/* logical join and last join. */
/*=================================*/
#if LOGICAL_DEPENDENCIES
tempDefrule.logicalJoin = BsaveJoinIndex(theDisjunct->logicalJoin);
#else
tempDefrule.logicalJoin = -1L;
#endif
tempDefrule.lastJoin = BsaveJoinIndex(theDisjunct->lastJoin);
/*=====================================*/
/* Set the index to the next disjunct. */
/*=====================================*/
if (theDisjunct->disjunct != NULL)
{ tempDefrule.disjunct = NumberOfDefrules; }
else
{ tempDefrule.disjunct = -1L; }
#if CERTAINTY_FACTORS
tempDefrule.CF = theDisjunct->CF;
#endif
#if FUZZY_DEFTEMPLATES
tempDefrule.min_of_maxmins = theDisjunct->min_of_maxmins;
tempDefrule.lhsRuleType = theDisjunct->lhsRuleType;
tempDefrule.numberOfFuzzySlots = theDisjunct->numberOfFuzzySlots;
if (theDisjunct->numberOfFuzzySlots > 0)
tempDefrule.pattern_fv_arrayPtr = NumberOfPatternFuzzyValues;
else
tempDefrule.pattern_fv_arrayPtr = -1L;
NumberOfPatternFuzzyValues += theDisjunct->numberOfFuzzySlots;
#endif
/*=================================*/
/* Write the disjunct to the file. */
/*=================================*/
GenWrite(&tempDefrule,(unsigned long) sizeof(struct bsaveDefrule),fp);
}
}
static void BsaveBinaryItem(
Environment *theEnv,
FILE *fp)
{
size_t space;
Deftemplate *theDeftemplate;
struct bsaveDeftemplate tempDeftemplate;
struct templateSlot *theSlot;
struct bsaveTemplateSlot tempTemplateSlot;
struct bsaveDeftemplateModule tempTemplateModule;
Defmodule *theModule;
struct deftemplateModule *theModuleItem;
/*============================================================*/
/* Write out the amount of space taken up by the deftemplate, */
/* deftemplateModule, and templateSlot data structures in the */
/* binary image. */
/*============================================================*/
space = (DeftemplateBinaryData(theEnv)->NumberOfDeftemplates * sizeof(struct bsaveDeftemplate)) +
(DeftemplateBinaryData(theEnv)->NumberOfTemplateSlots * sizeof(struct bsaveTemplateSlot)) +
(DeftemplateBinaryData(theEnv)->NumberOfTemplateModules * sizeof(struct bsaveDeftemplateModule));
GenWrite(&space,sizeof(size_t),fp);
/*===================================================*/
/* Write out each deftemplate module data structure. */
/*===================================================*/
DeftemplateBinaryData(theEnv)->NumberOfDeftemplates = 0;
for (theModule = GetNextDefmodule(theEnv,NULL);
theModule != NULL;
theModule = GetNextDefmodule(theEnv,theModule))
{
SetCurrentModule(theEnv,theModule);
theModuleItem = (struct deftemplateModule *)
GetModuleItem(theEnv,NULL,FindModuleItem(theEnv,"deftemplate")->moduleIndex);
AssignBsaveDefmdlItemHdrVals(&tempTemplateModule.header,
&theModuleItem->header);
GenWrite(&tempTemplateModule,sizeof(struct bsaveDeftemplateModule),fp);
}
/*============================================*/
/* Write out each deftemplate data structure. */
/*============================================*/
DeftemplateBinaryData(theEnv)->NumberOfTemplateSlots = 0;
for (theModule = GetNextDefmodule(theEnv,NULL);
theModule != NULL;
theModule = GetNextDefmodule(theEnv,theModule))
{
SetCurrentModule(theEnv,theModule);
for (theDeftemplate = GetNextDeftemplate(theEnv,NULL);
theDeftemplate != NULL;
theDeftemplate = GetNextDeftemplate(theEnv,theDeftemplate))
{
AssignBsaveConstructHeaderVals(&tempDeftemplate.header,
&theDeftemplate->header);
tempDeftemplate.implied = theDeftemplate->implied;
tempDeftemplate.numberOfSlots = theDeftemplate->numberOfSlots;
tempDeftemplate.patternNetwork = BsaveFactPatternIndex(theDeftemplate->patternNetwork);
if (theDeftemplate->slotList != NULL)
{ tempDeftemplate.slotList = DeftemplateBinaryData(theEnv)->NumberOfTemplateSlots; }
else
{ tempDeftemplate.slotList = ULONG_MAX; }
GenWrite(&tempDeftemplate,sizeof(struct bsaveDeftemplate),fp);
DeftemplateBinaryData(theEnv)->NumberOfTemplateSlots += theDeftemplate->numberOfSlots;
}
}
/*=============================================*/
/* Write out each templateSlot data structure. */
/*=============================================*/
for (theModule = GetNextDefmodule(theEnv,NULL);
theModule != NULL;
theModule = GetNextDefmodule(theEnv,theModule))
{
SetCurrentModule(theEnv,theModule);
for (theDeftemplate = GetNextDeftemplate(theEnv,NULL);
theDeftemplate != NULL;
theDeftemplate = GetNextDeftemplate(theEnv,theDeftemplate))
{
for (theSlot = theDeftemplate->slotList;
theSlot != NULL;
theSlot = theSlot->next)
{
tempTemplateSlot.constraints = ConstraintIndex(theSlot->constraints);
tempTemplateSlot.slotName = theSlot->slotName->bucket;
tempTemplateSlot.multislot = theSlot->multislot;
tempTemplateSlot.noDefault = theSlot->noDefault;
tempTemplateSlot.defaultPresent = theSlot->defaultPresent;
tempTemplateSlot.defaultDynamic = theSlot->defaultDynamic;
tempTemplateSlot.defaultList = HashedExpressionIndex(theEnv,theSlot->defaultList);
tempTemplateSlot.facetList = HashedExpressionIndex(theEnv,theSlot->facetList);
if (theSlot->next != NULL) tempTemplateSlot.next = 0L;
else tempTemplateSlot.next = ULONG_MAX;
GenWrite(&tempTemplateSlot,sizeof(struct bsaveTemplateSlot),fp);
}
}
}
/*=============================================================*/
/* If a binary image was already loaded when the bsave command */
/* was issued, then restore the counts indicating the number */
/* of deftemplates, deftemplate modules, and deftemplate slots */
/* in the binary image (these were overwritten by the binary */
/* save). */
/*=============================================================*/
RestoreBloadCount(theEnv,&DeftemplateBinaryData(theEnv)->NumberOfDeftemplates);
RestoreBloadCount(theEnv,&DeftemplateBinaryData(theEnv)->NumberOfTemplateSlots);
RestoreBloadCount(theEnv,&DeftemplateBinaryData(theEnv)->NumberOfTemplateModules);
}
static void BsaveDisjuncts(
void *theEnv,
FILE *fp,
struct defrule *theDefrule)
{
struct defrule *theDisjunct;
struct bsaveDefrule tempDefrule;
long int disjunctExpressionCount = 0L;
int first;
/*=========================================*/
/* Loop through each disjunct of the rule. */
/*=========================================*/
for (theDisjunct = theDefrule, first = TRUE;
theDisjunct != NULL;
theDisjunct = theDisjunct->disjunct, first = FALSE)
{
DefruleBinaryData(theEnv)->NumberOfDefrules++;
/*======================================*/
/* Set header and miscellaneous values. */
/*======================================*/
AssignBsaveConstructHeaderVals(&tempDefrule.header,
&theDisjunct->header);
tempDefrule.salience = theDisjunct->salience;
tempDefrule.localVarCnt = theDisjunct->localVarCnt;
tempDefrule.complexity = theDisjunct->complexity;
tempDefrule.autoFocus = theDisjunct->autoFocus;
/*=======================================*/
/* Set dynamic salience data structures. */
/*=======================================*/
if (theDisjunct->dynamicSalience != NULL)
{
if (first)
{
tempDefrule.dynamicSalience = ExpressionData(theEnv)->ExpressionCount;
disjunctExpressionCount = ExpressionData(theEnv)->ExpressionCount;
ExpressionData(theEnv)->ExpressionCount += ExpressionSize(theDisjunct->dynamicSalience);
}
else
{ tempDefrule.dynamicSalience = disjunctExpressionCount; }
}
else
{ tempDefrule.dynamicSalience = -1L; }
/*==============================================*/
/* Set the index to the disjunct's RHS actions. */
/*==============================================*/
if (theDisjunct->actions != NULL)
{
tempDefrule.actions = ExpressionData(theEnv)->ExpressionCount;
ExpressionData(theEnv)->ExpressionCount += ExpressionSize(theDisjunct->actions);
}
else
{ tempDefrule.actions = -1L; }
/*=================================*/
/* Set the index to the disjunct's */
/* logical join and last join. */
/*=================================*/
tempDefrule.logicalJoin = BsaveJoinIndex(theDisjunct->logicalJoin);
tempDefrule.lastJoin = BsaveJoinIndex(theDisjunct->lastJoin);
/*=====================================*/
/* Set the index to the next disjunct. */
/*=====================================*/
if (theDisjunct->disjunct != NULL)
{ tempDefrule.disjunct = DefruleBinaryData(theEnv)->NumberOfDefrules; }
else
{ tempDefrule.disjunct = -1L; }
/*=================================*/
/* Write the disjunct to the file. */
/*=================================*/
GenWrite(&tempDefrule,(unsigned long) sizeof(struct bsaveDefrule),fp);
}
}
static void BsaveBinaryItem(
void *theEnv,
FILE *fp)
{
size_t space;
struct deffacts *theDeffacts;
struct bsaveDeffacts newDeffacts;
struct defmodule *theModule;
struct bsaveDeffactsModule tempDeffactsModule;
struct deffactsModule *theModuleItem;
/*=========================================================*/
/* Write out the amount of space taken up by the deffacts */
/* and deffactsModule data structures in the binary image. */
/*=========================================================*/
space = DeffactsBinaryData(theEnv)->NumberOfDeffacts * sizeof(struct bsaveDeffacts) +
(DeffactsBinaryData(theEnv)->NumberOfDeffactsModules * sizeof(struct bsaveDeffactsModule));
GenWrite(&space,sizeof(size_t),fp);
/*================================================*/
/* Write out each deffacts module data structure. */
/*================================================*/
DeffactsBinaryData(theEnv)->NumberOfDeffacts = 0;
for (theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,NULL);
theModule != NULL;
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,theModule))
{
EnvSetCurrentModule(theEnv,(void *) theModule);
theModuleItem = (struct deffactsModule *) GetModuleItem(theEnv,NULL,DeffactsData(theEnv)->DeffactsModuleIndex);
AssignBsaveDefmdlItemHdrVals(&tempDeffactsModule.header,&theModuleItem->header);
GenWrite(&tempDeffactsModule,(unsigned long) sizeof(struct bsaveDeffactsModule),fp);
}
/*==========================*/
/* Write out each deffacts. */
/*==========================*/
for (theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,NULL);
theModule != NULL;
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,theModule))
{
EnvSetCurrentModule(theEnv,(void *) theModule);
for (theDeffacts = (struct deffacts *) EnvGetNextDeffacts(theEnv,NULL);
theDeffacts != NULL;
theDeffacts = (struct deffacts *) EnvGetNextDeffacts(theEnv,theDeffacts))
{
AssignBsaveConstructHeaderVals(&newDeffacts.header,&theDeffacts->header);
if (theDeffacts->assertList != NULL)
{
newDeffacts.assertList = ExpressionData(theEnv)->ExpressionCount;
ExpressionData(theEnv)->ExpressionCount += ExpressionSize(theDeffacts->assertList);
}
else
{ newDeffacts.assertList = -1L; }
GenWrite(&newDeffacts,(unsigned long) sizeof(struct bsaveDeffacts),fp);
}
}
/*=============================================================*/
/* If a binary image was already loaded when the bsave command */
/* was issued, then restore the counts indicating the number */
/* of deffacts and deffacts modules in the binary image (these */
/* were overwritten by the binary save). */
/*=============================================================*/
RestoreBloadCount(theEnv,&DeffactsBinaryData(theEnv)->NumberOfDeffactsModules);
RestoreBloadCount(theEnv,&DeffactsBinaryData(theEnv)->NumberOfDeffacts);
}
static void BsaveBinaryItem(
FILE *fp)
{
unsigned long int space;
struct defglobal *theDefglobal;
struct bsaveDefglobal newDefglobal;
struct defmodule *theModule;
struct bsaveDefglobalModule tempDefglobalModule;
struct defglobalModule *theModuleItem;
/*==========================================================*/
/* Write out the amount of space taken up by the defglobal */
/* and defglobalModule data structures in the binary image. */
/*==========================================================*/
space = NumberOfDefglobals * sizeof(struct bsaveDefglobal) +
(NumberOfDefglobalModules * sizeof(struct bsaveDefglobalModule));
GenWrite(&space,(unsigned long) sizeof(unsigned long int),fp);
/*=================================================*/
/* Write out each defglobal module data structure. */
/*=================================================*/
NumberOfDefglobals = 0;
for (theModule = (struct defmodule *) GetNextDefmodule(NULL);
theModule != NULL;
theModule = (struct defmodule *) GetNextDefmodule(theModule))
{
SetCurrentModule((void *) theModule);
theModuleItem = (struct defglobalModule *)
GetModuleItem(NULL,FindModuleItem("defglobal")->moduleIndex);
AssignBsaveDefmdlItemHdrVals(&tempDefglobalModule.header,
&theModuleItem->header);
GenWrite(&tempDefglobalModule,(unsigned long) sizeof(struct bsaveDefglobalModule),fp);
}
/*===========================*/
/* Write out each defglobal. */
/*===========================*/
NumberOfDefglobals = 0;
for (theModule = (struct defmodule *) GetNextDefmodule(NULL);
theModule != NULL;
theModule = (struct defmodule *) GetNextDefmodule(theModule))
{
SetCurrentModule((void *) theModule);
for (theDefglobal = (struct defglobal *) GetNextDefglobal(NULL);
theDefglobal != NULL;
theDefglobal = (struct defglobal *) GetNextDefglobal(theDefglobal))
{
AssignBsaveConstructHeaderVals(&newDefglobal.header,
&theDefglobal->header);
newDefglobal.initial = HashedExpressionIndex(theDefglobal->initial);
GenWrite(&newDefglobal,(unsigned long) sizeof(struct bsaveDefglobal),fp);
}
}
/*=============================================================*/
/* If a binary image was already loaded when the bsave command */
/* was issued, then restore the counts indicating the number */
/* of defglobals and defglobal modules in the binary image */
/* (these were overwritten by the binary save). */
/*=============================================================*/
if (Bloaded())
{
RestoreBloadCount(&NumberOfDefglobalModules);
RestoreBloadCount(&NumberOfDefglobals);
}
}
static void BsaveBinaryItem(
void *theEnv,
EXEC_STATUS,
FILE *fp)
{
size_t space;
struct defglobal *theDefglobal;
struct bsaveDefglobal newDefglobal;
struct defmodule *theModule;
struct bsaveDefglobalModule tempDefglobalModule;
struct defglobalModule *theModuleItem;
/*==========================================================*/
/* Write out the amount of space taken up by the defglobal */
/* and defglobalModule data structures in the binary image. */
/*==========================================================*/
space = DefglobalBinaryData(theEnv,execStatus)->NumberOfDefglobals * sizeof(struct bsaveDefglobal) +
(DefglobalBinaryData(theEnv,execStatus)->NumberOfDefglobalModules * sizeof(struct bsaveDefglobalModule));
GenWrite(&space,sizeof(size_t),fp);
/*=================================================*/
/* Write out each defglobal module data structure. */
/*=================================================*/
DefglobalBinaryData(theEnv,execStatus)->NumberOfDefglobals = 0;
for (theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,execStatus,NULL);
theModule != NULL;
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,execStatus,theModule))
{
EnvSetCurrentModule(theEnv,execStatus,(void *) theModule);
theModuleItem = (struct defglobalModule *)
GetModuleItem(theEnv,execStatus,NULL,FindModuleItem(theEnv,execStatus,"defglobal")->moduleIndex);
AssignBsaveDefmdlItemHdrVals(&tempDefglobalModule.header,
&theModuleItem->header);
GenWrite(&tempDefglobalModule,sizeof(struct bsaveDefglobalModule),fp);
}
/*===========================*/
/* Write out each defglobal. */
/*===========================*/
DefglobalBinaryData(theEnv,execStatus)->NumberOfDefglobals = 0;
for (theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,execStatus,NULL);
theModule != NULL;
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,execStatus,theModule))
{
EnvSetCurrentModule(theEnv,execStatus,(void *) theModule);
for (theDefglobal = (struct defglobal *) EnvGetNextDefglobal(theEnv,execStatus,NULL);
theDefglobal != NULL;
theDefglobal = (struct defglobal *) EnvGetNextDefglobal(theEnv,execStatus,theDefglobal))
{
AssignBsaveConstructHeaderVals(&newDefglobal.header,
&theDefglobal->header);
newDefglobal.initial = HashedExpressionIndex(theEnv,execStatus,theDefglobal->initial);
GenWrite(&newDefglobal,sizeof(struct bsaveDefglobal),fp);
}
}
/*=============================================================*/
/* If a binary image was already loaded when the bsave command */
/* was issued, then restore the counts indicating the number */
/* of defglobals and defglobal modules in the binary image */
/* (these were overwritten by the binary save). */
/*=============================================================*/
RestoreBloadCount(theEnv,execStatus,&DefglobalBinaryData(theEnv,execStatus)->NumberOfDefglobalModules);
RestoreBloadCount(theEnv,execStatus,&DefglobalBinaryData(theEnv,execStatus)->NumberOfDefglobals);
}
/***************************************************
NAME : BsaveDefclass
DESCRIPTION : Writes defclass binary data
INPUTS : 1) The defclass
2) The binary file pointer
RETURNS : Nothing useful
SIDE EFFECTS : Defclass binary data written
NOTES : None
***************************************************/
static void BsaveDefclass(
struct constructHeader *theDefclass,
void *buf)
{
DEFCLASS *cls = (DEFCLASS *) theDefclass;
BSAVE_DEFCLASS dummy_class;
AssignBsaveConstructHeaderVals(&dummy_class.header,&cls->header);
dummy_class.abstract = cls->abstract;
dummy_class.reactive = cls->reactive;
dummy_class.system = cls->system;
dummy_class.id = cls->id;
dummy_class.slotCount = cls->slotCount;
dummy_class.instanceSlotCount = cls->instanceSlotCount;
dummy_class.localInstanceSlotCount = cls->localInstanceSlotCount;
dummy_class.maxSlotNameID = cls->maxSlotNameID;
dummy_class.handlerCount = cls->handlerCount;
dummy_class.directSuperclasses.classCount = cls->directSuperclasses.classCount;
dummy_class.directSubclasses.classCount = cls->directSubclasses.classCount;
dummy_class.allSuperclasses.classCount = cls->allSuperclasses.classCount;
if (cls->directSuperclasses.classCount != 0)
{
dummy_class.directSuperclasses.classArray = LinkCount;
LinkCount += cls->directSuperclasses.classCount;
}
else
dummy_class.directSuperclasses.classArray = -1L;
if (cls->directSubclasses.classCount != 0)
{
dummy_class.directSubclasses.classArray = LinkCount;
LinkCount += cls->directSubclasses.classCount;
}
else
dummy_class.directSubclasses.classArray = -1L;
if (cls->allSuperclasses.classCount != 0)
{
dummy_class.allSuperclasses.classArray = LinkCount;
LinkCount += cls->allSuperclasses.classCount;
}
else
dummy_class.allSuperclasses.classArray = -1L;
if (cls->slots != NULL)
{
dummy_class.slots = SlotCount;
SlotCount += cls->slotCount;
}
else
dummy_class.slots = -1L;
if (cls->instanceTemplate != NULL)
{
dummy_class.instanceTemplate = TemplateSlotCount;
TemplateSlotCount += cls->instanceSlotCount;
dummy_class.slotNameMap = SlotNameMapCount;
SlotNameMapCount += cls->maxSlotNameID + 1;
}
else
{
dummy_class.instanceTemplate = -1L;
dummy_class.slotNameMap = -1L;
}
if (cls->handlers != NULL)
{
dummy_class.handlers = HandlerCount;
HandlerCount += cls->handlerCount;
}
else
dummy_class.handlers = -1L;
#if DEFMODULE_CONSTRUCT
dummy_class.scopeMap = (long) cls->scopeMap->bucket;
#else
dummy_class.scopeMap = -1L;
#endif
GenWrite((void *) &dummy_class,(UNLN) sizeof(BSAVE_DEFCLASS),(FILE *) buf);
}
