static void MarkDefgenericItems(
struct constructHeader *theDefgeneric,
void *userBuffer)
{
#if MAC_MPW || MAC_MCW || IBM_MCW
#pragma unused(userBuffer)
#endif
DEFGENERIC *gfunc = (DEFGENERIC *) theDefgeneric;
register unsigned i,j;
DEFMETHOD *meth;
RESTRICTION *rptr;
MarkConstructHeaderNeededItems(&gfunc->header,GenericCount++);
MethodCount += gfunc->mcnt;
for (i = 0 ; i < gfunc->mcnt ; i++)
{
meth = &gfunc->methods[i];
ExpressionCount += ExpressionSize(meth->actions);
MarkNeededItems(meth->actions);
RestrictionCount += meth->restrictionCount;
for (j = 0 ; j < meth->restrictionCount ; j++)
{
rptr = &meth->restrictions[j];
ExpressionCount += ExpressionSize(rptr->query);
MarkNeededItems(rptr->query);
TypeCount += rptr->tcnt;
}
}
}
static void MarkDefgenericItems(
void *theEnv,
struct constructHeader *theDefgeneric,
void *userBuffer)
{
#if MAC_MCW || WIN_MCW || MAC_XCD
#pragma unused(userBuffer)
#endif
DEFGENERIC *gfunc = (DEFGENERIC *) theDefgeneric;
long i,j;
DEFMETHOD *meth;
RESTRICTION *rptr;
MarkConstructHeaderNeededItems(&gfunc->header,DefgenericBinaryData(theEnv)->GenericCount++);
DefgenericBinaryData(theEnv)->MethodCount += (long) gfunc->mcnt;
for (i = 0 ; i < gfunc->mcnt ; i++)
{
meth = &gfunc->methods[i];
ExpressionData(theEnv)->ExpressionCount += ExpressionSize(meth->actions);
MarkNeededItems(theEnv,meth->actions);
DefgenericBinaryData(theEnv)->RestrictionCount += meth->restrictionCount;
for (j = 0 ; j < meth->restrictionCount ; j++)
{
rptr = &meth->restrictions[j];
ExpressionData(theEnv)->ExpressionCount += ExpressionSize(rptr->query);
MarkNeededItems(theEnv,rptr->query);
DefgenericBinaryData(theEnv)->TypeCount += rptr->tcnt;
}
}
}
static void MarkDeffunctionItems(
struct constructHeader *theDeffunction,
void *userBuffer)
{
#if MAC_MPW || MAC_MCW || IBM_MCW
#pragma unused(userBuffer)
#endif
MarkConstructHeaderNeededItems(theDeffunction,DeffunctionCount++);
ExpressionCount += ExpressionSize(((DEFFUNCTION *) theDeffunction)->code);
MarkNeededItems(((DEFFUNCTION *) theDeffunction)->code);
}
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 : MarkDeffunctionItems
DESCRIPTION : Marks the needed items for
a deffunction bsave
INPUTS : 1) The deffunction
2) User data buffer (ignored)
RETURNS : Nothing useful
SIDE EFFECTS : Needed items marked
NOTES : None
***************************************************/
static void MarkDeffunctionItems(
void *theEnv,
struct constructHeader *theDeffunction,
void *userBuffer)
{
#if MAC_XCD
#pragma unused(userBuffer)
#endif
MarkConstructHeaderNeededItems(theDeffunction,DeffunctionBinaryData(theEnv)->DeffunctionCount++);
ExpressionData(theEnv)->ExpressionCount += ExpressionSize(((DEFFUNCTION *) theDeffunction)->code);
MarkNeededItems(theEnv,((DEFFUNCTION *) theDeffunction)->code);
}
static void MarkDefinstancesItems(
void *theEnv,
struct constructHeader *theDefinstances,
void *userBuffer)
{
#if MAC_MCW || IBM_MCW || MAC_XCD
#pragma unused(userBuffer)
#endif
MarkConstructHeaderNeededItems(theDefinstances,DefinstancesBinaryData(theEnv)->DefinstancesCount++);
ExpressionData(theEnv)->ExpressionCount += ExpressionSize(((DEFINSTANCES *) theDefinstances)->mkinstance);
MarkNeededItems(theEnv,((DEFINSTANCES *) theDefinstances)->mkinstance);
}
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(
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);
}
}
}
static void MarkDefclassItems(
struct constructHeader *theDefclass,
void *buf)
{
#if MAC_MPW || MAC_MCW || IBM_MCW
#pragma unused(buf)
#endif
DEFCLASS *cls = (DEFCLASS *) theDefclass;
register unsigned i;
EXPRESSION *tmpexp;
MarkConstructHeaderNeededItems(&cls->header,ClassCount++);
LinkCount += cls->directSuperclasses.classCount +
cls->directSubclasses.classCount +
cls->allSuperclasses.classCount;
#if DEFMODULE_CONSTRUCT
cls->scopeMap->neededBitMap = TRUE;
#endif
/* ===================================================
Mark items needed by slot default value expressions
=================================================== */
for (i = 0 ; i < cls->slotCount ; i++)
{
cls->slots[i].bsaveIndex = SlotCount++;
cls->slots[i].overrideMessage->neededSymbol = TRUE;
if (cls->slots[i].defaultValue != NULL)
{
if (cls->slots[i].dynamicDefault)
{
ExpressionCount +=
ExpressionSize((EXPRESSION *) cls->slots[i].defaultValue);
MarkNeededItems((EXPRESSION *) cls->slots[i].defaultValue);
}
else
{
/* =================================================
Static default values are stotred as data objects
and must be converted into expressions
================================================= */
tmpexp =
ConvertValueToExpression((DATA_OBJECT *) cls->slots[i].defaultValue);
ExpressionCount += ExpressionSize(tmpexp);
MarkNeededItems(tmpexp);
ReturnExpression(tmpexp);
}
}
}
/* ========================================
Count canonical slots needed by defclass
======================================== */
TemplateSlotCount += cls->instanceSlotCount;
if (cls->instanceSlotCount != 0)
SlotNameMapCount += cls->maxSlotNameID + 1;
/* ===============================================
Mark items needed by defmessage-handler actions
=============================================== */
for (i = 0 ; i < cls->handlerCount ; i++)
{
cls->handlers[i].name->neededSymbol = TRUE;
ExpressionCount += ExpressionSize(cls->handlers[i].actions);
MarkNeededItems(cls->handlers[i].actions);
}
HandlerCount += cls->handlerCount;
}