modulutl.c

NASA 开发使用的一个专家系统

   /*******************************************************/
   /*      "C" Language Integrated Production System      */
   /*                                                     */
   /*             CLIPS Version 6.05  04/09/97            */
   /*                                                     */
   /*              DEFMODULE UTILITY MODULE               */
   /*******************************************************/

/*************************************************************/
/* Purpose: Provides routines for parsing module/construct   */
/*   names and searching through modules for specific        */
/*   constructs.                                             */
/*                                                           */
/* Principal Programmer(s):                                  */
/*      Gary D. Riley                                        */
/*                                                           */
/* Contributing Programmer(s):                               */
/*      Brian L. Donnell                                     */
/*                                                           */
/* Revision History:                                         */
/*                                                           */
/*************************************************************/

#define _MODULUTL_SOURCE_

#include "setup.h"

#include "clipsmem.h"
#include "router.h"

#include "modulpsr.h"
#include "modulutl.h"

/***************************************/
/* LOCAL INTERNAL FUNCTION DEFINITIONS */
/***************************************/

#if ANSI_COMPILER
   static VOID                      *SearchImportedConstructModules(struct symbolHashNode *,
                                              struct defmodule *,
                                              struct moduleItem *,struct symbolHashNode *,
                                              int *,int,struct defmodule *);
#else
   static VOID                      *SearchImportedConstructModules();
#endif

/********************************************************************/
/* FindModuleSeparator: Finds the :: separator which delineates the */
/*   boundary between a module name and a construct name. The value */
/*   zero is returned if the separator is not found, otherwise the  */
/*   position of the second colon within the string is returned.    */
/********************************************************************/
globle int FindModuleSeparator(theString)
  char *theString;
  {
   int i, foundColon;
   
   for (i = 0, foundColon = CLIPS_FALSE; theString[i] != EOS; i++)
     {
      if (theString[i] == ':')
        {
         if (foundColon) return(i);
         foundColon = CLIPS_TRUE;
        }
      else
        { foundColon = CLIPS_FALSE; }
     }
     
   return(CLIPS_FALSE);
  }
  
/*******************************************************************/
/* ExtractModuleName: Given the position of the :: separator and a */
/*   module/construct name joined using the separator, returns a   */
/*   symbol reference to the module name (or NULL if a module name */
/*   cannot be extracted).                                         */
/*******************************************************************/
globle SYMBOL_HN *ExtractModuleName(thePosition,theString)
  int thePosition;
  char *theString;
  {
   char *newString;
   SYMBOL_HN *returnValue;
   
   /*=============================================*/
   /* Return NULL if the :: is in a position such */
   /* that a module name can't be extracted.      */
   /*=============================================*/
   
   if (thePosition <= 1) return(NULL);
   
   /*==========================================*/
   /* Allocate storage for a temporary string. */
   /*==========================================*/
   
   newString = (char *) gm2(thePosition);
   
   /*======================================================*/
   /* Copy the entire module/construct name to the string. */
   /*======================================================*/
   
   strncpy(newString,theString,
           (CLIPS_STD_SIZE) thePosition - 1);
   
   /*========================================================*/
   /* Place an end of string marker where the :: is located. */
   /*========================================================*/
   
   newString[thePosition-1] = EOS;
   
   /*=====================================================*/
   /* Add the module name (the truncated module/construct */
   /* name) to the symbol table.                          */
   /*=====================================================*/
   
   returnValue = (SYMBOL_HN *) AddSymbol(newString);
   
   /*=============================================*/
   /* Return the storage of the temporary string. */
   /*=============================================*/
   
   rm(newString,thePosition);
   
   /*=============================================*/
   /* Return a pointer to the module name symbol. */
   /*=============================================*/
   
   return(returnValue);
  }

