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 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;
}
}
}
globle void EnvSlotAllowedClasses(
void *theEnv,
void *clsptr,
const char *sname,
DATA_OBJECT *result)
{
register int i;
register SLOT_DESC *sp;
register EXPRESSION *theExp;
if ((sp = SlotInfoSlot(theEnv,result,(DEFCLASS *) clsptr,sname,"slot-allowed-classes")) == NULL)
return;
if ((sp->constraint != NULL) ? (sp->constraint->classList == NULL) : TRUE)
{
result->type = SYMBOL;
result->value = EnvFalseSymbol(theEnv);
return;
}
result->end = ExpressionSize(sp->constraint->classList) - 1;
result->value = EnvCreateMultifield(theEnv,(unsigned long) (result->end + 1));
i = 1;
theExp = sp->constraint->classList;
while (theExp != NULL)
{
SetMFType(result->value,i,theExp->type);
SetMFValue(result->value,i,theExp->value);
theExp = theExp->nextArg;
i++;
}
}
/***************************************************
NAME : BsaveMethods
DESCRIPTION : Bsaves defgeneric methods
INPUTS : 1) The defgeneric
2) Output data file pointer
RETURNS : Nothing useful
SIDE EFFECTS : Defgeneric methods saved
NOTES : None
***************************************************/
static void BsaveMethods(
struct constructHeader *theDefgeneric,
void *userBuffer)
{
DEFGENERIC *gfunc = (DEFGENERIC *) theDefgeneric;
DEFMETHOD *meth;
BSAVE_METHOD dummy_method;
register unsigned i;
for (i = 0 ; i < gfunc->mcnt ; i++)
{
meth = &gfunc->methods[i];
dummy_method.index = meth->index;
dummy_method.restrictionCount = meth->restrictionCount;
dummy_method.minRestrictions = meth->minRestrictions;
dummy_method.maxRestrictions = meth->maxRestrictions;
dummy_method.localVarCount = meth->localVarCount;
dummy_method.system = meth->system;
if (meth->restrictions != NULL)
{
dummy_method.restrictions = RestrictionCount;
RestrictionCount += meth->restrictionCount;
}
else
dummy_method.restrictions = -1L;
if (meth->actions != NULL)
{
dummy_method.actions = ExpressionCount;
ExpressionCount += ExpressionSize(meth->actions);
}
else
dummy_method.actions = -1L;
GenWrite((void *) &dummy_method,(unsigned long) sizeof(BSAVE_METHOD),(FILE *) userBuffer);
}
}
globle void SlotAllowedValues(
void *clsptr,
char *sname,
DATA_OBJECT *result)
{
register int i;
register SLOT_DESC *sp;
register EXPRESSION *exp;
if ((sp = SlotInfoSlot(result,(DEFCLASS *) clsptr,sname,"slot-allowed-values")) == NULL)
return;
if ((sp->constraint != NULL) ? (sp->constraint->restrictionList == NULL) : TRUE)
{
result->type = SYMBOL;
result->value = FalseSymbol;
return;
}
result->end = ExpressionSize(sp->constraint->restrictionList) - 1;
result->value = CreateMultifield(result->end + 1);
i = 1;
exp = sp->constraint->restrictionList;
while (exp != NULL)
{
SetMFType(result->value,i,exp->type);
SetMFValue(result->value,i,exp->value);
exp = exp->nextArg;
i++;
}
}
/************************************************************
NAME : BsaveHandlers
DESCRIPTION : Writes class message-handlers binary data
INPUTS : 1) The defclass
2) The binary file pointer
RETURNS : Nothing useful
SIDE EFFECTS : Defclass message-handler binary data written
NOTES : None
************************************************************/
static void BsaveHandlers(
struct constructHeader *theDefclass,
void *buf)
{
DEFCLASS *cls = (DEFCLASS *) theDefclass;
register unsigned i;
BSAVE_HANDLER dummy_handler;
HANDLER *hnd;
for (i = 0 ; i < cls->handlerCount ; i++)
{
hnd = &cls->handlers[i];
dummy_handler.system = hnd->system;
dummy_handler.type = hnd->type;
dummy_handler.minParams = hnd->minParams;
dummy_handler.maxParams = hnd->maxParams;
dummy_handler.localVarCount = hnd->localVarCount;
dummy_handler.cls = DefclassIndex(hnd->cls);
dummy_handler.name = (long) hnd->name->bucket;
if (hnd->actions != NULL)
{
dummy_handler.actions = ExpressionCount;
ExpressionCount += ExpressionSize(hnd->actions);
}
else
dummy_handler.actions = -1L;
GenWrite((void *) &dummy_handler,(UNLN) sizeof(BSAVE_HANDLER),(FILE *) buf);
}
}
/******************************************************
NAME : BsaveMethodRestrictions
DESCRIPTION : Bsaves defgeneric methods' retrictions
INPUTS : 1) The defgeneric
2) Output data file pointer
RETURNS : Nothing useful
SIDE EFFECTS : Defgeneric methods' restrictions saved
NOTES : None
******************************************************/
static void BsaveMethodRestrictions(
struct constructHeader *theDefgeneric,
void *userBuffer)
{
DEFGENERIC *gfunc = (DEFGENERIC *) theDefgeneric;
BSAVE_RESTRICTION dummy_restriction;
RESTRICTION *rptr;
register unsigned i,j;
for (i = 0 ; i < gfunc->mcnt ; i++)
{
for (j = 0 ; j < gfunc->methods[i].restrictionCount ; j++)
{
rptr = &gfunc->methods[i].restrictions[j];
dummy_restriction.tcnt = rptr->tcnt;
if (rptr->types != NULL)
{
dummy_restriction.types = TypeCount;
TypeCount += rptr->tcnt;
}
else
dummy_restriction.types = -1L;
if (rptr->query != NULL)
{
dummy_restriction.query = ExpressionCount;
ExpressionCount += ExpressionSize(rptr->query);
}
else
dummy_restriction.query = -1L;
GenWrite((void *) &dummy_restriction,
(unsigned long) sizeof(BSAVE_RESTRICTION),(FILE *) userBuffer);
}
}
}
/***************************************************
NAME : BsaveSlots
DESCRIPTION : Writes class slots binary data
INPUTS : 1) The defclass
2) The binary file pointer
RETURNS : Nothing useful
SIDE EFFECTS : Defclass slots binary data written
NOTES : None
***************************************************/
static void BsaveSlots(
struct constructHeader *theDefclass,
void *buf)
{
DEFCLASS *cls = (DEFCLASS *) theDefclass;
register unsigned i;
BSAVE_SLOT_DESC dummy_slot;
SLOT_DESC *sp;
EXPRESSION *tmpexp;
for (i = 0 ; i < cls->slotCount ; i++)
{
sp = &cls->slots[i];
dummy_slot.dynamicDefault = sp->dynamicDefault;
dummy_slot.noDefault = sp->noDefault;
dummy_slot.shared = sp->shared;
dummy_slot.multiple = sp->multiple;
dummy_slot.composite = sp->composite;
dummy_slot.noInherit = sp->noInherit;
dummy_slot.noWrite = sp->noWrite;
dummy_slot.initializeOnly = sp->initializeOnly;
dummy_slot.reactive = sp->reactive;
dummy_slot.publicVisibility = sp->publicVisibility;
dummy_slot.createReadAccessor = sp->createReadAccessor;
dummy_slot.createWriteAccessor = sp->createWriteAccessor;
dummy_slot.cls = DefclassIndex(sp->cls);
dummy_slot.slotName = SlotNameIndex(sp->slotName);
dummy_slot.overrideMessage = (long) sp->overrideMessage->bucket;
if (sp->defaultValue != NULL)
{
dummy_slot.defaultValue = ExpressionCount;
if (sp->dynamicDefault)
ExpressionCount += ExpressionSize((EXPRESSION *) sp->defaultValue);
else
{
tmpexp = ConvertValueToExpression((DATA_OBJECT *) sp->defaultValue);
ExpressionCount += ExpressionSize(tmpexp);
ReturnExpression(tmpexp);
}
}
else
dummy_slot.defaultValue = -1L;
dummy_slot.constraint = ConstraintIndex(sp->constraint);
GenWrite((void *) &dummy_slot,(UNLN) sizeof(BSAVE_SLOT_DESC),(FILE *) buf);
}
}
globle void ReturnPackedExpression(
struct expr *packPtr)
{
if (packPtr != NULL)
{
rm3((void *) packPtr,(long) sizeof (struct expr) *
ExpressionSize(packPtr));
}
}
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);
}
globle struct expr *PackExpression(
struct expr *original)
{
struct expr *packPtr;
if (original == NULL) return (NULL);
packPtr = (struct expr *)
gm3((long) sizeof (struct expr) *
(long) ExpressionSize(original));
ListToPacked(original,packPtr,0L);
return(packPtr);
}
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);
}
/***************************************************
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);
}
/***************************************************
NAME : FindHashedExpressions
DESCRIPTION : Sets the bsave expression array
indices for hashed expression nodes
and marks the items needed by
these expressions
INPUTS : None
RETURNS : Nothing useful
SIDE EFFECTS : Atoms marked and ids set
NOTES : None
***************************************************/
void FindHashedExpressions(
Environment *theEnv)
{
unsigned i;
EXPRESSION_HN *exphash;
for (i = 0 ; i < EXPRESSION_HASH_SIZE ; i++)
for (exphash = ExpressionData(theEnv)->ExpressionHashTable[i] ; exphash != NULL ; exphash = exphash->next)
{
MarkNeededItems(theEnv,exphash->exp);
exphash->bsaveID = ExpressionData(theEnv)->ExpressionCount;
ExpressionData(theEnv)->ExpressionCount += ExpressionSize(exphash->exp);
}
}
globle long ExpressionSize(
struct expr *testPtr)
{
long size = 0;
while (testPtr != NULL)
{
size++;
if (testPtr->argList != NULL)
{ size += ExpressionSize(testPtr->argList); }
testPtr = testPtr->nextArg;
}
return(size);
}
/***************************************************
NAME : BsaveDefinstances
DESCRIPTION : Bsaves a definstances
INPUTS : 1) The definstances
2) Output data file pointer
RETURNS : Nothing useful
SIDE EFFECTS : Definstances saved
NOTES : None
***************************************************/
static void BsaveDefinstances(
void *theEnv,
struct constructHeader *theDefinstances,
void *userBuffer)
{
DEFINSTANCES *dptr = (DEFINSTANCES *) theDefinstances;
BSAVE_DEFINSTANCES dummy_df;
AssignBsaveConstructHeaderVals(&dummy_df.header,&dptr->header);
if (dptr->mkinstance != NULL)
{
dummy_df.mkinstance = ExpressionData(theEnv)->ExpressionCount;
ExpressionData(theEnv)->ExpressionCount += ExpressionSize(dptr->mkinstance);
}
else
dummy_df.mkinstance = -1L;
GenWrite((void *) &dummy_df,(unsigned long) sizeof(BSAVE_DEFINSTANCES),(FILE *) userBuffer);
}
/***************************************************
NAME : BsaveDeffunction
DESCRIPTION : Bsaves a deffunction
INPUTS : 1) The deffunction
2) Output data file pointer
RETURNS : Nothing useful
SIDE EFFECTS : Deffunction saved
NOTES : None
***************************************************/
static void BsaveDeffunction(
struct constructHeader *theDeffunction,
void *userBuffer)
{
DEFFUNCTION *dptr = (DEFFUNCTION *) theDeffunction;
BSAVE_DEFFUNCTION dummy_df;
AssignBsaveConstructHeaderVals(&dummy_df.header,&dptr->header);
dummy_df.minNumberOfParameters = dptr->minNumberOfParameters;
dummy_df.maxNumberOfParameters = dptr->maxNumberOfParameters;
dummy_df.numberOfLocalVars = dptr->numberOfLocalVars;
if (dptr->code != NULL)
{
dummy_df.code = ExpressionCount;
ExpressionCount += ExpressionSize(dptr->code);
}
else
dummy_df.code = -1L;
GenWrite((void *) &dummy_df,(unsigned long) sizeof(BSAVE_DEFFUNCTION),(FILE *) userBuffer);
}
static void BsaveDisjuncts(
FILE *fp,
struct defrule *theDefrule)
{
struct defrule *theDisjunct;
struct bsaveDefrule tempDefrule;
long int disjunctExpressionCount = 0L;
#if CERTAINTY_FACTORS
long int disjunctExpressionCountCF = 0L;
#endif
int first;
/*=========================================*/
/* Loop through each disjunct of the rule. */
/*=========================================*/
for (theDisjunct = theDefrule, first = TRUE;
theDisjunct != NULL;
theDisjunct = theDisjunct->disjunct, first = FALSE)
{
NumberOfDefrules++;
/*======================================*/
/* Set header and miscellaneous values. */
/*======================================*/
AssignBsaveConstructHeaderVals(&tempDefrule.header,
&theDisjunct->header);
tempDefrule.salience = theDisjunct->salience;
tempDefrule.localVarCnt = theDisjunct->localVarCnt;
tempDefrule.complexity = theDisjunct->complexity;
tempDefrule.autoFocus = theDisjunct->autoFocus;
/*=======================================*/
/* Set dynamic salience data structures. */
/*=======================================*/
#if DYNAMIC_SALIENCE
if (theDisjunct->dynamicSalience != NULL)
{
if (first)
{
tempDefrule.dynamicSalience = ExpressionCount;
disjunctExpressionCount = ExpressionCount;
ExpressionCount += ExpressionSize(theDisjunct->dynamicSalience);
}
else
{ tempDefrule.dynamicSalience = disjunctExpressionCount; }
}
else
#endif
{ tempDefrule.dynamicSalience = -1L; }
#if CERTAINTY_FACTORS
if (theDisjunct->dynamicCF != NULL)
{
if (first)
{
tempDefrule.dynamicCF = ExpressionCount;
disjunctExpressionCountCF = ExpressionCount;
ExpressionCount += ExpressionSize(theDisjunct->dynamicCF);
}
else
{ tempDefrule.dynamicCF = disjunctExpressionCountCF; }
}
else
{ tempDefrule.dynamicCF = -1L; }
#endif
/*==============================================*/
/* Set the index to the disjunct's RHS actions. */
/*==============================================*/
if (theDisjunct->actions != NULL)
{
tempDefrule.actions = ExpressionCount;
ExpressionCount += ExpressionSize(theDisjunct->actions);
}
else
{ tempDefrule.actions = -1L; }
/*=================================*/
/* Set the index to the disjunct's */
/* logical join and last join. */
/*=================================*/
#if LOGICAL_DEPENDENCIES
tempDefrule.logicalJoin = BsaveJoinIndex(theDisjunct->logicalJoin);
#else
tempDefrule.logicalJoin = -1L;
#endif
tempDefrule.lastJoin = BsaveJoinIndex(theDisjunct->lastJoin);
/*=====================================*/
/* Set the index to the next disjunct. */
/*=====================================*/
if (theDisjunct->disjunct != NULL)
{ tempDefrule.disjunct = NumberOfDefrules; }
else
{ tempDefrule.disjunct = -1L; }
#if CERTAINTY_FACTORS
tempDefrule.CF = theDisjunct->CF;
#endif
#if FUZZY_DEFTEMPLATES
tempDefrule.min_of_maxmins = theDisjunct->min_of_maxmins;
tempDefrule.lhsRuleType = theDisjunct->lhsRuleType;
tempDefrule.numberOfFuzzySlots = theDisjunct->numberOfFuzzySlots;
if (theDisjunct->numberOfFuzzySlots > 0)
tempDefrule.pattern_fv_arrayPtr = NumberOfPatternFuzzyValues;
else
tempDefrule.pattern_fv_arrayPtr = -1L;
NumberOfPatternFuzzyValues += theDisjunct->numberOfFuzzySlots;
#endif
/*=================================*/
/* Write the disjunct to the file. */
/*=================================*/
GenWrite(&tempDefrule,(unsigned long) sizeof(struct bsaveDefrule),fp);
}
}
static void 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 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;
}
static void DumpExpression(
struct expr *exprPtr)
{
while (exprPtr != NULL)
{
fprintf(ExpressionFP,"{");
fprintf(ExpressionFP,"%d,",exprPtr->type);
fprintf(ExpressionFP,"VS ");
switch (exprPtr->type)
{
case FCALL:
PrintFunctionReference(ExpressionFP,(struct FunctionDefinition *) exprPtr->value);
break;
case INTEGER:
PrintIntegerReference(ExpressionFP,(INTEGER_HN *) exprPtr->value);
break;
case FLOAT:
PrintFloatReference(ExpressionFP,(FLOAT_HN *) exprPtr->value);
break;
case PCALL:
#if DEFFUNCTION_CONSTRUCT
PrintDeffunctionReference(ExpressionFP,(DEFFUNCTION *) exprPtr->value,
ImageID,MaxIndices);
#else
fprintf(ExpressionFP,"NULL");
#endif
break;
case GCALL:
#if DEFGENERIC_CONSTRUCT
PrintGenericFunctionReference(ExpressionFP,(DEFGENERIC *) exprPtr->value,
ImageID,MaxIndices);
#else
fprintf(ExpressionFP,"NULL");
#endif
break;
case DEFTEMPLATE_PTR:
#if DEFTEMPLATE_CONSTRUCT
DeftemplateCConstructReference(ExpressionFP,exprPtr->value,ImageID,MaxIndices);
#else
fprintf(ExpressionFP,"NULL");
#endif
break;
case DEFGLOBAL_PTR:
#if DEFGLOBAL_CONSTRUCT
DefglobalCConstructReference(ExpressionFP,exprPtr->value,ImageID,MaxIndices);
#else
fprintf(ExpressionFP,"NULL");
#endif
break;
case DEFCLASS_PTR:
#if OBJECT_SYSTEM
PrintClassReference(ExpressionFP,(DEFCLASS *) exprPtr->value,ImageID,MaxIndices);
#else
fprintf(ExpressionFP,"NULL");
#endif
break;
case FACT_ADDRESS:
#if DEFTEMPLATE_CONSTRUCT
fprintf(ExpressionFP,"&DummyFact");
#else
fprintf(ExpressionFP,"NULL");
#endif
break;
case INSTANCE_ADDRESS:
#if OBJECT_SYSTEM
fprintf(ExpressionFP,"&DummyInstance");
#else
fprintf(ExpressionFP,"NULL");
#endif
break;
case STRING:
case SYMBOL:
case INSTANCE_NAME:
case GBL_VARIABLE:
PrintSymbolReference(ExpressionFP,(SYMBOL_HN *) exprPtr->value);
break;
case RVOID:
fprintf(ExpressionFP,"NULL");
break;
default:
if (PrimitivesArray[exprPtr->type] == NULL)
{ fprintf(ExpressionFP,"NULL"); }
else if (PrimitivesArray[exprPtr->type]->bitMap)
{ PrintBitMapReference(ExpressionFP,(BITMAP_HN *) exprPtr->value); }
else
{ fprintf(ExpressionFP,"NULL"); }
break;
}
fprintf(ExpressionFP,",");
ExpressionCount++;
if (exprPtr->argList == NULL)
{ fprintf(ExpressionFP,"NULL,"); }
else
{
fprintf(ExpressionFP,"&E%d_%d[%ld],",ImageID,ExpressionVersion,
ExpressionCount);
}
if (exprPtr->nextArg == NULL)
{ fprintf(ExpressionFP,"NULL}"); }
else
{
fprintf(ExpressionFP,"&E%d_%d[%ld]}",ImageID,ExpressionVersion,
ExpressionCount + ExpressionSize(exprPtr->argList));
}
if (exprPtr->argList != NULL)
{
fprintf(ExpressionFP,",\n");
DumpExpression(exprPtr->argList);
}
exprPtr = exprPtr->nextArg;
if (exprPtr != NULL) fprintf(ExpressionFP,",\n");
}
}
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 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 BsaveDisjuncts(
void *theEnv,
FILE *fp,
struct defrule *theDefrule)
{
struct defrule *theDisjunct;
struct bsaveDefrule tempDefrule;
long int disjunctExpressionCount = 0L;
int first;
/*=========================================*/
/* Loop through each disjunct of the rule. */
/*=========================================*/
for (theDisjunct = theDefrule, first = TRUE;
theDisjunct != NULL;
theDisjunct = theDisjunct->disjunct, first = FALSE)
{
DefruleBinaryData(theEnv)->NumberOfDefrules++;
/*======================================*/
/* Set header and miscellaneous values. */
/*======================================*/
AssignBsaveConstructHeaderVals(&tempDefrule.header,
&theDisjunct->header);
tempDefrule.salience = theDisjunct->salience;
tempDefrule.localVarCnt = theDisjunct->localVarCnt;
tempDefrule.complexity = theDisjunct->complexity;
tempDefrule.autoFocus = theDisjunct->autoFocus;
/*=======================================*/
/* Set dynamic salience data structures. */
/*=======================================*/
if (theDisjunct->dynamicSalience != NULL)
{
if (first)
{
tempDefrule.dynamicSalience = ExpressionData(theEnv)->ExpressionCount;
disjunctExpressionCount = ExpressionData(theEnv)->ExpressionCount;
ExpressionData(theEnv)->ExpressionCount += ExpressionSize(theDisjunct->dynamicSalience);
}
else
{ tempDefrule.dynamicSalience = disjunctExpressionCount; }
}
else
{ tempDefrule.dynamicSalience = -1L; }
/*==============================================*/
/* Set the index to the disjunct's RHS actions. */
/*==============================================*/
if (theDisjunct->actions != NULL)
{
tempDefrule.actions = ExpressionData(theEnv)->ExpressionCount;
ExpressionData(theEnv)->ExpressionCount += ExpressionSize(theDisjunct->actions);
}
else
{ tempDefrule.actions = -1L; }
/*=================================*/
/* Set the index to the disjunct's */
/* logical join and last join. */
/*=================================*/
tempDefrule.logicalJoin = BsaveJoinIndex(theDisjunct->logicalJoin);
tempDefrule.lastJoin = BsaveJoinIndex(theDisjunct->lastJoin);
/*=====================================*/
/* Set the index to the next disjunct. */
/*=====================================*/
if (theDisjunct->disjunct != NULL)
{ tempDefrule.disjunct = DefruleBinaryData(theEnv)->NumberOfDefrules; }
else
{ tempDefrule.disjunct = -1L; }
/*=================================*/
/* Write the disjunct to the file. */
/*=================================*/
GenWrite(&tempDefrule,(unsigned long) sizeof(struct bsaveDefrule),fp);
}
}
static void 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);
}
void BsaveExpression(
Environment *theEnv,
struct expr *testPtr,
FILE *fp)
{
BSAVE_EXPRESSION newTest;
unsigned long newIndex;
while (testPtr != NULL)
{
ExpressionData(theEnv)->ExpressionCount++;
/*================*/
/* Copy the type. */
/*================*/
newTest.type = testPtr->type;
/*=======================================*/
/* Convert the argList slot to an index. */
/*=======================================*/
if (testPtr->argList == NULL)
{ newTest.argList = ULONG_MAX; }
else
{ newTest.argList = ExpressionData(theEnv)->ExpressionCount; }
/*========================================*/
/* Convert the nextArg slot to an index. */
/*========================================*/
if (testPtr->nextArg == NULL)
{ newTest.nextArg = ULONG_MAX; }
else
{
newIndex = ExpressionData(theEnv)->ExpressionCount + ExpressionSize(testPtr->argList);
newTest.nextArg = newIndex;
}
/*=========================*/
/* Convert the value slot. */
/*=========================*/
switch(testPtr->type)
{
case FLOAT_TYPE:
newTest.value = testPtr->floatValue->bucket;
break;
case INTEGER_TYPE:
newTest.value = testPtr->integerValue->bucket;
break;
case FCALL:
newTest.value = testPtr->functionValue->bsaveIndex;
break;
case GCALL:
#if DEFGENERIC_CONSTRUCT
if (testPtr->value != NULL)
newTest.value = testPtr->constructValue->bsaveID;
else
#endif
newTest.value = ULONG_MAX;
break;
case PCALL:
#if DEFFUNCTION_CONSTRUCT
if (testPtr->value != NULL)
newTest.value = testPtr->constructValue->bsaveID;
else
#endif
newTest.value = ULONG_MAX;
break;
case DEFTEMPLATE_PTR:
#if DEFTEMPLATE_CONSTRUCT
if (testPtr->value != NULL)
newTest.value = testPtr->constructValue->bsaveID;
else
#endif
newTest.value = ULONG_MAX;
break;
case DEFCLASS_PTR:
#if OBJECT_SYSTEM
if (testPtr->value != NULL)
newTest.value = testPtr->constructValue->bsaveID;
else
#endif
newTest.value = ULONG_MAX;
break;
case DEFGLOBAL_PTR:
#if DEFGLOBAL_CONSTRUCT
if (testPtr->value != NULL)
newTest.value = testPtr->constructValue->bsaveID;
else
#endif
newTest.value = ULONG_MAX;
break;
#if OBJECT_SYSTEM
case INSTANCE_NAME_TYPE:
#endif
case SYMBOL_TYPE:
case GBL_VARIABLE:
case STRING_TYPE:
newTest.value = testPtr->lexemeValue->bucket;
break;
case FACT_ADDRESS_TYPE:
case INSTANCE_ADDRESS_TYPE:
case EXTERNAL_ADDRESS_TYPE:
newTest.value = ULONG_MAX;
break;
case VOID_TYPE:
break;
default:
if (EvaluationData(theEnv)->PrimitivesArray[testPtr->type] == NULL) break;
if (EvaluationData(theEnv)->PrimitivesArray[testPtr->type]->bitMap)
{ newTest.value = ((CLIPSBitMap *) testPtr->value)->bucket; }
break;
}
/*===========================*/
/* Write out the expression. */
/*===========================*/
GenWrite(&newTest,sizeof(BSAVE_EXPRESSION),fp);
/*==========================*/
/* Write out argument list. */
/*==========================*/
if (testPtr->argList != NULL)
{
BsaveExpression(theEnv,testPtr->argList,fp);
}
testPtr = testPtr->nextArg;
}
}
