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; }
}
}
