classpsr.c

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

   /*******************************************************/
   /*      "C" Language Integrated Production System      */
   /*                                                     */
   /*               CLIPS Version 6.05  04/09/97          */
   /*                                                     */
   /*                  CLASS PARSER MODULE                */
   /*******************************************************/

/**************************************************************/
/* Purpose: Parsing Routines for Defclass Construct           */
/*                                                            */
/* Principal Programmer(s):                                   */
/*      Brian L. Donnell                                      */
/*                                                            */
/* Contributing Programmer(s):                                */
/*                                                            */
/* Revision History:                                          */
/*                                                            */
/**************************************************************/
   
/* =========================================
   *****************************************
               EXTERNAL DEFINITIONS
   =========================================
   ***************************************** */
#include "setup.h"

#if OBJECT_SYSTEM && (! BLOAD_ONLY) && (! RUN_TIME)

#if BLOAD || BLOAD_AND_BSAVE
#include "bload.h"
#endif

#include "classcom.h"
#include "classfun.h"
#include "clipsmem.h"
#include "cstrcpsr.h"
#include "inherpsr.h"
#include "modulpsr.h"
#include "modulutl.h"
#include "msgpsr.h"
#include "clsltpsr.h"
#include "router.h"
#include "scanner.h"

#define _CLASSPSR_SOURCE_
#include "classpsr.h"

/* =========================================
   *****************************************
                   CONSTANTS
   =========================================
   ***************************************** */
#define ROLE_RLN             "role"
#define ABSTRACT_RLN         "abstract"
#define CONCRETE_RLN         "concrete"

#define HANDLER_DECL         "message-handler"

#define SLOT_RLN             "slot"
#define SGL_SLOT_RLN         "single-slot"
#define MLT_SLOT_RLN         "multislot"

#define DIRECT               0
#define INHERIT              1

/* =========================================
   *****************************************
               MACROS AND TYPES
   =========================================
   ***************************************** */

/* =========================================
   *****************************************
      INTERNALLY VISIBLE FUNCTION HEADERS
   =========================================
   ***************************************** */
#if ANSI_COMPILER

static BOOLEAN ValidClassName(char *,DEFCLASS **);
static BOOLEAN ParseSimpleQualifier(char *,char *,char *,char *,BOOLEAN *,BOOLEAN *);
static BOOLEAN ReadUntilClosingParen(char *,struct token *);
static VOID AddClass(DEFCLASS *);
static VOID BuildSubclassLinks(DEFCLASS *);
static VOID FormInstanceTemplate(DEFCLASS *);
static VOID FormSlotNameMap(DEFCLASS *);
static TEMP_SLOT_LINK *MergeSlots(TEMP_SLOT_LINK *,DEFCLASS *,unsigned *,int);
static VOID PackSlots(DEFCLASS *,TEMP_SLOT_LINK *);
#if DEFMODULE_CONSTRUCT
static VOID CreateClassScopeMap(DEFCLASS *);
#endif
static VOID CreatePublicSlotMessageHandlers(DEFCLASS *);

#else

static BOOLEAN ValidClassName();
static BOOLEAN ParseSimpleQualifier();
static BOOLEAN ReadUntilClosingParen();
static VOID AddClass();
static VOID BuildSubclassLinks();
static VOID FormInstanceTemplate();
static VOID FormSlotNameMap();
static TEMP_SLOT_LINK *MergeSlots();
static VOID PackSlots();
#if DEFMODULE_CONSTRUCT
static VOID CreateClassScopeMap();
#endif
static VOID CreatePublicSlotMessageHandlers();

#endif

/* =========================================
   *****************************************
      EXTERNALLY VISIBLE GLOBAL VARIABLES
   =========================================
   ***************************************** */
globle struct token ObjectParseToken;

/* =========================================
   *****************************************
      INTERNALLY VISIBLE GLOBAL VARIABLES
   =========================================
   ***************************************** */
    
/* =========================================
   *****************************************
          EXTERNALLY VISIBLE FUNCTIONS
   =========================================
   ***************************************** */

/***************************************************************************************
  NAME         : ParseDefclass
  DESCRIPTION  : (defclass ...) is A CLIPS construct (as
                 opposed to a function), thus no variables
                 may be used.  This means classes may only
                 be STATICALLY defined (like rules).
  INPUTS       : The logical name of the router
                    for the parser input
  RETURNS      : CLIPS_FALSE if successful parse, CLIPS_TRUE otherwise
  SIDE EFFECTS : Inserts valid class definition into
                 Class Table.
  NOTES        : CLIPS Syntax :
                 (defclass <name> [<comment>]
                    (is-a <superclass-name>+)
                    <class-descriptor>*)
                
                 <class-descriptor> :== (slot <name> <slot-descriptor>*) |
                                        (role abstract|concrete) |
                                        (pattern-match reactive|non-reactive)
                                        
                                        These are for documentation only:
                                        (message-handler <name> [<type>])
                                        
                 <slot-descriptor>  :== (default <default-expression>) |
                                        (default-dynamic <default-expression>) |
                                        (storage shared|local) |
                                        (access read-only|read-write|initialize-only) |
                                        (propagation no-inherit|inherit) |
                                        (source composite|exclusive)
                                        (pattern-match reactive|non-reactive)
                                        (visibility public|private)
                                        (override-message <message-name>)
                                        (type ...) |
                                        (cardinality ...) |
                                        (allowed-symbols ...) |
                                        (allowed-strings ...) |
                                        (allowed-numbers ...) |
                                        (allowed-integers ...) |
                                        (allowed-floats ...) |
                                        (allowed-values ...) |
                                        (allowed-instance-names ...) |
                                        (range ...)
                                        
               <default-expression> ::= ?NONE | ?VARIABLE | <expression>*
  ***************************************************************************************/
