msgcom.c

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

  NOTES        : None
 ***************************************************/
globle int IsDefmessageHandlerDeletable(ptr,index)
  VOID *ptr;
  unsigned index;
  {
#if (MAC_MPW || MAC_MCW) && (RUN_TIME || BLOAD_ONLY)
#pragma unused(ptr)
#pragma unused(index)
#endif

#if BLOAD_ONLY || RUN_TIME
   return(CLIPS_FALSE);
#else
   DEFCLASS *cls;
   
#if BLOAD || BLOAD_AND_BSAVE
   if (Bloaded())
     return(CLIPS_FALSE);
#endif
   cls = (DEFCLASS *) ptr;
   if (cls->handlers[index-1].system == 1)
     return(CLIPS_FALSE);
   return((HandlersExecuting(cls) == CLIPS_FALSE) ? CLIPS_TRUE : CLIPS_FALSE);
#endif
  }

/******************************************************************************
  NAME         : UndefmessageHandlerCommand
  DESCRIPTION  : Deletes a handler from a class
  INPUTS       : None
  RETURNS      : Nothing useful
  SIDE EFFECTS : Handler deleted if possible
  NOTES        : CLIPS Syntax: (undefmessage-handler <class> <handler> [<type>])
 ******************************************************************************/
globle VOID UndefmessageHandlerCommand()
  {
#if RUN_TIME || BLOAD_ONLY
   PrintErrorID("MSGCOM",3,CLIPS_FALSE);
   PrintCLIPS(WERROR,"Unable to delete message-handlers.\n");
#else
   SYMBOL_HN *mname;
   char *tname;
   DATA_OBJECT tmp;
   DEFCLASS *cls;

#if BLOAD || BLOAD_AND_BSAVE
   if (Bloaded())
     {
      PrintErrorID("MSGCOM",3,CLIPS_FALSE);
      PrintCLIPS(WERROR,"Unable to delete message-handlers.\n");
      return;
     }
#endif
   if (ArgTypeCheck("undefmessage-handler",1,SYMBOL,&tmp) == CLIPS_FALSE)
     return;
   cls = LookupDefclassByMdlOrScope(DOToString(tmp));
   if ((cls == NULL) ? (strcmp(DOToString(tmp),"*") != 0) : CLIPS_FALSE)
     {
      ClassExistError("undefmessage-handler",DOToString(tmp));
      return;
     }
   if (ArgTypeCheck("undefmessage-handler",2,SYMBOL,&tmp) == CLIPS_FALSE)
     return;
   mname = (SYMBOL_HN *) tmp.value;
   if (RtnArgCount() == 3)
     {
      if (ArgTypeCheck("undefmessage-handler",3,SYMBOL,&tmp) == CLIPS_FALSE)
        return;
      tname = DOToString(tmp);
      if (strcmp(tname,"*") == 0)
        tname = NULL;
     }
   else
     tname = hndquals[MPRIMARY];
   WildDeleteHandler(cls,mname,tname);
#endif
  }
  
/***********************************************************
  NAME         : UndefmessageHandler
  DESCRIPTION  : Deletes a handler from a class
  INPUTS       : 1) Class address    (Can be NULL)
                 2) Handler index (can be 0)
  RETURNS      : 1 if successful, 0 otherwise
  SIDE EFFECTS : Handler deleted if possible
  NOTES        : None
 ***********************************************************/
globle int UndefmessageHandler(vptr,mhi)
  VOID *vptr;
  unsigned mhi;
  {
#if (MAC_MPW || MAC_MCW) && (RUN_TIME || BLOAD_ONLY)
#pragma unused(vptr)
#pragma unused(mhi)
#endif

#if RUN_TIME || BLOAD_ONLY
   PrintErrorID("MSGCOM",3,CLIPS_FALSE);
   PrintCLIPS(WERROR,"Unable to delete message-handlers.\n");
   return(0);
#else
   DEFCLASS *cls;

#if BLOAD || BLOAD_AND_BSAVE
   if (Bloaded())
     {
      PrintErrorID("MSGCOM",3,CLIPS_FALSE);
      PrintCLIPS(WERROR,"Unable to delete message-handlers.\n");
      return(0);
     }
#endif
   if (vptr == NULL)
     {
      if (mhi != 0)
        {
         PrintErrorID("MSGCOM",1,CLIPS_FALSE);
         PrintCLIPS(WERROR,"Incomplete message-handler specification for deletion.\n");
         return(0);
        }
      return(WildDeleteHandler(NULL,NULL,NULL));
     }
   if (mhi == 0)
     return(WildDeleteHandler((DEFCLASS *) vptr,NULL,NULL));
   cls = (DEFCLASS *) vptr;
   if (HandlersExecuting(cls))
     {
      HandlerDeleteError(GetDefclassName((VOID *) cls));
      return(0);
     }
   cls->handlers[mhi-1].mark = 1;
   DeallocateMarkedHandlers(cls);
   return(1);
#endif
  }
  
