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, 2010 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/bdw-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_trampoline_objcode;
  45 } scm_smob_descriptor;
  46
  47
  48 \f
  49 SCM_API SCM scm_i_new_smob_with_mark_proc (scm_t_bits tc,
  50                                            scm_t_bits, scm_t_bits, scm_t_bits);
  51
  52
  53
  54 #define SCM_NEWSMOB(z, tc, data)                                          \
  55 do                                                                        \
  56   {                                                                       \
  57     register scm_t_bits _smobnum = SCM_TC2SMOBNUM (tc);                   \
  58     z = (scm_smobs[_smobnum].mark                                         \
  59          ? scm_i_new_smob_with_mark_proc ((tc), (scm_t_bits)(data),       \
  60                                           0, 0)                           \
  61          : scm_cell (tc, (scm_t_bits)(data)));                            \
  62     if (scm_smobs[_smobnum].free)                                         \
  63       {                                                                   \
  64         GC_finalization_proc _prev_finalizer;                             \
  65         GC_PTR _prev_finalizer_data;                                      \
  66                                                                           \
  67         GC_REGISTER_FINALIZER_NO_ORDER (SCM2PTR (z), scm_i_finalize_smob, \
  68                                         NULL,                             \
  69                                         &_prev_finalizer,                 \
  70                                         &_prev_finalizer_data);           \
  71       }                                                                   \
  72   }                                                                       \
  73 while (0)
  74
  75 #define SCM_RETURN_NEWSMOB(tc, data)                    \
  76   do { SCM __SCM_smob_answer;                           \
  77        SCM_NEWSMOB (__SCM_smob_answer, (tc), (data));   \
  78        return __SCM_smob_answer;                        \
  79   } while (0)
  80
  81 #define SCM_NEWSMOB2(z, tc, data1, data2)       \
  82   SCM_NEWSMOB3 (z, tc, data1, data2, 0)
  83
  84 #define SCM_RETURN_NEWSMOB2(tc, data1, data2)                           \
  85   do { SCM __SCM_smob_answer;                                           \
  86        SCM_NEWSMOB2 (__SCM_smob_answer, (tc), (data1), (data2));        \
  87        return __SCM_smob_answer;                                        \
  88   } while (0)
  89
  90 #define SCM_NEWSMOB3(z, tc, data1, data2, data3)                          \
  91 do                                                                        \
  92   {                                                                       \
  93     register scm_t_bits _smobnum = SCM_TC2SMOBNUM (tc);                   \
  94     z = (scm_smobs[_smobnum].mark                                         \
  95          ? scm_i_new_smob_with_mark_proc (tc, (scm_t_bits)(data1),        \
  96                                           (scm_t_bits)(data2),            \
  97                                           (scm_t_bits)(data3))            \
  98          : scm_double_cell ((tc), (scm_t_bits)(data1),                    \
  99                             (scm_t_bits)(data2),                          \
 100                             (scm_t_bits)(data3)));                        \
 101     if (scm_smobs[_smobnum].free)                                         \
 102       {                                                                   \
 103         GC_finalization_proc _prev_finalizer;                             \
 104         GC_PTR _prev_finalizer_data;                                      \
 105                                                                           \
 106         GC_REGISTER_FINALIZER_NO_ORDER (SCM2PTR (z), scm_i_finalize_smob, \
 107                                         NULL,                             \
 108                                         &_prev_finalizer,                 \
 109                                         &_prev_finalizer_data);           \
 110       }                                                                   \
 111   }                                                                       \
 112 while (0)
 113
 114 #define SCM_RETURN_NEWSMOB3(tc, data1, data2, data3)                        \
 115   do { SCM __SCM_smob_answer;                                               \
 116        SCM_NEWSMOB3 (__SCM_smob_answer, (tc), (data1), (data2), (data3));   \
 117        return __SCM_smob_answer;                                            \
 118   } while (0)
 119
 120
 121 #define SCM_SMOB_DATA_N(x, n)           (SCM_CELL_WORD ((x), (n)))
 122 #define SCM_SET_SMOB_DATA_N(x, n, data) (SCM_SET_CELL_WORD ((x), (n), (data)))
 123
 124 #define SCM_SMOB_DATA_0(x)              (SCM_SMOB_DATA_N ((x), 0))
 125 #define SCM_SMOB_DATA_1(x)              (SCM_SMOB_DATA_N ((x), 1))
 126 #define SCM_SMOB_DATA_2(x)              (SCM_SMOB_DATA_N ((x), 2))
 127 #define SCM_SMOB_DATA_3(x)              (SCM_SMOB_DATA_N ((x), 3))
 128 #define SCM_SET_SMOB_DATA_0(x, data)    (SCM_SET_SMOB_DATA_N ((x), 0, (data)))
 129 #define SCM_SET_SMOB_DATA_1(x, data)    (SCM_SET_SMOB_DATA_N ((x), 1, (data)))
 130 #define SCM_SET_SMOB_DATA_2(x, data)    (SCM_SET_SMOB_DATA_N ((x), 2, (data)))
 131 #define SCM_SET_SMOB_DATA_3(x, data)    (SCM_SET_SMOB_DATA_N ((x), 3, (data)))
 132
 133 #define SCM_SMOB_FLAGS(x)               (SCM_SMOB_DATA_0 (x) >> 16)
 134 #define SCM_SMOB_DATA(x)                (SCM_SMOB_DATA_1 (x))
 135 #define SCM_SET_SMOB_FLAGS(x, data)     (SCM_SET_SMOB_DATA_0 ((x), (SCM_CELL_TYPE (x)&0xffff)|((data)<<16)))
 136 #define SCM_SET_SMOB_DATA(x, data)      (SCM_SET_SMOB_DATA_1 ((x), (data)))
 137
 138 #define SCM_SMOB_OBJECT_N(x,n)          (SCM_CELL_OBJECT ((x), (n)))
 139 #define SCM_SET_SMOB_OBJECT_N(x,n,obj)  (SCM_SET_CELL_OBJECT ((x), (n), (obj)))
 140 #define SCM_SMOB_OBJECT_N_LOC(x,n)      (SCM_CELL_OBJECT_LOC ((x), (n)))
 141
 142 /*#define SCM_SMOB_OBJECT_0(x)          (SCM_SMOB_OBJECT_N ((x), 0))*/
 143 #define SCM_SMOB_OBJECT_1(x)            (SCM_SMOB_OBJECT_N ((x), 1))
 144 #define SCM_SMOB_OBJECT_2(x)            (SCM_SMOB_OBJECT_N ((x), 2))
 145 #define SCM_SMOB_OBJECT_3(x)            (SCM_SMOB_OBJECT_N ((x), 3))
 146 /*#define SCM_SET_SMOB_OBJECT_0(x,obj)  (SCM_SET_SMOB_OBJECT_N ((x), 0, (obj)))*/
 147 #define SCM_SET_SMOB_OBJECT_1(x,obj)    (SCM_SET_SMOB_OBJECT_N ((x), 1, (obj)))
 148 #define SCM_SET_SMOB_OBJECT_2(x,obj)    (SCM_SET_SMOB_OBJECT_N ((x), 2, (obj)))
 149 #define SCM_SET_SMOB_OBJECT_3(x,obj)    (SCM_SET_SMOB_OBJECT_N ((x), 3, (obj)))
 150 #define SCM_SMOB_OBJECT_0_LOC(x)        (SCM_SMOB_OBJECT_N_LOC ((x), 0)))
 151 #define SCM_SMOB_OBJECT_1_LOC(x)        (SCM_SMOB_OBJECT_N_LOC ((x), 1)))
 152 #define SCM_SMOB_OBJECT_2_LOC(x)        (SCM_SMOB_OBJECT_N_LOC ((x), 2)))
 153 #define SCM_SMOB_OBJECT_3_LOC(x)        (SCM_SMOB_OBJECT_N_LOC ((x), 3)))
 154
 155 #define SCM_SMOB_OBJECT(x)              (SCM_SMOB_OBJECT_1 (x))
 156 #define SCM_SET_SMOB_OBJECT(x,obj)      (SCM_SET_SMOB_OBJECT_1 ((x), (obj)))
 157 #define SCM_SMOB_OBJECT_LOC(x)          (SCM_SMOB_OBJECT_1_LOC (x)))
 158
 159
 160 #define SCM_SMOB_TYPE_MASK              0xffff
 161 #define SCM_SMOB_TYPE_BITS(tc)          (tc)
 162 #define SCM_TC2SMOBNUM(x)               (0x0ff & ((x) >> 8))
 163 #define SCM_SMOBNUM(x)                  (SCM_TC2SMOBNUM (SCM_CELL_TYPE (x)))
 164 /* SCM_SMOBNAME can be 0 if name is missing */
 165 #define SCM_SMOBNAME(smobnum)           (scm_smobs[smobnum].name)
 166 #define SCM_SMOB_PREDICATE(tag, obj)    SCM_TYP16_PREDICATE (tag, obj)
 167 #define SCM_SMOB_DESCRIPTOR(x)          (scm_smobs[SCM_SMOBNUM (x)])
 168 #define SCM_SMOB_APPLICABLE_P(x)        (SCM_SMOB_DESCRIPTOR (x).apply)
 169 #define SCM_SMOB_APPLY_0(x)             (scm_call_0 (x))
 170 #define SCM_SMOB_APPLY_1(x, a1)         (scm_call_1 (x, a1))
 171 #define SCM_SMOB_APPLY_2(x, a1, a2)     (scm_call_2 (x, a1, a2))
 172 #define SCM_SMOB_APPLY_3(x, a1, a2, rst) (scm_call_3 (x, a1, a2, a3))
 173
 174 /* Maximum number of SMOB types.  */
 175 #define SCM_I_MAX_SMOB_TYPE_COUNT  256
 176
 177 SCM_API long scm_numsmob;
 178 SCM_API scm_smob_descriptor scm_smobs[];
 179
 180 SCM_API void scm_i_finalize_smob (GC_PTR obj, GC_PTR data);
 181
 182 \f
 183
 184 SCM_API SCM scm_mark0 (SCM ptr);
 185 SCM_API SCM scm_markcdr (SCM ptr);
 186 SCM_API size_t scm_free0 (SCM ptr);
 187 SCM_API int scm_smob_print (SCM exp, SCM port, scm_print_state *pstate);
 188
 189 /* The following set of functions is the standard way to create new
 190  * SMOB types.
 191  *
 192  * Create a type tag using `scm_make_smob_type', accept default values
 193  * for mark, free, print and/or equalp functions, or set your own
 194  * values using `scm_set_smob_xxx'.
 195  */
 196
 197 SCM_API scm_t_bits scm_make_smob_type (char const *name, size_t size);
 198
 199 SCM_API void scm_set_smob_mark (scm_t_bits tc, SCM (*mark) (SCM));
 200 SCM_API void scm_set_smob_free (scm_t_bits tc, size_t (*free) (SCM));
 201 SCM_API void scm_set_smob_print (scm_t_bits tc,
 202                                  int (*print) (SCM, SCM, scm_print_state*));
 203 SCM_API void scm_set_smob_equalp (scm_t_bits tc, SCM (*equalp) (SCM, SCM));
 204 SCM_API void scm_set_smob_apply (scm_t_bits tc,
 205                                  SCM (*apply) (),
 206                                  unsigned int req,
 207                                  unsigned int opt,
 208                                  unsigned int rst);
 209
 210 SCM_API void scm_assert_smob_type (scm_t_bits tag, SCM val);
 211
 212 /* Function for creating smobs */
 213
 214 SCM_API SCM scm_make_smob (scm_t_bits tc);
 215
 216 SCM_INTERNAL SCM scm_i_smob_apply_trampoline (SCM smob);
 217
 218 SCM_API void scm_smob_prehistory (void);
 219
 220 #endif  /* SCM_SMOB_H */
 221
 222 /*
 223   Local Variables:
 224   c-file-style: "gnu"
 225   End:
 226 */