libguile/objects.h

   1 /* classes: h_files */
   2
   3 #ifndef SCM_OBJECTS_H
   4 #define SCM_OBJECTS_H
   5
   6 /* Copyright (C) 1996,1999,2000,2001 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
  47 \f
  48
  49 /* This file and objects.c contains those minimal pieces of the Guile
  50  * Object Oriented Programming System which need to be included in
  51  * libguile.
  52  *
  53  * {Objects and structs}
  54  *
  55  * Objects are currently based upon structs.  Although the struct
  56  * implementation will change thoroughly in the future, objects will
  57  * still be based upon structs.
  58  */
  59
  60 #include "libguile/__scm.h"
  61 #include "libguile/struct.h"
  62
  63 \f
  64
  65 /* {Class flags}
  66  *
  67  * These are used for efficient identification of instances of a
  68  * certain class or its subclasses when traversal of the inheritance
  69  * graph would be too costly.
  70  */
  71 #define SCM_CLASS_FLAGS(class) (SCM_STRUCT_DATA (class) [scm_struct_i_flags])
  72 #define SCM_OBJ_CLASS_FLAGS(obj) (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 SCM_STRUCTF_MASK
  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_PROCEDURE(obj) (SCM_OBJ_OPERATOR_CLASS (obj)->procedure)
  89 #define SCM_OPERATOR_SETTER(obj) (SCM_OBJ_OPERATOR_CLASS (obj)->setter)
  90
  91 #define SCM_I_ENTITYP(obj)\
  92         ((SCM_OBJ_CLASS_FLAGS (obj) & SCM_CLASSF_ENTITY) != 0)
  93 #define SCM_ENTITY_PROCEDURE(obj) \
  94         (SCM_PACK (SCM_STRUCT_DATA (obj) [scm_struct_i_procedure]))
  95 #define SCM_SET_ENTITY_PROCEDURE(obj,v) \
  96         (SCM_STRUCT_DATA (obj) [scm_struct_i_procedure] = SCM_UNPACK (v))
  97 #define SCM_ENTITY_SETTER(obj) (SCM_PACK (SCM_STRUCT_DATA (obj)[scm_struct_i_setter]))
  98 #define SCM_SET_ENTITY_SETTER(obj, v) \
  99         (SCM_STRUCT_DATA (obj) [scm_struct_i_setter] = SCM_UNPACK (v))
 100
 101 #define SCM_SET_CLASS_DESTRUCTOR(c, d) SCM_SET_VTABLE_DESTRUCTOR (c, d)
 102 #define SCM_SET_CLASS_INSTANCE_SIZE(c, s) \
 103   (SCM_STRUCT_DATA (c)[scm_struct_i_size] \
 104    = (SCM_STRUCT_DATA (c) [scm_struct_i_size] & SCM_STRUCTF_MASK) | s)
 105
 106 /* {Operator classes}
 107  *
 108  * Instances of operator classes can work as operators, i. e., they
 109  * can be applied to arguments just as if they were ordinary
 110  * procedures.
 111  *
 112  * For instances of operator classes, the procedures to be applied are
 113  * stored in four dedicated slots in the associated class object.
 114  * Which one is selected depends on the number of arguments in the
 115  * application.
 116  *
 117  * If zero arguments are passed, the first will be selected.
 118  * If one argument is passed, the second will be selected.
 119  * If two arguments are passed, the third will be selected.
 120  * If three or more arguments are passed, the fourth will be selected.
 121  *
 122  * This is complicated and may seem gratuitous but has to do with the
 123  * architecture of the evaluator.  Using only one procedure would
 124  * result in a great deal less efficient application, loss of
 125  * tail-recursion and would be difficult to reconcile with the
 126  * debugging evaluator.
 127  *
 128  * Also, using this "forked" application in low-level code has the
 129  * advantage of speeding up some code.  An example is method dispatch
 130  * for generic operators applied to few arguments.  On the user level,
 131  * the "forked" application will be hidden by mechanisms in the GOOPS
 132  * package.
 133  *
 134  * Operator classes have the metaclass <operator-metaclass>.
 135  *
 136  * An example of an operator class is the class <tk-command>.
 137  */
 138 #define SCM_METACLASS_STANDARD_LAYOUT ""
 139 struct scm_metaclass_standard {
 140   SCM layout;
 141   SCM vcell;
 142   SCM vtable;
 143   SCM print;
 144 };
 145
 146 #define SCM_METACLASS_OPERATOR_LAYOUT "popo"
 147 struct scm_metaclass_operator {
 148   SCM layout;
 149   SCM vcell;
 150   SCM vtable;
 151   SCM print;
 152   SCM procedure;
 153   SCM setter;
 154 };
 155
 156 /* {Entity classes}
 157  *
 158  * For instances of entity classes (entities), the procedures to be
 159  * applied are stored in the instance itself rather than in the class
 160  * object as is the case for instances of operator classes (see above).
 161  *
 162  * An example of an entity class is the class of generic methods.
 163  */
 164 #define SCM_ENTITY_LAYOUT ""
 165
 166 /* {Interface to Goops}
 167  *
 168  * The evaluator contains a multi-method dispatch mechanism.
 169  * This interface is used by that mechanism and during creation of
 170  * smob and struct classes.
 171  */
 172
 173 /* Internal representation of Goops objects. */
 174 #define SCM_CLASSF_PURE_GENERIC (0x010 << 20)
 175 #define SCM_CLASSF_GOOPS_VALID  (0x080 << 20)
 176 #define SCM_CLASSF_GOOPS        (0x100 << 20)
 177 #define scm_si_redefined         5
 178 #define scm_si_hashsets          6
 179 #define SCM_CLASS_OF(x)         SCM_STRUCT_VTABLE (x)
 180 #define SCM_OBJ_CLASS_REDEF(x)  (SCM_PACK (SCM_STRUCT_VTABLE_DATA (x) [scm_si_redefined]))
 181
 182 typedef struct scm_effective_slot_definition {
 183   SCM name;
 184   long location;
 185   SCM init_value;
 186   SCM (*get) (SCM obj, SCM slotdef);
 187   SCM (*set) (SCM obj, SCM slotdef, SCM value);
 188 } scm_effective_slot_definition;
 189
 190 #define SCM_ESLOTDEF(x) ((scm_effective_slot_definition *) SCM_CDR (x))
 191
 192 #define SCM_CMETHOD_CODE(cmethod) SCM_CDR (cmethod)
 193 #define SCM_CMETHOD_ENV(cmethod)  SCM_CAR (cmethod)
 194
 195 /* Port classes */
 196 #define SCM_IN_PCLASS_INDEX    0x000
 197 #define SCM_OUT_PCLASS_INDEX   0x100
 198 #define SCM_INOUT_PCLASS_INDEX 0x200
 199
 200 /* Plugin proxy classes for basic types. */
 201 extern SCM scm_metaclass_standard;
 202 extern SCM scm_metaclass_operator;
 203 extern SCM scm_class_boolean, scm_class_char, scm_class_pair;
 204 extern SCM scm_class_procedure, scm_class_string, scm_class_symbol;
 205 extern SCM scm_class_procedure_with_setter, scm_class_primitive_generic;
 206 extern SCM scm_class_vector, scm_class_null;
 207 extern SCM scm_class_real, scm_class_complex, scm_class_integer;
 208 extern SCM scm_class_unknown;
 209 extern SCM *scm_port_class;
 210 extern SCM *scm_smob_class;
 211
 212 extern SCM scm_no_applicable_method;
 213
 214 /* Goops functions. */
 215 extern SCM scm_make_extended_class (char *type_name);
 216 extern void scm_make_port_classes (long ptobnum, char *type_name);
 217 extern void scm_change_object_class (SCM, SCM, SCM);
 218 extern SCM scm_memoize_method (SCM x, SCM args);
 219
 220 extern SCM scm_class_of (SCM obj);
 221 extern SCM scm_mcache_lookup_cmethod (SCM cache, SCM args);
 222 extern SCM scm_mcache_compute_cmethod (SCM cache, SCM args);
 223 /* The following are declared in __scm.h
 224 extern SCM scm_call_generic_0 (SCM gf);
 225 extern SCM scm_call_generic_1 (SCM gf, SCM a1);
 226 extern SCM scm_call_generic_2 (SCM gf, SCM a1, SCM a2);
 227 extern SCM scm_apply_generic (SCM gf, SCM args);
 228 */
 229 extern SCM scm_call_generic_3 (SCM gf, SCM a1, SCM a2, SCM a3);
 230 extern SCM scm_entity_p (SCM obj);
 231 extern SCM scm_operator_p (SCM obj);
 232 extern SCM scm_valid_object_procedure_p (SCM proc);
 233 extern SCM scm_set_object_procedure_x (SCM obj, SCM proc);
 234 #ifdef GUILE_DEBUG
 235 extern SCM scm_object_procedure (SCM obj);
 236 #endif
 237 extern SCM scm_make_class_object (SCM metaclass, SCM layout);
 238 extern SCM scm_make_subclass_object (SCM c, SCM layout);
 239
 240 extern SCM scm_i_make_class_object (SCM metaclass, SCM layout_string,
 241                                     unsigned long flags);
 242 extern void scm_init_objects (void);
 243
 244 #endif  /* SCM_OBJECTS_H */
 245
 246 /*
 247   Local Variables:
 248   c-file-style: "gnu"
 249   End:
 250 */