/*************************************************************************************
NAME : BsaveDeffunctions
DESCRIPTION : Writes out deffunction in binary format
Space required (unsigned long)
All deffunctions (sizeof(DEFFUNCTION) * Number of deffunctions)
INPUTS : File pointer of binary file
RETURNS : Nothing useful
SIDE EFFECTS : Binary file adjusted
NOTES : None
*************************************************************************************/
static void BsaveDeffunctions(
FILE *fp)
{
unsigned long space;
struct defmodule *theModule;
DEFFUNCTION_MODULE *theModuleItem;
BSAVE_DEFFUNCTION_MODULE dummy_mitem;
space = (unsigned long) ((sizeof(BSAVE_DEFFUNCTION_MODULE) * ModuleCount) +
(sizeof(BSAVE_DEFFUNCTION) * DeffunctionCount));
GenWrite((void *) &space,(unsigned long) sizeof(unsigned long),fp);
/* =================================
Write out each deffunction module
================================= */
DeffunctionCount = 0L;
theModule = (struct defmodule *) GetNextDefmodule(NULL);
while (theModule != NULL)
{
theModuleItem = (DEFFUNCTION_MODULE *)
GetModuleItem(theModule,FindModuleItem("deffunction")->moduleIndex);
AssignBsaveDefmdlItemHdrVals(&dummy_mitem.header,&theModuleItem->header);
GenWrite((void *) &dummy_mitem,(unsigned long) sizeof(BSAVE_DEFFUNCTION_MODULE),fp);
theModule = (struct defmodule *) GetNextDefmodule((void *) theModule);
}
/* ==========================
Write out each deffunction
========================== */
DoForAllConstructs(BsaveDeffunction,DeffunctionModuleIndex,
FALSE,(void *) fp);
if (Bloaded())
{
RestoreBloadCount(&ModuleCount);
RestoreBloadCount(&DeffunctionCount);
}
}
/*************************************************************************************
NAME : BsaveDeffunctions
DESCRIPTION : Writes out deffunction in binary format
Space required (unsigned long)
All deffunctions (sizeof(DEFFUNCTION) * Number of deffunctions)
INPUTS : File pointer of binary file
RETURNS : Nothing useful
SIDE EFFECTS : Binary file adjusted
NOTES : None
*************************************************************************************/
static void BsaveDeffunctions(
void *theEnv,
FILE *fp)
{
size_t space;
struct defmodule *theModule;
DEFFUNCTION_MODULE *theModuleItem;
BSAVE_DEFFUNCTION_MODULE dummy_mitem;
space = ((sizeof(BSAVE_DEFFUNCTION_MODULE) * DeffunctionBinaryData(theEnv)->ModuleCount) +
(sizeof(BSAVE_DEFFUNCTION) * DeffunctionBinaryData(theEnv)->DeffunctionCount));
GenWrite((void *) &space,sizeof(size_t),fp);
/* =================================
Write out each deffunction module
================================= */
DeffunctionBinaryData(theEnv)->DeffunctionCount = 0L;
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,NULL);
while (theModule != NULL)
{
theModuleItem = (DEFFUNCTION_MODULE *)
GetModuleItem(theEnv,theModule,FindModuleItem(theEnv,"deffunction")->moduleIndex);
AssignBsaveDefmdlItemHdrVals(&dummy_mitem.header,&theModuleItem->header);
GenWrite((void *) &dummy_mitem,sizeof(BSAVE_DEFFUNCTION_MODULE),fp);
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,(void *) theModule);
}
/* ==========================
Write out each deffunction
========================== */
DoForAllConstructs(theEnv,BsaveDeffunction,DeffunctionData(theEnv)->DeffunctionModuleIndex,
FALSE,(void *) fp);
RestoreBloadCount(theEnv,&DeffunctionBinaryData(theEnv)->ModuleCount);
RestoreBloadCount(theEnv,&DeffunctionBinaryData(theEnv)->DeffunctionCount);
}
/*************************************************************************************
NAME : BsaveDefinstancesDriver
DESCRIPTION : Writes out definstances in binary format
Space required (unsigned long)
All definstances (sizeof(DEFINSTANCES) * Number of definstances)
INPUTS : File pointer of binary file
RETURNS : Nothing useful
SIDE EFFECTS : Binary file adjusted
NOTES : None
*************************************************************************************/
static void BsaveDefinstancesDriver(
void *theEnv,
FILE *fp)
{
unsigned long space;
struct defmodule *theModule;
DEFINSTANCES_MODULE *theModuleItem;
BSAVE_DEFINSTANCES_MODULE dummy_mitem;
space = (unsigned long) ((sizeof(BSAVE_DEFINSTANCES_MODULE) * DefinstancesBinaryData(theEnv)->ModuleCount) +
(sizeof(BSAVE_DEFINSTANCES) * DefinstancesBinaryData(theEnv)->DefinstancesCount));
GenWrite((void *) &space,(unsigned long) sizeof(unsigned long),fp);
/* =================================
Write out each definstances module
================================= */
DefinstancesBinaryData(theEnv)->DefinstancesCount = 0L;
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,NULL);
while (theModule != NULL)
{
theModuleItem = (DEFINSTANCES_MODULE *)
GetModuleItem(theEnv,theModule,FindModuleItem(theEnv,"definstances")->moduleIndex);
AssignBsaveDefmdlItemHdrVals(&dummy_mitem.header,&theModuleItem->header);
GenWrite((void *) &dummy_mitem,(unsigned long) sizeof(BSAVE_DEFINSTANCES_MODULE),fp);
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,(void *) theModule);
}
/* ==========================
Write out each definstances
========================== */
DoForAllConstructs(theEnv,BsaveDefinstances,DefinstancesData(theEnv)->DefinstancesModuleIndex,
FALSE,(void *) fp);
RestoreBloadCount(theEnv,&DefinstancesBinaryData(theEnv)->ModuleCount);
RestoreBloadCount(theEnv,&DefinstancesBinaryData(theEnv)->DefinstancesCount);
}
static void BsaveFactPatterns(
void *theEnv,
EXEC_STATUS,
FILE *fp)
{
size_t space;
struct deftemplate *theDeftemplate;
struct defmodule *theModule;
/*========================================*/
/* Write out the amount of space taken up */
/* by the factPatternNode data structures */
/* in the binary image. */
/*========================================*/
space = FactBinaryData(theEnv,execStatus)->NumberOfPatterns * sizeof(struct bsaveFactPatternNode);
GenWrite(&space,sizeof(size_t),fp);
/*===========================*/
/* Loop through each module. */
/*===========================*/
for (theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,execStatus,NULL);
theModule != NULL;
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,execStatus,theModule))
{
/*=====================================================*/
/* Loop through each deftemplate in the current module */
/* and save its fact pattern network to the file. */
/*=====================================================*/
EnvSetCurrentModule(theEnv,execStatus,(void *) theModule);
for (theDeftemplate = (struct deftemplate *) EnvGetNextDeftemplate(theEnv,execStatus,NULL);
theDeftemplate != NULL;
theDeftemplate = (struct deftemplate *) EnvGetNextDeftemplate(theEnv,execStatus,theDeftemplate))
{ BsaveDriver(theEnv,execStatus,BSAVE_PATTERNS,fp,theDeftemplate->patternNetwork); }
}
/*=============================================================*/
/* If a binary image was already loaded when the bsave command */
/* was issued, then restore the counts indicating the number */
/* of factPatternNode data structures in the binary image */
/* (these were overwritten by the binary save). */
/*=============================================================*/
RestoreBloadCount(theEnv,execStatus,&FactBinaryData(theEnv,execStatus)->NumberOfPatterns);
}
static void BsaveBinaryItem(
FILE *fp)
{
unsigned long int space;
struct defrule *theDefrule;
#if FUZZY_DEFTEMPLATES
struct defrule *theDisjunct;
#endif
struct defmodule *theModule;
struct defruleModule *theModuleItem;
struct bsaveDefruleModule tempDefruleModule;
#if CERTAINTY_FACTORS
long int disjunctExpressionCountCF = 0L;
#endif
/*===============================================*/
/* Write out the space required by the defrules. */
/*===============================================*/
space = (NumberOfDefrules * sizeof(struct bsaveDefrule)) +
(NumberOfJoins * sizeof(struct bsaveJoinNode)) +
#if FUZZY_DEFTEMPLATES
(NumberOfPatternFuzzyValues * sizeof(struct fzSlotLocator)) +
#endif
(NumberOfDefruleModules * sizeof(struct bsaveDefruleModule));
GenWrite(&space,(unsigned long) sizeof(unsigned long int),fp);
/*===============================================*/
/* Write out each defrule module data structure. */
/*===============================================*/
NumberOfDefrules = 0;
#if FUZZY_DEFTEMPLATES
NumberOfPatternFuzzyValues = 0;
#endif
for (theModule = (struct defmodule *) GetNextDefmodule(NULL);
theModule != NULL;
theModule = (struct defmodule *) GetNextDefmodule(theModule))
{
SetCurrentModule((void *) theModule);
theModuleItem = (struct defruleModule *)
GetModuleItem(NULL,FindModuleItem("defrule")->moduleIndex);
AssignBsaveDefmdlItemHdrVals(&tempDefruleModule.header,
&theModuleItem->header);
GenWrite(&tempDefruleModule,(unsigned long) sizeof(struct bsaveDefruleModule),fp);
}
/*========================================*/
/* Write out each defrule data structure. */
/*========================================*/
for (theModule = (struct defmodule *) GetNextDefmodule(NULL);
theModule != NULL;
theModule = (struct defmodule *) GetNextDefmodule(theModule))
{
SetCurrentModule((void *) theModule);
for (theDefrule = (struct defrule *) GetNextDefrule(NULL);
theDefrule != NULL;
theDefrule = (struct defrule *) GetNextDefrule(theDefrule))
{ BsaveDisjuncts(fp,theDefrule); }
}
#if FUZZY_DEFTEMPLATES
/*====================================*/
/* Write out the PatternFuzzyValues . */
/*====================================*/
theModule = (struct defmodule *) GetNextDefmodule(NULL);
while (theModule != NULL)
{
SetCurrentModule((VOID *) theModule);
theDefrule = (struct defrule *) GetNextDefrule(NULL);
while (theDefrule != NULL)
{
theDisjunct = theDefrule;
while (theDisjunct != NULL)
{
int i;
struct bsaveFzSlotLocator tempFZSlotLocator;
for (i=0; i<theDisjunct->numberOfFuzzySlots; i++)
{
FUZZY_VALUE_HN *fvhnPtr;
struct fzSlotLocator *fvSLPtr;
fvSLPtr = theDisjunct->pattern_fv_arrayPtr + i;
fvhnPtr = fvSLPtr->fvhnPtr;
tempFZSlotLocator.patternNum = fvSLPtr->patternNum;
tempFZSlotLocator.slotNum = fvSLPtr->slotNum;
tempFZSlotLocator.fvhnPtr = fvhnPtr->bucket;
GenWrite(&tempFZSlotLocator,(unsigned long) sizeof(struct bsaveFzSlotLocator),fp);
}
theDisjunct = theDisjunct->disjunct;
}
theDefrule = (struct defrule *) GetNextDefrule(theDefrule);
}
theModule = (struct defmodule *) GetNextDefmodule(theModule);
}
#endif
/*=============================*/
/* Write out the Rete Network. */
/*=============================*/
MarkRuleNetwork(1);
BsaveJoins(fp);
/*=============================================================*/
/* If a binary image was already loaded when the bsave command */
/* was issued, then restore the counts indicating the number */
/* of defrules, defrule modules, and joins in the binary image */
/* (these were overwritten by the binary save). */
/*=============================================================*/
if (Bloaded())
{
RestoreBloadCount(&NumberOfDefruleModules);
RestoreBloadCount(&NumberOfDefrules);
RestoreBloadCount(&NumberOfJoins);
#if FUZZY_DEFTEMPLATES
RestoreBloadCount(&NumberOfPatternFuzzyValues);
#endif
}
}
/****************************************************************************************
NAME : BsaveGenerics
DESCRIPTION : Writes out generic function in binary format
Space required (unsigned long)
All generic modules (sizeof(DEFGENERIC_MODULE) * Number of generic modules)
All generic headers (sizeof(DEFGENERIC) * Number of generics)
All methods (sizeof(DEFMETHOD) * Number of methods)
All method restrictions (sizeof(RESTRICTION) * Number of restrictions)
All restriction type arrays (sizeof(void *) * # of types)
INPUTS : File pointer of binary file
RETURNS : Nothing useful
SIDE EFFECTS : Binary file adjusted
NOTES : None
****************************************************************************************/
static void BsaveGenerics(
FILE *fp)
{
struct defmodule *theModule;
DEFGENERIC_MODULE *theModuleItem;
unsigned long space;
BSAVE_DEFGENERIC_MODULE dummy_generic_module;
/* =====================================================================
Space is: Sum over all structures(sizeof(structure) * structure-cnt))
===================================================================== */
space = ((unsigned long) ModuleCount * (unsigned long) sizeof(BSAVE_DEFGENERIC_MODULE)) +
((unsigned long) GenericCount * (unsigned long) sizeof(BSAVE_GENERIC)) +
((unsigned long) MethodCount * (unsigned long) sizeof(BSAVE_METHOD)) +
((unsigned long) RestrictionCount * (unsigned long) sizeof(BSAVE_RESTRICTION)) +
((unsigned long) TypeCount * (unsigned long) sizeof(unsigned long));
/* ================================================================
Write out the total amount of space required: modules,headers,
methods, restrictions, types
================================================================ */
GenWrite((void *) &space,(unsigned long) sizeof(unsigned long),fp);
/* ======================================
Write out the generic function modules
====================================== */
GenericCount = 0L;
theModule = (struct defmodule *) GetNextDefmodule(NULL);
while (theModule != NULL)
{
theModuleItem = (DEFGENERIC_MODULE *)
GetModuleItem(theModule,FindModuleItem("defgeneric")->moduleIndex);
AssignBsaveDefmdlItemHdrVals(&dummy_generic_module.header,
&theModuleItem->header);
GenWrite((void *) &dummy_generic_module,
(unsigned long) sizeof(BSAVE_DEFGENERIC_MODULE),fp);
theModule = (struct defmodule *) GetNextDefmodule((void *) theModule);
}
/* ======================================
Write out the generic function headers
====================================== */
MethodCount = 0L;
DoForAllConstructs(BsaveDefgenericHeader,DefgenericModuleIndex,
FALSE,(void *) fp);
/* =====================
Write out the methods
===================== */
RestrictionCount = 0L;
DoForAllConstructs(BsaveMethods,DefgenericModuleIndex,
FALSE,(void *) fp);
/* =================================
Write out the method restrictions
================================= */
TypeCount = 0L;
DoForAllConstructs(BsaveMethodRestrictions,DefgenericModuleIndex,
FALSE,(void *) fp);
/* =============================================================
Finally, write out the type lists for the method restrictions
============================================================= */
DoForAllConstructs(BsaveRestrictionTypes,DefgenericModuleIndex,
FALSE,(void *) fp);
if (Bloaded())
{
RestoreBloadCount(&ModuleCount);
RestoreBloadCount(&GenericCount);
RestoreBloadCount(&MethodCount);
RestoreBloadCount(&RestrictionCount);
RestoreBloadCount(&TypeCount);
}
}
/***************************************************
NAME : BsaveObjectPatterns
DESCRIPTION : Writes ouyt object pattern data
structures to binary save file
INPUTS : Bsave file stream pointer
RETURNS : Nothing useful
SIDE EFFECTS : Data structures written
NOTES : Extra padding written with alpha
node bitmaps to ensure correct
alignment of structues on bload
***************************************************/
static void BsaveObjectPatterns(
void *theEnv,
EXEC_STATUS,
FILE *fp)
{
size_t space;
OBJECT_ALPHA_NODE *alphaPtr;
OBJECT_PATTERN_NODE *patternPtr;
BSAVE_OBJECT_ALPHA_NODE dummyAlpha;
BSAVE_OBJECT_PATTERN_NODE dummyPattern;
space = (sizeof(BSAVE_OBJECT_ALPHA_NODE) * ObjectReteBinaryData(theEnv,execStatus)->AlphaNodeCount) +
(sizeof(BSAVE_OBJECT_PATTERN_NODE) * ObjectReteBinaryData(theEnv,execStatus)->PatternNodeCount);
GenWrite(&space,sizeof(size_t),fp);
/* ==========================================
Write out the alpha terminal pattern nodes
========================================== */
alphaPtr = ObjectNetworkTerminalPointer(theEnv,execStatus);
while (alphaPtr != NULL)
{
AssignBsavePatternHeaderValues(theEnv,execStatus,&dummyAlpha.header,&alphaPtr->header);
dummyAlpha.classbmp = (long) alphaPtr->classbmp->bucket;
if (alphaPtr->slotbmp != NULL)
dummyAlpha.slotbmp = (long) alphaPtr->slotbmp->bucket;
else
dummyAlpha.slotbmp = -1L;
dummyAlpha.patternNode = BsaveObjectPatternIndex(alphaPtr->patternNode);
dummyAlpha.nxtInGroup = BsaveObjectAlphaIndex(alphaPtr->nxtInGroup);
dummyAlpha.nxtTerminal = BsaveObjectAlphaIndex(alphaPtr->nxtTerminal);
GenWrite(&dummyAlpha,sizeof(BSAVE_OBJECT_ALPHA_NODE),fp);
alphaPtr = alphaPtr->nxtTerminal;
}
/* ========================================
Write out the intermediate pattern nodes
======================================== */
patternPtr = ObjectNetworkPointer(theEnv,execStatus);
while (patternPtr != NULL)
{
dummyPattern.multifieldNode = patternPtr->multifieldNode;
dummyPattern.whichField = patternPtr->whichField;
dummyPattern.leaveFields = patternPtr->leaveFields;
dummyPattern.endSlot = patternPtr->endSlot;
dummyPattern.selector = patternPtr->selector;
dummyPattern.slotNameID = patternPtr->slotNameID;
dummyPattern.networkTest = HashedExpressionIndex(theEnv,execStatus,patternPtr->networkTest);
dummyPattern.nextLevel = BsaveObjectPatternIndex(patternPtr->nextLevel);
dummyPattern.lastLevel = BsaveObjectPatternIndex(patternPtr->lastLevel);
dummyPattern.leftNode = BsaveObjectPatternIndex(patternPtr->leftNode);
dummyPattern.rightNode = BsaveObjectPatternIndex(patternPtr->rightNode);
dummyPattern.alphaNode = BsaveObjectAlphaIndex(patternPtr->alphaNode);
GenWrite(&dummyPattern,sizeof(BSAVE_OBJECT_PATTERN_NODE),fp);
if (patternPtr->nextLevel == NULL)
{
while (patternPtr->rightNode == NULL)
{
patternPtr = patternPtr->lastLevel;
if (patternPtr == NULL)
{
RestoreBloadCount(theEnv,execStatus,&ObjectReteBinaryData(theEnv,execStatus)->AlphaNodeCount);
RestoreBloadCount(theEnv,execStatus,&ObjectReteBinaryData(theEnv,execStatus)->PatternNodeCount);
return;
}
}
patternPtr = patternPtr->rightNode;
}
else
patternPtr = patternPtr->nextLevel;
}
RestoreBloadCount(theEnv,execStatus,&ObjectReteBinaryData(theEnv,execStatus)->AlphaNodeCount);
RestoreBloadCount(theEnv,execStatus,&ObjectReteBinaryData(theEnv,execStatus)->PatternNodeCount);
}
static void BsaveBinaryItem(
void *theEnv,
FILE *fp)
{
unsigned long int space;
struct defmodule *defmodulePtr;
struct bsaveDefmodule newDefmodule;
struct bsavePortItem newPortItem;
struct portItem *theList;
/*=========================================================*/
/* Write out the amount of space taken up by the defmodule */
/* and port item data structures in the binary image. */
/*=========================================================*/
space = DefmoduleData(theEnv)->BNumberOfDefmodules * sizeof(struct bsaveDefmodule);
space += DefmoduleData(theEnv)->NumberOfPortItems * sizeof(struct bsavePortItem);
GenWrite(&space,(unsigned long) sizeof(unsigned long int),fp);
/*==========================================*/
/* Write out each defmodule data structure. */
/*==========================================*/
DefmoduleData(theEnv)->BNumberOfDefmodules = 0;
DefmoduleData(theEnv)->NumberOfPortItems = 0;
for (defmodulePtr = (struct defmodule *) EnvGetNextDefmodule(theEnv,NULL);
defmodulePtr != NULL;
defmodulePtr = (struct defmodule *) EnvGetNextDefmodule(theEnv,defmodulePtr))
{
newDefmodule.name = defmodulePtr->name->bucket;
DefmoduleData(theEnv)->BNumberOfDefmodules++;
if (defmodulePtr->next != NULL)
{ newDefmodule.next = DefmoduleData(theEnv)->BNumberOfDefmodules; }
else
{ newDefmodule.next = -1L; }
if (defmodulePtr->importList == NULL)
{ newDefmodule.importList = -1L; }
else
{
newDefmodule.importList = DefmoduleData(theEnv)->NumberOfPortItems;
for (theList = defmodulePtr->importList;
theList != NULL;
theList = theList->next)
{ DefmoduleData(theEnv)->NumberOfPortItems++; }
}
if (defmodulePtr->exportList == NULL)
{ newDefmodule.exportList = -1L; }
else
{
newDefmodule.exportList = DefmoduleData(theEnv)->NumberOfPortItems;
for (theList = defmodulePtr->exportList;
theList != NULL;
theList = theList->next)
{ DefmoduleData(theEnv)->NumberOfPortItems++; }
}
newDefmodule.bsaveID = defmodulePtr->bsaveID;
GenWrite(&newDefmodule,(unsigned long) sizeof(struct bsaveDefmodule),fp);
}
/*==========================================*/
/* Write out each port item data structure. */
/*==========================================*/
DefmoduleData(theEnv)->NumberOfPortItems = 0;
defmodulePtr = (struct defmodule *) EnvGetNextDefmodule(theEnv,NULL);
while (defmodulePtr != NULL)
{
for (theList = defmodulePtr->importList;
theList != NULL;
theList = theList->next)
{
DefmoduleData(theEnv)->NumberOfPortItems++;
if (theList->moduleName == NULL) newPortItem.moduleName = -1L;
else newPortItem.moduleName = (long) theList->moduleName->bucket;
if (theList->constructType == NULL) newPortItem.constructType = -1L;
else newPortItem.constructType = (long) theList->constructType->bucket;
if (theList->constructName == NULL) newPortItem.constructName = -1L;
else newPortItem.constructName = (long) theList->constructName->bucket;
if (theList->next == NULL) newPortItem.next = -1L;
else newPortItem.next = DefmoduleData(theEnv)->NumberOfPortItems;
GenWrite(&newPortItem,(unsigned long) sizeof(struct bsavePortItem),fp);
}
for (theList = defmodulePtr->exportList;
theList != NULL;
theList = theList->next)
{
DefmoduleData(theEnv)->NumberOfPortItems++;
if (theList->moduleName == NULL) newPortItem.moduleName = -1L;
else newPortItem.moduleName = (long) theList->moduleName->bucket;
if (theList->constructType == NULL) newPortItem.constructType = -1L;
else newPortItem.constructType = (long) theList->constructType->bucket;
if (theList->constructName == NULL) newPortItem.constructName = -1L;
else newPortItem.constructName = (long) theList->constructName->bucket;
if (theList->next == NULL) newPortItem.next = -1L;
else newPortItem.next = DefmoduleData(theEnv)->NumberOfPortItems;
GenWrite(&newPortItem,(unsigned long) sizeof(struct bsavePortItem),fp);
}
defmodulePtr = (struct defmodule *) EnvGetNextDefmodule(theEnv,defmodulePtr);
}
/*=============================================================*/
/* If a binary image was already loaded when the bsave command */
/* was issued, then restore the counts indicating the number */
/* of defmodule and port items in the binary image (these were */
/* overwritten by the binary save). */
/*=============================================================*/
RestoreBloadCount(theEnv,&DefmoduleData(theEnv)->BNumberOfDefmodules);
RestoreBloadCount(theEnv,&DefmoduleData(theEnv)->NumberOfPortItems);
}
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 BsaveBinaryItem(
void *theEnv,
FILE *fp)
{
unsigned long int space;
struct defrule *theDefrule;
struct defmodule *theModule;
struct defruleModule *theModuleItem;
struct bsaveDefruleModule tempDefruleModule;
/*===============================================*/
/* Write out the space required by the defrules. */
/*===============================================*/
space = (DefruleBinaryData(theEnv)->NumberOfDefrules * sizeof(struct bsaveDefrule)) +
(DefruleBinaryData(theEnv)->NumberOfJoins * sizeof(struct bsaveJoinNode)) +
(DefruleBinaryData(theEnv)->NumberOfDefruleModules * sizeof(struct bsaveDefruleModule));
GenWrite(&space,(unsigned long) sizeof(unsigned long int),fp);
/*===============================================*/
/* Write out each defrule module data structure. */
/*===============================================*/
DefruleBinaryData(theEnv)->NumberOfDefrules = 0;
for (theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,NULL);
theModule != NULL;
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,theModule))
{
EnvSetCurrentModule(theEnv,(void *) theModule);
theModuleItem = (struct defruleModule *)
GetModuleItem(theEnv,NULL,FindModuleItem(theEnv,"defrule")->moduleIndex);
AssignBsaveDefmdlItemHdrVals(&tempDefruleModule.header,
&theModuleItem->header);
GenWrite(&tempDefruleModule,(unsigned long) sizeof(struct bsaveDefruleModule),fp);
}
/*========================================*/
/* Write out each defrule data structure. */
/*========================================*/
for (theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,NULL);
theModule != NULL;
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,theModule))
{
EnvSetCurrentModule(theEnv,(void *) theModule);
for (theDefrule = (struct defrule *) EnvGetNextDefrule(theEnv,NULL);
theDefrule != NULL;
theDefrule = (struct defrule *) EnvGetNextDefrule(theEnv,theDefrule))
{ BsaveDisjuncts(theEnv,fp,theDefrule); }
}
/*=============================*/
/* Write out the Rete Network. */
/*=============================*/
MarkRuleNetwork(theEnv,1);
BsaveJoins(theEnv,fp);
/*=============================================================*/
/* If a binary image was already loaded when the bsave command */
/* was issued, then restore the counts indicating the number */
/* of defrules, defrule modules, and joins in the binary image */
/* (these were overwritten by the binary save). */
/*=============================================================*/
RestoreBloadCount(theEnv,&DefruleBinaryData(theEnv)->NumberOfDefruleModules);
RestoreBloadCount(theEnv,&DefruleBinaryData(theEnv)->NumberOfDefrules);
RestoreBloadCount(theEnv,&DefruleBinaryData(theEnv)->NumberOfJoins);
}
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 : BsaveObjects
DESCRIPTION : Writes out classes and message-handlers in binary format
Space required (unsigned long)
Followed by the data structures in order
INPUTS : File pointer of binary file
RETURNS : Nothing useful
SIDE EFFECTS : Binary file adjusted
NOTES : None
*************************************************************************************/
static void BsaveObjects(
FILE *fp)
{
UNLN space;
struct defmodule *theModule;
DEFCLASS_MODULE *theModuleItem;
BSAVE_DEFCLASS_MODULE dummy_mitem;
BSAVE_SLOT_NAME dummy_slot_name;
SLOT_NAME *snp;
register unsigned i;
if ((ClassCount == 0L) && (HandlerCount == 0L))
{
space = 0L;
GenWrite((void *) &space,(UNLN) sizeof(UNLN),fp);
return;
}
space = (ModuleCount * (UNLN) sizeof(BSAVE_DEFCLASS_MODULE)) +
(ClassCount * (UNLN) sizeof(BSAVE_DEFCLASS)) +
(LinkCount * (UNLN) sizeof(long)) +
(SlotCount * (UNLN) sizeof(BSAVE_SLOT_DESC)) +
(SlotNameCount * (UNLN) sizeof(BSAVE_SLOT_NAME)) +
(TemplateSlotCount * (UNLN) sizeof(long)) +
(SlotNameMapCount * (UNLN) sizeof(unsigned)) +
(HandlerCount * (UNLN) sizeof(BSAVE_HANDLER)) +
(HandlerCount * (UNLN) sizeof(unsigned));
GenWrite((void *) &space,(UNLN) sizeof(UNLN),fp);
ClassCount = 0L;
LinkCount = 0L;
SlotCount = 0L;
SlotNameCount = 0L;
TemplateSlotCount = 0L;
SlotNameMapCount = 0L;
HandlerCount = 0L;
/* =================================
Write out each defclass module
================================= */
theModule = (struct defmodule *) GetNextDefmodule(NULL);
while (theModule != NULL)
{
theModuleItem = (DEFCLASS_MODULE *)
GetModuleItem(theModule,FindModuleItem("defclass")->moduleIndex);
AssignBsaveDefmdlItemHdrVals(&dummy_mitem.header,&theModuleItem->header);
GenWrite((void *) &dummy_mitem,(unsigned long) sizeof(BSAVE_DEFCLASS_MODULE),fp);
theModule = (struct defmodule *) GetNextDefmodule((void *) theModule);
}
/* =====================
Write out the classes
===================== */
DoForAllConstructs(BsaveDefclass,DefclassModuleIndex,FALSE,(void *) fp);
/* =========================
Write out the class links
========================= */
LinkCount = 0L;
DoForAllConstructs(BsaveClassLinks,DefclassModuleIndex,FALSE,(void *) fp);
/* ===============================
Write out the slot name entries
=============================== */
for (i = 0 ; i < SLOT_NAME_TABLE_HASH_SIZE ; i++)
for (snp = SlotNameTable[i] ; snp != NULL ; snp = snp->nxt)
{
if ((snp->id != ISA_ID) && (snp->id != NAME_ID))
{
dummy_slot_name.id = snp->id;
dummy_slot_name.hashTableIndex = snp->hashTableIndex;
dummy_slot_name.name = (long) snp->name->bucket;
dummy_slot_name.putHandlerName = (long) snp->putHandlerName->bucket;
GenWrite((void *) &dummy_slot_name,(UNLN) sizeof(BSAVE_SLOT_NAME),fp);
}
}
/* ===================
Write out the slots
=================== */
DoForAllConstructs(BsaveSlots,DefclassModuleIndex,FALSE,(void *) fp);
/* =====================================
Write out the template instance slots
===================================== */
DoForAllConstructs(BsaveTemplateSlots,DefclassModuleIndex,FALSE,(void *) fp);
/* =============================================
Write out the ordered instance slot name maps
============================================= */
DoForAllConstructs(BsaveSlotMap,DefclassModuleIndex,FALSE,(void *) fp);
/* ==============================
Write out the message-handlers
============================== */
DoForAllConstructs(BsaveHandlers,DefclassModuleIndex,FALSE,(void *) fp);
/* ==========================================
Write out the ordered message-handler maps
========================================== */
DoForAllConstructs(BsaveHandlerMap,DefclassModuleIndex,FALSE,(void *) fp);
if (Bloaded())
{
RestoreBloadCount(&ModuleCount);
RestoreBloadCount(&ClassCount);
RestoreBloadCount(&LinkCount);
RestoreBloadCount(&SlotCount);
RestoreBloadCount(&SlotNameCount);
RestoreBloadCount(&TemplateSlotCount);
RestoreBloadCount(&SlotNameMapCount);
RestoreBloadCount(&HandlerCount);
}
}
/****************************************************************************************
NAME : BsaveGenerics
DESCRIPTION : Writes out generic function in binary format
Space required (unsigned long)
All generic modules (sizeof(DEFGENERIC_MODULE) * Number of generic modules)
All generic headers (sizeof(DEFGENERIC) * Number of generics)
All methods (sizeof(DEFMETHOD) * Number of methods)
All method restrictions (sizeof(RESTRICTION) * Number of restrictions)
All restriction type arrays (sizeof(void *) * # of types)
INPUTS : File pointer of binary file
RETURNS : Nothing useful
SIDE EFFECTS : Binary file adjusted
NOTES : None
****************************************************************************************/
static void BsaveGenerics(
void *theEnv,
FILE *fp)
{
struct defmodule *theModule;
DEFGENERIC_MODULE *theModuleItem;
size_t space;
BSAVE_DEFGENERIC_MODULE dummy_generic_module;
/* =====================================================================
Space is: Sum over all structures(sizeof(structure) * structure-cnt))
===================================================================== */
space = ((unsigned long) DefgenericBinaryData(theEnv)->ModuleCount * sizeof(BSAVE_DEFGENERIC_MODULE)) +
((unsigned long) DefgenericBinaryData(theEnv)->GenericCount * sizeof(BSAVE_GENERIC)) +
((unsigned long) DefgenericBinaryData(theEnv)->MethodCount * sizeof(BSAVE_METHOD)) +
((unsigned long) DefgenericBinaryData(theEnv)->RestrictionCount * sizeof(BSAVE_RESTRICTION)) +
((unsigned long) DefgenericBinaryData(theEnv)->TypeCount * sizeof(unsigned long));
/* ================================================================
Write out the total amount of space required: modules,headers,
methods, restrictions, types
================================================================ */
GenWrite((void *) &space,sizeof(size_t),fp);
/* ======================================
Write out the generic function modules
====================================== */
DefgenericBinaryData(theEnv)->GenericCount = 0L;
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,NULL);
while (theModule != NULL)
{
theModuleItem = (DEFGENERIC_MODULE *)
GetModuleItem(theEnv,theModule,FindModuleItem(theEnv,"defgeneric")->moduleIndex);
AssignBsaveDefmdlItemHdrVals(&dummy_generic_module.header,
&theModuleItem->header);
GenWrite((void *) &dummy_generic_module,
sizeof(BSAVE_DEFGENERIC_MODULE),fp);
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,(void *) theModule);
}
/* ======================================
Write out the generic function headers
====================================== */
DefgenericBinaryData(theEnv)->MethodCount = 0L;
DoForAllConstructs(theEnv,BsaveDefgenericHeader,DefgenericData(theEnv)->DefgenericModuleIndex,
false,(void *) fp);
/* =====================
Write out the methods
===================== */
DefgenericBinaryData(theEnv)->RestrictionCount = 0L;
DoForAllConstructs(theEnv,BsaveMethods,DefgenericData(theEnv)->DefgenericModuleIndex,
false,(void *) fp);
/* =================================
Write out the method restrictions
================================= */
DefgenericBinaryData(theEnv)->TypeCount = 0L;
DoForAllConstructs(theEnv,BsaveMethodRestrictions,DefgenericData(theEnv)->DefgenericModuleIndex,
false,(void *) fp);
/* =============================================================
Finally, write out the type lists for the method restrictions
============================================================= */
DoForAllConstructs(theEnv,BsaveRestrictionTypes,DefgenericData(theEnv)->DefgenericModuleIndex,
false,(void *) fp);
RestoreBloadCount(theEnv,&DefgenericBinaryData(theEnv)->ModuleCount);
RestoreBloadCount(theEnv,&DefgenericBinaryData(theEnv)->GenericCount);
RestoreBloadCount(theEnv,&DefgenericBinaryData(theEnv)->MethodCount);
RestoreBloadCount(theEnv,&DefgenericBinaryData(theEnv)->RestrictionCount);
RestoreBloadCount(theEnv,&DefgenericBinaryData(theEnv)->TypeCount);
}
/***************************************************
NAME : BsaveObjectPatterns
DESCRIPTION : Writes ouyt object pattern data
structures to binary save file
INPUTS : Bsave file stream pointer
RETURNS : Nothing useful
SIDE EFFECTS : Data structures written
NOTES : Extra padding written with alpha
node bitmaps to ensure correct
alignment of structues on bload
***************************************************/
static void BsaveObjectPatterns(
FILE *fp)
{
UNLN space;
OBJECT_ALPHA_NODE *alphaPtr;
OBJECT_PATTERN_NODE *patternPtr;
BSAVE_OBJECT_ALPHA_NODE dummyAlpha;
BSAVE_OBJECT_PATTERN_NODE dummyPattern;
space = (sizeof(BSAVE_OBJECT_ALPHA_NODE) * AlphaNodeCount) +
(sizeof(BSAVE_OBJECT_PATTERN_NODE) * PatternNodeCount);
GenWrite(&space,(UNLN) sizeof(UNLN),fp);
/* ==========================================
Write out the alpha terminal pattern nodes
========================================== */
alphaPtr = ObjectNetworkTerminalPointer();
while (alphaPtr != NULL)
{
AssignBsavePatternHeaderValues(&dummyAlpha.header,&alphaPtr->header);
dummyAlpha.classbmp = alphaPtr->classbmp->bucket;
if (alphaPtr->slotbmp != NULL)
dummyAlpha.slotbmp = alphaPtr->slotbmp->bucket;
else
dummyAlpha.slotbmp = -1L;
dummyAlpha.patternNode = BsaveObjectPatternIndex(alphaPtr->patternNode);
dummyAlpha.nxtInGroup = BsaveObjectAlphaIndex(alphaPtr->nxtInGroup);
dummyAlpha.nxtTerminal = BsaveObjectAlphaIndex(alphaPtr->nxtTerminal);
GenWrite(&dummyAlpha,(UNLN) sizeof(BSAVE_OBJECT_ALPHA_NODE),fp);
alphaPtr = alphaPtr->nxtTerminal;
}
/* ========================================
Write out the intermediate pattern nodes
======================================== */
patternPtr = ObjectNetworkPointer();
while (patternPtr != NULL)
{
dummyPattern.multifieldNode = patternPtr->multifieldNode;
dummyPattern.whichField = patternPtr->whichField;
dummyPattern.leaveFields = patternPtr->leaveFields;
dummyPattern.endSlot = patternPtr->endSlot;
dummyPattern.slotNameID = patternPtr->slotNameID;
dummyPattern.networkTest = HashedExpressionIndex(patternPtr->networkTest);
dummyPattern.nextLevel = BsaveObjectPatternIndex(patternPtr->nextLevel);
dummyPattern.lastLevel = BsaveObjectPatternIndex(patternPtr->lastLevel);
dummyPattern.leftNode = BsaveObjectPatternIndex(patternPtr->leftNode);
dummyPattern.rightNode = BsaveObjectPatternIndex(patternPtr->rightNode);
dummyPattern.alphaNode = BsaveObjectAlphaIndex(patternPtr->alphaNode);
GenWrite(&dummyPattern,(UNLN) sizeof(BSAVE_OBJECT_PATTERN_NODE),fp);
if (patternPtr->nextLevel == NULL)
{
while (patternPtr->rightNode == NULL)
{
patternPtr = patternPtr->lastLevel;
if (patternPtr == NULL)
return;
}
patternPtr = patternPtr->rightNode;
}
else
patternPtr = patternPtr->nextLevel;
}
if (Bloaded())
{
RestoreBloadCount(&AlphaNodeCount);
RestoreBloadCount(&PatternNodeCount);
}
}
