/*******************************************************/   /*      "C" Language Integrated Production System      */   /*                                                     */   /*             CLIPS Version 6.30  10/19/06            */   /*                                                     */   /*                  RULE BUILD MODULE                  */   /*******************************************************//*************************************************************//* Purpose: Provides routines to ntegrates a set of pattern  *//*   and join tests associated with a rule into the pattern  *//*   and join networks. The joins are integrated into the    *//*   join network by routines in this module. The pattern    *//*   is integrated by calling the external routine           *//*   associated with the pattern parser that originally      *//*   parsed the pattern.                                     *//*                                                           *//* Principal Programmer(s):                                  *//*      Gary D. Riley                                        *//*                                                           *//* Contributing Programmer(s):                               *//*                                                           *//* Revision History:                                         *//*                                                           *//*      6.24: Removed INCREMENTAL_RESET compilation flag.    *//*                                                           *//*            Corrected code to remove compiler warnings.    *//*                                                           *//*      6.30: Added support for hashed alpha memories.       *//*                                                           *//*************************************************************/#define _RULEBLD_SOURCE_#include "setup.h"#if DEFRULE_CONSTRUCT && (! RUN_TIME) && (! BLOAD_ONLY)#include <stdio.h>#define _STDIO_INCLUDED_#include <stdlib.h>#include "constant.h"#include "envrnmnt.h"#include "constrct.h"#include "drive.h"#include "incrrset.h"#include "memalloc.h"#include "pattern.h"#include "reteutil.h"#include "router.h"#include "rulebld.h"#include "watch.h"/***************************************//* LOCAL INTERNAL FUNCTION DEFINITIONS *//***************************************/   static struct joinNode        *FindShareableJoin(struct joinLink *,struct joinNode *,intBool,void *,unsigned,unsigned,                                                    unsigned,unsigned,struct expr *,struct expr *,                                                    struct expr *,struct expr *);   static int                     TestJoinForReuse(struct joinNode *,unsigned,unsigned,                                                   unsigned,unsigned,struct expr *,struct expr *,                                                   struct expr *,struct expr *);   static struct joinNode        *CreateNewJoin(void *,struct expr *,struct expr *,struct joinNode *,void *,                                                int,int,int,struct expr *,struct expr *);   static void                    AttachTestCEsToPatternCEs(void *,struct lhsParseNode *);/****************************************************************//* ConstructJoins: Integrates a set of pattern and join tests   *//*   associated with a rule into the pattern and join networks. *//****************************************************************/globle struct joinNode *ConstructJoins(  void *theEnv,  int logicalJoin,  struct lhsParseNode *theLHS,  int startDepth)  {   struct joinNode *lastJoin = NULL;   struct patternNodeHeader *lastPattern;   unsigned firstJoin = TRUE;   int tryToReuse = TRUE;   struct joinNode *listOfJoins = NULL;   struct joinNode *oldJoin;   int joinNumber = 1;   int isLogical, isExists;   struct joinNode *lastRightJoin;   int lastIteration = FALSE;   int rhsType;   struct expr *leftHash, *rightHash;   void *rhsStruct;   struct lhsParseNode *nextLHS;   struct expr *networkTest, *secondaryNetworkTest, *secondaryExternalTest;   int joinFromTheRight;   struct joinLink *theLinks;   intBool useLinks;   /*===================================================*/   /* Remove any test CEs from the LHS and attach their */   /* expression to the closest preceeding non-negated  */   /* join at the same not/and depth.                   */   /*===================================================*/   if (startDepth == 1)     { AttachTestCEsToPatternCEs(theEnv,theLHS); }   if (theLHS == NULL)     {      lastJoin = FindShareableJoin(DefruleData(theEnv)->RightPrimeJoins,NULL,TRUE,NULL,TRUE,                                   FALSE,FALSE,FALSE,NULL,NULL,NULL,NULL);                                              if (lastJoin == NULL)        { lastJoin = CreateNewJoin(theEnv,NULL,NULL,NULL,NULL,FALSE,FALSE,FALSE,NULL,NULL); }     }   /*=====================================================*/   /* Process each pattern CE in the rule. At this point, */   /* there should be no and/or/not/test CEs in the LHS.  */   /*=====================================================*/   while (theLHS != NULL)     {      /*======================================================*/      /* Find the beginning of the next group of patterns. If */      /* the current pattern is not the beginning of a "join  */      /* from the right" group of patterns, then the next     */      /* pattern is the next pattern. Otherwise skip over all */      /* the patterns that belong to the group of subjoins.   */      /*======================================================*/                   nextLHS = theLHS->bottom;      secondaryExternalTest = NULL;      if (theLHS->endNandDepth > startDepth)        {         while ((nextLHS != NULL) &&                (nextLHS->endNandDepth > startDepth))           { nextLHS = nextLHS->bottom; }                  /*====================================================*/         /* Variable nextLHS is now pointing to the end of the */         /* not/and group beginning with variable theLHS. If   */          /* the end depth of the group is less than the depth  */         /* of the current enclosing not/and group, then this  */         /* is the last iteration for the enclosing group.     */         /*====================================================*/                    if (nextLHS != NULL)           {            if (nextLHS->endNandDepth < startDepth)              { lastIteration = TRUE; }           }                    if (nextLHS != NULL)           { nextLHS = nextLHS->bottom; }                    if ((nextLHS != NULL) && (nextLHS->type == TEST_CE))           {             secondaryExternalTest = nextLHS->networkTest;            nextLHS = nextLHS->bottom;            }        }             /*=======================================*/      /* Is this the last pattern to be added? */      /*=======================================*/            if (nextLHS == NULL)        { lastIteration = TRUE; }      else if (theLHS->endNandDepth < startDepth)        { lastIteration = TRUE; }       else if ((nextLHS->type == TEST_CE) &&               (theLHS->beginNandDepth > startDepth) &&               (nextLHS->endNandDepth < startDepth))        { lastIteration = TRUE; }       /*===============================================*/      /* If the pattern is a join from the right, then */      /* construct the subgroup of patterns and use    */      /* that as the RHS of the join to be added.      */      /*===============================================*/                                               if (theLHS->beginNandDepth > startDepth)        {         joinFromTheRight = TRUE;         isExists = theLHS->existsNand;         lastRightJoin = ConstructJoins(theEnv,logicalJoin,theLHS,startDepth+1);                    rhsStruct = lastRightJoin;         rhsType = 0;         lastPattern = NULL;         networkTest = theLHS->externalNetworkTest; /* TBD */         secondaryNetworkTest = secondaryExternalTest;         leftHash = theLHS->externalLeftHash;         rightHash = theLHS->externalRightHash;        }               /*=======================================================*/      /* Otherwise, add the pattern to the appropriate pattern */      /* network and use the pattern node containing the alpha */      /* memory as the RHS of the join to be added.            */      /*=======================================================*/            else if (theLHS->right == NULL)        {         joinFromTheRight = FALSE;         rhsType = 0;         lastPattern = NULL;         rhsStruct = NULL;         lastRightJoin = NULL;         isExists = theLHS->exists;         networkTest = theLHS->networkTest;         secondaryNetworkTest = theLHS->secondaryNetworkTest;         leftHash = NULL;         rightHash = NULL;        }      else        {         joinFromTheRight = FALSE;         rhsType = theLHS->patternType->positionInArray;         lastPattern = (*theLHS->patternType->addPatternFunction)(theEnv,theLHS);         rhsStruct = lastPattern;         lastRightJoin = NULL;         isExists = theLHS->exists;         networkTest = theLHS->networkTest;         secondaryNetworkTest = theLHS->secondaryNetworkTest;         leftHash = theLHS->leftHash;         rightHash = theLHS->rightHash;        }            /*======================================================*/      /* Determine if the join being added is a logical join. */      /*======================================================*/      if ((startDepth == 1) && (joinNumber == logicalJoin)) isLogical = TRUE;      else isLogical = FALSE;      /*===============================================*/      /* Get the list of joins which could potentially */      /* be reused in place of the join being added.   */      /*===============================================*/      useLinks = TRUE;      if (firstJoin == TRUE)        {          if (theLHS->right == NULL)           { theLinks = DefruleData(theEnv)->RightPrimeJoins; }         else if (lastPattern != NULL)           {             listOfJoins = lastPattern->entryJoin;            theLinks = NULL;            useLinks = FALSE;           }         else           { theLinks = lastRightJoin->nextLinks; }        }      else        { theLinks = lastJoin->nextLinks; }      /*=======================================================*/      /* Determine if the next join to be added can be shared. */      /*=======================================================*/      if ((tryToReuse == TRUE) &&          ((oldJoin = FindShareableJoin(theLinks,listOfJoins,useLinks,rhsStruct,firstJoin,