#if DEBUGGING_FUNCTIONS

/*******************************************************************************
  NAME         : PPDefmessageHandlerCommand
  DESCRIPTION  : Displays the pretty-print form (if any) for a handler
  INPUTS       : None
  RETURNS      : Nothing useful
  SIDE EFFECTS : None
  NOTES        : CLIPS Syntax: (ppdefmessage-handler <class> <message> [<type>])
 *******************************************************************************/
globle VOID PPDefmessageHandlerCommand()
  {
   DATA_OBJECT temp;
   SYMBOL_HN *csym,*msym;
   char *tname;
   DEFCLASS *cls = NULL;
   int mtype;
   HANDLER *hnd;
   
   if (ArgTypeCheck("ppdefmessage-handler",1,SYMBOL,&temp) == CLIPS_FALSE)
     return;
   csym = FindSymbol(DOToString(temp));
   if (ArgTypeCheck("ppdefmessage-handler",2,SYMBOL,&temp) == CLIPS_FALSE)
     return;
   msym = FindSymbol(DOToString(temp));
   if (RtnArgCount() == 3)
     {
      if (ArgTypeCheck("ppdefmessage-handler",3,SYMBOL,&temp) == CLIPS_FALSE)
        return;
      tname = DOToString(temp);
     }
   else
     tname = hndquals[MPRIMARY];
   mtype = HandlerType("ppdefmessage-handler",tname);
   if (mtype == MERROR)
     {
      SetEvaluationError(CLIPS_TRUE);
      return;
     }
   if (csym != NULL)
     cls = LookupDefclassByMdlOrScope(ValueToString(csym));
   if (((cls == NULL) || (msym == NULL)) ? CLIPS_TRUE :
       ((hnd = FindHandlerByAddress(cls,msym,(unsigned) mtype)) == NULL))
     {
      PrintErrorID("MSGCOM",2,CLIPS_FALSE);
      PrintCLIPS(WERROR,"Unable to find message-handler ");
      PrintCLIPS(WERROR,ValueToString(msym));
      PrintCLIPS(WERROR," ");
      PrintCLIPS(WERROR,tname);
      PrintCLIPS(WERROR," for class ");
      PrintCLIPS(WERROR,ValueToString(csym));
      PrintCLIPS(WERROR," in function ppdefmessage-handler.\n");
      SetEvaluationError(CLIPS_TRUE);
      return;
     }
   if (hnd->ppForm != NULL)
     PrintInChunks(WDISPLAY,hnd->ppForm);
  }

/*****************************************************************************
  NAME         : ListDefmessageHandlersCommand
  DESCRIPTION  : Depending on arguments, does lists handlers which
                   match restrictions
  INPUTS       : None
  RETURNS      : Nothing useful
  SIDE EFFECTS : None
  NOTES        : CLIPS Syntax: (list-defmessage-handlers [<class> [inherit]]))
 *****************************************************************************/
globle VOID ListDefmessageHandlersCommand()
  {
   int inhp;
   VOID *clsptr;
   
   if (RtnArgCount() == 0)
     ListDefmessageHandlers(WDISPLAY,NULL,0);
   else
     {
      clsptr = ClassInfoFnxArgs("list-defmessage-handlers",&inhp);
      if (clsptr == NULL)
        return;
      ListDefmessageHandlers(WDISPLAY,clsptr,inhp);
     }
  }
  
/********************************************************************
  NAME         : PreviewSendCommand
  DESCRIPTION  : Displays a list of the core for a message describing
                   shadows,etc.
  INPUTS       : None
  RETURNS      : Nothing useful
  SIDE EFFECTS : Temporary core created and destroyed
  NOTES        : CLIPS Syntax: (preview-send <class> <msg>)
 ********************************************************************/
