/************************************************************//* DestroyPMDependencies: Removes all logical support links *//*   from a partial match that point to any data entities.  *//************************************************************/globle void DestroyPMDependencies(  void *theEnv,  struct partialMatch *theBinds)  {   struct dependency *fdPtr, *nextPtr;   fdPtr = (struct dependency *) theBinds->dependents;   while (fdPtr != NULL)     {      nextPtr = fdPtr->next;      rtn_struct(theEnv,dependency,fdPtr);      fdPtr = nextPtr;     }   theBinds->dependents = NULL;  }/************************************************************************//* RemoveLogicalSupport: Removes the dependency links between a partial *//*   match and the data entities it logically supports. Also removes    *//*   the associated links from the data entities which point back to    *//*   the partial match by calling DetachAssociatedEntityDependencies.   *//*   If an entity has all of its logical support removed as a result of *//*   this procedure, the dependency link from the partial match is      *//*   added to the list of unsupported data entities so that the entity  *//*   will be deleted as a result of losing its logical support.         *//************************************************************************/globle void RemoveLogicalSupport(  void *theEnv,  struct partialMatch *theBinds)  {   struct dependency *dlPtr, *tempPtr, *theList;   struct patternEntity *theEntity;   /*========================================*/   /* If the partial match has no associated */   /* dependencies, then return.             */   /*========================================*/   if (theBinds->dependents == NULL) return;   /*=======================================*/   /* Loop through each of the dependencies */   /* attached to the partial match.        */   /*=======================================*/   dlPtr = (struct dependency *) theBinds->dependents;   while (dlPtr != NULL)     {      /*===============================*/      /* Remember the next dependency. */      /*===============================*/      tempPtr = dlPtr->next;      /*==========================================================*/      /* Determine the data entity associated with the dependency */      /* structure and delete its dependency references to this   */      /* partial match.                                           */      /*==========================================================*/      theEntity = (struct patternEntity *) dlPtr->dPtr;      theList = (struct dependency *) theEntity->dependents;      theList = DetachAssociatedDependencies(theEnv,theList,(void *) theBinds);      theEntity->dependents = (void *) theList;      /*==============================================================*/      /* If the data entity has lost all of its logical support, then */      /* add the dependency structure from the partial match to the   */      /* list of unsupported data entities to be deleted. Otherwise,  */      /* just delete the dependency structure.                        */      /*==============================================================*/      if (theEntity->dependents == NULL)        {         (*theEntity->theInfo->base.incrementBusyCount)(theEnv,theEntity);         dlPtr->next = EngineData(theEnv)->UnsupportedDataEntities;         EngineData(theEnv)->UnsupportedDataEntities = dlPtr;        }      else        { rtn_struct(theEnv,dependency,dlPtr); }      /*==================================*/      /* Move on to the next dependency.  */      /*==================================*/      dlPtr = tempPtr;     }   /*=====================================*/   /* The partial match no longer has any */   /* dependencies associated with it.    */   /*=====================================*/   theBinds->dependents = NULL;  }/********************************************************************//* ForceLogicalRetractions: Deletes the data entities found on the  *//*   list of items that have lost their logical support. The delete *//*   function associated with each data entity is called to delete  *//*   that data entity. Calling the delete function may in turn      *//*   add more data entities to the list of data entities which have *//*   lost their logical support.                                    *//********************************************************************/globle void ForceLogicalRetractions(  void *theEnv)  {   struct dependency *tempPtr;   struct patternEntity *theEntity;   /*===================================================*/   /* Don't reenter this function once it's called. Any */   /* new additions to the list of items to be deleted  */   /* as a result of losing their logical support will  */   /* be handled properly.                              */   /*===================================================*/   if (EngineData(theEnv)->alreadyEntered) return;   EngineData(theEnv)->alreadyEntered = TRUE;   /*=======================================================*/   /* Continue to delete the first item on the list as long */   /* as one exists. This is done because new items may be  */   /* placed at the beginning of the list as other data     */   /* entities are deleted.                                 */   /*=======================================================*/   while (EngineData(theEnv)->UnsupportedDataEntities != NULL)     {      /*==========================================*/      /* Determine the data entity to be deleted. */      /*==========================================*/      theEntity = (struct patternEntity *) EngineData(theEnv)->UnsupportedDataEntities->dPtr;      /*================================================*/      /* Remove the dependency structure from the list. */      /*================================================*/      tempPtr = EngineData(theEnv)->UnsupportedDataEntities;      EngineData(theEnv)->UnsupportedDataEntities = EngineData(theEnv)->UnsupportedDataEntities->next;      rtn_struct(theEnv,dependency,tempPtr);      /*=========================*/      /* Delete the data entity. */      /*=========================*/      (*theEntity->theInfo->base.decrementBusyCount)(theEnv,theEntity);      (*theEntity->theInfo->base.deleteFunction)(theEnv,theEntity);     }   /*============================================*/   /* Deletion of items on the list is complete. */   /*============================================*/   EngineData(theEnv)->alreadyEntered = FALSE;  }/****************************************************************//* Dependencies: C access routine for the dependencies command. *//****************************************************************/globle void Dependencies(  void *theEnv,  struct patternEntity *theEntity)  {   struct dependency *fdPtr;   /*=========================================*/   /* If the data entity has no dependencies, */   /* then print "None" and return.           */   /*=========================================*/   if (theEntity->dependents == NULL)     {      EnvPrintRouter(theEnv,WDISPLAY,"None\n");      return;     }   /*============================================*/   /* Loop through the list of the data entities */   /* dependencies and print them.               */   /*============================================*/   for (fdPtr = (struct dependency *) theEntity->dependents;        fdPtr != NULL;        fdPtr = fdPtr->next)     {      if (GetHaltExecution(theEnv) == TRUE) return;      PrintPartialMatch(theEnv,WDISPLAY,(struct partialMatch *) fdPtr->dPtr);      EnvPrintRouter(theEnv,WDISPLAY,"\n");     }  }/************************************************************//* Dependents: C access routine for the dependents command. *//************************************************************/globle void Dependents(  void *theEnv,  struct patternEntity *theEntity)  {   struct patternEntity *entityPtr = NULL;   struct patternParser *theParser = NULL;   struct dependency *fdPtr;   struct partialMatch *theBinds;   int found = FALSE;      /*=================================*/   /* Loop through every data entity. */   /*=================================*/   for (GetNextPatternEntity(theEnv,&theParser,&entityPtr);        entityPtr != NULL;        GetNextPatternEntity(theEnv,&theParser,&entityPtr))     {      if (GetHaltExecution(theEnv) == TRUE) return;      /*====================================*/      /* Loop through every dependency link */      /* associated with the data entity.   */      /*====================================*/      for (fdPtr = (struct dependency *) entityPtr->dependents;           fdPtr != NULL;           fdPtr = fdPtr->next)        {         if (GetHaltExecution(theEnv) == TRUE) return;         /*=====================================================*/         /* If the data entity which was the argument passed to */         /* the dependents command is contained in one of the   */         /* partial matches of the data entity currently being  */         /* examined, then the data entity being examined is a  */         /* dependent. Print the data entity and then move on   */         /* to the next data entity.                            */         /*=====================================================*/         theBinds = (struct partialMatch *) fdPtr->dPtr;         if (FindEntityInPartialMatch(theEntity,theBinds) == TRUE)           {            if (found) EnvPrintRouter(theEnv,WDISPLAY,",");            (*entityPtr->theInfo->base.shortPrintFunction)(theEnv,WDISPLAY,entityPtr);            found = TRUE;            break;           }        }     }   /*=================================================*/   /* If no dependents were found, then print "None." */   /* Otherwise print a carriage return after the     */   /* list of dependents.                             */   /*=================================================*/   if (! found) EnvPrintRouter(theEnv,WDISPLAY,"None\n");   else EnvPrintRouter(theEnv,WDISPLAY,"\n");  }#if DEBUGGING_FUNCTIONS/*********************************************//* DependenciesCommand: H/L access routine   *//*   for the dependencies command.           *//*********************************************/globle void DependenciesCommand(  void *theEnv)  {   DATA_OBJECT item;   void *ptr;   if (EnvArgCountCheck(theEnv,"dependencies",EXACTLY,1) == -1) return;   ptr = GetFactOrInstanceArgument(theEnv,1,&item,"dependencies");   if (ptr == NULL) return;#if DEFRULE_CONSTRUCT   Dependencies(theEnv,(struct patternEntity *) ptr);#else   EnvPrintRouter(theEnv,WDISPLAY,"None\n");#endif  }/*******************************************//* DependentsCommand: H/L access routine   *//*   for the dependents command.           *//*******************************************/globle void DependentsCommand(  void *theEnv)  {   DATA_OBJECT item;   void *ptr;   if (EnvArgCountCheck(theEnv,"dependents",EXACTLY,1) == -1) return;   ptr = GetFactOrInstanceArgument(theEnv,1,&item,"dependents");   if (ptr == NULL) return;#if DEFRULE_CONSTRUCT   Dependents(theEnv,(struct patternEntity *) ptr);#else   EnvPrintRouter(theEnv,WDISPLAY,"None\n");#endif  }#endif /* DEBUGGING_FUNCTIONS */#endif /* DEFRULE_CONSTRUCT */