/***************************************************************************
NAME : BsaveDeffunctionFind
DESCRIPTION : For all deffunctions, this routine marks all
the needed symbols.
Also, it also counts the number of
expression structures needed.
Also, counts total number of deffunctions.
INPUTS : None
RETURNS : Nothing useful
SIDE EFFECTS : ExpressionCount (a global from BSAVE.C) is incremented
for every expression needed
Symbols are marked in their structures
NOTES : Also sets bsaveIndex for each deffunction (assumes
deffunctions will be bsaved in order of binary list)
***************************************************************************/
static void BsaveDeffunctionFind(
void *theEnv)
{
SaveBloadCount(theEnv,DeffunctionBinaryData(theEnv)->ModuleCount);
SaveBloadCount(theEnv,DeffunctionBinaryData(theEnv)->DeffunctionCount);
DeffunctionBinaryData(theEnv)->DeffunctionCount = 0L;
DeffunctionBinaryData(theEnv)->ModuleCount =
DoForAllConstructs(theEnv,MarkDeffunctionItems,DeffunctionData(theEnv)->DeffunctionModuleIndex,
FALSE,NULL);
}
/***************************************************************************
NAME : BsaveDefinstancesFind
DESCRIPTION : For all definstances, this routine marks all
the needed symbols.
Also, it also counts the number of
expression structures needed.
Also, counts total number of definstances.
INPUTS : None
RETURNS : Nothing useful
SIDE EFFECTS : ExpressionCount (a global from BSAVE.C) is incremented
for every expression needed
Symbols are marked in their structures
NOTES : Also sets bsaveIndex for each definstances (assumes
definstances will be bsaved in order of binary list)
***************************************************************************/
static void BsaveDefinstancesFind(
void *theEnv)
{
SaveBloadCount(theEnv,DefinstancesBinaryData(theEnv)->ModuleCount);
SaveBloadCount(theEnv,DefinstancesBinaryData(theEnv)->DefinstancesCount);
DefinstancesBinaryData(theEnv)->DefinstancesCount = 0L;
DefinstancesBinaryData(theEnv)->ModuleCount =
DoForAllConstructs(theEnv,MarkDefinstancesItems,DefinstancesData(theEnv)->DefinstancesModuleIndex,
FALSE,NULL);
}
static void BsaveFind()
{
struct defglobal *defglobalPtr;
struct defmodule *theModule;
/*=======================================================*/
/* If a binary image is already loaded, then temporarily */
/* save the count values since these will be overwritten */
/* in the process of saving the binary image. */
/*=======================================================*/
if (Bloaded())
{
SaveBloadCount(NumberOfDefglobalModules);
SaveBloadCount(NumberOfDefglobals);
}
/*============================================*/
/* Set the count of defglobals and defglobals */
/* module data structures to zero. */
/*============================================*/
NumberOfDefglobals = 0;
NumberOfDefglobalModules = 0;
for (theModule = (struct defmodule *) GetNextDefmodule(NULL);
theModule != NULL;
theModule = (struct defmodule *) GetNextDefmodule(theModule))
{
/*================================================*/
/* Set the current module to the module being */
/* examined and increment the number of defglobal */
/* modules encountered. */
/*================================================*/
SetCurrentModule((void *) theModule);
NumberOfDefglobalModules++;
/*====================================================*/
/* Loop through each defglobal in the current module. */
/*====================================================*/
for (defglobalPtr = (struct defglobal *) GetNextDefglobal(NULL);
defglobalPtr != NULL;
defglobalPtr = (struct defglobal *) GetNextDefglobal(defglobalPtr))
{
/*======================================================*/
/* Initialize the construct header for the binary save. */
/*======================================================*/
MarkConstructHeaderNeededItems(&defglobalPtr->header,NumberOfDefglobals++);
}
}
}
/***************************************************************************
NAME : BsaveDeffunctionFind
DESCRIPTION : For all deffunctions, this routine marks all
the needed symbols.
Also, it also counts the number of
expression structures needed.
Also, counts total number of deffunctions.
INPUTS : None
RETURNS : Nothing useful
SIDE EFFECTS : ExpressionCount (a global from BSAVE.C) is incremented
for every expression needed
Symbols are marked in their structures
NOTES : Also sets bsaveIndex for each deffunction (assumes
deffunctions will be bsaved in order of binary list)
***************************************************************************/
static void BsaveDeffunctionFind()
{
if (Bloaded())
{
SaveBloadCount(ModuleCount);
SaveBloadCount(DeffunctionCount);
}
DeffunctionCount = 0L;
ModuleCount = DoForAllConstructs(MarkDeffunctionItems,DeffunctionModuleIndex,
FALSE,NULL);
}
/***************************************************************************
NAME : BsaveGenericsFind
DESCRIPTION : For all generic functions and their
methods, this routine marks all
the needed symbols and system functions.
Also, it also counts the number of
expression structures needed.
Also, counts total number of generics, methods,
restrictions and types.
INPUTS : None
RETURNS : Nothing useful
SIDE EFFECTS : ExpressionCount (a global from BSAVE.C) is incremented
for every expression needed
Symbols and system function are marked in their structures
NOTES : Also sets bsaveIndex for each generic function (assumes
generic functions will be bsaved in order of binary list)
***************************************************************************/
static void BsaveGenericsFind()
{
if (Bloaded())
{
SaveBloadCount(ModuleCount);
SaveBloadCount(GenericCount);
SaveBloadCount(MethodCount);
SaveBloadCount(RestrictionCount);
SaveBloadCount(TypeCount);
}
GenericCount = 0L;
MethodCount = 0L;
RestrictionCount = 0L;
TypeCount = 0L;
ModuleCount = DoForAllConstructs(MarkDefgenericItems,DefgenericModuleIndex,
FALSE,NULL);
}
/***************************************************************************
NAME : BsaveGenericsFind
DESCRIPTION : For all generic functions and their
methods, this routine marks all
the needed symbols and system functions.
Also, it also counts the number of
expression structures needed.
Also, counts total number of generics, methods,
restrictions and types.
INPUTS : None
RETURNS : Nothing useful
SIDE EFFECTS : ExpressionCount (a global from BSAVE.C) is incremented
for every expression needed
Symbols and system function are marked in their structures
NOTES : Also sets bsaveIndex for each generic function (assumes
generic functions will be bsaved in order of binary list)
***************************************************************************/
static void BsaveGenericsFind(
void *theEnv)
{
SaveBloadCount(theEnv,DefgenericBinaryData(theEnv)->ModuleCount);
SaveBloadCount(theEnv,DefgenericBinaryData(theEnv)->GenericCount);
SaveBloadCount(theEnv,DefgenericBinaryData(theEnv)->MethodCount);
SaveBloadCount(theEnv,DefgenericBinaryData(theEnv)->RestrictionCount);
SaveBloadCount(theEnv,DefgenericBinaryData(theEnv)->TypeCount);
DefgenericBinaryData(theEnv)->GenericCount = 0L;
DefgenericBinaryData(theEnv)->MethodCount = 0L;
DefgenericBinaryData(theEnv)->RestrictionCount = 0L;
DefgenericBinaryData(theEnv)->TypeCount = 0L;
DefgenericBinaryData(theEnv)->ModuleCount =
DoForAllConstructs(theEnv,MarkDefgenericItems,DefgenericData(theEnv)->DefgenericModuleIndex,
FALSE,NULL);
}
/***************************************************
NAME : BsaveObjectPatternsFind
DESCRIPTION : Sets the Bsave IDs for the object
pattern data structures and
determines how much space
(including padding) is necessary
for the alpha node bitmPS
INPUTS : None
RETURNS : Nothing useful
SIDE EFFECTS : Counts written
NOTES : None
***************************************************/
static void BsaveObjectPatternsFind(
void *theEnv,
EXEC_STATUS)
{
OBJECT_ALPHA_NODE *alphaPtr;
OBJECT_PATTERN_NODE *patternPtr;
SaveBloadCount(theEnv,execStatus,ObjectReteBinaryData(theEnv,execStatus)->AlphaNodeCount);
SaveBloadCount(theEnv,execStatus,ObjectReteBinaryData(theEnv,execStatus)->PatternNodeCount);
ObjectReteBinaryData(theEnv,execStatus)->AlphaNodeCount = 0L;
alphaPtr = ObjectNetworkTerminalPointer(theEnv,execStatus);
while (alphaPtr != NULL)
{
alphaPtr->classbmp->neededBitMap = TRUE;
if (alphaPtr->slotbmp != NULL)
alphaPtr->slotbmp->neededBitMap = TRUE;
alphaPtr->bsaveID = ObjectReteBinaryData(theEnv,execStatus)->AlphaNodeCount++;
alphaPtr = alphaPtr->nxtTerminal;
}
ObjectReteBinaryData(theEnv,execStatus)->PatternNodeCount = 0L;
patternPtr = ObjectNetworkPointer(theEnv,execStatus);
while (patternPtr != NULL)
{
patternPtr->bsaveID = ObjectReteBinaryData(theEnv,execStatus)->PatternNodeCount++;
if (patternPtr->nextLevel == NULL)
{
while (patternPtr->rightNode == NULL)
{
patternPtr = patternPtr->lastLevel;
if (patternPtr == NULL)
return;
}
patternPtr = patternPtr->rightNode;
}
else
patternPtr = patternPtr->nextLevel;
}
}
/***************************************************
NAME : BsaveObjectPatternsFind
DESCRIPTION : Sets the Bsave IDs for the object
pattern data structures and
determines how much space
(including padding) is necessary
for the alpha node bitmPS
INPUTS : None
RETURNS : Nothing useful
SIDE EFFECTS : Counts written
NOTES : None
***************************************************/
static void BsaveObjectPatternsFind()
{
OBJECT_ALPHA_NODE *alphaPtr;
OBJECT_PATTERN_NODE *patternPtr;
if (Bloaded())
{
SaveBloadCount(AlphaNodeCount);
SaveBloadCount(PatternNodeCount);
}
AlphaNodeCount = 0L;
alphaPtr = ObjectNetworkTerminalPointer();
while (alphaPtr != NULL)
{
alphaPtr->classbmp->neededBitMap = TRUE;
if (alphaPtr->slotbmp != NULL)
alphaPtr->slotbmp->neededBitMap = TRUE;
alphaPtr->bsaveID = AlphaNodeCount++;
alphaPtr = alphaPtr->nxtTerminal;
}
PatternNodeCount = 0L;
patternPtr = ObjectNetworkPointer();
while (patternPtr != NULL)
{
patternPtr->bsaveID = PatternNodeCount++;
if (patternPtr->nextLevel == NULL)
{
while (patternPtr->rightNode == NULL)
{
patternPtr = patternPtr->lastLevel;
if (patternPtr == NULL)
return;
}
patternPtr = patternPtr->rightNode;
}
else
patternPtr = patternPtr->nextLevel;
}
}
/***************************************************************************
NAME : BsaveObjectsFind
DESCRIPTION : For all classes and their message-handlers, this routine
marks all the needed symbols and system functions.
Also, it also counts the number of expression structures
needed.
INPUTS : None
RETURNS : Nothing useful
SIDE EFFECTS : ExpressionCount (a global from BSAVE.C) is incremented
for every expression needed
Symbols are marked in their structures
NOTES : Also sets bsaveIndex for each class (assumes classes
will be bsaved in order of binary list)
***************************************************************************/
static void BsaveObjectsFind()
{
register unsigned i;
SLOT_NAME *snp;
/* ========================================================
The counts need to be saved in case a bload is in effect
======================================================== */
if (Bloaded())
{
SaveBloadCount(ModuleCount);
SaveBloadCount(ClassCount);
SaveBloadCount(LinkCount);
SaveBloadCount(SlotNameCount);
SaveBloadCount(SlotCount);
SaveBloadCount(TemplateSlotCount);
SaveBloadCount(SlotNameMapCount);
SaveBloadCount(HandlerCount);
}
ModuleCount= 0L;
ClassCount = 0L;
SlotCount = 0L;
SlotNameCount = 0L;
LinkCount = 0L;
TemplateSlotCount = 0L;
SlotNameMapCount = 0L;
HandlerCount = 0L;
/* ==============================================
Mark items needed by defclasses in all modules
============================================== */
ModuleCount = DoForAllConstructs(MarkDefclassItems,DefclassModuleIndex,
FALSE,NULL);
/* =============================================
Mark items needed by canonicalized slot names
============================================= */
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))
{
snp->bsaveIndex = SlotNameCount++;
snp->name->neededSymbol = TRUE;
snp->putHandlerName->neededSymbol = TRUE;
}
}
}
static void BsaveFind(
void *theEnv,
EXEC_STATUS)
{
struct deftemplate *theDeftemplate;
struct defmodule *theModule;
/*=======================================================*/
/* If a binary image is already loaded, then temporarily */
/* save the count values since these will be overwritten */
/* in the process of saving the binary image. */
/*=======================================================*/
SaveBloadCount(theEnv,execStatus,FactBinaryData(theEnv,execStatus)->NumberOfPatterns);
/*=======================================*/
/* Set the count of fact pattern network */
/* data structures to zero. */
/*=======================================*/
FactBinaryData(theEnv,execStatus)->NumberOfPatterns = 0L;
/*===========================*/
/* Loop through each module. */
/*===========================*/
for (theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,execStatus,NULL);
theModule != NULL;
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,execStatus,theModule))
{
/*===============================*/
/* Set the current module to the */
/* module being examined. */
/*===============================*/
EnvSetCurrentModule(theEnv,execStatus,(void *) theModule);
/*=====================================================*/
/* Loop through each deftemplate in the current module */
/* and count the number of data structures which must */
/* be saved for its pattern network. */
/*=====================================================*/
for (theDeftemplate = (struct deftemplate *) EnvGetNextDeftemplate(theEnv,execStatus,NULL);
theDeftemplate != NULL;
theDeftemplate = (struct deftemplate *) EnvGetNextDeftemplate(theEnv,execStatus,theDeftemplate))
{ BsaveDriver(theEnv,execStatus,BSAVE_FIND,NULL,theDeftemplate->patternNetwork); }
}
}
static void BsaveFind()
{
struct defrule *theDefrule, *theDisjunct;
struct defmodule *theModule;
/*=======================================================*/
/* If a binary image is already loaded, then temporarily */
/* save the count values since these will be overwritten */
/* in the process of saving the binary image. */
/*=======================================================*/
if (Bloaded())
{
SaveBloadCount(NumberOfDefruleModules);
SaveBloadCount(NumberOfDefrules);
SaveBloadCount(NumberOfJoins);
#if FUZZY_DEFTEMPLATES
SaveBloadCount(NumberOfPatternFuzzyValues);
#endif
}
/*====================================================*/
/* Set the binary save ID for defrule data structures */
/* and count the number of each type. */
/*====================================================*/
TagRuleNetwork(&NumberOfDefruleModules,&NumberOfDefrules,&NumberOfJoins);
#if FUZZY_DEFTEMPLATES
NumberOfPatternFuzzyValues = 0;
#endif
/*===========================*/
/* Loop through each module. */
/*===========================*/
for (theModule = (struct defmodule *) GetNextDefmodule(NULL);
theModule != NULL;
theModule = (struct defmodule *) GetNextDefmodule(theModule))
{
/*============================*/
/* Set the current module to */
/* the module being examined. */
/*============================*/
SetCurrentModule((void *) theModule);
/*==================================================*/
/* Loop through each defrule in the current module. */
/*==================================================*/
for (theDefrule = (struct defrule *) GetNextDefrule(NULL);
theDefrule != NULL;
theDefrule = (struct defrule *) GetNextDefrule(theDefrule))
{
/*================================================*/
/* Initialize the construct header for the binary */
/* save. The binary save ID has already been set. */
/*================================================*/
MarkConstructHeaderNeededItems(&theDefrule->header,theDefrule->header.bsaveID);
/*===========================================*/
/* Count and mark data structures associated */
/* with dynamic salience. */
/*===========================================*/
#if DYNAMIC_SALIENCE
ExpressionCount += ExpressionSize(theDefrule->dynamicSalience);
MarkNeededItems(theDefrule->dynamicSalience);
#endif
#if CERTAINTY_FACTORS
ExpressionCount += ExpressionSize(theDefrule->dynamicCF);
MarkNeededItems(theDefrule->dynamicCF);
#endif
/*==========================================*/
/* Loop through each disjunct of the rule */
/* counting and marking the data structures */
/* associated with RHS actions. */
/*==========================================*/
for (theDisjunct = theDefrule;
theDisjunct != NULL;
theDisjunct = theDisjunct->disjunct)
{
ExpressionCount += ExpressionSize(theDisjunct->actions);
MarkNeededItems(theDisjunct->actions);
#if FUZZY_DEFTEMPLATES
/* count the number of PatternFuzzyValues store with each rule
and mark all of the FuzzyValues pointed to as needed
*/
if (theDisjunct->numberOfFuzzySlots > 0)
{ int i;
FUZZY_VALUE_HN *fvhnPtr;
struct fzSlotLocator *fvSLPtr;
NumberOfPatternFuzzyValues += theDisjunct->numberOfFuzzySlots;
for (i= 0; i<theDisjunct->numberOfFuzzySlots; i++)
{
fvSLPtr = theDisjunct->pattern_fv_arrayPtr + i;
fvhnPtr = fvSLPtr->fvhnPtr;
if (fvhnPtr != NULL)
{ fvhnPtr->neededFuzzyValue = TRUE;
}
}
}
#endif
}
}
}
/*===============================*/
/* Reset the bsave tags assigned */
/* to defrule data structures. */
/*===============================*/
MarkRuleNetwork(1);
}
static void BsaveFind(
void *theEnv)
{
struct defmodule *defmodulePtr;
struct portItem *theList;
/*=======================================================*/
/* If a binary image is already loaded, then temporarily */
/* save the count values since these will be overwritten */
/* in the process of saving the binary image. */
/*=======================================================*/
SaveBloadCount(theEnv,DefmoduleData(theEnv)->BNumberOfDefmodules);
SaveBloadCount(theEnv,DefmoduleData(theEnv)->NumberOfPortItems);
/*==========================================*/
/* Set the count of defmodule and defmodule */
/* port items data structures to zero. */
/*==========================================*/
DefmoduleData(theEnv)->BNumberOfDefmodules = 0;
DefmoduleData(theEnv)->NumberOfPortItems = 0;
/*===========================*/
/* Loop through each module. */
/*===========================*/
for (defmodulePtr = (struct defmodule *) EnvGetNextDefmodule(theEnv,NULL);
defmodulePtr != NULL;
defmodulePtr = (struct defmodule *) EnvGetNextDefmodule(theEnv,defmodulePtr))
{
/*==============================================*/
/* Increment the number of modules encountered. */
/*==============================================*/
DefmoduleData(theEnv)->BNumberOfDefmodules++;
/*===========================*/
/* Mark the defmodule's name */
/* as being a needed symbol. */
/*===========================*/
defmodulePtr->name->neededSymbol = TRUE;
/*==============================================*/
/* Loop through each of the port items in the */
/* defmodule's import list incrementing the */
/* number of port items encountered and marking */
/* needed symbols. */
/*==============================================*/
for (theList = defmodulePtr->importList;
theList != NULL;
theList = theList->next)
{
DefmoduleData(theEnv)->NumberOfPortItems++;
if (theList->moduleName != NULL)
{ theList->moduleName->neededSymbol = TRUE; }
if (theList->constructType != NULL)
{ theList->constructType->neededSymbol = TRUE; }
if (theList->constructName != NULL)
{ theList->constructName->neededSymbol = TRUE; }
}
/*==============================================*/
/* Loop through each of the port items in the */
/* defmodule's export list incrementing the */
/* number of port items encountered and marking */
/* needed symbols. */
/*==============================================*/
for (theList = defmodulePtr->exportList;
theList != NULL;
theList = theList->next)
{
DefmoduleData(theEnv)->NumberOfPortItems++;
if (theList->moduleName != NULL)
{ theList->moduleName->neededSymbol = TRUE; }
if (theList->constructType != NULL)
{ theList->constructType->neededSymbol = TRUE; }
if (theList->constructName != NULL)
{ theList->constructName->neededSymbol = TRUE; }
}
}
}
static void BsaveFind(
Environment *theEnv)
{
Deftemplate *theDeftemplate;
struct templateSlot *theSlot;
Defmodule *theModule;
/*=======================================================*/
/* If a binary image is already loaded, then temporarily */
/* save the count values since these will be overwritten */
/* in the process of saving the binary image. */
/*=======================================================*/
SaveBloadCount(theEnv,DeftemplateBinaryData(theEnv)->NumberOfDeftemplates);
SaveBloadCount(theEnv,DeftemplateBinaryData(theEnv)->NumberOfTemplateSlots);
SaveBloadCount(theEnv,DeftemplateBinaryData(theEnv)->NumberOfTemplateModules);
/*==================================================*/
/* Set the count of deftemplates, deftemplate slots */
/* and deftemplate module data structures to zero. */
/*==================================================*/
DeftemplateBinaryData(theEnv)->NumberOfDeftemplates = 0;
DeftemplateBinaryData(theEnv)->NumberOfTemplateSlots = 0;
DeftemplateBinaryData(theEnv)->NumberOfTemplateModules = 0;
/*===========================*/
/* Loop through each module. */
/*===========================*/
for (theModule = GetNextDefmodule(theEnv,NULL);
theModule != NULL;
theModule = GetNextDefmodule(theEnv,theModule))
{
/*============================================*/
/* Set the current module to the module being */
/* examined and increment the number of */
/* deftemplate modules encountered. */
/*============================================*/
SetCurrentModule(theEnv,theModule);
DeftemplateBinaryData(theEnv)->NumberOfTemplateModules++;
/*======================================================*/
/* Loop through each deftemplate in the current module. */
/*======================================================*/
for (theDeftemplate = GetNextDeftemplate(theEnv,NULL);
theDeftemplate != NULL;
theDeftemplate = GetNextDeftemplate(theEnv,theDeftemplate))
{
/*======================================================*/
/* Initialize the construct header for the binary save. */
/*======================================================*/
MarkConstructHeaderNeededItems(&theDeftemplate->header,
DeftemplateBinaryData(theEnv)->NumberOfDeftemplates++);
/*=============================================================*/
/* Loop through each slot in the deftemplate, incrementing the */
/* slot count and marking the slot names as needed symbols. */
/*=============================================================*/
for (theSlot = theDeftemplate->slotList;
theSlot != NULL;
theSlot = theSlot->next)
{
DeftemplateBinaryData(theEnv)->NumberOfTemplateSlots++;
theSlot->slotName->neededSymbol = true;
}
}
}
}
static void BsaveFind(
void *theEnv)
{
struct defrule *theDefrule, *theDisjunct;
struct defmodule *theModule;
/*=======================================================*/
/* If a binary image is already loaded, then temporarily */
/* save the count values since these will be overwritten */
/* in the process of saving the binary image. */
/*=======================================================*/
SaveBloadCount(theEnv,DefruleBinaryData(theEnv)->NumberOfDefruleModules);
SaveBloadCount(theEnv,DefruleBinaryData(theEnv)->NumberOfDefrules);
SaveBloadCount(theEnv,DefruleBinaryData(theEnv)->NumberOfJoins);
/*====================================================*/
/* Set the binary save ID for defrule data structures */
/* and count the number of each type. */
/*====================================================*/
TagRuleNetwork(theEnv,&DefruleBinaryData(theEnv)->NumberOfDefruleModules,
&DefruleBinaryData(theEnv)->NumberOfDefrules,
&DefruleBinaryData(theEnv)->NumberOfJoins);
/*===========================*/
/* Loop through each module. */
/*===========================*/
for (theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,NULL);
theModule != NULL;
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,theModule))
{
/*============================*/
/* Set the current module to */
/* the module being examined. */
/*============================*/
EnvSetCurrentModule(theEnv,(void *) theModule);
/*==================================================*/
/* Loop through each defrule in the current module. */
/*==================================================*/
for (theDefrule = (struct defrule *) EnvGetNextDefrule(theEnv,NULL);
theDefrule != NULL;
theDefrule = (struct defrule *) EnvGetNextDefrule(theEnv,theDefrule))
{
/*================================================*/
/* Initialize the construct header for the binary */
/* save. The binary save ID has already been set. */
/*================================================*/
MarkConstructHeaderNeededItems(&theDefrule->header,theDefrule->header.bsaveID);
/*===========================================*/
/* Count and mark data structures associated */
/* with dynamic salience. */
/*===========================================*/
ExpressionData(theEnv)->ExpressionCount += ExpressionSize(theDefrule->dynamicSalience);
MarkNeededItems(theEnv,theDefrule->dynamicSalience);
/*==========================================*/
/* Loop through each disjunct of the rule */
/* counting and marking the data structures */
/* associated with RHS actions. */
/*==========================================*/
for (theDisjunct = theDefrule;
theDisjunct != NULL;
theDisjunct = theDisjunct->disjunct)
{
ExpressionData(theEnv)->ExpressionCount += ExpressionSize(theDisjunct->actions);
MarkNeededItems(theEnv,theDisjunct->actions);
}
}
}
/*===============================*/
/* Reset the bsave tags assigned */
/* to defrule data structures. */
/*===============================*/
MarkRuleNetwork(theEnv,1);
}
static void BsaveFind(
void *theEnv)
{
struct deffacts *theDeffacts;
struct defmodule *theModule;
/*=======================================================*/
/* If a binary image is already loaded, then temporarily */
/* save the count values since these will be overwritten */
/* in the process of saving the binary image. */
/*=======================================================*/
SaveBloadCount(theEnv,DeffactsBinaryData(theEnv)->NumberOfDeffactsModules);
SaveBloadCount(theEnv,DeffactsBinaryData(theEnv)->NumberOfDeffacts);
/*========================================*/
/* Set the count of deffacts and deffacts */
/* module data structures to zero. */
/*========================================*/
DeffactsBinaryData(theEnv)->NumberOfDeffacts = 0;
DeffactsBinaryData(theEnv)->NumberOfDeffactsModules = 0;
/*===========================*/
/* Loop through each module. */
/*===========================*/
for (theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,NULL);
theModule != NULL;
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,theModule))
{
/*===============================================*/
/* Set the current module to the module being */
/* examined and increment the number of deffacts */
/* modules encountered. */
/*===============================================*/
EnvSetCurrentModule(theEnv,(void *) theModule);
DeffactsBinaryData(theEnv)->NumberOfDeffactsModules++;
/*===================================================*/
/* Loop through each deffacts in the current module. */
/*===================================================*/
for (theDeffacts = (struct deffacts *) EnvGetNextDeffacts(theEnv,NULL);
theDeffacts != NULL;
theDeffacts = (struct deffacts *) EnvGetNextDeffacts(theEnv,theDeffacts))
{
/*======================================================*/
/* Initialize the construct header for the binary save. */
/*======================================================*/
MarkConstructHeaderNeededItems(&theDeffacts->header,DeffactsBinaryData(theEnv)->NumberOfDeffacts++);
/*============================================================*/
/* Count the number of expressions contained in the deffacts' */
/* assertion list and mark any atomic values contained there */
/* as in use. */
/*============================================================*/
ExpressionData(theEnv)->ExpressionCount += ExpressionSize(theDeffacts->assertList);
MarkNeededItems(theEnv,theDeffacts->assertList);
}
}
}