自学教程：C++ EngineData函数代码示例

globle void *EnvGetFocus(  void *theEnv)  {   if (EngineData(theEnv)->CurrentFocus == NULL) return(NULL);   return((void *) EngineData(theEnv)->CurrentFocus->theModule);  }

globle intBool EvaluateSecondaryNetworkTest(  void *theEnv,  struct partialMatch *leftMatch,  struct joinNode *joinPtr)  {   int joinExpr;   struct partialMatch *oldLHSBinds;   struct partialMatch *oldRHSBinds;   struct joinNode *oldJoin;   if (joinPtr->secondaryNetworkTest == NULL)     { return(TRUE); }        #if DEVELOPER   EngineData(theEnv)->rightToLeftComparisons++;#endif   oldLHSBinds = EngineData(theEnv)->GlobalLHSBinds;   oldRHSBinds = EngineData(theEnv)->GlobalRHSBinds;   oldJoin = EngineData(theEnv)->GlobalJoin;   EngineData(theEnv)->GlobalLHSBinds = leftMatch;   EngineData(theEnv)->GlobalRHSBinds = NULL;   EngineData(theEnv)->GlobalJoin = joinPtr;   joinExpr = EvaluateJoinExpression(theEnv,joinPtr->secondaryNetworkTest,joinPtr);   EvaluationData(theEnv)->EvaluationError = FALSE;   EngineData(theEnv)->GlobalLHSBinds = oldLHSBinds;   EngineData(theEnv)->GlobalRHSBinds = oldRHSBinds;   EngineData(theEnv)->GlobalJoin = oldJoin;   return(joinExpr);  }

globle CLIPS_BOOLEAN AddLogicalDependencies(  void *theEnv,  struct patternEntity *theEntity,  int existingEntity)  {   struct partialMatch *theBinds;   struct dependency *newDependency;   /*==============================================*/   /* If the rule has no logical patterns, then no */   /* dependencies have to be established.         */   /*==============================================*/   if (EngineData(theEnv)->TheLogicalJoin == NULL)     {      if (existingEntity) RemoveEntityDependencies(theEnv,theEntity);      return(TRUE);     }   else if (existingEntity && (theEntity->dependents == NULL))     { return(TRUE); }   /*============================================================*/   /* Find the partial match in the logical join associated with */   /* activation partial match. If the partial match cannot be   */   /* found, then the partial match must have been deleted by a  */   /* previous RHS action and the dependency link should not be  */   /* added.                                                     */   /*============================================================*/   theBinds = FindLogicalBind(EngineData(theEnv)->TheLogicalJoin,EngineData(theEnv)->GlobalLHSBinds);   if (theBinds == NULL) return(FALSE);   /*==============================================================*/   /* Add a dependency link between the partial match and the data */   /* entity. The dependency links are stored in the partial match */   /* behind the data entities stored in the partial match and the */   /* activation link, if any.                                     */   /*==============================================================*/   newDependency = get_struct(theEnv,dependency);   newDependency->dPtr = (void *) theEntity;   newDependency->next = (struct dependency *)                         theBinds->binds[theBinds->bcount + theBinds->activationf].gm.theValue;   theBinds->binds[theBinds->bcount + theBinds->activationf].gm.theValue = (void *) newDependency;   /*================================================================*/   /* Add a dependency link between the entity and the partialMatch. */   /*================================================================*/   newDependency = get_struct(theEnv,dependency);   newDependency->dPtr = (void *) theBinds;   newDependency->next = (struct dependency *) theEntity->dependents;   theEntity->dependents = (void *) newDependency;   /*==================================================================*/   /* Return TRUE to indicate that the data entity should be asserted. */   /*==================================================================*/   return(TRUE);  }

globle void EnvClearFocusStack(  void *theEnv)  {   while (EngineData(theEnv)->CurrentFocus != NULL) EnvPopFocus(theEnv);   EngineData(theEnv)->FocusChanged = TRUE;  }

globle intBool EnvSetIncrementalReset(  void *theEnv,  int value)  {   int ov;   struct defmodule *theModule;   SaveCurrentModule(theEnv);   for (theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,NULL);        theModule != NULL;        theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,theModule))     {      EnvSetCurrentModule(theEnv,(void *) theModule);      if (EnvGetNextDefrule(theEnv,NULL) != NULL)        {         RestoreCurrentModule(theEnv);         return(-1);        }     }        RestoreCurrentModule(theEnv);   ov = EngineData(theEnv)->IncrementalResetFlag;   EngineData(theEnv)->IncrementalResetFlag = value;   return(ov);  }

