src/clipsrules/core/objrtbin.c Source File

00001    /*******************************************************/
00002    /*      "C" Language Integrated Production System      */
00003    /*                                                     */
00004    /*               CLIPS Version 6.30  10/19/06          */
00005    /*                                                     */
00006    /*                                                     */
00007    /*******************************************************/
00008 
00009 /*************************************************************/
00010 /* Purpose: Binary Load/Save Functions Defrule               */
00011 /*          Object Pattern Network                           */
00012 /*                                                           */
00013 /* Principal Programmer(s):                                  */
00014 /*      Brian L. Dantes                                      */
00015 /*                                                           */
00016 /* Contributing Programmer(s):                               */
00017 /*                                                           */
00018 /* Revision History:                                         */
00019 /*                                                           */
00020 /*      6.24: Converted INSTANCE_PATTERN_MATCHING to         */
00021 /*            DEFRULE_CONSTRUCT.                             */
00022 /*                                                           */
00023 /*            ResetObjectMatchTimeTags did not pass in the   */
00024 /*            environment argument when BLOAD_ONLY was set.  */
00025 /*                                                           */
00026 /*      6.30: Added support for hashed alpha memories.       */
00027 /*                                                           */
00028 /*************************************************************/
00029 
00030 /* =========================================
00031    *****************************************
00032                EXTERNAL DEFINITIONS
00033    =========================================
00034    ***************************************** */
00035 #include "setup.h"
00036 
00037 #if DEFRULE_CONSTRUCT && OBJECT_SYSTEM && (BLOAD || BLOAD_ONLY || BLOAD_AND_BSAVE)
00038 
00039 #include "bload.h"
00040 #include "bsave.h"
00041 #include "envrnmnt.h"
00042 #include "memalloc.h"
00043 #include "insfun.h"
00044 #include "objrtmch.h"
00045 #include "reteutil.h"
00046 #include "rulebin.h"
00047 
00048 #define _OBJRTBIN_SOURCE_
00049 #include "objrtbin.h"
00050 
00051 /* =========================================
00052    *****************************************
00053                MACROS AND TYPES
00054    =========================================
00055    ***************************************** */
00056 typedef unsigned long UNLN;
00057 
00058 typedef struct bsaveObjectPatternNode
00059   {
00060    unsigned multifieldNode : 1;
00061    unsigned endSlot        : 1;
00062    unsigned selector       : 1;
00063    unsigned whichField     : 8;
00064    unsigned short leaveFields;
00065    unsigned slotNameID;
00066    long networkTest,
00067         nextLevel,
00068         lastLevel,
00069         leftNode,
00070         rightNode,
00071         alphaNode;
00072   } BSAVE_OBJECT_PATTERN_NODE;
00073 
00074 typedef struct bsaveObjectAlphaNode
00075   {
00076    struct bsavePatternNodeHeader header;
00077    long classbmp,
00078         slotbmp,
00079         patternNode,
00080         nxtInGroup,
00081         nxtTerminal;
00082   } BSAVE_OBJECT_ALPHA_NODE;
00083 
00084 #define BsaveObjectPatternIndex(op) ((op != NULL) ? op->bsaveID : -1L)
00085 #define BsaveObjectAlphaIndex(ap)   ((ap != NULL) ? ap->bsaveID : -1L)
00086 
00087 #define ObjectPatternPointer(i) ((i == -1L) ? NULL : (OBJECT_PATTERN_NODE *) &ObjectReteBinaryData(theEnv)->PatternArray[i])
00088 #define ObjectAlphaPointer(i)   ((i == -1L) ? NULL : (OBJECT_ALPHA_NODE *) &ObjectReteBinaryData(theEnv)->AlphaArray[i])
00089 
00090 /* =========================================
00091    *****************************************
00092       INTERNALLY VISIBLE FUNCTION HEADERS
00093    =========================================
00094    ***************************************** */
00095 
00096 #if BLOAD_AND_BSAVE
00097 static void BsaveObjectPatternsFind(void *);
00098 static void BsaveStorageObjectPatterns(void *,FILE *);
00099 static void BsaveObjectPatterns(void *,FILE *);
00100 #endif
00101 static void BloadStorageObjectPatterns(void *);
00102 static void BloadObjectPatterns(void *);
00103 static void UpdateAlpha(void *,void *,long);
00104 static void UpdatePattern(void *,void *,long);
00105 static void ClearBloadObjectPatterns(void *);
00106 static void DeallocateObjectReteBinaryData(void *);
00107 
00108 /* =========================================
00109    *****************************************
00110           EXTERNALLY VISIBLE FUNCTIONS
00111    =========================================
00112    ***************************************** */
00113 
00114 /***********************************************************
00115   NAME         : SetupObjectPatternsBload
00116   DESCRIPTION  : Initializes data structures and
00117                    routines for binary loads of
00118                    generic function constructs
00119   INPUTS       : None
00120   RETURNS      : Nothing useful
00121   SIDE EFFECTS : Routines defined and structures initialized
00122   NOTES        : None
00123  ***********************************************************/
00124 globle void SetupObjectPatternsBload(
00125   void *theEnv)
00126   {
00127    AllocateEnvironmentData(theEnv,OBJECTRETEBIN_DATA,sizeof(struct objectReteBinaryData),DeallocateObjectReteBinaryData);
00128 
00129 #if BLOAD_AND_BSAVE
00130    AddBinaryItem(theEnv,"object patterns",0,BsaveObjectPatternsFind,NULL,
00131                              BsaveStorageObjectPatterns,BsaveObjectPatterns,
00132                              BloadStorageObjectPatterns,BloadObjectPatterns,
00133                              ClearBloadObjectPatterns);
00134 #endif
00135 #if BLOAD || BLOAD_ONLY
00136    AddBinaryItem(theEnv,"object patterns",0,NULL,NULL,NULL,NULL,
00137                              BloadStorageObjectPatterns,BloadObjectPatterns,
00138                              ClearBloadObjectPatterns);
00139 #endif
00140   }
00141   
00142 /***********************************************************/
00143 /* DeallocateObjectReteBinaryData: Deallocates environment */
00144 /*    data for object rete binary functionality.           */
00145 /***********************************************************/
00146 static void DeallocateObjectReteBinaryData(
00147   void *theEnv)
00148   {
00149 #if (BLOAD || BLOAD_ONLY || BLOAD_AND_BSAVE) && (! RUN_TIME)
00150    size_t space;
00151    long i;
00152 
00153    for (i = 0; i < ObjectReteBinaryData(theEnv)->AlphaNodeCount; i++)
00154      { DestroyAlphaMemory(theEnv,&ObjectReteBinaryData(theEnv)->AlphaArray[i].header,FALSE); }
00155 
00156    space = ObjectReteBinaryData(theEnv)->AlphaNodeCount * sizeof(struct objectAlphaNode);
00157    if (space != 0) genfree(theEnv,(void *) ObjectReteBinaryData(theEnv)->AlphaArray,space);
00158 
00159    space = ObjectReteBinaryData(theEnv)->PatternNodeCount * sizeof(struct objectPatternNode);
00160    if (space != 0) genfree(theEnv,(void *) ObjectReteBinaryData(theEnv)->PatternArray,space);
00161 
00162 #endif
00163   }
00164 
00165 /* =========================================
00166    *****************************************
00167           INTERNALLY VISIBLE FUNCTIONS
00168    =========================================
00169    ***************************************** */
00170 
00171 #if BLOAD_AND_BSAVE
00172 
00173 /***************************************************
00174   NAME         : BsaveObjectPatternsFind
00175   DESCRIPTION  : Sets the Bsave IDs for the object
00176                  pattern data structures and
00177                  determines how much space
00178                  (including padding) is necessary
00179                  for the alpha node bitmPS
00180   INPUTS       : None
00181   RETURNS      : Nothing useful
00182   SIDE EFFECTS : Counts written
00183   NOTES        : None
00184  ***************************************************/
00185 static void BsaveObjectPatternsFind(
00186   void *theEnv)
00187   {
00188    OBJECT_ALPHA_NODE *alphaPtr;
00189    OBJECT_PATTERN_NODE *patternPtr;
00190 
00191    SaveBloadCount(theEnv,ObjectReteBinaryData(theEnv)->AlphaNodeCount);
00192    SaveBloadCount(theEnv,ObjectReteBinaryData(theEnv)->PatternNodeCount);
00193 
00194    ObjectReteBinaryData(theEnv)->AlphaNodeCount = 0L;
00195    alphaPtr = ObjectNetworkTerminalPointer(theEnv);
00196    while (alphaPtr != NULL)
00197      {
00198       alphaPtr->classbmp->neededBitMap = TRUE;
00199       if (alphaPtr->slotbmp != NULL)
00200         alphaPtr->slotbmp->neededBitMap = TRUE;
00201       alphaPtr->bsaveID = ObjectReteBinaryData(theEnv)->AlphaNodeCount++;
00202       alphaPtr = alphaPtr->nxtTerminal;
00203      }
00204 
00205    ObjectReteBinaryData(theEnv)->PatternNodeCount = 0L;
00206    patternPtr = ObjectNetworkPointer(theEnv);
00207    while (patternPtr != NULL)
00208      {
00209       patternPtr->bsaveID = ObjectReteBinaryData(theEnv)->PatternNodeCount++;
00210       if (patternPtr->nextLevel == NULL)
00211         {
00212          while (patternPtr->rightNode == NULL)
00213            {
00214             patternPtr = patternPtr->lastLevel;
00215             if (patternPtr == NULL)
00216               return;
00217            }
00218          patternPtr = patternPtr->rightNode;
00219         }
00220       else
00221         patternPtr = patternPtr->nextLevel;
00222      }
00223   }
00224 
00225 /****************************************************
00226   NAME         : BsaveStorageObjectPatterns
00227   DESCRIPTION  : Writes out the number of bytes
00228                  required for object pattern bitmaps,
00229                  and the number of object pattern
00230                  alpha an intermediate nodes
00231   INPUTS       : Bsave file stream pointer
00232   RETURNS      : Nothing useful
00233   SIDE EFFECTS : Counts written
00234   NOTES        : None
00235  ****************************************************/
00236 static void BsaveStorageObjectPatterns(
00237   void *theEnv,
00238   FILE *fp)
00239   {
00240    size_t space;
00241 
00242    space = sizeof(long) * 2;
00243    GenWrite(&space,sizeof(size_t),fp);
00244    GenWrite(&ObjectReteBinaryData(theEnv)->AlphaNodeCount,sizeof(long),fp);
00245    GenWrite(&ObjectReteBinaryData(theEnv)->PatternNodeCount,sizeof(long),fp);
00246   }
00247 
00248 /***************************************************
00249   NAME         : BsaveObjectPatterns
00250   DESCRIPTION  : Writes ouyt object pattern data
00251                  structures to binary save file
00252   INPUTS       : Bsave file stream pointer
00253   RETURNS      : Nothing useful
00254   SIDE EFFECTS : Data structures written
00255   NOTES        : Extra padding written with alpha
00256                  node bitmaps to ensure correct
00257                  alignment of structues on bload
00258  ***************************************************/
00259 static void BsaveObjectPatterns(
00260   void *theEnv,
00261   FILE *fp)
00262   {
00263    size_t space;
00264    OBJECT_ALPHA_NODE *alphaPtr;
00265    OBJECT_PATTERN_NODE *patternPtr;
00266    BSAVE_OBJECT_ALPHA_NODE dummyAlpha;
00267    BSAVE_OBJECT_PATTERN_NODE dummyPattern;
00268 
00269    space = (sizeof(BSAVE_OBJECT_ALPHA_NODE) * ObjectReteBinaryData(theEnv)->AlphaNodeCount) +
00270            (sizeof(BSAVE_OBJECT_PATTERN_NODE) * ObjectReteBinaryData(theEnv)->PatternNodeCount);
00271    GenWrite(&space,sizeof(size_t),fp);
00272 
00273    /* ==========================================
00274       Write out the alpha terminal pattern nodes
00275       ========================================== */
00276    alphaPtr = ObjectNetworkTerminalPointer(theEnv);
00277    while (alphaPtr != NULL)
00278      {
00279       AssignBsavePatternHeaderValues(theEnv,&dummyAlpha.header,&alphaPtr->header);
00280       dummyAlpha.classbmp = (long) alphaPtr->classbmp->bucket;
00281       if (alphaPtr->slotbmp != NULL)
00282         dummyAlpha.slotbmp = (long) alphaPtr->slotbmp->bucket;
00283       else
00284         dummyAlpha.slotbmp = -1L;
00285       dummyAlpha.patternNode = BsaveObjectPatternIndex(alphaPtr->patternNode);
00286       dummyAlpha.nxtInGroup = BsaveObjectAlphaIndex(alphaPtr->nxtInGroup);
00287       dummyAlpha.nxtTerminal = BsaveObjectAlphaIndex(alphaPtr->nxtTerminal);
00288       GenWrite(&dummyAlpha,sizeof(BSAVE_OBJECT_ALPHA_NODE),fp);
00289       alphaPtr = alphaPtr->nxtTerminal;
00290      }
00291 
00292    /* ========================================
00293       Write out the intermediate pattern nodes
00294       ======================================== */
00295    patternPtr = ObjectNetworkPointer(theEnv);
00296    while (patternPtr != NULL)
00297      {
00298       dummyPattern.multifieldNode = patternPtr->multifieldNode;
00299       dummyPattern.whichField = patternPtr->whichField;
00300       dummyPattern.leaveFields = patternPtr->leaveFields;
00301       dummyPattern.endSlot = patternPtr->endSlot;
00302       dummyPattern.selector = patternPtr->selector;
00303       dummyPattern.slotNameID = patternPtr->slotNameID;
00304       dummyPattern.networkTest = HashedExpressionIndex(theEnv,patternPtr->networkTest);
00305       dummyPattern.nextLevel = BsaveObjectPatternIndex(patternPtr->nextLevel);
00306       dummyPattern.lastLevel = BsaveObjectPatternIndex(patternPtr->lastLevel);
00307       dummyPattern.leftNode = BsaveObjectPatternIndex(patternPtr->leftNode);
00308       dummyPattern.rightNode = BsaveObjectPatternIndex(patternPtr->rightNode);
00309       dummyPattern.alphaNode = BsaveObjectAlphaIndex(patternPtr->alphaNode);
00310       GenWrite(&dummyPattern,sizeof(BSAVE_OBJECT_PATTERN_NODE),fp);
00311 
00312       if (patternPtr->nextLevel == NULL)
00313         {
00314          while (patternPtr->rightNode == NULL)
00315            {
00316             patternPtr = patternPtr->lastLevel;
00317             if (patternPtr == NULL)
00318               {
00319                RestoreBloadCount(theEnv,&ObjectReteBinaryData(theEnv)->AlphaNodeCount);
00320                RestoreBloadCount(theEnv,&ObjectReteBinaryData(theEnv)->PatternNodeCount);
00321                return;
00322               }
00323            }
00324          patternPtr = patternPtr->rightNode;
00325         }
00326       else
00327         patternPtr = patternPtr->nextLevel;
00328      }
00329 
00330    RestoreBloadCount(theEnv,&ObjectReteBinaryData(theEnv)->AlphaNodeCount);
00331    RestoreBloadCount(theEnv,&ObjectReteBinaryData(theEnv)->PatternNodeCount);
00332   }
00333 
00334 #endif
00335 
00336 /***************************************************
00337   NAME         : BloadStorageObjectPatterns
00338   DESCRIPTION  : Reads in the storage requirements
00339                  for the object patterns in this
00340                  bload image
00341   INPUTS       : None
00342   RETURNS      : Nothing useful
00343   SIDE EFFECTS : Counts read and arrays allocated
00344   NOTES        : None
00345  ***************************************************/
00346 static void BloadStorageObjectPatterns(
00347   void *theEnv)
00348   {
00349    size_t space;
00350    long counts[2];
00351 
00352    GenReadBinary(theEnv,(void *) &space,sizeof(size_t));
00353    GenReadBinary(theEnv,(void *) counts,space);
00354    ObjectReteBinaryData(theEnv)->AlphaNodeCount = counts[0];
00355    ObjectReteBinaryData(theEnv)->PatternNodeCount = counts[1];
00356 
00357    if (ObjectReteBinaryData(theEnv)->AlphaNodeCount == 0L)
00358      ObjectReteBinaryData(theEnv)->AlphaArray = NULL;
00359    else
00360      {
00361       space = (ObjectReteBinaryData(theEnv)->AlphaNodeCount * sizeof(OBJECT_ALPHA_NODE));
00362       ObjectReteBinaryData(theEnv)->AlphaArray = (OBJECT_ALPHA_NODE *) genalloc(theEnv,space);
00363      }
00364    if (ObjectReteBinaryData(theEnv)->PatternNodeCount == 0L)
00365      ObjectReteBinaryData(theEnv)->PatternArray = NULL;
00366    else
00367      {
00368       space = (ObjectReteBinaryData(theEnv)->PatternNodeCount * sizeof(OBJECT_PATTERN_NODE));
00369       ObjectReteBinaryData(theEnv)->PatternArray = (OBJECT_PATTERN_NODE *) genalloc(theEnv,space);
00370      }
00371   }
00372 
00373 /****************************************************
00374   NAME         : BloadObjectPatterns
00375   DESCRIPTION  : Reads in all object pattern
00376                  data structures from binary
00377                  image and updates pointers
00378   INPUTS       : None
00379   RETURNS      : Nothing useful
00380   SIDE EFFECTS : Binary data structures updated
00381   NOTES        : Assumes storage allocated previously
00382  ****************************************************/
00383 static void BloadObjectPatterns(
00384   void *theEnv)
00385   {
00386    size_t space;
00387    long i;
00388 
00389    GenReadBinary(theEnv,(void *) &space,sizeof(size_t));
00390    if (space == 0L)
00391      return;
00392 
00393    /* ================================================
00394       Read in the alpha and intermediate pattern nodes
00395       ================================================ */
00396    BloadandRefresh(theEnv,ObjectReteBinaryData(theEnv)->AlphaNodeCount,sizeof(BSAVE_OBJECT_ALPHA_NODE),UpdateAlpha);
00397    BloadandRefresh(theEnv,ObjectReteBinaryData(theEnv)->PatternNodeCount,sizeof(BSAVE_OBJECT_PATTERN_NODE),UpdatePattern);
00398 
00399    for (i = 0; i < ObjectReteBinaryData(theEnv)->PatternNodeCount; i++)
00400      {
00401       if ((ObjectReteBinaryData(theEnv)->PatternArray[i].lastLevel != NULL) &&
00402           (ObjectReteBinaryData(theEnv)->PatternArray[i].lastLevel->selector))
00403         { 
00404          AddHashedPatternNode(theEnv,ObjectReteBinaryData(theEnv)->PatternArray[i].lastLevel,
00405                                      &ObjectReteBinaryData(theEnv)->PatternArray[i],
00406                                      ObjectReteBinaryData(theEnv)->PatternArray[i].networkTest->type,
00407                                      ObjectReteBinaryData(theEnv)->PatternArray[i].networkTest->value); 
00408         }
00409      }
00410 
00411    /* =======================
00412       Set the global pointers
00413       ======================= */
00414    SetObjectNetworkTerminalPointer(theEnv,(OBJECT_ALPHA_NODE *) &ObjectReteBinaryData(theEnv)->AlphaArray[0]);
00415    SetObjectNetworkPointer(theEnv,(OBJECT_PATTERN_NODE *) &ObjectReteBinaryData(theEnv)->PatternArray[0]);
00416   }
00417 
00418 /***************************************************
00419   NAME         : UpdateAlpha
00420   DESCRIPTION  : Updates all the pointers for an
00421                  alpha node based on the binary
00422                  image indices
00423   INPUTS       : 1) A pointer to the binary
00424                     image alpha node buffer
00425                  2) The index of the actual
00426                     alpha node in the array
00427   RETURNS      : Nothing useful
00428   SIDE EFFECTS : Alpha node updated
00429   NOTES        : None
00430  ***************************************************/
00431 static void UpdateAlpha(
00432   void *theEnv,
00433   void *buf,
00434   long obji)
00435   {
00436    BSAVE_OBJECT_ALPHA_NODE *bap;
00437    OBJECT_ALPHA_NODE *ap;
00438 
00439    bap = (BSAVE_OBJECT_ALPHA_NODE *) buf;
00440    ap = (OBJECT_ALPHA_NODE *) &ObjectReteBinaryData(theEnv)->AlphaArray[obji];
00441 
00442    UpdatePatternNodeHeader(theEnv,&ap->header,&bap->header);
00443    ap->matchTimeTag = 0L;
00444    ap->classbmp = BitMapPointer(bap->classbmp);
00445    if (bap->slotbmp != -1L)
00446      {
00447       ap->slotbmp = BitMapPointer(bap->slotbmp);
00448       IncrementBitMapCount(ap->slotbmp);
00449      }
00450    else
00451      ap->slotbmp = NULL;
00452    IncrementBitMapCount(ap->classbmp);
00453    ap->patternNode = ObjectPatternPointer(bap->patternNode);
00454    ap->nxtInGroup = ObjectAlphaPointer(bap->nxtInGroup);
00455    ap->nxtTerminal = ObjectAlphaPointer(bap->nxtTerminal);
00456    ap->bsaveID = 0L;
00457   }
00458 
00459 /***************************************************
00460   NAME         : UpdatePattern
00461   DESCRIPTION  : Updates all the pointers for a
00462                  pattern node based on the binary
00463                  image indices
00464   INPUTS       : 1) A pointer to the binary
00465                     image pattern node buffer
00466                  2) The index of the actual
00467                     pattern node in the array
00468   RETURNS      : Nothing useful
00469   SIDE EFFECTS : Pattern node updated
00470   NOTES        : None
00471  ***************************************************/
00472 static void UpdatePattern(
00473   void *theEnv,
00474   void *buf,
00475   long obji)
00476   {
00477    BSAVE_OBJECT_PATTERN_NODE *bop;
00478    OBJECT_PATTERN_NODE *op;
00479 
00480    bop = (BSAVE_OBJECT_PATTERN_NODE *) buf;
00481    op = (OBJECT_PATTERN_NODE *) &ObjectReteBinaryData(theEnv)->PatternArray[obji];
00482 
00483    op->blocked = FALSE;
00484    op->multifieldNode = bop->multifieldNode;
00485    op->whichField = bop->whichField;
00486    op->leaveFields = bop->leaveFields;
00487    op->endSlot = bop->endSlot;
00488    op->selector = bop->selector;
00489    op->matchTimeTag = 0L;
00490    op->slotNameID = bop->slotNameID;
00491    op->networkTest = HashedExpressionPointer(bop->networkTest);
00492    op->nextLevel = ObjectPatternPointer(bop->nextLevel);
00493    op->lastLevel = ObjectPatternPointer(bop->lastLevel);
00494    op->leftNode = ObjectPatternPointer(bop->leftNode);
00495    op->rightNode = ObjectPatternPointer(bop->rightNode);
00496    op->alphaNode = ObjectAlphaPointer(bop->alphaNode);
00497    op->bsaveID = 0L;
00498   }
00499 
00500 /***************************************************
00501   NAME         : ClearBloadObjectPatterns
00502   DESCRIPTION  : Releases all emmory associated
00503                  with binary image object patterns
00504   INPUTS       : None
00505   RETURNS      : Nothing useful
00506   SIDE EFFECTS : Memory released and global
00507                  network pointers set to NULL
00508   NOTES        : None
00509  ***************************************************/
00510 static void ClearBloadObjectPatterns(
00511   void *theEnv)
00512   {
00513    size_t space;
00514    register long i;
00515 
00516    for (i = 0; i < ObjectReteBinaryData(theEnv)->PatternNodeCount; i++)
00517      {
00518       if ((ObjectReteBinaryData(theEnv)->PatternArray[i].lastLevel != NULL) &&
00519           (ObjectReteBinaryData(theEnv)->PatternArray[i].lastLevel->selector))
00520         { 
00521          RemoveHashedPatternNode(theEnv,ObjectReteBinaryData(theEnv)->PatternArray[i].lastLevel,
00522                                         &ObjectReteBinaryData(theEnv)->PatternArray[i],
00523                                         ObjectReteBinaryData(theEnv)->PatternArray[i].networkTest->type,
00524                                         ObjectReteBinaryData(theEnv)->PatternArray[i].networkTest->value); 
00525         }
00526      }
00527 
00528    /* ================================================
00529       All instances have been deleted by this point
00530       so we don't need to worry about clearing partial
00531       matches
00532       ================================================ */
00533    for (i = 0L ; i < ObjectReteBinaryData(theEnv)->AlphaNodeCount ; i++)
00534      {
00535       DecrementBitMapCount(theEnv,ObjectReteBinaryData(theEnv)->AlphaArray[i].classbmp);
00536       if (ObjectReteBinaryData(theEnv)->AlphaArray[i].slotbmp != NULL)
00537         DecrementBitMapCount(theEnv,ObjectReteBinaryData(theEnv)->AlphaArray[i].slotbmp);
00538      }
00539 
00540    if (ObjectReteBinaryData(theEnv)->AlphaNodeCount != 0L)
00541      {
00542       space = (ObjectReteBinaryData(theEnv)->AlphaNodeCount * sizeof(OBJECT_ALPHA_NODE));
00543       genfree(theEnv,(void *) ObjectReteBinaryData(theEnv)->AlphaArray,space);
00544       ObjectReteBinaryData(theEnv)->AlphaArray = NULL;
00545       ObjectReteBinaryData(theEnv)->AlphaNodeCount = 0;
00546       space = (ObjectReteBinaryData(theEnv)->PatternNodeCount * sizeof(OBJECT_PATTERN_NODE));
00547       genfree(theEnv,(void *) ObjectReteBinaryData(theEnv)->PatternArray,space);
00548       ObjectReteBinaryData(theEnv)->PatternArray = NULL;
00549       ObjectReteBinaryData(theEnv)->PatternNodeCount = 0;
00550      }
00551 
00552    SetObjectNetworkTerminalPointer(theEnv,NULL);
00553    SetObjectNetworkPointer(theEnv,NULL);
00554 #if BLOAD_ONLY
00555    ResetObjectMatchTimeTags(theEnv);
00556 #endif
00557   }
00558 
00559 #endif
00560