libguile/smob.h

   1 /* classes: h_files */
   2
   3 #ifndef SCM_SMOB_H
   4 #define SCM_SMOB_H
   5
   6 /* Copyright (C) 1995,1996,1998,1999,2000,2001, 2004, 2006, 2009 Free Software Foundation, Inc.
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public License
  10  * as published by the Free Software Foundation; either version 3 of
  11  * the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21  * 02110-1301 USA
  22  */
  23
  24 \f
  25
  26 #include "libguile/__scm.h"
  27 #include "libguile/print.h"
  28
  29 #include "libguile/boehm-gc.h"
  30
  31
  32 \f
  33 /* This is the internal representation of a smob type */
  34
  35 typedef struct scm_smob_descriptor
  36 {
  37   char const *name;
  38   size_t size;
  39   SCM (*mark) (SCM);
  40   size_t (*free) (SCM);
  41   int (*print) (SCM exp, SCM port, scm_print_state *pstate);
  42   SCM (*equalp) (SCM, SCM);
  43   SCM (*apply) ();
  44   SCM (*apply_0) (SCM);
  45   SCM (*apply_1) (SCM, SCM);
  46   SCM (*apply_2) (SCM, SCM, SCM);
  47   SCM (*apply_3) (SCM, SCM, SCM, SCM);
  48   int gsubr_type; /* Used in procprop.c */
  49 } scm_smob_descriptor;
  50
  51
  52 \f
  53 SCM_API SCM scm_i_new_smob_with_mark_proc (scm_t_bits tc,
  54                                            scm_t_bits, scm_t_bits, scm_t_bits);
  55
  56
  57
  58 #define SCM_NEWSMOB(z, tc, data)                                          \
  59 do                                                                        \
  60   {                                                                       \
  61     register scm_t_bits _smobnum = SCM_TC2SMOBNUM (tc);                   \
  62     z = (scm_smobs[_smobnum].mark                                         \
  63          ? scm_i_new_smob_with_mark_proc ((tc), (scm_t_bits)(data),       \
  64                                           0, 0)                           \
  65          : scm_cell (tc, (scm_t_bits)(data)));                            \
  66     if (scm_smobs[_smobnum].free)                                         \
  67       {                                                                   \
  68         GC_finalization_proc _prev_finalizer;                             \
  69         GC_PTR _prev_finalizer_data;                                      \
  70                                                                           \
  71         GC_REGISTER_FINALIZER_NO_ORDER (SCM2PTR (z), scm_i_finalize_smob, \
  72                                         NULL,                             \
  73                                         &_prev_finalizer,                 \
  74                                         &_prev_finalizer_data);           \
  75       }                                                                   \
  76   }                                                                       \
  77 while (0)
  78
  79 #define SCM_RETURN_NEWSMOB(tc, data)                    \
  80   do { SCM __SCM_smob_answer;                           \
  81        SCM_NEWSMOB (__SCM_smob_answer, (tc), (data));   \
  82        return __SCM_smob_answer;                        \
  83   } while (0)
  84
  85 #define SCM_NEWSMOB2(z, tc, data1, data2)       \
  86   SCM_NEWSMOB3 (z, tc, data1, data2, 0)
  87
  88 #define SCM_RETURN_NEWSMOB2(tc, data1, data2)                           \
  89   do { SCM __SCM_smob_answer;                                           \
  90        SCM_NEWSMOB2 (__SCM_smob_answer, (tc), (data1), (data2));        \
  91        return __SCM_smob_answer;                                        \
  92   } while (0)
  93
  94 #define SCM_NEWSMOB3(z, tc, data1, data2, data3)                          \
  95 do                                                                        \
  96   {                                                                       \
  97     register scm_t_bits _smobnum = SCM_TC2SMOBNUM (tc);                   \
  98     z = (scm_smobs[_smobnum].mark                                         \
  99          ? scm_i_new_smob_with_mark_proc (tc, (scm_t_bits)(data1),        \
 100                                           (scm_t_bits)(data2),            \
 101                                           (scm_t_bits)(data3))            \
 102          : scm_double_cell ((tc), (scm_t_bits)(data1),                    \
 103                             (scm_t_bits)(data2),                          \
 104                             (scm_t_bits)(data3)));                        \
 105     if (scm_smobs[_smobnum].free)                                         \
 106       {                                                                   \
 107         GC_finalization_proc _prev_finalizer;                             \
 108         GC_PTR _prev_finalizer_data;                                      \
 109                                                                           \
 110         GC_REGISTER_FINALIZER_NO_ORDER (SCM2PTR (z), scm_i_finalize_smob, \
 111                                         NULL,                             \
 112                                         &_prev_finalizer,                 \
 113                                         &_prev_finalizer_data);           \
 114       }                                                                   \
 115   }                                                                       \
 116 while (0)
 117
 118 #define SCM_RETURN_NEWSMOB3(tc, data1, data2, data3)                        \
 119   do { SCM __SCM_smob_answer;                                               \
 120        SCM_NEWSMOB3 (__SCM_smob_answer, (tc), (data1), (data2), (data3));   \
 121        return __SCM_smob_answer;                                            \
 122   } while (0)
 123
 124
 125 #define SCM_SMOB_FLAGS(x)               (SCM_CELL_WORD_0 (x) >> 16)
 126 #define SCM_SMOB_DATA(x)                (SCM_CELL_WORD_1 (x))
 127 #define SCM_SMOB_DATA_2(x)              (SCM_CELL_WORD_2 (x))
 128 #define SCM_SMOB_DATA_3(x)              (SCM_CELL_WORD_3 (x))
 129 #define SCM_SET_SMOB_DATA(x, data)      (SCM_SET_CELL_WORD_1 ((x), (data)))
 130 #define SCM_SET_SMOB_DATA_2(x, data)    (SCM_SET_CELL_WORD_2 ((x), (data)))
 131 #define SCM_SET_SMOB_DATA_3(x, data)    (SCM_SET_CELL_WORD_3 ((x), (data)))
 132 #define SCM_SET_SMOB_FLAGS(x, data)     (scm_i_set_smob_flags((x),(data)<<16))
 133
 134 #define SCM_SMOB_OBJECT(x)              (SCM_CELL_OBJECT_1 (x))
 135 #define SCM_SMOB_OBJECT_2(x)            (SCM_CELL_OBJECT_2 (x))
 136 #define SCM_SMOB_OBJECT_3(x)            (SCM_CELL_OBJECT_3 (x))
 137 #define SCM_SET_SMOB_OBJECT(x,obj)      (SCM_SET_CELL_OBJECT_1 ((x), (obj)))
 138 #define SCM_SET_SMOB_OBJECT_2(x,obj)    (SCM_SET_CELL_OBJECT_2 ((x), (obj)))
 139 #define SCM_SET_SMOB_OBJECT_3(x,obj)    (SCM_SET_CELL_OBJECT_3 ((x), (obj)))
 140 #define SCM_SMOB_OBJECT_LOC(x)          (SCM_CELL_OBJECT_LOC ((x), 1))
 141 #define SCM_SMOB_OBJECT_2_LOC(x)        (SCM_CELL_OBJECT_LOC ((x), 2))
 142 #define SCM_SMOB_OBJECT_3_LOC(x)        (SCM_CELL_OBJECT_LOC ((x), 3))
 143
 144 #define SCM_TC2SMOBNUM(x)               (0x0ff & ((x) >> 8))
 145 #define SCM_SMOBNUM(x)                  (SCM_TC2SMOBNUM (SCM_CELL_TYPE (x)))
 146 /* SCM_SMOBNAME can be 0 if name is missing */
 147 #define SCM_SMOBNAME(smobnum)           (scm_smobs[smobnum].name)
 148 #define SCM_SMOB_PREDICATE(tag, obj)    SCM_TYP16_PREDICATE (tag, obj)
 149 #define SCM_SMOB_DESCRIPTOR(x)          (scm_smobs[SCM_SMOBNUM (x)])
 150 #define SCM_SMOB_APPLICABLE_P(x)        (SCM_SMOB_DESCRIPTOR (x).apply)
 151 #define SCM_SMOB_APPLY_0(x)             (SCM_SMOB_DESCRIPTOR (x).apply_0 (x))
 152 #define SCM_SMOB_APPLY_1(x, a1)         (SCM_SMOB_DESCRIPTOR (x).apply_1 (x, (a1)))
 153 #define SCM_SMOB_APPLY_2(x, a1, a2)     (SCM_SMOB_DESCRIPTOR (x).apply_2 (x, (a1), (a2)))
 154 #define SCM_SMOB_APPLY_3(x, a1, a2, rst)        (SCM_SMOB_DESCRIPTOR (x).apply_3 (x, (a1), (a2), (rst)))
 155
 156 /* Maximum number of SMOB types.  */
 157 #define SCM_I_MAX_SMOB_TYPE_COUNT  256
 158
 159 SCM_API long scm_numsmob;
 160 SCM_API scm_smob_descriptor scm_smobs[];
 161
 162 SCM_API void scm_i_set_smob_flags (SCM x, scm_t_bits data);
 163 SCM_API void scm_i_finalize_smob (GC_PTR obj, GC_PTR data);
 164
 165 \f
 166
 167 SCM_API SCM scm_mark0 (SCM ptr);
 168 SCM_API SCM scm_markcdr (SCM ptr);
 169 SCM_API size_t scm_free0 (SCM ptr);
 170 SCM_API size_t scm_smob_free (SCM obj);
 171 SCM_API int scm_smob_print (SCM exp, SCM port, scm_print_state *pstate);
 172
 173 /* The following set of functions is the standard way to create new
 174  * SMOB types.
 175  *
 176  * Create a type tag using `scm_make_smob_type', accept default values
 177  * for mark, free, print and/or equalp functions, or set your own
 178  * values using `scm_set_smob_xxx'.
 179  */
 180
 181 SCM_API scm_t_bits scm_make_smob_type (char const *name, size_t size);
 182
 183 SCM_API void scm_set_smob_mark (scm_t_bits tc, SCM (*mark) (SCM));
 184 SCM_API void scm_set_smob_free (scm_t_bits tc, size_t (*free) (SCM));
 185 SCM_API void scm_set_smob_print (scm_t_bits tc,
 186                                  int (*print) (SCM, SCM, scm_print_state*));
 187 SCM_API void scm_set_smob_equalp (scm_t_bits tc, SCM (*equalp) (SCM, SCM));
 188 SCM_API void scm_set_smob_apply (scm_t_bits tc,
 189                                  SCM (*apply) (),
 190                                  unsigned int req,
 191                                  unsigned int opt,
 192                                  unsigned int rst);
 193
 194 SCM_API void scm_assert_smob_type (scm_t_bits tag, SCM val);
 195
 196 /* Function for creating smobs */
 197
 198 SCM_API SCM scm_make_smob (scm_t_bits tc);
 199
 200 SCM_API void scm_smob_prehistory (void);
 201
 202 #endif  /* SCM_SMOB_H */
 203
 204 /*
 205   Local Variables:
 206   c-file-style: "gnu"
 207   End:
 208 */