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); }
/*************************************************** 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); }
/*************************************************** 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 void MarkNeededItems( void *theEnv, EXEC_STATUS, struct expr *testPtr) { while (testPtr != NULL) { switch (testPtr->type) { case SYMBOL: case STRING: case GBL_VARIABLE: case INSTANCE_NAME: ((SYMBOL_HN *) testPtr->value)->neededSymbol = TRUE; break; case FLOAT: ((FLOAT_HN *) testPtr->value)->neededFloat = TRUE; break; case INTEGER: ((INTEGER_HN *) testPtr->value)->neededInteger = TRUE; break; case FCALL: ((struct FunctionDefinition *) testPtr->value)->bsaveIndex = TRUE; break; case RVOID: break; default: if (EvaluationData(theEnv,execStatus)->PrimitivesArray[testPtr->type] == NULL) break; if (EvaluationData(theEnv,execStatus)->PrimitivesArray[testPtr->type]->bitMap) { ((BITMAP_HN *) testPtr->value)->neededBitMap = TRUE; } break; } if (testPtr->argList != NULL) { MarkNeededItems(theEnv,execStatus,testPtr->argList); } testPtr = testPtr->nextArg; } }
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 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; }