static struct lhsParseNode *TestPattern(
void *theEnv,
EXEC_STATUS,
char *readSource,
int *error)
{
struct lhsParseNode *theNode;
struct token theToken;
struct expr *theExpression;
/*================================================*/
/* Create the data specification for the test CE. */
/*================================================*/
SavePPBuffer(theEnv,execStatus," ");
theNode = GetLHSParseNode(theEnv,execStatus);
theNode->type = TEST_CE;
theExpression = Function0Parse(theEnv,execStatus,readSource);
theNode->expression = ExpressionToLHSParseNodes(theEnv,execStatus,theExpression);
ReturnExpression(theEnv,execStatus,theExpression);
if (theNode->expression == NULL)
{
*error = TRUE;
ReturnLHSParseNodes(theEnv,execStatus,theNode);
return(NULL);
}
/*=========================================================*/
/* Check for the closing right parenthesis of the test CE. */
/*=========================================================*/
GetToken(theEnv,execStatus,readSource,&theToken);
if (theToken.type != RPAREN)
{
SyntaxErrorMessage(theEnv,execStatus,"test conditional element");
*error = TRUE;
ReturnLHSParseNodes(theEnv,execStatus,theNode);
return(NULL);
}
/*=====================*/
/* Return the test CE. */
/*=====================*/
return(theNode);
}
static struct lhsParseNode *LiteralRestrictionParse(
char *readSource,
struct token *theToken,
int *error)
{
struct lhsParseNode *topNode;
struct expr *theExpression;
/*============================================*/
/* Create a node to represent the constraint. */
/*============================================*/
topNode = GetLHSParseNode();
/*=================================================*/
/* Determine if the constraint has a '~' preceding */
/* it. If it does, then the field is negated */
/* (e.g. ~red means "not the constant red." */
/*=================================================*/
if (theToken->type == NOT_CONSTRAINT)
{
GetToken(readSource,theToken);
topNode->negated = TRUE;
}
else
{ topNode->negated = FALSE; }
/*===========================================*/
/* Determine if the constraint is one of the */
/* recognized types. These are ?variables, */
/* symbols, strings, numbers, :(expression), */
/* and =(expression). */
/*===========================================*/
topNode->type = theToken->type;
/*============================================*/
/* Any symbol is valid, but an = signifies a */
/* return value constraint and an : signifies */
/* a predicate constraint. */
/*============================================*/
if (theToken->type == SYMBOL)
{
/*==============================*/
/* If the symbol is an =, parse */
/* a return value constraint. */
/*==============================*/
if (strcmp(ValueToString(theToken->value),"=") == 0)
{
theExpression = Function0Parse(readSource);
if (theExpression == NULL)
{
*error = TRUE;
ReturnLHSParseNodes(topNode);
return(NULL);
}
topNode->type = RETURN_VALUE_CONSTRAINT;
topNode->expression = ExpressionToLHSParseNodes(theExpression);
ReturnExpression(theExpression);
}
/*=============================*/
/* If the symbol is a :, parse */
/* a predicate constraint. */
/*=============================*/
else if (strcmp(ValueToString(theToken->value),":") == 0)
{
theExpression = Function0Parse(readSource);
if (theExpression == NULL)
{
*error = TRUE;
ReturnLHSParseNodes(topNode);
return(NULL);
}
topNode->type = PREDICATE_CONSTRAINT;
topNode->expression = ExpressionToLHSParseNodes(theExpression);
ReturnExpression(theExpression);
}
/*==============================================*/
/* Otherwise, treat the constraint as a symbol. */
/*==============================================*/
else
{ topNode->value = theToken->value; }
}
/*=====================================================*/
/* Single and multifield variables and float, integer, */
/* string, and instance name constants are also valid. */
/*=====================================================*/
else if ((theToken->type == SF_VARIABLE) ||
(theToken->type == MF_VARIABLE) ||
(theToken->type == FLOAT) ||
(theToken->type == INTEGER) ||
(theToken->type == STRING) ||
(theToken->type == INSTANCE_NAME))
{ topNode->value = theToken->value; }
/*===========================*/
/* Anything else is invalid. */
/*===========================*/
else
{
SyntaxErrorMessage("defrule");
*error = TRUE;
ReturnLHSParseNodes(topNode);
return(NULL);
}
/*===============================*/
/* Return the parsed constraint. */
/*===============================*/
return(topNode);
}
globle struct expr *GetAssertArgument(
char *logicalName,
struct token *theToken,
int *error,
int endType,
int constantsOnly,
int *printError)
{
struct expr *nextField;
/*=================================================*/
/* Read in the first token of the slot's value. If */
/* the end delimiter is encountered, then return. */
/*=================================================*/
*printError = TRUE;
GetToken(logicalName,theToken);
if (theToken->type == endType) return(NULL);
/*=============================================================*/
/* If an equal sign of left parenthesis was parsed, then parse */
/* a function which is to be evaluated to determine the slot's */
/* value. The equal sign corresponds to the return value */
/* constraint which can be used in LHS fact patterns. The */
/* equal sign is no longer necessary on either the LHS or RHS */
/* of a rule to indicate that a function is being evaluated to */
/* determine its value either for assignment or pattern */
/* matching. */
/*=============================================================*/
if ((theToken->type == SYMBOL) ?
(strcmp(ValueToString(theToken->value),"=") == 0) :
(theToken->type == LPAREN))
{
if (constantsOnly)
{
*error = TRUE;
return(NULL);
}
#if ! RUN_TIME
if (theToken->type == LPAREN) nextField = Function1Parse(logicalName);
else nextField = Function0Parse(logicalName);
if (nextField == NULL)
#endif
{
*printError = FALSE;
*error = TRUE;
}
#if ! RUN_TIME
else
{
theToken->type= RPAREN;
theToken->value = (void *) AddSymbol(")");
theToken->printForm = ")";
}
#endif
return(nextField);
}
/*==================================================*/
/* Constants are always allowed as RHS slot values. */
/*==================================================*/
if ((theToken->type == SYMBOL) || (theToken->type == STRING) ||
#if OBJECT_SYSTEM
(theToken->type == INSTANCE_NAME) ||
#endif
(theToken->type == FLOAT) || (theToken->type == INTEGER))
{ return(GenConstant(theToken->type,theToken->value)); }
/*========================================*/
/* Variables are also allowed as RHS slot */
/* values under some circumstances. */
/*========================================*/
if ((theToken->type == SF_VARIABLE) ||
#if DEFGLOBAL_CONSTRUCT
(theToken->type == GBL_VARIABLE) ||
(theToken->type == MF_GBL_VARIABLE) ||
#endif
(theToken->type == MF_VARIABLE))
{
if (constantsOnly)
{
*error = TRUE;
return(NULL);
}
return(GenConstant(theToken->type,theToken->value));
}
/*==========================================================*/
/* If none of the other cases have been satisfied, then the */
/* token parsed is not appropriate for a RHS slot value. */
/*==========================================================*/
*error = TRUE;
return(NULL);
}
