static void UpdateDeftemplateSlot(
Environment *theEnv,
void *buf,
unsigned long obji)
{
struct templateSlot *theSlot;
struct bsaveTemplateSlot *btsPtr;
btsPtr = (struct bsaveTemplateSlot *) buf;
theSlot = (struct templateSlot *) &DeftemplateBinaryData(theEnv)->SlotArray[obji];
theSlot->slotName = SymbolPointer(btsPtr->slotName);
IncrementLexemeCount(theSlot->slotName);
theSlot->defaultList = HashedExpressionPointer(btsPtr->defaultList);
theSlot->facetList = HashedExpressionPointer(btsPtr->facetList);
theSlot->constraints = ConstraintPointer(btsPtr->constraints);
theSlot->multislot = btsPtr->multislot;
theSlot->noDefault = btsPtr->noDefault;
theSlot->defaultPresent = btsPtr->defaultPresent;
theSlot->defaultDynamic = btsPtr->defaultDynamic;
if (btsPtr->next != ULONG_MAX)
{ theSlot->next = (struct templateSlot *) &DeftemplateBinaryData(theEnv)->SlotArray[obji + 1]; }
else
{ theSlot->next = NULL; }
}
static void UpdateJoin(
void *buf,
long obji)
{
struct bsaveJoinNode *bj;
bj = (struct bsaveJoinNode *) buf;
JoinArray[obji].firstJoin = bj->firstJoin;
JoinArray[obji].logicalJoin = bj->logicalJoin;
JoinArray[obji].joinFromTheRight = bj->joinFromTheRight;
JoinArray[obji].patternIsNegated = bj->patternIsNegated;
JoinArray[obji].depth = bj->depth;
JoinArray[obji].rhsType = bj->rhsType;
JoinArray[obji].networkTest = HashedExpressionPointer(bj->networkTest);
JoinArray[obji].nextLevel = BloadJoinPointer(bj->nextLevel);
JoinArray[obji].lastLevel = BloadJoinPointer(bj->lastLevel);
if (bj->joinFromTheRight == TRUE)
{ JoinArray[obji].rightSideEntryStructure = (void *) BloadJoinPointer(bj->rightSideEntryStructure); }
JoinArray[obji].rightMatchNode = BloadJoinPointer(bj->rightMatchNode);
JoinArray[obji].rightDriveNode = BloadJoinPointer(bj->rightDriveNode);
JoinArray[obji].ruleToActivate = BloadDefrulePointer(DefruleArray,bj->ruleToActivate);
JoinArray[obji].initialize = 0;
JoinArray[obji].marked = 0;
JoinArray[obji].bsaveID = 0L;
JoinArray[obji].beta = NULL;
}
/***************************************************
NAME : UpdatePattern
DESCRIPTION : Updates all the pointers for a
pattern node based on the binary
image indices
INPUTS : 1) A pointer to the binary
image pattern node buffer
2) The index of the actual
pattern node in the array
RETURNS : Nothing useful
SIDE EFFECTS : Pattern node updated
NOTES : None
***************************************************/
static void UpdatePattern(
void *theEnv,
EXEC_STATUS,
void *buf,
long obji)
{
BSAVE_OBJECT_PATTERN_NODE *bop;
OBJECT_PATTERN_NODE *op;
bop = (BSAVE_OBJECT_PATTERN_NODE *) buf;
op = (OBJECT_PATTERN_NODE *) &ObjectReteBinaryData(theEnv,execStatus)->PatternArray[obji];
op->blocked = FALSE;
op->multifieldNode = bop->multifieldNode;
op->whichField = bop->whichField;
op->leaveFields = bop->leaveFields;
op->endSlot = bop->endSlot;
op->selector = bop->selector;
op->matchTimeTag = 0L;
op->slotNameID = bop->slotNameID;
op->networkTest = HashedExpressionPointer(bop->networkTest);
op->nextLevel = ObjectPatternPointer(bop->nextLevel);
op->lastLevel = ObjectPatternPointer(bop->lastLevel);
op->leftNode = ObjectPatternPointer(bop->leftNode);
op->rightNode = ObjectPatternPointer(bop->rightNode);
op->alphaNode = ObjectAlphaPointer(bop->alphaNode);
op->bsaveID = 0L;
}
static void CopyFromBsaveConstraintRecord(
void *theEnv,
void *buf,
long theIndex)
{
BSAVE_CONSTRAINT_RECORD *bsaveConstraints;
CONSTRAINT_RECORD *constraints;
bsaveConstraints = (BSAVE_CONSTRAINT_RECORD *) buf;
constraints = (CONSTRAINT_RECORD *) &ConstraintData(theEnv)->ConstraintArray[theIndex];
constraints->anyAllowed = bsaveConstraints->anyAllowed;
constraints->symbolsAllowed = bsaveConstraints->symbolsAllowed;
constraints->stringsAllowed = bsaveConstraints->stringsAllowed;
constraints->floatsAllowed = bsaveConstraints->floatsAllowed;
constraints->integersAllowed = bsaveConstraints->integersAllowed;
constraints->instanceNamesAllowed = bsaveConstraints->instanceNamesAllowed;
constraints->instanceAddressesAllowed = bsaveConstraints->instanceAddressesAllowed;
constraints->externalAddressesAllowed = bsaveConstraints->externalAddressesAllowed;
constraints->voidAllowed = FALSE;
constraints->multifieldsAllowed = bsaveConstraints->multifieldsAllowed;
constraints->singlefieldsAllowed = bsaveConstraints->singlefieldsAllowed;
constraints->factAddressesAllowed = bsaveConstraints->factAddressesAllowed;
constraints->anyRestriction = bsaveConstraints->anyRestriction;
constraints->symbolRestriction = bsaveConstraints->symbolRestriction;
constraints->stringRestriction = bsaveConstraints->stringRestriction;
constraints->floatRestriction = bsaveConstraints->floatRestriction;
constraints->integerRestriction = bsaveConstraints->integerRestriction;
constraints->instanceNameRestriction = bsaveConstraints->instanceNameRestriction;
constraints->restrictionList = HashedExpressionPointer(bsaveConstraints->restrictionList);
constraints->minValue = HashedExpressionPointer(bsaveConstraints->minValue);
constraints->maxValue = HashedExpressionPointer(bsaveConstraints->maxValue);
constraints->minFields = HashedExpressionPointer(bsaveConstraints->minFields);
constraints->maxFields = HashedExpressionPointer(bsaveConstraints->maxFields);
constraints->multifield = NULL;
}
static void UpdateDefglobal(
void *buf,
long obji)
{
struct bsaveDefglobal *bdp;
bdp = (struct bsaveDefglobal *) buf;
UpdateConstructHeader(&bdp->header,&DefglobalArray[obji].header,
(int) sizeof(struct defglobalModule),(void *) ModuleArray,
(int) sizeof(struct defglobal),(void *) DefglobalArray);
#if DEBUGGING_FUNCTIONS
DefglobalArray[obji].watch = WatchGlobals;
#endif
DefglobalArray[obji].initial = HashedExpressionPointer(bdp->initial);
DefglobalArray[obji].current.type = RVOID;
}
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);
}
