/***************************************************
NAME : UpdateAlpha
DESCRIPTION : Updates all the pointers for an
alpha node based on the binary
image indices
INPUTS : 1) A pointer to the binary
image alpha node buffer
2) The index of the actual
alpha node in the array
RETURNS : Nothing useful
SIDE EFFECTS : Alpha node updated
NOTES : None
***************************************************/
static void UpdateAlpha(
void *theEnv,
EXEC_STATUS,
void *buf,
long obji)
{
BSAVE_OBJECT_ALPHA_NODE *bap;
OBJECT_ALPHA_NODE *ap;
bap = (BSAVE_OBJECT_ALPHA_NODE *) buf;
ap = (OBJECT_ALPHA_NODE *) &ObjectReteBinaryData(theEnv,execStatus)->AlphaArray[obji];
UpdatePatternNodeHeader(theEnv,execStatus,&ap->header,&bap->header);
ap->matchTimeTag = 0L;
ap->classbmp = BitMapPointer(bap->classbmp);
if (bap->slotbmp != -1L)
{
ap->slotbmp = BitMapPointer(bap->slotbmp);
IncrementBitMapCount(ap->slotbmp);
}
else
ap->slotbmp = NULL;
IncrementBitMapCount(ap->classbmp);
ap->patternNode = ObjectPatternPointer(bap->patternNode);
ap->nxtInGroup = ObjectAlphaPointer(bap->nxtInGroup);
ap->nxtTerminal = ObjectAlphaPointer(bap->nxtTerminal);
ap->bsaveID = 0L;
}
/***************************************************
NAME : UpdateDefclassesScope
DESCRIPTION : This function updates the scope
bitmaps for existing classes when
a new module is defined
INPUTS : None
RETURNS : Nothing
SIDE EFFECTS : Class scope bitmaps are updated
NOTES : None
***************************************************/
static void UpdateDefclassesScope(
void *theEnv)
{
register unsigned i;
DEFCLASS *theDefclass;
int newModuleID,count;
char *newScopeMap;
unsigned newScopeMapSize;
char *className;
struct defmodule *matchModule;
newModuleID = (int) ((struct defmodule *) EnvGetCurrentModule(theEnv))->bsaveID;
newScopeMapSize = (sizeof(char) * ((GetNumberOfDefmodules(theEnv) / BITS_PER_BYTE) + 1));
newScopeMap = (char *) gm2(theEnv,newScopeMapSize);
for (i = 0 ; i < CLASS_TABLE_HASH_SIZE ; i++)
for (theDefclass = DefclassData(theEnv)->ClassTable[i] ;
theDefclass != NULL ;
theDefclass = theDefclass->nxtHash)
{
matchModule = theDefclass->header.whichModule->theModule;
className = ValueToString(theDefclass->header.name);
ClearBitString((void *) newScopeMap,newScopeMapSize);
GenCopyMemory(char,theDefclass->scopeMap->size,
newScopeMap,ValueToBitMap(theDefclass->scopeMap));
DecrementBitMapCount(theEnv,theDefclass->scopeMap);
if (theDefclass->system)
SetBitMap(newScopeMap,newModuleID);
else if (FindImportedConstruct(theEnv,(char*)"defclass",matchModule,
className,&count,TRUE,NULL) != NULL)
SetBitMap(newScopeMap,newModuleID);
theDefclass->scopeMap = (BITMAP_HN *) EnvAddBitMap(theEnv,(void *) newScopeMap,newScopeMapSize);
IncrementBitMapCount(theDefclass->scopeMap);
}
rm(theEnv,(void *) newScopeMap,newScopeMapSize);
}
globle void *CreateDeftemplateScopeMap(
void *theEnv,
struct deftemplate *theDeftemplate)
{
unsigned scopeMapSize;
char *scopeMap;
char *templateName;
struct defmodule *matchModule, *theModule;
int moduleID,count;
void *theBitMap;
templateName = ValueToString(theDeftemplate->header.name);
matchModule = theDeftemplate->header.whichModule->theModule;
scopeMapSize = (sizeof(char) * ((GetNumberOfDefmodules(theEnv) / BITS_PER_BYTE) + 1));
scopeMap = (char *) gm2(theEnv,scopeMapSize);
ClearBitString((void *) scopeMap,scopeMapSize);
SaveCurrentModule(theEnv);
for (theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,NULL) ;
theModule != NULL ;
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,(void *) theModule))
{
EnvSetCurrentModule(theEnv,(void *) theModule);
moduleID = (int) theModule->bsaveID;
if (FindImportedConstruct(theEnv,"deftemplate",matchModule,
templateName,&count,TRUE,NULL) != NULL)
SetBitMap(scopeMap,moduleID);
}
RestoreCurrentModule(theEnv);
theBitMap = EnvAddBitMap(theEnv,scopeMap,scopeMapSize);
IncrementBitMapCount(theBitMap);
rm(theEnv,(void *) scopeMap,scopeMapSize);
return(theBitMap);
}
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);
}
globle void AtomInstall(
int type,
void *vPtr)
{
switch (type)
{
case SYMBOL:
case STRING:
#if DEFGLOBAL_CONSTRUCT
case GBL_VARIABLE:
#endif
#if OBJECT_SYSTEM
case INSTANCE_NAME:
#endif
IncrementSymbolCount(vPtr);
break;
case FLOAT:
IncrementFloatCount(vPtr);
break;
case INTEGER:
IncrementIntegerCount(vPtr);
break;
case MULTIFIELD:
MultifieldInstall((struct multifield *) vPtr);
break;
#if FUZZY_DEFTEMPLATES
/* fuzzy values have a name which is a symbol */
case FUZZY_VALUE:
InstallFuzzyValue(vPtr);
break;
#endif
case RVOID:
break;
default:
if (PrimitivesArray[type] == NULL) break;
if (PrimitivesArray[type]->bitMap) IncrementBitMapCount(vPtr);
else if (PrimitivesArray[type]->incrementBusyCount)
{ (*PrimitivesArray[type]->incrementBusyCount)(vPtr); }
break;
}
}
globle void AtomInstall(
void *theEnv,
int type,
void *vPtr)
{
switch (type)
{
case SYMBOL:
case STRING:
#if DEFGLOBAL_CONSTRUCT
case GBL_VARIABLE:
#endif
#if OBJECT_SYSTEM
case INSTANCE_NAME:
#endif
IncrementSymbolCount(vPtr);
break;
case FLOAT:
IncrementFloatCount(vPtr);
break;
case INTEGER:
IncrementIntegerCount(vPtr);
break;
case EXTERNAL_ADDRESS:
IncrementExternalAddressCount(vPtr);
break;
case MULTIFIELD:
MultifieldInstall(theEnv,(struct multifield *) vPtr);
break;
case RVOID:
break;
default:
if (EvaluationData(theEnv)->PrimitivesArray[type] == NULL) break;
if (EvaluationData(theEnv)->PrimitivesArray[type]->bitMap) IncrementBitMapCount(vPtr);
else if (EvaluationData(theEnv)->PrimitivesArray[type]->incrementBusyCount)
{ (*EvaluationData(theEnv)->PrimitivesArray[type]->incrementBusyCount)(theEnv,vPtr); }
break;
}
}
/*********************************************************
NAME : AddSystemClass
DESCRIPTION : Performs all necessary allocations
for adding a system class
INPUTS : 1) The name-string of the system class
2) The address of the parent class
(NULL if none)
RETURNS : The address of the new system class
SIDE EFFECTS : Allocations performed
NOTES : Assumes system-class name is unique
Also assumes SINGLE INHERITANCE for
system classes to simplify precedence
list determination
Adds classes to has table but NOT to
class list (this is responsibility
of caller)
*********************************************************/
static DEFCLASS *AddSystemClass(
void *theEnv,
char *name,
DEFCLASS *parent)
{
DEFCLASS *sys;
long i;
char defaultScopeMap[1];
sys = NewClass(theEnv,(SYMBOL_HN *) EnvAddSymbol(theEnv,name));
sys->abstract = 1;
#if DEFRULE_CONSTRUCT
sys->reactive = 0;
#endif
IncrementSymbolCount(sys->header.name);
sys->installed = 1;
sys->system = 1;
sys->hashTableIndex = HashClass(sys->header.name);
AddClassLink(theEnv,&sys->allSuperclasses,sys,-1);
if (parent != NULL)
{
AddClassLink(theEnv,&sys->directSuperclasses,parent,-1);
AddClassLink(theEnv,&parent->directSubclasses,sys,-1);
AddClassLink(theEnv,&sys->allSuperclasses,parent,-1);
for (i = 1 ; i < parent->allSuperclasses.classCount ; i++)
AddClassLink(theEnv,&sys->allSuperclasses,parent->allSuperclasses.classArray[i],-1);
}
sys->nxtHash = DefclassData(theEnv)->ClassTable[sys->hashTableIndex];
DefclassData(theEnv)->ClassTable[sys->hashTableIndex] = sys;
/* =========================================
Add default scope maps for a system class
There is only one module (MAIN) so far -
which has an id of 0
========================================= */
ClearBitString((void *) defaultScopeMap,(int) sizeof(char));
SetBitMap(defaultScopeMap,0);
#if DEFMODULE_CONSTRUCT
sys->scopeMap = (BITMAP_HN *) EnvAddBitMap(theEnv,(void *) defaultScopeMap,(int) sizeof(char));
IncrementBitMapCount(sys->scopeMap);
#endif
return(sys);
}
/*********************************************************
NAME : UpdateExpression
DESCRIPTION : Given a bloaded expression buffer,
this routine refreshes the pointers
in the expression array
INPUTS : 1) a bloaded expression buffer
2) the index of the expression to refresh
RETURNS : Nothing useful
SIDE EFFECTS : Expression updated
NOTES : None
*********************************************************/
static void UpdateExpression(
Environment *theEnv,
void *buf,
unsigned long obji)
{
BSAVE_EXPRESSION *bexp;
unsigned long theIndex;
bexp = (BSAVE_EXPRESSION *) buf;
ExpressionData(theEnv)->ExpressionArray[obji].type = bexp->type;
switch(bexp->type)
{
case FCALL:
ExpressionData(theEnv)->ExpressionArray[obji].value = BloadData(theEnv)->FunctionArray[bexp->value];
break;
case GCALL:
#if DEFGENERIC_CONSTRUCT
ExpressionData(theEnv)->ExpressionArray[obji].value = GenericPointer(bexp->value);
#else
ExpressionData(theEnv)->ExpressionArray[obji].value = NULL;
#endif
break;
case PCALL:
#if DEFFUNCTION_CONSTRUCT
ExpressionData(theEnv)->ExpressionArray[obji].value = DeffunctionPointer(bexp->value);
#else
ExpressionData(theEnv)->ExpressionArray[obji].value = NULL;
#endif
break;
case DEFTEMPLATE_PTR:
#if DEFTEMPLATE_CONSTRUCT
ExpressionData(theEnv)->ExpressionArray[obji].value = DeftemplatePointer(bexp->value);
#else
ExpressionData(theEnv)->ExpressionArray[obji].value = NULL;
#endif
break;
case DEFCLASS_PTR:
#if OBJECT_SYSTEM
ExpressionData(theEnv)->ExpressionArray[obji].value = DefclassPointer(bexp->value);
#else
ExpressionData(theEnv)->ExpressionArray[obji].value = NULL;
#endif
break;
case DEFGLOBAL_PTR:
#if DEFGLOBAL_CONSTRUCT
ExpressionData(theEnv)->ExpressionArray[obji].value = DefglobalPointer(bexp->value);
#else
ExpressionData(theEnv)->ExpressionArray[obji].value = NULL;
#endif
break;
case INTEGER_TYPE:
ExpressionData(theEnv)->ExpressionArray[obji].value = SymbolData(theEnv)->IntegerArray[bexp->value];
IncrementIntegerCount(ExpressionData(theEnv)->ExpressionArray[obji].integerValue);
break;
case FLOAT_TYPE:
ExpressionData(theEnv)->ExpressionArray[obji].value = SymbolData(theEnv)->FloatArray[bexp->value];
IncrementFloatCount(ExpressionData(theEnv)->ExpressionArray[obji].floatValue);
break;
case INSTANCE_NAME_TYPE:
#if ! OBJECT_SYSTEM
ExpressionData(theEnv)->ExpressionArray[obji].type = SYMBOL_TYPE;
#endif
case GBL_VARIABLE:
case SYMBOL_TYPE:
case STRING_TYPE:
ExpressionData(theEnv)->ExpressionArray[obji].value = SymbolData(theEnv)->SymbolArray[bexp->value];
IncrementLexemeCount(ExpressionData(theEnv)->ExpressionArray[obji].lexemeValue);
break;
#if DEFTEMPLATE_CONSTRUCT
case FACT_ADDRESS_TYPE:
ExpressionData(theEnv)->ExpressionArray[obji].value = &FactData(theEnv)->DummyFact;
RetainFact((Fact *) ExpressionData(theEnv)->ExpressionArray[obji].value);
break;
#endif
#if OBJECT_SYSTEM
case INSTANCE_ADDRESS_TYPE:
ExpressionData(theEnv)->ExpressionArray[obji].value = &InstanceData(theEnv)->DummyInstance;
RetainInstance((Instance *) ExpressionData(theEnv)->ExpressionArray[obji].value);
break;
#endif
case EXTERNAL_ADDRESS_TYPE:
ExpressionData(theEnv)->ExpressionArray[obji].value = NULL;
break;
case VOID_TYPE:
break;
default:
if (EvaluationData(theEnv)->PrimitivesArray[bexp->type] == NULL) break;
if (EvaluationData(theEnv)->PrimitivesArray[bexp->type]->bitMap)
{
ExpressionData(theEnv)->ExpressionArray[obji].value = SymbolData(theEnv)->BitMapArray[bexp->value];
IncrementBitMapCount((CLIPSBitMap *) ExpressionData(theEnv)->ExpressionArray[obji].value);
}
break;
}
theIndex = bexp->nextArg;
if (theIndex == ULONG_MAX)
{ ExpressionData(theEnv)->ExpressionArray[obji].nextArg = NULL; }
else
{ ExpressionData(theEnv)->ExpressionArray[obji].nextArg = (struct expr *) &ExpressionData(theEnv)->ExpressionArray[theIndex]; }
theIndex = bexp->argList;
if (theIndex == ULONG_MAX)
{ ExpressionData(theEnv)->ExpressionArray[obji].argList = NULL; }
else
{ ExpressionData(theEnv)->ExpressionArray[obji].argList = (struct expr *) &ExpressionData(theEnv)->ExpressionArray[theIndex]; }
}
