static void BloadStorage(
void *theEnv,
EXEC_STATUS)
{
size_t space;
/*=========================================*/
/* Determine the number of factPatternNode */
/* data structures to be read. */
/*=========================================*/
GenReadBinary(theEnv,execStatus,&space,sizeof(size_t));
GenReadBinary(theEnv,execStatus,&FactBinaryData(theEnv,execStatus)->NumberOfPatterns,sizeof(long int));
/*===================================*/
/* Allocate the space needed for the */
/* factPatternNode data structures. */
/*===================================*/
if (FactBinaryData(theEnv,execStatus)->NumberOfPatterns == 0)
{
FactBinaryData(theEnv,execStatus)->FactPatternArray = NULL;
return;
}
space = FactBinaryData(theEnv,execStatus)->NumberOfPatterns * sizeof(struct factPatternNode);
FactBinaryData(theEnv,execStatus)->FactPatternArray = (struct factPatternNode *) genalloc(theEnv,execStatus,space);
}
/***************************************************
NAME : BloadStorageObjectPatterns
DESCRIPTION : Reads in the storage requirements
for the object patterns in this
bload image
INPUTS : None
RETURNS : Nothing useful
SIDE EFFECTS : Counts read and arrays allocated
NOTES : None
***************************************************/
static void BloadStorageObjectPatterns(
void *theEnv)
{
UNLN space;
long counts[2];
GenReadBinary(theEnv,(void *) &space,(UNLN) sizeof(UNLN));
GenReadBinary(theEnv,(void *) counts,space);
ObjectReteBinaryData(theEnv)->AlphaNodeCount = counts[0];
ObjectReteBinaryData(theEnv)->PatternNodeCount = counts[1];
if (ObjectReteBinaryData(theEnv)->AlphaNodeCount == 0L)
ObjectReteBinaryData(theEnv)->AlphaArray = NULL;
else
{
space = (UNLN) (ObjectReteBinaryData(theEnv)->AlphaNodeCount * sizeof(OBJECT_ALPHA_NODE));
ObjectReteBinaryData(theEnv)->AlphaArray = (OBJECT_ALPHA_NODE *) genlongalloc(theEnv,space);
}
if (ObjectReteBinaryData(theEnv)->PatternNodeCount == 0L)
ObjectReteBinaryData(theEnv)->PatternArray = NULL;
else
{
space = (UNLN) (ObjectReteBinaryData(theEnv)->PatternNodeCount * sizeof(OBJECT_PATTERN_NODE));
ObjectReteBinaryData(theEnv)->PatternArray = (OBJECT_PATTERN_NODE *) genlongalloc(theEnv,space);
}
}
/***********************************************************************
NAME : BloadStorageDeffunctions
DESCRIPTION : This routine space required for deffunction
structures and allocates space for them
INPUTS : Nothing
RETURNS : Nothing useful
SIDE EFFECTS : Arrays allocated and set
NOTES : This routine makes no attempt to reset any pointers
within the structures
***********************************************************************/
static void BloadStorageDeffunctions(
void *theEnv)
{
size_t space;
GenReadBinary(theEnv,(void *) &space,sizeof(size_t));
if (space == 0L)
return;
GenReadBinary(theEnv,(void *) &DeffunctionBinaryData(theEnv)->ModuleCount,sizeof(unsigned long));
GenReadBinary(theEnv,(void *) &DeffunctionBinaryData(theEnv)->DeffunctionCount,sizeof(unsigned long));
if (DeffunctionBinaryData(theEnv)->ModuleCount == 0L)
{
DeffunctionBinaryData(theEnv)->ModuleArray = NULL;
DeffunctionBinaryData(theEnv)->DeffunctionArray = NULL;
return;
}
space = (DeffunctionBinaryData(theEnv)->ModuleCount * sizeof(DEFFUNCTION_MODULE));
DeffunctionBinaryData(theEnv)->ModuleArray = (DEFFUNCTION_MODULE *) genalloc(theEnv,space);
if (DeffunctionBinaryData(theEnv)->DeffunctionCount == 0L)
{
DeffunctionBinaryData(theEnv)->DeffunctionArray = NULL;
return;
}
space = (DeffunctionBinaryData(theEnv)->DeffunctionCount * sizeof(DEFFUNCTION));
DeffunctionBinaryData(theEnv)->DeffunctionArray = (DEFFUNCTION *) genalloc(theEnv,space);
}
static void BloadStorage(
Environment *theEnv)
{
size_t space;
/*=========================================================*/
/* Determine the number of deftemplate, deftemplateModule, */
/* and templateSlot data structures to be read. */
/*=========================================================*/
GenReadBinary(theEnv,&space,sizeof(size_t));
GenReadBinary(theEnv,&DeftemplateBinaryData(theEnv)->NumberOfDeftemplates,sizeof(long));
GenReadBinary(theEnv,&DeftemplateBinaryData(theEnv)->NumberOfTemplateSlots,sizeof(long));
GenReadBinary(theEnv,&DeftemplateBinaryData(theEnv)->NumberOfTemplateModules,sizeof(long));
/*====================================*/
/* Allocate the space needed for the */
/* deftemplateModule data structures. */
/*====================================*/
if (DeftemplateBinaryData(theEnv)->NumberOfTemplateModules == 0)
{
DeftemplateBinaryData(theEnv)->DeftemplateArray = NULL;
DeftemplateBinaryData(theEnv)->SlotArray = NULL;
DeftemplateBinaryData(theEnv)->ModuleArray = NULL;
return;
}
space = DeftemplateBinaryData(theEnv)->NumberOfTemplateModules * sizeof(struct deftemplateModule);
DeftemplateBinaryData(theEnv)->ModuleArray = (struct deftemplateModule *) genalloc(theEnv,space);
/*===================================*/
/* Allocate the space needed for the */
/* deftemplate data structures. */
/*===================================*/
if (DeftemplateBinaryData(theEnv)->NumberOfDeftemplates == 0)
{
DeftemplateBinaryData(theEnv)->DeftemplateArray = NULL;
DeftemplateBinaryData(theEnv)->SlotArray = NULL;
return;
}
space = DeftemplateBinaryData(theEnv)->NumberOfDeftemplates * sizeof(Deftemplate);
DeftemplateBinaryData(theEnv)->DeftemplateArray = (Deftemplate *) genalloc(theEnv,space);
/*===================================*/
/* Allocate the space needed for the */
/* templateSlot data structures. */
/*===================================*/
if (DeftemplateBinaryData(theEnv)->NumberOfTemplateSlots == 0)
{
DeftemplateBinaryData(theEnv)->SlotArray = NULL;
return;
}
space = DeftemplateBinaryData(theEnv)->NumberOfTemplateSlots * sizeof(struct templateSlot);
DeftemplateBinaryData(theEnv)->SlotArray = (struct templateSlot *) genalloc(theEnv,space);
}
/***************************************************
NAME : BloadStorageObjectPatterns
DESCRIPTION : Reads in the storage requirements
for the object patterns in this
bload image
INPUTS : None
RETURNS : Nothing useful
SIDE EFFECTS : Counts read and arrays allocated
NOTES : None
***************************************************/
static void BloadStorageObjectPatterns(
void *theEnv,
EXEC_STATUS)
{
size_t space;
long counts[2];
GenReadBinary(theEnv,execStatus,(void *) &space,sizeof(size_t));
GenReadBinary(theEnv,execStatus,(void *) counts,space);
ObjectReteBinaryData(theEnv,execStatus)->AlphaNodeCount = counts[0];
ObjectReteBinaryData(theEnv,execStatus)->PatternNodeCount = counts[1];
if (ObjectReteBinaryData(theEnv,execStatus)->AlphaNodeCount == 0L)
ObjectReteBinaryData(theEnv,execStatus)->AlphaArray = NULL;
else
{
space = (ObjectReteBinaryData(theEnv,execStatus)->AlphaNodeCount * sizeof(OBJECT_ALPHA_NODE));
ObjectReteBinaryData(theEnv,execStatus)->AlphaArray = (OBJECT_ALPHA_NODE *) genalloc(theEnv,execStatus,space);
}
if (ObjectReteBinaryData(theEnv,execStatus)->PatternNodeCount == 0L)
ObjectReteBinaryData(theEnv,execStatus)->PatternArray = NULL;
else
{
space = (ObjectReteBinaryData(theEnv,execStatus)->PatternNodeCount * sizeof(OBJECT_PATTERN_NODE));
ObjectReteBinaryData(theEnv,execStatus)->PatternArray = (OBJECT_PATTERN_NODE *) genalloc(theEnv,execStatus,space);
}
}
/***********************************************************************
NAME : BloadStorageDefinstances
DESCRIPTION : This routine space required for definstances
structures and allocates space for them
INPUTS : Nothing
RETURNS : Nothing useful
SIDE EFFECTS : Arrays allocated and set
NOTES : This routine makes no attempt to reset any pointers
within the structures
***********************************************************************/
static void BloadStorageDefinstances(
void *theEnv)
{
unsigned long space;
GenReadBinary(theEnv,(void *) &space,(unsigned long) sizeof(unsigned long));
if (space == 0L)
return;
GenReadBinary(theEnv,(void *) &DefinstancesBinaryData(theEnv)->ModuleCount,(unsigned long) sizeof(unsigned long));
GenReadBinary(theEnv,(void *) &DefinstancesBinaryData(theEnv)->DefinstancesCount,(unsigned long) sizeof(unsigned long));
if (DefinstancesBinaryData(theEnv)->ModuleCount == 0L)
{
DefinstancesBinaryData(theEnv)->ModuleArray = NULL;
DefinstancesBinaryData(theEnv)->DefinstancesArray = NULL;
return;
}
space = (unsigned long) (DefinstancesBinaryData(theEnv)->ModuleCount * sizeof(DEFINSTANCES_MODULE));
DefinstancesBinaryData(theEnv)->ModuleArray = (DEFINSTANCES_MODULE *) genlongalloc(theEnv,space);
if (DefinstancesBinaryData(theEnv)->DefinstancesCount == 0L)
{
DefinstancesBinaryData(theEnv)->DefinstancesArray = NULL;
return;
}
space = (unsigned long) (DefinstancesBinaryData(theEnv)->DefinstancesCount * sizeof(DEFINSTANCES));
DefinstancesBinaryData(theEnv)->DefinstancesArray = (DEFINSTANCES *) genlongalloc(theEnv,space);
}
static void BloadStorage(
void *theEnv)
{
unsigned long space;
/*=================================================*/
/* Determine the number of defrule, defruleModule, */
/* and joinNode data structures to be read. */
/*=================================================*/
GenReadBinary(theEnv,&space,(unsigned long) sizeof(unsigned long int));
GenReadBinary(theEnv,&DefruleBinaryData(theEnv)->NumberOfDefruleModules,(unsigned long) sizeof(long int));
GenReadBinary(theEnv,&DefruleBinaryData(theEnv)->NumberOfDefrules,(unsigned long) sizeof(long int));
GenReadBinary(theEnv,&DefruleBinaryData(theEnv)->NumberOfJoins,(unsigned long) sizeof(long int));
/*===================================*/
/* Allocate the space needed for the */
/* defruleModule data structures. */
/*===================================*/
if (DefruleBinaryData(theEnv)->NumberOfDefruleModules == 0)
{
DefruleBinaryData(theEnv)->ModuleArray = NULL;
DefruleBinaryData(theEnv)->DefruleArray = NULL;
DefruleBinaryData(theEnv)->JoinArray = NULL;
}
space = DefruleBinaryData(theEnv)->NumberOfDefruleModules * sizeof(struct defruleModule);
DefruleBinaryData(theEnv)->ModuleArray = (struct defruleModule *) genlongalloc(theEnv,space);
/*===============================*/
/* Allocate the space needed for */
/* the defrule data structures. */
/*===============================*/
if (DefruleBinaryData(theEnv)->NumberOfDefrules == 0)
{
DefruleBinaryData(theEnv)->DefruleArray = NULL;
DefruleBinaryData(theEnv)->JoinArray = NULL;
return;
}
space = DefruleBinaryData(theEnv)->NumberOfDefrules * sizeof(struct defrule);
DefruleBinaryData(theEnv)->DefruleArray = (struct defrule *) genlongalloc(theEnv,space);
/*===============================*/
/* Allocate the space needed for */
/* the joinNode data structures. */
/*===============================*/
space = DefruleBinaryData(theEnv)->NumberOfJoins * sizeof(struct joinNode);
DefruleBinaryData(theEnv)->JoinArray = (struct joinNode *) genlongalloc(theEnv,space);
}
/***********************************************************************
NAME : BloadStorageGenerics
DESCRIPTION : This routine space required for generic function
structures and allocates space for them
INPUTS : Nothing
RETURNS : Nothing useful
SIDE EFFECTS : Arrays allocated and set
NOTES : This routine makes no attempt to reset any pointers
within the structures
***********************************************************************/
static void BloadStorageGenerics(
void *theEnv)
{
size_t space;
long counts[5];
GenReadBinary(theEnv,(void *) &space,sizeof(size_t));
if (space == 0L)
return;
GenReadBinary(theEnv,(void *) counts,space);
DefgenericBinaryData(theEnv)->ModuleCount = counts[0];
DefgenericBinaryData(theEnv)->GenericCount = counts[1];
DefgenericBinaryData(theEnv)->MethodCount = counts[2];
DefgenericBinaryData(theEnv)->RestrictionCount = counts[3];
DefgenericBinaryData(theEnv)->TypeCount = counts[4];
if (DefgenericBinaryData(theEnv)->ModuleCount != 0L)
{
space = (sizeof(DEFGENERIC_MODULE) * DefgenericBinaryData(theEnv)->ModuleCount);
DefgenericBinaryData(theEnv)->ModuleArray = (DEFGENERIC_MODULE *) genalloc(theEnv,space);
}
else
return;
if (DefgenericBinaryData(theEnv)->GenericCount != 0L)
{
space = (sizeof(DEFGENERIC) * DefgenericBinaryData(theEnv)->GenericCount);
DefgenericBinaryData(theEnv)->DefgenericArray = (DEFGENERIC *) genalloc(theEnv,space);
}
else
return;
if (DefgenericBinaryData(theEnv)->MethodCount != 0L)
{
space = (sizeof(DEFMETHOD) * DefgenericBinaryData(theEnv)->MethodCount);
DefgenericBinaryData(theEnv)->MethodArray = (DEFMETHOD *) genalloc(theEnv,space);
}
else
return;
if (DefgenericBinaryData(theEnv)->RestrictionCount != 0L)
{
space = (sizeof(RESTRICTION) * DefgenericBinaryData(theEnv)->RestrictionCount);
DefgenericBinaryData(theEnv)->RestrictionArray = (RESTRICTION *) genalloc(theEnv,space);
}
else
return;
if (DefgenericBinaryData(theEnv)->TypeCount != 0L)
{
space = (sizeof(void *) * DefgenericBinaryData(theEnv)->TypeCount);
DefgenericBinaryData(theEnv)->TypeArray = (void * *) genalloc(theEnv,space);
}
}
static void ReadNeededBitMaps(
void *theEnv)
{
char *bitMapStorage, *bitMapPtr;
unsigned long space;
long i;
unsigned short *tempSize;
/*=======================================*/
/* Determine the number of bitmaps to be */
/* read and space required for them. */
/*=======================================*/
GenReadBinary(theEnv,(void *) &SymbolData(theEnv)->NumberOfBitMaps,(unsigned long) sizeof(long int));
GenReadBinary(theEnv,&space,(unsigned long) sizeof(unsigned long int));
if (SymbolData(theEnv)->NumberOfBitMaps == 0)
{
SymbolData(theEnv)->BitMapArray = NULL;
return;
}
/*=======================================*/
/* Allocate area for bitmaps to be read. */
/*=======================================*/
bitMapStorage = (char *) gm3(theEnv,(long) space);
GenReadBinary(theEnv,(void *) bitMapStorage,space);
/*================================================*/
/* Store the bitMap pointers in the bitmap array. */
/*================================================*/
SymbolData(theEnv)->BitMapArray = (BITMAP_HN **)
gm3(theEnv,(long) sizeof(BITMAP_HN *) * SymbolData(theEnv)->NumberOfBitMaps);
bitMapPtr = bitMapStorage;
for (i = 0; i < SymbolData(theEnv)->NumberOfBitMaps; i++)
{
tempSize = (unsigned short *) bitMapPtr;
SymbolData(theEnv)->BitMapArray[i] = (BITMAP_HN *) EnvAddBitMap(theEnv,bitMapPtr+sizeof(unsigned short),*tempSize);
bitMapPtr += *tempSize + sizeof(unsigned short);
}
/*=========================*/
/* Free the bitmap buffer. */
/*=========================*/
rm3(theEnv,(void *) bitMapStorage,(long) space);
}
static void BloadBinaryItem(
void *theEnv,
EXEC_STATUS)
{
size_t space;
long i;
/*======================================================*/
/* Read in the amount of space used by the binary image */
/* (this is used to skip the construct in the event it */
/* is not available in the version being run). */
/*======================================================*/
GenReadBinary(theEnv,execStatus,&space,sizeof(size_t));
/*=============================================*/
/* Read in the factPatternNode data structures */
/* and refresh the pointers. */
/*=============================================*/
BloadandRefresh(theEnv,execStatus,FactBinaryData(theEnv,execStatus)->NumberOfPatterns,(unsigned) sizeof(struct bsaveFactPatternNode),
UpdateFactPatterns);
for (i = 0; i < FactBinaryData(theEnv,execStatus)->NumberOfPatterns; i++)
{
if ((FactBinaryData(theEnv,execStatus)->FactPatternArray[i].lastLevel != NULL) &&
(FactBinaryData(theEnv,execStatus)->FactPatternArray[i].lastLevel->header.selector))
{
AddHashedPatternNode(theEnv,execStatus,FactBinaryData(theEnv,execStatus)->FactPatternArray[i].lastLevel,
&FactBinaryData(theEnv,execStatus)->FactPatternArray[i],
FactBinaryData(theEnv,execStatus)->FactPatternArray[i].networkTest->type,
FactBinaryData(theEnv,execStatus)->FactPatternArray[i].networkTest->value);
}
}
}
static void BloadBinaryItem(
void *theEnv)
{
size_t space;
/*======================================================*/
/* Read in the amount of space used by the binary image */
/* (this is used to skip the construct in the event it */
/* is not available in the version being run). */
/*======================================================*/
GenReadBinary(theEnv,&space,sizeof(size_t));
/*============================================*/
/* Read in the deffactsModule data structures */
/* and refresh the pointers. */
/*============================================*/
BloadandRefresh(theEnv,DeffactsBinaryData(theEnv)->NumberOfDeffactsModules,
sizeof(struct bsaveDeffactsModule),UpdateDeffactsModule);
/*======================================*/
/* Read in the deffacts data structures */
/* and refresh the pointers. */
/*======================================*/
BloadandRefresh(theEnv,DeffactsBinaryData(theEnv)->NumberOfDeffacts,
sizeof(struct bsaveDeffacts),UpdateDeffacts);
}
/****************************************************
NAME : BloadObjectPatterns
DESCRIPTION : Reads in all object pattern
data structures from binary
image and updates pointers
INPUTS : None
RETURNS : Nothing useful
SIDE EFFECTS : Binary data structures updated
NOTES : Assumes storage allocated previously
****************************************************/
static void BloadObjectPatterns(
void *theEnv,
EXEC_STATUS)
{
size_t space;
long i;
GenReadBinary(theEnv,execStatus,(void *) &space,sizeof(size_t));
if (space == 0L)
return;
/* ================================================
Read in the alpha and intermediate pattern nodes
================================================ */
BloadandRefresh(theEnv,execStatus,ObjectReteBinaryData(theEnv,execStatus)->AlphaNodeCount,sizeof(BSAVE_OBJECT_ALPHA_NODE),UpdateAlpha);
BloadandRefresh(theEnv,execStatus,ObjectReteBinaryData(theEnv,execStatus)->PatternNodeCount,sizeof(BSAVE_OBJECT_PATTERN_NODE),UpdatePattern);
for (i = 0; i < ObjectReteBinaryData(theEnv,execStatus)->PatternNodeCount; i++)
{
if ((ObjectReteBinaryData(theEnv,execStatus)->PatternArray[i].lastLevel != NULL) &&
(ObjectReteBinaryData(theEnv,execStatus)->PatternArray[i].lastLevel->selector))
{
AddHashedPatternNode(theEnv,execStatus,ObjectReteBinaryData(theEnv,execStatus)->PatternArray[i].lastLevel,
&ObjectReteBinaryData(theEnv,execStatus)->PatternArray[i],
ObjectReteBinaryData(theEnv,execStatus)->PatternArray[i].networkTest->type,
ObjectReteBinaryData(theEnv,execStatus)->PatternArray[i].networkTest->value);
}
}
/* =======================
Set the global pointers
======================= */
SetObjectNetworkTerminalPointer(theEnv,execStatus,(OBJECT_ALPHA_NODE *) &ObjectReteBinaryData(theEnv,execStatus)->AlphaArray[0]);
SetObjectNetworkPointer(theEnv,execStatus,(OBJECT_PATTERN_NODE *) &ObjectReteBinaryData(theEnv,execStatus)->PatternArray[0]);
}
globle void ReadNeededSymbols(
void *theEnv)
{
char *symbolNames, *namePtr;
unsigned long space;
long i;
/*=================================================*/
/* Determine the number of symbol names to be read */
/* and space required for them. */
/*=================================================*/
GenReadBinary(theEnv,(void *) &SymbolData(theEnv)->NumberOfSymbols,(unsigned long) sizeof(long int));
GenReadBinary(theEnv,&space,(unsigned long) sizeof(unsigned long int));
if (SymbolData(theEnv)->NumberOfSymbols == 0)
{
SymbolData(theEnv)->SymbolArray = NULL;
return;
}
/*=======================================*/
/* Allocate area for strings to be read. */
/*=======================================*/
symbolNames = (char *) gm3(theEnv,(long) space);
GenReadBinary(theEnv,(void *) symbolNames,space);
/*================================================*/
/* Store the symbol pointers in the symbol array. */
/*================================================*/
SymbolData(theEnv)->SymbolArray = (SYMBOL_HN **)
gm3(theEnv,(long) sizeof(SYMBOL_HN *) * SymbolData(theEnv)->NumberOfSymbols);
namePtr = symbolNames;
for (i = 0; i < SymbolData(theEnv)->NumberOfSymbols; i++)
{
SymbolData(theEnv)->SymbolArray[i] = (SYMBOL_HN *) EnvAddSymbol(theEnv,namePtr);
namePtr += strlen(namePtr) + 1;
}
/*=======================*/
/* Free the name buffer. */
/*=======================*/
rm3(theEnv,(void *) symbolNames,(long) space);
}
/*********************************************************************
NAME : BloadDefinstances
DESCRIPTION : This routine reads definstances information from
a binary file
This routine moves through the definstances
binary array updating pointers
INPUTS : None
RETURNS : Nothing useful
SIDE EFFECTS : Pointers reset from array indices
NOTES : Assumes all loading is finished
********************************************************************/
static void BloadDefinstances(
void *theEnv)
{
unsigned long space;
GenReadBinary(theEnv,(void *) &space,(unsigned long) sizeof(unsigned long));
BloadandRefresh(theEnv,DefinstancesBinaryData(theEnv)->ModuleCount,sizeof(BSAVE_DEFINSTANCES_MODULE),UpdateDefinstancesModule);
BloadandRefresh(theEnv,DefinstancesBinaryData(theEnv)->DefinstancesCount,sizeof(BSAVE_DEFINSTANCES),UpdateDefinstances);
}
/*********************************************************************
NAME : BloadDeffunctions
DESCRIPTION : This routine reads deffunction information from
a binary file
This routine moves through the deffunction
binary array updating pointers
INPUTS : None
RETURNS : Nothing useful
SIDE EFFECTS : Pointers reset from array indices
NOTES : Assumes all loading is finished
********************************************************************/
static void BloadDeffunctions(
void *theEnv)
{
size_t space;
GenReadBinary(theEnv,(void *) &space,sizeof(size_t));
BloadandRefresh(theEnv,DeffunctionBinaryData(theEnv)->ModuleCount,sizeof(BSAVE_DEFFUNCTION_MODULE),UpdateDeffunctionModule);
BloadandRefresh(theEnv,DeffunctionBinaryData(theEnv)->DeffunctionCount,sizeof(BSAVE_DEFFUNCTION),UpdateDeffunction);
}
static void BloadStorageDefglobals(
void *theEnv,
EXEC_STATUS)
{
size_t space;
/*=======================================================*/
/* Determine the number of defglobal and defglobalModule */
/* data structures to be read. */
/*=======================================================*/
GenReadBinary(theEnv,execStatus,&space,sizeof(size_t));
GenReadBinary(theEnv,execStatus,&DefglobalBinaryData(theEnv,execStatus)->NumberOfDefglobals,sizeof(long int));
GenReadBinary(theEnv,execStatus,&DefglobalBinaryData(theEnv,execStatus)->NumberOfDefglobalModules,sizeof(long int));
/*===================================*/
/* Allocate the space needed for the */
/* defglobalModule data structures. */
/*===================================*/
if (DefglobalBinaryData(theEnv,execStatus)->NumberOfDefglobalModules == 0)
{
DefglobalBinaryData(theEnv,execStatus)->DefglobalArray = NULL;
DefglobalBinaryData(theEnv,execStatus)->ModuleArray = NULL;
}
space = DefglobalBinaryData(theEnv,execStatus)->NumberOfDefglobalModules * sizeof(struct defglobalModule);
DefglobalBinaryData(theEnv,execStatus)->ModuleArray = (struct defglobalModule *) genalloc(theEnv,execStatus,space);
/*===================================*/
/* Allocate the space needed for the */
/* defglobal data structures. */
/*===================================*/
if (DefglobalBinaryData(theEnv,execStatus)->NumberOfDefglobals == 0)
{
DefglobalBinaryData(theEnv,execStatus)->DefglobalArray = NULL;
return;
}
space = (DefglobalBinaryData(theEnv,execStatus)->NumberOfDefglobals * sizeof(struct defglobal));
DefglobalBinaryData(theEnv,execStatus)->DefglobalArray = (struct defglobal *) genalloc(theEnv,execStatus,space);
}
static void BloadStorage(
void *theEnv)
{
size_t space;
/*=====================================================*/
/* Determine the number of deffacts and deffactsModule */
/* data structures to be read. */
/*=====================================================*/
GenReadBinary(theEnv,&space,sizeof(size_t));
GenReadBinary(theEnv,&DeffactsBinaryData(theEnv)->NumberOfDeffacts,sizeof(long int));
GenReadBinary(theEnv,&DeffactsBinaryData(theEnv)->NumberOfDeffactsModules,sizeof(long int));
/*===================================*/
/* Allocate the space needed for the */
/* deffactsModule data structures. */
/*===================================*/
if (DeffactsBinaryData(theEnv)->NumberOfDeffactsModules == 0)
{
DeffactsBinaryData(theEnv)->DeffactsArray = NULL;
DeffactsBinaryData(theEnv)->ModuleArray = NULL;
return;
}
space = DeffactsBinaryData(theEnv)->NumberOfDeffactsModules * sizeof(struct deffactsModule);
DeffactsBinaryData(theEnv)->ModuleArray = (struct deffactsModule *) genalloc(theEnv,space);
/*===================================*/
/* Allocate the space needed for the */
/* deffacts data structures. */
/*===================================*/
if (DeffactsBinaryData(theEnv)->NumberOfDeffacts == 0)
{
DeffactsBinaryData(theEnv)->DeffactsArray = NULL;
return;
}
space = (DeffactsBinaryData(theEnv)->NumberOfDeffacts * sizeof(struct deffacts));
DeffactsBinaryData(theEnv)->DeffactsArray = (struct deffacts *) genalloc(theEnv,space);
}
static void BloadStorage(
void *theEnv)
{
unsigned long int space;
/*=======================================*/
/* Determine the number of defmodule and */
/* port item data structures to be read. */
/*=======================================*/
GenReadBinary(theEnv,&space,(unsigned long) sizeof(unsigned long int));
GenReadBinary(theEnv,&DefmoduleData(theEnv)->BNumberOfDefmodules,(unsigned long) sizeof(long int));
GenReadBinary(theEnv,&DefmoduleData(theEnv)->NumberOfPortItems,(unsigned long) sizeof(long int));
/*================================*/
/* Allocate the space needed for */
/* the defmodule data structures. */
/*================================*/
if (DefmoduleData(theEnv)->BNumberOfDefmodules == 0)
{
DefmoduleData(theEnv)->DefmoduleArray = NULL;
return;
}
space = (unsigned long) (DefmoduleData(theEnv)->BNumberOfDefmodules * sizeof(struct defmodule));
DefmoduleData(theEnv)->DefmoduleArray = (struct defmodule *) genlongalloc(theEnv,space);
/*================================*/
/* Allocate the space needed for */
/* the port item data structures. */
/*================================*/
if (DefmoduleData(theEnv)->NumberOfPortItems == 0)
{
DefmoduleData(theEnv)->PortItemArray = NULL;
return;
}
space = (unsigned long) (DefmoduleData(theEnv)->NumberOfPortItems * sizeof(struct portItem));
DefmoduleData(theEnv)->PortItemArray = (struct portItem *) genlongalloc(theEnv,space);
}
globle void ReadNeededConstraints(
void *theEnv)
{
GenReadBinary(theEnv,(void *) &ConstraintData(theEnv)->NumberOfConstraints,sizeof(unsigned long int));
if (ConstraintData(theEnv)->NumberOfConstraints == 0) return;
ConstraintData(theEnv)->ConstraintArray = (CONSTRAINT_RECORD *)
genalloc(theEnv,(sizeof(CONSTRAINT_RECORD) * ConstraintData(theEnv)->NumberOfConstraints));
BloadandRefresh(theEnv,ConstraintData(theEnv)->NumberOfConstraints,sizeof(BSAVE_CONSTRAINT_RECORD),
CopyFromBsaveConstraintRecord);
}
globle void ReadNeededFloats(
void *theEnv)
{
double *floatValues;
long i;
/*============================================*/
/* Determine the number of floats to be read. */
/*============================================*/
GenReadBinary(theEnv,&SymbolData(theEnv)->NumberOfFloats,(unsigned long) sizeof(long int));
if (SymbolData(theEnv)->NumberOfFloats == 0)
{
SymbolData(theEnv)->FloatArray = NULL;
return;
}
/*===============================*/
/* Allocate area for the floats. */
/*===============================*/
floatValues = (double *) gm3(theEnv,(long) sizeof(double) * SymbolData(theEnv)->NumberOfFloats);
GenReadBinary(theEnv,(void *) floatValues,(unsigned long) (sizeof(double) * SymbolData(theEnv)->NumberOfFloats));
/*======================================*/
/* Store the floats in the float array. */
/*======================================*/
SymbolData(theEnv)->FloatArray = (FLOAT_HN **)
gm3(theEnv,(long) sizeof(FLOAT_HN *) * SymbolData(theEnv)->NumberOfFloats);
for (i = 0; i < SymbolData(theEnv)->NumberOfFloats; i++)
{ SymbolData(theEnv)->FloatArray[i] = (FLOAT_HN *) EnvAddDouble(theEnv,floatValues[i]); }
/*========================*/
/* Free the float buffer. */
/*========================*/
rm3(theEnv,(void *) floatValues,(long) (sizeof(double) * SymbolData(theEnv)->NumberOfFloats));
}
globle void ReadNeededIntegers(
void *theEnv)
{
long long *integerValues;
long i;
/*==============================================*/
/* Determine the number of integers to be read. */
/*==============================================*/
GenReadBinary(theEnv,&SymbolData(theEnv)->NumberOfIntegers,(unsigned long) sizeof(unsigned long int));
if (SymbolData(theEnv)->NumberOfIntegers == 0)
{
SymbolData(theEnv)->IntegerArray = NULL;
return;
}
/*=================================*/
/* Allocate area for the integers. */
/*=================================*/
integerValues = (long long *) gm3(theEnv,(long) (sizeof(long long) * SymbolData(theEnv)->NumberOfIntegers));
GenReadBinary(theEnv,(void *) integerValues,(unsigned long) (sizeof(long long) * SymbolData(theEnv)->NumberOfIntegers));
/*==========================================*/
/* Store the integers in the integer array. */
/*==========================================*/
SymbolData(theEnv)->IntegerArray = (INTEGER_HN **)
gm3(theEnv,(long) (sizeof(INTEGER_HN *) * SymbolData(theEnv)->NumberOfIntegers));
for (i = 0; i < SymbolData(theEnv)->NumberOfIntegers; i++)
{ SymbolData(theEnv)->IntegerArray[i] = (INTEGER_HN *) EnvAddLong(theEnv,integerValues[i]); }
/*==========================*/
/* Free the integer buffer. */
/*==========================*/
rm3(theEnv,(void *) integerValues,(long) (sizeof(long long) * SymbolData(theEnv)->NumberOfIntegers));
}
static void BloadBinaryItem(
void *theEnv)
{
unsigned long int space;
GenReadBinary(theEnv,&space,(unsigned long) sizeof(unsigned long int));
if (DefmoduleData(theEnv)->BNumberOfDefmodules == 0) return;
BloadandRefresh(theEnv,DefmoduleData(theEnv)->BNumberOfDefmodules,(unsigned) sizeof(struct bsaveDefmodule),UpdateDefmodule);
BloadandRefresh(theEnv,DefmoduleData(theEnv)->NumberOfPortItems,(unsigned) sizeof(struct bsavePortItem),UpdatePortItem);
SetListOfDefmodules(theEnv,(void *) DefmoduleData(theEnv)->DefmoduleArray);
EnvSetCurrentModule(theEnv,(void *) EnvGetNextDefmodule(theEnv,NULL));
}
void AllocateExpressions(
Environment *theEnv)
{
size_t space;
GenReadBinary(theEnv,&ExpressionData(theEnv)->NumberOfExpressions,sizeof(long));
if (ExpressionData(theEnv)->NumberOfExpressions == 0L)
ExpressionData(theEnv)->ExpressionArray = NULL;
else
{
space = ExpressionData(theEnv)->NumberOfExpressions * sizeof(struct expr);
ExpressionData(theEnv)->ExpressionArray = (struct expr *) genalloc(theEnv,space);
}
}
/************************************************************
NAME : BloadandRefresh
DESCRIPTION : Loads and refreshes objects - will bload
all objects at once, if possible, but
will aslo work in increments if memory is
restricted
INPUTS : 1) the number of objects to bload and update
2) the size of one object
3) An update function which takes a bloaded
object buffer and the index of the object
to refresh as arguments
RETURNS : Nothing useful
SIDE EFFECTS : Objects bloaded and updated
NOTES : Assumes binary file pointer is positioned
for bloads of the objects
************************************************************/
globle void BloadandRefresh(
void *theEnv,
long objcnt,
unsigned objsz,
void (*objupdate)(void *,void *,long))
{
register long i,bi;
char *buf;
long objsmaxread,objsread;
unsigned long space;
int (*oldOutOfMemoryFunction)(void *,unsigned long);
if (objcnt == 0L) return;
oldOutOfMemoryFunction = EnvSetOutOfMemoryFunction(theEnv,BloadOutOfMemoryFunction);
objsmaxread = objcnt;
do
{
space = objsmaxread * objsz;
buf = (char *) genlongalloc(theEnv,space);
if (buf == NULL)
{
if ((objsmaxread / 2) == 0)
{
if ((*oldOutOfMemoryFunction)(theEnv,space) == TRUE)
{
EnvSetOutOfMemoryFunction(theEnv,oldOutOfMemoryFunction);
return;
}
}
else
objsmaxread /= 2;
}
}
while (buf == NULL);
EnvSetOutOfMemoryFunction(theEnv,oldOutOfMemoryFunction);
i = 0L;
do
{
objsread = (objsmaxread > (objcnt - i)) ? (objcnt - i) : objsmaxread;
GenReadBinary(theEnv,(void *) buf,objsread * objsz);
for (bi = 0L ; bi < objsread ; bi++ , i++)
(*objupdate)(theEnv,buf + objsz * bi,i);
}
while (i < objcnt);
genlongfree(theEnv,(void *) buf,space);
}
/*********************************************************************
NAME : BloadGenerics
DESCRIPTION : This routine reads generic function information from
a binary file in four chunks:
Generic-header array
Method array
Method restrictions array
Restriction types array
This routine moves through the generic function
binary arrays updating pointers
INPUTS : None
RETURNS : Nothing useful
SIDE EFFECTS : Pointers reset from array indices
NOTES : Assumes all loading is finished
********************************************************************/
static void BloadGenerics(
void *theEnv)
{
size_t space;
GenReadBinary(theEnv,(void *) &space,sizeof(size_t));
if (DefgenericBinaryData(theEnv)->ModuleCount == 0L)
return;
BloadandRefresh(theEnv,DefgenericBinaryData(theEnv)->ModuleCount,sizeof(BSAVE_DEFGENERIC_MODULE),UpdateGenericModule);
if (DefgenericBinaryData(theEnv)->GenericCount == 0L)
return;
BloadandRefresh(theEnv,DefgenericBinaryData(theEnv)->GenericCount,sizeof(BSAVE_GENERIC),UpdateGeneric);
BloadandRefresh(theEnv,DefgenericBinaryData(theEnv)->MethodCount,sizeof(BSAVE_METHOD),UpdateMethod);
BloadandRefresh(theEnv,DefgenericBinaryData(theEnv)->RestrictionCount,sizeof(BSAVE_RESTRICTION),UpdateRestriction);
BloadandRefresh(theEnv,DefgenericBinaryData(theEnv)->TypeCount,sizeof(long),UpdateType);
}
/****************************************************
NAME : BloadObjectPatterns
DESCRIPTION : Reads in all object pattern
data structures from binary
image and updates pointers
INPUTS : None
RETURNS : Nothing useful
SIDE EFFECTS : Binary data structures updated
NOTES : Assumes storage allocated previously
****************************************************/
static void BloadObjectPatterns(
void *theEnv)
{
UNLN space;
GenReadBinary(theEnv,(void *) &space,(UNLN) sizeof(UNLN));
if (space == 0L)
return;
/* ================================================
Read in the alpha and intermediate pattern nodes
================================================ */
BloadandRefresh(theEnv,ObjectReteBinaryData(theEnv)->AlphaNodeCount,(unsigned) sizeof(BSAVE_OBJECT_ALPHA_NODE),UpdateAlpha);
BloadandRefresh(theEnv,ObjectReteBinaryData(theEnv)->PatternNodeCount,(unsigned) sizeof(BSAVE_OBJECT_PATTERN_NODE),UpdatePattern);
/* =======================
Set the global pointers
======================= */
SetObjectNetworkTerminalPointer(theEnv,(OBJECT_ALPHA_NODE *) &ObjectReteBinaryData(theEnv)->AlphaArray[0]);
SetObjectNetworkPointer(theEnv,(OBJECT_PATTERN_NODE *) &ObjectReteBinaryData(theEnv)->PatternArray[0]);
}
static void BloadBinaryItem(
void *theEnv)
{
unsigned long space;
/*======================================================*/
/* Read in the amount of space used by the binary image */
/* (this is used to skip the construct in the event it */
/* is not available in the version being run). */
/*======================================================*/
GenReadBinary(theEnv,&space,(unsigned long) sizeof(unsigned long int));
/*===========================================*/
/* Read in the defruleModule data structures */
/* and refresh the pointers. */
/*===========================================*/
BloadandRefresh(theEnv,DefruleBinaryData(theEnv)->NumberOfDefruleModules,(unsigned) sizeof(struct bsaveDefruleModule),
UpdateDefruleModule);
/*=====================================*/
/* Read in the defrule data structures */
/* and refresh the pointers. */
/*=====================================*/
BloadandRefresh(theEnv,DefruleBinaryData(theEnv)->NumberOfDefrules,(unsigned) sizeof(struct bsaveDefrule),
UpdateDefrule);
/*======================================*/
/* Read in the joinNode data structures */
/* and refresh the pointers. */
/*======================================*/
BloadandRefresh(theEnv,DefruleBinaryData(theEnv)->NumberOfJoins,(unsigned) sizeof(struct bsaveJoinNode),
UpdateJoin);
}
globle int EnvBload(
void *theEnv,
char *fileName)
{
long numberOfFunctions;
unsigned long space;
int error;
char IDbuffer[20];
char constructBuffer[CONSTRUCT_HEADER_SIZE];
struct BinaryItem *biPtr;
struct callFunctionItem *bfPtr;
/*================*/
/* Open the file. */
/*================*/
if (GenOpenReadBinary(theEnv,"bload",fileName) == 0) return(FALSE);
/*=====================================*/
/* Determine if this is a binary file. */
/*=====================================*/
GenReadBinary(theEnv,IDbuffer,(unsigned long) strlen(BloadData(theEnv)->BinaryPrefixID) + 1);
if (strcmp(IDbuffer,BloadData(theEnv)->BinaryPrefixID) != 0)
{
PrintErrorID(theEnv,"BLOAD",2,FALSE);
EnvPrintRouter(theEnv,WERROR,"File ");
EnvPrintRouter(theEnv,WERROR,fileName);
EnvPrintRouter(theEnv,WERROR," is not a binary construct file.\n");
GenCloseBinary(theEnv);
return(FALSE);
}
/*=======================================*/
/* Determine if it's a binary file using */
/* a format from a different version. */
/*=======================================*/
GenReadBinary(theEnv,IDbuffer,(unsigned long) strlen(BloadData(theEnv)->BinaryVersionID) + 1);
if (strcmp(IDbuffer,BloadData(theEnv)->BinaryVersionID) != 0)
{
PrintErrorID(theEnv,"BLOAD",3,FALSE);
EnvPrintRouter(theEnv,WERROR,"File ");
EnvPrintRouter(theEnv,WERROR,fileName);
EnvPrintRouter(theEnv,WERROR," is an incompatible binary construct file.\n");
GenCloseBinary(theEnv);
return(FALSE);
}
/*====================*/
/* Clear environment. */
/*====================*/
if (BloadData(theEnv)->BloadActive)
{
if (ClearBload(theEnv) == FALSE)
{
GenCloseBinary(theEnv);
return(FALSE);
}
}
/*=================================*/
/* Determine if the KB environment */
/* was successfully cleared. */
/*=================================*/
if (ClearReady(theEnv) == FALSE)
{
GenCloseBinary(theEnv);
EnvPrintRouter(theEnv,WERROR,"The ");
EnvPrintRouter(theEnv,WERROR,APPLICATION_NAME);
EnvPrintRouter(theEnv,WERROR," environment could not be cleared.\n");
EnvPrintRouter(theEnv,WERROR,"Binary load cannot continue.\n");
return(FALSE);
}
/*==================================*/
/* Call the list of functions to be */
/* executed before a bload occurs. */
/*==================================*/
for (bfPtr = BloadData(theEnv)->BeforeBloadFunctions;
bfPtr != NULL;
bfPtr = bfPtr->next)
{
if (bfPtr->environmentAware)
{ (*bfPtr->func)(theEnv); }
else
{ (* (void (*)(void)) bfPtr->func)(); }
}
/*====================================================*/
/* Read in the functions needed by this binary image. */
/*====================================================*/
BloadData(theEnv)->FunctionArray = ReadNeededFunctions(theEnv,&numberOfFunctions,&error);
if (error)
{
GenCloseBinary(theEnv);
AbortBload(theEnv);
return(FALSE);
}
/*================================================*/
/* Read in the atoms needed by this binary image. */
/*================================================*/
ReadNeededAtomicValues(theEnv);
/*===========================================*/
/* Determine the number of expressions to be */
/* read and allocate the appropriate space */
/*===========================================*/
AllocateExpressions(theEnv);
/*==========================================================*/
/* Read in the memory requirements of the constructs stored */
/* in this binary image and allocate the necessary space */
/*==========================================================*/
for (GenReadBinary(theEnv,constructBuffer,(unsigned long) CONSTRUCT_HEADER_SIZE);
strncmp(constructBuffer,BloadData(theEnv)->BinaryPrefixID,CONSTRUCT_HEADER_SIZE) != 0;
GenReadBinary(theEnv,constructBuffer,(unsigned long) CONSTRUCT_HEADER_SIZE))
{
intBool found;
/*================================================*/
/* Search for the construct type in the list of */
/* binary items. If found, allocate the storage */
/* needed by the construct for this binary image. */
/*================================================*/
found = FALSE;
for (biPtr = BsaveData(theEnv)->ListOfBinaryItems;
biPtr != NULL;
biPtr = biPtr->next)
{
if (strncmp(biPtr->name,constructBuffer,CONSTRUCT_HEADER_SIZE) == 0)
{
if (biPtr->bloadStorageFunction != NULL)
{
(*biPtr->bloadStorageFunction)(theEnv);
found = TRUE;
}
break;
}
}
/*==========================================*/
/* If the construct type wasn't found, skip */
/* the storage binary load information for */
/* this construct. */
/*==========================================*/
if (! found)
{
GenReadBinary(theEnv,&space,(unsigned long) sizeof(unsigned long));
GetSeekCurBinary(theEnv,(long) space);
if (space != 0)
{
EnvPrintRouter(theEnv,WDIALOG,"\nSkipping ");
EnvPrintRouter(theEnv,WDIALOG,constructBuffer);
EnvPrintRouter(theEnv,WDIALOG," constructs because of unavailibility\n");
}
}
}
/*======================================*/
/* Refresh the pointers in expressions. */
/*======================================*/
RefreshExpressions(theEnv);
/*==========================*/
/* Read in the constraints. */
/*==========================*/
ReadNeededConstraints(theEnv);
/*======================================================*/
/* Read in the constructs stored in this binary image. */
/*======================================================*/
for (GenReadBinary(theEnv,constructBuffer,(unsigned long) CONSTRUCT_HEADER_SIZE);
strncmp(constructBuffer,BloadData(theEnv)->BinaryPrefixID,CONSTRUCT_HEADER_SIZE) != 0;
GenReadBinary(theEnv,constructBuffer,(unsigned long) CONSTRUCT_HEADER_SIZE))
{
intBool found;
/*==================================================*/
/* Search for the function to load the construct */
/* into the previously allocated storage. If found, */
/* call the function to load the construct. */
/*==================================================*/
found = FALSE;
for (biPtr = BsaveData(theEnv)->ListOfBinaryItems;
biPtr != NULL;
biPtr = biPtr->next)
{
if (strncmp(biPtr->name,constructBuffer,CONSTRUCT_HEADER_SIZE) == 0)
{
if (biPtr->bloadFunction != NULL)
{
(*biPtr->bloadFunction)(theEnv);
found = TRUE;
}
break;
}
}
/*==========================================*/
/* If the construct type wasn't found, skip */
/* the binary data for this construct. */
/*==========================================*/
if (! found)
{
GenReadBinary(theEnv,&space,(unsigned long) sizeof(unsigned long));
GetSeekCurBinary(theEnv,(long) space);
}
}
/*=================*/
/* Close the file. */
/*=================*/
GenCloseBinary(theEnv);
/*========================================*/
/* Free up temporary storage used for the */
/* function and atomic value information. */
/*========================================*/
if (BloadData(theEnv)->FunctionArray != NULL)
{
genlongfree(theEnv,(void *) BloadData(theEnv)->FunctionArray,
(unsigned long) sizeof(struct FunctionDefinition *) * numberOfFunctions);
}
FreeAtomicValueStorage(theEnv);
/*==================================*/
/* Call the list of functions to be */
/* executed after a bload occurs. */
/*==================================*/
for (bfPtr = BloadData(theEnv)->AfterBloadFunctions;
bfPtr != NULL;
bfPtr = bfPtr->next)
{
if (bfPtr->environmentAware)
{ (*bfPtr->func)(theEnv); }
else
{ (* (void (*)(void)) bfPtr->func)(); }
}
/*=======================================*/
/* Add a clear function to remove binary */
/* load when a clear command is issued. */
/*=======================================*/
BloadData(theEnv)->BloadActive = TRUE;
EnvAddClearFunction(theEnv,"bload",(void (*)(void *)) ClearBload,10000);
/*=============================*/
/* Return TRUE to indicate the */
/* binary load was successful. */
/*=============================*/
return(TRUE);
}
