static void DeallocateObjectReteBinaryData( void *theEnv) { #if (BLOAD || BLOAD_ONLY || BLOAD_AND_BSAVE) && (! RUN_TIME) unsigned long space; long i; for (i = 0; i < ObjectReteBinaryData(theEnv)->AlphaNodeCount; i++) { DestroyAlphaBetaMemory(theEnv,ObjectReteBinaryData(theEnv)->AlphaArray[i].header.alphaMemory); } space = ObjectReteBinaryData(theEnv)->AlphaNodeCount * sizeof(struct objectAlphaNode); if (space != 0) genlongfree(theEnv,(void *) ObjectReteBinaryData(theEnv)->AlphaArray,space); space = ObjectReteBinaryData(theEnv)->PatternNodeCount * sizeof(struct objectPatternNode); if (space != 0) genlongfree(theEnv,(void *) ObjectReteBinaryData(theEnv)->PatternArray,space); #endif }
static void DestroyObjectAlphaNodes( void *theEnv, OBJECT_ALPHA_NODE *theNode) { OBJECT_ALPHA_NODE *nodePtr; if (theNode == NULL) return; while (theNode != NULL) { nodePtr = theNode->nxtInGroup; DestroyAlphaBetaMemory(theEnv,theNode->header.alphaMemory); #if ! RUN_TIME rtn_struct(theEnv,objectAlphaNode,theNode); #endif theNode = nodePtr; } }
static void DeallocateDefruleBloadData( void *theEnv) { #if (BLOAD || BLOAD_ONLY || BLOAD_AND_BSAVE) && (! RUN_TIME) unsigned long space; long i; struct defruleModule *theModuleItem; struct activation *theActivation, *tmpActivation; for (i = 0; i < DefruleBinaryData(theEnv)->NumberOfJoins; i++) { DestroyAlphaBetaMemory(theEnv,DefruleBinaryData(theEnv)->JoinArray[i].beta); } for (i = 0; i < DefruleBinaryData(theEnv)->NumberOfDefruleModules; i++) { theModuleItem = &DefruleBinaryData(theEnv)->ModuleArray[i]; theActivation = theModuleItem->agenda; while (theActivation != NULL) { tmpActivation = theActivation->next; if (theActivation->sortedBasis != NULL) { DestroyPartialMatch(theEnv,theActivation->sortedBasis); } rtn_struct(theEnv,activation,theActivation); theActivation = tmpActivation; } } space = DefruleBinaryData(theEnv)->NumberOfDefruleModules * sizeof(struct defruleModule); if (space != 0) genlongfree(theEnv,(void *) DefruleBinaryData(theEnv)->ModuleArray,space); space = DefruleBinaryData(theEnv)->NumberOfDefrules * sizeof(struct defrule); if (space != 0) genlongfree(theEnv,(void *) DefruleBinaryData(theEnv)->DefruleArray,space); space = DefruleBinaryData(theEnv)->NumberOfJoins * sizeof(struct joinNode); if (space != 0) genlongfree(theEnv,(void *) DefruleBinaryData(theEnv)->JoinArray,space); #endif }
globle void DestroyFactPatternNetwork( void *theEnv, struct factPatternNode *thePattern) { struct factPatternNode *patternPtr; if (thePattern == NULL) return; while (thePattern != NULL) { patternPtr = thePattern->rightNode; DestroyFactPatternNetwork(theEnv,thePattern->nextLevel); DestroyAlphaBetaMemory(theEnv,thePattern->header.alphaMemory); #if (! BLOAD_ONLY) && (! RUN_TIME) rtn_struct(theEnv,factPatternNode,thePattern); #endif thePattern = patternPtr; } }
static void DetachJoins( void *theEnv, struct defrule *theRule, BOOLEAN destroy) { struct joinNode *join; struct joinNode *prevJoin; struct joinNode *joinPtr, *lastJoin, *rightJoin; /*==================================*/ /* Find the last join for the rule. */ /*==================================*/ join = theRule->lastJoin; theRule->lastJoin = NULL; if (join == NULL) return; /*===================================================*/ /* Remove the activation link from the last join. If */ /* there are joins below this join, then all of the */ /* joins for this rule were shared with another rule */ /* and thus no joins can be deleted. */ /*===================================================*/ join->ruleToActivate = NULL; if (join->nextLevel != NULL) return; /*===========================*/ /* Begin removing the joins. */ /*===========================*/ while (join != NULL) { /*==========================================================*/ /* Remember the join "above" this join (the one that enters */ /* from the left). If the join is entered from the right by */ /* another join, remember the right entering join as well. */ /*==========================================================*/ prevJoin = join->lastLevel; if (join->joinFromTheRight) { rightJoin = (struct joinNode *) join->rightSideEntryStructure; } else { rightJoin = NULL; } /*=================================================*/ /* If the join was attached to a pattern, remove */ /* any structures associated with the pattern that */ /* are no longer needed. */ /*=================================================*/ #if (! RUN_TIME) && (! BLOAD_ONLY) if (! destroy) { if ((join->rightSideEntryStructure != NULL) && (join->joinFromTheRight == FALSE)) { RemoveIntranetworkLink(theEnv,join); } } #endif /*======================================*/ /* Remove any partial matches contained */ /* in the beta memory of the join. */ /*======================================*/ if (destroy) { DestroyAlphaBetaMemory(theEnv,join->beta); } else { FlushAlphaBetaMemory(theEnv,join->beta); } join->beta = NULL; /*===================================*/ /* Remove the expressions associated */ /* with the join. */ /*===================================*/ #if (! RUN_TIME) && (! BLOAD_ONLY) if (! destroy) { RemoveHashedExpression(theEnv,join->networkTest); } #endif /*==================================================*/ /* Remove the link to the join from the join above. */ /*==================================================*/ if (prevJoin == NULL) { #if (! RUN_TIME) && (! BLOAD_ONLY) rtn_struct(theEnv,joinNode,join); #endif return; } lastJoin = NULL; joinPtr = prevJoin->nextLevel; while (joinPtr != NULL) { if (joinPtr == join) { if (lastJoin == NULL) { prevJoin->nextLevel = joinPtr->rightDriveNode; } else { lastJoin->rightDriveNode = joinPtr->rightDriveNode; } joinPtr = NULL; } else { lastJoin = joinPtr; joinPtr = joinPtr->rightDriveNode; } } /*==================*/ /* Delete the join. */ /*==================*/ #if (! RUN_TIME) && (! BLOAD_ONLY) rtn_struct(theEnv,joinNode,join); #endif /*==========================================*/ /* Remove the right join link if it exists. */ /*==========================================*/ if (rightJoin != NULL) { rightJoin->nextLevel = NULL; prevJoin = rightJoin; } /*===========================================================*/ /* Move on to the next join to be removed. All the joins of */ /* a rule can be deleted by following the right joins links */ /* (when these links exist) and then following the left join */ /* links. This works because if join A enters join B from */ /* the right, the right/left links of join A eventually lead */ /* to the join which enters join B from the left. */ /*===========================================================*/ if (prevJoin->ruleToActivate != NULL) { join = NULL; } else if (prevJoin->nextLevel == NULL) { join = prevJoin; } else { join = NULL; } } }