static void ResetDefrules(
void *theEnv,
EXEC_STATUS)
{
struct defmodule *theModule;
struct joinLink *theLink;
struct partialMatch *notParent;
DefruleData(theEnv,execStatus)->CurrentEntityTimeTag = 1L;
EnvClearFocusStack(theEnv,execStatus);
theModule = (struct defmodule *) EnvFindDefmodule(theEnv,execStatus,"MAIN");
EnvFocus(theEnv,execStatus,(void *) theModule);
for (theLink = DefruleData(theEnv,execStatus)->RightPrimeJoins;
theLink != NULL;
theLink = theLink->next)
{ PosEntryRetractAlpha(theEnv,execStatus,theLink->join->rightMemory->beta[0]); }
for (theLink = DefruleData(theEnv,execStatus)->LeftPrimeJoins;
theLink != NULL;
theLink = theLink->next)
{
if ((theLink->join->patternIsNegated || theLink->join->joinFromTheRight) &&
(! theLink->join->patternIsExists))
{
notParent = theLink->join->leftMemory->beta[0];
if (notParent->marker)
{ RemoveBlockedLink(notParent); }
/*==========================================================*/
/* Prevent any retractions from generating partial matches. */
/*==========================================================*/
notParent->marker = notParent;
if (notParent->children != NULL)
{ PosEntryRetractBeta(theEnv,execStatus,notParent,notParent->children); }
/*
if (notParent->dependents != NULL)
{ RemoveLogicalSupport(theEnv,execStatus,notParent); } */
}
}
}
static void EmptyDrive(
void *theEnv,
struct joinNode *join,
struct partialMatch *rhsBinds)
{
struct partialMatch *linker, *existsParent = NULL, *notParent;
struct joinLink *listOfJoins;
int joinExpr;
unsigned long hashValue;
struct partialMatch *oldLHSBinds;
struct partialMatch *oldRHSBinds;
struct joinNode *oldJoin;
/*======================================================*/
/* Determine if the alpha memory partial match satifies */
/* the join expression. If it doesn't then no further */
/* action is taken. */
/*======================================================*/
join->memoryCompares++;
if (join->networkTest != NULL)
{
#if DEVELOPER
EngineData(theEnv)->rightToLeftComparisons++;
#endif
oldLHSBinds = EngineData(theEnv)->GlobalLHSBinds;
oldRHSBinds = EngineData(theEnv)->GlobalRHSBinds;
oldJoin = EngineData(theEnv)->GlobalJoin;
EngineData(theEnv)->GlobalLHSBinds = NULL;
EngineData(theEnv)->GlobalRHSBinds = rhsBinds;
EngineData(theEnv)->GlobalJoin = join;
joinExpr = EvaluateJoinExpression(theEnv,join->networkTest,join);
EvaluationData(theEnv)->EvaluationError = FALSE;
EngineData(theEnv)->GlobalLHSBinds = oldLHSBinds;
EngineData(theEnv)->GlobalRHSBinds = oldRHSBinds;
EngineData(theEnv)->GlobalJoin = oldJoin;
if (joinExpr == FALSE) return;
}
if (join->secondaryNetworkTest != NULL)
{
#if DEVELOPER
EngineData(theEnv)->rightToLeftComparisons++;
#endif
oldLHSBinds = EngineData(theEnv)->GlobalLHSBinds;
oldRHSBinds = EngineData(theEnv)->GlobalRHSBinds;
oldJoin = EngineData(theEnv)->GlobalJoin;
EngineData(theEnv)->GlobalLHSBinds = NULL;
EngineData(theEnv)->GlobalRHSBinds = rhsBinds;
EngineData(theEnv)->GlobalJoin = join;
joinExpr = EvaluateJoinExpression(theEnv,join->secondaryNetworkTest,join);
EvaluationData(theEnv)->EvaluationError = FALSE;
EngineData(theEnv)->GlobalLHSBinds = oldLHSBinds;
EngineData(theEnv)->GlobalRHSBinds = oldRHSBinds;
EngineData(theEnv)->GlobalJoin = oldJoin;
if (joinExpr == FALSE) return;
}
/*========================================================*/
/* Handle a negated first pattern or join from the right. */
/*========================================================*/
if (join->patternIsNegated || (join->joinFromTheRight && (! join->patternIsExists))) /* reorder to remove patternIsExists test */
{
notParent = join->leftMemory->beta[0];
if (notParent->marker != NULL)
{ return; }
AddBlockedLink(notParent,rhsBinds);
if (notParent->children != NULL)
{ PosEntryRetractBeta(theEnv,notParent,notParent->children); }
/*
if (notParent->dependents != NULL)
{ RemoveLogicalSupport(theEnv,notParent); }
*/
return;
}
/*=====================================================*/
/* For exists CEs used as the first pattern of a rule, */
/* a special partial match in the left memory of the */
/* join is used to track the RHS partial match */
/* satisfying the CE. */
/*=====================================================*/
/* TBD reorder */
if (join->patternIsExists)
{
existsParent = join->leftMemory->beta[0];
if (existsParent->marker != NULL)
{ return; }
AddBlockedLink(existsParent,rhsBinds);
}
/*============================================*/
/* Send the partial match to all child joins. */
/*============================================*/
listOfJoins = join->nextLinks;
if (listOfJoins == NULL) return;
while (listOfJoins != NULL)
{
/*===================================================================*/
/* An exists CE as the first pattern of a rule can generate at most */
/* one partial match, so if there's already a partial match in the */
/* beta memory nothing further needs to be done. Since there are no */
/* variable bindings which child joins can use for indexing, the */
/* partial matches will always be stored in the bucket with index 0. */
/* Although an exists is associated with a specific fact/instance */
/* (through its rightParent link) that allows it to be satisfied, */
/* the bindings in the partial match will be empty for this CE. */
/*===================================================================*/
if (join->patternIsExists)
{ linker = CreateEmptyPartialMatch(theEnv); }
/*=============================================================*/
/* Othewise just copy the partial match from the alpha memory. */
/*=============================================================*/
else
{ linker = CopyPartialMatch(theEnv,rhsBinds); }
/*================================================*/
/* Determine the hash value of the partial match. */
/*================================================*/
if (listOfJoins->enterDirection == LHS)
{
if (listOfJoins->join->leftHash != NULL)
{ hashValue = BetaMemoryHashValue(theEnv,listOfJoins->join->leftHash,linker,NULL,listOfJoins->join); }
else
{ hashValue = 0; }
}
else
{
if (listOfJoins->join->rightHash != NULL)
{ hashValue = BetaMemoryHashValue(theEnv,listOfJoins->join->rightHash,linker,NULL,listOfJoins->join); }
else
{ hashValue = 0; }
}
/*=======================================================*/
/* Add the partial match to the beta memory of the join. */
/*=======================================================*/
if (join->patternIsExists)
{ UpdateBetaPMLinks(theEnv,linker,existsParent,NULL,listOfJoins->join,hashValue,listOfJoins->enterDirection); }
else
{ UpdateBetaPMLinks(theEnv,linker,NULL,rhsBinds,listOfJoins->join,hashValue,listOfJoins->enterDirection); }
if (listOfJoins->enterDirection == LHS)
{ NetworkAssertLeft(theEnv,linker,listOfJoins->join); }
else
{ NetworkAssertRight(theEnv,linker,listOfJoins->join); }
listOfJoins = listOfJoins->next;
}
}
globle void NetworkAssertRight(
void *theEnv,
struct partialMatch *rhsBinds,
struct joinNode *join)
{
struct partialMatch *lhsBinds, *nextBind;
int exprResult, restore = FALSE;
struct partialMatch *oldLHSBinds = NULL;
struct partialMatch *oldRHSBinds = NULL;
struct joinNode *oldJoin = NULL;
/*=========================================================*/
/* 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
if (join->firstJoin)
{
EmptyDrive(theEnv,join,rhsBinds);
return;
}
/*=====================================================*/
/* The partial matches entering from the LHS of a join */
/* are stored in the left beta memory of the join. */
/*=====================================================*/
lhsBinds = GetLeftBetaMemory(join,rhsBinds->hashValue);
#if DEVELOPER
if (lhsBinds != NULL)
{ EngineData(theEnv)->rightToLeftLoops++; }
#endif
/*====================================*/
/* Set up the evaluation environment. */
/*====================================*/
if (lhsBinds != NULL)
{
oldLHSBinds = EngineData(theEnv)->GlobalLHSBinds;
oldRHSBinds = EngineData(theEnv)->GlobalRHSBinds;
oldJoin = EngineData(theEnv)->GlobalJoin;
EngineData(theEnv)->GlobalRHSBinds = rhsBinds;
EngineData(theEnv)->GlobalJoin = join;
restore = TRUE;
}
/*===================================================*/
/* Compare each set of binds on the opposite side of */
/* the join with the set of binds that entered this */
/* join. If the binds don't mismatch, then perform */
/* the appropriate action for the logic of the join. */
/*===================================================*/
while (lhsBinds != NULL)
{
nextBind = lhsBinds->nextInMemory;
join->memoryCompares++;
/*===========================================================*/
/* Initialize some variables pointing to the partial matches */
/* in the LHS and RHS of the join. */
/*===========================================================*/
if (lhsBinds->hashValue != rhsBinds->hashValue)
{
#if DEVELOPER
if (join->leftMemory->size == 1)
{ EngineData(theEnv)->betaHashListSkips++; }
else
{ EngineData(theEnv)->betaHashHTSkips++; }
if (lhsBinds->marker != NULL)
{ EngineData(theEnv)->unneededMarkerCompare++; }
#endif
lhsBinds = nextBind;
continue;
}
/*===============================================================*/
/* If there already is an associated RHS partial match stored in */
/* the LHS partial match from the beta memory of this join, then */
/* the exists/nand CE has already been satisfied and we can move */
/* on to the next partial match found in the beta memory. */
/*===============================================================*/
if (lhsBinds->marker != NULL)
{
#if DEVELOPER
EngineData(theEnv)->unneededMarkerCompare++;
#endif
lhsBinds = nextBind;
continue;
}
/*===================================================*/
/* If the join has no expression associated with it, */
/* then the new partial match derived from the LHS */
/* and RHS partial matches is valid. */
/*===================================================*/
if (join->networkTest == NULL)
{ exprResult = TRUE; }
/*=========================================================*/
/* If the join has an expression associated with it, then */
/* evaluate the expression to determine if the new partial */
/* match derived from the LHS and RHS partial matches is */
/* valid (i.e. variable bindings are consistent and */
/* predicate expressions evaluate to TRUE). */
/*=========================================================*/
else
{
#if DEVELOPER
EngineData(theEnv)->rightToLeftComparisons++;
#endif
EngineData(theEnv)->GlobalLHSBinds = lhsBinds;
exprResult = EvaluateJoinExpression(theEnv,join->networkTest,join);
if (EvaluationData(theEnv)->EvaluationError)
{
if (join->patternIsNegated) exprResult = TRUE;
SetEvaluationError(theEnv,FALSE);
}
#if DEVELOPER
if (exprResult)
{ EngineData(theEnv)->rightToLeftSucceeds++; }
#endif
}
if ((join->secondaryNetworkTest != NULL) && exprResult)
{
EngineData(theEnv)->GlobalLHSBinds = lhsBinds;
exprResult = EvaluateJoinExpression(theEnv,join->secondaryNetworkTest,join);
if (EvaluationData(theEnv)->EvaluationError)
{ SetEvaluationError(theEnv,FALSE); }
}
/*====================================================*/
/* If the join expression evaluated to TRUE (i.e. */
/* there were no conflicts between variable bindings, */
/* all tests were satisfied, etc.), then perform the */
/* appropriate action given the logic of this join. */
/*====================================================*/
if (exprResult != FALSE)
{
if (join->patternIsExists)
{
AddBlockedLink(lhsBinds,rhsBinds);
PPDrive(theEnv,lhsBinds,NULL,join);
}
else if (join->patternIsNegated || join->joinFromTheRight)
{
AddBlockedLink(lhsBinds,rhsBinds);
if (lhsBinds->children != NULL)
{ PosEntryRetractBeta(theEnv,lhsBinds,lhsBinds->children); }
/*
if (lhsBinds->dependents != NULL)
{ RemoveLogicalSupport(theEnv,lhsBinds); }
*/
}
else
{ PPDrive(theEnv,lhsBinds,rhsBinds,join); }
}
/*====================================*/
/* Move on to the next partial match. */
/*====================================*/
lhsBinds = nextBind;
}
/*=========================================*/
/* Restore the old evaluation environment. */
/*=========================================*/
if (restore)
{
EngineData(theEnv)->GlobalLHSBinds = oldLHSBinds;
EngineData(theEnv)->GlobalRHSBinds = oldRHSBinds;
EngineData(theEnv)->GlobalJoin = oldJoin;
}
return;
}