/*******************************************************/   /*      "C" Language Integrated Production System      */   /*                                                     */   /*             CLIPS Version 6.30  10/19/06            */   /*                                                     */   /*              INCREMENTAL RESET MODULE               */   /*******************************************************//*************************************************************//* Purpose: Provides functionality for the incremental       *//*   reset of the pattern and join networks when a new       *//*   rule is added.                                          *//*                                                           *//* Principal Programmer(s):                                  *//*      Gary D. Riley                                        *//*                                                           *//* Contributing Programmer(s):                               *//*                                                           *//* Revision History:                                         *//*      6.23: Correction for FalseSymbol/TrueSymbol. DR0859  *//*                                                           *//*      6.24: Removed INCREMENTAL_RESET compilation flag.    *//*                                                           *//*            Renamed BOOLEAN macro type to intBool.         *//*                                                           *//*      6.30: Added support for hashed alpha memories.       *//*                                                           *//*************************************************************/#define _INCRRSET_SOURCE_#include "setup.h"#include <stdio.h>#define _STDIO_INCLUDED_#if DEFRULE_CONSTRUCT#include "agenda.h"#include "argacces.h"#include "constant.h"#include "drive.h"#include "engine.h"#include "envrnmnt.h"#include "evaluatn.h"#include "pattern.h"#include "router.h"#include "reteutil.h"#include "incrrset.h"/***************************************//* LOCAL INTERNAL FUNCTION DEFINITIONS *//***************************************/#if (! RUN_TIME) && (! BLOAD_ONLY)   static void                    MarkNetworkForIncrementalReset(void *,struct defrule *,int);   static void                    MarkJoinsForIncrementalReset(void *,struct joinNode *,int);   static void                    CheckForPrimableJoins(void *,struct defrule *,struct joinNode *);   static void                    PrimeJoinFromLeftMemory(void *,struct joinNode *);   static void                    PrimeJoinFromRightMemory(void *,struct joinNode *);   static void                    MarkPatternForIncrementalReset(void *,int,struct patternNodeHeader *,int);#endif/**************************************************************//* IncrementalReset: Incrementally resets the specified rule. *//**************************************************************/globle void IncrementalReset(  void *theEnv,  struct defrule *tempRule)  {#if (MAC_MCW || IBM_MCW) && (RUN_TIME || BLOAD_ONLY)#pragma unused(theEnv,tempRule)#endif#if (! RUN_TIME) && (! BLOAD_ONLY)   struct defrule *tempPtr;   struct patternParser *theParser;   /*================================================*/   /* If incremental reset is disabled, then return. */   /*================================================*/   if (! EnvGetIncrementalReset(theEnv)) return;   /*=====================================================*/   /* Mark the pattern and join network data structures   */   /* associated with the rule being incrementally reset. */   /*=====================================================*/   MarkNetworkForIncrementalReset(theEnv,tempRule,TRUE);   /*==========================*/   /* Begin incremental reset. */   /*==========================*/   EngineData(theEnv)->IncrementalResetInProgress = TRUE;   /*============================================================*/   /* If the new rule shares patterns or joins with other rules, */   /* then it is necessary to update its join network based on   */   /* existing partial matches it shares with other rules.       */   /*============================================================*/   for (tempPtr = tempRule;        tempPtr != NULL;        tempPtr = tempPtr->disjunct)     { CheckForPrimableJoins(theEnv,tempPtr,tempPtr->lastJoin); }   /*===============================================*/   /* Filter existing data entities through the new */   /* portions of the pattern and join networks.    */   /*===============================================*/   for (theParser = PatternData(theEnv)->ListOfPatternParsers;        theParser != NULL;        theParser = theParser->next)     {      if (theParser->incrementalResetFunction != NULL)        { (*theParser->incrementalResetFunction)(theEnv); }     }   /*========================*/   /* End incremental reset. */   /*========================*/   EngineData(theEnv)->IncrementalResetInProgress = FALSE;   /*====================================================*/   /* Remove the marks in the pattern and join networks. */   /*====================================================*/   MarkNetworkForIncrementalReset(theEnv,tempRule,FALSE);#endif  }#if (! RUN_TIME) && (! BLOAD_ONLY)/**********************************************************************//* MarkNetworkForIncrementalReset: Coordinates marking the initialize *//*   flags in the pattern and join networks both before and after an  *//*   incremental reset.                                               *//**********************************************************************/static void MarkNetworkForIncrementalReset(  void *theEnv,  struct defrule *tempRule,  int value)  {   /*============================================*/   /* Loop through each of the rule's disjuncts. */   /*============================================*/   for (;        tempRule != NULL;        tempRule = tempRule->disjunct)     { MarkJoinsForIncrementalReset(theEnv,tempRule->lastJoin,value); }  }/**********************************************************************//* MarkJoinsForIncrementalReset: Coordinates marking the initialize *//*   flags in the pattern and join networks both before and after an  *//*   incremental reset.                                               *//**********************************************************************/static void MarkJoinsForIncrementalReset(  void *theEnv,  struct joinNode *joinPtr,  int value)  {   struct patternNodeHeader *patternPtr;   for (;        joinPtr != NULL;        joinPtr = joinPtr->lastLevel)     {      if (joinPtr->ruleToActivate != NULL)        {          joinPtr->marked = FALSE;         joinPtr->initialize = value;         continue;         }              if (joinPtr->joinFromTheRight)        { MarkJoinsForIncrementalReset(theEnv,joinPtr->rightSideEntryStructure,value); }      /*================*/      /* Mark the join. */      /*================*/      joinPtr->marked = FALSE; /* GDR 6.05 */              if (joinPtr->initialize)         {         joinPtr->initialize = value;         if (joinPtr->joinFromTheRight == FALSE)           {            patternPtr = (struct patternNodeHeader *) GetPatternForJoin(joinPtr);            if (patternPtr != NULL)              { MarkPatternForIncrementalReset(theEnv,(int) joinPtr->rhsType,patternPtr,value); }           }        }     }  }  /*******************************************************************************//* CheckForPrimableJoins: Updates the joins of a rule for an incremental reset *//*   if portions of that rule are shared with other rules that have already    *//*   been incrementally reset. A join for a new rule will be updated if it is  *//*   marked for initialization and either its parent join or its associated    *//*   entry pattern node has not been marked for initialization. The function   *//*   PrimeJoin is used to update joins which meet these criteria.              *//*******************************************************************************/static void CheckForPrimableJoins(  void *theEnv,  struct defrule *tempRule,  struct joinNode *joinPtr)  {      struct patternNodeHeader *theHeader;      /*========================================*/   /* Loop through each of the rule's joins. */   /*========================================*/   for (;        joinPtr != NULL;        joinPtr = joinPtr->lastLevel)     {      /*===============================*/      /* Update the join if necessary. */      /*===============================*/      if ((joinPtr->initialize) && (! joinPtr->marked))        {         if (joinPtr->firstJoin == TRUE)           {            theHeader = (struct patternNodeHeader *) joinPtr->rightSideEntryStructure;            if (joinPtr->joinFromTheRight == FALSE)               {               if ((joinPtr->rightSideEntryStructure == NULL) ||                   (joinPtr->patternIsNegated) ||                   (((struct patternNodeHeader *) joinPtr->rightSideEntryStructure)->initialize == FALSE))                 {                  PrimeJoinFromLeftMemory(theEnv,joinPtr);                  joinPtr->marked = TRUE;                 }              }            else              {               PrimeJoinFromRightMemory(theEnv,joinPtr);               joinPtr->marked = TRUE;              }           }         else if (joinPtr->lastLevel->initialize == FALSE)           {             PrimeJoinFromLeftMemory(theEnv,joinPtr);             joinPtr->marked = TRUE;           }         else if ((joinPtr->joinFromTheRight) &&                (((struct joinNode *) joinPtr->rightSideEntryStructure)->initialize == FALSE))           {            PrimeJoinFromRightMemory(theEnv,joinPtr);            joinPtr->marked = TRUE;           }        }              if (joinPtr->joinFromTheRight)        { CheckForPrimableJoins(theEnv,tempRule,joinPtr->rightSideEntryStructure); }     }  }/****************************************************************************//* PrimeJoinFromLeftMemory: Updates a join in a rule for an incremental     *//*   reset. Joins are updated by "priming" them only if the join (or its    *//*   associated pattern) is shared with other rules that have already been  *//*   incrementally reset. A join for a new rule will be updated if it is    *//*   marked for initialization and either its parent join or its associated *//*   entry pattern node has not been marked for initialization.             *//****************************************************************************/static void PrimeJoinFromLeftMemory(  void *theEnv,  struct joinNode *joinPtr)  {   struct partialMatch *theList, *linker;   struct alphaMemoryHash *listOfHashNodes;   unsigned long b;   unsigned long hashValue;   struct betaMemory *theMemory;   struct partialMatch *notParent = NULL;   struct joinLink *tempLink;   /*===========================================================*/   /* If the join is the first join of a rule, then send all of */   /* the partial matches from the alpha memory of the pattern  */   /* associated with this join to the join for processing and  */   /* the priming process is then complete.                     */   /*===========================================================*/   if (joinPtr->firstJoin == TRUE)     {      if (joinPtr->rightSideEntryStructure == NULL)        { NetworkAssert(theEnv,joinPtr->rightMemory->beta[0],joinPtr); }      else if (joinPtr->patternIsNegated)        {          notParent = joinPtr->leftMemory->beta[0];                  if (joinPtr->secondaryNetworkTest != NULL)           {            if (EvaluateSecondaryNetworkTest(theEnv,notParent,joinPtr) == FALSE)              { return; }           }         for (listOfHashNodes = ((struct patternNodeHeader *) joinPtr->rightSideEntryStructure)->firstHash;              listOfHashNodes != NULL;              listOfHashNodes = listOfHashNodes->nextHash)           {            if (listOfHashNodes->alphaMemory != NULL)              {                AddBlockedLink(notParent,listOfHashNodes->alphaMemory);               return;               }           }