static void DeallocateDeffactsData(
void *theEnv)
{
#if ! RUN_TIME
struct deffactsModule *theModuleItem;
void *theModule;
#if BLOAD || BLOAD_AND_BSAVE
if (Bloaded(theEnv)) return;
#endif
DoForAllConstructs(theEnv,DestroyDeffactsAction,DeffactsData(theEnv)->DeffactsModuleIndex,FALSE,NULL);
for (theModule = EnvGetNextDefmodule(theEnv,NULL);
theModule != NULL;
theModule = EnvGetNextDefmodule(theEnv,theModule))
{
theModuleItem = (struct deffactsModule *)
GetModuleItem(theEnv,(struct defmodule *) theModule,
DeffactsData(theEnv)->DeffactsModuleIndex);
rtn_struct(theEnv,deffactsModule,theModuleItem);
}
#else
#if MAC_MCW || WIN_MCW || MAC_XCD
#pragma unused(theEnv)
#endif
#endif
}
struct deftemplate *CreateImpliedDeftemplate(
void *theEnv,
SYMBOL_HN *deftemplateName,
bool setFlag)
{
struct deftemplate *newDeftemplate;
newDeftemplate = get_struct(theEnv,deftemplate);
newDeftemplate->header.name = deftemplateName;
newDeftemplate->header.ppForm = NULL;
newDeftemplate->header.usrData = NULL;
newDeftemplate->slotList = NULL;
newDeftemplate->implied = setFlag;
newDeftemplate->numberOfSlots = 0;
newDeftemplate->inScope = 1;
newDeftemplate->patternNetwork = NULL;
newDeftemplate->factList = NULL;
newDeftemplate->lastFact = NULL;
newDeftemplate->busyCount = 0;
newDeftemplate->watch = false;
newDeftemplate->header.next = NULL;
#if DEBUGGING_FUNCTIONS
if (EnvGetWatchItem(theEnv,"facts"))
{ EnvSetDeftemplateWatch(theEnv,ON,(void *) newDeftemplate); }
#endif
newDeftemplate->header.whichModule = (struct defmoduleItemHeader *)
GetModuleItem(theEnv,NULL,DeftemplateData(theEnv)->DeftemplateModuleIndex);
AddConstructToModule(&newDeftemplate->header);
InstallDeftemplate(theEnv,newDeftemplate);
return(newDeftemplate);
}
static void DeallocateDefglobalData(
void *theEnv)
{
#if ! RUN_TIME
struct defglobalModule *theModuleItem;
void *theModule;
#if BLOAD || BLOAD_AND_BSAVE
if (Bloaded(theEnv)) return;
#endif
DoForAllConstructs(theEnv,DestroyDefglobalAction,DefglobalData(theEnv)->DefglobalModuleIndex,FALSE,NULL);
for (theModule = EnvGetNextDefmodule(theEnv,NULL);
theModule != NULL;
theModule = EnvGetNextDefmodule(theEnv,theModule))
{
theModuleItem = (struct defglobalModule *)
GetModuleItem(theEnv,(struct defmodule *) theModule,
DefglobalData(theEnv)->DefglobalModuleIndex);
rtn_struct(theEnv,defglobalModule,theModuleItem);
}
#else
DoForAllConstructs(theEnv,DestroyDefglobalAction,DefglobalData(theEnv)->DefglobalModuleIndex,FALSE,NULL);
#endif
}
static void DeallocateDefruleData(
Environment *theEnv)
{
struct defruleModule *theModuleItem;
Defmodule *theModule;
Activation *theActivation, *tmpActivation;
struct salienceGroup *theGroup, *tmpGroup;
#if BLOAD || BLOAD_AND_BSAVE
if (Bloaded(theEnv))
{ return; }
#endif
DoForAllConstructs(theEnv,DestroyDefruleAction,
DefruleData(theEnv)->DefruleModuleIndex,false,NULL);
for (theModule = GetNextDefmodule(theEnv,NULL);
theModule != NULL;
theModule = GetNextDefmodule(theEnv,theModule))
{
theModuleItem = (struct defruleModule *)
GetModuleItem(theEnv,theModule,
DefruleData(theEnv)->DefruleModuleIndex);
theActivation = theModuleItem->agenda;
while (theActivation != NULL)
{
tmpActivation = theActivation->next;
rtn_struct(theEnv,activation,theActivation);
theActivation = tmpActivation;
}
theGroup = theModuleItem->groupings;
while (theGroup != NULL)
{
tmpGroup = theGroup->next;
rtn_struct(theEnv,salienceGroup,theGroup);
theGroup = tmpGroup;
}
#if ! RUN_TIME
rtn_struct(theEnv,defruleModule,theModuleItem);
#endif
}
rm(theEnv,DefruleData(theEnv)->AlphaMemoryTable,sizeof (ALPHA_MEMORY_HASH *) * ALPHA_MEMORY_HASH_SIZE);
}
globle void *EnvGetNextActivation(
void *theEnv,
void *actPtr)
{
struct defruleModule *theModuleItem;
if (actPtr == NULL)
{
theModuleItem = (struct defruleModule *) GetModuleItem(theEnv,NULL,DefruleData(theEnv)->DefruleModuleIndex);
if (theModuleItem == NULL) return(NULL);
return((void *) theModuleItem->agenda);
}
else
{ return((void *) (((struct activation *) actPtr)->next)); }
}
globle void ConstructModuleToCode(
FILE *theFile,
struct defmodule *theModule,
int imageID,
int maxIndices,
int constructIndex,
char *constructPrefix)
{
struct defmoduleItemHeader *theModuleItem;
/*======================*/
/* Associated Defmodule */
/*======================*/
fprintf(theFile,"{");
theModuleItem = (struct defmoduleItemHeader *)
GetModuleItem(theModule,constructIndex);
PrintDefmoduleReference(theFile,theModule);
fprintf(theFile,",");
/*=============================*/
/* First Construct Module Item */
/*=============================*/
if (theModuleItem->firstItem == NULL) fprintf(theFile,"NULL,");
else fprintf(theFile,"CHS &%s%d_%ld[%ld],",
constructPrefix,
imageID,
(long) (theModuleItem->firstItem->bsaveID / maxIndices) + 1,
(long) theModuleItem->firstItem->bsaveID % maxIndices);
/*============================*/
/* Last Construct Module Item */
/*============================*/
if (theModuleItem->lastItem == NULL) fprintf(theFile,"NULL");
else fprintf(theFile,"CHS &%s%d_%ld[%ld]",
constructPrefix,
imageID,
(long) (theModuleItem->lastItem->bsaveID / maxIndices) + 1,
(long) theModuleItem->lastItem->bsaveID % maxIndices);
fprintf(theFile,"}");
}
void UpdateDefglobalScope(
Environment *theEnv)
{
Defglobal *theDefglobal;
unsigned int moduleCount;
Defmodule *theModule;
struct defmoduleItemHeader *theItem;
/*============================*/
/* Loop through every module. */
/*============================*/
for (theModule = GetNextDefmodule(theEnv,NULL);
theModule != NULL;
theModule = GetNextDefmodule(theEnv,theModule))
{
/*============================================================*/
/* Loop through every defglobal in the module being examined. */
/*============================================================*/
theItem = (struct defmoduleItemHeader *)
GetModuleItem(theEnv,theModule,DefglobalData(theEnv)->DefglobalModuleIndex);
for (theDefglobal = (Defglobal *) theItem->firstItem;
theDefglobal != NULL ;
theDefglobal = GetNextDefglobal(theEnv,theDefglobal))
{
/*====================================================*/
/* If the defglobal is visible to the current module, */
/* then mark it as being in scope, otherwise mark it */
/* as being out of scope. */
/*====================================================*/
if (FindImportedConstruct(theEnv,"defglobal",theModule,
theDefglobal->header.name->contents,
&moduleCount,true,NULL) != NULL)
{ theDefglobal->inScope = true; }
else
{ theDefglobal->inScope = false; }
}
}
}
static void DeallocateDefruleData(
void *theEnv)
{
struct defruleModule *theModuleItem;
void *theModule;
struct activation *theActivation, *tmpActivation;
#if BLOAD || BLOAD_AND_BSAVE
if (Bloaded(theEnv)) return;
#endif
DoForAllConstructs(theEnv,DestroyDefruleAction,DefruleData(theEnv)->DefruleModuleIndex,FALSE,NULL);
for (theModule = EnvGetNextDefmodule(theEnv,NULL);
theModule != NULL;
theModule = EnvGetNextDefmodule(theEnv,theModule))
{
theModuleItem = (struct defruleModule *)
GetModuleItem(theEnv,(struct defmodule *) theModule,
DefruleData(theEnv)->DefruleModuleIndex);
theActivation = theModuleItem->agenda;
while (theActivation != NULL)
{
tmpActivation = theActivation->next;
#if CONFLICT_RESOLUTION_STRATEGIES
if (theActivation->sortedBasis != NULL)
{ DestroyPartialMatch(theEnv,theActivation->sortedBasis); }
#endif
rtn_struct(theEnv,activation,theActivation);
theActivation = tmpActivation;
}
#if ! RUN_TIME
rtn_struct(theEnv,defruleModule,theModuleItem);
#endif
}
}
void UpdateDeftemplateScope(
void *theEnv)
{
struct deftemplate *theDeftemplate;
int moduleCount;
struct defmodule *theModule;
struct defmoduleItemHeader *theItem;
/*==================================*/
/* Loop through all of the modules. */
/*==================================*/
for (theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,NULL);
theModule != NULL;
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,theModule))
{
/*======================================================*/
/* Loop through each of the deftemplates in the module. */
/*======================================================*/
theItem = (struct defmoduleItemHeader *)
GetModuleItem(theEnv,theModule,DeftemplateData(theEnv)->DeftemplateModuleIndex);
for (theDeftemplate = (struct deftemplate *) theItem->firstItem;
theDeftemplate != NULL ;
theDeftemplate = (struct deftemplate *) EnvGetNextDeftemplate(theEnv,theDeftemplate))
{
/*=======================================*/
/* If the deftemplate can be seen by the */
/* current module, then it is in scope. */
/*=======================================*/
if (FindImportedConstruct(theEnv,"deftemplate",theModule,
ValueToString(theDeftemplate->header.name),
&moduleCount,true,NULL) != NULL)
{ theDeftemplate->inScope = true; }
else
{ theDeftemplate->inScope = false; }
}
}
}
/*************************************************************************************
NAME : BsaveDeffunctions
DESCRIPTION : Writes out deffunction in binary format
Space required (unsigned long)
All deffunctions (sizeof(DEFFUNCTION) * Number of deffunctions)
INPUTS : File pointer of binary file
RETURNS : Nothing useful
SIDE EFFECTS : Binary file adjusted
NOTES : None
*************************************************************************************/
static void BsaveDeffunctions(
FILE *fp)
{
unsigned long space;
struct defmodule *theModule;
DEFFUNCTION_MODULE *theModuleItem;
BSAVE_DEFFUNCTION_MODULE dummy_mitem;
space = (unsigned long) ((sizeof(BSAVE_DEFFUNCTION_MODULE) * ModuleCount) +
(sizeof(BSAVE_DEFFUNCTION) * DeffunctionCount));
GenWrite((void *) &space,(unsigned long) sizeof(unsigned long),fp);
/* =================================
Write out each deffunction module
================================= */
DeffunctionCount = 0L;
theModule = (struct defmodule *) GetNextDefmodule(NULL);
while (theModule != NULL)
{
theModuleItem = (DEFFUNCTION_MODULE *)
GetModuleItem(theModule,FindModuleItem("deffunction")->moduleIndex);
AssignBsaveDefmdlItemHdrVals(&dummy_mitem.header,&theModuleItem->header);
GenWrite((void *) &dummy_mitem,(unsigned long) sizeof(BSAVE_DEFFUNCTION_MODULE),fp);
theModule = (struct defmodule *) GetNextDefmodule((void *) theModule);
}
/* ==========================
Write out each deffunction
========================== */
DoForAllConstructs(BsaveDeffunction,DeffunctionModuleIndex,
FALSE,(void *) fp);
if (Bloaded())
{
RestoreBloadCount(&ModuleCount);
RestoreBloadCount(&DeffunctionCount);
}
}
Deftemplate *CreateImpliedDeftemplate(
Environment *theEnv,
CLIPSLexeme *deftemplateName,
bool setFlag)
{
Deftemplate *newDeftemplate;
newDeftemplate = get_struct(theEnv,deftemplate);
newDeftemplate->header.name = deftemplateName;
newDeftemplate->header.ppForm = NULL;
newDeftemplate->header.usrData = NULL;
newDeftemplate->header.constructType = DEFTEMPLATE;
newDeftemplate->header.env = theEnv;
newDeftemplate->slotList = NULL;
newDeftemplate->implied = setFlag;
newDeftemplate->numberOfSlots = 0;
newDeftemplate->inScope = 1;
newDeftemplate->patternNetwork = NULL;
newDeftemplate->factList = NULL;
newDeftemplate->lastFact = NULL;
newDeftemplate->busyCount = 0;
newDeftemplate->watch = false;
newDeftemplate->header.next = NULL;
#if DEBUGGING_FUNCTIONS
if (GetWatchItem(theEnv,"facts") == 1)
{ DeftemplateSetWatch(newDeftemplate,true); }
#endif
newDeftemplate->header.whichModule = (struct defmoduleItemHeader *)
GetModuleItem(theEnv,NULL,DeftemplateData(theEnv)->DeftemplateModuleIndex);
AddConstructToModule(&newDeftemplate->header);
InstallDeftemplate(theEnv,newDeftemplate);
return(newDeftemplate);
}
globle struct deftemplate *CreateImpliedDeftemplate(
SYMBOL_HN *deftemplateName,
int setFlag)
{
struct deftemplate *newDeftemplate;
newDeftemplate = get_struct(deftemplate);
newDeftemplate->header.name = deftemplateName;
newDeftemplate->header.ppForm = NULL;
newDeftemplate->header.usrData = NULL;
newDeftemplate->slotList = NULL;
newDeftemplate->implied = setFlag;
newDeftemplate->numberOfSlots = 0;
newDeftemplate->inScope = 1;
newDeftemplate->patternNetwork = NULL;
newDeftemplate->busyCount = 0;
newDeftemplate->watch = FALSE;
newDeftemplate->header.next = NULL;
#if FUZZY_DEFTEMPLATES
newDeftemplate->hasFuzzySlots = FALSE;
newDeftemplate->fuzzyTemplate = NULL;
#endif
#if DEBUGGING_FUNCTIONS
if (GetWatchItem("facts"))
{ SetDeftemplateWatch(ON,(void *) newDeftemplate); }
#endif
newDeftemplate->header.whichModule = (struct defmoduleItemHeader *)
GetModuleItem(NULL,DeftemplateModuleIndex);
AddConstructToModule(&newDeftemplate->header);
InstallDeftemplate(newDeftemplate);
return(newDeftemplate);
}
/*************************************************************************************
NAME : BsaveDeffunctions
DESCRIPTION : Writes out deffunction in binary format
Space required (unsigned long)
All deffunctions (sizeof(DEFFUNCTION) * Number of deffunctions)
INPUTS : File pointer of binary file
RETURNS : Nothing useful
SIDE EFFECTS : Binary file adjusted
NOTES : None
*************************************************************************************/
static void BsaveDeffunctions(
void *theEnv,
FILE *fp)
{
size_t space;
struct defmodule *theModule;
DEFFUNCTION_MODULE *theModuleItem;
BSAVE_DEFFUNCTION_MODULE dummy_mitem;
space = ((sizeof(BSAVE_DEFFUNCTION_MODULE) * DeffunctionBinaryData(theEnv)->ModuleCount) +
(sizeof(BSAVE_DEFFUNCTION) * DeffunctionBinaryData(theEnv)->DeffunctionCount));
GenWrite((void *) &space,sizeof(size_t),fp);
/* =================================
Write out each deffunction module
================================= */
DeffunctionBinaryData(theEnv)->DeffunctionCount = 0L;
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,NULL);
while (theModule != NULL)
{
theModuleItem = (DEFFUNCTION_MODULE *)
GetModuleItem(theEnv,theModule,FindModuleItem(theEnv,"deffunction")->moduleIndex);
AssignBsaveDefmdlItemHdrVals(&dummy_mitem.header,&theModuleItem->header);
GenWrite((void *) &dummy_mitem,sizeof(BSAVE_DEFFUNCTION_MODULE),fp);
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,(void *) theModule);
}
/* ==========================
Write out each deffunction
========================== */
DoForAllConstructs(theEnv,BsaveDeffunction,DeffunctionData(theEnv)->DeffunctionModuleIndex,
FALSE,(void *) fp);
RestoreBloadCount(theEnv,&DeffunctionBinaryData(theEnv)->ModuleCount);
RestoreBloadCount(theEnv,&DeffunctionBinaryData(theEnv)->DeffunctionCount);
}
/*************************************************************************************
NAME : BsaveDefinstancesDriver
DESCRIPTION : Writes out definstances in binary format
Space required (unsigned long)
All definstances (sizeof(DEFINSTANCES) * Number of definstances)
INPUTS : File pointer of binary file
RETURNS : Nothing useful
SIDE EFFECTS : Binary file adjusted
NOTES : None
*************************************************************************************/
static void BsaveDefinstancesDriver(
void *theEnv,
FILE *fp)
{
unsigned long space;
struct defmodule *theModule;
DEFINSTANCES_MODULE *theModuleItem;
BSAVE_DEFINSTANCES_MODULE dummy_mitem;
space = (unsigned long) ((sizeof(BSAVE_DEFINSTANCES_MODULE) * DefinstancesBinaryData(theEnv)->ModuleCount) +
(sizeof(BSAVE_DEFINSTANCES) * DefinstancesBinaryData(theEnv)->DefinstancesCount));
GenWrite((void *) &space,(unsigned long) sizeof(unsigned long),fp);
/* =================================
Write out each definstances module
================================= */
DefinstancesBinaryData(theEnv)->DefinstancesCount = 0L;
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,NULL);
while (theModule != NULL)
{
theModuleItem = (DEFINSTANCES_MODULE *)
GetModuleItem(theEnv,theModule,FindModuleItem(theEnv,"definstances")->moduleIndex);
AssignBsaveDefmdlItemHdrVals(&dummy_mitem.header,&theModuleItem->header);
GenWrite((void *) &dummy_mitem,(unsigned long) sizeof(BSAVE_DEFINSTANCES_MODULE),fp);
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,(void *) theModule);
}
/* ==========================
Write out each definstances
========================== */
DoForAllConstructs(theEnv,BsaveDefinstances,DefinstancesData(theEnv)->DefinstancesModuleIndex,
FALSE,(void *) fp);
RestoreBloadCount(theEnv,&DefinstancesBinaryData(theEnv)->ModuleCount);
RestoreBloadCount(theEnv,&DefinstancesBinaryData(theEnv)->DefinstancesCount);
}
Defglobal *GetNextDefglobalInScope(
Environment *theEnv,
Defglobal *theGlobal)
{
struct defmoduleItemHeader *theItem;
/*=======================================*/
/* If we're beginning the search for the */
/* first defglobal in scope, then ... */
/*=======================================*/
if (theGlobal == NULL)
{
/*==============================================*/
/* If the current module has been changed since */
/* the last time the scopes were computed, then */
/* recompute the scopes. */
/*==============================================*/
if (DefglobalData(theEnv)->LastModuleIndex != DefmoduleData(theEnv)->ModuleChangeIndex)
{
UpdateDefglobalScope(theEnv);
DefglobalData(theEnv)->LastModuleIndex = DefmoduleData(theEnv)->ModuleChangeIndex;
}
/*==========================================*/
/* Get the first module and first defglobal */
/* to start the search with. */
/*==========================================*/
DefglobalData(theEnv)->TheDefmodule = GetNextDefmodule(theEnv,NULL);
theItem = (struct defmoduleItemHeader *)
GetModuleItem(theEnv,DefglobalData(theEnv)->TheDefmodule,DefglobalData(theEnv)->DefglobalModuleIndex);
theGlobal = (Defglobal *) theItem->firstItem;
}
/*==================================================*/
/* Otherwise, see if the last defglobal returned by */
/* this function has a defglobal following it. */
/*==================================================*/
else
{ theGlobal = GetNextDefglobal(theEnv,theGlobal); }
/*======================================*/
/* Continue looping through the modules */
/* until a defglobal in scope is found. */
/*======================================*/
while (DefglobalData(theEnv)->TheDefmodule != NULL)
{
/*=====================================================*/
/* Loop through the defglobals in the module currently */
/* being examined to see if one is in scope. */
/*=====================================================*/
for (;
theGlobal != NULL;
theGlobal = GetNextDefglobal(theEnv,theGlobal))
{ if (theGlobal->inScope) return theGlobal; }
/*================================================*/
/* If a global in scope couldn't be found in this */
/* module, then move on to the next module. */
/*================================================*/
DefglobalData(theEnv)->TheDefmodule = GetNextDefmodule(theEnv,DefglobalData(theEnv)->TheDefmodule);
theItem = (struct defmoduleItemHeader *)
GetModuleItem(theEnv,DefglobalData(theEnv)->TheDefmodule,DefglobalData(theEnv)->DefglobalModuleIndex);
theGlobal = (Defglobal *) theItem->firstItem;
}
/*====================================*/
/* All the globals in scope have been */
/* traversed and there are none left. */
/*====================================*/
return NULL;
}
static void BsaveBinaryItem(
void *theEnv,
EXEC_STATUS,
FILE *fp)
{
size_t space;
struct defglobal *theDefglobal;
struct bsaveDefglobal newDefglobal;
struct defmodule *theModule;
struct bsaveDefglobalModule tempDefglobalModule;
struct defglobalModule *theModuleItem;
/*==========================================================*/
/* Write out the amount of space taken up by the defglobal */
/* and defglobalModule data structures in the binary image. */
/*==========================================================*/
space = DefglobalBinaryData(theEnv,execStatus)->NumberOfDefglobals * sizeof(struct bsaveDefglobal) +
(DefglobalBinaryData(theEnv,execStatus)->NumberOfDefglobalModules * sizeof(struct bsaveDefglobalModule));
GenWrite(&space,sizeof(size_t),fp);
/*=================================================*/
/* Write out each defglobal module data structure. */
/*=================================================*/
DefglobalBinaryData(theEnv,execStatus)->NumberOfDefglobals = 0;
for (theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,execStatus,NULL);
theModule != NULL;
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,execStatus,theModule))
{
EnvSetCurrentModule(theEnv,execStatus,(void *) theModule);
theModuleItem = (struct defglobalModule *)
GetModuleItem(theEnv,execStatus,NULL,FindModuleItem(theEnv,execStatus,"defglobal")->moduleIndex);
AssignBsaveDefmdlItemHdrVals(&tempDefglobalModule.header,
&theModuleItem->header);
GenWrite(&tempDefglobalModule,sizeof(struct bsaveDefglobalModule),fp);
}
/*===========================*/
/* Write out each defglobal. */
/*===========================*/
DefglobalBinaryData(theEnv,execStatus)->NumberOfDefglobals = 0;
for (theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,execStatus,NULL);
theModule != NULL;
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,execStatus,theModule))
{
EnvSetCurrentModule(theEnv,execStatus,(void *) theModule);
for (theDefglobal = (struct defglobal *) EnvGetNextDefglobal(theEnv,execStatus,NULL);
theDefglobal != NULL;
theDefglobal = (struct defglobal *) EnvGetNextDefglobal(theEnv,execStatus,theDefglobal))
{
AssignBsaveConstructHeaderVals(&newDefglobal.header,
&theDefglobal->header);
newDefglobal.initial = HashedExpressionIndex(theEnv,execStatus,theDefglobal->initial);
GenWrite(&newDefglobal,sizeof(struct bsaveDefglobal),fp);
}
}
/*=============================================================*/
/* If a binary image was already loaded when the bsave command */
/* was issued, then restore the counts indicating the number */
/* of defglobals and defglobal modules in the binary image */
/* (these were overwritten by the binary save). */
/*=============================================================*/
RestoreBloadCount(theEnv,execStatus,&DefglobalBinaryData(theEnv,execStatus)->NumberOfDefglobalModules);
RestoreBloadCount(theEnv,execStatus,&DefglobalBinaryData(theEnv,execStatus)->NumberOfDefglobals);
}
static void BsaveBinaryItem(
FILE *fp)
{
unsigned long int space;
struct defglobal *theDefglobal;
struct bsaveDefglobal newDefglobal;
struct defmodule *theModule;
struct bsaveDefglobalModule tempDefglobalModule;
struct defglobalModule *theModuleItem;
/*==========================================================*/
/* Write out the amount of space taken up by the defglobal */
/* and defglobalModule data structures in the binary image. */
/*==========================================================*/
space = NumberOfDefglobals * sizeof(struct bsaveDefglobal) +
(NumberOfDefglobalModules * sizeof(struct bsaveDefglobalModule));
GenWrite(&space,(unsigned long) sizeof(unsigned long int),fp);
/*=================================================*/
/* Write out each defglobal module data structure. */
/*=================================================*/
NumberOfDefglobals = 0;
for (theModule = (struct defmodule *) GetNextDefmodule(NULL);
theModule != NULL;
theModule = (struct defmodule *) GetNextDefmodule(theModule))
{
SetCurrentModule((void *) theModule);
theModuleItem = (struct defglobalModule *)
GetModuleItem(NULL,FindModuleItem("defglobal")->moduleIndex);
AssignBsaveDefmdlItemHdrVals(&tempDefglobalModule.header,
&theModuleItem->header);
GenWrite(&tempDefglobalModule,(unsigned long) sizeof(struct bsaveDefglobalModule),fp);
}
/*===========================*/
/* Write out each defglobal. */
/*===========================*/
NumberOfDefglobals = 0;
for (theModule = (struct defmodule *) GetNextDefmodule(NULL);
theModule != NULL;
theModule = (struct defmodule *) GetNextDefmodule(theModule))
{
SetCurrentModule((void *) theModule);
for (theDefglobal = (struct defglobal *) GetNextDefglobal(NULL);
theDefglobal != NULL;
theDefglobal = (struct defglobal *) GetNextDefglobal(theDefglobal))
{
AssignBsaveConstructHeaderVals(&newDefglobal.header,
&theDefglobal->header);
newDefglobal.initial = HashedExpressionIndex(theDefglobal->initial);
GenWrite(&newDefglobal,(unsigned long) sizeof(struct bsaveDefglobal),fp);
}
}
/*=============================================================*/
/* If a binary image was already loaded when the bsave command */
/* was issued, then restore the counts indicating the number */
/* of defglobals and defglobal modules in the binary image */
/* (these were overwritten by the binary save). */
/*=============================================================*/
if (Bloaded())
{
RestoreBloadCount(&NumberOfDefglobalModules);
RestoreBloadCount(&NumberOfDefglobals);
}
}
globle int ParseDefrule(
void *theEnv,
const char *readSource)
{
#if (! RUN_TIME) && (! BLOAD_ONLY)
SYMBOL_HN *ruleName;
struct lhsParseNode *theLHS;
struct expr *actions;
struct token theToken;
struct defrule *topDisjunct, *tempPtr;
struct defruleModule *theModuleItem;
int error;
/*================================================*/
/* Flush the buffer which stores the pretty print */
/* representation for a rule. Add the already */
/* parsed keyword defrule to this buffer. */
/*================================================*/
SetPPBufferStatus(theEnv,ON);
FlushPPBuffer(theEnv);
SavePPBuffer(theEnv,"(defrule ");
/*=========================================================*/
/* Rules cannot be loaded when a binary load is in effect. */
/*=========================================================*/
#if BLOAD || BLOAD_ONLY || BLOAD_AND_BSAVE
if ((Bloaded(theEnv) == TRUE) && (! ConstructData(theEnv)->CheckSyntaxMode))
{
CannotLoadWithBloadMessage(theEnv,"defrule");
return(TRUE);
}
#endif
/*================================================*/
/* Parse the name and comment fields of the rule, */
/* deleting the rule if it already exists. */
/*================================================*/
#if DEBUGGING_FUNCTIONS
DefruleData(theEnv)->DeletedRuleDebugFlags = 0;
#endif
ruleName = GetConstructNameAndComment(theEnv,readSource,&theToken,"defrule",
EnvFindDefruleInModule,EnvUndefrule,"*",FALSE,
TRUE,TRUE,FALSE);
if (ruleName == NULL) return(TRUE);
/*============================*/
/* Parse the LHS of the rule. */
/*============================*/
theLHS = ParseRuleLHS(theEnv,readSource,&theToken,ValueToString(ruleName),&error);
if (error)
{
ReturnPackedExpression(theEnv,PatternData(theEnv)->SalienceExpression);
PatternData(theEnv)->SalienceExpression = NULL;
return(TRUE);
}
/*============================*/
/* Parse the RHS of the rule. */
/*============================*/
ClearParsedBindNames(theEnv);
ExpressionData(theEnv)->ReturnContext = TRUE;
actions = ParseRuleRHS(theEnv,readSource);
if (actions == NULL)
{
ReturnPackedExpression(theEnv,PatternData(theEnv)->SalienceExpression);
PatternData(theEnv)->SalienceExpression = NULL;
ReturnLHSParseNodes(theEnv,theLHS);
return(TRUE);
}
/*=======================*/
/* Process the rule LHS. */
/*=======================*/
topDisjunct = ProcessRuleLHS(theEnv,theLHS,actions,ruleName,&error);
ReturnExpression(theEnv,actions);
ClearParsedBindNames(theEnv);
ReturnLHSParseNodes(theEnv,theLHS);
if (error)
{
ReturnPackedExpression(theEnv,PatternData(theEnv)->SalienceExpression);
PatternData(theEnv)->SalienceExpression = NULL;
return(TRUE);
}
/*==============================================*/
/* If we're only checking syntax, don't add the */
/* successfully parsed defrule to the KB. */
/*==============================================*/
if (ConstructData(theEnv)->CheckSyntaxMode)
{
ReturnPackedExpression(theEnv,PatternData(theEnv)->SalienceExpression);
PatternData(theEnv)->SalienceExpression = NULL;
return(FALSE);
}
PatternData(theEnv)->SalienceExpression = NULL;
/*======================================*/
/* Save the nice printout of the rules. */
/*======================================*/
SavePPBuffer(theEnv,"\n");
if (EnvGetConserveMemory(theEnv) == TRUE)
{ topDisjunct->header.ppForm = NULL; }
else
{ topDisjunct->header.ppForm = CopyPPBuffer(theEnv); }
/*=======================================*/
/* Store a pointer to the rule's module. */
/*=======================================*/
theModuleItem = (struct defruleModule *)
GetModuleItem(theEnv,NULL,FindModuleItem(theEnv,"defrule")->moduleIndex);
for (tempPtr = topDisjunct; tempPtr != NULL; tempPtr = tempPtr->disjunct)
{
tempPtr->header.whichModule = (struct defmoduleItemHeader *) theModuleItem;
tempPtr->header.ppForm = topDisjunct->header.ppForm;
}
/*===============================================*/
/* Rule completely parsed. Add to list of rules. */
/*===============================================*/
AddToDefruleList(topDisjunct);
/*========================================================================*/
/* If a rule is redefined, then we want to restore its breakpoint status. */
/*========================================================================*/
#if DEBUGGING_FUNCTIONS
if (BitwiseTest(DefruleData(theEnv)->DeletedRuleDebugFlags,0))
{ EnvSetBreak(theEnv,topDisjunct); }
if (BitwiseTest(DefruleData(theEnv)->DeletedRuleDebugFlags,1) || EnvGetWatchItem(theEnv,"activations"))
{ EnvSetDefruleWatchActivations(theEnv,ON,(void *) topDisjunct); }
if (BitwiseTest(DefruleData(theEnv)->DeletedRuleDebugFlags,2) || EnvGetWatchItem(theEnv,"rules"))
{ EnvSetDefruleWatchFirings(theEnv,ON,(void *) topDisjunct); }
#endif
/*================================*/
/* Perform the incremental reset. */
/*================================*/
IncrementalReset(theEnv,topDisjunct);
/*=============================================*/
/* Return FALSE to indicate no errors occured. */
/*=============================================*/
#endif
return(FALSE);
}
/****************************************************************************************
NAME : BsaveGenerics
DESCRIPTION : Writes out generic function in binary format
Space required (unsigned long)
All generic modules (sizeof(DEFGENERIC_MODULE) * Number of generic modules)
All generic headers (sizeof(DEFGENERIC) * Number of generics)
All methods (sizeof(DEFMETHOD) * Number of methods)
All method restrictions (sizeof(RESTRICTION) * Number of restrictions)
All restriction type arrays (sizeof(void *) * # of types)
INPUTS : File pointer of binary file
RETURNS : Nothing useful
SIDE EFFECTS : Binary file adjusted
NOTES : None
****************************************************************************************/
static void BsaveGenerics(
FILE *fp)
{
struct defmodule *theModule;
DEFGENERIC_MODULE *theModuleItem;
unsigned long space;
BSAVE_DEFGENERIC_MODULE dummy_generic_module;
/* =====================================================================
Space is: Sum over all structures(sizeof(structure) * structure-cnt))
===================================================================== */
space = ((unsigned long) ModuleCount * (unsigned long) sizeof(BSAVE_DEFGENERIC_MODULE)) +
((unsigned long) GenericCount * (unsigned long) sizeof(BSAVE_GENERIC)) +
((unsigned long) MethodCount * (unsigned long) sizeof(BSAVE_METHOD)) +
((unsigned long) RestrictionCount * (unsigned long) sizeof(BSAVE_RESTRICTION)) +
((unsigned long) TypeCount * (unsigned long) sizeof(unsigned long));
/* ================================================================
Write out the total amount of space required: modules,headers,
methods, restrictions, types
================================================================ */
GenWrite((void *) &space,(unsigned long) sizeof(unsigned long),fp);
/* ======================================
Write out the generic function modules
====================================== */
GenericCount = 0L;
theModule = (struct defmodule *) GetNextDefmodule(NULL);
while (theModule != NULL)
{
theModuleItem = (DEFGENERIC_MODULE *)
GetModuleItem(theModule,FindModuleItem("defgeneric")->moduleIndex);
AssignBsaveDefmdlItemHdrVals(&dummy_generic_module.header,
&theModuleItem->header);
GenWrite((void *) &dummy_generic_module,
(unsigned long) sizeof(BSAVE_DEFGENERIC_MODULE),fp);
theModule = (struct defmodule *) GetNextDefmodule((void *) theModule);
}
/* ======================================
Write out the generic function headers
====================================== */
MethodCount = 0L;
DoForAllConstructs(BsaveDefgenericHeader,DefgenericModuleIndex,
FALSE,(void *) fp);
/* =====================
Write out the methods
===================== */
RestrictionCount = 0L;
DoForAllConstructs(BsaveMethods,DefgenericModuleIndex,
FALSE,(void *) fp);
/* =================================
Write out the method restrictions
================================= */
TypeCount = 0L;
DoForAllConstructs(BsaveMethodRestrictions,DefgenericModuleIndex,
FALSE,(void *) fp);
/* =============================================================
Finally, write out the type lists for the method restrictions
============================================================= */
DoForAllConstructs(BsaveRestrictionTypes,DefgenericModuleIndex,
FALSE,(void *) fp);
if (Bloaded())
{
RestoreBloadCount(&ModuleCount);
RestoreBloadCount(&GenericCount);
RestoreBloadCount(&MethodCount);
RestoreBloadCount(&RestrictionCount);
RestoreBloadCount(&TypeCount);
}
}
static void AddDefglobal(
void *theEnv,
SYMBOL_HN *name,
DATA_OBJECT_PTR vPtr,
struct expr *ePtr)
{
struct defglobal *defglobalPtr;
intBool newGlobal = FALSE;
#if DEBUGGING_FUNCTIONS
int GlobalHadWatch = FALSE;
#endif
/*========================================================*/
/* If the defglobal is already defined, then use the old */
/* data structure and substitute new values. If it hasn't */
/* been defined, then create a new data structure. */
/*========================================================*/
defglobalPtr = QFindDefglobal(theEnv,name);
if (defglobalPtr == NULL)
{
newGlobal = TRUE;
defglobalPtr = get_struct(theEnv,defglobal);
}
else
{
DeinstallConstructHeader(theEnv,&defglobalPtr->header);
#if DEBUGGING_FUNCTIONS
GlobalHadWatch = defglobalPtr->watch;
#endif
}
/*===========================================*/
/* Remove the old values from the defglobal. */
/*===========================================*/
if (newGlobal == FALSE)
{
ValueDeinstall(theEnv,&defglobalPtr->current);
if (defglobalPtr->current.type == MULTIFIELD)
{ ReturnMultifield(theEnv,(struct multifield *) defglobalPtr->current.value); }
RemoveHashedExpression(theEnv,defglobalPtr->initial);
}
/*=======================================*/
/* Copy the new values to the defglobal. */
/*=======================================*/
defglobalPtr->current.type = vPtr->type;
if (vPtr->type != MULTIFIELD) defglobalPtr->current.value = vPtr->value;
else DuplicateMultifield(theEnv,&defglobalPtr->current,vPtr);
ValueInstall(theEnv,&defglobalPtr->current);
defglobalPtr->initial = AddHashedExpression(theEnv,ePtr);
ReturnExpression(theEnv,ePtr);
DefglobalData(theEnv)->ChangeToGlobals = TRUE;
/*=================================*/
/* Restore the old watch value to */
/* the defglobal if redefined. */
/*=================================*/
#if DEBUGGING_FUNCTIONS
defglobalPtr->watch = GlobalHadWatch ? TRUE : WatchGlobals;
#endif
/*======================================*/
/* Save the name and pretty print form. */
/*======================================*/
defglobalPtr->header.name = name;
defglobalPtr->header.usrData = NULL;
IncrementSymbolCount(name);
SavePPBuffer(theEnv,"\n");
if (EnvGetConserveMemory(theEnv) == TRUE)
{ defglobalPtr->header.ppForm = NULL; }
else
{ defglobalPtr->header.ppForm = CopyPPBuffer(theEnv); }
defglobalPtr->inScope = TRUE;
/*=============================================*/
/* If the defglobal was redefined, we're done. */
/*=============================================*/
if (newGlobal == FALSE) return;
/*===================================*/
/* Copy the defglobal variable name. */
/*===================================*/
defglobalPtr->busyCount = 0;
defglobalPtr->header.whichModule = (struct defmoduleItemHeader *)
GetModuleItem(theEnv,NULL,FindModuleItem(theEnv,"defglobal")->moduleIndex);
/*=============================================*/
/* Add the defglobal to the list of defglobals */
/* for the current module. */
/*=============================================*/
AddConstructToModule(&defglobalPtr->header);
}
globle int ParseDeftemplate(
void *theEnv,
char *readSource)
{
#if (MAC_MCW || IBM_MCW) && (RUN_TIME || BLOAD_ONLY)
#pragma unused(readSource)
#endif
#if (! RUN_TIME) && (! BLOAD_ONLY)
SYMBOL_HN *deftemplateName;
struct deftemplate *newDeftemplate;
struct templateSlot *slots;
struct token inputToken;
/*================================================*/
/* Initialize pretty print and error information. */
/*================================================*/
DeftemplateData(theEnv)->DeftemplateError = FALSE;
SetPPBufferStatus(theEnv,ON);
FlushPPBuffer(theEnv);
SavePPBuffer(theEnv,"(deftemplate ");
/*==============================================================*/
/* Deftemplates can not be added when a binary image is loaded. */
/*==============================================================*/
#if BLOAD || BLOAD_AND_BSAVE
if ((Bloaded(theEnv) == TRUE) && (! ConstructData(theEnv)->CheckSyntaxMode))
{
CannotLoadWithBloadMessage(theEnv,"deftemplate");
return(TRUE);
}
#endif
/*=======================================================*/
/* Parse the name and comment fields of the deftemplate. */
/*=======================================================*/
#if DEBUGGING_FUNCTIONS
DeftemplateData(theEnv)->DeletedTemplateDebugFlags = 0;
#endif
deftemplateName = GetConstructNameAndComment(theEnv,readSource,&inputToken,"deftemplate",
EnvFindDeftemplate,EnvUndeftemplate,"%",
TRUE,TRUE,DEFMODULE_CONSTRUCT);
if (deftemplateName == NULL) return(TRUE);
if (ReservedPatternSymbol(theEnv,ValueToString(deftemplateName),"deftemplate"))
{
ReservedPatternSymbolErrorMsg(theEnv,ValueToString(deftemplateName),"a deftemplate name");
return(TRUE);
}
/*===========================================*/
/* Parse the slot fields of the deftemplate. */
/*===========================================*/
slots = SlotDeclarations(theEnv,readSource,&inputToken);
if (DeftemplateData(theEnv)->DeftemplateError == TRUE) return(TRUE);
/*==============================================*/
/* If we're only checking syntax, don't add the */
/* successfully parsed deftemplate to the KB. */
/*==============================================*/
if (ConstructData(theEnv)->CheckSyntaxMode)
{
ReturnSlots(theEnv,slots);
return(FALSE);
}
/*=====================================*/
/* Create a new deftemplate structure. */
/*=====================================*/
newDeftemplate = get_struct(theEnv,deftemplate);
newDeftemplate->header.name = deftemplateName;
newDeftemplate->header.next = NULL;
newDeftemplate->header.usrData = NULL;
newDeftemplate->slotList = slots;
newDeftemplate->implied = FALSE;
newDeftemplate->numberOfSlots = 0;
newDeftemplate->busyCount = 0;
newDeftemplate->watch = 0;
newDeftemplate->inScope = TRUE;
newDeftemplate->patternNetwork = NULL;
newDeftemplate->factList = NULL;
newDeftemplate->lastFact = NULL;
newDeftemplate->header.whichModule = (struct defmoduleItemHeader *)
GetModuleItem(theEnv,NULL,DeftemplateData(theEnv)->DeftemplateModuleIndex);
/*================================*/
/* Determine the number of slots. */
/*================================*/
while (slots != NULL)
{
newDeftemplate->numberOfSlots++;
slots = slots->next;
}
/*====================================*/
/* Store pretty print representation. */
/*====================================*/
if (EnvGetConserveMemory(theEnv) == TRUE)
{ newDeftemplate->header.ppForm = NULL; }
else
{ newDeftemplate->header.ppForm = CopyPPBuffer(theEnv); }
/*=======================================================================*/
/* If a template is redefined, then we want to restore its watch status. */
/*=======================================================================*/
#if DEBUGGING_FUNCTIONS
if ((BitwiseTest(DeftemplateData(theEnv)->DeletedTemplateDebugFlags,0)) || EnvGetWatchItem(theEnv,"facts"))
{ EnvSetDeftemplateWatch(theEnv,ON,(void *) newDeftemplate); }
#endif
/*==============================================*/
/* Add deftemplate to the list of deftemplates. */
/*==============================================*/
AddConstructToModule(&newDeftemplate->header);
InstallDeftemplate(theEnv,newDeftemplate);
#else
#if MAC_MCW || IBM_MCW || MAC_XCD
#pragma unused(theEnv)
#endif
#endif
return(FALSE);
}
globle int ParseDeffacts(
char *readSource)
{
#if (MAC_MPW || MAC_MCW) && (RUN_TIME || BLOAD_ONLY)
#pragma unused(readSource)
#endif
#if (! RUN_TIME) && (! BLOAD_ONLY)
SYMBOL_HN *deffactsName;
struct expr *temp;
struct deffacts *newDeffacts;
int deffactsError;
struct token inputToken;
/*=========================*/
/* Parsing initialization. */
/*=========================*/
deffactsError = FALSE;
SetPPBufferStatus(ON);
FlushPPBuffer();
SetIndentDepth(3);
SavePPBuffer("(deffacts ");
/*==========================================================*/
/* Deffacts can not be added when a binary image is loaded. */
/*==========================================================*/
#if BLOAD || BLOAD_AND_BSAVE
if ((Bloaded() == TRUE) && (! CheckSyntaxMode))
{
CannotLoadWithBloadMessage("deffacts");
return(TRUE);
}
#endif
/*============================*/
/* Parse the deffacts header. */
/*============================*/
deffactsName = GetConstructNameAndComment(readSource,&inputToken,"deffacts",
FindDeffacts,Undeffacts,"$",TRUE,
TRUE,TRUE);
if (deffactsName == NULL) { return(TRUE); }
/*===============================================*/
/* Parse the list of facts in the deffacts body. */
/*===============================================*/
temp = BuildRHSAssert(readSource,&inputToken,&deffactsError,FALSE,FALSE,"deffacts");
if (deffactsError == TRUE) { return(TRUE); }
if (ExpressionContainsVariables(temp,FALSE))
{
LocalVariableErrorMessage("a deffacts construct");
ReturnExpression(temp);
return(TRUE);
}
SavePPBuffer("\n");
/*==============================================*/
/* If we're only checking syntax, don't add the */
/* successfully parsed deffacts to the KB. */
/*==============================================*/
if (CheckSyntaxMode)
{
ReturnExpression(temp);
return(FALSE);
}
/*==========================*/
/* Create the new deffacts. */
/*==========================*/
ExpressionInstall(temp);
newDeffacts = get_struct(deffacts);
newDeffacts->header.name = deffactsName;
IncrementSymbolCount(deffactsName);
newDeffacts->assertList = PackExpression(temp);
newDeffacts->header.whichModule = (struct defmoduleItemHeader *)
GetModuleItem(NULL,FindModuleItem("deffacts")->moduleIndex);
newDeffacts->header.next = NULL;
newDeffacts->header.usrData = NULL;
ReturnExpression(temp);
/*=======================================================*/
/* Save the pretty print representation of the deffacts. */
/*=======================================================*/
if (GetConserveMemory() == TRUE)
{ newDeffacts->header.ppForm = NULL; }
else
{ newDeffacts->header.ppForm = CopyPPBuffer(); }
/*=============================================*/
/* Add the deffacts to the appropriate module. */
/*=============================================*/
AddConstructToModule(&newDeffacts->header);
#endif /* (! RUN_TIME) && (! BLOAD_ONLY) */
/*================================================================*/
/* Return FALSE to indicate the deffacts was successfully parsed. */
/*================================================================*/
return(FALSE);
}
/****************************************************************************************
NAME : BsaveGenerics
DESCRIPTION : Writes out generic function in binary format
Space required (unsigned long)
All generic modules (sizeof(DEFGENERIC_MODULE) * Number of generic modules)
All generic headers (sizeof(DEFGENERIC) * Number of generics)
All methods (sizeof(DEFMETHOD) * Number of methods)
All method restrictions (sizeof(RESTRICTION) * Number of restrictions)
All restriction type arrays (sizeof(void *) * # of types)
INPUTS : File pointer of binary file
RETURNS : Nothing useful
SIDE EFFECTS : Binary file adjusted
NOTES : None
****************************************************************************************/
static void BsaveGenerics(
void *theEnv,
FILE *fp)
{
struct defmodule *theModule;
DEFGENERIC_MODULE *theModuleItem;
size_t space;
BSAVE_DEFGENERIC_MODULE dummy_generic_module;
/* =====================================================================
Space is: Sum over all structures(sizeof(structure) * structure-cnt))
===================================================================== */
space = ((unsigned long) DefgenericBinaryData(theEnv)->ModuleCount * sizeof(BSAVE_DEFGENERIC_MODULE)) +
((unsigned long) DefgenericBinaryData(theEnv)->GenericCount * sizeof(BSAVE_GENERIC)) +
((unsigned long) DefgenericBinaryData(theEnv)->MethodCount * sizeof(BSAVE_METHOD)) +
((unsigned long) DefgenericBinaryData(theEnv)->RestrictionCount * sizeof(BSAVE_RESTRICTION)) +
((unsigned long) DefgenericBinaryData(theEnv)->TypeCount * sizeof(unsigned long));
/* ================================================================
Write out the total amount of space required: modules,headers,
methods, restrictions, types
================================================================ */
GenWrite((void *) &space,sizeof(size_t),fp);
/* ======================================
Write out the generic function modules
====================================== */
DefgenericBinaryData(theEnv)->GenericCount = 0L;
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,NULL);
while (theModule != NULL)
{
theModuleItem = (DEFGENERIC_MODULE *)
GetModuleItem(theEnv,theModule,FindModuleItem(theEnv,"defgeneric")->moduleIndex);
AssignBsaveDefmdlItemHdrVals(&dummy_generic_module.header,
&theModuleItem->header);
GenWrite((void *) &dummy_generic_module,
sizeof(BSAVE_DEFGENERIC_MODULE),fp);
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,(void *) theModule);
}
/* ======================================
Write out the generic function headers
====================================== */
DefgenericBinaryData(theEnv)->MethodCount = 0L;
DoForAllConstructs(theEnv,BsaveDefgenericHeader,DefgenericData(theEnv)->DefgenericModuleIndex,
false,(void *) fp);
/* =====================
Write out the methods
===================== */
DefgenericBinaryData(theEnv)->RestrictionCount = 0L;
DoForAllConstructs(theEnv,BsaveMethods,DefgenericData(theEnv)->DefgenericModuleIndex,
false,(void *) fp);
/* =================================
Write out the method restrictions
================================= */
DefgenericBinaryData(theEnv)->TypeCount = 0L;
DoForAllConstructs(theEnv,BsaveMethodRestrictions,DefgenericData(theEnv)->DefgenericModuleIndex,
false,(void *) fp);
/* =============================================================
Finally, write out the type lists for the method restrictions
============================================================= */
DoForAllConstructs(theEnv,BsaveRestrictionTypes,DefgenericData(theEnv)->DefgenericModuleIndex,
false,(void *) fp);
RestoreBloadCount(theEnv,&DefgenericBinaryData(theEnv)->ModuleCount);
RestoreBloadCount(theEnv,&DefgenericBinaryData(theEnv)->GenericCount);
RestoreBloadCount(theEnv,&DefgenericBinaryData(theEnv)->MethodCount);
RestoreBloadCount(theEnv,&DefgenericBinaryData(theEnv)->RestrictionCount);
RestoreBloadCount(theEnv,&DefgenericBinaryData(theEnv)->TypeCount);
}
static void DeallocateDefclassData(
void *theEnv)
{
#if ! RUN_TIME
SLOT_NAME *tmpSNPPtr, *nextSNPPtr;
int i;
struct defclassModule *theModuleItem;
void *theModule;
int bloaded = FALSE;
#if BLOAD || BLOAD_AND_BSAVE
if (Bloaded(theEnv)) bloaded = TRUE;
#endif
/*=============================*/
/* Destroy all the defclasses. */
/*=============================*/
if (! bloaded)
{
DoForAllConstructs(theEnv,DestroyDefclassAction,DefclassData(theEnv)->DefclassModuleIndex,FALSE,NULL);
for (theModule = EnvGetNextDefmodule(theEnv,NULL);
theModule != NULL;
theModule = EnvGetNextDefmodule(theEnv,theModule))
{
theModuleItem = (struct defclassModule *)
GetModuleItem(theEnv,(struct defmodule *) theModule,
DefclassData(theEnv)->DefclassModuleIndex);
rtn_struct(theEnv,defclassModule,theModuleItem);
}
}
/*==========================*/
/* Remove the class tables. */
/*==========================*/
if (! bloaded)
{
if (DefclassData(theEnv)->ClassIDMap != NULL)
{
genfree(theEnv,DefclassData(theEnv)->ClassIDMap,DefclassData(theEnv)->AvailClassID * sizeof(DEFCLASS *));
}
}
if (DefclassData(theEnv)->ClassTable != NULL)
{
genfree(theEnv,DefclassData(theEnv)->ClassTable,sizeof(DEFCLASS *) * CLASS_TABLE_HASH_SIZE);
}
/*==============================*/
/* Free up the slot name table. */
/*==============================*/
if (! bloaded)
{
for (i = 0; i < SLOT_NAME_TABLE_HASH_SIZE; i++)
{
tmpSNPPtr = DefclassData(theEnv)->SlotNameTable[i];
while (tmpSNPPtr != NULL)
{
nextSNPPtr = tmpSNPPtr->nxt;
rtn_struct(theEnv,slotName,tmpSNPPtr);
tmpSNPPtr = nextSNPPtr;
}
}
}
if (DefclassData(theEnv)->SlotNameTable != NULL)
{
genfree(theEnv,DefclassData(theEnv)->SlotNameTable,sizeof(SLOT_NAME *) * SLOT_NAME_TABLE_HASH_SIZE);
}
#else
DEFCLASS *cls;
void *tmpexp;
register unsigned int i;
register int j;
if (DefclassData(theEnv)->ClassTable != NULL)
{
for (j = 0 ; j < CLASS_TABLE_HASH_SIZE ; j++)
for (cls = DefclassData(theEnv)->ClassTable[j] ; cls != NULL ; cls = cls->nxtHash)
{
for (i = 0 ; i < cls->slotCount ; i++)
{
if ((cls->slots[i].defaultValue != NULL) && (cls->slots[i].dynamicDefault == 0))
{
tmpexp = ((DATA_OBJECT *) cls->slots[i].defaultValue)->supplementalInfo;
rtn_struct(theEnv,dataObject,cls->slots[i].defaultValue);
cls->slots[i].defaultValue = tmpexp;
}
}
}
}
#endif
}
static void BsaveBinaryItem(
Environment *theEnv,
FILE *fp)
{
size_t space;
Deftemplate *theDeftemplate;
struct bsaveDeftemplate tempDeftemplate;
struct templateSlot *theSlot;
struct bsaveTemplateSlot tempTemplateSlot;
struct bsaveDeftemplateModule tempTemplateModule;
Defmodule *theModule;
struct deftemplateModule *theModuleItem;
/*============================================================*/
/* Write out the amount of space taken up by the deftemplate, */
/* deftemplateModule, and templateSlot data structures in the */
/* binary image. */
/*============================================================*/
space = (DeftemplateBinaryData(theEnv)->NumberOfDeftemplates * sizeof(struct bsaveDeftemplate)) +
(DeftemplateBinaryData(theEnv)->NumberOfTemplateSlots * sizeof(struct bsaveTemplateSlot)) +
(DeftemplateBinaryData(theEnv)->NumberOfTemplateModules * sizeof(struct bsaveDeftemplateModule));
GenWrite(&space,sizeof(size_t),fp);
/*===================================================*/
/* Write out each deftemplate module data structure. */
/*===================================================*/
DeftemplateBinaryData(theEnv)->NumberOfDeftemplates = 0;
for (theModule = GetNextDefmodule(theEnv,NULL);
theModule != NULL;
theModule = GetNextDefmodule(theEnv,theModule))
{
SetCurrentModule(theEnv,theModule);
theModuleItem = (struct deftemplateModule *)
GetModuleItem(theEnv,NULL,FindModuleItem(theEnv,"deftemplate")->moduleIndex);
AssignBsaveDefmdlItemHdrVals(&tempTemplateModule.header,
&theModuleItem->header);
GenWrite(&tempTemplateModule,sizeof(struct bsaveDeftemplateModule),fp);
}
/*============================================*/
/* Write out each deftemplate data structure. */
/*============================================*/
DeftemplateBinaryData(theEnv)->NumberOfTemplateSlots = 0;
for (theModule = GetNextDefmodule(theEnv,NULL);
theModule != NULL;
theModule = GetNextDefmodule(theEnv,theModule))
{
SetCurrentModule(theEnv,theModule);
for (theDeftemplate = GetNextDeftemplate(theEnv,NULL);
theDeftemplate != NULL;
theDeftemplate = GetNextDeftemplate(theEnv,theDeftemplate))
{
AssignBsaveConstructHeaderVals(&tempDeftemplate.header,
&theDeftemplate->header);
tempDeftemplate.implied = theDeftemplate->implied;
tempDeftemplate.numberOfSlots = theDeftemplate->numberOfSlots;
tempDeftemplate.patternNetwork = BsaveFactPatternIndex(theDeftemplate->patternNetwork);
if (theDeftemplate->slotList != NULL)
{ tempDeftemplate.slotList = DeftemplateBinaryData(theEnv)->NumberOfTemplateSlots; }
else
{ tempDeftemplate.slotList = ULONG_MAX; }
GenWrite(&tempDeftemplate,sizeof(struct bsaveDeftemplate),fp);
DeftemplateBinaryData(theEnv)->NumberOfTemplateSlots += theDeftemplate->numberOfSlots;
}
}
/*=============================================*/
/* Write out each templateSlot data structure. */
/*=============================================*/
for (theModule = GetNextDefmodule(theEnv,NULL);
theModule != NULL;
theModule = GetNextDefmodule(theEnv,theModule))
{
SetCurrentModule(theEnv,theModule);
for (theDeftemplate = GetNextDeftemplate(theEnv,NULL);
theDeftemplate != NULL;
theDeftemplate = GetNextDeftemplate(theEnv,theDeftemplate))
{
for (theSlot = theDeftemplate->slotList;
theSlot != NULL;
theSlot = theSlot->next)
{
tempTemplateSlot.constraints = ConstraintIndex(theSlot->constraints);
tempTemplateSlot.slotName = theSlot->slotName->bucket;
tempTemplateSlot.multislot = theSlot->multislot;
tempTemplateSlot.noDefault = theSlot->noDefault;
tempTemplateSlot.defaultPresent = theSlot->defaultPresent;
tempTemplateSlot.defaultDynamic = theSlot->defaultDynamic;
tempTemplateSlot.defaultList = HashedExpressionIndex(theEnv,theSlot->defaultList);
tempTemplateSlot.facetList = HashedExpressionIndex(theEnv,theSlot->facetList);
if (theSlot->next != NULL) tempTemplateSlot.next = 0L;
else tempTemplateSlot.next = ULONG_MAX;
GenWrite(&tempTemplateSlot,sizeof(struct bsaveTemplateSlot),fp);
}
}
}
/*=============================================================*/
/* If a binary image was already loaded when the bsave command */
/* was issued, then restore the counts indicating the number */
/* of deftemplates, deftemplate modules, and deftemplate slots */
/* in the binary image (these were overwritten by the binary */
/* save). */
/*=============================================================*/
RestoreBloadCount(theEnv,&DeftemplateBinaryData(theEnv)->NumberOfDeftemplates);
RestoreBloadCount(theEnv,&DeftemplateBinaryData(theEnv)->NumberOfTemplateSlots);
RestoreBloadCount(theEnv,&DeftemplateBinaryData(theEnv)->NumberOfTemplateModules);
}
static void BsaveBinaryItem(
void *theEnv,
FILE *fp)
{
size_t space;
struct deffacts *theDeffacts;
struct bsaveDeffacts newDeffacts;
struct defmodule *theModule;
struct bsaveDeffactsModule tempDeffactsModule;
struct deffactsModule *theModuleItem;
/*=========================================================*/
/* Write out the amount of space taken up by the deffacts */
/* and deffactsModule data structures in the binary image. */
/*=========================================================*/
space = DeffactsBinaryData(theEnv)->NumberOfDeffacts * sizeof(struct bsaveDeffacts) +
(DeffactsBinaryData(theEnv)->NumberOfDeffactsModules * sizeof(struct bsaveDeffactsModule));
GenWrite(&space,sizeof(size_t),fp);
/*================================================*/
/* Write out each deffacts module data structure. */
/*================================================*/
DeffactsBinaryData(theEnv)->NumberOfDeffacts = 0;
for (theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,NULL);
theModule != NULL;
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,theModule))
{
EnvSetCurrentModule(theEnv,(void *) theModule);
theModuleItem = (struct deffactsModule *) GetModuleItem(theEnv,NULL,DeffactsData(theEnv)->DeffactsModuleIndex);
AssignBsaveDefmdlItemHdrVals(&tempDeffactsModule.header,&theModuleItem->header);
GenWrite(&tempDeffactsModule,(unsigned long) sizeof(struct bsaveDeffactsModule),fp);
}
/*==========================*/
/* Write out each deffacts. */
/*==========================*/
for (theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,NULL);
theModule != NULL;
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,theModule))
{
EnvSetCurrentModule(theEnv,(void *) theModule);
for (theDeffacts = (struct deffacts *) EnvGetNextDeffacts(theEnv,NULL);
theDeffacts != NULL;
theDeffacts = (struct deffacts *) EnvGetNextDeffacts(theEnv,theDeffacts))
{
AssignBsaveConstructHeaderVals(&newDeffacts.header,&theDeffacts->header);
if (theDeffacts->assertList != NULL)
{
newDeffacts.assertList = ExpressionData(theEnv)->ExpressionCount;
ExpressionData(theEnv)->ExpressionCount += ExpressionSize(theDeffacts->assertList);
}
else
{ newDeffacts.assertList = -1L; }
GenWrite(&newDeffacts,(unsigned long) sizeof(struct bsaveDeffacts),fp);
}
}
/*=============================================================*/
/* If a binary image was already loaded when the bsave command */
/* was issued, then restore the counts indicating the number */
/* of deffacts and deffacts modules in the binary image (these */
/* were overwritten by the binary save). */
/*=============================================================*/
RestoreBloadCount(theEnv,&DeffactsBinaryData(theEnv)->NumberOfDeffactsModules);
RestoreBloadCount(theEnv,&DeffactsBinaryData(theEnv)->NumberOfDeffacts);
}
/*************************************************************************************
NAME : BsaveObjects
DESCRIPTION : Writes out classes and message-handlers in binary format
Space required (unsigned long)
Followed by the data structures in order
INPUTS : File pointer of binary file
RETURNS : Nothing useful
SIDE EFFECTS : Binary file adjusted
NOTES : None
*************************************************************************************/
static void BsaveObjects(
FILE *fp)
{
UNLN space;
struct defmodule *theModule;
DEFCLASS_MODULE *theModuleItem;
BSAVE_DEFCLASS_MODULE dummy_mitem;
BSAVE_SLOT_NAME dummy_slot_name;
SLOT_NAME *snp;
register unsigned i;
if ((ClassCount == 0L) && (HandlerCount == 0L))
{
space = 0L;
GenWrite((void *) &space,(UNLN) sizeof(UNLN),fp);
return;
}
space = (ModuleCount * (UNLN) sizeof(BSAVE_DEFCLASS_MODULE)) +
(ClassCount * (UNLN) sizeof(BSAVE_DEFCLASS)) +
(LinkCount * (UNLN) sizeof(long)) +
(SlotCount * (UNLN) sizeof(BSAVE_SLOT_DESC)) +
(SlotNameCount * (UNLN) sizeof(BSAVE_SLOT_NAME)) +
(TemplateSlotCount * (UNLN) sizeof(long)) +
(SlotNameMapCount * (UNLN) sizeof(unsigned)) +
(HandlerCount * (UNLN) sizeof(BSAVE_HANDLER)) +
(HandlerCount * (UNLN) sizeof(unsigned));
GenWrite((void *) &space,(UNLN) sizeof(UNLN),fp);
ClassCount = 0L;
LinkCount = 0L;
SlotCount = 0L;
SlotNameCount = 0L;
TemplateSlotCount = 0L;
SlotNameMapCount = 0L;
HandlerCount = 0L;
/* =================================
Write out each defclass module
================================= */
theModule = (struct defmodule *) GetNextDefmodule(NULL);
while (theModule != NULL)
{
theModuleItem = (DEFCLASS_MODULE *)
GetModuleItem(theModule,FindModuleItem("defclass")->moduleIndex);
AssignBsaveDefmdlItemHdrVals(&dummy_mitem.header,&theModuleItem->header);
GenWrite((void *) &dummy_mitem,(unsigned long) sizeof(BSAVE_DEFCLASS_MODULE),fp);
theModule = (struct defmodule *) GetNextDefmodule((void *) theModule);
}
/* =====================
Write out the classes
===================== */
DoForAllConstructs(BsaveDefclass,DefclassModuleIndex,FALSE,(void *) fp);
/* =========================
Write out the class links
========================= */
LinkCount = 0L;
DoForAllConstructs(BsaveClassLinks,DefclassModuleIndex,FALSE,(void *) fp);
/* ===============================
Write out the slot name entries
=============================== */
for (i = 0 ; i < SLOT_NAME_TABLE_HASH_SIZE ; i++)
for (snp = SlotNameTable[i] ; snp != NULL ; snp = snp->nxt)
{
if ((snp->id != ISA_ID) && (snp->id != NAME_ID))
{
dummy_slot_name.id = snp->id;
dummy_slot_name.hashTableIndex = snp->hashTableIndex;
dummy_slot_name.name = (long) snp->name->bucket;
dummy_slot_name.putHandlerName = (long) snp->putHandlerName->bucket;
GenWrite((void *) &dummy_slot_name,(UNLN) sizeof(BSAVE_SLOT_NAME),fp);
}
}
/* ===================
Write out the slots
=================== */
DoForAllConstructs(BsaveSlots,DefclassModuleIndex,FALSE,(void *) fp);
/* =====================================
Write out the template instance slots
===================================== */
DoForAllConstructs(BsaveTemplateSlots,DefclassModuleIndex,FALSE,(void *) fp);
/* =============================================
Write out the ordered instance slot name maps
============================================= */
DoForAllConstructs(BsaveSlotMap,DefclassModuleIndex,FALSE,(void *) fp);
/* ==============================
Write out the message-handlers
============================== */
DoForAllConstructs(BsaveHandlers,DefclassModuleIndex,FALSE,(void *) fp);
/* ==========================================
Write out the ordered message-handler maps
========================================== */
DoForAllConstructs(BsaveHandlerMap,DefclassModuleIndex,FALSE,(void *) fp);
if (Bloaded())
{
RestoreBloadCount(&ModuleCount);
RestoreBloadCount(&ClassCount);
RestoreBloadCount(&LinkCount);
RestoreBloadCount(&SlotCount);
RestoreBloadCount(&SlotNameCount);
RestoreBloadCount(&TemplateSlotCount);
RestoreBloadCount(&SlotNameMapCount);
RestoreBloadCount(&HandlerCount);
}
}
static void BsaveBinaryItem(
void *theEnv,
FILE *fp)
{
unsigned long int space;
struct defrule *theDefrule;
struct defmodule *theModule;
struct defruleModule *theModuleItem;
struct bsaveDefruleModule tempDefruleModule;
/*===============================================*/
/* Write out the space required by the defrules. */
/*===============================================*/
space = (DefruleBinaryData(theEnv)->NumberOfDefrules * sizeof(struct bsaveDefrule)) +
(DefruleBinaryData(theEnv)->NumberOfJoins * sizeof(struct bsaveJoinNode)) +
(DefruleBinaryData(theEnv)->NumberOfDefruleModules * sizeof(struct bsaveDefruleModule));
GenWrite(&space,(unsigned long) sizeof(unsigned long int),fp);
/*===============================================*/
/* Write out each defrule module data structure. */
/*===============================================*/
DefruleBinaryData(theEnv)->NumberOfDefrules = 0;
for (theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,NULL);
theModule != NULL;
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,theModule))
{
EnvSetCurrentModule(theEnv,(void *) theModule);
theModuleItem = (struct defruleModule *)
GetModuleItem(theEnv,NULL,FindModuleItem(theEnv,"defrule")->moduleIndex);
AssignBsaveDefmdlItemHdrVals(&tempDefruleModule.header,
&theModuleItem->header);
GenWrite(&tempDefruleModule,(unsigned long) sizeof(struct bsaveDefruleModule),fp);
}
/*========================================*/
/* Write out each defrule data structure. */
/*========================================*/
for (theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,NULL);
theModule != NULL;
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,theModule))
{
EnvSetCurrentModule(theEnv,(void *) theModule);
for (theDefrule = (struct defrule *) EnvGetNextDefrule(theEnv,NULL);
theDefrule != NULL;
theDefrule = (struct defrule *) EnvGetNextDefrule(theEnv,theDefrule))
{ BsaveDisjuncts(theEnv,fp,theDefrule); }
}
/*=============================*/
/* Write out the Rete Network. */
/*=============================*/
MarkRuleNetwork(theEnv,1);
BsaveJoins(theEnv,fp);
/*=============================================================*/
/* If a binary image was already loaded when the bsave command */
/* was issued, then restore the counts indicating the number */
/* of defrules, defrule modules, and joins in the binary image */
/* (these were overwritten by the binary save). */
/*=============================================================*/
RestoreBloadCount(theEnv,&DefruleBinaryData(theEnv)->NumberOfDefruleModules);
RestoreBloadCount(theEnv,&DefruleBinaryData(theEnv)->NumberOfDefrules);
RestoreBloadCount(theEnv,&DefruleBinaryData(theEnv)->NumberOfJoins);
}
static void BsaveBinaryItem(
FILE *fp)
{
unsigned long int space;
struct defrule *theDefrule;
#if FUZZY_DEFTEMPLATES
struct defrule *theDisjunct;
#endif
struct defmodule *theModule;
struct defruleModule *theModuleItem;
struct bsaveDefruleModule tempDefruleModule;
#if CERTAINTY_FACTORS
long int disjunctExpressionCountCF = 0L;
#endif
/*===============================================*/
/* Write out the space required by the defrules. */
/*===============================================*/
space = (NumberOfDefrules * sizeof(struct bsaveDefrule)) +
(NumberOfJoins * sizeof(struct bsaveJoinNode)) +
#if FUZZY_DEFTEMPLATES
(NumberOfPatternFuzzyValues * sizeof(struct fzSlotLocator)) +
#endif
(NumberOfDefruleModules * sizeof(struct bsaveDefruleModule));
GenWrite(&space,(unsigned long) sizeof(unsigned long int),fp);
/*===============================================*/
/* Write out each defrule module data structure. */
/*===============================================*/
NumberOfDefrules = 0;
#if FUZZY_DEFTEMPLATES
NumberOfPatternFuzzyValues = 0;
#endif
for (theModule = (struct defmodule *) GetNextDefmodule(NULL);
theModule != NULL;
theModule = (struct defmodule *) GetNextDefmodule(theModule))
{
SetCurrentModule((void *) theModule);
theModuleItem = (struct defruleModule *)
GetModuleItem(NULL,FindModuleItem("defrule")->moduleIndex);
AssignBsaveDefmdlItemHdrVals(&tempDefruleModule.header,
&theModuleItem->header);
GenWrite(&tempDefruleModule,(unsigned long) sizeof(struct bsaveDefruleModule),fp);
}
/*========================================*/
/* Write out each defrule data structure. */
/*========================================*/
for (theModule = (struct defmodule *) GetNextDefmodule(NULL);
theModule != NULL;
theModule = (struct defmodule *) GetNextDefmodule(theModule))
{
SetCurrentModule((void *) theModule);
for (theDefrule = (struct defrule *) GetNextDefrule(NULL);
theDefrule != NULL;
theDefrule = (struct defrule *) GetNextDefrule(theDefrule))
{ BsaveDisjuncts(fp,theDefrule); }
}
#if FUZZY_DEFTEMPLATES
/*====================================*/
/* Write out the PatternFuzzyValues . */
/*====================================*/
theModule = (struct defmodule *) GetNextDefmodule(NULL);
while (theModule != NULL)
{
SetCurrentModule((VOID *) theModule);
theDefrule = (struct defrule *) GetNextDefrule(NULL);
while (theDefrule != NULL)
{
theDisjunct = theDefrule;
while (theDisjunct != NULL)
{
int i;
struct bsaveFzSlotLocator tempFZSlotLocator;
for (i=0; i<theDisjunct->numberOfFuzzySlots; i++)
{
FUZZY_VALUE_HN *fvhnPtr;
struct fzSlotLocator *fvSLPtr;
fvSLPtr = theDisjunct->pattern_fv_arrayPtr + i;
fvhnPtr = fvSLPtr->fvhnPtr;
tempFZSlotLocator.patternNum = fvSLPtr->patternNum;
tempFZSlotLocator.slotNum = fvSLPtr->slotNum;
tempFZSlotLocator.fvhnPtr = fvhnPtr->bucket;
GenWrite(&tempFZSlotLocator,(unsigned long) sizeof(struct bsaveFzSlotLocator),fp);
}
theDisjunct = theDisjunct->disjunct;
}
theDefrule = (struct defrule *) GetNextDefrule(theDefrule);
}
theModule = (struct defmodule *) GetNextDefmodule(theModule);
}
#endif
/*=============================*/
/* Write out the Rete Network. */
/*=============================*/
MarkRuleNetwork(1);
BsaveJoins(fp);
/*=============================================================*/
/* If a binary image was already loaded when the bsave command */
/* was issued, then restore the counts indicating the number */
/* of defrules, defrule modules, and joins in the binary image */
/* (these were overwritten by the binary save). */
/*=============================================================*/
if (Bloaded())
{
RestoreBloadCount(&NumberOfDefruleModules);
RestoreBloadCount(&NumberOfDefrules);
RestoreBloadCount(&NumberOfJoins);
#if FUZZY_DEFTEMPLATES
RestoreBloadCount(&NumberOfPatternFuzzyValues);
#endif
}
}
static struct defrule *CreateNewDisjunct(
void *theEnv,
SYMBOL_HN *ruleName,
int localVarCnt,
struct expr *theActions,
int complexity,
unsigned logicalJoin,
struct joinNode *lastJoin)
{
struct joinNode *tempJoin;
struct defrule *newDisjunct;
/*===================================================*/
/* Create and initialize the defrule data structure. */
/*===================================================*/
newDisjunct = get_struct(theEnv,defrule);
newDisjunct->header.ppForm = NULL;
newDisjunct->header.next = NULL;
newDisjunct->header.usrData = NULL;
newDisjunct->logicalJoin = NULL;
newDisjunct->disjunct = NULL;
newDisjunct->header.name = ruleName;
IncrementSymbolCount(newDisjunct->header.name);
newDisjunct->actions = theActions;
newDisjunct->salience = PatternData(theEnv)->GlobalSalience;
newDisjunct->afterBreakpoint = 0;
newDisjunct->watchActivation = 0;
newDisjunct->watchFiring = 0;
newDisjunct->executing = 0;
newDisjunct->complexity = complexity;
newDisjunct->autoFocus = PatternData(theEnv)->GlobalAutoFocus;
newDisjunct->dynamicSalience = PatternData(theEnv)->SalienceExpression;
newDisjunct->localVarCnt = localVarCnt;
/*=====================================*/
/* Add a pointer to the rule's module. */
/*=====================================*/
newDisjunct->header.whichModule =
(struct defmoduleItemHeader *)
GetModuleItem(theEnv,NULL,FindModuleItem(theEnv,"defrule")->moduleIndex);
/*============================================================*/
/* Attach the rule's last join to the defrule data structure. */
/*============================================================*/
lastJoin->ruleToActivate = newDisjunct;
newDisjunct->lastJoin = lastJoin;
/*=================================================*/
/* Determine the rule's logical join if it exists. */
/*=================================================*/
tempJoin = lastJoin;
while (tempJoin != NULL)
{
if (tempJoin->depth == logicalJoin)
{
newDisjunct->logicalJoin = tempJoin;
tempJoin->logicalJoin = TRUE;
}
tempJoin = tempJoin->lastLevel;
}
/*==================================================*/
/* Return the newly created defrule data structure. */
/*==================================================*/
return(newDisjunct);
}