自学教程：C++ GenWrite函数代码示例

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