libguile/objects.h

   1 /* classes: h_files */
   2
   3 #ifndef OBJECTSH
   4 #define OBJECTSH
   5
   6 /*      Copyright (C) 1996 Free Software Foundation, Inc.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2, or (at your option)
  11  * any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this software; see the file COPYING.  If not, write to
  20  * the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  21  * Boston, MA 02111-1307 USA
  22  *
  23  * As a special exception, the Free Software Foundation gives permission
  24  * for additional uses of the text contained in its release of GUILE.
  25  *
  26  * The exception is that, if you link the GUILE library with other files
  27  * to produce an executable, this does not by itself cause the
  28  * resulting executable to be covered by the GNU General Public License.
  29  * Your use of that executable is in no way restricted on account of
  30  * linking the GUILE library code into it.
  31  *
  32  * This exception does not however invalidate any other reasons why
  33  * the executable file might be covered by the GNU General Public License.
  34  *
  35  * This exception applies only to the code released by the
  36  * Free Software Foundation under the name GUILE.  If you copy
  37  * code from other Free Software Foundation releases into a copy of
  38  * GUILE, as the General Public License permits, the exception does
  39  * not apply to the code that you add in this way.  To avoid misleading
  40  * anyone as to the status of such modified files, you must delete
  41  * this exception notice from them.
  42  *
  43  * If you write modifications of your own for GUILE, it is your choice
  44  * whether to permit this exception to apply to your modifications.
  45  * If you do not wish that, delete this exception notice.  */
  46 \f
  47
  48 /* This file and objects.c contains those minimal pieces of the Guile
  49  * Object Oriented Programming System which need to be included in
  50  * libguile.
  51  *
  52  * {Objects and structs}
  53  *
  54  * Objects are currently based upon structs.  Although the struct
  55  * implementation will change thoroughly in the future, objects will
  56  * still be based upon structs.
  57  */
  58
  59 #include "libguile/__scm.h"
  60 #include "libguile/struct.h"
  61
  62 \f
  63
  64 /* {Class flags}
  65  *
  66  * These are used for efficient identification of instances of a
  67  * certain class or its subclasses when traversal of the inheritance
  68  * graph would be too costly.
  69  */
  70 #define SCM_CLASS_FLAGS(class) (SCM_STRUCT_DATA (class)[scm_struct_i_flags])
  71 #define SCM_OBJ_CLASS_FLAGS(obj)\
  72 (SCM_STRUCT_VTABLE_DATA (obj)[scm_struct_i_flags])
  73 #define SCM_SET_CLASS_FLAGS(c, f) (SCM_CLASS_FLAGS (c) |= (f))
  74 #define SCM_CLEAR_CLASS_FLAGS(c, f) (SCM_CLASS_FLAGS (c) &= ~(f))
  75 #define SCM_CLASSF_MASK (0xFF << 24)
  76
  77 #define SCM_CLASSF_ENTITY       SCM_STRUCTF_ENTITY
  78 /* Operator classes need to be identified in the evaluator.
  79    (Entities also have SCM_CLASSF_OPERATOR set in their vtable.) */
  80 #define SCM_CLASSF_OPERATOR     (1L << 29)
  81
  82 #define SCM_I_OPERATORP(obj)\
  83 ((SCM_OBJ_CLASS_FLAGS (obj) & SCM_CLASSF_OPERATOR) != 0)
  84 #define SCM_OPERATOR_CLASS(obj)\
  85 ((struct scm_metaclass_operator *) SCM_STRUCT_DATA (obj))
  86 #define SCM_OBJ_OPERATOR_CLASS(obj)\
  87 ((struct scm_metaclass_operator *) SCM_STRUCT_VTABLE_DATA (obj))
  88 #define SCM_OPERATOR_PROC_0(obj) (SCM_OBJ_OPERATOR_CLASS (obj)->proc0)
  89 #define SCM_OPERATOR_PROC_1(obj) (SCM_OBJ_OPERATOR_CLASS (obj)->proc1)
  90 #define SCM_OPERATOR_PROC_2(obj) (SCM_OBJ_OPERATOR_CLASS (obj)->proc2)
  91 #define SCM_OPERATOR_PROC_3(obj) (SCM_OBJ_OPERATOR_CLASS (obj)->proc3)
  92
  93 #define SCM_I_ENTITYP(obj)\
  94 ((SCM_OBJ_CLASS_FLAGS (obj) & SCM_CLASSF_ENTITY) != 0)
  95 #define SCM_ENTITY_PROC_0(obj) (SCM_STRUCT_DATA (obj)[scm_struct_i_proc + 0])
  96 #define SCM_ENTITY_PROC_1(obj) (SCM_STRUCT_DATA (obj)[scm_struct_i_proc + 1])
  97 #define SCM_ENTITY_PROC_2(obj) (SCM_STRUCT_DATA (obj)[scm_struct_i_proc + 2])
  98 #define SCM_ENTITY_PROC_3(obj) (SCM_STRUCT_DATA (obj)[scm_struct_i_proc + 3])
  99
 100 /* {Operator classes}
 101  *
 102  * Instances of operator classes can work as operators, i. e., they
 103  * can be applied to arguments just as if they were ordinary
 104  * procedures.
 105  *
 106  * For instances of operator classes, the procedures to be applied are
 107  * stored in four dedicated slots in the associated class object.
 108  * Which one is selected depends on the number of arguments in the
 109  * application.
 110  *
 111  * If zero arguments are passed, the first will be selected.
 112  * If one argument is passed, the second will be selected.
 113  * If two arguments are passed, the third will be selected.
 114  * If three or more arguments are passed, the fourth will be selected.
 115  *
 116  * This is complicated and may seem gratuitous but has to do with the
 117  * architecture of the evaluator.  Using only one procedure would
 118  * result in a great deal less efficient application, loss of
 119  * tail-recursion and would be difficult to reconcile with the
 120  * debugging evaluator.
 121  *
 122  * Also, using this "forked" application in low-level code has the
 123  * advantage of speeding up some code.  An example is method dispatch
 124  * for generic operators applied to few arguments.  On the user level,
 125  * the "forked" application will be hidden by mechanisms in the GOOPS
 126  * package.
 127  *
 128  * Operator classes have the metaclass <operator-metaclass>.
 129  *
 130  * An example of an operator class is the class <tk-command>.
 131  */
 132 #define SCM_METACLASS_STANDARD_LAYOUT ""
 133 struct scm_metaclass_standard {
 134   SCM layout;
 135   SCM vcell;
 136   SCM vtable;
 137   SCM print;
 138 };
 139
 140 #define SCM_METACLASS_OPERATOR_LAYOUT "popopopo"
 141 struct scm_metaclass_operator {
 142   SCM layout;
 143   SCM vcell;
 144   SCM vtable;
 145   SCM print;
 146   SCM proc0;
 147   SCM proc1;
 148   SCM proc2;
 149   SCM proc3;
 150 };
 151
 152 /* {Entity classes}
 153  *
 154  * For instances of entity classes (entities), the procedures to be
 155  * applied are stored in the instance itself rather than in the class
 156  * object as is the case for instances of operator classes (see above).
 157  *
 158  * An example of an entity class is the class of generic methods.
 159  */
 160 #define SCM_ENTITY_LAYOUT ""
 161
 162 extern SCM scm_metaclass_standard;
 163 extern SCM scm_metaclass_operator;
 164
 165 extern SCM scm_entity_p (SCM obj);
 166 extern SCM scm_set_object_procedure_x (SCM obj, SCM procs);
 167 extern SCM scm_make_class_object (SCM metaclass, SCM layout);
 168 extern SCM scm_make_subclass_object (SCM class, SCM layout);
 169
 170 extern SCM scm_i_make_class_object (SCM metaclass, SCM layout_string,
 171                                     unsigned long flags);
 172 extern void scm_init_objects SCM_P ((void));
 173
 174 #endif /* OBJECTSH */