/*******************************************************/   /*      "C" Language Integrated Production System      */   /*                                                     */   /*               CLIPS Version 6.30  10/19/06          */   /*                                                     */   /*                                                     */   /*******************************************************//*************************************************************//* Purpose: Binary Load/Save Functions Defrule               *//*          Object Pattern Network                           *//*                                                           *//* Principal Programmer(s):                                  *//*      Brian L. Donnell                                     *//*                                                           *//* Contributing Programmer(s):                               *//*                                                           *//* Revision History:                                         *//*                                                           *//*      6.24: Converted INSTANCE_PATTERN_MATCHING to         *//*            DEFRULE_CONSTRUCT.                             *//*                                                           *//*            ResetObjectMatchTimeTags did not pass in the   *//*            environment argument when BLOAD_ONLY was set.  *//*                                                           *//*      6.30: Added support for hashed alpha memories.       *//*                                                           *//*************************************************************//* =========================================   *****************************************               EXTERNAL DEFINITIONS   =========================================   ***************************************** */#include "setup.h"#if DEFRULE_CONSTRUCT && OBJECT_SYSTEM && (BLOAD || BLOAD_ONLY || BLOAD_AND_BSAVE)#include "bload.h"#include "bsave.h"#include "envrnmnt.h"#include "memalloc.h"#include "insfun.h"#include "objrtmch.h"#include "reteutil.h"#include "rulebin.h"#define _OBJRTBIN_SOURCE_#include "objrtbin.h"/* =========================================   *****************************************               MACROS AND TYPES   =========================================   ***************************************** */typedef unsigned long UNLN;typedef struct bsaveObjectPatternNode  {   unsigned multifieldNode : 1;   unsigned endSlot        : 1;   unsigned selector       : 1;   unsigned whichField     : 8;   unsigned leaveFields    : 8;   unsigned slotNameID;   long networkTest,        nextLevel,        lastLevel,        leftNode,        rightNode,        alphaNode;  } BSAVE_OBJECT_PATTERN_NODE;typedef struct bsaveObjectAlphaNode  {   struct bsavePatternNodeHeader header;   long classbmp,        slotbmp,        patternNode,        nxtInGroup,        nxtTerminal;  } BSAVE_OBJECT_ALPHA_NODE;#define BsaveObjectPatternIndex(op) ((op != NULL) ? op->bsaveID : -1L)#define BsaveObjectAlphaIndex(ap)   ((ap != NULL) ? ap->bsaveID : -1L)#define ObjectPatternPointer(i) ((i == -1L) ? NULL : (OBJECT_PATTERN_NODE *) &ObjectReteBinaryData(theEnv)->PatternArray[i])#define ObjectAlphaPointer(i)   ((i == -1L) ? NULL : (OBJECT_ALPHA_NODE *) &ObjectReteBinaryData(theEnv)->AlphaArray[i])/* =========================================   *****************************************      INTERNALLY VISIBLE FUNCTION HEADERS   =========================================   ***************************************** */#if BLOAD_AND_BSAVEstatic void BsaveObjectPatternsFind(void *);static void BsaveStorageObjectPatterns(void *,FILE *);static void BsaveObjectPatterns(void *,FILE *);#endifstatic void BloadStorageObjectPatterns(void *);static void BloadObjectPatterns(void *);static void UpdateAlpha(void *,void *,long);static void UpdatePattern(void *,void *,long);static void ClearBloadObjectPatterns(void *);static void DeallocateObjectReteBinaryData(void *);/* =========================================   *****************************************          EXTERNALLY VISIBLE FUNCTIONS   =========================================   ***************************************** *//***********************************************************  NAME         : SetupObjectPatternsBload  DESCRIPTION  : Initializes data structures and                   routines for binary loads of                   generic function constructs  INPUTS       : None  RETURNS      : Nothing useful  SIDE EFFECTS : Routines defined and structures initialized  NOTES        : None ***********************************************************/globle void SetupObjectPatternsBload(  void *theEnv)  {   AllocateEnvironmentData(theEnv,OBJECTRETEBIN_DATA,sizeof(struct objectReteBinaryData),DeallocateObjectReteBinaryData);#if BLOAD_AND_BSAVE   AddBinaryItem(theEnv,"object patterns",0,BsaveObjectPatternsFind,NULL,                             BsaveStorageObjectPatterns,BsaveObjectPatterns,                             BloadStorageObjectPatterns,BloadObjectPatterns,                             ClearBloadObjectPatterns);#endif#if BLOAD || BLOAD_ONLY   AddBinaryItem(theEnv,"object patterns",0,NULL,NULL,NULL,NULL,                             BloadStorageObjectPatterns,BloadObjectPatterns,                             ClearBloadObjectPatterns);#endif  }  /***********************************************************//* DeallocateObjectReteBinaryData: Deallocates environment *//*    data for object rete binary functionality.           *//***********************************************************/static void DeallocateObjectReteBinaryData(  void *theEnv)  {#if (BLOAD || BLOAD_ONLY || BLOAD_AND_BSAVE) && (! RUN_TIME)   size_t space;   long i;   for (i = 0; i < ObjectReteBinaryData(theEnv)->AlphaNodeCount; i++)     { DestroyAlphaMemory(theEnv,&ObjectReteBinaryData(theEnv)->AlphaArray[i].header,FALSE); }   space = ObjectReteBinaryData(theEnv)->AlphaNodeCount * sizeof(struct objectAlphaNode);   if (space != 0) genfree(theEnv,(void *) ObjectReteBinaryData(theEnv)->AlphaArray,space);   space = ObjectReteBinaryData(theEnv)->PatternNodeCount * sizeof(struct objectPatternNode);   if (space != 0) genfree(theEnv,(void *) ObjectReteBinaryData(theEnv)->PatternArray,space);#endif  }/* =========================================   *****************************************          INTERNALLY VISIBLE FUNCTIONS   =========================================   ***************************************** */#if BLOAD_AND_BSAVE/***************************************************  NAME         : BsaveObjectPatternsFind  DESCRIPTION  : Sets the Bsave IDs for the object                 pattern data structures and                 determines how much space                 (including padding) is necessary                 for the alpha node bitmPS  INPUTS       : None  RETURNS      : Nothing useful  SIDE EFFECTS : Counts written  NOTES        : None ***************************************************/static void BsaveObjectPatternsFind(  void *theEnv)  {   OBJECT_ALPHA_NODE *alphaPtr;   OBJECT_PATTERN_NODE *patternPtr;   SaveBloadCount(theEnv,ObjectReteBinaryData(theEnv)->AlphaNodeCount);   SaveBloadCount(theEnv,ObjectReteBinaryData(theEnv)->PatternNodeCount);   ObjectReteBinaryData(theEnv)->AlphaNodeCount = 0L;   alphaPtr = ObjectNetworkTerminalPointer(theEnv);   while (alphaPtr != NULL)     {      alphaPtr->classbmp->neededBitMap = TRUE;      if (alphaPtr->slotbmp != NULL)        alphaPtr->slotbmp->neededBitMap = TRUE;      alphaPtr->bsaveID = ObjectReteBinaryData(theEnv)->AlphaNodeCount++;      alphaPtr = alphaPtr->nxtTerminal;     }   ObjectReteBinaryData(theEnv)->PatternNodeCount = 0L;   patternPtr = ObjectNetworkPointer(theEnv);   while (patternPtr != NULL)     {      patternPtr->bsaveID = ObjectReteBinaryData(theEnv)->PatternNodeCount++;      if (patternPtr->nextLevel == NULL)        {         while (patternPtr->rightNode == NULL)           {            patternPtr = patternPtr->lastLevel;            if (patternPtr == NULL)              return;           }         patternPtr = patternPtr->rightNode;        }      else        patternPtr = patternPtr->nextLevel;     }  }/****************************************************  NAME         : BsaveStorageObjectPatterns  DESCRIPTION  : Writes out the number of bytes                 required for object pattern bitmaps,                 and the number of object pattern                 alpha an intermediate nodes  INPUTS       : Bsave file stream pointer  RETURNS      : Nothing useful  SIDE EFFECTS : Counts written  NOTES        : None ****************************************************/static void BsaveStorageObjectPatterns(  void *theEnv,  FILE *fp)  {   size_t space;   space = sizeof(long) * 2;   GenWrite(&space,sizeof(size_t),fp);   GenWrite(&ObjectReteBinaryData(theEnv)->AlphaNodeCount,sizeof(long),fp);   GenWrite(&ObjectReteBinaryData(theEnv)->PatternNodeCount,sizeof(long),fp);  }/***************************************************  NAME         : BsaveObjectPatterns  DESCRIPTION  : Writes ouyt object pattern data                 structures to binary save file  INPUTS       : Bsave file stream pointer  RETURNS      : Nothing useful  SIDE EFFECTS : Data structures written  NOTES        : Extra padding written with alpha                 node bitmaps to ensure correct                 alignment of structues on bload ***************************************************/static void BsaveObjectPatterns(  void *theEnv,  FILE *fp)  {   size_t space;   OBJECT_ALPHA_NODE *alphaPtr;   OBJECT_PATTERN_NODE *patternPtr;   BSAVE_OBJECT_ALPHA_NODE dummyAlpha;   BSAVE_OBJECT_PATTERN_NODE dummyPattern;   space = (sizeof(BSAVE_OBJECT_ALPHA_NODE) * ObjectReteBinaryData(theEnv)->AlphaNodeCount) +           (sizeof(BSAVE_OBJECT_PATTERN_NODE) * ObjectReteBinaryData(theEnv)->PatternNodeCount);   GenWrite(&space,sizeof(size_t),fp);   /* ==========================================      Write out the alpha terminal pattern nodes      ========================================== */   alphaPtr = ObjectNetworkTerminalPointer(theEnv);   while (alphaPtr != NULL)     {      AssignBsavePatternHeaderValues(theEnv,&dummyAlpha.header,&alphaPtr->header);      dummyAlpha.classbmp = (long) alphaPtr->classbmp->bucket;      if (alphaPtr->slotbmp != NULL)