static void WriteBinaryHeader( void *theEnv, FILE *fp) { GenWrite(BloadData(theEnv)->BinaryPrefixID,(unsigned long) strlen(BloadData(theEnv)->BinaryPrefixID) + 1,fp); GenWrite(BloadData(theEnv)->BinaryVersionID,(unsigned long) strlen(BloadData(theEnv)->BinaryVersionID) + 1,fp); }
/*************************************************** NAME : BsaveClassLinks DESCRIPTION : Writes class links binary data INPUTS : 1) The defclass 2) The binary file pointer RETURNS : Nothing useful SIDE EFFECTS : Defclass links binary data written NOTES : None ***************************************************/ static void BsaveClassLinks( struct constructHeader *theDefclass, void *buf) { DEFCLASS *cls = (DEFCLASS *) theDefclass; register unsigned i; long dummy_class_index; for (i = 0 ; i < cls->directSuperclasses.classCount ; i++) { dummy_class_index = DefclassIndex(cls->directSuperclasses.classArray[i]); GenWrite((void *) &dummy_class_index,(UNLN) sizeof(long),(FILE *) buf); } LinkCount += cls->directSuperclasses.classCount; for (i = 0 ; i < cls->directSubclasses.classCount ; i++) { dummy_class_index = DefclassIndex(cls->directSubclasses.classArray[i]); GenWrite((void *) &dummy_class_index,(UNLN) sizeof(long),(FILE *) buf); } LinkCount += cls->directSubclasses.classCount; for (i = 0 ; i < cls->allSuperclasses.classCount ; i++) { dummy_class_index = DefclassIndex(cls->allSuperclasses.classArray[i]); GenWrite((void *) &dummy_class_index,(UNLN) sizeof(long),(FILE *) buf); } LinkCount += cls->allSuperclasses.classCount; }
globle void WriteNeededConstraints( void *theEnv, FILE *fp) { int i; unsigned short theIndex = 0; unsigned long int numberOfUsedConstraints = 0; CONSTRAINT_RECORD *tmpPtr; BSAVE_CONSTRAINT_RECORD bsaveConstraints; /*================================*/ /* Get the number of constraints. */ /*================================*/ for (i = 0; i < SIZE_CONSTRAINT_HASH; i++) { for (tmpPtr = ConstraintData(theEnv)->ConstraintHashtable[i]; tmpPtr != NULL; tmpPtr = tmpPtr->next) { tmpPtr->bsaveIndex = theIndex++; numberOfUsedConstraints++; } } /*=============================================*/ /* If dynamic constraint checking is disabled, */ /* then no constraints are saved. */ /*=============================================*/ if ((! EnvGetDynamicConstraintChecking(theEnv)) && (numberOfUsedConstraints != 0)) { numberOfUsedConstraints = 0; PrintWarningID(theEnv,"CSTRNBIN",1,FALSE); EnvPrintRouter(theEnv,WWARNING,"Constraints are not saved with a binary image\n"); EnvPrintRouter(theEnv,WWARNING," when dynamic constraint checking is disabled.\n"); } /*============================================*/ /* Write out the number of constraints in the */ /* constraint table followed by each of the */ /* constraints in the constraint table. */ /*============================================*/ GenWrite(&numberOfUsedConstraints,(unsigned long) sizeof(unsigned long int),fp); if (numberOfUsedConstraints == 0) return; for (i = 0 ; i < SIZE_CONSTRAINT_HASH; i++) { for (tmpPtr = ConstraintData(theEnv)->ConstraintHashtable[i]; tmpPtr != NULL; tmpPtr = tmpPtr->next) { CopyToBsaveConstraintRecord(theEnv,tmpPtr,&bsaveConstraints); GenWrite(&bsaveConstraints, (unsigned long) sizeof(BSAVE_CONSTRAINT_RECORD),fp); } } }
globle void WriteNeededSymbols( void *theEnv, FILE *fp) { unsigned long i; size_t length; SYMBOL_HN **symbolArray; SYMBOL_HN *symbolPtr; unsigned long int numberOfUsedSymbols = 0; size_t size = 0; /*=================================*/ /* Get a copy of the symbol table. */ /*=================================*/ symbolArray = GetSymbolTable(theEnv); /*======================================================*/ /* Get the number of symbols and the total string size. */ /*======================================================*/ for (i = 0; i < SYMBOL_HASH_SIZE; i++) { for (symbolPtr = symbolArray[i]; symbolPtr != NULL; symbolPtr = symbolPtr->next) { if (symbolPtr->neededSymbol) { numberOfUsedSymbols++; size += strlen(symbolPtr->contents) + 1; } } } /*=============================================*/ /* Write out the symbols and the string sizes. */ /*=============================================*/ GenWrite((void *) &numberOfUsedSymbols,(unsigned long) sizeof(unsigned long int),fp); GenWrite((void *) &size,(unsigned long) sizeof(unsigned long int),fp); for (i = 0; i < SYMBOL_HASH_SIZE; i++) { for (symbolPtr = symbolArray[i]; symbolPtr != NULL; symbolPtr = symbolPtr->next) { if (symbolPtr->neededSymbol) { length = strlen(symbolPtr->contents) + 1; GenWrite((void *) symbolPtr->contents,(unsigned long) length,fp); } } } }
static void WriteNeededFunctions( void *theEnv, FILE *fp) { unsigned long int count = 0; size_t space, length; struct FunctionDefinition *functionList; /*================================================*/ /* Assign each function an index if it is needed. */ /*================================================*/ for (functionList = GetFunctionList(theEnv); functionList != NULL; functionList = functionList->next) { if (functionList->bsaveIndex) { functionList->bsaveIndex = (short int) count++; } else { functionList->bsaveIndex = -1; } } /*===================================================*/ /* Write the number of function names to be written. */ /*===================================================*/ GenWrite(&count,(unsigned long) sizeof(unsigned long int),fp); if (count == 0) { GenWrite(&count,(unsigned long) sizeof(unsigned long int),fp); return; } /*================================*/ /* Determine the amount of space */ /* needed for the function names. */ /*================================*/ space = FunctionBinarySize(theEnv); GenWrite(&space,(unsigned long) sizeof(unsigned long int),fp); /*===============================*/ /* Write out the function names. */ /*===============================*/ for (functionList = GetFunctionList(theEnv); functionList != NULL; functionList = functionList->next) { if (functionList->bsaveIndex >= 0) { length = strlen(ValueToString(functionList->callFunctionName)) + 1; GenWrite(ValueToString(functionList->callFunctionName),(unsigned long) length,fp); } } }
static void WriteNeededBitMaps( void *theEnv, FILE *fp) { int i; BITMAP_HN **bitMapArray; BITMAP_HN *bitMapPtr; unsigned long int numberOfUsedBitMaps = 0, size = 0; unsigned short tempSize; /*=================================*/ /* Get a copy of the bitmap table. */ /*=================================*/ bitMapArray = GetBitMapTable(theEnv); /*======================================================*/ /* Get the number of bitmaps and the total bitmap size. */ /*======================================================*/ for (i = 0; i < BITMAP_HASH_SIZE; i++) { for (bitMapPtr = bitMapArray[i]; bitMapPtr != NULL; bitMapPtr = bitMapPtr->next) { if (bitMapPtr->neededBitMap) { numberOfUsedBitMaps++; size += (unsigned long) (bitMapPtr->size + sizeof(unsigned short)); } } } /*========================================*/ /* Write out the bitmaps and their sizes. */ /*========================================*/ GenWrite((void *) &numberOfUsedBitMaps,(unsigned long) sizeof(unsigned long int),fp); GenWrite((void *) &size,(unsigned long) sizeof(unsigned long int),fp); for (i = 0; i < BITMAP_HASH_SIZE; i++) { for (bitMapPtr = bitMapArray[i]; bitMapPtr != NULL; bitMapPtr = bitMapPtr->next) { if (bitMapPtr->neededBitMap) { tempSize = (unsigned short) bitMapPtr->size; GenWrite((void *) &tempSize,(unsigned long) sizeof(unsigned short),fp); GenWrite((void *) bitMapPtr->contents,(unsigned long) bitMapPtr->size,fp); } } } }
static void BsaveStorage( FILE *fp) { unsigned long space; space = sizeof(long) * 2; GenWrite(&space,(unsigned long) sizeof(unsigned long int),fp); GenWrite(&NumberOfDefmodules,(unsigned long) sizeof(long int),fp); GenWrite(&NumberOfPortItems,(unsigned long) sizeof(long int),fp); }
/*********************************************************** NAME : BsaveStorageDeffunctions DESCRIPTION : Writes out number of each type of structure required for deffunctions Space required for counts (unsigned long) INPUTS : File pointer of binary file RETURNS : Nothing useful SIDE EFFECTS : Binary file adjusted NOTES : None ***********************************************************/ static void BsaveStorageDeffunctions( FILE *fp) { unsigned long space; space = sizeof(unsigned long) * 2; GenWrite((void *) &space,(unsigned long) sizeof(unsigned long),fp); GenWrite((void *) &ModuleCount,(unsigned long) sizeof(long),fp); GenWrite((void *) &DeffunctionCount,(unsigned long) sizeof(long),fp); }
static void BsaveStorage( void *theEnv, FILE *fp) { size_t space; space = sizeof(long); GenWrite(&space,sizeof(size_t),fp); GenWrite(&FactBinaryData(theEnv)->NumberOfPatterns,sizeof(long int),fp); }
/**************************************************** NAME : BsaveStorageObjectPatterns DESCRIPTION : Writes out the number of bytes required for object pattern bitmaps, and the number of object pattern alpha an intermediate nodes INPUTS : Bsave file stream pointer RETURNS : Nothing useful SIDE EFFECTS : Counts written NOTES : None ****************************************************/ static void BsaveStorageObjectPatterns( FILE *fp) { UNLN space; space = sizeof(long) * 2; GenWrite(&space,(UNLN) sizeof(UNLN),fp); GenWrite(&AlphaNodeCount,(UNLN) sizeof(long),fp); GenWrite(&PatternNodeCount,(UNLN) sizeof(long),fp); }
/*********************************************************** NAME : BsaveStorageDefinstances DESCRIPTION : Writes out number of each type of structure required for definstances Space required for counts (unsigned long) INPUTS : File pointer of binary file RETURNS : Nothing useful SIDE EFFECTS : Binary file adjusted NOTES : None ***********************************************************/ static void BsaveStorageDefinstances( void *theEnv, FILE *fp) { unsigned long space; space = sizeof(unsigned long) * 2; GenWrite((void *) &space,(unsigned long) sizeof(unsigned long),fp); GenWrite((void *) &DefinstancesBinaryData(theEnv)->ModuleCount,(unsigned long) sizeof(long),fp); GenWrite((void *) &DefinstancesBinaryData(theEnv)->DefinstancesCount,(unsigned long) sizeof(long),fp); }
/*********************************************************** NAME : BsaveStorageDeffunctions DESCRIPTION : Writes out number of each type of structure required for deffunctions Space required for counts (unsigned long) INPUTS : File pointer of binary file RETURNS : Nothing useful SIDE EFFECTS : Binary file adjusted NOTES : None ***********************************************************/ static void BsaveStorageDeffunctions( void *theEnv, FILE *fp) { size_t space; space = sizeof(unsigned long) * 2; GenWrite((void *) &space,sizeof(size_t),fp); GenWrite((void *) &DeffunctionBinaryData(theEnv)->ModuleCount,sizeof(unsigned long),fp); GenWrite((void *) &DeffunctionBinaryData(theEnv)->DeffunctionCount,sizeof(unsigned long),fp); }
/**************************************************** NAME : BsaveStorageObjectPatterns DESCRIPTION : Writes out the number of bytes required for object pattern bitmaps, and the number of object pattern alpha an intermediate nodes INPUTS : Bsave file stream pointer RETURNS : Nothing useful SIDE EFFECTS : Counts written NOTES : None ****************************************************/ static void BsaveStorageObjectPatterns( void *theEnv, FILE *fp) { size_t space; space = sizeof(long) * 2; GenWrite(&space,sizeof(size_t),fp); GenWrite(&ObjectReteBinaryData(theEnv)->AlphaNodeCount,sizeof(long),fp); GenWrite(&ObjectReteBinaryData(theEnv)->PatternNodeCount,sizeof(long),fp); }
static void BsaveStorage( void *theEnv, FILE *fp) { unsigned long space; space = sizeof(long) * 2; GenWrite(&space,(unsigned long) sizeof(unsigned long int),fp); GenWrite(&DefmoduleData(theEnv)->BNumberOfDefmodules,(unsigned long) sizeof(long int),fp); GenWrite(&DefmoduleData(theEnv)->NumberOfPortItems,(unsigned long) sizeof(long int),fp); }
static void BsaveStorage( void *theEnv, FILE *fp) { unsigned long space; space = sizeof(long) * 3; GenWrite(&space,(unsigned long) sizeof(unsigned long int),fp); GenWrite(&DefruleBinaryData(theEnv)->NumberOfDefruleModules,(unsigned long) sizeof(long int),fp); GenWrite(&DefruleBinaryData(theEnv)->NumberOfDefrules,(unsigned long) sizeof(long int),fp); GenWrite(&DefruleBinaryData(theEnv)->NumberOfJoins,(unsigned long) sizeof(long int),fp); }
static void BsaveStorage( FILE *fp) { unsigned long space; space = sizeof(long) * 3; GenWrite(&space,(unsigned long) sizeof(unsigned long int),fp); GenWrite(&NumberOfDefruleModules,(unsigned long) sizeof(long int),fp); GenWrite(&NumberOfDefrules,(unsigned long) sizeof(long int),fp); GenWrite(&NumberOfJoins,(unsigned long) sizeof(long int),fp); #if FUZZY_DEFTEMPLATES GenWrite(&NumberOfPatternFuzzyValues,(unsigned long) sizeof(long int),fp); #endif }
globle void WriteNeededIntegers( void *theEnv, FILE *fp) { int i; INTEGER_HN **integerArray; INTEGER_HN *integerPtr; unsigned long int numberOfUsedIntegers = 0; /*==================================*/ /* Get a copy of the integer table. */ /*==================================*/ integerArray = GetIntegerTable(theEnv); /*=============================*/ /* Get the number of integers. */ /*=============================*/ for (i = 0 ; i < INTEGER_HASH_SIZE; i++) { for (integerPtr = integerArray[i]; integerPtr != NULL; integerPtr = integerPtr->next) { if (integerPtr->neededInteger) numberOfUsedIntegers++; } } /*==========================================================*/ /* Write out the number of integers and the integer values. */ /*==========================================================*/ GenWrite(&numberOfUsedIntegers,(unsigned long) sizeof(unsigned long int),fp); for (i = 0 ; i < INTEGER_HASH_SIZE; i++) { for (integerPtr = integerArray[i]; integerPtr != NULL; integerPtr = integerPtr->next) { if (integerPtr->neededInteger) { GenWrite(&integerPtr->contents, (unsigned long) sizeof(integerPtr->contents),fp); } } } }
/****************************************************** 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); } } }
static void BsaveJoin( FILE *fp, struct joinNode *joinPtr) { struct bsaveJoinNode tempJoin; joinPtr->marked = 0; tempJoin.depth = joinPtr->depth; tempJoin.rhsType = joinPtr->rhsType; tempJoin.firstJoin = joinPtr->firstJoin; tempJoin.logicalJoin = joinPtr->logicalJoin; tempJoin.joinFromTheRight = joinPtr->joinFromTheRight; tempJoin.patternIsNegated = joinPtr->patternIsNegated; if (joinPtr->joinFromTheRight) { tempJoin.rightSideEntryStructure = BsaveJoinIndex(joinPtr->rightSideEntryStructure); } else { tempJoin.rightSideEntryStructure = -1L; } tempJoin.lastLevel = BsaveJoinIndex(joinPtr->lastLevel); tempJoin.nextLevel = BsaveJoinIndex(joinPtr->nextLevel); tempJoin.rightMatchNode = BsaveJoinIndex(joinPtr->rightMatchNode); tempJoin.rightDriveNode = BsaveJoinIndex(joinPtr->rightDriveNode); tempJoin.networkTest = HashedExpressionIndex(joinPtr->networkTest); if (joinPtr->ruleToActivate != NULL) { tempJoin.ruleToActivate = GetDisjunctIndex(joinPtr->ruleToActivate); } else { tempJoin.ruleToActivate = -1L; } GenWrite(&tempJoin,(unsigned long) sizeof(struct bsaveJoinNode),fp); }
/************************************************************* NAME : BsaveRestrictionTypes DESCRIPTION : Bsaves defgeneric methods' retrictions' types INPUTS : 1) The defgeneric 2) Output data file pointer RETURNS : Nothing useful SIDE EFFECTS : Defgeneric methods' restrictions' types saved NOTES : None *************************************************************/ static void BsaveRestrictionTypes( struct constructHeader *theDefgeneric, void *userBuffer) { DEFGENERIC *gfunc = (DEFGENERIC *) theDefgeneric; long dummy_type; RESTRICTION *rptr; register unsigned i,j,k; for (i = 0 ; i < gfunc->mcnt ; i++) { for (j = 0 ; j < gfunc->methods[i].restrictionCount ; j++) { rptr = &gfunc->methods[i].restrictions[j]; for (k = 0 ; k < rptr->tcnt ; k++) { #if OBJECT_SYSTEM dummy_type = DefclassIndex(rptr->types[k]); #else dummy_type = (long) ((INTEGER_HN *) rptr->types[k])->contents; #endif GenWrite(&dummy_type,(unsigned long) sizeof(long),(FILE *) userBuffer); } } } }
/************************************************************ 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 : 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); } }
static void BsaveRestrictionTypes( void *theEnv, struct constructHeader *theDefgeneric, void *userBuffer) { DEFGENERIC *gfunc = (DEFGENERIC *) theDefgeneric; long dummy_type; RESTRICTION *rptr; short i,j,k; #if MAC_MCW || WIN_MCW || MAC_XCD #pragma unused(theEnv) #endif for (i = 0 ; i < gfunc->mcnt ; i++) { for (j = 0 ; j < gfunc->methods[i].restrictionCount ; j++) { rptr = &gfunc->methods[i].restrictions[j]; for (k = 0 ; k < rptr->tcnt ; k++) { #if OBJECT_SYSTEM dummy_type = DefclassIndex(rptr->types[k]); #else dummy_type = (long) ((INTEGER_HN *) rptr->types[k])->contents; #endif GenWrite(&dummy_type,sizeof(long),(FILE *) userBuffer); } } } }
static void BsaveStorage( FILE *fp) { unsigned long space; /*===========================================================*/ /* Only two data structures are saved as part of a defglobal */ /* binary image: the defglobal data structure and the */ /* defglobalModule data structure. */ /*===========================================================*/ space = sizeof(long) * 2; GenWrite(&space,(unsigned long) sizeof(unsigned long int),fp); GenWrite(&NumberOfDefglobals,(unsigned long) sizeof(long int),fp); GenWrite(&NumberOfDefglobalModules,(unsigned long) sizeof(long int),fp); }
globle void WriteNeededFloats( void *theEnv, FILE *fp) { int i; FLOAT_HN **floatArray; FLOAT_HN *floatPtr; unsigned long int numberOfUsedFloats = 0; /*================================*/ /* Get a copy of the float table. */ /*================================*/ floatArray = GetFloatTable(theEnv); /*===========================*/ /* Get the number of floats. */ /*===========================*/ for (i = 0; i < FLOAT_HASH_SIZE; i++) { for (floatPtr = floatArray[i]; floatPtr != NULL; floatPtr = floatPtr->next) { if (floatPtr->neededFloat) numberOfUsedFloats++; } } /*======================================================*/ /* Write out the number of floats and the float values. */ /*======================================================*/ GenWrite(&numberOfUsedFloats,(unsigned long) sizeof(unsigned long int),fp); for (i = 0 ; i < FLOAT_HASH_SIZE; i++) { for (floatPtr = floatArray[i]; floatPtr != NULL; floatPtr = floatPtr->next) { if (floatPtr->neededFloat) { GenWrite(&floatPtr->contents, (unsigned long) sizeof(floatPtr->contents),fp); } } } }
/**************************************************************** NAME : BsaveHandlerMap DESCRIPTION : Writes class message-handler map binary data INPUTS : 1) The defclass 2) The binary file pointer RETURNS : Nothing useful SIDE EFFECTS : Defclass message-handler map binary data written NOTES : None ****************************************************************/ static void BsaveHandlerMap( struct constructHeader *theDefclass, void *buf) { DEFCLASS *cls = (DEFCLASS *) theDefclass; GenWrite((void *) cls->handlerOrderMap, (UNLN) (sizeof(unsigned) * cls->handlerCount),(FILE *) buf); }
static void BsaveStorage( void *theEnv, EXEC_STATUS, FILE *fp) { size_t space; /*===========================================================*/ /* Only two data structures are saved as part of a defglobal */ /* binary image: the defglobal data structure and the */ /* defglobalModule data structure. */ /*===========================================================*/ space = sizeof(long) * 2; GenWrite(&space,sizeof(size_t),fp); GenWrite(&DefglobalBinaryData(theEnv,execStatus)->NumberOfDefglobals,sizeof(long int),fp); GenWrite(&DefglobalBinaryData(theEnv,execStatus)->NumberOfDefglobalModules,sizeof(long int),fp); }
static void WriteBinaryFooter( void *theEnv, FILE *fp) { char footerBuffer[CONSTRUCT_HEADER_SIZE]; genstrncpy(footerBuffer,BloadData(theEnv)->BinaryPrefixID,CONSTRUCT_HEADER_SIZE); GenWrite(footerBuffer,(unsigned long) CONSTRUCT_HEADER_SIZE,fp); }
static void BsaveStorage( void *theEnv, FILE *fp) { size_t space; /*=================================================================*/ /* Only two data structures are saved as part of a deffacts binary */ /* image: the deffacts data structure and the deffactsModule data */ /* structure. The assertion list expressions are not save with the */ /* deffacts portion of the binary image. */ /*=================================================================*/ space = sizeof(long) * 2; GenWrite(&space,sizeof(size_t),fp); GenWrite(&DeffactsBinaryData(theEnv)->NumberOfDeffacts,sizeof(long int),fp); GenWrite(&DeffactsBinaryData(theEnv)->NumberOfDeffactsModules,sizeof(long int),fp); }
/*************************************************************** NAME : BsaveSlotMap DESCRIPTION : Writes class canonical slot map binary data INPUTS : 1) The defclass 2) The binary file pointer RETURNS : Nothing useful SIDE EFFECTS : Defclass canonical slot map binary data written NOTES : None ***************************************************************/ static void BsaveSlotMap( struct constructHeader *theDefclass, void *buf) { DEFCLASS *cls = (DEFCLASS *) theDefclass; if (cls->instanceSlotCount != 0) GenWrite((void *) cls->slotNameMap, (UNLN) (sizeof(unsigned) * (cls->maxSlotNameID + 1)),(FILE *) buf); }