src/clipsrules/core/classexm.c Source File

00001    /*******************************************************/
00002    /*      "C" Language Integrated Production System      */
00003    /*                                                     */
00004    /*             CLIPS Version 6.30  03/04/08            */
00005    /*                                                     */
00006    /*                 CLASS EXAMINATION MODULE            */
00007    /*******************************************************/
00008 
00009 /**************************************************************/
00010 /* Purpose: Class browsing and examination commands           */
00011 /*                                                            */
00012 /* Principal Programmer(s):                                   */
00013 /*      Brian L. Dantes                                       */
00014 /*                                                            */
00015 /* Contributing Programmer(s):                                */
00016 /*                                                            */
00017 /* Revision History:                                          */
00018 /*      6.23: Correction for FalseSymbol/TrueSymbol. DR0859   */
00019 /*                                                            */
00020 /*            Modified the slot-writablep function to return  */
00021 /*            FALSE for slots having initialize-only access.  */
00022 /*            DR0860                                          */
00023 /*                                                            */
00024 /*      6.24: Added allowed-classes slot facet.               */
00025 /*                                                            */
00026 /*            Converted INSTANCE_PATTERN_MATCHING to          */
00027 /*            DEFRULE_CONSTRUCT.                              */
00028 /*                                                            */
00029 /*            Renamed BOOLEAN macro type to intBool.          */
00030 /*                                                            */
00031 /*            The slot-default-value function crashes when no */
00032 /*            default exists for a slot (the ?NONE value was  */
00033 /*            specified). DR0870                              */
00034 /*                                                            */
00035 /*      6.30: Used %zd for printing size_t arguments.         */
00036 /*                                                            */
00037 /*            Added EnvSlotDefaultP function.                 */
00038 /*                                                            */
00039 /**************************************************************/
00040 
00041 /* =========================================
00042    *****************************************
00043                EXTERNAL DEFINITIONS
00044    =========================================
00045    ***************************************** */
00046 #include "setup.h"
00047 
00048 #if OBJECT_SYSTEM
00049 
00050 #include <string.h>
00051 
00052 #include "argacces.h"
00053 #include "classcom.h"
00054 #include "classfun.h"
00055 #include "classini.h"
00056 #include "envrnmnt.h"
00057 #include "insfun.h"
00058 #include "memalloc.h"
00059 #include "msgcom.h"
00060 #include "msgfun.h"
00061 #include "router.h"
00062 #include "strngrtr.h"
00063 #include "sysdep.h"
00064 
00065 #define _CLASSEXM_SOURCE_
00066 #include "classexm.h"
00067 
00068 /* =========================================
00069    *****************************************
00070       INTERNALLY VISIBLE FUNCTION HEADERS
00071    =========================================
00072    ***************************************** */
00073 
00074 static int CheckTwoClasses(void *,char *,DEFCLASS **,DEFCLASS **);
00075 static SLOT_DESC *CheckSlotExists(void *,char *,DEFCLASS **,intBool,intBool);
00076 static SLOT_DESC *LookupSlot(void *,DEFCLASS *,char *,intBool);
00077 
00078 #if DEBUGGING_FUNCTIONS
00079 static DEFCLASS *CheckClass(void *,char *,char *);
00080 static char *GetClassNameArgument(void *,char *);
00081 static void PrintClassBrowse(void *,char *,DEFCLASS *,long);
00082 static void DisplaySeparator(void *,char *,char *,int,int);
00083 static void DisplaySlotBasicInfo(void *,char *,char *,char *,char *,DEFCLASS *);
00084 static intBool PrintSlotSources(void *,char *,SYMBOL_HN *,PACKED_CLASS_LINKS *,long,int);
00085 static void DisplaySlotConstraintInfo(void *,char *,char *,char *,unsigned,DEFCLASS *);
00086 static char *ConstraintCode(CONSTRAINT_RECORD *,unsigned,unsigned);
00087 #endif
00088 
00089 /* =========================================
00090    *****************************************
00091           EXTERNALLY VISIBLE FUNCTIONS
00092    =========================================
00093    ***************************************** */
00094 
00095 #if DEBUGGING_FUNCTIONS
00096 
00097 /****************************************************************
00098   NAME         : BrowseClassesCommand
00099   DESCRIPTION  : Displays a "graph" of the class hierarchy
00100   INPUTS       : None
00101   RETURNS      : Nothing useful
00102   SIDE EFFECTS : None
00103   NOTES        : Syntax : (browse-classes [<class>])
00104  ****************************************************************/
00105 globle void BrowseClassesCommand(
00106   void *theEnv)
00107   {
00108    register DEFCLASS *cls;
00109    
00110    if (EnvRtnArgCount(theEnv) == 0)
00111       /* ================================================
00112          Find the OBJECT root class (has no superclasses)
00113          ================================================ */
00114       cls = LookupDefclassByMdlOrScope(theEnv,OBJECT_TYPE_NAME);
00115    else
00116      {
00117       DATA_OBJECT tmp;
00118 
00119       if (EnvArgTypeCheck(theEnv,"browse-classes",1,SYMBOL,&tmp) == FALSE)
00120         return;
00121       cls = LookupDefclassByMdlOrScope(theEnv,DOToString(tmp));
00122       if (cls == NULL)
00123         {
00124          ClassExistError(theEnv,"browse-classes",DOToString(tmp));
00125          return;
00126         }
00127      }
00128    EnvBrowseClasses(theEnv,WDISPLAY,(void *) cls);
00129   }
00130 
00131 /****************************************************************
00132   NAME         : EnvBrowseClasses
00133   DESCRIPTION  : Displays a "graph" of the class hierarchy
00134   INPUTS       : 1) The logical name of the output
00135                  2) Class pointer
00136   RETURNS      : Nothing useful
00137   SIDE EFFECTS : None
00138   NOTES        : None
00139  ****************************************************************/
00140 globle void EnvBrowseClasses(
00141   void *theEnv,
00142   char *logicalName,
00143   void *clsptr)
00144   {
00145    PrintClassBrowse(theEnv,logicalName,(DEFCLASS *) clsptr,0);
00146   }
00147 
00148 /****************************************************************
00149   NAME         : DescribeClassCommand
00150   DESCRIPTION  : Displays direct superclasses and
00151                    subclasses and the entire precedence
00152                    list for a class
00153   INPUTS       : None
00154   RETURNS      : Nothing useful
00155   SIDE EFFECTS : None
00156   NOTES        : Syntax : (describe-class <class-name>)
00157  ****************************************************************/
00158 globle void DescribeClassCommand(
00159   void *theEnv)
00160   {
00161    char *cname;
00162    DEFCLASS *cls;
00163    
00164    cname = GetClassNameArgument(theEnv,"describe-class");
00165    if (cname == NULL)
00166      return;
00167    cls = CheckClass(theEnv,"describe-class",cname);
00168    if (cls == NULL)
00169      return;
00170    EnvDescribeClass(theEnv,WDISPLAY,(void *) cls);
00171   }
00172 
00173 /******************************************************
00174   NAME         : EnvDescribeClass
00175   DESCRIPTION  : Displays direct superclasses and
00176                    subclasses and the entire precedence
00177                    list for a class
00178   INPUTS       : 1) The logical name of the output
00179                  2) Class pointer
00180   RETURNS      : Nothing useful
00181   SIDE EFFECTS : None
00182   NOTES        : None
00183  ******************************************************/
00184 globle void EnvDescribeClass(
00185   void *theEnv,
00186   char *logicalName,
00187   void *clsptr)
00188   {
00189    DEFCLASS *cls;
00190    char buf[83],
00191         slotNamePrintFormat[12],
00192         overrideMessagePrintFormat[12];
00193    int messageBanner;
00194    long i;
00195    size_t slotNameLength, maxSlotNameLength;
00196    size_t overrideMessageLength, maxOverrideMessageLength;
00197 
00198    cls = (DEFCLASS *) clsptr;
00199    DisplaySeparator(theEnv,logicalName,buf,82,'=');
00200    DisplaySeparator(theEnv,logicalName,buf,82,'*');
00201    if (cls->abstract)
00202      EnvPrintRouter(theEnv,logicalName,"Abstract: direct instances of this class cannot be created.\n\n");
00203    else
00204      {
00205       EnvPrintRouter(theEnv,logicalName,"Concrete: direct instances of this class can be created.\n");
00206 #if DEFRULE_CONSTRUCT
00207       if (cls->reactive)
00208         EnvPrintRouter(theEnv,logicalName,"Reactive: direct instances of this class can match defrule patterns.\n\n");
00209       else
00210         EnvPrintRouter(theEnv,logicalName,"Non-reactive: direct instances of this class cannot match defrule patterns.\n\n");
00211 #else
00212       EnvPrintRouter(theEnv,logicalName,"\n");
00213 #endif
00214      }
00215    PrintPackedClassLinks(theEnv,logicalName,"Direct Superclasses:",&cls->directSuperclasses);
00216    PrintPackedClassLinks(theEnv,logicalName,"Inheritance Precedence:",&cls->allSuperclasses);
00217    PrintPackedClassLinks(theEnv,logicalName,"Direct Subclasses:",&cls->directSubclasses);
00218    if (cls->instanceTemplate != NULL)
00219      {
00220       DisplaySeparator(theEnv,logicalName,buf,82,'-');
00221       maxSlotNameLength = 5;
00222       maxOverrideMessageLength = 8;
00223       for (i = 0 ; i < cls->instanceSlotCount ; i++)
00224         {
00225          slotNameLength = strlen(ValueToString(cls->instanceTemplate[i]->slotName->name));
00226          if (slotNameLength > maxSlotNameLength)
00227            maxSlotNameLength = slotNameLength;
00228          if (cls->instanceTemplate[i]->noWrite == 0)
00229            {
00230             overrideMessageLength =
00231               strlen(ValueToString(cls->instanceTemplate[i]->overrideMessage));
00232             if (overrideMessageLength > maxOverrideMessageLength)
00233               maxOverrideMessageLength = overrideMessageLength;
00234            }
00235         }
00236       if (maxSlotNameLength > 16)
00237         maxSlotNameLength = 16;
00238       if (maxOverrideMessageLength > 12)
00239         maxOverrideMessageLength = 12;
00240 #if WIN_MVC || WIN_BTC
00241       gensprintf(slotNamePrintFormat,"%%-%Id.%Ids : ",maxSlotNameLength,maxSlotNameLength);
00242       gensprintf(overrideMessagePrintFormat,"%%-%Id.%Ids ",maxOverrideMessageLength,
00243                                               maxOverrideMessageLength);
00244 #elif WIN_GCC
00245       gensprintf(slotNamePrintFormat,"%%-%ld.%lds : ",(long) maxSlotNameLength,(long) maxSlotNameLength);
00246       gensprintf(overrideMessagePrintFormat,"%%-%ld.%lds ",(long) maxOverrideMessageLength,
00247                                             (long) maxOverrideMessageLength);
00248 #else
00249       gensprintf(slotNamePrintFormat,"%%-%zd.%zds : ",maxSlotNameLength,maxSlotNameLength);
00250       gensprintf(overrideMessagePrintFormat,"%%-%zd.%zds ",maxOverrideMessageLength,
00251                                               maxOverrideMessageLength);
00252 #endif
00253 
00254       DisplaySlotBasicInfo(theEnv,logicalName,slotNamePrintFormat,overrideMessagePrintFormat,buf,cls);
00255       EnvPrintRouter(theEnv,logicalName,"\nConstraint information for slots:\n\n");
00256       DisplaySlotConstraintInfo(theEnv,logicalName,slotNamePrintFormat,buf,82,cls);
00257      }
00258    if (cls->handlerCount > 0)
00259      messageBanner = TRUE;
00260    else
00261      {
00262       messageBanner = FALSE;
00263       for (i = 1 ; i < cls->allSuperclasses.classCount ; i++)
00264         if (cls->allSuperclasses.classArray[i]->handlerCount > 0)
00265           {
00266            messageBanner = TRUE;
00267            break;
00268           }
00269      }
00270    if (messageBanner)
00271      {
00272       DisplaySeparator(theEnv,logicalName,buf,82,'-');
00273       EnvPrintRouter(theEnv,logicalName,"Recognized message-handlers:\n");
00274       DisplayHandlersInLinks(theEnv,logicalName,&cls->allSuperclasses,0);
00275      }
00276    DisplaySeparator(theEnv,logicalName,buf,82,'*');
00277    DisplaySeparator(theEnv,logicalName,buf,82,'=');
00278   }
00279 
00280 #endif
00281 
00282 /**********************************************************
00283   NAME         : GetCreateAccessorString
00284   DESCRIPTION  : Gets a string describing which
00285                  accessors are implicitly created
00286                  for a slot: R, W, RW or NIL
00287   INPUTS       : The slot descriptor
00288   RETURNS      : The string description
00289   SIDE EFFECTS : None
00290   NOTES        : Used by (describe-class) and (slot-facets)
00291  **********************************************************/
00292 globle char *GetCreateAccessorString(
00293   void *vsd)
00294   {
00295    SLOT_DESC *sd = (SLOT_DESC *) vsd;
00296 
00297    if (sd->createReadAccessor && sd->createWriteAccessor)
00298      return("RW");
00299    if ((sd->createReadAccessor == 0) && (sd->createWriteAccessor == 0))
00300      return("NIL");
00301    else
00302      {
00303       if (sd->createReadAccessor) return "R";
00304       else return "W";
00305      }
00306   }
00307 
00308 /************************************************************
00309   NAME         : GetDefclassModuleCommand
00310   DESCRIPTION  : Determines to which module a class belongs
00311   INPUTS       : None
00312   RETURNS      : The symbolic name of the module
00313   SIDE EFFECTS : None
00314   NOTES        : H/L Syntax: (defclass-module <class-name>)
00315  ************************************************************/
00316 globle void *GetDefclassModuleCommand(
00317   void *theEnv)
00318   {
00319    return(GetConstructModuleCommand(theEnv,"defclass-module",DefclassData(theEnv)->DefclassConstruct));
00320   }
00321 
00322 /*********************************************************************
00323   NAME         : SuperclassPCommand
00324   DESCRIPTION  : Determines if a class is a superclass of another
00325   INPUTS       : None
00326   RETURNS      : TRUE if class-1 is a superclass of class-2
00327   SIDE EFFECTS : None
00328   NOTES        : H/L Syntax : (superclassp <class-1> <class-2>)
00329  *********************************************************************/
00330 globle intBool SuperclassPCommand(
00331   void *theEnv)
00332   {
00333    DEFCLASS *c1,*c2;
00334    
00335    if (CheckTwoClasses(theEnv,"superclassp",&c1,&c2) == FALSE)
00336      return(FALSE);
00337    return(EnvSuperclassP(theEnv,(void *) c1,(void *) c2));
00338   }
00339 
00340 /***************************************************
00341   NAME         : EnvSuperclassP
00342   DESCRIPTION  : Determines if the first class is
00343                  a superclass of the other
00344   INPUTS       : 1) First class
00345                  2) Second class
00346   RETURNS      : TRUE if first class is a
00347                  superclass of the first,
00348                  FALSE otherwise
00349   SIDE EFFECTS : None
00350   NOTES        : None
00351  ***************************************************/
00352 #if WIN_BTC
00353 #pragma argsused
00354 #endif
00355 globle intBool EnvSuperclassP(
00356   void *theEnv,
00357   void *firstClass,
00358   void *secondClass)
00359   {
00360 #if MAC_MCW || WIN_MCW || MAC_XCD
00361 #pragma unused(theEnv)
00362 #endif
00363 
00364    return(HasSuperclass((DEFCLASS *) secondClass,(DEFCLASS *) firstClass));
00365   }
00366 
00367 /*********************************************************************
00368   NAME         : SubclassPCommand
00369   DESCRIPTION  : Determines if a class is a subclass of another
00370   INPUTS       : None
00371   RETURNS      : TRUE if class-1 is a subclass of class-2
00372   SIDE EFFECTS : None
00373   NOTES        : H/L Syntax : (subclassp <class-1> <class-2>)
00374  *********************************************************************/
00375 globle intBool SubclassPCommand(
00376   void *theEnv)
00377   {
00378    DEFCLASS *c1,*c2;
00379    
00380    if (CheckTwoClasses(theEnv,"subclassp",&c1,&c2) == FALSE)
00381      return(FALSE);
00382    return(EnvSubclassP(theEnv,(void *) c1,(void *) c2));
00383   }
00384 
00385 /***************************************************
00386   NAME         : EnvSubclassP
00387   DESCRIPTION  : Determines if the first class is
00388                  a subclass of the other
00389   INPUTS       : 1) First class
00390                  2) Second class
00391   RETURNS      : TRUE if first class is a
00392                  subclass of the first,
00393                  FALSE otherwise
00394   SIDE EFFECTS : None
00395   NOTES        : None
00396  ***************************************************/
00397 #if WIN_BTC
00398 #pragma argsused
00399 #endif
00400 globle intBool EnvSubclassP(
00401   void *theEnv,
00402   void *firstClass,
00403   void *secondClass)
00404   {
00405 #if MAC_MCW || WIN_MCW || MAC_XCD
00406 #pragma unused(theEnv)
00407 #endif
00408 
00409    return(HasSuperclass((DEFCLASS *) firstClass,(DEFCLASS *) secondClass));
00410   }
00411 
00412 /*********************************************************************
00413   NAME         : SlotExistPCommand
00414   DESCRIPTION  : Determines if a slot is present in a class
00415   INPUTS       : None
00416   RETURNS      : TRUE if the slot exists, FALSE otherwise
00417   SIDE EFFECTS : None
00418   NOTES        : H/L Syntax : (slot-existp <class> <slot> [inherit])
00419  *********************************************************************/
00420 globle int SlotExistPCommand(
00421   void *theEnv)
00422   {
00423    DEFCLASS *cls;
00424    SLOT_DESC *sd;
00425    int inheritFlag = FALSE;
00426    DATA_OBJECT dobj;
00427    
00428    sd = CheckSlotExists(theEnv,"slot-existp",&cls,FALSE,TRUE);
00429    if (sd == NULL)
00430      return(FALSE);
00431    if (EnvRtnArgCount(theEnv) == 3)
00432      {
00433       if (EnvArgTypeCheck(theEnv,"slot-existp",3,SYMBOL,&dobj) == FALSE)
00434         return(FALSE);
00435       if (strcmp(DOToString(dobj),"inherit") != 0)
00436         {
00437          ExpectedTypeError1(theEnv,"slot-existp",3,"keyword \"inherit\"");
00438          SetEvaluationError(theEnv,TRUE);
00439          return(FALSE);
00440         }
00441       inheritFlag = TRUE;
00442      }
00443    return((sd->cls == cls) ? TRUE : inheritFlag);
00444   }
00445 
00446 /***************************************************
00447   NAME         : EnvSlotExistP
00448   DESCRIPTION  : Determines if a slot exists
00449   INPUTS       : 1) The class
00450                  2) The slot name
00451                  3) A flag indicating if the slot
00452                     can be inherited or not
00453   RETURNS      : TRUE if slot exists,
00454                  FALSE otherwise
00455   SIDE EFFECTS : None
00456   NOTES        : None
00457  ***************************************************/
00458 globle intBool EnvSlotExistP(
00459   void *theEnv,
00460   void *theDefclass,
00461   char *slotName,
00462   intBool inheritFlag)
00463   {
00464    return((LookupSlot(theEnv,(DEFCLASS *) theDefclass,slotName,inheritFlag) != NULL)
00465            ? TRUE : FALSE);
00466   }
00467 
00468 /************************************************************************************
00469   NAME         : MessageHandlerExistPCommand
00470   DESCRIPTION  : Determines if a message-handler is present in a class
00471   INPUTS       : None
00472   RETURNS      : TRUE if the message header is present, FALSE otherwise
00473   SIDE EFFECTS : None
00474   NOTES        : H/L Syntax : (message-handler-existp <class> <hnd> [<type>])
00475  ************************************************************************************/
00476 globle int MessageHandlerExistPCommand(
00477   void *theEnv)
00478   {
00479    DEFCLASS *cls;
00480    SYMBOL_HN *mname;
00481    DATA_OBJECT temp;
00482    unsigned mtype = MPRIMARY;
00483    
00484    if (EnvArgTypeCheck(theEnv,"message-handler-existp",1,SYMBOL,&temp) == FALSE)
00485      return(FALSE);
00486    cls = LookupDefclassByMdlOrScope(theEnv,DOToString(temp));
00487    if (cls == NULL)
00488      {
00489       ClassExistError(theEnv,"message-handler-existp",DOToString(temp));
00490       return(FALSE);
00491      }
00492    if (EnvArgTypeCheck(theEnv,"message-handler-existp",2,SYMBOL,&temp) == FALSE)
00493      return(FALSE);
00494    mname = (SYMBOL_HN *) GetValue(temp);
00495    if (EnvRtnArgCount(theEnv) == 3)
00496      {
00497       if (EnvArgTypeCheck(theEnv,"message-handler-existp",3,SYMBOL,&temp) == FALSE)
00498         return(FALSE);
00499       mtype = HandlerType(theEnv,"message-handler-existp",DOToString(temp));
00500       if (mtype == MERROR)
00501         {
00502          SetEvaluationError(theEnv,TRUE);
00503          return(FALSE);
00504         }
00505      }
00506    if (FindHandlerByAddress(cls,mname,mtype) != NULL)
00507      return(TRUE);
00508    return(FALSE);
00509   }
00510 
00511 /**********************************************************************
00512   NAME         : SlotWritablePCommand
00513   DESCRIPTION  : Determines if an existing slot can be written to
00514   INPUTS       : None
00515   RETURNS      : TRUE if the slot is writable, FALSE otherwise
00516   SIDE EFFECTS : None
00517   NOTES        : H/L Syntax : (slot-writablep <class> <slot>)
00518  **********************************************************************/
00519 globle intBool SlotWritablePCommand(
00520   void *theEnv)
00521   {
00522    DEFCLASS *theDefclass;
00523    SLOT_DESC *sd;
00524    
00525    sd = CheckSlotExists(theEnv,"slot-writablep",&theDefclass,TRUE,TRUE);
00526    if (sd == NULL)
00527      return(FALSE);
00528    return((sd->noWrite || sd->initializeOnly) ? FALSE : TRUE);
00529   }
00530 
00531 /***************************************************
00532   NAME         : EnvSlotWritableP
00533   DESCRIPTION  : Determines if a slot is writable
00534   INPUTS       : 1) The class
00535                  2) The slot name
00536   RETURNS      : TRUE if slot is writable,
00537                  FALSE otherwise
00538   SIDE EFFECTS : None
00539   NOTES        : None
00540  ***************************************************/
00541 globle intBool EnvSlotWritableP(
00542   void *theEnv,
00543   void *theDefclass,
00544   char *slotName)
00545   {
00546    SLOT_DESC *sd;
00547 
00548    if ((sd = LookupSlot(theEnv,(DEFCLASS *) theDefclass,slotName,TRUE)) == NULL)
00549      return(FALSE);
00550    return((sd->noWrite || sd->initializeOnly) ? FALSE : TRUE);
00551   }
00552 
00553 /**********************************************************************
00554   NAME         : SlotInitablePCommand
00555   DESCRIPTION  : Determines if an existing slot can be initialized
00556                    via an init message-handler or slot-override
00557   INPUTS       : None
00558   RETURNS      : TRUE if the slot is writable, FALSE otherwise
00559   SIDE EFFECTS : None
00560   NOTES        : H/L Syntax : (slot-initablep <class> <slot>)
00561  **********************************************************************/
00562 globle intBool SlotInitablePCommand(
00563   void *theEnv)
00564   {
00565    DEFCLASS *theDefclass;
00566    SLOT_DESC *sd;
00567    
00568    sd = CheckSlotExists(theEnv,"slot-initablep",&theDefclass,TRUE,TRUE);
00569    if (sd == NULL)
00570      return(FALSE);
00571    return((sd->noWrite && (sd->initializeOnly == 0)) ? FALSE : TRUE);
00572   }
00573 
00574 /***************************************************
00575   NAME         : EnvSlotInitableP
00576   DESCRIPTION  : Determines if a slot is initable
00577   INPUTS       : 1) The class
00578                  2) The slot name
00579   RETURNS      : TRUE if slot is initable,
00580                  FALSE otherwise
00581   SIDE EFFECTS : None
00582   NOTES        : None
00583  ***************************************************/
00584 globle intBool EnvSlotInitableP(
00585   void *theEnv,
00586   void *theDefclass,
00587   char *slotName)
00588   {
00589    SLOT_DESC *sd;
00590 
00591    if ((sd = LookupSlot(theEnv,(DEFCLASS *) theDefclass,slotName,TRUE)) == NULL)
00592      return(FALSE);
00593    return((sd->noWrite && (sd->initializeOnly == 0)) ? FALSE : TRUE);
00594   }
00595 
00596 /**********************************************************************
00597   NAME         : SlotPublicPCommand
00598   DESCRIPTION  : Determines if an existing slot is publicly visible
00599                    for direct reference by subclasses
00600   INPUTS       : None
00601   RETURNS      : TRUE if the slot is public, FALSE otherwise
00602   SIDE EFFECTS : None
00603   NOTES        : H/L Syntax : (slot-publicp <class> <slot>)
00604  **********************************************************************/
00605 globle intBool SlotPublicPCommand(
00606   void *theEnv)
00607   {
00608    DEFCLASS *theDefclass;
00609    SLOT_DESC *sd;
00610    
00611    sd = CheckSlotExists(theEnv,"slot-publicp",&theDefclass,TRUE,FALSE);
00612    if (sd == NULL)
00613      return(FALSE);
00614    return(sd->publicVisibility ? TRUE : FALSE);
00615   }
00616 
00617 /***************************************************
00618   NAME         : EnvSlotPublicP
00619   DESCRIPTION  : Determines if a slot is public
00620   INPUTS       : 1) The class
00621                  2) The slot name
00622   RETURNS      : TRUE if slot is public,
00623                  FALSE otherwise
00624   SIDE EFFECTS : None
00625   NOTES        : None
00626  ***************************************************/
00627 globle intBool EnvSlotPublicP(
00628   void *theEnv,
00629   void *theDefclass,
00630   char *slotName)
00631   {
00632    SLOT_DESC *sd;
00633 
00634    if ((sd = LookupSlot(theEnv,(DEFCLASS *) theDefclass,slotName,FALSE)) == NULL)
00635      return(FALSE);
00636    return(sd->publicVisibility ? TRUE : FALSE);
00637   }
00638 
00639 /***************************************************
00640   NAME         : EnvSlotDefaultP
00641   DESCRIPTION  : Determines if a slot has a default value
00642   INPUTS       : 1) The class
00643                  2) The slot name
00644   RETURNS      : TRUE if slot is public,
00645                  FALSE otherwise
00646   SIDE EFFECTS : None
00647   NOTES        : None
00648  ***************************************************/
00649 globle int EnvSlotDefaultP(
00650   void *theEnv,
00651   void *theDefclass,
00652   char *slotName)
00653   {
00654    SLOT_DESC *sd;
00655 
00656    if ((sd = LookupSlot(theEnv,(DEFCLASS *) theDefclass,slotName,FALSE)) == NULL)
00657      return(NO_DEFAULT);
00658      
00659    if (sd->noDefault)
00660      { return(NO_DEFAULT); }
00661    else if (sd->dynamicDefault)
00662      { return(DYNAMIC_DEFAULT); }
00663    
00664    return(STATIC_DEFAULT);
00665   }
00666   
00667   
00668 /**********************************************************************
00669   NAME         : SlotDirectAccessPCommand
00670   DESCRIPTION  : Determines if an existing slot can be directly
00671                    referenced by the class - i.e., if the slot is
00672                    private, is the slot defined in the class
00673   INPUTS       : None
00674   RETURNS      : TRUE if the slot is private,
00675                     FALSE otherwise
00676   SIDE EFFECTS : None
00677   NOTES        : H/L Syntax : (slot-direct-accessp <class> <slot>)
00678  **********************************************************************/
00679 globle intBool SlotDirectAccessPCommand(
00680   void *theEnv)
00681   {
00682    DEFCLASS *theDefclass;
00683    SLOT_DESC *sd;
00684    
00685    sd = CheckSlotExists(theEnv,"slot-direct-accessp",&theDefclass,TRUE,TRUE);
00686    if (sd == NULL)
00687      return(FALSE);
00688    return((sd->publicVisibility || (sd->cls == theDefclass)) ? TRUE : FALSE);
00689   }
00690 
00691 /***************************************************
00692   NAME         : EnvSlotDirectAccessP
00693   DESCRIPTION  : Determines if a slot is directly
00694                  accessible from message-handlers
00695                  on class
00696   INPUTS       : 1) The class
00697                  2) The slot name
00698   RETURNS      : TRUE if slot is directly
00699                  accessible, FALSE otherwise
00700   SIDE EFFECTS : None
00701   NOTES        : None
00702  ***************************************************/
00703 globle intBool EnvSlotDirectAccessP(
00704   void *theEnv,
00705   void *theDefclass,
00706   char *slotName)
00707   {
00708    SLOT_DESC *sd;
00709 
00710    if ((sd = LookupSlot(theEnv,(DEFCLASS *) theDefclass,slotName,TRUE)) == NULL)
00711      return(FALSE);
00712    return((sd->publicVisibility || (sd->cls == (DEFCLASS *) theDefclass)) ?
00713            TRUE : FALSE);
00714   }
00715 
00716 /**********************************************************************
00717   NAME         : SlotDefaultValueCommand
00718   DESCRIPTION  : Determines the default avlue for the specified slot
00719                  of the specified class
00720   INPUTS       : None
00721   RETURNS      : Nothing useful
00722   SIDE EFFECTS : None
00723   NOTES        : H/L Syntax : (slot-default-value <class> <slot>)
00724  **********************************************************************/
00725 globle void SlotDefaultValueCommand(
00726   void *theEnv,
00727   DATA_OBJECT_PTR theValue)
00728   {
00729    DEFCLASS *theDefclass;
00730    SLOT_DESC *sd;
00731 
00732    SetpType(theValue,SYMBOL);
00733    SetpValue(theValue,EnvFalseSymbol(theEnv));
00734    sd = CheckSlotExists(theEnv,"slot-default-value",&theDefclass,TRUE,TRUE);
00735    if (sd == NULL)
00736      return;
00737    
00738    if (sd->noDefault)
00739      {
00740       SetpType(theValue,SYMBOL);
00741       SetpValue(theValue,EnvAddSymbol(theEnv,"?NONE"));
00742       return; 
00743      }
00744      
00745    if (sd->dynamicDefault)
00746      EvaluateAndStoreInDataObject(theEnv,(int) sd->multiple,
00747                                   (EXPRESSION *) sd->defaultValue,
00748                                   theValue,TRUE);
00749    else
00750      GenCopyMemory(DATA_OBJECT,1,theValue,sd->defaultValue);
00751   }
00752 
00753 /*********************************************************
00754   NAME         : SlotDefaultValue
00755   DESCRIPTION  : Determines the default value for
00756                  the specified slot of the specified class
00757   INPUTS       : 1) The class
00758                  2) The slot name
00759   RETURNS      : TRUE if slot default value is set,
00760                  FALSE otherwise
00761   SIDE EFFECTS : Slot default value evaluated - dynamic
00762                  defaults will cause any side effects
00763   NOTES        : None
00764  *********************************************************/
00765 globle intBool EnvSlotDefaultValue(
00766   void *theEnv,
00767   void *theDefclass,
00768   char *slotName,
00769   DATA_OBJECT_PTR theValue)
00770   {
00771    SLOT_DESC *sd;
00772 
00773    SetpType(theValue,SYMBOL);
00774    SetpValue(theValue,EnvFalseSymbol(theEnv));
00775    if ((sd = LookupSlot(theEnv,(DEFCLASS *) theDefclass,slotName,TRUE)) == NULL)
00776      return(FALSE);
00777    
00778    if (sd->noDefault)
00779      {
00780       SetpType(theValue,SYMBOL);
00781       SetpValue(theValue,EnvAddSymbol(theEnv,"?NONE"));
00782       return(TRUE); 
00783      }
00784      
00785    if (sd->dynamicDefault)
00786      return(EvaluateAndStoreInDataObject(theEnv,(int) sd->multiple,
00787                                          (EXPRESSION *) sd->defaultValue,
00788                                          theValue,TRUE));
00789    GenCopyMemory(DATA_OBJECT,1,theValue,sd->defaultValue);
00790    return(TRUE);
00791   }
00792 
00793 /********************************************************
00794   NAME         : ClassExistPCommand
00795   DESCRIPTION  : Determines if a class exists
00796   INPUTS       : None
00797   RETURNS      : TRUE if class exists, FALSE otherwise
00798   SIDE EFFECTS : None
00799   NOTES        : H/L Syntax : (class-existp <arg>)
00800  ********************************************************/
00801 globle intBool ClassExistPCommand(
00802   void *theEnv)
00803   {
00804    DATA_OBJECT temp;
00805    
00806    if (EnvArgTypeCheck(theEnv,"class-existp",1,SYMBOL,&temp) == FALSE)
00807      return(FALSE);
00808    return((LookupDefclassByMdlOrScope(theEnv,DOToString(temp)) != NULL) ? TRUE : FALSE);
00809   }
00810 
00811 /* =========================================
00812    *****************************************
00813           INTERNALLY VISIBLE FUNCTIONS
00814    =========================================
00815    ***************************************** */
00816 
00817 /******************************************************
00818   NAME         : CheckTwoClasses
00819   DESCRIPTION  : Checks for exactly two class arguments
00820                     for a H/L function
00821   INPUTS       : 1) The function name
00822                  2) Caller's buffer for first class
00823                  3) Caller's buffer for second class
00824   RETURNS      : TRUE if both found, FALSE otherwise
00825   SIDE EFFECTS : Caller's buffers set
00826   NOTES        : Assumes exactly 2 arguments
00827  ******************************************************/
00828 static int CheckTwoClasses(
00829   void *theEnv,
00830   char *func,
00831   DEFCLASS **c1,
00832   DEFCLASS **c2)
00833   {
00834    DATA_OBJECT temp;
00835 
00836    if (EnvArgTypeCheck(theEnv,func,1,SYMBOL,&temp) == FALSE)
00837      return(FALSE);
00838    *c1 = LookupDefclassByMdlOrScope(theEnv,DOToString(temp));
00839    if (*c1 == NULL)
00840      {
00841       ClassExistError(theEnv,func,ValueToString(temp.value));
00842       return(FALSE);
00843      }
00844    if (EnvArgTypeCheck(theEnv,func,2,SYMBOL,&temp) == FALSE)
00845      return(FALSE);
00846    *c2 = LookupDefclassByMdlOrScope(theEnv,DOToString(temp));
00847    if (*c2 == NULL)
00848      {
00849       ClassExistError(theEnv,func,ValueToString(temp.value));
00850       return(FALSE);
00851      }
00852    return(TRUE);
00853   }
00854 
00855 /***************************************************
00856   NAME         : CheckSlotExists
00857   DESCRIPTION  : Checks first two arguments of
00858                  a function for a valid class
00859                  and (inherited) slot
00860   INPUTS       : 1) The name of the function
00861                  2) A buffer to hold the found class
00862                  3) A flag indicating whether the
00863                     non-existence of the slot should
00864                     be an error
00865                  4) A flag indicating if the slot
00866                     can be inherited or not
00867   RETURNS      : NULL if slot not found, slot
00868                  descriptor otherwise
00869   SIDE EFFECTS : Class buffer set if no errors,
00870                  NULL on errors
00871   NOTES        : None
00872  ***************************************************/
00873 static SLOT_DESC *CheckSlotExists(
00874   void *theEnv,
00875   char *func,
00876   DEFCLASS **classBuffer,
00877   intBool existsErrorFlag,
00878   intBool inheritFlag)
00879   {
00880    SYMBOL_HN *ssym;
00881    int slotIndex;
00882    SLOT_DESC *sd;
00883 
00884    ssym = CheckClassAndSlot(theEnv,func,classBuffer);
00885    if (ssym == NULL)
00886      return(NULL);
00887    slotIndex = FindInstanceTemplateSlot(theEnv,*classBuffer,ssym);
00888    if (slotIndex == -1)
00889      {
00890       if (existsErrorFlag)
00891         {
00892          SlotExistError(theEnv,ValueToString(ssym),func);
00893          SetEvaluationError(theEnv,TRUE);
00894         }
00895       return(NULL);
00896      }
00897    sd = (*classBuffer)->instanceTemplate[slotIndex];
00898    if ((sd->cls == *classBuffer) || inheritFlag)
00899      return(sd);
00900    PrintErrorID(theEnv,"CLASSEXM",1,FALSE);
00901    EnvPrintRouter(theEnv,WERROR,"Inherited slot ");
00902    EnvPrintRouter(theEnv,WERROR,ValueToString(ssym));
00903    EnvPrintRouter(theEnv,WERROR," from class ");
00904    PrintClassName(theEnv,WERROR,sd->cls,FALSE);
00905    EnvPrintRouter(theEnv,WERROR," is not valid for function ");
00906    EnvPrintRouter(theEnv,WERROR,func);
00907    EnvPrintRouter(theEnv,WERROR,"\n");
00908    SetEvaluationError(theEnv,TRUE);
00909    return(NULL);
00910   }
00911 
00912 /***************************************************
00913   NAME         : LookupSlot
00914   DESCRIPTION  : Finds a slot in a class
00915   INPUTS       : 1) The class
00916                  2) The slot name
00917                  3) A flag indicating if inherited
00918                     slots are OK or not
00919   RETURNS      : The slot descriptor address, or
00920                  NULL if not found
00921   SIDE EFFECTS : None
00922   NOTES        : None
00923  ***************************************************/
00924 static SLOT_DESC *LookupSlot(
00925   void *theEnv,
00926   DEFCLASS *theDefclass,
00927   char *slotName,
00928   intBool inheritFlag)
00929   {
00930    SYMBOL_HN *slotSymbol;
00931    int slotIndex;
00932    SLOT_DESC *sd;
00933 
00934    slotSymbol = FindSymbolHN(theEnv,slotName);
00935    if (slotSymbol == NULL)
00936      return(NULL);
00937    slotIndex = FindInstanceTemplateSlot(theEnv,theDefclass,slotSymbol);
00938    if (slotIndex == -1)
00939      return(NULL);
00940    sd = theDefclass->instanceTemplate[slotIndex];
00941    if ((sd->cls != theDefclass) && (inheritFlag == FALSE))
00942      return(NULL);
00943    return(sd);
00944   }
00945 
00946 #if DEBUGGING_FUNCTIONS
00947 
00948 /*****************************************************
00949   NAME         : CheckClass
00950   DESCRIPTION  : Used for to check class name for
00951                  class accessor functions such
00952                  as ppdefclass and undefclass
00953   INPUTS       : 1) The name of the H/L function
00954                  2) Name of the class
00955   RETURNS      : The class address,
00956                    or NULL if ther was an error
00957   SIDE EFFECTS : None
00958   NOTES        : None
00959  ******************************************************/
00960 static DEFCLASS *CheckClass(
00961   void *theEnv,
00962   char *func,
00963   char *cname)
00964   {
00965    DEFCLASS *cls;
00966 
00967    cls = LookupDefclassByMdlOrScope(theEnv,cname);
00968    if (cls == NULL)
00969      ClassExistError(theEnv,func,cname);
00970    return(cls);
00971   }
00972 
00973 /*********************************************************
00974   NAME         : GetClassNameArgument
00975   DESCRIPTION  : Gets a class name-string
00976   INPUTS       : Calling function name
00977   RETURNS      : Class name (NULL on errors)
00978   SIDE EFFECTS : None
00979   NOTES        : Assumes only 1 argument
00980  *********************************************************/
00981 static char *GetClassNameArgument(
00982   void *theEnv,
00983   char *fname)
00984   {
00985    DATA_OBJECT temp;
00986 
00987    if (EnvArgTypeCheck(theEnv,fname,1,SYMBOL,&temp) == FALSE)
00988      return(NULL);
00989    return(DOToString(temp));
00990   }
00991 
00992 /****************************************************************
00993   NAME         : PrintClassBrowse
00994   DESCRIPTION  : Displays a "graph" of class and subclasses
00995   INPUTS       : 1) The logical name of the output
00996                  2) The class address
00997                  3) The depth of the graph
00998   RETURNS      : Nothing useful
00999   SIDE EFFECTS : None
01000   NOTES        : None
01001  ****************************************************************/
01002 static void PrintClassBrowse(
01003   void *theEnv,
01004   char *logicalName,
01005   DEFCLASS *cls,
01006   long depth)
01007   {
01008    long i;
01009 
01010    for (i = 0 ; i < depth ; i++)
01011      EnvPrintRouter(theEnv,logicalName,"  ");
01012    EnvPrintRouter(theEnv,logicalName,EnvGetDefclassName(theEnv,(void *) cls));
01013    if (cls->directSuperclasses.classCount > 1)
01014      EnvPrintRouter(theEnv,logicalName," *");
01015    EnvPrintRouter(theEnv,logicalName,"\n");
01016    for (i = 0 ;i < cls->directSubclasses.classCount ; i++)
01017      PrintClassBrowse(theEnv,logicalName,cls->directSubclasses.classArray[i],depth+1);
01018   }
01019 
01020 /*********************************************************
01021   NAME         : DisplaySeparator
01022   DESCRIPTION  : Prints a separator line for DescribeClass
01023   INPUTS       : 1) The logical name of the output
01024                  2) The buffer to use for the line
01025                  3) The buffer size
01026                  4) The character to use
01027   RETURNS      : Nothing useful
01028   SIDE EFFECTS : Buffer overwritten and displayed
01029   NOTES        : None
01030  *********************************************************/
01031 static void DisplaySeparator(
01032   void *theEnv,
01033   char *logicalName,
01034   char *buf,
01035   int maxlen,
01036   int sepchar)
01037   {
01038    register int i;
01039 
01040    for (i = 0 ; i < maxlen-2 ; i++)
01041      buf[i] = (char) sepchar;
01042    buf[i++] = '\n';
01043    buf[i] = '\0';
01044    EnvPrintRouter(theEnv,logicalName,buf);
01045   }
01046 
01047 /*************************************************************
01048   NAME         : DisplaySlotBasicInfo
01049   DESCRIPTION  : Displays a table summary of basic
01050                   facets for the slots of a class
01051                   including:
01052                   single/multiple
01053                   default/no-default/default-dynamic
01054                   inherit/no-inherit
01055                   read-write/initialize-only/read-only
01056                   local/shared
01057                   composite/exclusive
01058                   reactive/non-reactive
01059                   public/private
01060                   create-accessor read/write
01061                   override-message
01062 
01063                   The function also displays the source
01064                   class(es) for the facets
01065   INPUTS       : 1) The logical name of the output
01066                  2) A format string for use in sprintf
01067                     (for printing slot names)
01068                  3) A format string for use in sprintf
01069                     (for printing slot override message names)
01070                  4) A buffer to store the display in
01071                  5) A pointer to the class
01072   RETURNS      : Nothing useful
01073   SIDE EFFECTS : Buffer written to and displayed
01074   NOTES        : None
01075  *************************************************************/
01076 static void DisplaySlotBasicInfo(
01077   void *theEnv,
01078   char *logicalName,
01079   char *slotNamePrintFormat,
01080   char *overrideMessagePrintFormat,
01081   char *buf,
01082   DEFCLASS *cls)
01083   {
01084    long i;
01085    SLOT_DESC *sp;
01086    char *createString;
01087 
01088    gensprintf(buf,slotNamePrintFormat,"SLOTS");
01089 #if DEFRULE_CONSTRUCT
01090    genstrcat(buf,"FLD DEF PRP ACC STO MCH SRC VIS CRT ");
01091 #else
01092    genstrcat(buf,"FLD DEF PRP ACC STO SRC VIS CRT ");
01093 #endif
01094    EnvPrintRouter(theEnv,logicalName,buf);
01095    gensprintf(buf,overrideMessagePrintFormat,"OVRD-MSG");
01096    EnvPrintRouter(theEnv,logicalName,buf);
01097    EnvPrintRouter(theEnv,logicalName,"SOURCE(S)\n");
01098    for (i = 0 ; i < cls->instanceSlotCount ; i++)
01099      {
01100       sp = cls->instanceTemplate[i];
01101       gensprintf(buf,slotNamePrintFormat,ValueToString(sp->slotName->name));
01102       genstrcat(buf,sp->multiple ? "MLT " : "SGL ");
01103       if (sp->noDefault)
01104         genstrcat(buf,"NIL ");
01105       else
01106         genstrcat(buf,sp->dynamicDefault ? "DYN " : "STC ");
01107       genstrcat(buf,sp->noInherit ? "NIL " : "INH ");
01108       if (sp->initializeOnly)
01109         genstrcat(buf,"INT ");
01110       else if (sp->noWrite)
01111         genstrcat(buf," R  ");
01112       else
01113         genstrcat(buf,"RW  ");
01114       genstrcat(buf,sp->shared ? "SHR " : "LCL ");
01115 #if DEFRULE_CONSTRUCT
01116       genstrcat(buf,sp->reactive ? "RCT " : "NIL ");
01117 #endif
01118       genstrcat(buf,sp->composite ? "CMP " : "EXC ");
01119       genstrcat(buf,sp->publicVisibility ? "PUB " : "PRV ");
01120       createString = GetCreateAccessorString(sp);
01121       if (createString[1] == '\0')
01122         genstrcat(buf," ");
01123       genstrcat(buf,createString);
01124       if ((createString[1] == '\0') ? TRUE : (createString[2] == '\0'))
01125         genstrcat(buf," ");
01126       genstrcat(buf," ");
01127       EnvPrintRouter(theEnv,logicalName,buf);
01128       gensprintf(buf,overrideMessagePrintFormat,
01129               sp->noWrite ? "NIL" : ValueToString(sp->overrideMessage));
01130       EnvPrintRouter(theEnv,logicalName,buf);
01131       PrintSlotSources(theEnv,logicalName,sp->slotName->name,&sp->cls->allSuperclasses,0,TRUE);
01132       EnvPrintRouter(theEnv,logicalName,"\n");
01133      }
01134   }
01135 
01136 /***************************************************
01137   NAME         : PrintSlotSources
01138   DESCRIPTION  : Displays a list of source classes
01139                    for a composite class (in order
01140                    of most general to specific)
01141   INPUTS       : 1) The logical name of the output
01142                  2) The name of the slot
01143                  3) The precedence list of the class
01144                     of the slot (the source class
01145                     shold be first in the list)
01146                  4) The index into the packed
01147                     links array
01148                  5) Flag indicating whether to
01149                     disregard noniherit facet
01150   RETURNS      : TRUE if a class is printed, FALSE
01151                  otherwise
01152   SIDE EFFECTS : Recursively prints out appropriate
01153                  memebers from list in reverse order
01154   NOTES        : None
01155  ***************************************************/
01156 static intBool PrintSlotSources(
01157   void *theEnv,
01158   char *logicalName,
01159   SYMBOL_HN *sname,
01160   PACKED_CLASS_LINKS *sprec,
01161   long theIndex,
01162   int inhp)
01163   {
01164    SLOT_DESC *csp;
01165 
01166    if (theIndex == sprec->classCount)
01167      return(FALSE);
01168    csp = FindClassSlot(sprec->classArray[theIndex],sname);
01169    if ((csp != NULL) ? ((csp->noInherit == 0) || inhp) : FALSE)
01170      {
01171       if (csp->composite)
01172         {
01173          if (PrintSlotSources(theEnv,logicalName,sname,sprec,theIndex+1,FALSE))
01174            EnvPrintRouter(theEnv,logicalName," ");
01175         }
01176       PrintClassName(theEnv,logicalName,sprec->classArray[theIndex],FALSE);
01177       return(TRUE);
01178      }
01179    else
01180      return(PrintSlotSources(theEnv,logicalName,sname,sprec,theIndex+1,FALSE));
01181   }
01182 
01183 /*********************************************************
01184   NAME         : DisplaySlotConstraintInfo
01185   DESCRIPTION  : Displays a table summary of type-checking
01186                   facets for the slots of a class
01187                   including:
01188                   type
01189                   allowed-symbols
01190                   allowed-integers
01191                   allowed-floats
01192                   allowed-values
01193                   allowed-instance-names
01194                   range
01195                   min-number-of-elements
01196                   max-number-of-elements
01197 
01198                   The function also displays the source
01199                   class(es) for the facets
01200   INPUTS       : 1) A format string for use in sprintf
01201                  2) A buffer to store the display in
01202                  3) Maximum buffer size
01203                  4) A pointer to the class
01204   RETURNS      : Nothing useful
01205   SIDE EFFECTS : Buffer written to and displayed
01206   NOTES        : None
01207  *********************************************************/
01208 static void DisplaySlotConstraintInfo(
01209   void *theEnv,
01210   char *logicalName,
01211   char *slotNamePrintFormat,
01212   char *buf,
01213   unsigned maxlen,
01214   DEFCLASS *cls)
01215   {
01216    long i;
01217    CONSTRAINT_RECORD *cr;
01218    char *strdest = "***describe-class***";
01219 
01220    gensprintf(buf,slotNamePrintFormat,"SLOTS");
01221    genstrcat(buf,"SYM STR INN INA EXA FTA INT FLT\n");
01222    EnvPrintRouter(theEnv,logicalName,buf);
01223    for (i = 0 ; i < cls->instanceSlotCount ; i++)
01224      {
01225       cr = cls->instanceTemplate[i]->constraint;
01226       gensprintf(buf,slotNamePrintFormat,ValueToString(cls->instanceTemplate[i]->slotName->name));
01227       if (cr != NULL)
01228         {
01229          genstrcat(buf,ConstraintCode(cr,(unsigned) cr->symbolsAllowed,
01230                                       (unsigned) cr->symbolRestriction));
01231          genstrcat(buf,ConstraintCode(cr,(unsigned) cr->stringsAllowed,
01232                                       (unsigned) cr->stringRestriction));
01233          genstrcat(buf,ConstraintCode(cr,(unsigned) cr->instanceNamesAllowed,
01234                                       (unsigned) (cr->instanceNameRestriction || cr->classRestriction)));
01235          genstrcat(buf,ConstraintCode(cr,(unsigned) cr->instanceAddressesAllowed,
01236                                       (unsigned) cr->classRestriction));
01237          genstrcat(buf,ConstraintCode(cr,(unsigned) cr->externalAddressesAllowed,0));
01238          genstrcat(buf,ConstraintCode(cr,(unsigned) cr->factAddressesAllowed,0));
01239          genstrcat(buf,ConstraintCode(cr,(unsigned) cr->integersAllowed,
01240                                       (unsigned) cr->integerRestriction));
01241          genstrcat(buf,ConstraintCode(cr,(unsigned) cr->floatsAllowed,
01242                                       (unsigned) cr->floatRestriction));
01243          OpenStringDestination(theEnv,strdest,buf + strlen(buf),(maxlen - strlen(buf) - 1));
01244          if (cr->integersAllowed || cr->floatsAllowed || cr->anyAllowed)
01245            {
01246             EnvPrintRouter(theEnv,strdest,"RNG:[");
01247             PrintExpression(theEnv,strdest,cr->minValue);
01248             EnvPrintRouter(theEnv,strdest,"..");
01249             PrintExpression(theEnv,strdest,cr->maxValue);
01250             EnvPrintRouter(theEnv,strdest,"] ");
01251            }
01252          if (cls->instanceTemplate[i]->multiple)
01253            {
01254             EnvPrintRouter(theEnv,strdest,"CRD:[");
01255             PrintExpression(theEnv,strdest,cr->minFields);
01256             EnvPrintRouter(theEnv,strdest,"..");
01257             PrintExpression(theEnv,strdest,cr->maxFields);
01258             EnvPrintRouter(theEnv,strdest,"]");
01259            }
01260         }
01261       else
01262         {
01263          OpenStringDestination(theEnv,strdest,buf,maxlen);
01264          EnvPrintRouter(theEnv,strdest," +   +   +   +   +   +   +   +  RNG:[-oo..+oo]");
01265          if (cls->instanceTemplate[i]->multiple)
01266            EnvPrintRouter(theEnv,strdest," CRD:[0..+oo]");
01267         }
01268       EnvPrintRouter(theEnv,strdest,"\n");
01269       CloseStringDestination(theEnv,strdest);
01270       EnvPrintRouter(theEnv,logicalName,buf);
01271      }
01272   }
01273 
01274 /******************************************************
01275   NAME         : ConstraintCode
01276   DESCRIPTION  : Gives a string code representing the
01277                  type of constraint
01278   INPUTS       : 1) The constraint record
01279                  2) Allowed Flag
01280                  3) Restricted Values flag
01281   RETURNS      : "    " for type not allowed
01282                  " +  " for any value of type allowed
01283                  " #  " for some values of type allowed
01284   SIDE EFFECTS : None
01285   NOTES        : Used by DisplaySlotConstraintInfo
01286  ******************************************************/
01287 static char *ConstraintCode(
01288   CONSTRAINT_RECORD *cr,
01289   unsigned allow,
01290   unsigned restrictValues)
01291   {
01292    if (allow || cr->anyAllowed)
01293      {
01294       if (restrictValues || cr->anyRestriction) return " #  ";
01295       else return " +  ";
01296      }
01297    return("    ");
01298   }
01299 
01300 #endif
01301 
01302 #endif
01303