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 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
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library 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 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 02110-1301 USA
  21  */
  22
  23 \f
  24
  25 #include "libguile/__scm.h"
  26 #include "libguile/print.h"
  27
  28 \f
  29 /* This is the internal representation of a smob type */
  30
  31 typedef struct scm_smob_descriptor
  32 {
  33   char const *name;
  34   size_t size;
  35   SCM (*mark) (SCM);
  36   size_t (*free) (SCM);
  37   int (*print) (SCM exp, SCM port, scm_print_state *pstate);
  38   SCM (*equalp) (SCM, SCM);
  39   SCM (*apply) ();
  40   SCM (*apply_0) (SCM);
  41   SCM (*apply_1) (SCM, SCM);
  42   SCM (*apply_2) (SCM, SCM, SCM);
  43   SCM (*apply_3) (SCM, SCM, SCM, SCM);
  44   int gsubr_type; /* Used in procprop.c */
  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       scm_gc_register_finalizer ((z), scm_i_finalize_smob,              \
  64                                  SCM_BOOL_F, 0);                        \
  65   }                                                                     \
  66 while (0)
  67
  68 #define SCM_RETURN_NEWSMOB(tc, data)                    \
  69   do { SCM __SCM_smob_answer;                           \
  70        SCM_NEWSMOB (__SCM_smob_answer, (tc), (data));   \
  71        return __SCM_smob_answer;                        \
  72   } while (0)
  73
  74 #define SCM_NEWSMOB2(z, tc, data1, data2)       \
  75   SCM_NEWSMOB3 (z, tc, data1, data2, 0)
  76
  77 #define SCM_RETURN_NEWSMOB2(tc, data1, data2)                           \
  78   do { SCM __SCM_smob_answer;                                           \
  79        SCM_NEWSMOB2 (__SCM_smob_answer, (tc), (data1), (data2));        \
  80        return __SCM_smob_answer;                                        \
  81   } while (0)
  82
  83 #define SCM_NEWSMOB3(z, tc, data1, data2, data3)                        \
  84 do                                                                      \
  85   {                                                                     \
  86     register scm_t_bits _smobnum = SCM_TC2SMOBNUM (tc);                 \
  87     z = (scm_smobs[_smobnum].mark                                       \
  88          ? scm_i_new_smob_with_mark_proc (tc, (scm_t_bits)(data1),      \
  89                                           (scm_t_bits)(data2),          \
  90                                           (scm_t_bits)(data3))          \
  91          : scm_double_cell ((tc), (scm_t_bits)(data1),                  \
  92                             (scm_t_bits)(data2),                        \
  93                             (scm_t_bits)(data3)));                      \
  94     if (scm_smobs[_smobnum].free)                                       \
  95       scm_gc_register_finalizer ((z), scm_i_finalize_smob,              \
  96                                  SCM_BOOL_F, 0);                        \
  97   }                                                                     \
  98 while (0)
  99
 100 #define SCM_RETURN_NEWSMOB3(tc, data1, data2, data3)                        \
 101   do { SCM __SCM_smob_answer;                                               \
 102        SCM_NEWSMOB3 (__SCM_smob_answer, (tc), (data1), (data2), (data3));   \
 103        return __SCM_smob_answer;                                            \
 104   } while (0)
 105
 106
 107 #define SCM_SMOB_FLAGS(x)               (SCM_CELL_WORD_0 (x) >> 16)
 108 #define SCM_SMOB_DATA(x)                (SCM_CELL_WORD_1 (x))
 109 #define SCM_SMOB_DATA_2(x)              (SCM_CELL_WORD_2 (x))
 110 #define SCM_SMOB_DATA_3(x)              (SCM_CELL_WORD_3 (x))
 111 #define SCM_SET_SMOB_DATA(x, data)      (SCM_SET_CELL_WORD_1 ((x), (data)))
 112 #define SCM_SET_SMOB_DATA_2(x, data)    (SCM_SET_CELL_WORD_2 ((x), (data)))
 113 #define SCM_SET_SMOB_DATA_3(x, data)    (SCM_SET_CELL_WORD_3 ((x), (data)))
 114 #define SCM_SET_SMOB_FLAGS(x, data)     (scm_i_set_smob_flags((x),(data)<<16))
 115
 116 #define SCM_SMOB_OBJECT(x)              (SCM_CELL_OBJECT_1 (x))
 117 #define SCM_SMOB_OBJECT_2(x)            (SCM_CELL_OBJECT_2 (x))
 118 #define SCM_SMOB_OBJECT_3(x)            (SCM_CELL_OBJECT_3 (x))
 119 #define SCM_SET_SMOB_OBJECT(x,obj)      (SCM_SET_CELL_OBJECT_1 ((x), (obj)))
 120 #define SCM_SET_SMOB_OBJECT_2(x,obj)    (SCM_SET_CELL_OBJECT_2 ((x), (obj)))
 121 #define SCM_SET_SMOB_OBJECT_3(x,obj)    (SCM_SET_CELL_OBJECT_3 ((x), (obj)))
 122 #define SCM_SMOB_OBJECT_LOC(x)          (SCM_CELL_OBJECT_LOC ((x), 1))
 123 #define SCM_SMOB_OBJECT_2_LOC(x)        (SCM_CELL_OBJECT_LOC ((x), 2))
 124 #define SCM_SMOB_OBJECT_3_LOC(x)        (SCM_CELL_OBJECT_LOC ((x), 3))
 125
 126 #define SCM_TC2SMOBNUM(x)               (0x0ff & ((x) >> 8))
 127 #define SCM_SMOBNUM(x)                  (SCM_TC2SMOBNUM (SCM_CELL_TYPE (x)))
 128 /* SCM_SMOBNAME can be 0 if name is missing */
 129 #define SCM_SMOBNAME(smobnum)           (scm_smobs[smobnum].name)
 130 #define SCM_SMOB_PREDICATE(tag, obj)    SCM_TYP16_PREDICATE (tag, obj)
 131 #define SCM_SMOB_DESCRIPTOR(x)          (scm_smobs[SCM_SMOBNUM (x)])
 132 #define SCM_SMOB_APPLICABLE_P(x)        (SCM_SMOB_DESCRIPTOR (x).apply)
 133 #define SCM_SMOB_APPLY_0(x)             (SCM_SMOB_DESCRIPTOR (x).apply_0 (x))
 134 #define SCM_SMOB_APPLY_1(x, a1)         (SCM_SMOB_DESCRIPTOR (x).apply_1 (x, (a1)))
 135 #define SCM_SMOB_APPLY_2(x, a1, a2)     (SCM_SMOB_DESCRIPTOR (x).apply_2 (x, (a1), (a2)))
 136 #define SCM_SMOB_APPLY_3(x, a1, a2, rst)        (SCM_SMOB_DESCRIPTOR (x).apply_3 (x, (a1), (a2), (rst)))
 137
 138 SCM_API long scm_numsmob;
 139 SCM_API scm_smob_descriptor scm_smobs[];
 140
 141 SCM_API void scm_i_set_smob_flags (SCM x, scm_t_bits data);
 142 SCM_API SCM scm_i_finalize_smob (SCM smob, SCM data);
 143
 144 \f
 145
 146 SCM_API SCM scm_mark0 (SCM ptr);
 147 SCM_API SCM scm_markcdr (SCM ptr);
 148 SCM_API size_t scm_free0 (SCM ptr);
 149 SCM_API size_t scm_smob_free (SCM obj);
 150 SCM_API int scm_smob_print (SCM exp, SCM port, scm_print_state *pstate);
 151
 152 /* The following set of functions is the standard way to create new
 153  * SMOB types.
 154  *
 155  * Create a type tag using `scm_make_smob_type', accept default values
 156  * for mark, free, print and/or equalp functions, or set your own
 157  * values using `scm_set_smob_xxx'.
 158  */
 159
 160 SCM_API scm_t_bits scm_make_smob_type (char const *name, size_t size);
 161
 162 SCM_API void scm_set_smob_mark (scm_t_bits tc, SCM (*mark) (SCM));
 163 SCM_API void scm_set_smob_free (scm_t_bits tc, size_t (*free) (SCM));
 164 SCM_API void scm_set_smob_print (scm_t_bits tc,
 165                                  int (*print) (SCM, SCM, scm_print_state*));
 166 SCM_API void scm_set_smob_equalp (scm_t_bits tc, SCM (*equalp) (SCM, SCM));
 167 SCM_API void scm_set_smob_apply (scm_t_bits tc,
 168                                  SCM (*apply) (),
 169                                  unsigned int req,
 170                                  unsigned int opt,
 171                                  unsigned int rst);
 172
 173 SCM_API void scm_assert_smob_type (scm_t_bits tag, SCM val);
 174
 175 /* Function for creating smobs */
 176
 177 SCM_API SCM scm_make_smob (scm_t_bits tc);
 178
 179 SCM_API void scm_smob_prehistory (void);
 180
 181 #endif  /* SCM_SMOB_H */
 182
 183 /*
 184   Local Variables:
 185   c-file-style: "gnu"
 186   End:
 187 */