/********************************************************************/
/* ExtractConstructName: Given the position of the :: separator and */
/*   a module/construct name joined using the separator, returns a  */
/*   symbol reference to the construct name (or NULL if a construct */
/*   name cannot be extracted).                                     */
/********************************************************************/
globle SYMBOL_HN *ExtractConstructName(thePosition,theString)
  int thePosition;
  char *theString;
  {
   int theLength;
   char *newString;
   SYMBOL_HN *returnValue;
   
   /*======================================*/
   /* Just return the string if it doesn't */
   /* contain the :: symbol.               */
   /*======================================*/
   
   if (thePosition == 0) return((SYMBOL_HN *) AddSymbol(theString));
   
   /*=====================================*/
   /* Determine the length of the string. */
   /*=====================================*/
   
   theLength = strlen(theString);
   
   /*=================================================*/
   /* Return NULL if the :: is at the very end of the */
   /* string (and thus there is no construct name).   */
   /*=================================================*/
   
   if (theLength <= (thePosition + 1)) return(NULL);
      
   /*====================================*/
   /* Allocate a temporary string large  */
   /* enough to hold the construct name. */
   /*====================================*/
   
   newString = (char *) gm2(theLength - thePosition);
   
   /*================================================*/
   /* Copy the construct name portion of the         */
   /* module/construct name to the temporary string. */
   /*================================================*/
   
   strncpy(newString,&theString[thePosition+1],
           (CLIPS_STD_SIZE) theLength - thePosition);
   
   /*=============================================*/
   /* Add the construct name to the symbol table. */
   /*=============================================*/

   returnValue = (SYMBOL_HN *) AddSymbol(newString);

   /*=============================================*/
   /* Return the storage of the temporary string. */
   /*=============================================*/
   
   rm(newString,theLength - thePosition);
      
   /*================================================*/
   /* Return a pointer to the construct name symbol. */
   /*================================================*/

   return(returnValue);
  }
  
/****************************************************/
/* ExtractModuleAndConstructName: Extracts both the */
/*   module and construct name from a string. Sets  */
/*   the current module to the specified module.    */
/****************************************************/
globle char *ExtractModuleAndConstructName(theName)
  char *theName;
  {
   int separatorPosition;
   SYMBOL_HN *moduleName, *shortName;
   struct defmodule *theModule;
   
   /*========================*/
   /* Find the :: separator. */
   /*========================*/
   
   separatorPosition = FindModuleSeparator(theName);
   if (! separatorPosition) return(theName);
   
   /*==========================*/
   /* Extract the module name. */
   /*==========================*/
   
   moduleName = ExtractModuleName(separatorPosition,theName);
   if (moduleName == NULL) return(NULL);
        
   /*====================================*/
   /* Check to see if the module exists. */
   /*====================================*/
   
   theModule = (struct defmodule *) FindDefmodule(ValueToString(moduleName));
   if (theModule == NULL) return(NULL);
        
   /*============================*/
   /* Change the current module. */
   /*============================*/
   
   SetCurrentModule((VOID *) theModule);
   
   /*=============================*/
   /* Extract the construct name. */
   /*=============================*/
   
   shortName = ExtractConstructName(separatorPosition,theName);
   return(ValueToString(shortName));
  }
  
/************************************************************/
/* FindImportedConstruct: High level routine which searches */
/*   a module and other modules from which it imports       */
/*   constructs for a specified construct.                  */
/************************************************************/
globle VOID *FindImportedConstruct(constructName,matchModule,findName,count,
                                   searchCurrent,notYetDefinedInModule)
  char *constructName;
  struct defmodule *matchModule;
  char *findName;
  int *count;
  int searchCurrent;
  struct defmodule *notYetDefinedInModule;
  {
   VOID *rv;
   struct moduleItem *theModuleItem;

   /*=============================================*/
   /* Set the number of references found to zero. */
   /*=============================================*/
   
   *count = 0;
      
   /*===============================*/
   /* The :: should not be included */
   /* in the construct's name.      */
   /*===============================*/
   
   if (FindModuleSeparator(findName)) return(NULL);
   
   /*=============================================*/
   /* Remember the current module since we'll be  */
   /* changing it during the search and will want */
   /* to restore it once the search is completed. */
   /*=============================================*/
             
   SaveCurrentModule();
   
   /*==========================================*/
   /* Find the module related access functions */
   /* for the construct type being sought.     */
   /*==========================================*/
            
   if ((theModuleItem = FindModuleItem(constructName)) == NULL)
     {
      RestoreCurrentModule();
      return(NULL);
     } 

   /*===========================================*/
   /* If the construct type doesn't have a find */
   /* function, then we can't look for it.      */
   /*===========================================*/
   
   if (theModuleItem->findFunction == NULL)
     {
      RestoreCurrentModule();
      return(NULL);
     }
        
   /*==================================*/
   /* Initialize the search by marking */
   /* all modules as unvisited.        */
   /*==================================*/
   
   MarkModulesAsUnvisited();
   
   /*===========================*/
   /* Search for the construct. */
   /*===========================*/
   
   rv = SearchImportedConstructModules(AddSymbol(constructName),
                                       matchModule,theModuleItem,