globle void RetractCheckDriveRetractions(  /* GDR 111599 #834 Begin */  void *theEnv,  struct alphaMatch *theAlphaNode,  int position)  {   struct rdriveinfo *tempDR, *theDR, *lastDR = NULL;   theDR = EngineData(theEnv)->DriveRetractionList;   while (theDR != NULL)     {      if ((position < (int) theDR->link->bcount) &&          (theDR->link->binds[position].gm.theMatch == theAlphaNode))        {         tempDR = theDR->next;         rtn_struct(theEnv,rdriveinfo,theDR);         if (lastDR == NULL)           { EngineData(theEnv)->DriveRetractionList = tempDR; }         else           { lastDR->next = tempDR; }         theDR = tempDR;        }      else        {         lastDR = theDR;         theDR = theDR->next;        }     }  }                                        /* GDR 111599 #834 End */

globle int FactJNCompVars1(    void *theEnv,    void *theValue,    DATA_OBJECT *theResult){    int p1, e1, p2, e2;    struct fact *fact1, *fact2;    struct factCompVarsJN1Call *hack;    /*=========================================*/    /* Retrieve the arguments to the function. */    /*=========================================*/    hack = (struct factCompVarsJN1Call *) ValueToBitMap(theValue);    /*=================================================*/    /* Extract the fact pointers for the two patterns. */    /*=================================================*/    p1 = (int) hack->pattern1;    p2 = (int) hack->pattern2;    fact1 = (struct fact *) EngineData(theEnv)->GlobalRHSBinds->binds[p1].gm.theMatch->matchingItem;    if (hack->p2rhs)    {        fact2 = (struct fact *) EngineData(theEnv)->GlobalRHSBinds->binds[p2].gm.theMatch->matchingItem;    }    else    {        fact2 = (struct fact *) EngineData(theEnv)->GlobalLHSBinds->binds[p2].gm.theMatch->matchingItem;    }    /*=====================*/    /* Compare the values. */    /*=====================*/    e1 = (int) hack->slot1;    e2 = (int) hack->slot2;    if (fact1->theProposition.theFields[e1].type !=            fact2->theProposition.theFields[e2].type)    {        return((int) hack->fail);    }    if (fact1->theProposition.theFields[e1].value !=            fact2->theProposition.theFields[e2].value)    {        return((int) hack->fail);    }    return((int) hack->pass);}

