{ theDeftemplate = CreateImpliedDeftemplate(theEnv,(SYMBOL_HN *) templateName,TRUE); }     }#else    {     NoSuchTemplateError(theEnv,ValueToString(templateName));     *error = TRUE;     return(NULL);    }#endif   /*=========================================*/   /* If an explicit deftemplate exists, then */   /* parse the fact as a deftemplate fact.   */   /*=========================================*/   if ((theDeftemplate != NULL) && (theDeftemplate->implied == FALSE))     {      firstOne = GenConstant(theEnv,DEFTEMPLATE_PTR,theDeftemplate);      firstOne->nextArg = ParseAssertTemplate(theEnv,readSource,tempToken,                                              error,endType,                                              constantsOnly,theDeftemplate);      if (*error)        {         ReturnExpression(theEnv,firstOne);         firstOne = NULL;        }      return(firstOne);     }   /*========================================*/   /* Parse the fact as an ordered RHS fact. */   /*========================================*/   firstOne = GenConstant(theEnv,DEFTEMPLATE_PTR,theDeftemplate);#if (! RUN_TIME) && (! BLOAD_ONLY)   SavePPBuffer(theEnv," ");#endif   while ((nextOne = GetAssertArgument(theEnv,readSource,tempToken,                                        error,endType,constantsOnly,&printError)) != NULL)     {      if (argHead == NULL) argHead = nextOne;      else lastOne->nextArg = nextOne;      lastOne = nextOne;#if (! RUN_TIME) && (! BLOAD_ONLY)      SavePPBuffer(theEnv," ");#endif     }   /*===========================================================*/   /* If an error occurred, set the error flag and return NULL. */   /*===========================================================*/   if (*error)     {      if (printError) SyntaxErrorMessage(theEnv,"RHS patterns");      ReturnExpression(theEnv,firstOne);      ReturnExpression(theEnv,argHead);      return(NULL);     }   /*=====================================*/   /* Fix the pretty print representation */   /* of the RHS ordered fact.            */   /*=====================================*/#if (! RUN_TIME) && (! BLOAD_ONLY)   PPBackup(theEnv);   PPBackup(theEnv);   SavePPBuffer(theEnv,tempToken->printForm);#endif   /*==========================================================*/   /* Ordered fact assertions are processed by stuffing all of */   /* the fact's proposition (except the relation name) into a */   /* single multifield slot.                                  */   /*==========================================================*/   firstOne->nextArg = GenConstant(theEnv,FACT_STORE_MULTIFIELD,AddBitMap(theEnv,(void *) "\0",1));   firstOne->nextArg->argList = argHead;   /*==============================*/   /* Return the RHS ordered fact. */   /*==============================*/   return(firstOne);  }/********************************************************************//* GetAssertArgument: Parses a single RHS slot value and returns an *//*   expression representing the value. When parsing a deftemplate  *//*   slot, the slot name has already been parsed when this function *//*   is called. NULL is returned if a slot or fact delimiter is     *//*   encountered. In the event of a parse error, the error flag     *//*   passed as an argument is set.                                  *//********************************************************************/globle struct expr *GetAssertArgument(  void *theEnv,  char *logicalName,  struct token *theToken,  int *error,  int endType,  int constantsOnly,  int *printError)  {#if ! RUN_TIME   struct expr *nextField;#else   struct expr *nextField = NULL;#endif   /*=================================================*/   /* Read in the first token of the slot's value. If */   /* the end delimiter is encountered, then return.  */   /*=================================================*/   *printError = TRUE;   GetToken(theEnv,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(theEnv,logicalName);      else nextField = Function0Parse(theEnv,logicalName);      if (nextField == NULL)#endif        {         *printError = FALSE;         *error = TRUE;        }#if ! RUN_TIME      else        {         theToken->type= RPAREN;         theToken->value = (void *) EnvAddSymbol(theEnv,")");         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(theEnv,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(theEnv,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);  }/****************************************************//* StringToFact: Converts the string representation *//*   of a fact to a fact data structure.            *//****************************************************/globle struct fact *StringToFact(  void *theEnv,  char *str)  {   struct token theToken;   struct fact *factPtr;   unsigned 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.    */   /*=========================================*/      SetEvaluationError(theEnv,FALSE);   OpenStringSource(theEnv,"assert_str",str,0);   assertArgs = GetRHSPattern(theEnv,"assert_str",&theToken,                              &error,FALSE,TRUE,                              TRUE,RPAREN);   CloseStringSource(theEnv,"assert_str");   /*===========================================*/   /* Check for errors or the use of variables. */   /*===========================================*/      if ((assertArgs == NULL) && (! error))     {      SyntaxErrorMessage(theEnv,"RHS patterns");      ReturnExpression(theEnv,assertArgs);      return(NULL);     }   if (error)     {      ReturnExpression(theEnv,assertArgs);      return(NULL);     }   if (ExpressionContainsVariables(assertArgs,FALSE))     {      LocalVariableErrorMessage(theEnv,"the assert-string function");      SetEvaluationError(theEnv,TRUE);      ReturnExpression(theEnv,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(theEnv,numberOfFields);   factPtr->whichDeftemplate = (struct deftemplate *) assertArgs->value;   /*=============================================*/   /* Copy the fields to the fact data structure. */   /*=============================================*/   ExpressionInstall(theEnv,assertArgs); /* DR0836 */   whichField = 0;   for (tempPtr = assertArgs->nextArg; tempPtr != NULL; tempPtr = tempPtr->nextArg)     {      EvaluateExpression(theEnv,tempPtr,&theResult);      factPtr->theProposition.theFields[whichField].type = theResult.type;      factPtr->theProposition.theFields[whichField].value = theResult.value;      whichField++;     }   ExpressionDeinstall(theEnv,assertArgs); /* DR0836 */   ReturnExpression(theEnv,assertArgs);   /*==================*/   /* Return the fact. */   /*==================*/   return(factPtr);  }#if RUN_TIME || BLOAD_ONLY || BLOAD || BLOAD_AND_BSAVE/*********************************************************//* NoSuchTemplateError: Prints out an error message      *//* in a BLOAD_ONLY, RUN_TIME or bload active environment *//* when an implied deftemplate cannot be created for     *//* an assert                                             *//*********************************************************/static void NoSuchTemplateError(  void *theEnv,  char *templateName)  {   PrintErrorID(theEnv,"FACTRHS",1,FALSE);   EnvPrintRouter(theEnv,WERROR,"Template ");   EnvPrintRouter(theEnv,WERROR,templateName);   EnvPrintRouter(theEnv,WERROR," does not exist for assert.\n");  }#endif /* RUN_TIME || BLOAD_ONLY || BLOAD || BLOAD_AND_BSAVE */#endif /* DEFTEMPLATE_CONSTRUCT */