Commit | Line | Data |
---|---|---|
0f2d19dd JB |
1 | /* classes: h_files */ |
2 | ||
22a52da1 DH |
3 | #ifndef SCM_TAGS_H |
4 | #define SCM_TAGS_H | |
8c494e99 | 5 | |
28d52ebb | 6 | /* Copyright (C) 1995,1996,1997,1998,1999,2000,2001, 2002 Free Software Foundation, Inc. |
8ce94504 | 7 | * |
73be1d9e MV |
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. | |
8ce94504 | 12 | * |
73be1d9e | 13 | * This library is distributed in the hope that it will be useful, |
0f2d19dd | 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
73be1d9e MV |
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
16 | * Lesser General Public License for more details. | |
8ce94504 | 17 | * |
73be1d9e MV |
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
21 | */ | |
1bbd0b84 | 22 | |
0f2d19dd JB |
23 | \f |
24 | ||
8ce94504 | 25 | /** This file defines the format of SCM values and cons pairs. |
0f2d19dd JB |
26 | ** It is here that tag bits are assigned for various purposes. |
27 | **/ | |
28 | ||
353d4770 RB |
29 | /* picks up scmconfig.h too */ |
30 | #include "libguile/__scm.h" | |
0f2d19dd JB |
31 | |
32 | /* In the beginning was the Word: | |
33 | */ | |
353d4770 RB |
34 | #if SCM_SIZEOF_INTPTR_T != 0 && defined(INTPTR_MAX) && defined(INTPTR_MIN) |
35 | typedef scm_t_intptr scm_t_signed_bits; | |
004c0902 MV |
36 | #define SCM_T_SIGNED_BITS_MAX INTPTR_MAX |
37 | #define SCM_T_SIGNED_BITS_MIN INTPTR_MIN | |
4a19973d | 38 | #else |
92c2555f | 39 | typedef signed long scm_t_signed_bits; |
004c0902 MV |
40 | #define SCM_T_SIGNED_BITS_MAX LONG_MAX |
41 | #define SCM_T_SIGNED_BITS_MIN LONG_MIN | |
4a19973d | 42 | #endif |
8d3356e7 | 43 | |
353d4770 RB |
44 | #if SCM_SIZEOF_UINTPTR_T != 0 && defined(UINTPTR_MAX) |
45 | typedef uintptr_t scm_t_bits; | |
46 | #define SIZEOF_SCM_T_BITS SCM_SIZEOF_UINTPTR_T | |
47 | #define SCM_T_BITS_MAX UINTPTR_MAX | |
48 | #else | |
49 | typedef unsigned long scm_t_bits; | |
50 | #define SIZEOF_SCM_T_BITS SCM_SIZEOF_UNSIGNED_LONG | |
51 | #define SCM_T_BITS_MAX ULONG_MAX | |
52 | #endif | |
53 | ||
8d3356e7 DH |
54 | /* But as external interface, we use SCM, which may, according to the desired |
55 | * level of type checking, be defined in several ways: | |
56 | */ | |
729dbac3 | 57 | #if (SCM_DEBUG_TYPING_STRICTNESS == 2) |
92c2555f MV |
58 | typedef union { struct { scm_t_bits n; } n; } SCM; |
59 | static SCM scm_pack(scm_t_bits b) { SCM s; s.n.n = b; return s; } | |
076d6063 | 60 | # define SCM_UNPACK(x) ((x).n.n) |
92c2555f | 61 | # define SCM_PACK(x) (scm_pack ((scm_t_bits) (x))) |
729dbac3 | 62 | #elif (SCM_DEBUG_TYPING_STRICTNESS == 1) |
8d3356e7 DH |
63 | /* This is the default, which provides an intermediate level of compile time |
64 | * type checking while still resulting in very efficient code. | |
c209c88e | 65 | */ |
729dbac3 | 66 | typedef struct scm_unused_struct * SCM; |
92c2555f | 67 | # define SCM_UNPACK(x) ((scm_t_bits) (x)) |
076d6063 | 68 | # define SCM_PACK(x) ((SCM) (x)) |
c209c88e | 69 | #else |
8d3356e7 DH |
70 | /* This should be used as a fall back solution for machines on which casting |
71 | * to a pointer may lead to loss of bit information, e. g. in the three least | |
72 | * significant bits. | |
73 | */ | |
92c2555f | 74 | typedef scm_t_bits SCM; |
076d6063 | 75 | # define SCM_UNPACK(x) (x) |
92c2555f | 76 | # define SCM_PACK(x) ((scm_t_bits) (x)) |
c209c88e | 77 | #endif |
0f2d19dd | 78 | |
8d3356e7 DH |
79 | |
80 | /* SCM values can not be compared by using the operator ==. Use the following | |
81 | * macro instead, which is the equivalent of the scheme predicate 'eq?'. | |
82 | */ | |
83 | #define SCM_EQ_P(x, y) (SCM_UNPACK (x) == SCM_UNPACK (y)) | |
84 | ||
0f2d19dd | 85 | \f |
2549a709 | 86 | |
0f2d19dd JB |
87 | /* SCM variables can contain: |
88 | * | |
89 | * Non-objects -- meaning that the tag-related macros don't apply to them | |
90 | * in the usual way. | |
91 | * | |
92 | * Immediates -- meaning that the variable contains an entire Scheme object. | |
93 | * | |
3c205827 JB |
94 | * Non-immediates -- meaning that the variable holds a (possibly |
95 | * tagged) pointer into the cons pair heap. | |
96 | * | |
97 | * Non-objects are distinguished from other values by careful coding | |
98 | * only (i.e., programmers must keep track of any SCM variables they | |
99 | * create that don't contain ordinary scheme values). | |
100 | * | |
904a077d MV |
101 | * All immediates and pointers to cells of non-immediates have a 0 in |
102 | * bit 0. All non-immediates that are not pairs have a 1 in bit 0 of | |
103 | * the first word of their cell. This is how pairs are distinguished | |
104 | * from other non-immediates; a pair can have a immediate in its car | |
105 | * (thus a 0 in bit 0), or a pointer to the cell of a non-immediate | |
106 | * (again, this pointer has a 0 in bit 0). | |
107 | * | |
108 | * Immediates and non-immediates are distinguished by bits 1 and 2. | |
109 | * Immediate values must have a 1 in at least one of those bits. | |
110 | * Consequently, a pointer to a cell of a non-immediate must have | |
111 | * zeros in bits 1 and 2. Together with the requirement from above | |
112 | * that bit 0 must also be zero, this means that pointers to cells of | |
113 | * non-immediates must have their three low bits all zero. This in | |
114 | * turn means that cells must be aligned on a 8 byte boundary, which | |
115 | * is just right for two 32bit numbers (surprise, surprise). Does | |
116 | * this (or any other detail of tagging) seem arbitrary? Try changing | |
117 | * it! (Not always impossible but it is fair to say that many details | |
118 | * of tags are mutually dependent). */ | |
0f2d19dd | 119 | |
f1267706 | 120 | #define SCM_IMP(x) (6 & SCM_UNPACK (x)) |
76189127 | 121 | #define SCM_NIMP(x) (!SCM_IMP (x)) |
0f2d19dd JB |
122 | |
123 | /* Here is a summary of tagging in SCM values as they might occur in | |
8ce94504 | 124 | * SCM variables or in the heap. |
0f2d19dd JB |
125 | * |
126 | * low bits meaning | |
127 | * | |
8ce94504 | 128 | * |
0f2d19dd | 129 | * 0 Most objects except... |
904a077d MV |
130 | * 1 ... structs (this tag is valid only in the header |
131 | * of a struct's data, as with all odd tags). | |
0f2d19dd JB |
132 | * |
133 | * 00 heap addresses and many immediates (not integers) | |
904a077d | 134 | * 01 structs, some tc7_ codes |
0f2d19dd JB |
135 | * 10 immediate integers |
136 | * 11 various tc7_ codes including, tc16_ codes. | |
137 | * | |
138 | * | |
139 | * 000 heap address | |
904a077d | 140 | * 001 structs |
0f2d19dd JB |
141 | * 010 integer |
142 | * 011 closure | |
143 | * 100 immediates | |
144 | * 101 tc7_ | |
145 | * 110 integer | |
146 | * 111 tc7_ | |
147 | * | |
148 | * | |
149 | * 100 --- IMMEDIATES | |
150 | * | |
151 | * Looking at the seven final bits of an immediate: | |
8ce94504 | 152 | * |
0f2d19dd JB |
153 | * 0000-100 short instruction |
154 | * 0001-100 short instruction | |
155 | * 0010-100 short instruction | |
156 | * 0011-100 short instruction | |
157 | * 0100-100 short instruction | |
158 | * 0101-100 short instruction | |
159 | * 0110-100 various immediates and long instructions | |
160 | * 0111-100 short instruction | |
161 | * 1000-100 short instruction | |
162 | * 1001-100 short instruction | |
163 | * 1010-100 short instruction | |
164 | * 1011-100 short instruction | |
165 | * 1100-100 short instruction | |
166 | * 1101-100 short instruction | |
167 | * 1110-100 immediate characters | |
168 | * 1111-100 ilocs | |
169 | * | |
8ce94504 | 170 | * Some of the 0110100 immediates are long instructions (they dispatch |
0f2d19dd JB |
171 | * in two steps compared to one step for a short instruction). |
172 | * The two steps are, (1) dispatch on 7 bits to the long instruction | |
173 | * handler, (2) dispatch on 7 additional bits. | |
174 | * | |
175 | * One way to think of it is that there are 128 short instructions, | |
176 | * with the 13 immediates above being some of the most interesting. | |
177 | * | |
178 | * Also noteworthy are the groups of 16 7-bit instructions implied by | |
904a077d MV |
179 | * some of the 3-bit tags. For example, closure references consist of |
180 | * an 8-byte aligned address tagged with 011. There are 16 identical | |
181 | * 7-bit instructions, all ending 011, which are invoked by evaluating | |
182 | * closures. | |
0f2d19dd JB |
183 | * |
184 | * In other words, if you hand the evaluator a closure, the evaluator | |
904a077d MV |
185 | * treats the closure as a graph of virtual machine instructions. A |
186 | * closure is a pair with a pointer to the body of the procedure in | |
187 | * the CDR and a pointer to the environment of the closure in the CAR. | |
0f2d19dd | 188 | * The environment pointer is tagged 011 which implies that the least |
904a077d MV |
189 | * significant 7 bits of the environment pointer also happen to be a |
190 | * virtual machine instruction we could call "SELF" (for | |
191 | * self-evaluating object). | |
192 | * | |
193 | * A less trivial example are the 16 instructions ending 000. If | |
194 | * those bits tag the CAR of a pair, then evidently the pair is an | |
195 | * ordinary cons pair and should be evaluated as a procedure | |
196 | * application. The sixteen, 7-bit 000 instructions are all | |
197 | * "NORMAL-APPLY" (Things get trickier. For example, if the CAR of a | |
198 | * procedure application is a symbol, the NORMAL-APPLY instruction | |
199 | * will, as a side effect, overwrite that CAR with a new instruction | |
200 | * that contains a cached address for the variable named by the | |
201 | * symbol.) | |
0f2d19dd JB |
202 | * |
203 | * Here is a summary of tags in the CAR of a non-immediate: | |
204 | * | |
33138b05 HWN |
205 | * cons ..........SCM car..............0 ...........SCM cdr.............0 |
206 | * struct ..........void * type........001 ...........void * data.........0 | |
207 | * closure ..........SCM code...........011 ...........SCM env.............0 | |
208 | * tc7 ......24.bits of data...0xxxx1S1 ..........void *data............ | |
0f2d19dd JB |
209 | * |
210 | * | |
211 | * | |
212 | * 101 & 111 --- tc7_ types | |
213 | * | |
8ce94504 JB |
214 | * tc7_tags are 7 bit tags ending in 1x1. These tags |
215 | * occur only in the CAR of heap cells, and have the | |
216 | * handy property that all bits of the CAR above the | |
a002f1a2 | 217 | * bottom eight can be used to store some data, thus |
8ce94504 | 218 | * saving a word in the body itself. Thus, we use them |
28b06554 | 219 | * for strings and vectors (among other things). |
0f2d19dd | 220 | * |
a002f1a2 | 221 | * TYP7(X) returns bits 0...6 of CELL_TYPE (X) |
0f2d19dd | 222 | * |
8ce94504 | 223 | * Sometimes we choose the bottom seven bits carefully, |
c2cb2500 JB |
224 | * so that the 2-valued bit (called S bit) can be masked |
225 | * off to reveal a common type. | |
8ce94504 | 226 | * |
0f2d19dd | 227 | * TYP7S(X) returns TYP7, but masking out the option bit S. |
0f2d19dd | 228 | * |
0f2d19dd JB |
229 | * Some TC7 types are subdivided into 256 subtypes giving |
230 | * rise to the macros: | |
231 | * | |
232 | * TYP16 | |
233 | * TYP16S | |
0f2d19dd JB |
234 | * |
235 | * TYP16S functions similarly wrt to TYP16 as TYP7S to TYP7, | |
236 | * but a different option bit is used (bit 2 for TYP7S, | |
237 | * bit 8 for TYP16S). | |
8ce94504 | 238 | * */ |
0f2d19dd JB |
239 | |
240 | ||
241 | ||
242 | \f | |
243 | /* {Non-immediate values.} | |
244 | * | |
245 | * If X is non-immediate, it is necessary to look at SCM_CAR (X) to | |
c2cb2500 JB |
246 | * figure out Xs type. X may be a cons pair, in which case the value |
247 | * SCM_CAR (x) will be either an immediate or non-immediate value. X | |
248 | * may be something other than a cons pair, in which case the value | |
249 | * SCM_CAR (x) will be a non-object value. | |
250 | * | |
251 | * All immediates and non-immediates have a 0 in bit 0. We | |
252 | * additionally preserve the invariant that all non-object values | |
253 | * stored in the SCM_CAR of a non-immediate object have a 1 in bit 1: | |
0f2d19dd JB |
254 | */ |
255 | ||
22a52da1 | 256 | #define SCM_CONSP(x) (!SCM_IMP (x) && ((1 & SCM_CELL_TYPE (x)) == 0)) |
445f675c | 257 | #define SCM_NCONSP(x) (!SCM_CONSP (x)) |
0f2d19dd | 258 | |
0f2d19dd JB |
259 | \f |
260 | ||
8ce94504 | 261 | /* See numbers.h for macros relating to immediate integers. |
0f2d19dd JB |
262 | */ |
263 | ||
904a077d MV |
264 | #define SCM_ITAG3(x) (7 & SCM_UNPACK (x)) |
265 | #define SCM_TYP3(x) (7 & SCM_CELL_TYPE (x)) | |
266 | #define scm_tc3_cons 0 | |
267 | #define scm_tc3_struct 1 | |
268 | #define scm_tc3_int_1 2 | |
c209c88e GB |
269 | #define scm_tc3_closure 3 |
270 | #define scm_tc3_imm24 4 | |
271 | #define scm_tc3_tc7_1 5 | |
272 | #define scm_tc3_int_2 6 | |
273 | #define scm_tc3_tc7_2 7 | |
0f2d19dd JB |
274 | |
275 | ||
276 | /* | |
277 | * Do not change the three bit tags. | |
278 | */ | |
279 | ||
280 | ||
d1ca2c64 | 281 | #define SCM_ITAG7(x) (127 & SCM_UNPACK (x)) |
445f675c DH |
282 | #define SCM_TYP7(x) (0x7f & SCM_CELL_TYPE (x)) |
283 | #define SCM_TYP7S(x) ((0x7f & ~2) & SCM_CELL_TYPE (x)) | |
0f2d19dd JB |
284 | |
285 | ||
445f675c DH |
286 | #define SCM_TYP16(x) (0xffff & SCM_CELL_TYPE (x)) |
287 | #define SCM_TYP16S(x) (0xfeff & SCM_CELL_TYPE (x)) | |
0f2d19dd | 288 | |
34d19ef6 | 289 | #define SCM_TYP16_PREDICATE(tag, x) (!SCM_IMP (x) && SCM_TYP16 (x) == (tag)) |
e841c3e0 | 290 | |
0f2d19dd JB |
291 | \f |
292 | ||
28b06554 | 293 | #define scm_tc7_symbol 5 |
e5aca4b5 | 294 | #define scm_tc7_variable 7 |
0f2d19dd JB |
295 | |
296 | /* couple */ | |
297 | #define scm_tc7_vector 13 | |
298 | #define scm_tc7_wvect 15 | |
299 | ||
0f2d19dd | 300 | #define scm_tc7_string 21 |
8c494e99 | 301 | /* free 23 */ |
0f2d19dd JB |
302 | |
303 | /* Many of the following should be turned | |
304 | * into structs or smobs. We need back some | |
305 | * of these 7 bit tags! | |
306 | */ | |
37581b11 | 307 | #define scm_tc7_pws 31 |
afe5177e | 308 | |
f546be4d | 309 | #if SCM_HAVE_ARRAYS |
afe5177e GH |
310 | #define scm_tc7_llvect 29 |
311 | #define scm_tc7_uvect 37 | |
1660782e | 312 | /* free 39 */ |
0f2d19dd JB |
313 | #define scm_tc7_fvect 45 |
314 | #define scm_tc7_dvect 47 | |
315 | #define scm_tc7_cvect 53 | |
316 | #define scm_tc7_svect 55 | |
0f2d19dd JB |
317 | #define scm_tc7_bvect 71 |
318 | #define scm_tc7_byvect 77 | |
319 | #define scm_tc7_ivect 79 | |
afe5177e GH |
320 | #endif |
321 | ||
5f144b10 | 322 | /* free 61 */ |
afe5177e GH |
323 | #define scm_tc7_cclo 63 |
324 | #define scm_tc7_rpsubr 69 | |
0f2d19dd JB |
325 | #define scm_tc7_subr_0 85 |
326 | #define scm_tc7_subr_1 87 | |
327 | #define scm_tc7_cxr 93 | |
328 | #define scm_tc7_subr_3 95 | |
329 | #define scm_tc7_subr_2 101 | |
330 | #define scm_tc7_asubr 103 | |
331 | #define scm_tc7_subr_1o 109 | |
332 | #define scm_tc7_subr_2o 111 | |
333 | #define scm_tc7_lsubr_2 117 | |
334 | #define scm_tc7_lsubr 119 | |
335 | ||
336 | ||
a98bddfd | 337 | /* There are 256 port subtypes. |
0f2d19dd JB |
338 | */ |
339 | #define scm_tc7_port 125 | |
340 | ||
0f2d19dd JB |
341 | |
342 | /* There are 256 smob subtypes. Here are the first four. | |
343 | */ | |
344 | ||
345 | #define scm_tc7_smob 127 /* DO NOT CHANGE [**] */ | |
346 | ||
347 | /* [**] If you change scm_tc7_smob, you must also change | |
348 | * the places it is hard coded in this file and possibly others. | |
349 | */ | |
350 | ||
351 | ||
ab256d39 JB |
352 | /* scm_tc_free_cell is also the 0th smob type. We place this |
353 | * in free cells to tell the conservative marker not to trace it. | |
0f2d19dd | 354 | */ |
8c921d5c | 355 | #define scm_tc_free_cell (scm_tc7_smob + 0 * 256L) |
0f2d19dd | 356 | |
8c921d5c | 357 | /* Smob type 1 to 3 (note the dependency on the predicate SCM_NUMP) |
0f2d19dd | 358 | */ |
8c921d5c DH |
359 | #define scm_tc16_big (scm_tc7_smob + 1 * 256L) |
360 | #define scm_tc16_real (scm_tc7_smob + 2 * 256L) | |
361 | #define scm_tc16_complex (scm_tc7_smob + 3 * 256L) | |
0f2d19dd | 362 | |
0f2d19dd | 363 | \f |
8ce94504 | 364 | /* {Immediate Values} |
0f2d19dd JB |
365 | */ |
366 | ||
367 | enum scm_tags | |
368 | { | |
369 | scm_tc8_char = 0xf4, | |
4816f615 | 370 | scm_tc8_iloc = 0xfc |
0f2d19dd JB |
371 | }; |
372 | ||
f1267706 MD |
373 | #define SCM_ITAG8(X) (SCM_UNPACK (X) & 0xff) |
374 | #define SCM_MAKE_ITAG8(X, TAG) SCM_PACK (((X) << 8) + TAG) | |
375 | #define SCM_ITAG8_DATA(X) (SCM_UNPACK (X) >> 8) | |
0f2d19dd JB |
376 | |
377 | ||
378 | \f | |
379 | /* Immediate Symbols, Special Symbols, Flags (various constants). | |
380 | */ | |
381 | ||
382 | /* SCM_ISYMP tests for ISPCSYM and ISYM */ | |
f1267706 | 383 | #define SCM_ISYMP(n) ((0x187 & SCM_UNPACK (n)) == 4) |
0f2d19dd JB |
384 | |
385 | /* SCM_IFLAGP tests for ISPCSYM, ISYM and IFLAG */ | |
f1267706 MD |
386 | #define SCM_IFLAGP(n) ((0x87 & SCM_UNPACK (n)) == 4) |
387 | #define SCM_ISYMNUM(n) (SCM_UNPACK (n) >> 9) | |
76189127 | 388 | #define SCM_ISYMCHARS(n) (scm_isymnames[SCM_ISYMNUM (n)]) |
f1267706 MD |
389 | #define SCM_MAKSPCSYM(n) SCM_PACK (((n) << 9) + ((n) << 3) + 4L) |
390 | #define SCM_MAKISYM(n) SCM_PACK (((n) << 9) + 0x74L) | |
391 | #define SCM_MAKIFLAG(n) SCM_PACK (((n) << 9) + 0x174L) | |
0f2d19dd | 392 | |
33b001fd | 393 | SCM_API char *scm_isymnames[]; /* defined in print.c */ |
29ff38c4 | 394 | |
8ce94504 | 395 | /* This table must agree with the declarations |
0f2d19dd JB |
396 | * in repl.c: {Names of immediate symbols}. |
397 | * | |
398 | * These are used only in eval but their values | |
399 | * have to be allocated here. | |
400 | * | |
401 | */ | |
402 | ||
76189127 MD |
403 | #define SCM_IM_AND SCM_MAKSPCSYM (0) |
404 | #define SCM_IM_BEGIN SCM_MAKSPCSYM (1) | |
405 | #define SCM_IM_CASE SCM_MAKSPCSYM (2) | |
406 | #define SCM_IM_COND SCM_MAKSPCSYM (3) | |
407 | #define SCM_IM_DO SCM_MAKSPCSYM (4) | |
408 | #define SCM_IM_IF SCM_MAKSPCSYM (5) | |
409 | #define SCM_IM_LAMBDA SCM_MAKSPCSYM (6) | |
410 | #define SCM_IM_LET SCM_MAKSPCSYM (7) | |
411 | #define SCM_IM_LETSTAR SCM_MAKSPCSYM (8) | |
412 | #define SCM_IM_LETREC SCM_MAKSPCSYM (9) | |
413 | #define SCM_IM_OR SCM_MAKSPCSYM (10) | |
414 | #define SCM_IM_QUOTE SCM_MAKSPCSYM (11) | |
415 | #define SCM_IM_SET_X SCM_MAKSPCSYM (12) | |
416 | #define SCM_IM_DEFINE SCM_MAKSPCSYM (13) | |
417 | #define SCM_IM_APPLY SCM_MAKISYM (14) | |
418 | #define SCM_IM_CONT SCM_MAKISYM (15) | |
419 | #define SCM_BOOL_F SCM_MAKIFLAG (16) | |
420 | #define SCM_BOOL_T SCM_MAKIFLAG (17) | |
421 | #define SCM_UNDEFINED SCM_MAKIFLAG (18) | |
422 | #define SCM_EOF_VAL SCM_MAKIFLAG (19) | |
423 | #define SCM_EOL SCM_MAKIFLAG (20) | |
424 | #define SCM_UNSPECIFIED SCM_MAKIFLAG (21) | |
425 | #define SCM_IM_DISPATCH SCM_MAKISYM (22) | |
426 | #define SCM_IM_SLOT_REF SCM_MAKISYM (23) | |
427 | #define SCM_IM_SLOT_SET_X SCM_MAKISYM (24) | |
0f2d19dd | 428 | |
159500fb MD |
429 | /* Multi-language support */ |
430 | ||
76189127 | 431 | #define SCM_IM_NIL_COND SCM_MAKISYM (25) |
c96d76b8 | 432 | #define SCM_IM_BIND SCM_MAKISYM (26) |
159500fb | 433 | |
c96d76b8 | 434 | #define SCM_IM_DELAY SCM_MAKISYM (27) |
28d52ebb MD |
435 | #define SCM_IM_FUTURE SCM_MAKISYM (28) |
436 | #define SCM_IM_CALL_WITH_VALUES SCM_MAKISYM (29) | |
0f2d19dd | 437 | |
5623a9b4 MD |
438 | /* When a variable is unbound this is marked by the SCM_UNDEFINED |
439 | * value. The following is an unbound value which can be handled on | |
440 | * the Scheme level, i.e., it can be stored in and retrieved from a | |
441 | * Scheme variable. This value is only intended to mark an unbound | |
442 | * slot in GOOPS. It is needed now, but we should probably rewrite | |
443 | * the code which handles this value in C so that SCM_UNDEFINED can be | |
444 | * used instead. It is not ideal to let this kind of unique and | |
445 | * strange values loose on the Scheme level. | |
446 | */ | |
28d52ebb | 447 | #define SCM_UNBOUND SCM_MAKIFLAG (30) |
5623a9b4 | 448 | |
fbd485ba | 449 | #define SCM_UNBNDP(x) (SCM_EQ_P ((x), SCM_UNDEFINED)) |
0f2d19dd | 450 | |
c96d76b8 | 451 | /* The Elisp nil value. */ |
28d52ebb | 452 | #define SCM_ELISP_NIL SCM_MAKIFLAG (31) |
c96d76b8 | 453 | |
0f2d19dd JB |
454 | \f |
455 | ||
904a077d | 456 | /* Dispatching aids: |
0f2d19dd | 457 | |
904a077d MV |
458 | When switching on SCM_TYP7 of a SCM value, use these fake case |
459 | labels to catch types that use fewer than 7 bits for tagging. */ | |
0f2d19dd | 460 | |
8ce94504 | 461 | /* For cons pairs with immediate values in the CAR |
0f2d19dd JB |
462 | */ |
463 | ||
464 | #define scm_tcs_cons_imcar 2:case 4:case 6:case 10:\ | |
465 | case 12:case 14:case 18:case 20:\ | |
466 | case 22:case 26:case 28:case 30:\ | |
467 | case 34:case 36:case 38:case 42:\ | |
468 | case 44:case 46:case 50:case 52:\ | |
469 | case 54:case 58:case 60:case 62:\ | |
470 | case 66:case 68:case 70:case 74:\ | |
471 | case 76:case 78:case 82:case 84:\ | |
472 | case 86:case 90:case 92:case 94:\ | |
473 | case 98:case 100:case 102:case 106:\ | |
474 | case 108:case 110:case 114:case 116:\ | |
475 | case 118:case 122:case 124:case 126 | |
476 | ||
477 | /* For cons pairs with non-immediate values in the SCM_CAR | |
478 | */ | |
479 | #define scm_tcs_cons_nimcar 0:case 8:case 16:case 24:\ | |
480 | case 32:case 40:case 48:case 56:\ | |
481 | case 64:case 72:case 80:case 88:\ | |
482 | case 96:case 104:case 112:case 120 | |
483 | ||
904a077d | 484 | /* For structs |
0f2d19dd | 485 | */ |
904a077d | 486 | #define scm_tcs_struct 1:case 9:case 17:case 25:\ |
0f2d19dd JB |
487 | case 33:case 41:case 49:case 57:\ |
488 | case 65:case 73:case 81:case 89:\ | |
489 | case 97:case 105:case 113:case 121 | |
490 | ||
904a077d MV |
491 | /* For closures |
492 | */ | |
0f2d19dd JB |
493 | #define scm_tcs_closures 3:case 11:case 19:case 27:\ |
494 | case 35:case 43:case 51:case 59:\ | |
495 | case 67:case 75:case 83:case 91:\ | |
496 | case 99:case 107:case 115:case 123 | |
497 | ||
904a077d MV |
498 | /* For subrs |
499 | */ | |
0f2d19dd JB |
500 | #define scm_tcs_subrs scm_tc7_asubr:case scm_tc7_subr_0:case scm_tc7_subr_1:case scm_tc7_cxr:\ |
501 | case scm_tc7_subr_3:case scm_tc7_subr_2:case scm_tc7_rpsubr:case scm_tc7_subr_1o:\ | |
502 | case scm_tc7_subr_2o:case scm_tc7_lsubr_2:case scm_tc7_lsubr | |
503 | ||
f5f2dcff DH |
504 | \f |
505 | ||
8c494e99 | 506 | #if (SCM_ENABLE_DEPRECATED == 1) |
22a52da1 | 507 | |
228a24ef | 508 | #define SCM_CELLP(x) (((sizeof (scm_t_cell) - 1) & SCM_UNPACK (x)) == 0) |
8c494e99 | 509 | #define SCM_NCELLP(x) (!SCM_CELLP (x)) |
28b06554 | 510 | |
8c494e99 | 511 | #endif |
f5f2dcff | 512 | |
22a52da1 | 513 | #endif /* SCM_TAGS_H */ |
89e00824 ML |
514 | |
515 | /* | |
516 | Local Variables: | |
517 | c-file-style: "gnu" | |
518 | End: | |
519 | */ |