static void DeletePartialMatches(  void *theEnv,  struct partialMatch *listOfPMs,  int betaDelete)  {   struct partialMatch *nextPM;   while (listOfPMs != NULL)     {      /*============================================*/      /* Remember the next partial match to delete. */      /*============================================*/      nextPM = listOfPMs->next;      /*================================================*/      /* Remove the links between the partial match and */      /* any data entities that it is attached to as a  */      /* result of a logical CE.                        */      /*================================================*/#if LOGICAL_DEPENDENCIES      if (listOfPMs->dependentsf) RemoveLogicalSupport(theEnv,listOfPMs);#endif      /*==========================================================*/      /* If the partial match is being deleted from a beta memory */      /* and the partial match isn't associated with a satisfied  */      /* not CE, then it can be immediately returned to the pool  */      /* of free memory. Otherwise, it's could be in use (either  */      /* to retrieve variables from the LHS or by the activation  */      /* of the rule). Since a not CE creates a "pseudo" data     */      /* entity, the beta partial match which stores this pseudo  */      /* data entity can not be deleted immediately (for the same */      /* reason an alpha memory partial match can't be deleted    */      /* immediately).                                            */      /*==========================================================*/      if (betaDelete &&          ((listOfPMs->notOriginf == FALSE) || (listOfPMs->counterf)))        { ReturnPartialMatch(theEnv,listOfPMs); }      else        {         listOfPMs->next = EngineData(theEnv)->GarbagePartialMatches;         EngineData(theEnv)->GarbagePartialMatches = listOfPMs;        }      /*====================================*/      /* Move on to the next partial match. */      /*====================================*/      listOfPMs = nextPM;     }  }

globle intBool EnvAddRunFunction(  void *theEnv,  char *name,  void (*functionPtr)(void *),  int priority)  {   EngineData(theEnv)->ListOfRunFunctions = AddFunctionToCallList(theEnv,name,priority,                                              functionPtr,                                              EngineData(theEnv)->ListOfRunFunctions,TRUE);   return(1);  }

globle BOOLEAN EnvSetIncrementalReset(  void *theEnv,  int value)  {   int ov;   ov = EngineData(theEnv)->IncrementalResetFlag;   if (EnvGetNextDefrule(theEnv,NULL) != NULL) return(-1);   EngineData(theEnv)->IncrementalResetFlag = value;   return(ov);  }

globle void InitializeEngine(  void *theEnv)  {      AllocateEnvironmentData(theEnv,ENGINE_DATA,sizeof(struct engineData),DeallocateEngineData);   EngineData(theEnv)->IncrementalResetFlag = TRUE;   #if DEBUGGING_FUNCTIONS   AddWatchItem(theEnv,"statistics",0,&EngineData(theEnv)->WatchStatistics,20,NULL,NULL);   AddWatchItem(theEnv,"focus",0,&EngineData(theEnv)->WatchFocus,0,NULL,NULL);#endif  }

globle void EnvGetFocusStack(  void *theEnv,  DATA_OBJECT_PTR returnValue)  {   struct focus *theFocus;   struct multifield *theList;   unsigned long count = 0;   /*===========================================*/   /* If there is no current focus, then return */   /* a multifield value of length zero.        */   /*===========================================*/   if (EngineData(theEnv)->CurrentFocus == NULL)     {      SetpType(returnValue,MULTIFIELD);      SetpDOBegin(returnValue,1);      SetpDOEnd(returnValue,0);      SetpValue(returnValue,(void *) EnvCreateMultifield(theEnv,0L));      return;     }   /*=====================================================*/   /* Determine the number of modules on the focus stack. */   /*=====================================================*/   for (theFocus = EngineData(theEnv)->CurrentFocus; theFocus != NULL; theFocus = theFocus->next)     { count++; }   /*=============================================*/   /* Create a multifield of the appropriate size */   /* in which to store the module names.         */   /*=============================================*/   SetpType(returnValue,MULTIFIELD);   SetpDOBegin(returnValue,1);   SetpDOEnd(returnValue,(long) count);   theList = (struct multifield *) EnvCreateMultifield(theEnv,count);   SetpValue(returnValue,(void *) theList);   /*=================================================*/   /* Store the module names in the multifield value. */   /*=================================================*/   for (theFocus = EngineData(theEnv)->CurrentFocus, count = 1;        theFocus != NULL;        theFocus = theFocus->next, count++)     {      SetMFType(theList,count,SYMBOL);      SetMFValue(theList,count,theFocus->theModule->name);     }  }

globle intBool EnvRemoveRunFunction(  void *theEnv,  char *name)  {   int found;   EngineData(theEnv)->ListOfRunFunctions =       RemoveFunctionFromCallList(theEnv,name,EngineData(theEnv)->ListOfRunFunctions,&found);   if (found) return(TRUE);   return(FALSE);  }

globle intBool AddRunFunction(  char *name,  void (*functionPtr)(void),  int priority)  {   void *theEnv;      theEnv = GetCurrentEnvironment();   EngineData(theEnv)->ListOfRunFunctions =        AddFunctionToCallList(theEnv,name,priority,(void (*)(void *)) functionPtr,                             EngineData(theEnv)->ListOfRunFunctions,TRUE);   return(1);  }

static bool ClearDefrulesReady(  void *theEnv)  {   if (EngineData(theEnv)->ExecutingRule != NULL) return(false);   if (EngineData(theEnv)->JoinOperationInProgress) return(false);   EnvClearFocusStack(theEnv);   if (EnvGetCurrentModule(theEnv) == NULL) return(false);   DefruleData(theEnv)->CurrentEntityTimeTag = 1L;   return(true);  }

/****************************************************  NAME         : GetPatternObjectAndMarks  DESCRIPTION  : Finds the instance and multfiield                 markers corresponding to a specified                 pattern in the join network  INPUTS       : 1) The index of the desired pattern                 2) A buffer to hold the instance                    address                 3) A buffer to hold the list of                    multifield markers  RETURNS      : Nothing useful  SIDE EFFECTS : Buffers set  NOTES        : None ****************************************************/static void GetPatternObjectAndMarks(  void *theEnv,  int pattern,  INSTANCE_TYPE **theInstance,  struct multifieldMarker **theMarkers)  {   if (EngineData(theEnv)->GlobalRHSBinds == NULL)     {      *theInstance = (INSTANCE_TYPE *)        get_nth_pm_match(EngineData(theEnv)->GlobalLHSBinds,pattern)->matchingItem;      *theMarkers =        get_nth_pm_match(EngineData(theEnv)->GlobalLHSBinds,pattern)->markers;     }   else if ((((int) EngineData(theEnv)->GlobalJoin->depth) - 1) == pattern)     {      *theInstance = (INSTANCE_TYPE *) get_nth_pm_match(EngineData(theEnv)->GlobalRHSBinds,0)->matchingItem;      *theMarkers = get_nth_pm_match(EngineData(theEnv)->GlobalRHSBinds,0)->markers;     }   else     {      *theInstance = (INSTANCE_TYPE *)        get_nth_pm_match(EngineData(theEnv)->GlobalLHSBinds,pattern)->matchingItem;      *theMarkers =        get_nth_pm_match(EngineData(theEnv)->GlobalLHSBinds,pattern)->markers;     }  }

globle void ReturnPartialMatch(  void *theEnv,  struct partialMatch *waste)  {   /*==============================================*/   /* If the partial match is in use, then put it  */   /* on a garbage list to be processed later when */   /* the partial match is not in use.             */   /*==============================================*/   if (waste->busy)     {      waste->next = EngineData(theEnv)->GarbagePartialMatches;      EngineData(theEnv)->GarbagePartialMatches = waste;      return;     }   /*======================================================*/   /* If we're dealing with an alpha memory partial match, */   /* then return the multifield markers associated with   */   /* the partial match (if any) along with the alphaMatch */   /* data structure.                                      */   /*======================================================*/   if (waste->betaMemory == FALSE)     {      if (waste->binds[0].gm.theMatch->markers != NULL)        { ReturnMarkers(theEnv,waste->binds[0].gm.theMatch->markers); }      rm(theEnv,waste->binds[0].gm.theMatch,(int) sizeof(struct alphaMatch));     }   /*=================================================*/   /* Remove any links between the partial match and  */   /* a data entity that were created with the use of */   /* the logical CE.                                 */   /*=================================================*/#if LOGICAL_DEPENDENCIES   if (waste->dependentsf) RemovePMDependencies(theEnv,waste);#endif   /*======================================================*/   /* Return the partial match to the pool of free memory. */   /*======================================================*/   rtn_var_struct(theEnv,partialMatch,(int) sizeof(struct genericMatch *) *                  (waste->bcount + waste->activationf + waste->dependentsf - 1),                  waste);  }

static void DeallocateEngineData(  void *theEnv)  {   struct focus *tmpPtr, *nextPtr;      DeallocateCallList(theEnv,EngineData(theEnv)->ListOfRunFunctions);   tmpPtr = EngineData(theEnv)->CurrentFocus;   while (tmpPtr != NULL)     {      nextPtr = tmpPtr->next;      rtn_struct(theEnv,focus,tmpPtr);      tmpPtr = nextPtr;     }  }

globle void FactsIncrementalReset(  void *theEnv)  {   struct fact *factPtr;   for (factPtr = (struct fact *) EnvGetNextFact(theEnv,NULL);        factPtr != NULL;        factPtr = (struct fact *) EnvGetNextFact(theEnv,factPtr))     {      EngineData(theEnv)->JoinOperationInProgress = TRUE;      FactPatternMatch(theEnv,factPtr,                       factPtr->whichDeftemplate->patternNetwork,                       0,NULL,NULL);      EngineData(theEnv)->JoinOperationInProgress = FALSE;     }  }

globle CLIPS_BOOLEAN EnvIsDefruleDeletable(  void *theEnv,  void *vTheDefrule)  {#if BLOAD_ONLY || RUN_TIME#if MAC_MCW || IBM_MCW || MAC_XCD#pragma unused(theEnv,vTheDefrule)#endif   return(FALSE);#else   struct defrule *theDefrule;#if BLOAD || BLOAD_AND_BSAVE   if (Bloaded(theEnv)) return(FALSE);#endif   for (theDefrule = (struct defrule *) vTheDefrule;        theDefrule != NULL;        theDefrule = theDefrule->disjunct)     { if (theDefrule->executing) return(FALSE); }   if (EngineData(theEnv)->JoinOperationInProgress) return(FALSE);   return(TRUE);#endif  }

globle void NetworkAssert(  void *theEnv,  struct partialMatch *binds,  struct joinNode *join)  {   /*=========================================================*/   /* If an incremental reset is being performed and the join */   /* is not part of the network to be reset, then return.    */   /*=========================================================*/#if (! BLOAD_ONLY) && (! RUN_TIME)   if (EngineData(theEnv)->IncrementalResetInProgress && (join->initialize == FALSE)) return;#endif   /*==================================================*/   /* Use a special routine if this is the first join. */   /*==================================================*/   if (join->firstJoin)     {      EmptyDrive(theEnv,join,binds);      return;     }   /*================================*/   /* Enter the join from the right. */   /*================================*/   NetworkAssertRight(theEnv,binds,join);   return;  }

bool FactJNCompVars1(  Environment *theEnv,  void *theValue,  UDFValue *theResult)  {#if MAC_XCD#pragma unused(theResult)#endif   unsigned short p1, e1, p2, e2;   Fact *fact1, *fact2;   struct factCompVarsJN1Call *hack;   /*=========================================*/   /* Retrieve the arguments to the function. */   /*=========================================*/   hack = (struct factCompVarsJN1Call *) ((CLIPSBitMap *) theValue)->contents;   /*=================================================*/   /* Extract the fact pointers for the two patterns. */   /*=================================================*/   p1 = hack->pattern1;   p2 = hack->pattern2;   fact1 = (Fact *) EngineData(theEnv)->GlobalRHSBinds->binds[p1].gm.theMatch->matchingItem;   if (hack->p2rhs)     { fact2 = (Fact *) EngineData(theEnv)->GlobalRHSBinds->binds[p2].gm.theMatch->matchingItem; }   else     { fact2 = (Fact *) EngineData(theEnv)->GlobalLHSBinds->binds[p2].gm.theMatch->matchingItem; }   /*=====================*/   /* Compare the values. */   /*=====================*/   e1 = hack->slot1;   e2 = hack->slot2;   if (fact1->theProposition.contents[e1].value !=       fact2->theProposition.contents[e2].value)     { return hack->fail; }   return hack->pass;  }

globle void ForceLogicalRetractions(  void *theEnv)  {   struct dependency *tempPtr;   struct patternEntity *theEntity;   /*===================================================*/   /* Don't reenter this function once it's called. Any */   /* new additions to the list of items to be deleted  */   /* as a result of losing their logical support will  */   /* be handled properly.                              */   /*===================================================*/   if (EngineData(theEnv)->alreadyEntered) return;   EngineData(theEnv)->alreadyEntered = TRUE;   /*=======================================================*/   /* Continue to delete the first item on the list as long */   /* as one exists. This is done because new items may be  */   /* placed at the beginning of the list as other data     */   /* entities are deleted.                                 */   /*=======================================================*/   while (EngineData(theEnv)->UnsupportedDataEntities != NULL)     {      /*==========================================*/      /* Determine the data entity to be deleted. */      /*==========================================*/      theEntity = (struct patternEntity *) EngineData(theEnv)->UnsupportedDataEntities->dPtr;      /*================================================*/      /* Remove the dependency structure from the list. */      /*================================================*/      tempPtr = EngineData(theEnv)->UnsupportedDataEntities;      EngineData(theEnv)->UnsupportedDataEntities = EngineData(theEnv)->UnsupportedDataEntities->next;      rtn_struct(theEnv,dependency,tempPtr);      /*=========================*/      /* Delete the data entity. */      /*=========================*/      (*theEntity->theInfo->base.decrementBusyCount)(theEnv,theEntity);      (*theEntity->theInfo->base.deleteFunction)(theEnv,theEntity);     }   /*============================================*/   /* Deletion of items on the list is complete. */   /*============================================*/   EngineData(theEnv)->alreadyEntered = FALSE;  }

static int ClearDefrulesReady(  void *theEnv)  {   if (EngineData(theEnv)->ExecutingRule != NULL) return(FALSE);      EnvClearFocusStack(theEnv);   if (EnvGetCurrentModule(theEnv) == NULL) return(FALSE);   DefruleData(theEnv)->CurrentEntityTimeTag = 0L;   return(TRUE);  }

static int SkipFactPatternNode(  void *theEnv,  struct factPatternNode *thePattern)  {#if (! RUN_TIME) && (! BLOAD_ONLY)   if (EngineData(theEnv)->IncrementalResetInProgress &&       (thePattern->header.initialize == FALSE))     { return(TRUE); }#endif   return(FALSE);  }

globle void EnvListFocusStack(  void *theEnv,  char *logicalName)  {   struct focus *theFocus;   for (theFocus = EngineData(theEnv)->CurrentFocus;        theFocus != NULL;        theFocus = theFocus->next)     {      EnvPrintRouter(theEnv,logicalName,EnvGetDefmoduleName(theEnv,theFocus->theModule));      EnvPrintRouter(theEnv,logicalName,"/n");     }  }

globle CLIPS_BOOLEAN FactJNGetVar2(  void *theEnv,  void *theValue,  DATA_OBJECT_PTR returnValue)  {   struct fact *factPtr;   struct factGetVarJN2Call *hack;   struct field *fieldPtr;   /*==========================================*/   /* Retrieve the arguments for the function. */   /*==========================================*/   hack = (struct factGetVarJN2Call *) ValueToBitMap(theValue);   /*=====================================================*/   /* Get the pointer to the fact from the partial match. */   /*=====================================================*/   if (EngineData(theEnv)->GlobalRHSBinds == NULL)     { factPtr = (struct fact *) get_nth_pm_match(EngineData(theEnv)->GlobalLHSBinds,hack->whichPattern)->matchingItem; }   else if ((EngineData(theEnv)->GlobalJoin->depth - 1) == hack->whichPattern)     { factPtr = (struct fact *) get_nth_pm_match(EngineData(theEnv)->GlobalRHSBinds,0)->matchingItem; }   else     { factPtr = (struct fact *) get_nth_pm_match(EngineData(theEnv)->GlobalLHSBinds,hack->whichPattern)->matchingItem; }   /*============================================*/   /* Extract the value from the specified slot. */   /*============================================*/   fieldPtr = &factPtr->theProposition.theFields[hack->whichSlot];   returnValue->type = fieldPtr->type;   returnValue->value = fieldPtr->value;   return(TRUE);  }

globle void EnvFocus(  void *theEnv,  void *vTheModule)  {   struct defmodule *theModule = (struct defmodule *) vTheModule;   struct focus *tempFocus;   /*==================================================*/   /* Make the specified module be the current module. */   /* If the specified module is the current focus,    */   /* then no further action is needed.                */   /*==================================================*/   EnvSetCurrentModule(theEnv,(void *) theModule);   if (EngineData(theEnv)->CurrentFocus != NULL)     { if (EngineData(theEnv)->CurrentFocus->theModule == theModule) return; }   /*=====================================*/   /* If the focus is being watched, then */   /* print an information message.       */   /*=====================================*/#if DEBUGGING_FUNCTIONS   if (EngineData(theEnv)->WatchFocus)     {      EnvPrintRouter(theEnv,WTRACE,"==> Focus ");      EnvPrintRouter(theEnv,WTRACE,ValueToString(theModule->name));      if (EngineData(theEnv)->CurrentFocus != NULL)        {         EnvPrintRouter(theEnv,WTRACE," from ");         EnvPrintRouter(theEnv,WTRACE,ValueToString(EngineData(theEnv)->CurrentFocus->theModule->name));        }      EnvPrintRouter(theEnv,WTRACE,"/n");     }#endif   /*=======================================*/   /* Add the new focus to the focus stack. */   /*=======================================*/   tempFocus = get_struct(theEnv,focus);   tempFocus->theModule = theModule;   tempFocus->theDefruleModule = GetDefruleModuleItem(theEnv,theModule);   tempFocus->next = EngineData(theEnv)->CurrentFocus;   EngineData(theEnv)->CurrentFocus = tempFocus;   EngineData(theEnv)->FocusChanged = TRUE;  }

globle intBool EnvSetIncrementalReset(  void *theEnv,  int value)  {   int ov;   struct defmodule *theModule;   /*============================================*/   /* The incremental reset behavior can only be */   /* changed if there are no existing rules.    */   /*============================================*/      SaveCurrentModule(theEnv);   for (theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,NULL);        theModule != NULL;        theModule = (struct defmodule *) EnvGetNextDefmodule(theEnv,theModule))     {      EnvSetCurrentModule(theEnv,(void *) theModule);      if (EnvGetNextDefrule(theEnv,NULL) != NULL)        {         RestoreCurrentModule(theEnv);         return(-1);        }     }        RestoreCurrentModule(theEnv);   /*====================================*/   /* Change the incremental reset flag. */   /*====================================*/      ov = EngineData(theEnv)->IncrementalResetFlag;   EngineData(theEnv)->IncrementalResetFlag = value;   return(ov);  }

static int SkipFactPatternNode(  void *theEnv,  struct factPatternNode *thePattern)  {#if (MAC_MCW || IBM_MCW) && (RUN_TIME || BLOAD_ONLY || (! INCREMENTAL_RESET))#pragma unused(theEnv,thePattern)#endif#if INCREMENTAL_RESET && (! RUN_TIME) && (! BLOAD_ONLY)   if (EngineData(theEnv)->IncrementalResetInProgress &&       (thePattern->header.initialize == FALSE))     { return(TRUE); }#endif   return(FALSE);  }