/***************************************************
NAME : UpdateDeffunction
DESCRIPTION : Updates deffunction with binary
load data - sets pointers from
offset information
INPUTS : 1) A pointer to the bloaded data
2) The index of the binary array
element to update
RETURNS : Nothing useful
SIDE EFFECTS : Deffunction pointers upadted
NOTES : None
***************************************************/
static void UpdateDeffunction(
void *theEnv,
void *buf,
long obji)
{
BSAVE_DEFFUNCTION *bdptr;
DEFFUNCTION *dptr;
bdptr = (BSAVE_DEFFUNCTION *) buf;
dptr = (DEFFUNCTION *) &DeffunctionBinaryData(theEnv)->DeffunctionArray[obji];
UpdateConstructHeader(theEnv,&bdptr->header,&dptr->header,
(int) sizeof(DEFFUNCTION_MODULE),(void *) DeffunctionBinaryData(theEnv)->ModuleArray,
(int) sizeof(DEFFUNCTION),(void *) DeffunctionBinaryData(theEnv)->DeffunctionArray);
dptr->code = ExpressionPointer(bdptr->code);
dptr->busy = 0;
dptr->executing = 0;
#if DEBUGGING_FUNCTIONS
dptr->trace = (unsigned short) DeffunctionData(theEnv)->WatchDeffunctions;
#endif
dptr->minNumberOfParameters = bdptr->minNumberOfParameters;
dptr->maxNumberOfParameters = bdptr->maxNumberOfParameters;
dptr->numberOfLocalVars = bdptr->numberOfLocalVars;
}
static void UpdateDeftemplate(
Environment *theEnv,
void *buf,
unsigned long obji)
{
Deftemplate *theDeftemplate;
struct bsaveDeftemplate *bdtPtr;
bdtPtr = (struct bsaveDeftemplate *) buf;
theDeftemplate = &DeftemplateBinaryData(theEnv)->DeftemplateArray[obji];
UpdateConstructHeader(theEnv,&bdtPtr->header,&theDeftemplate->header,DEFTEMPLATE,
sizeof(struct deftemplateModule),DeftemplateBinaryData(theEnv)->ModuleArray,
sizeof(Deftemplate),DeftemplateBinaryData(theEnv)->DeftemplateArray);
if (bdtPtr->slotList != ULONG_MAX)
{ theDeftemplate->slotList = (struct templateSlot *) &DeftemplateBinaryData(theEnv)->SlotArray[bdtPtr->slotList]; }
else
{ theDeftemplate->slotList = NULL; }
if (bdtPtr->patternNetwork != ULONG_MAX)
{ theDeftemplate->patternNetwork = (struct factPatternNode *) BloadFactPatternPointer(bdtPtr->patternNetwork); }
else
{ theDeftemplate->patternNetwork = NULL; }
theDeftemplate->implied = bdtPtr->implied;
#if DEBUGGING_FUNCTIONS
theDeftemplate->watch = FactData(theEnv)->WatchFacts;
#endif
theDeftemplate->inScope = false;
theDeftemplate->numberOfSlots = bdtPtr->numberOfSlots;
theDeftemplate->factList = NULL;
theDeftemplate->lastFact = NULL;
}
static void UpdateDefrule(
void *theEnv,
void *buf,
long obji)
{
struct bsaveDefrule *br;
br = (struct bsaveDefrule *) buf;
UpdateConstructHeader(theEnv,&br->header,&DefruleBinaryData(theEnv)->DefruleArray[obji].header,
(int) sizeof(struct defruleModule),(void *) DefruleBinaryData(theEnv)->ModuleArray,
(int) sizeof(struct defrule),(void *) DefruleBinaryData(theEnv)->DefruleArray);
DefruleBinaryData(theEnv)->DefruleArray[obji].dynamicSalience = ExpressionPointer(br->dynamicSalience);
DefruleBinaryData(theEnv)->DefruleArray[obji].actions = ExpressionPointer(br->actions);
DefruleBinaryData(theEnv)->DefruleArray[obji].logicalJoin = BloadJoinPointer(br->logicalJoin);
DefruleBinaryData(theEnv)->DefruleArray[obji].lastJoin = BloadJoinPointer(br->lastJoin);
DefruleBinaryData(theEnv)->DefruleArray[obji].disjunct = BloadDefrulePointer(DefruleBinaryData(theEnv)->DefruleArray,br->disjunct);
DefruleBinaryData(theEnv)->DefruleArray[obji].salience = br->salience;
DefruleBinaryData(theEnv)->DefruleArray[obji].localVarCnt = br->localVarCnt;
DefruleBinaryData(theEnv)->DefruleArray[obji].complexity = br->complexity;
DefruleBinaryData(theEnv)->DefruleArray[obji].autoFocus = br->autoFocus;
DefruleBinaryData(theEnv)->DefruleArray[obji].executing = 0;
DefruleBinaryData(theEnv)->DefruleArray[obji].afterBreakpoint = 0;
#if DEBUGGING_FUNCTIONS
DefruleBinaryData(theEnv)->DefruleArray[obji].watchActivation = AgendaData(theEnv)->WatchActivations;
DefruleBinaryData(theEnv)->DefruleArray[obji].watchFiring = DefruleData(theEnv)->WatchRules;
#endif
}
static void UpdateDeftemplate(
void *theEnv,
void *buf,
long obji)
{
struct deftemplate *theDeftemplate;
struct bsaveDeftemplate *bdtPtr;
bdtPtr = (struct bsaveDeftemplate *) buf;
theDeftemplate = (struct deftemplate *) &DeftemplateBinaryData(theEnv)->DeftemplateArray[obji];
UpdateConstructHeader(theEnv,&bdtPtr->header,&theDeftemplate->header,
(int) sizeof(struct deftemplateModule),(void *) DeftemplateBinaryData(theEnv)->ModuleArray,
(int) sizeof(struct deftemplate),(void *) DeftemplateBinaryData(theEnv)->DeftemplateArray);
if (bdtPtr->slotList != -1L)
{ theDeftemplate->slotList = (struct templateSlot *) &DeftemplateBinaryData(theEnv)->SlotArray[bdtPtr->slotList]; }
else
{ theDeftemplate->slotList = NULL; }
if (bdtPtr->patternNetwork != -1L)
{ theDeftemplate->patternNetwork = (struct factPatternNode *) BloadFactPatternPointer(bdtPtr->patternNetwork); }
else
{ theDeftemplate->patternNetwork = NULL; }
theDeftemplate->implied = bdtPtr->implied;
#if DEBUGGING_FUNCTIONS
theDeftemplate->watch = FactData(theEnv)->WatchFacts;
#endif
theDeftemplate->inScope = FALSE;
theDeftemplate->numberOfSlots = (unsigned short) bdtPtr->numberOfSlots;
theDeftemplate->factList = NULL;
theDeftemplate->lastFact = NULL;
}
static void UpdateDeffacts(
void *theEnv,
void *buf,
long obji)
{
struct bsaveDeffacts *bdp;
bdp = (struct bsaveDeffacts *) buf;
UpdateConstructHeader(theEnv,&bdp->header,&DeffactsBinaryData(theEnv)->DeffactsArray[obji].header,
(int) sizeof(struct deffactsModule),(void *) DeffactsBinaryData(theEnv)->ModuleArray,
(int) sizeof(struct deffacts),(void *) DeffactsBinaryData(theEnv)->DeffactsArray);
DeffactsBinaryData(theEnv)->DeffactsArray[obji].assertList = ExpressionPointer(bdp->assertList);
}
static void UpdateDefclass(
void *buf,
long obji)
{
BSAVE_DEFCLASS *bcls;
DEFCLASS *cls;
bcls = (BSAVE_DEFCLASS *) buf;
cls = (DEFCLASS *) &defclassArray[obji];
UpdateConstructHeader(&bcls->header,&cls->header,
(int) sizeof(DEFCLASS_MODULE),(void *) ModuleArray,
(int) sizeof(DEFCLASS),(void *) defclassArray);
cls->abstract = bcls->abstract;
cls->reactive = bcls->reactive;
cls->system = bcls->system;
cls->id = bcls->id;
ClassIDMap[cls->id] = cls;
#if DEBUGGING_FUNCTIONS
cls->traceInstances = WatchInstances;
cls->traceSlots = WatchSlots;
#endif
cls->slotCount = bcls->slotCount;
cls->instanceSlotCount = bcls->instanceSlotCount;
cls->localInstanceSlotCount = bcls->localInstanceSlotCount;
cls->maxSlotNameID = bcls->maxSlotNameID;
cls->handlerCount = bcls->handlerCount;
cls->directSuperclasses.classCount =bcls->directSuperclasses.classCount;
cls->directSuperclasses.classArray = LinkPointer(bcls->directSuperclasses.classArray);
cls->directSubclasses.classCount =bcls->directSubclasses.classCount;
cls->directSubclasses.classArray = LinkPointer(bcls->directSubclasses.classArray);
cls->allSuperclasses.classCount =bcls->allSuperclasses.classCount;
cls->allSuperclasses.classArray = LinkPointer(bcls->allSuperclasses.classArray);
cls->slots = SlotPointer(bcls->slots);
cls->instanceTemplate = TemplateSlotPointer(bcls->instanceTemplate);
cls->slotNameMap = OrderedSlotPointer(bcls->slotNameMap);
cls->instanceList = NULL;
cls->handlers = HandlerPointer(bcls->handlers);
cls->handlerOrderMap = OrderedHandlerPointer(bcls->handlers);
cls->installed = 1;
cls->busy = 0;
cls->instanceList = NULL;
cls->instanceListBottom = NULL;
#if DEFMODULE_CONSTRUCT
cls->scopeMap = BitMapPointer(bcls->scopeMap);
IncrementBitMapCount(cls->scopeMap);
#else
cls->scopeMap = NULL;
#endif
PutClassInTable(cls);
}
/***************************************************
NAME : UpdateDefinstances
DESCRIPTION : Updates definstances with binary
load data - sets pointers from
offset information
INPUTS : 1) A pointer to the bloaded data
2) The index of the binary array
element to update
RETURNS : Nothing useful
SIDE EFFECTS : Definstances pointers upadted
NOTES : None
***************************************************/
static void UpdateDefinstances(
void *theEnv,
void *buf,
long obji)
{
BSAVE_DEFINSTANCES *bdptr;
DEFINSTANCES *dfiptr;
bdptr = (BSAVE_DEFINSTANCES *) buf;
dfiptr = (DEFINSTANCES *) &DefinstancesBinaryData(theEnv)->DefinstancesArray[obji];
UpdateConstructHeader(theEnv,&bdptr->header,&dfiptr->header,
(int) sizeof(DEFINSTANCES_MODULE),(void *) DefinstancesBinaryData(theEnv)->ModuleArray,
(int) sizeof(DEFINSTANCES),(void *) DefinstancesBinaryData(theEnv)->DefinstancesArray);
dfiptr->mkinstance = ExpressionPointer(bdptr->mkinstance);
dfiptr->busy = 0;
}
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 UpdateDefrule(
void *buf,
long obji)
{
struct bsaveDefrule *br;
br = (struct bsaveDefrule *) buf;
UpdateConstructHeader(&br->header,&DefruleArray[obji].header,
(int) sizeof(struct defruleModule),(void *) ModuleArray,
(int) sizeof(struct defrule),(void *) DefruleArray);
#if DYNAMIC_SALIENCE
DefruleArray[obji].dynamicSalience = ExpressionPointer(br->dynamicSalience);
#endif
#if CERTAINTY_FACTORS
DefruleArray[obji].dynamicCF = ExpressionPointer(br->dynamicCF);
#endif
DefruleArray[obji].actions = ExpressionPointer(br->actions);
#if LOGICAL_DEPENDENCIES
DefruleArray[obji].logicalJoin = BloadJoinPointer(br->logicalJoin);
#endif
DefruleArray[obji].lastJoin = BloadJoinPointer(br->lastJoin);
DefruleArray[obji].disjunct = BloadDefrulePointer(DefruleArray,br->disjunct);
DefruleArray[obji].salience = br->salience;
#if CERTAINTY_FACTORS
DefruleArray[obji].CF = br->CF;
#endif
DefruleArray[obji].localVarCnt = br->localVarCnt;
DefruleArray[obji].complexity = br->complexity;
DefruleArray[obji].autoFocus = br->autoFocus;
DefruleArray[obji].executing = 0;
DefruleArray[obji].afterBreakpoint = 0;
#if FUZZY_DEFTEMPLATES
DefruleArray[obji].min_of_maxmins = br->min_of_maxmins;
DefruleArray[obji].lhsRuleType = br->lhsRuleType;
DefruleArray[obji].numberOfFuzzySlots = br->numberOfFuzzySlots;
DefruleArray[obji].pattern_fv_arrayPtr = &PatternFuzzyValueArray[br->pattern_fv_arrayPtr];
#endif
#if DEBUGGING_FUNCTIONS
DefruleArray[obji].watchActivation = WatchActivations;
DefruleArray[obji].watchFiring = WatchRules;
#endif
}
static void UpdateGeneric(
void *buf,
long obji)
{
BSAVE_GENERIC *bgp;
DEFGENERIC *gp;
bgp = (BSAVE_GENERIC *) buf;
gp = (DEFGENERIC *) &defgenericArray[obji];
UpdateConstructHeader(&bgp->header,&gp->header,
(int) sizeof(DEFGENERIC_MODULE),(void *) ModuleArray,
(int) sizeof(DEFGENERIC),(void *) defgenericArray);
defgenericArray[obji].busy = 0;
#if DEBUGGING_FUNCTIONS
defgenericArray[obji].trace = WatchGenerics;
#endif
defgenericArray[obji].methods = MethodPointer(bgp->methods);
defgenericArray[obji].mcnt = bgp->mcnt;
defgenericArray[obji].new_index = 0;
}
static void UpdateGeneric(
void *theEnv,
void *buf,
long obji)
{
BSAVE_GENERIC *bgp;
DEFGENERIC *gp;
bgp = (BSAVE_GENERIC *) buf;
gp = (DEFGENERIC *) &DefgenericBinaryData(theEnv)->DefgenericArray[obji];
UpdateConstructHeader(theEnv,&bgp->header,&gp->header,
(int) sizeof(DEFGENERIC_MODULE),(void *) DefgenericBinaryData(theEnv)->ModuleArray,
(int) sizeof(DEFGENERIC),(void *) DefgenericBinaryData(theEnv)->DefgenericArray);
DefgenericBinaryData(theEnv)->DefgenericArray[obji].busy = 0;
#if DEBUGGING_FUNCTIONS
DefgenericBinaryData(theEnv)->DefgenericArray[obji].trace = DefgenericData(theEnv)->WatchGenerics;
#endif
DefgenericBinaryData(theEnv)->DefgenericArray[obji].methods = MethodPointer(bgp->methods);
DefgenericBinaryData(theEnv)->DefgenericArray[obji].mcnt = bgp->mcnt;
DefgenericBinaryData(theEnv)->DefgenericArray[obji].new_index = 0;
}
