/* Return TRUE to indicate that fact slot */   /* values were successfully copied.       */   /*========================================*/   return(TRUE);  }/*********************************************//* CreateFactBySize: Allocates a fact data   *//*   structure based on the number of slots. *//*********************************************/globle struct fact *CreateFactBySize(  void *theEnv,  unsigned size)  {   struct fact *theFact;   unsigned newSize;   if (size <= 0) newSize = 1;   else newSize = size;   theFact = get_var_struct(theEnv,fact,sizeof(struct field) * (newSize - 1));   theFact->depth = (unsigned) EvaluationData(theEnv)->CurrentEvaluationDepth;   theFact->garbage = FALSE;   theFact->factIndex = 0LL;   theFact->factHeader.busyCount = 0;   theFact->factHeader.theInfo = &FactData(theEnv)->FactInfo;   theFact->factHeader.dependents = NULL;   theFact->whichDeftemplate = NULL;   theFact->nextFact = NULL;   theFact->previousFact = NULL;   theFact->previousTemplateFact = NULL;   theFact->nextTemplateFact = NULL;   theFact->list = NULL;   theFact->theProposition.multifieldLength = size;   theFact->theProposition.depth = (short) EvaluationData(theEnv)->CurrentEvaluationDepth;   theFact->theProposition.busyCount = 0;   return(theFact);  }/*********************************************//* ReturnFact: Returns a fact data structure *//*   to the pool of free memory.             *//*********************************************/globle void ReturnFact(  void *theEnv,  struct fact *theFact)  {   struct multifield *theSegment, *subSegment;   long newSize, i;   theSegment = &theFact->theProposition;   for (i = 0; i < theSegment->multifieldLength; i++)     {      if (theSegment->theFields[i].type == MULTIFIELD)        {         subSegment = (struct multifield *) theSegment->theFields[i].value;         if (subSegment->busyCount == 0)           { ReturnMultifield(theEnv,subSegment); }         else           { AddToMultifieldList(theEnv,subSegment); }        }     }   if (theFact->theProposition.multifieldLength == 0) newSize = 1;   else newSize = theFact->theProposition.multifieldLength;         rtn_var_struct(theEnv,fact,sizeof(struct field) * (newSize - 1),theFact);  }/*************************************************************//* FactInstall: Increments the fact, deftemplate, and atomic *//*   data value busy counts associated with the fact.        *//*************************************************************/globle void FactInstall(  void *theEnv,  struct fact *newFact)  {   struct multifield *theSegment;   int i;   FactData(theEnv)->NumberOfFacts++;   newFact->whichDeftemplate->busyCount++;   theSegment = &newFact->theProposition;   for (i = 0 ; i < (int) theSegment->multifieldLength ; i++)     {      AtomInstall(theEnv,theSegment->theFields[i].type,theSegment->theFields[i].value);     }   newFact->factHeader.busyCount++;  }/***************************************************************//* FactDeinstall: Decrements the fact, deftemplate, and atomic *//*   data value busy counts associated with the fact.          *//***************************************************************/globle void FactDeinstall(  void *theEnv,  struct fact *newFact)  {   struct multifield *theSegment;   int i;   FactData(theEnv)->NumberOfFacts--;   theSegment = &newFact->theProposition;   newFact->whichDeftemplate->busyCount--;   for (i = 0 ; i < (int) theSegment->multifieldLength ; i++)     {      AtomDeinstall(theEnv,theSegment->theFields[i].type,theSegment->theFields[i].value);     }   newFact->factHeader.busyCount--;  }/************************************************//* EnvIncrementFactCount: Increments the number *//*   of references to a specified fact.         *//************************************************/#if IBM_TBC#pragma argsused#endifgloble void EnvIncrementFactCount(  void *theEnv,  void *factPtr)  {#if MAC_MCW || IBM_MCW || MAC_XCD#pragma unused(theEnv)#endif   ((struct fact *) factPtr)->factHeader.busyCount++;  }/************************************************//* EnvDecrementFactCount: Decrements the number *//*   of references to a specified fact.         *//************************************************/#if IBM_TBC#pragma argsused#endifgloble void EnvDecrementFactCount(  void *theEnv,  void *factPtr)  {#if MAC_MCW || IBM_MCW || MAC_XCD#pragma unused(theEnv)#endif   ((struct fact *) factPtr)->factHeader.busyCount--;  }/*********************************************************//* EnvGetNextFact: If passed a NULL pointer, returns the *//*   first fact in the fact-list. Otherwise returns the  *//*   next fact following the fact passed as an argument. *//*********************************************************/globle void *EnvGetNextFact(  void *theEnv,  void *factPtr)  {   if (factPtr == NULL)     { return((void *) FactData(theEnv)->FactList); }   if (((struct fact *) factPtr)->garbage) return(NULL);   return((void *) ((struct fact *) factPtr)->nextFact);  }/**************************************************//* GetNextFactInScope: Returns the next fact that *//*   is in scope of the current module. Works in  *//*   a similar fashion to GetNextFact, but skips  *//*   facts that are out of scope.                 *//**************************************************/globle void *GetNextFactInScope(  void *theEnv,  void *vTheFact)  {   struct fact *theFact = (struct fact *) vTheFact;   /*=======================================================*/   /* If fact passed as an argument is a NULL pointer, then */   /* we're just beginning a traversal of the fact list. If */   /* the module index has changed since that last time the */   /* fact list was traversed by this routine, then         */   /* determine all of the deftemplates that are in scope   */   /* of the current module.                                */   /*=======================================================*/   if (theFact == NULL)     {      theFact = FactData(theEnv)->FactList;      if (FactData(theEnv)->LastModuleIndex != DefmoduleData(theEnv)->ModuleChangeIndex)        {         UpdateDeftemplateScope(theEnv);         FactData(theEnv)->LastModuleIndex = DefmoduleData(theEnv)->ModuleChangeIndex;        }     }   /*==================================================*/   /* Otherwise, if the fact passed as an argument has */   /* been retracted, then there's no way to determine */   /* the next fact, so return a NULL pointer.         */   /*==================================================*/   else if (((struct fact *) theFact)->garbage)     { return(NULL); }   /*==================================================*/   /* Otherwise, start the search for the next fact in */   /* scope with the fact immediately following the    */   /* fact passed as an argument.                      */   /*==================================================*/   else     { theFact = theFact->nextFact; }   /*================================================*/   /* Continue traversing the fact-list until a fact */   /* is found that's associated with a deftemplate  */   /* that's in scope.                               */   /*================================================*/   while (theFact != NULL)     {      if (theFact->whichDeftemplate->inScope) return((void *) theFact);      theFact = theFact->nextFact;     }   return(NULL);  }/****************************************//* EnvGetFactPPForm: Returns the pretty *//*   print representation of a fact.    *//****************************************/globle void EnvGetFactPPForm(  void *theEnv,  char *buffer,  unsigned bufferLength,  void *theFact)  {   OpenStringDestination(theEnv,"FactPPForm",buffer,bufferLength);   PrintFactWithIdentifier(theEnv,"FactPPForm",(struct fact *) theFact);   CloseStringDestination(theEnv,"FactPPForm");  }/**********************************//* EnvFactIndex: C access routine *//*   for the fact-index function. *//**********************************/#if IBM_TBC#pragma argsused#endifgloble long long EnvFactIndex(  void *theEnv,  void *factPtr)  {#if MAC_MCW || IBM_MCW || MAC_XCD#pragma unused(theEnv)#endif   return(((struct fact *) factPtr)->factIndex);  }/*************************************//* EnvAssertString: C access routine *//*   for the assert-string function. *//*************************************/globle void *EnvAssertString(  void *theEnv,  char *theString)  {   struct fact *theFact;   if ((theFact = StringToFact(theEnv,theString)) == NULL) return(NULL);   return((void *) EnvAssert(theEnv,(void *) theFact));  }/******************************************************//* EnvGetFactListChanged: Returns the flag indicating *//*   whether a change to the fact-list has been made. *//******************************************************/globle int EnvGetFactListChanged(  void *theEnv)  {   return(FactData(theEnv)->ChangeToFactList);   }/***********************************************************//* EnvSetFactListChanged: Sets the flag indicating whether *//*   a change to the fact-list has been made.              *//***********************************************************/globle void EnvSetFactListChanged(  void *theEnv,  int value)  {   FactData(theEnv)->ChangeToFactList = value;  }/****************************************//* GetNumberOfFacts: Returns the number *//* of facts in the fact-list.           *//****************************************/globle unsigned long GetNumberOfFacts(  void *theEnv)  {      return(FactData(theEnv)->NumberOfFacts);   }/***********************************************************//* ResetFacts: Reset function for facts. Sets the starting *//*   fact index to zero and removes all facts.             *//***********************************************************/static void ResetFacts(  void *theEnv)  {   /*====================================*/   /* Initialize the fact index to zero. */   /*====================================*/   FactData(theEnv)->NextFactIndex = 0L;   /*======================================*/   /* Remove all facts from the fact list. */   /*======================================*/   RemoveAllFacts(theEnv);  }/************************************************************//* ClearFactsReady: Clear ready function for facts. Returns *//*   TRUE if facts were successfully removed and the clear  *//*   command can continue, otherwise FALSE.                 *//************************************************************/static int ClearFactsReady(  void *theEnv)  {   /*====================================*/   /* Initialize the fact index to zero. */   /*====================================*/   FactData(theEnv)->NextFactIndex = 0L;   /*======================================*/   /* Remove all facts from the fact list. */   /*======================================*/   RemoveAllFacts(theEnv);   /*==============================================*/   /* If for some reason there are any facts still */   /* remaining, don't continue with the clear.    */   /*==============================================*/   if (EnvGetNextFact(theEnv,NULL) != NULL) return(FALSE);   /*=============================*/   /* Return TRUE to indicate the */   /* clear command can continue. */   /*=============================*/   return(TRUE);  }/***************************************************//* FindIndexedFact: Returns a pointer to a fact in *//*   the fact list with the specified fact index.  *//***************************************************/globle struct fact *FindIndexedFact(  void *theEnv,  long long factIndexSought)  {   struct fact *theFact;   for (theFact = (struct fact *) EnvGetNextFact(theEnv,NULL);        theFact != NULL;        theFact = (struct fact *) EnvGetNextFact(theEnv,theFact))     {      if (theFact->factIndex == factIndexSought)        { return(theFact); }     }   return(NULL);  }#endif /* DEFTEMPLATE_CONSTRUCT && DEFRULE_CONSTRUCT */