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);
}
static void DeallocateFactBloadData(
void *theEnv)
{
size_t space;
int i;
for (i = 0; i < FactBinaryData(theEnv)->NumberOfPatterns; i++)
{ DestroyAlphaMemory(theEnv,&FactBinaryData(theEnv)->FactPatternArray[i].header,FALSE); }
space = FactBinaryData(theEnv)->NumberOfPatterns * sizeof(struct factPatternNode);
if (space != 0) genfree(theEnv,(void *) FactBinaryData(theEnv)->FactPatternArray,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 BsaveFind(
void *theEnv,
EXEC_STATUS)
{
struct deftemplate *theDeftemplate;
struct defmodule *theModule;
/*=======================================================*/
/* If a binary image is already loaded, then temporarily */
/* save the count values since these will be overwritten */
/* in the process of saving the binary image. */
/*=======================================================*/
SaveBloadCount(theEnv,execStatus,FactBinaryData(theEnv,execStatus)->NumberOfPatterns);
/*=======================================*/
/* Set the count of fact pattern network */
/* data structures to zero. */
/*=======================================*/
FactBinaryData(theEnv,execStatus)->NumberOfPatterns = 0L;
/*===========================*/
/* Loop through each module. */
/*===========================*/
for (theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,execStatus,NULL);
theModule != NULL;
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,execStatus,theModule))
{
/*===============================*/
/* Set the current module to the */
/* module being examined. */
/*===============================*/
EnvSetCurrentModule(theEnv,execStatus,(void *) theModule);
/*=====================================================*/
/* Loop through each deftemplate in the current module */
/* and count the number of data structures which must */
/* be saved for its pattern network. */
/*=====================================================*/
for (theDeftemplate = (struct deftemplate *) EnvGetNextDeftemplate(theEnv,execStatus,NULL);
theDeftemplate != NULL;
theDeftemplate = (struct deftemplate *) EnvGetNextDeftemplate(theEnv,execStatus,theDeftemplate))
{ BsaveDriver(theEnv,execStatus,BSAVE_FIND,NULL,theDeftemplate->patternNetwork); }
}
}
static void BsaveDriver(
void *theEnv,
int action,
FILE *fp,
struct factPatternNode *thePattern)
{
while (thePattern != NULL)
{
switch(action)
{
case BSAVE_FIND:
thePattern->bsaveID = FactBinaryData(theEnv)->NumberOfPatterns++;
break;
case BSAVE_PATTERNS:
BsavePatternNode(theEnv,thePattern,fp);
break;
default:
break;
}
if (thePattern->nextLevel == NULL)
{
while (thePattern->rightNode == NULL)
{
thePattern = thePattern->lastLevel;
if (thePattern == NULL) return;
}
thePattern = thePattern->rightNode;
}
else
{ thePattern = thePattern->nextLevel; }
}
}
static void BsaveFactPatterns(
void *theEnv,
EXEC_STATUS,
FILE *fp)
{
size_t space;
struct deftemplate *theDeftemplate;
struct defmodule *theModule;
/*========================================*/
/* Write out the amount of space taken up */
/* by the factPatternNode data structures */
/* in the binary image. */
/*========================================*/
space = FactBinaryData(theEnv,execStatus)->NumberOfPatterns * sizeof(struct bsaveFactPatternNode);
GenWrite(&space,sizeof(size_t),fp);
/*===========================*/
/* Loop through each module. */
/*===========================*/
for (theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,execStatus,NULL);
theModule != NULL;
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,execStatus,theModule))
{
/*=====================================================*/
/* Loop through each deftemplate in the current module */
/* and save its fact pattern network to the file. */
/*=====================================================*/
EnvSetCurrentModule(theEnv,execStatus,(void *) theModule);
for (theDeftemplate = (struct deftemplate *) EnvGetNextDeftemplate(theEnv,execStatus,NULL);
theDeftemplate != NULL;
theDeftemplate = (struct deftemplate *) EnvGetNextDeftemplate(theEnv,execStatus,theDeftemplate))
{ BsaveDriver(theEnv,execStatus,BSAVE_PATTERNS,fp,theDeftemplate->patternNetwork); }
}
/*=============================================================*/
/* If a binary image was already loaded when the bsave command */
/* was issued, then restore the counts indicating the number */
/* of factPatternNode data structures in the binary image */
/* (these were overwritten by the binary save). */
/*=============================================================*/
RestoreBloadCount(theEnv,execStatus,&FactBinaryData(theEnv,execStatus)->NumberOfPatterns);
}
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);
}
static void UpdateFactPatterns(
void *theEnv,
void *buf,
long obji)
{
struct bsaveFactPatternNode *bp;
bp = (struct bsaveFactPatternNode *) buf;
UpdatePatternNodeHeader(theEnv,&FactBinaryData(theEnv)->FactPatternArray[obji].header,&bp->header);
FactBinaryData(theEnv)->FactPatternArray[obji].bsaveID = 0L;
FactBinaryData(theEnv)->FactPatternArray[obji].whichField = bp->whichField;
FactBinaryData(theEnv)->FactPatternArray[obji].leaveFields = bp->leaveFields;
FactBinaryData(theEnv)->FactPatternArray[obji].whichSlot = bp->whichSlot;
FactBinaryData(theEnv)->FactPatternArray[obji].networkTest = HashedExpressionPointer(bp->networkTest);
FactBinaryData(theEnv)->FactPatternArray[obji].rightNode = BloadFactPatternPointer(bp->rightNode);
FactBinaryData(theEnv)->FactPatternArray[obji].nextLevel = BloadFactPatternPointer(bp->nextLevel);
FactBinaryData(theEnv)->FactPatternArray[obji].lastLevel = BloadFactPatternPointer(bp->lastLevel);
FactBinaryData(theEnv)->FactPatternArray[obji].leftNode = BloadFactPatternPointer(bp->leftNode);
}
static void ClearBload(
void *theEnv)
{
size_t space;
long i;
for (i = 0; i < FactBinaryData(theEnv)->NumberOfPatterns; i++)
{
if ((FactBinaryData(theEnv)->FactPatternArray[i].lastLevel != NULL) &&
(FactBinaryData(theEnv)->FactPatternArray[i].lastLevel->header.selector))
{
RemoveHashedPatternNode(theEnv,FactBinaryData(theEnv)->FactPatternArray[i].lastLevel,
&FactBinaryData(theEnv)->FactPatternArray[i],
FactBinaryData(theEnv)->FactPatternArray[i].networkTest->type,
FactBinaryData(theEnv)->FactPatternArray[i].networkTest->value);
}
}
space = FactBinaryData(theEnv)->NumberOfPatterns * sizeof(struct factPatternNode);
if (space != 0) genfree(theEnv,(void *) FactBinaryData(theEnv)->FactPatternArray,space);
FactBinaryData(theEnv)->NumberOfPatterns = 0;
}