static struct expr *StandardLoadFact(
void *theEnv,
char *logicalName,
struct token *theToken)
{
int error = FALSE;
struct expr *temp;
GetToken(theEnv,logicalName,theToken);
if (theToken->type != LPAREN) return(NULL);
temp = GenConstant(theEnv,FCALL,FindFunction(theEnv,(char*)"assert"));
temp->argList = GetRHSPattern(theEnv,logicalName,theToken,&error,
TRUE,FALSE,TRUE,RPAREN);
if (error == TRUE)
{
EnvPrintRouter(theEnv,WERROR,(char*)"Function load-facts encountered an error\n");
SetEvaluationError(theEnv,TRUE);
ReturnExpression(theEnv,temp);
return(NULL);
}
if (ExpressionContainsVariables(temp,TRUE))
{
ReturnExpression(theEnv,temp);
return(NULL);
}
return(temp);
}
globle struct expr *BuildRHSAssert(
char *logicalName,
struct token *theToken,
int *error,
int atLeastOne,
int readFirstParen,
char *whereParsed)
{
struct expr *lastOne, *nextOne, *assertList, *stub;
*error = FALSE;
/*===============================================================*/
/* If the first parenthesis of the RHS fact pattern has not been */
/* read yet, then get the next token. If a right parenthesis is */
/* encountered then exit (however, set the error return value if */
/* at least one fact was expected). */
/*===============================================================*/
if (readFirstParen == FALSE)
{
if (theToken->type == RPAREN)
{
if (atLeastOne)
{
*error = TRUE;
SyntaxErrorMessage(whereParsed);
}
return(NULL);
}
}
/*================================================*/
/* Parse the facts until no more are encountered. */
/*================================================*/
lastOne = assertList = NULL;
while ((nextOne = GetRHSPattern(logicalName,theToken,
error,FALSE,readFirstParen,
TRUE,RPAREN)) != NULL)
{
PPCRAndIndent();
stub = GenConstant(FCALL,(void *) FindFunction("assert"));
stub->argList = nextOne;
nextOne = stub;
if (lastOne == NULL)
{ assertList = nextOne; }
else
{ lastOne->nextArg = nextOne; }
lastOne = nextOne;
readFirstParen = TRUE;
}
/*======================================================*/
/* If an error was detected while parsing, then return. */
/*======================================================*/
if (*error)
{
ReturnExpression(assertList);
return(NULL);
}
/*======================================*/
/* Fix the pretty print representation. */
/*======================================*/
if (theToken->type == RPAREN)
{
PPBackup();
PPBackup();
SavePPBuffer(")");
}
/*==============================================================*/
/* If no facts are being asserted then return NULL. In addition */
/* if at least one fact was required, then signal an error. */
/*==============================================================*/
if (assertList == NULL)
{
if (atLeastOne)
{
*error = TRUE;
SyntaxErrorMessage(whereParsed);
}
return(NULL);
}
/*===============================================*/
/* If more than one fact is being asserted, then */
/* wrap the assert commands within a progn call. */
/*===============================================*/
if (assertList->nextArg != NULL)
{
stub = GenConstant(FCALL,(void *) FindFunction("progn"));
stub->argList = assertList;
assertList = stub;
}
/*==========================================================*/
/* Return the expression for asserting the specified facts. */
/*==========================================================*/
return(assertList);
}
globle struct fact *StringToFact(
char *str)
{
struct token theToken;
struct fact *factPtr;
int numberOfFields = 0, whichField;
struct expr *assertArgs, *tempPtr;
int error = FALSE;
DATA_OBJECT theResult;
/*=========================================*/
/* Open a string router and parse the fact */
/* using the router as an input source. */
/*=========================================*/
OpenStringSource("assert_str",str,0);
assertArgs = GetRHSPattern("assert_str",&theToken,
&error,FALSE,TRUE,
TRUE,RPAREN);
CloseStringSource("assert_str");
/*===========================================*/
/* Check for errors or the use of variables. */
/*===========================================*/
if (error)
{
ReturnExpression(assertArgs);
return(NULL);
}
if (ExpressionContainsVariables(assertArgs,FALSE))
{
LocalVariableErrorMessage("the assert-string function");
SetEvaluationError(TRUE);
ReturnExpression(assertArgs);
return(NULL);
}
/*=======================================================*/
/* Count the number of fields needed for the fact and */
/* create a fact data structure of the appropriate size. */
/*=======================================================*/
for (tempPtr = assertArgs->nextArg; tempPtr != NULL; tempPtr = tempPtr->nextArg)
{ numberOfFields++; }
factPtr = (struct fact *) CreateFactBySize(numberOfFields);
factPtr->whichDeftemplate = (struct deftemplate *) assertArgs->value;
/*=============================================*/
/* Copy the fields to the fact data structure. */
/*=============================================*/
whichField = 0;
for (tempPtr = assertArgs->nextArg; tempPtr != NULL; tempPtr = tempPtr->nextArg)
{
EvaluateExpression(tempPtr,&theResult);
factPtr->theProposition.theFields[whichField].type = (short) theResult.type;
factPtr->theProposition.theFields[whichField].value = theResult.value;
whichField++;
}
ReturnExpression(assertArgs);
/*==================*/
/* Return the fact. */
/*==================*/
return(factPtr);
}
globle struct fact *StringToFact(
char *str)
{
struct token theToken;
struct fact *factPtr;
int numberOfFields = 0, whichField;
struct expr *assertArgs, *tempPtr;
int error = FALSE;
DATA_OBJECT theResult;
/*=========================================*/
/* Open a string router and parse the fact */
/* using the router as an input source. */
/*=========================================*/
OpenStringSource("assert_str",str,0);
assertArgs = GetRHSPattern("assert_str",&theToken,
&error,FALSE,TRUE,
TRUE,RPAREN);
CloseStringSource("assert_str");
#if CERTAINTY_FACTORS
/* GetRHSPattern called above may have left a token
in the lookahead Token (theUnToken) -- see GetRHSPattern and
Scanner.c -- clear it since we are closing the string source
and it should not be read when next token requested
NOTE: this may not be needed now that am not unGetting STOP tokens?
*/
ClearTheUnToken();
#endif
/*===========================================*/
/* Check for errors or the use of variables. */
/*===========================================*/
if (error)
{
ReturnExpression(assertArgs);
return(NULL);
}
if (ExpressionContainsVariables(assertArgs,FALSE))
{
LocalVariableErrorMessage("the assert-string function");
SetEvaluationError(TRUE);
ReturnExpression(assertArgs);
return(NULL);
}
/*=======================================================*/
/* Count the number of fields needed for the fact and */
/* create a fact data structure of the appropriate size. */
/*=======================================================*/
for (tempPtr = assertArgs->nextArg; tempPtr != NULL; tempPtr = tempPtr->nextArg)
{ numberOfFields++; }
factPtr = (struct fact *) CreateFactBySize(numberOfFields);
factPtr->whichDeftemplate = (struct deftemplate *) assertArgs->value;
#if CERTAINTY_FACTORS
/* get the CF from the argList of the DEFTEMPLATE_PTR expr struct currently
pointed at be assertArgs
*/
if (assertArgs->argList == NULL)
factPtr->factCF = 1.0;
else
{
EvaluateExpression(assertArgs->argList,&theResult);
if (theResult.type != FLOAT && theResult.type != INTEGER)
{
cfNonNumberError();
factPtr->factCF = 1.0;
}
else
factPtr->factCF = (theResult.type == FLOAT) ?
ValueToDouble(theResult.value) :
(double)ValueToLong(theResult.value);
}
#endif
/*=============================================*/
/* Copy the fields to the fact data structure. */
/*=============================================*/
ExpressionInstall(assertArgs); /* DR0836 */
whichField = 0;
for (tempPtr = assertArgs->nextArg; tempPtr != NULL; tempPtr = tempPtr->nextArg)
{
#if FUZZY_DEFTEMPLATES /* 03-07-96 */
/* NOTE: a fuzzy fact should have been parsed to give a single constant arg
of type FUZZY_VALUE
*/
#endif
EvaluateExpression(tempPtr,&theResult);
factPtr->theProposition.theFields[whichField].type = (short) theResult.type;
factPtr->theProposition.theFields[whichField].value = theResult.value;
whichField++;
}
ExpressionDeinstall(assertArgs); /* DR0836 */
ReturnExpression(assertArgs);
/*==================*/
/* Return the fact. */
/*==================*/
return(factPtr);
}