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; } }