globle VOID PreviewSendCommand()
  {
   DEFCLASS *cls;
   DATA_OBJECT temp;
   
   /* ============================= 
      Get the class for the message
      ============================= */
   if (ArgTypeCheck("preview-send",1,SYMBOL,&temp) == CLIPS_FALSE)
     return;
   cls = LookupDefclassByMdlOrScope(DOToString(temp));
   if (cls == NULL)
     {
      ClassExistError("preview-send",ValueToString(temp.value));
      return;
     }
     
   if (ArgTypeCheck("preview-send",2,SYMBOL,&temp) == CLIPS_FALSE)
     return;
   PreviewSend(WDISPLAY,(VOID *) cls,DOToString(temp));
  }
  
/********************************************************
  NAME         : GetDefmessageHandlerPPForm
  DESCRIPTION  : Gets a message-handler pretty print form
  INPUTS       : 1) Address of the handler's class
                 2) Index of the handler
  RETURNS      : CLIPS_TRUE if printable, CLIPS_FALSE otherwise
  SIDE EFFECTS : None
  NOTES        : None
 ********************************************************/
globle char *GetDefmessageHandlerPPForm(ptr,index)
  VOID *ptr;
  unsigned index;
  {
   return(((DEFCLASS *) ptr)->handlers[index-1].ppForm);
  }

/*******************************************************************
  NAME         : ListDefmessageHandlers
  DESCRIPTION  : Lists message-handlers for a class
  INPUTS       : 1) The logical name of the output
                 2) Class name (NULL to display all handlers)
                 3) A flag indicating whether to list inherited
                    handlers or not
  RETURNS      : Nothing useful
  SIDE EFFECTS : None
  NOTES        : None
 *******************************************************************/
globle VOID ListDefmessageHandlers(log,vptr,inhp)
  char *log;
  VOID *vptr;
  int inhp;
  {
   DEFCLASS *cls;
   long cnt;
   PACKED_CLASS_LINKS plinks;
   
   if (vptr != NULL)
     {
      cls = (DEFCLASS *) vptr;
      if (inhp)
        cnt = DisplayHandlersInLinks(log,&cls->allSuperclasses,0);
      else
        {
         plinks.classCount = 1;
         plinks.classArray = &cls;
         cnt = DisplayHandlersInLinks(log,&plinks,0);
        }
     }
   else
     {
      plinks.classCount = 1;
      cnt = 0L;
      for (cls = (DEFCLASS *) GetNextDefclass(NULL) ;
           cls != NULL ;
           cls = (DEFCLASS *) GetNextDefclass((VOID *) cls))
        {
         plinks.classArray = &cls;
         cnt += DisplayHandlersInLinks(log,&plinks,0);
        }
     }
   PrintTally(log,cnt,"message-handler","message-handlers");
  }
  
/********************************************************************
  NAME         : PreviewSend
  DESCRIPTION  : Displays a list of the core for a message describing
                   shadows,etc.
  INPUTS       : 1) Logical name of output
                 2) Class pointer
                 3) Message name-string
  RETURNS      : Nothing useful
  SIDE EFFECTS : Temporary core created and destroyed
  NOTES        : None
 ********************************************************************/
globle VOID PreviewSend(logicalName,clsptr,msgname)
  char *logicalName;
  VOID *clsptr;
  char *msgname;
  {
   HANDLER_LINK *core;
   SYMBOL_HN *msym;
   
   msym = FindSymbol(msgname);
   if (msym == NULL)
     return;
   core = FindPreviewApplicableHandlers((DEFCLASS *) clsptr,msym);
   if (core != NULL)
     {
      DisplayCore(logicalName,core,0);
      DestroyHandlerLinks(core);
     }
  }

/****************************************************
  NAME         : DisplayHandlersInLinks
  DESCRIPTION  : Recursively displays all handlers
                  for an array of classes
  INPUTS       : 1) The logical name of the output
                 2) The packed class links
                 3) The index to print from the links
  RETURNS      : The number of handlers printed
  SIDE EFFECTS : None
  NOTES        : Used by DescribeClass()
 ****************************************************/
globle long DisplayHandlersInLinks(log,plinks,index)
  char *log;
  PACKED_CLASS_LINKS *plinks;
  unsigned index;
  {
   register unsigned i;
   long cnt;
   
   cnt = (long) plinks->classArray[index]->handlerCount;
   if (index < (plinks->classCount - 1))
     cnt += DisplayHandlersInLinks(log,plinks,index + 1);
   for (i = 0 ; i < plinks->classArray[index]->handlerCount ; i++)