static struct defrule *ProcessRuleLHS(
void *theEnv,
struct lhsParseNode *theLHS,
struct expr *actions,
SYMBOL_HN *ruleName,
int *error)
{
struct lhsParseNode *tempNode = NULL;
struct defrule *topDisjunct = NULL, *currentDisjunct, *lastDisjunct = NULL;
struct expr *newActions, *packPtr;
int logicalJoin;
int localVarCnt;
int complexity;
struct joinNode *lastJoin;
intBool emptyLHS;
/*================================================*/
/* Initially set the parsing error flag to FALSE. */
/*================================================*/
*error = FALSE;
/*===========================================================*/
/* The top level of the construct representing the LHS of a */
/* rule is assumed to be an OR. If the implied OR is at the */
/* top level of the pattern construct, then remove it. */
/*===========================================================*/
if (theLHS == NULL)
{ emptyLHS = TRUE; }
else
{
emptyLHS = FALSE;
if (theLHS->type == OR_CE) theLHS = theLHS->right;
}
/*=========================================*/
/* Loop through each disjunct of the rule. */
/*=========================================*/
localVarCnt = CountParsedBindNames(theEnv);
while ((theLHS != NULL) || (emptyLHS == TRUE))
{
/*===================================*/
/* Analyze the LHS of this disjunct. */
/*===================================*/
if (emptyLHS)
{ tempNode = NULL; }
else
{
if (theLHS->type == AND_CE) tempNode = theLHS->right;
else if (theLHS->type == PATTERN_CE) tempNode = theLHS;
}
if (VariableAnalysis(theEnv,tempNode))
{
*error = TRUE;
ReturnDefrule(theEnv,topDisjunct);
return(NULL);
}
/*=========================================*/
/* Perform entity dependent post analysis. */
/*=========================================*/
if (PostPatternAnalysis(theEnv,tempNode))
{
*error = TRUE;
ReturnDefrule(theEnv,topDisjunct);
return(NULL);
}
/*========================================================*/
/* Print out developer information if it's being watched. */
/*========================================================*/
#if DEVELOPER && DEBUGGING_FUNCTIONS
if (EnvGetWatchItem(theEnv,"rule-analysis"))
{ DumpRuleAnalysis(theEnv,tempNode); }
#endif
/*========================================*/
/* Check to see that logical CEs are used */
/* appropriately in the LHS of the rule. */
/*========================================*/
if ((logicalJoin = LogicalAnalysis(theEnv,tempNode)) < 0)
{
*error = TRUE;
ReturnDefrule(theEnv,topDisjunct);
return(NULL);
}
/*======================================================*/
/* Check to see if there are any RHS constraint errors. */
/*======================================================*/
if (CheckRHSForConstraintErrors(theEnv,actions,tempNode))
{
*error = TRUE;
ReturnDefrule(theEnv,topDisjunct);
return(NULL);
}
/*=================================================*/
/* Replace variable references in the RHS with the */
/* appropriate variable retrieval functions. */
/*=================================================*/
newActions = CopyExpression(theEnv,actions);
if (ReplaceProcVars(theEnv,"RHS of defrule",newActions,NULL,NULL,
ReplaceRHSVariable,(void *) tempNode))
{
*error = TRUE;
ReturnDefrule(theEnv,topDisjunct);
ReturnExpression(theEnv,newActions);
return(NULL);
}
/*==================================*/
/* We're finished for this disjunct */
/* if we're only checking syntax. */
/*==================================*/
if (ConstructData(theEnv)->CheckSyntaxMode)
{
ReturnExpression(theEnv,newActions);
if (emptyLHS)
{ emptyLHS = FALSE; }
else
{ theLHS = theLHS->bottom; }
continue;
}
/*=================================*/
/* Install the disjunct's actions. */
/*=================================*/
ExpressionInstall(theEnv,newActions);
packPtr = PackExpression(theEnv,newActions);
ReturnExpression(theEnv,newActions);
/*===============================================================*/
/* Create the pattern and join data structures for the new rule. */
/*===============================================================*/
lastJoin = ConstructJoins(theEnv,logicalJoin,tempNode,1,NULL,TRUE,TRUE);
/*===================================================================*/
/* Determine the rule's complexity for use with conflict resolution. */
/*===================================================================*/
complexity = RuleComplexity(theEnv,tempNode);
/*=====================================================*/
/* Create the defrule data structure for this disjunct */
/* and put it in the list of disjuncts for this rule. */
/*=====================================================*/
currentDisjunct = CreateNewDisjunct(theEnv,ruleName,localVarCnt,packPtr,complexity,
(unsigned) logicalJoin,lastJoin);
/*============================================================*/
/* Place the disjunct in the list of disjuncts for this rule. */
/* If the disjunct is the first disjunct, then increment the */
/* reference counts for the dynamic salience (the expression */
/* for the dynamic salience is only stored with the first */
/* disjuncts and the other disjuncts refer back to the first */
/* disjunct for their dynamic salience value. */
/*============================================================*/
if (topDisjunct == NULL)
{
topDisjunct = currentDisjunct;
ExpressionInstall(theEnv,topDisjunct->dynamicSalience);
}
else lastDisjunct->disjunct = currentDisjunct;
/*===========================================*/
/* Move on to the next disjunct of the rule. */
/*===========================================*/
lastDisjunct = currentDisjunct;
if (emptyLHS)
{ emptyLHS = FALSE; }
else
{ theLHS = theLHS->bottom; }
}
return(topDisjunct);
}
static struct defrule *ProcessRuleLHS(
void *theEnv,
struct lhsParseNode *theLHS,
struct expr *actions,
SYMBOL_HN *ruleName,
int *error)
{
struct lhsParseNode *tempNode = NULL;
struct defrule *topDisjunct = NULL, *currentDisjunct, *lastDisjunct = NULL;
struct expr *newActions, *packPtr;
int logicalJoin;
int localVarCnt;
int complexity;
struct joinNode *lastJoin;
intBool emptyLHS;
/*================================================*/
/* Initially set the parsing error flag to FALSE. */
/*================================================*/
*error = FALSE;
/*===========================================================*/
/* The top level of the construct representing the LHS of a */
/* rule is assumed to be an OR. If the implied OR is at the */
/* top level of the pattern construct, then remove it. */
/*===========================================================*/
if (theLHS == NULL)
{ emptyLHS = TRUE; }
else
{
emptyLHS = FALSE;
if (theLHS->type == OR_CE) theLHS = theLHS->right;
}
/*=========================================*/
/* Loop through each disjunct of the rule. */
/*=========================================*/
localVarCnt = CountParsedBindNames(theEnv);
while ((theLHS != NULL) || (emptyLHS == TRUE))
{
#if FUZZY_DEFTEMPLATES
unsigned int LHSRuleType; /* LHSRuleType is set to FUZZY_LHS or CRISP_LHS */
unsigned int numFuzzySlots;
int patternNum;
#endif
/*===================================*/
/* Analyze the LHS of this disjunct. */
/*===================================*/
if (emptyLHS)
{ tempNode = NULL; }
else
{
if (theLHS->type == AND_CE) tempNode = theLHS->right;
else if (theLHS->type == PATTERN_CE) tempNode = theLHS;
}
if (VariableAnalysis(theEnv,tempNode))
{
*error = TRUE;
ReturnDefrule(theEnv,topDisjunct);
return(NULL);
}
/*=========================================*/
/* Perform entity dependent post analysis. */
/*=========================================*/
if (PostPatternAnalysis(theEnv,tempNode))
{
*error = TRUE;
ReturnDefrule(theEnv,topDisjunct);
return(NULL);
}
#if FUZZY_DEFTEMPLATES
/* calculate the number of fuzzy value slots in patterns with
the rule disjunct and also determine LHS type of the
rule -- if number of fuzzy slots in non-NOT patterns >0
then FUZZY LHS [if pattern is (not (xxx (fuzzySlot ...) ...))
then they don't count when considering the LHS type]
*/
if (emptyLHS)
{ tempNode = NULL; }
else
{
if (theLHS->type == AND_CE) tempNode = theLHS->right;
else if (theLHS->type == PATTERN_CE) tempNode = theLHS;
}
{
int numFuzzySlotsInNonNotPatterns = 0;
numFuzzySlots = FuzzySlotAnalysis(theEnv,tempNode, &numFuzzySlotsInNonNotPatterns);
if (numFuzzySlotsInNonNotPatterns > 0)
LHSRuleType = FUZZY_LHS;
else
LHSRuleType = CRISP_LHS;
}
#endif
/*========================================================*/
/* Print out developer information if it's being watched. */
/*========================================================*/
#if DEVELOPER && DEBUGGING_FUNCTIONS
if (EnvGetWatchItem(theEnv,"rule-analysis"))
{ DumpRuleAnalysis(theEnv,tempNode); }
#endif
/*======================================================*/
/* Check to see if there are any RHS constraint errors. */
/*======================================================*/
if (CheckRHSForConstraintErrors(theEnv,actions,tempNode))
{
*error = TRUE;
ReturnDefrule(theEnv,topDisjunct);
return(NULL);
}
/*=================================================*/
/* Replace variable references in the RHS with the */
/* appropriate variable retrieval functions. */
/*=================================================*/
newActions = CopyExpression(theEnv,actions);
if (ReplaceProcVars(theEnv,"RHS of defrule",newActions,NULL,NULL,
ReplaceRHSVariable,(void *) tempNode))
{
*error = TRUE;
ReturnDefrule(theEnv,topDisjunct);
ReturnExpression(theEnv,newActions);
return(NULL);
}
/*===================================================*/
/* Remove any test CEs from the LHS and attach their */
/* expression to the closest preceeding non-negated */
/* join at the same not/and depth. */
/*===================================================*/
AttachTestCEsToPatternCEs(theEnv,tempNode);
/*========================================*/
/* Check to see that logical CEs are used */
/* appropriately in the LHS of the rule. */
/*========================================*/
if ((logicalJoin = LogicalAnalysis(theEnv,tempNode)) < 0)
{
*error = TRUE;
ReturnDefrule(theEnv,topDisjunct);
ReturnExpression(theEnv,newActions);
return(NULL);
}
/*==================================*/
/* We're finished for this disjunct */
/* if we're only checking syntax. */
/*==================================*/
if (ConstructData(theEnv)->CheckSyntaxMode)
{
ReturnExpression(theEnv,newActions);
if (emptyLHS)
{ emptyLHS = FALSE; }
else
{ theLHS = theLHS->bottom; }
continue;
}
/*=================================*/
/* Install the disjunct's actions. */
/*=================================*/
ExpressionInstall(theEnv,newActions);
packPtr = PackExpression(theEnv,newActions);
ReturnExpression(theEnv,newActions);
/*===============================================================*/
/* Create the pattern and join data structures for the new rule. */
/*===============================================================*/
lastJoin = ConstructJoins(theEnv,logicalJoin,tempNode,1,NULL,TRUE,TRUE);
/*===================================================================*/
/* Determine the rule's complexity for use with conflict resolution. */
/*===================================================================*/
complexity = RuleComplexity(theEnv,tempNode);
/*=====================================================*/
/* Create the defrule data structure for this disjunct */
/* and put it in the list of disjuncts for this rule. */
/*=====================================================*/
#if FUZZY_DEFTEMPLATES
/* if not a FUZZY LHS then no need to allocate space to store ptrs to
fuzzy slots of the patterns on the LHS since there won't be any
-- numFuzzySlots will be 0.
*/
currentDisjunct = CreateNewDisjunct(theEnv,ruleName,localVarCnt,packPtr,complexity,
logicalJoin,lastJoin,numFuzzySlots);
/* set the type of LHS of Rule disjunct and also
save fuzzy slot locator info for any fuzzy patterns
*/
currentDisjunct->lhsRuleType = LHSRuleType;
if (numFuzzySlots > 0)
{
struct lhsParseNode *lhsPNPtr, *lhsSlotPtr;
int i;
/* get ptr to a pattern CE */
if (theLHS->type == AND_CE) lhsPNPtr = theLHS->right;
else if (theLHS->type == PATTERN_CE) lhsPNPtr = theLHS;
else lhsPNPtr = NULL;
patternNum = 0; /* indexed from 0 */
i = 0;
while (lhsPNPtr != NULL)
{
if (lhsPNPtr->type == PATTERN_CE)
{
lhsSlotPtr = lhsPNPtr->right;
while (lhsSlotPtr != NULL)
{
/*==========================================================*/
/* If fuzzy template slot then save ptr to fuzzy value */
/* */
/* NOTE: when the pattern was added to the pattern net, the */
/* pattern node for the template name was removed (see */
/* PlaceFactPattern) and the pattern node of the FUZZY_VALUE*/
/* was changed a networkTest link in the SF_VARIABLE or */
/* SF_WILDCARD node as an SCALL_PN_FUZZY_VALUE expression. */
/* We need to search for that fuzzy value to put it in the */
/* rule (pattern_fv_arrayPtr points to an array of */
/* structures that holds the pattern number, slot number and*/
/* fuzzy value HN ptrs connected to the patterns of LHS). */
/*==========================================================*/
if (lhsSlotPtr->type == SF_WILDCARD ||
lhsSlotPtr->type == SF_VARIABLE)
{
FUZZY_VALUE_HN *fv_ptr;
struct fzSlotLocator * fzSL_ptr;
fv_ptr = findFuzzyValueInNetworktest(lhsSlotPtr->networkTest);
if (fv_ptr != NULL)
{
fzSL_ptr = currentDisjunct->pattern_fv_arrayPtr + i;
fzSL_ptr->patternNum = patternNum;
fzSL_ptr->slotNum = (lhsSlotPtr->slotNumber)-1;
fzSL_ptr->fvhnPtr = fv_ptr;
i++;
}
}
/*=====================================================*/
/* Move on to the next slot in the pattern. */
/*=====================================================*/
lhsSlotPtr = lhsSlotPtr->right;
}
}
/*=====================================================*/
/* Move on to the next pattern in the LHS of the rule. */
/*=====================================================*/
lhsPNPtr = lhsPNPtr->bottom;
patternNum++;
}
/* i should == numFuzzySlots OR something internal is screwed up --
OR this algorithm has a problem.
*/
if (i != numFuzzySlots)
{
EnvPrintRouter(theEnv,WERROR,"Internal ERROR *** Fuzzy structures -- routine ProcessRuleLHS\n");
EnvExitRouter(theEnv,EXIT_FAILURE);
}
}
#else
currentDisjunct = CreateNewDisjunct(theEnv,ruleName,localVarCnt,packPtr,complexity,
(unsigned) logicalJoin,lastJoin);
#endif
/*============================================================*/
/* Place the disjunct in the list of disjuncts for this rule. */
/* If the disjunct is the first disjunct, then increment the */
/* reference counts for the dynamic salience (the expression */
/* for the dynamic salience is only stored with the first */
/* disjuncts and the other disjuncts refer back to the first */
/* disjunct for their dynamic salience value. */
/*============================================================*/
if (topDisjunct == NULL)
{
topDisjunct = currentDisjunct;
ExpressionInstall(theEnv,topDisjunct->dynamicSalience);
#if CERTAINTY_FACTORS
ExpressionInstall(theEnv,topDisjunct->dynamicCF);
#endif
}
else lastDisjunct->disjunct = currentDisjunct;
/*===========================================*/
/* Move on to the next disjunct of the rule. */
/*===========================================*/
lastDisjunct = currentDisjunct;
if (emptyLHS)
{ emptyLHS = FALSE; }
else
{ theLHS = theLHS->bottom; }
}
return(topDisjunct);
}