globle void *EnvGetFocus(
void *theEnv)
{
if (EngineData(theEnv)->CurrentFocus == NULL) return(NULL);
return((void *) EngineData(theEnv)->CurrentFocus->theModule);
}
globle intBool EvaluateSecondaryNetworkTest(
void *theEnv,
struct partialMatch *leftMatch,
struct joinNode *joinPtr)
{
int joinExpr;
struct partialMatch *oldLHSBinds;
struct partialMatch *oldRHSBinds;
struct joinNode *oldJoin;
if (joinPtr->secondaryNetworkTest == NULL)
{ return(TRUE); }
#if DEVELOPER
EngineData(theEnv)->rightToLeftComparisons++;
#endif
oldLHSBinds = EngineData(theEnv)->GlobalLHSBinds;
oldRHSBinds = EngineData(theEnv)->GlobalRHSBinds;
oldJoin = EngineData(theEnv)->GlobalJoin;
EngineData(theEnv)->GlobalLHSBinds = leftMatch;
EngineData(theEnv)->GlobalRHSBinds = NULL;
EngineData(theEnv)->GlobalJoin = joinPtr;
joinExpr = EvaluateJoinExpression(theEnv,joinPtr->secondaryNetworkTest,joinPtr);
EvaluationData(theEnv)->EvaluationError = FALSE;
EngineData(theEnv)->GlobalLHSBinds = oldLHSBinds;
EngineData(theEnv)->GlobalRHSBinds = oldRHSBinds;
EngineData(theEnv)->GlobalJoin = oldJoin;
return(joinExpr);
}
globle CLIPS_BOOLEAN AddLogicalDependencies(
void *theEnv,
struct patternEntity *theEntity,
int existingEntity)
{
struct partialMatch *theBinds;
struct dependency *newDependency;
/*==============================================*/
/* If the rule has no logical patterns, then no */
/* dependencies have to be established. */
/*==============================================*/
if (EngineData(theEnv)->TheLogicalJoin == NULL)
{
if (existingEntity) RemoveEntityDependencies(theEnv,theEntity);
return(TRUE);
}
else if (existingEntity && (theEntity->dependents == NULL))
{ return(TRUE); }
/*============================================================*/
/* Find the partial match in the logical join associated with */
/* activation partial match. If the partial match cannot be */
/* found, then the partial match must have been deleted by a */
/* previous RHS action and the dependency link should not be */
/* added. */
/*============================================================*/
theBinds = FindLogicalBind(EngineData(theEnv)->TheLogicalJoin,EngineData(theEnv)->GlobalLHSBinds);
if (theBinds == NULL) return(FALSE);
/*==============================================================*/
/* Add a dependency link between the partial match and the data */
/* entity. The dependency links are stored in the partial match */
/* behind the data entities stored in the partial match and the */
/* activation link, if any. */
/*==============================================================*/
newDependency = get_struct(theEnv,dependency);
newDependency->dPtr = (void *) theEntity;
newDependency->next = (struct dependency *)
theBinds->binds[theBinds->bcount + theBinds->activationf].gm.theValue;
theBinds->binds[theBinds->bcount + theBinds->activationf].gm.theValue = (void *) newDependency;
/*================================================================*/
/* Add a dependency link between the entity and the partialMatch. */
/*================================================================*/
newDependency = get_struct(theEnv,dependency);
newDependency->dPtr = (void *) theBinds;
newDependency->next = (struct dependency *) theEntity->dependents;
theEntity->dependents = (void *) newDependency;
/*==================================================================*/
/* Return TRUE to indicate that the data entity should be asserted. */
/*==================================================================*/
return(TRUE);
}
globle void EnvClearFocusStack(
void *theEnv)
{
while (EngineData(theEnv)->CurrentFocus != NULL) EnvPopFocus(theEnv);
EngineData(theEnv)->FocusChanged = TRUE;
}
globle intBool EnvSetIncrementalReset(
void *theEnv,
int value)
{
int ov;
struct defmodule *theModule;
SaveCurrentModule(theEnv);
for (theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,NULL);
theModule != NULL;
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,theModule))
{
EnvSetCurrentModule(theEnv,(void *) theModule);
if (EnvGetNextDefrule(theEnv,NULL) != NULL)
{
RestoreCurrentModule(theEnv);
return(-1);
}
}
RestoreCurrentModule(theEnv);
ov = EngineData(theEnv)->IncrementalResetFlag;
EngineData(theEnv)->IncrementalResetFlag = value;
return(ov);
}
globle void RetractCheckDriveRetractions( /* GDR 111599 #834 Begin */
void *theEnv,
struct alphaMatch *theAlphaNode,
int position)
{
struct rdriveinfo *tempDR, *theDR, *lastDR = NULL;
theDR = EngineData(theEnv)->DriveRetractionList;
while (theDR != NULL)
{
if ((position < (int) theDR->link->bcount) &&
(theDR->link->binds[position].gm.theMatch == theAlphaNode))
{
tempDR = theDR->next;
rtn_struct(theEnv,rdriveinfo,theDR);
if (lastDR == NULL)
{ EngineData(theEnv)->DriveRetractionList = tempDR; }
else
{ lastDR->next = tempDR; }
theDR = tempDR;
}
else
{
lastDR = theDR;
theDR = theDR->next;
}
}
} /* GDR 111599 #834 End */
globle int FactJNCompVars1(
void *theEnv,
void *theValue,
DATA_OBJECT *theResult)
{
int p1, e1, p2, e2;
struct fact *fact1, *fact2;
struct factCompVarsJN1Call *hack;
/*=========================================*/
/* Retrieve the arguments to the function. */
/*=========================================*/
hack = (struct factCompVarsJN1Call *) ValueToBitMap(theValue);
/*=================================================*/
/* Extract the fact pointers for the two patterns. */
/*=================================================*/
p1 = (int) hack->pattern1;
p2 = (int) hack->pattern2;
fact1 = (struct fact *) EngineData(theEnv)->GlobalRHSBinds->binds[p1].gm.theMatch->matchingItem;
if (hack->p2rhs)
{
fact2 = (struct fact *) EngineData(theEnv)->GlobalRHSBinds->binds[p2].gm.theMatch->matchingItem;
}
else
{
fact2 = (struct fact *) EngineData(theEnv)->GlobalLHSBinds->binds[p2].gm.theMatch->matchingItem;
}
/*=====================*/
/* Compare the values. */
/*=====================*/
e1 = (int) hack->slot1;
e2 = (int) hack->slot2;
if (fact1->theProposition.theFields[e1].type !=
fact2->theProposition.theFields[e2].type)
{
return((int) hack->fail);
}
if (fact1->theProposition.theFields[e1].value !=
fact2->theProposition.theFields[e2].value)
{
return((int) hack->fail);
}
return((int) hack->pass);
}
static void DeletePartialMatches(
void *theEnv,
struct partialMatch *listOfPMs,
int betaDelete)
{
struct partialMatch *nextPM;
while (listOfPMs != NULL)
{
/*============================================*/
/* Remember the next partial match to delete. */
/*============================================*/
nextPM = listOfPMs->next;
/*================================================*/
/* Remove the links between the partial match and */
/* any data entities that it is attached to as a */
/* result of a logical CE. */
/*================================================*/
#if LOGICAL_DEPENDENCIES
if (listOfPMs->dependentsf) RemoveLogicalSupport(theEnv,listOfPMs);
#endif
/*==========================================================*/
/* If the partial match is being deleted from a beta memory */
/* and the partial match isn't associated with a satisfied */
/* not CE, then it can be immediately returned to the pool */
/* of free memory. Otherwise, it's could be in use (either */
/* to retrieve variables from the LHS or by the activation */
/* of the rule). Since a not CE creates a "pseudo" data */
/* entity, the beta partial match which stores this pseudo */
/* data entity can not be deleted immediately (for the same */
/* reason an alpha memory partial match can't be deleted */
/* immediately). */
/*==========================================================*/
if (betaDelete &&
((listOfPMs->notOriginf == FALSE) || (listOfPMs->counterf)))
{ ReturnPartialMatch(theEnv,listOfPMs); }
else
{
listOfPMs->next = EngineData(theEnv)->GarbagePartialMatches;
EngineData(theEnv)->GarbagePartialMatches = listOfPMs;
}
/*====================================*/
/* Move on to the next partial match. */
/*====================================*/
listOfPMs = nextPM;
}
}
globle intBool EnvAddRunFunction(
void *theEnv,
char *name,
void (*functionPtr)(void *),
int priority)
{
EngineData(theEnv)->ListOfRunFunctions = AddFunctionToCallList(theEnv,name,priority,
functionPtr,
EngineData(theEnv)->ListOfRunFunctions,TRUE);
return(1);
}
globle BOOLEAN EnvSetIncrementalReset(
void *theEnv,
int value)
{
int ov;
ov = EngineData(theEnv)->IncrementalResetFlag;
if (EnvGetNextDefrule(theEnv,NULL) != NULL) return(-1);
EngineData(theEnv)->IncrementalResetFlag = value;
return(ov);
}
globle void InitializeEngine(
void *theEnv)
{
AllocateEnvironmentData(theEnv,ENGINE_DATA,sizeof(struct engineData),DeallocateEngineData);
EngineData(theEnv)->IncrementalResetFlag = TRUE;
#if DEBUGGING_FUNCTIONS
AddWatchItem(theEnv,"statistics",0,&EngineData(theEnv)->WatchStatistics,20,NULL,NULL);
AddWatchItem(theEnv,"focus",0,&EngineData(theEnv)->WatchFocus,0,NULL,NULL);
#endif
}
globle void EnvGetFocusStack(
void *theEnv,
DATA_OBJECT_PTR returnValue)
{
struct focus *theFocus;
struct multifield *theList;
unsigned long count = 0;
/*===========================================*/
/* If there is no current focus, then return */
/* a multifield value of length zero. */
/*===========================================*/
if (EngineData(theEnv)->CurrentFocus == NULL)
{
SetpType(returnValue,MULTIFIELD);
SetpDOBegin(returnValue,1);
SetpDOEnd(returnValue,0);
SetpValue(returnValue,(void *) EnvCreateMultifield(theEnv,0L));
return;
}
/*=====================================================*/
/* Determine the number of modules on the focus stack. */
/*=====================================================*/
for (theFocus = EngineData(theEnv)->CurrentFocus; theFocus != NULL; theFocus = theFocus->next)
{ count++; }
/*=============================================*/
/* Create a multifield of the appropriate size */
/* in which to store the module names. */
/*=============================================*/
SetpType(returnValue,MULTIFIELD);
SetpDOBegin(returnValue,1);
SetpDOEnd(returnValue,(long) count);
theList = (struct multifield *) EnvCreateMultifield(theEnv,count);
SetpValue(returnValue,(void *) theList);
/*=================================================*/
/* Store the module names in the multifield value. */
/*=================================================*/
for (theFocus = EngineData(theEnv)->CurrentFocus, count = 1;
theFocus != NULL;
theFocus = theFocus->next, count++)
{
SetMFType(theList,count,SYMBOL);
SetMFValue(theList,count,theFocus->theModule->name);
}
}
globle intBool EnvRemoveRunFunction(
void *theEnv,
char *name)
{
int found;
EngineData(theEnv)->ListOfRunFunctions =
RemoveFunctionFromCallList(theEnv,name,EngineData(theEnv)->ListOfRunFunctions,&found);
if (found) return(TRUE);
return(FALSE);
}
globle intBool AddRunFunction(
char *name,
void (*functionPtr)(void),
int priority)
{
void *theEnv;
theEnv = GetCurrentEnvironment();
EngineData(theEnv)->ListOfRunFunctions =
AddFunctionToCallList(theEnv,name,priority,(void (*)(void *)) functionPtr,
EngineData(theEnv)->ListOfRunFunctions,TRUE);
return(1);
}
static bool ClearDefrulesReady(
void *theEnv)
{
if (EngineData(theEnv)->ExecutingRule != NULL) return(false);
if (EngineData(theEnv)->JoinOperationInProgress) return(false);
EnvClearFocusStack(theEnv);
if (EnvGetCurrentModule(theEnv) == NULL) return(false);
DefruleData(theEnv)->CurrentEntityTimeTag = 1L;
return(true);
}
/****************************************************
NAME : GetPatternObjectAndMarks
DESCRIPTION : Finds the instance and multfiield
markers corresponding to a specified
pattern in the join network
INPUTS : 1) The index of the desired pattern
2) A buffer to hold the instance
address
3) A buffer to hold the list of
multifield markers
RETURNS : Nothing useful
SIDE EFFECTS : Buffers set
NOTES : None
****************************************************/
static void GetPatternObjectAndMarks(
void *theEnv,
int pattern,
INSTANCE_TYPE **theInstance,
struct multifieldMarker **theMarkers)
{
if (EngineData(theEnv)->GlobalRHSBinds == NULL)
{
*theInstance = (INSTANCE_TYPE *)
get_nth_pm_match(EngineData(theEnv)->GlobalLHSBinds,pattern)->matchingItem;
*theMarkers =
get_nth_pm_match(EngineData(theEnv)->GlobalLHSBinds,pattern)->markers;
}
else if ((((int) EngineData(theEnv)->GlobalJoin->depth) - 1) == pattern)
{
*theInstance = (INSTANCE_TYPE *) get_nth_pm_match(EngineData(theEnv)->GlobalRHSBinds,0)->matchingItem;
*theMarkers = get_nth_pm_match(EngineData(theEnv)->GlobalRHSBinds,0)->markers;
}
else
{
*theInstance = (INSTANCE_TYPE *)
get_nth_pm_match(EngineData(theEnv)->GlobalLHSBinds,pattern)->matchingItem;
*theMarkers =
get_nth_pm_match(EngineData(theEnv)->GlobalLHSBinds,pattern)->markers;
}
}
globle void ReturnPartialMatch(
void *theEnv,
struct partialMatch *waste)
{
/*==============================================*/
/* If the partial match is in use, then put it */
/* on a garbage list to be processed later when */
/* the partial match is not in use. */
/*==============================================*/
if (waste->busy)
{
waste->next = EngineData(theEnv)->GarbagePartialMatches;
EngineData(theEnv)->GarbagePartialMatches = waste;
return;
}
/*======================================================*/
/* If we're dealing with an alpha memory partial match, */
/* then return the multifield markers associated with */
/* the partial match (if any) along with the alphaMatch */
/* data structure. */
/*======================================================*/
if (waste->betaMemory == FALSE)
{
if (waste->binds[0].gm.theMatch->markers != NULL)
{ ReturnMarkers(theEnv,waste->binds[0].gm.theMatch->markers); }
rm(theEnv,waste->binds[0].gm.theMatch,(int) sizeof(struct alphaMatch));
}
/*=================================================*/
/* Remove any links between the partial match and */
/* a data entity that were created with the use of */
/* the logical CE. */
/*=================================================*/
#if LOGICAL_DEPENDENCIES
if (waste->dependentsf) RemovePMDependencies(theEnv,waste);
#endif
/*======================================================*/
/* Return the partial match to the pool of free memory. */
/*======================================================*/
rtn_var_struct(theEnv,partialMatch,(int) sizeof(struct genericMatch *) *
(waste->bcount + waste->activationf + waste->dependentsf - 1),
waste);
}
static void DeallocateEngineData(
void *theEnv)
{
struct focus *tmpPtr, *nextPtr;
DeallocateCallList(theEnv,EngineData(theEnv)->ListOfRunFunctions);
tmpPtr = EngineData(theEnv)->CurrentFocus;
while (tmpPtr != NULL)
{
nextPtr = tmpPtr->next;
rtn_struct(theEnv,focus,tmpPtr);
tmpPtr = nextPtr;
}
}
globle void FactsIncrementalReset(
void *theEnv)
{
struct fact *factPtr;
for (factPtr = (struct fact *) EnvGetNextFact(theEnv,NULL);
factPtr != NULL;
factPtr = (struct fact *) EnvGetNextFact(theEnv,factPtr))
{
EngineData(theEnv)->JoinOperationInProgress = TRUE;
FactPatternMatch(theEnv,factPtr,
factPtr->whichDeftemplate->patternNetwork,
0,NULL,NULL);
EngineData(theEnv)->JoinOperationInProgress = FALSE;
}
}
globle CLIPS_BOOLEAN EnvIsDefruleDeletable(
void *theEnv,
void *vTheDefrule)
{
#if BLOAD_ONLY || RUN_TIME
#if MAC_MCW || IBM_MCW || MAC_XCD
#pragma unused(theEnv,vTheDefrule)
#endif
return(FALSE);
#else
struct defrule *theDefrule;
#if BLOAD || BLOAD_AND_BSAVE
if (Bloaded(theEnv)) return(FALSE);
#endif
for (theDefrule = (struct defrule *) vTheDefrule;
theDefrule != NULL;
theDefrule = theDefrule->disjunct)
{ if (theDefrule->executing) return(FALSE); }
if (EngineData(theEnv)->JoinOperationInProgress) return(FALSE);
return(TRUE);
#endif
}
globle void NetworkAssert(
void *theEnv,
struct partialMatch *binds,
struct joinNode *join)
{
/*=========================================================*/
/* If an incremental reset is being performed and the join */
/* is not part of the network to be reset, then return. */
/*=========================================================*/
#if (! BLOAD_ONLY) && (! RUN_TIME)
if (EngineData(theEnv)->IncrementalResetInProgress && (join->initialize == FALSE)) return;
#endif
/*==================================================*/
/* Use a special routine if this is the first join. */
/*==================================================*/
if (join->firstJoin)
{
EmptyDrive(theEnv,join,binds);
return;
}
/*================================*/
/* Enter the join from the right. */
/*================================*/
NetworkAssertRight(theEnv,binds,join);
return;
}
bool FactJNCompVars1(
Environment *theEnv,
void *theValue,
UDFValue *theResult)
{
#if MAC_XCD
#pragma unused(theResult)
#endif
unsigned short p1, e1, p2, e2;
Fact *fact1, *fact2;
struct factCompVarsJN1Call *hack;
/*=========================================*/
/* Retrieve the arguments to the function. */
/*=========================================*/
hack = (struct factCompVarsJN1Call *) ((CLIPSBitMap *) theValue)->contents;
/*=================================================*/
/* Extract the fact pointers for the two patterns. */
/*=================================================*/
p1 = hack->pattern1;
p2 = hack->pattern2;
fact1 = (Fact *) EngineData(theEnv)->GlobalRHSBinds->binds[p1].gm.theMatch->matchingItem;
if (hack->p2rhs)
{ fact2 = (Fact *) EngineData(theEnv)->GlobalRHSBinds->binds[p2].gm.theMatch->matchingItem; }
else
{ fact2 = (Fact *) EngineData(theEnv)->GlobalLHSBinds->binds[p2].gm.theMatch->matchingItem; }
/*=====================*/
/* Compare the values. */
/*=====================*/
e1 = hack->slot1;
e2 = hack->slot2;
if (fact1->theProposition.contents[e1].value !=
fact2->theProposition.contents[e2].value)
{ return hack->fail; }
return hack->pass;
}
globle void ForceLogicalRetractions(
void *theEnv)
{
struct dependency *tempPtr;
struct patternEntity *theEntity;
/*===================================================*/
/* Don't reenter this function once it's called. Any */
/* new additions to the list of items to be deleted */
/* as a result of losing their logical support will */
/* be handled properly. */
/*===================================================*/
if (EngineData(theEnv)->alreadyEntered) return;
EngineData(theEnv)->alreadyEntered = TRUE;
/*=======================================================*/
/* Continue to delete the first item on the list as long */
/* as one exists. This is done because new items may be */
/* placed at the beginning of the list as other data */
/* entities are deleted. */
/*=======================================================*/
while (EngineData(theEnv)->UnsupportedDataEntities != NULL)
{
/*==========================================*/
/* Determine the data entity to be deleted. */
/*==========================================*/
theEntity = (struct patternEntity *) EngineData(theEnv)->UnsupportedDataEntities->dPtr;
/*================================================*/
/* Remove the dependency structure from the list. */
/*================================================*/
tempPtr = EngineData(theEnv)->UnsupportedDataEntities;
EngineData(theEnv)->UnsupportedDataEntities = EngineData(theEnv)->UnsupportedDataEntities->next;
rtn_struct(theEnv,dependency,tempPtr);
/*=========================*/
/* Delete the data entity. */
/*=========================*/
(*theEntity->theInfo->base.decrementBusyCount)(theEnv,theEntity);
(*theEntity->theInfo->base.deleteFunction)(theEnv,theEntity);
}
/*============================================*/
/* Deletion of items on the list is complete. */
/*============================================*/
EngineData(theEnv)->alreadyEntered = FALSE;
}
static int ClearDefrulesReady(
void *theEnv)
{
if (EngineData(theEnv)->ExecutingRule != NULL) return(FALSE);
EnvClearFocusStack(theEnv);
if (EnvGetCurrentModule(theEnv) == NULL) return(FALSE);
DefruleData(theEnv)->CurrentEntityTimeTag = 0L;
return(TRUE);
}
static int SkipFactPatternNode(
void *theEnv,
struct factPatternNode *thePattern)
{
#if (! RUN_TIME) && (! BLOAD_ONLY)
if (EngineData(theEnv)->IncrementalResetInProgress &&
(thePattern->header.initialize == FALSE))
{ return(TRUE); }
#endif
return(FALSE);
}
globle void EnvListFocusStack(
void *theEnv,
char *logicalName)
{
struct focus *theFocus;
for (theFocus = EngineData(theEnv)->CurrentFocus;
theFocus != NULL;
theFocus = theFocus->next)
{
EnvPrintRouter(theEnv,logicalName,EnvGetDefmoduleName(theEnv,theFocus->theModule));
EnvPrintRouter(theEnv,logicalName,"\n");
}
}
globle CLIPS_BOOLEAN FactJNGetVar2(
void *theEnv,
void *theValue,
DATA_OBJECT_PTR returnValue)
{
struct fact *factPtr;
struct factGetVarJN2Call *hack;
struct field *fieldPtr;
/*==========================================*/
/* Retrieve the arguments for the function. */
/*==========================================*/
hack = (struct factGetVarJN2Call *) ValueToBitMap(theValue);
/*=====================================================*/
/* Get the pointer to the fact from the partial match. */
/*=====================================================*/
if (EngineData(theEnv)->GlobalRHSBinds == NULL)
{ factPtr = (struct fact *) get_nth_pm_match(EngineData(theEnv)->GlobalLHSBinds,hack->whichPattern)->matchingItem; }
else if ((EngineData(theEnv)->GlobalJoin->depth - 1) == hack->whichPattern)
{ factPtr = (struct fact *) get_nth_pm_match(EngineData(theEnv)->GlobalRHSBinds,0)->matchingItem; }
else
{ factPtr = (struct fact *) get_nth_pm_match(EngineData(theEnv)->GlobalLHSBinds,hack->whichPattern)->matchingItem; }
/*============================================*/
/* Extract the value from the specified slot. */
/*============================================*/
fieldPtr = &factPtr->theProposition.theFields[hack->whichSlot];
returnValue->type = fieldPtr->type;
returnValue->value = fieldPtr->value;
return(TRUE);
}
globle void EnvFocus(
void *theEnv,
void *vTheModule)
{
struct defmodule *theModule = (struct defmodule *) vTheModule;
struct focus *tempFocus;
/*==================================================*/
/* Make the specified module be the current module. */
/* If the specified module is the current focus, */
/* then no further action is needed. */
/*==================================================*/
EnvSetCurrentModule(theEnv,(void *) theModule);
if (EngineData(theEnv)->CurrentFocus != NULL)
{ if (EngineData(theEnv)->CurrentFocus->theModule == theModule) return; }
/*=====================================*/
/* If the focus is being watched, then */
/* print an information message. */
/*=====================================*/
#if DEBUGGING_FUNCTIONS
if (EngineData(theEnv)->WatchFocus)
{
EnvPrintRouter(theEnv,WTRACE,"==> Focus ");
EnvPrintRouter(theEnv,WTRACE,ValueToString(theModule->name));
if (EngineData(theEnv)->CurrentFocus != NULL)
{
EnvPrintRouter(theEnv,WTRACE," from ");
EnvPrintRouter(theEnv,WTRACE,ValueToString(EngineData(theEnv)->CurrentFocus->theModule->name));
}
EnvPrintRouter(theEnv,WTRACE,"\n");
}
#endif
/*=======================================*/
/* Add the new focus to the focus stack. */
/*=======================================*/
tempFocus = get_struct(theEnv,focus);
tempFocus->theModule = theModule;
tempFocus->theDefruleModule = GetDefruleModuleItem(theEnv,theModule);
tempFocus->next = EngineData(theEnv)->CurrentFocus;
EngineData(theEnv)->CurrentFocus = tempFocus;
EngineData(theEnv)->FocusChanged = TRUE;
}
globle intBool EnvSetIncrementalReset(
void *theEnv,
int value)
{
int ov;
struct defmodule *theModule;
/*============================================*/
/* The incremental reset behavior can only be */
/* changed if there are no existing rules. */
/*============================================*/
SaveCurrentModule(theEnv);
for (theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,NULL);
theModule != NULL;
theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,theModule))
{
EnvSetCurrentModule(theEnv,(void *) theModule);
if (EnvGetNextDefrule(theEnv,NULL) != NULL)
{
RestoreCurrentModule(theEnv);
return(-1);
}
}
RestoreCurrentModule(theEnv);
/*====================================*/
/* Change the incremental reset flag. */
/*====================================*/
ov = EngineData(theEnv)->IncrementalResetFlag;
EngineData(theEnv)->IncrementalResetFlag = value;
return(ov);
}
static int SkipFactPatternNode(
void *theEnv,
struct factPatternNode *thePattern)
{
#if (MAC_MCW || IBM_MCW) && (RUN_TIME || BLOAD_ONLY || (! INCREMENTAL_RESET))
#pragma unused(theEnv,thePattern)
#endif
#if INCREMENTAL_RESET && (! RUN_TIME) && (! BLOAD_ONLY)
if (EngineData(theEnv)->IncrementalResetInProgress &&
(thePattern->header.initialize == FALSE))
{ return(TRUE); }
#endif
return(FALSE);
}