globle int ParseDefclass(readSource)
  char *readSource;
  {
   SYMBOL_HN *cname;
   DEFCLASS *cls;
   PACKED_CLASS_LINKS *sclasses,*preclist;
   TEMP_SLOT_LINK *slots = NULL;
   int roleSpecified = CLIPS_FALSE,
       abstract = CLIPS_FALSE,
       parseError;
#if INSTANCE_PATTERN_MATCHING
   int patternMatchSpecified = CLIPS_FALSE,
       reactive = CLIPS_TRUE;
#endif
   
   SetPPBufferStatus(ON);
   FlushPPBuffer();          
   SetIndentDepth(3);    
   SavePPBuffer("(defclass ");

#if BLOAD || BLOAD_ONLY || BLOAD_AND_BSAVE
   if (Bloaded())
     {      
      CannotLoadWithBloadMessage("defclass");
      return(CLIPS_TRUE);
     }
#endif

   cname = GetConstructNameAndComment(readSource,&ObjectParseToken,"defclass",
                                      FindDefclass,NULL,"#",CLIPS_TRUE,
                                      CLIPS_TRUE,CLIPS_TRUE);
   if (cname == NULL)
     return(CLIPS_TRUE);

   if (ValidClassName(ValueToString(cname),&cls) == CLIPS_FALSE)
     return(CLIPS_TRUE);
     
   sclasses = ParseSuperclasses(readSource,cname);
   if (sclasses == NULL)
     return(CLIPS_TRUE);
   preclist = FindPrecedenceList(cls,sclasses);
   if (preclist == NULL)
     {
      DeletePackedClassLinks(sclasses,CLIPS_TRUE);
      return(CLIPS_TRUE);
     }
   parseError = CLIPS_FALSE;
   GetToken(readSource,&ObjectParseToken);
   while (GetType(ObjectParseToken) != RPAREN)
     {
      if (GetType(ObjectParseToken) != LPAREN)
        {
         SyntaxErrorMessage("defclass");
         parseError = CLIPS_TRUE;
         break;
        }
      PPBackup();
      PPCRAndIndent();
      SavePPBuffer("(");
      GetToken(readSource,&ObjectParseToken);
      if (GetType(ObjectParseToken) != SYMBOL)
        {
         SyntaxErrorMessage("defclass");
         parseError = CLIPS_TRUE;
         break;
        }
      if (strcmp(DOToString(ObjectParseToken),ROLE_RLN) == 0)
        {
         if (ParseSimpleQualifier(readSource,ROLE_RLN,CONCRETE_RLN,ABSTRACT_RLN,
                                  &roleSpecified,&abstract) == CLIPS_FALSE)
           {
            parseError = CLIPS_TRUE;
            break;
           }
        }
#if INSTANCE_PATTERN_MATCHING
      else if (strcmp(DOToString(ObjectParseToken),MATCH_RLN) == 0)
        {
         if (ParseSimpleQualifier(readSource,MATCH_RLN,NONREACTIVE_RLN,REACTIVE_RLN,
                                  &patternMatchSpecified,&reactive) == CLIPS_FALSE)
           {
            parseError = CLIPS_TRUE;
            break;
           }
        }
#endif
      else if (strcmp(DOToString(ObjectParseToken),SLOT_RLN) == 0)
        {
         slots = ParseSlot(readSource,slots,preclist,CLIPS_FALSE,CLIPS_FALSE);
         if (slots == NULL)
           {
            parseError = CLIPS_TRUE;
            break;
           }
        }
      else if (strcmp(DOToString(ObjectParseToken),SGL_SLOT_RLN) == 0)
        {
         slots = ParseSlot(readSource,slots,preclist,CLIPS_FALSE,CLIPS_TRUE);
         if (slots == NULL)
           {
            parseError = CLIPS_TRUE;
            break;
           }
        }
      else if (strcmp(DOToString(ObjectParseToken),MLT_SLOT_RLN) == 0)
        {
         slots = ParseSlot(readSource,slots,preclist,CLIPS_TRUE,CLIPS_TRUE);
         if (slots == NULL)
           {
            parseError = CLIPS_TRUE;
            break;
           }
        }
      else if (strcmp(DOToString(ObjectParseToken),HANDLER_DECL) == 0)
        {
         if (ReadUntilClosingParen(readSource,&ObjectParseToken) == CLIPS_FALSE)
           {
            parseError = CLIPS_TRUE;
            break;
           }
        }
      else
        {
         SyntaxErrorMessage("defclass");
         parseError = CLIPS_TRUE;
         break;
        }
      GetToken(readSource,&ObjectParseToken);
     }
   if ((GetType(ObjectParseToken) != RPAREN) || (parseError == CLIPS_TRUE))
     {
      DeletePackedClassLinks(sclasses,CLIPS_TRUE);
      DeletePackedClassLinks(preclist,CLIPS_TRUE);
      DeleteSlots(slots);