/*******************************************************/   /*      "C" Language Integrated Production System      */   /*                                                     */   /*               CLIPS Version 6.24  05/17/06          */   /*                                                     */   /*              MESSAGE-HANDLER PARSER FUNCTIONS       */   /*******************************************************//*************************************************************//* Purpose:                                                  *//*                                                           *//* Principal Programmer(s):                                  *//*      Brian L. Donnell                                     *//*                                                           *//* Contributing Programmer(s):                               *//*                                                           *//* Revision History:                                         *//*      6.23: Changed name of variable exp to theExp         *//*            because of Unix compiler warnings of shadowed  *//*            definitions.                                   *//*                                                           *//*      6.24: Removed IMPERATIVE_MESSAGE_HANDLERS            *//*                    compilation flag.                      *//*                                                           *//*            Renamed BOOLEAN macro type to intBool.         *//*                                                           *//*************************************************************//* =========================================   *****************************************               EXTERNAL DEFINITIONS   =========================================   ***************************************** */#include "setup.h"#if OBJECT_SYSTEM && (! BLOAD_ONLY) && (! RUN_TIME)#include <string.h>#if BLOAD || BLOAD_AND_BSAVE#include "bload.h"#endif#include "classcom.h"#include "classfun.h"#include "memalloc.h"#include "constrct.h"#include "cstrcpsr.h"#include "cstrnchk.h"#include "envrnmnt.h"#include "exprnpsr.h"#include "insfun.h"#include "msgcom.h"#include "msgfun.h"#include "pprint.h"#include "prccode.h"#include "router.h"#include "scanner.h"#include "strngrtr.h"#define _MSGPSR_SOURCE_#include "msgpsr.h"/* =========================================   *****************************************                   CONSTANTS   =========================================   ***************************************** */#define SELF_LEN         4#define SELF_SLOT_REF   ':'/* =========================================   *****************************************      INTERNALLY VISIBLE FUNCTION HEADERS   =========================================   ***************************************** */static intBool IsParameterSlotReference(void *,char *);static int SlotReferenceVar(void *,EXPRESSION *,void *);static int BindSlotReference(void *,EXPRESSION *,void *);static SLOT_DESC *CheckSlotReference(void *,DEFCLASS *,int,void *,intBool,EXPRESSION *);static void GenHandlerSlotReference(void *,EXPRESSION *,unsigned short,SLOT_DESC *);/* =========================================   *****************************************          EXTERNALLY VISIBLE FUNCTIONS   =========================================   ***************************************** *//***********************************************************************  NAME         : ParseDefmessageHandler  DESCRIPTION  : Parses a message-handler for a class of objects  INPUTS       : The logical name of the input source  RETURNS      : FALSE if successful parse, TRUE otherwise  SIDE EFFECTS : Handler allocated and inserted into class  NOTES        : H/L Syntax:                 (defmessage-handler <class> <name> [<type>] [<comment>]                    (<params>)                    <action>*)                 <params> ::= <var>* | <var>* $?<name> ***********************************************************************/globle int ParseDefmessageHandler(  void *theEnv,  char *readSource)  {   DEFCLASS *cls;   SYMBOL_HN *cname,*mname,*wildcard;   unsigned mtype = MPRIMARY;   int min,max,error,lvars;   EXPRESSION *hndParams,*actions;   HANDLER *hnd;   SetPPBufferStatus(theEnv,ON);   FlushPPBuffer(theEnv);   SetIndentDepth(theEnv,3);   SavePPBuffer(theEnv,"(defmessage-handler ");#if BLOAD || BLOAD_AND_BSAVE   if ((Bloaded(theEnv)) && (! ConstructData(theEnv)->CheckSyntaxMode))     {      CannotLoadWithBloadMessage(theEnv,"defmessage-handler");      return(TRUE);     }#endif   cname = GetConstructNameAndComment(theEnv,readSource,&DefclassData(theEnv)->ObjectParseToken,"defmessage-handler",                                      NULL,NULL,"~",TRUE,FALSE,TRUE);   if (cname == NULL)     return(TRUE);   cls = LookupDefclassByMdlOrScope(theEnv,ValueToString(cname));   if (cls == NULL)     {      PrintErrorID(theEnv,"MSGPSR",1,FALSE);      EnvPrintRouter(theEnv,WERROR,"A class must be defined before its message-handlers.\n");      return(TRUE);     }   if ((cls == DefclassData(theEnv)->PrimitiveClassMap[INSTANCE_NAME]) ||       (cls == DefclassData(theEnv)->PrimitiveClassMap[INSTANCE_ADDRESS]) ||       (cls == DefclassData(theEnv)->PrimitiveClassMap[INSTANCE_NAME]->directSuperclasses.classArray[0]))     {      PrintErrorID(theEnv,"MSGPSR",8,FALSE);      EnvPrintRouter(theEnv,WERROR,"Message-handlers cannot be attached to the class ");      EnvPrintRouter(theEnv,WERROR,EnvGetDefclassName(theEnv,(void *) cls));      EnvPrintRouter(theEnv,WERROR,".\n");      return(TRUE);     }   if (HandlersExecuting(cls))     {      PrintErrorID(theEnv,"MSGPSR",2,FALSE);      EnvPrintRouter(theEnv,WERROR,"Cannot (re)define message-handlers during execution of \n");      EnvPrintRouter(theEnv,WERROR,"  other message-handlers for the same class.\n");      return(TRUE);     }   if (GetType(DefclassData(theEnv)->ObjectParseToken) != SYMBOL)     {      SyntaxErrorMessage(theEnv,"defmessage-handler");      return(TRUE);     }   PPBackup(theEnv);   PPBackup(theEnv);   SavePPBuffer(theEnv," ");   SavePPBuffer(theEnv,DefclassData(theEnv)->ObjectParseToken.printForm);   SavePPBuffer(theEnv," ");   mname = (SYMBOL_HN *) GetValue(DefclassData(theEnv)->ObjectParseToken);   GetToken(theEnv,readSource,&DefclassData(theEnv)->ObjectParseToken);   if (GetType(DefclassData(theEnv)->ObjectParseToken) != LPAREN)     {      SavePPBuffer(theEnv," ");      if (GetType(DefclassData(theEnv)->ObjectParseToken) != STRING)        {         if (GetType(DefclassData(theEnv)->ObjectParseToken) != SYMBOL)           {            SyntaxErrorMessage(theEnv,"defmessage-handler");            return(TRUE);           }         mtype = HandlerType(theEnv,"defmessage-handler",DOToString(DefclassData(theEnv)->ObjectParseToken));         if (mtype == MERROR)           return(TRUE);         GetToken(theEnv,readSource,&DefclassData(theEnv)->ObjectParseToken);         if (GetType(DefclassData(theEnv)->ObjectParseToken) == STRING)           {            SavePPBuffer(theEnv," ");            GetToken(theEnv,readSource,&DefclassData(theEnv)->ObjectParseToken);           }        }      else        {         SavePPBuffer(theEnv," ");         GetToken(theEnv,readSource,&DefclassData(theEnv)->ObjectParseToken);        }     }   PPBackup(theEnv);   PPBackup(theEnv);   PPCRAndIndent(theEnv);   SavePPBuffer(theEnv,DefclassData(theEnv)->ObjectParseToken.printForm);   hnd = FindHandlerByAddress(cls,mname,mtype);   if (GetPrintWhileLoading(theEnv) && GetCompilationsWatch(theEnv))     {      EnvPrintRouter(theEnv,WDIALOG,"   Handler ");      EnvPrintRouter(theEnv,WDIALOG,ValueToString(mname));      EnvPrintRouter(theEnv,WDIALOG," ");      EnvPrintRouter(theEnv,WDIALOG,MessageHandlerData(theEnv)->hndquals[mtype]);      EnvPrintRouter(theEnv,WDIALOG,(char *) ((hnd == NULL) ? " defined.\n" : " redefined.\n"));     }   if ((hnd != NULL) ? hnd->system : FALSE)     {      PrintErrorID(theEnv,"MSGPSR",3,FALSE);      EnvPrintRouter(theEnv,WERROR,"System message-handlers may not be modified.\n");      return(TRUE);     }   hndParams = GenConstant(theEnv,SYMBOL,(void *) MessageHandlerData(theEnv)->SELF_SYMBOL);   hndParams = ParseProcParameters(theEnv,readSource,&DefclassData(theEnv)->ObjectParseToken,hndParams,                                    &wildcard,&min,&max,&error,IsParameterSlotReference);   if (error)     return(TRUE);   PPCRAndIndent(theEnv);   ExpressionData(theEnv)->ReturnContext = TRUE;   actions = ParseProcActions(theEnv,"message-handler",readSource,                              &DefclassData(theEnv)->ObjectParseToken,hndParams,wildcard,                              SlotReferenceVar,BindSlotReference,&lvars,                              (void *) cls);   if (actions == NULL)     {      ReturnExpression(theEnv,hndParams);      return(TRUE);     }   if (GetType(DefclassData(theEnv)->ObjectParseToken) != RPAREN)     {      SyntaxErrorMessage(theEnv,"defmessage-handler");      ReturnExpression(theEnv,hndParams);      ReturnPackedExpression(theEnv,actions);      return(TRUE);     }   PPBackup(theEnv);   PPBackup(theEnv);   SavePPBuffer(theEnv,DefclassData(theEnv)->ObjectParseToken.printForm);   SavePPBuffer(theEnv,"\n");   /* ===================================================      If we're only checking syntax, don't add the      successfully parsed defmessage-handler to the KB.      =================================================== */   if (ConstructData(theEnv)->CheckSyntaxMode)     {      ReturnExpression(theEnv,hndParams);      ReturnPackedExpression(theEnv,actions);      return(FALSE);     }   if (hnd != NULL)     {      ExpressionDeinstall(theEnv,hnd->actions);      ReturnPackedExpression(theEnv,hnd->actions);      if (hnd->ppForm != NULL)        rm(theEnv,(void *) hnd->ppForm,           (sizeof(char) * (strlen(hnd->ppForm)+1)));     }   else     {      hnd = InsertHandlerHeader(theEnv,cls,mname,(int) mtype);      IncrementSymbolCount(hnd->name);     }   ReturnExpression(theEnv,hndParams);   hnd->minParams = min;   hnd->maxParams = max;   hnd->localVarCount = lvars;   hnd->actions = actions;   ExpressionInstall(theEnv,hnd->actions);#if DEBUGGING_FUNCTIONS   /* ===================================================      Old handler trace status is automatically preserved      =================================================== */   if (EnvGetConserveMemory(theEnv) == FALSE)     hnd->ppForm = CopyPPBuffer(theEnv);   else#endif     hnd->ppForm = NULL;   return(FALSE);  }/*******************************************************************************  NAME         : CreateGetAndPutHandlers  DESCRIPTION  : Creates two message-handlers with                  the following syntax for the slot:                 (defmessage-handler <class> get-<slot-name> primary ()                    ?self:<slot-name>)                 For single-field slots:                 (defmessage-handler <class> put-<slot-name> primary (?value)                    (bind ?self:<slot-name> ?value))                 For multifield slots:                 (defmessage-handler <class> put-<slot-name> primary ($?value)                    (bind ?self:<slot-name> ?value))  INPUTS       : The class slot descriptor  RETURNS      : Nothing useful  SIDE EFFECTS : Message-handlers created  NOTES        : A put handler is not created for read-only slots *******************************************************************************/globle void CreateGetAndPutHandlers(  void *theEnv,  SLOT_DESC *sd)  {   char *className,*slotName;   size_t bufsz;   char *buf,*handlerRouter = "*** Default Public Handlers ***";   int oldPWL,oldCM;   char *oldRouter;   char *oldString;   long oldIndex;   if ((sd->createReadAccessor == 0) && (sd->createWriteAccessor == 0))     return;   className = ValueToString(sd->cls->header.name);   slotName = ValueToString(sd->slotName->name);   bufsz = (sizeof(char) * (strlen(className) + (strlen(slotName) * 2) + 80));   buf = (char *) gm2(theEnv,bufsz);   oldPWL = GetPrintWhileLoading(theEnv);   SetPrintWhileLoading(theEnv,FALSE);   oldCM = EnvSetConserveMemory(theEnv,TRUE);   if (sd->createReadAccessor)     {      gensprintf(buf,"%s get-%s () ?self:%s)",className,slotName,slotName);            oldRouter = RouterData(theEnv)->FastCharGetRouter;