Commit | Line | Data |
---|---|---|
0f2d19dd JB |
1 | /* classes: h_files */ |
2 | ||
22a52da1 DH |
3 | #ifndef SCM_TAGS_H |
4 | #define SCM_TAGS_H | |
8c494e99 | 5 | |
e2fafeb9 | 6 | /* Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004,2008,2009,2010,2011,2012,2013,2014,2015 |
5065b40d | 7 | * Free Software Foundation, Inc. |
8ce94504 | 8 | * |
73be1d9e | 9 | * This library is free software; you can redistribute it and/or |
53befeb7 NJ |
10 | * modify it under the terms of the GNU Lesser General Public License |
11 | * as published by the Free Software Foundation; either version 3 of | |
12 | * the License, or (at your option) any later version. | |
8ce94504 | 13 | * |
53befeb7 NJ |
14 | * This library is distributed in the hope that it will be useful, but |
15 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
73be1d9e MV |
16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
17 | * Lesser General Public License for more details. | |
8ce94504 | 18 | * |
73be1d9e MV |
19 | * You should have received a copy of the GNU Lesser General Public |
20 | * License along with this library; if not, write to the Free Software | |
53befeb7 NJ |
21 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA |
22 | * 02110-1301 USA | |
73be1d9e | 23 | */ |
1bbd0b84 | 24 | |
0f2d19dd JB |
25 | \f |
26 | ||
8ce94504 | 27 | /** This file defines the format of SCM values and cons pairs. |
0f2d19dd JB |
28 | ** It is here that tag bits are assigned for various purposes. |
29 | **/ | |
30 | ||
353d4770 RB |
31 | /* picks up scmconfig.h too */ |
32 | #include "libguile/__scm.h" | |
0f2d19dd | 33 | |
7e3b25bf DH |
34 | \f |
35 | ||
0f2d19dd | 36 | /* In the beginning was the Word: |
7e3b25bf DH |
37 | * |
38 | * For the representation of scheme objects and their handling, Guile provides | |
39 | * two types: scm_t_bits and SCM. | |
40 | * | |
41 | * - scm_t_bits values can hold bit patterns of non-objects and objects: | |
42 | * | |
43 | * Non-objects -- in this case the value may not be changed into a SCM value | |
44 | * in any way. | |
45 | * | |
46 | * Objects -- in this case the value may be changed into a SCM value using | |
47 | * the SCM_PACK macro. | |
48 | * | |
49 | * - SCM values can hold proper scheme objects only. They can be changed into | |
50 | * a scm_t_bits value using the SCM_UNPACK macro. | |
51 | * | |
52 | * When working in the domain of scm_t_bits values, programmers must keep | |
53 | * track of any scm_t_bits value they create that is not a proper scheme | |
54 | * object. This makes sure that in the domain of SCM values developers can | |
55 | * rely on the fact that they are dealing with proper scheme objects only. | |
56 | * Thus, the distinction between scm_t_bits and SCM values helps to identify | |
57 | * those parts of the code where special care has to be taken not to create | |
58 | * bad SCM values. | |
59 | */ | |
60 | ||
61 | /* For dealing with the bit level representation of scheme objects we define | |
62 | * scm_t_bits: | |
0f2d19dd | 63 | */ |
75917d62 | 64 | |
114bc68a LC |
65 | typedef scm_t_intptr scm_t_signed_bits; |
66 | typedef scm_t_uintptr scm_t_bits; | |
23c96d9b | 67 | |
114bc68a LC |
68 | #define SCM_T_SIGNED_BITS_MAX SCM_T_INTPTR_MAX |
69 | #define SCM_T_SIGNED_BITS_MIN SCM_T_INTPTR_MIN | |
70 | #define SCM_T_BITS_MAX SCM_T_UINTPTR_MAX | |
23c96d9b | 71 | |
353d4770 | 72 | |
75917d62 AW |
73 | /* But as external interface, we define SCM, which may, according to the |
74 | * desired level of type checking, be defined in several ways: | |
75 | */ | |
76 | #if (SCM_DEBUG_TYPING_STRICTNESS == 2) | |
25f4a880 AW |
77 | typedef union SCM { struct { scm_t_bits n; } n; } SCM; |
78 | # define SCM_UNPACK(x) ((x).n.n) | |
79 | # define SCM_PACK(x) ((SCM) { { (scm_t_bits) (x) } }) | |
75917d62 AW |
80 | #elif (SCM_DEBUG_TYPING_STRICTNESS == 1) |
81 | /* This is the default, which provides an intermediate level of compile time | |
82 | * type checking while still resulting in very efficient code. | |
c209c88e | 83 | */ |
75917d62 AW |
84 | typedef struct scm_unused_struct { char scm_unused_field; } *SCM; |
85 | ||
86 | /* | |
87 | The 0?: constructions makes sure that the code is never executed, | |
88 | and that there is no performance hit. However, the alternative is | |
89 | compiled, and does generate a warning when used with the wrong | |
824b9ad8 MW |
90 | pointer type. We use a volatile pointer type to avoid warnings |
91 | from clang. | |
75917d62 AW |
92 | |
93 | The Tru64 and ia64-hp-hpux11.23 compilers fail on `case (0?0=0:x)' | |
94 | statements, so for them type-checking is disabled. */ | |
95 | #if defined __DECC || defined __HP_cc | |
96 | # define SCM_UNPACK(x) ((scm_t_bits) (x)) | |
97 | #else | |
824b9ad8 | 98 | # define SCM_UNPACK(x) ((scm_t_bits) (0? (*(volatile SCM *)0=(x)): x)) |
75917d62 AW |
99 | #endif |
100 | ||
101 | /* | |
102 | There is no typechecking on SCM_PACK, since all kinds of types | |
103 | (unsigned long, void*) go in SCM_PACK | |
702551e6 | 104 | */ |
75917d62 AW |
105 | # define SCM_PACK(x) ((SCM) (x)) |
106 | ||
c209c88e | 107 | #else |
75917d62 AW |
108 | /* This should be used as a fall back solution for machines on which casting |
109 | * to a pointer may lead to loss of bit information, e. g. in the three least | |
110 | * significant bits. | |
8d3356e7 | 111 | */ |
75917d62 AW |
112 | typedef scm_t_bits SCM; |
113 | # define SCM_UNPACK(x) (x) | |
114 | # define SCM_PACK(x) ((SCM) (x)) | |
c209c88e | 115 | #endif |
0f2d19dd | 116 | |
21041372 AW |
117 | /* Packing SCM objects into and out of pointers. |
118 | */ | |
119 | #define SCM_UNPACK_POINTER(x) ((scm_t_bits *) (SCM_UNPACK (x))) | |
120 | #define SCM_PACK_POINTER(x) (SCM_PACK ((scm_t_bits) (x))) | |
121 | ||
8d3356e7 DH |
122 | |
123 | /* SCM values can not be compared by using the operator ==. Use the following | |
124 | * macro instead, which is the equivalent of the scheme predicate 'eq?'. | |
125 | */ | |
9c293a3d | 126 | #define scm_is_eq(x, y) (SCM_UNPACK (x) == SCM_UNPACK (y)) |
8d3356e7 | 127 | |
0f2d19dd | 128 | \f |
2549a709 | 129 | |
7e3b25bf DH |
130 | /* Representation of scheme objects: |
131 | * | |
c2597415 AW |
132 | * Guile's type system is designed to work on systems where scm_t_bits |
133 | * and SCM variables consist of at least 32 bits. The objects that a | |
134 | * SCM variable can represent belong to one of the following two major | |
135 | * categories: | |
136 | * | |
137 | * - Immediates -- meaning that the SCM variable contains an entire | |
138 | * Scheme object. That means, all the object's data (including the | |
139 | * type tagging information that is required to identify the object's | |
140 | * type) must fit into 32 bits. | |
141 | * | |
142 | * - Heap objects -- meaning that the SCM variable holds a pointer into | |
143 | * the heap. On systems where a pointer needs more than 32 bits this | |
144 | * means that scm_t_bits and SCM variables need to be large enough to | |
145 | * hold such pointers. In contrast to immediates, the data associated | |
146 | * with a heap object can consume arbitrary amounts of memory. | |
147 | * | |
148 | * The 'heap' is the memory area that is under control of Guile's | |
149 | * garbage collector. It holds allocated memory of various sizes. The | |
150 | * impact on the runtime type system is that Guile needs to be able to | |
151 | * determine the type of an object given the pointer. Usually the way | |
152 | * that Guile does this is by storing a "type tag" in the first word of | |
153 | * the object. | |
154 | * | |
155 | * Some objects are common enough that they get special treatment. | |
156 | * Since Guile guarantees that the address of a GC-allocated object on | |
157 | * the heap is 8-byte aligned, Guile can play tricks with the lower 3 | |
158 | * bits. That is, since heap objects encode a pointer to an | |
159 | * 8-byte-aligned pointer, the three least significant bits of a SCM can | |
160 | * be used to store additional information. The bits are used to store | |
161 | * information about the object's type and thus are called tc3-bits, | |
162 | * where tc stands for type-code. | |
163 | * | |
164 | * For a given SCM value, the distinction whether it holds an immediate | |
165 | * or heap object is based on the tc3-bits (see above) of its scm_t_bits | |
7e3b25bf | 166 | * equivalent: If the tc3-bits equal #b000, then the SCM value holds a |
c2597415 AW |
167 | * heap object, and the scm_t_bits variable's value is just the pointer |
168 | * to the heap cell. | |
7e3b25bf DH |
169 | * |
170 | * Summarized, the data of a scheme object that is represented by a SCM | |
c2597415 AW |
171 | * variable consists of a) the SCM variable itself, b) in case of heap |
172 | * objects memory that the SCM object points to, c) in case of heap | |
173 | * objects potentially additional data outside of the heap (like for | |
174 | * example malloc'ed data), and d) in case of heap objects potentially | |
175 | * additional data inside of the heap, since data stored in b) and c) | |
176 | * may hold references to other cells. | |
7e3b25bf DH |
177 | * |
178 | * | |
179 | * Immediates | |
180 | * | |
181 | * Operations on immediate objects can typically be processed faster than on | |
c2597415 | 182 | * heap objects. The reason is that the object's data can be extracted |
7e3b25bf DH |
183 | * directly from the SCM variable (or rather a corresponding scm_t_bits |
184 | * variable), instead of having to perform additional memory accesses to | |
185 | * obtain the object's data from the heap. In order to get the best possible | |
186 | * performance frequently used data types should be realized as immediates. | |
187 | * This is, as has been mentioned above, only possible if the objects can be | |
188 | * represented with 32 bits (including type tagging). | |
189 | * | |
190 | * In Guile, the following data types and special objects are realized as | |
191 | * immediates: booleans, characters, small integers (see below), the empty | |
192 | * list, the end of file object, the 'unspecified' object (which is delivered | |
193 | * as a return value by functions for which the return value is unspecified), | |
194 | * a 'nil' object used in the elisp-compatibility mode and certain other | |
195 | * 'special' objects which are only used internally in Guile. | |
196 | * | |
197 | * Integers in Guile can be arbitrarily large. On the other hand, integers | |
198 | * are one of the most frequently used data types. Especially integers with | |
199 | * less than 32 bits are commonly used. Thus, internally and transparently | |
200 | * for application code guile distinguishes between small and large integers. | |
201 | * Whether an integer is a large or a small integer depends on the number of | |
202 | * bits needed to represent its value. Small integers are those which can be | |
203 | * represented as immediates. Since they don't require more than a fixed | |
204 | * number of bits for their representation, they are also known as 'fixnums'. | |
205 | * | |
206 | * The tc3-combinations #b010 and #b110 are used to represent small integers, | |
207 | * which allows to use the most significant bit of the tc3-bits to be part of | |
208 | * the integer value being represented. This means that all integers with up | |
209 | * to 30 bits (including one bit for the sign) can be represented as | |
210 | * immediates. On systems where SCM and scm_t_bits variables hold more than | |
211 | * 32 bits, the amount of bits usable for small integers will even be larger. | |
212 | * The tc3-code #b100 is shared among booleans, characters and the other | |
213 | * special objects listed above. | |
214 | * | |
215 | * | |
c2597415 AW |
216 | * Heap Objects |
217 | * | |
218 | * All object types not mentioned above in the list of immedate objects | |
219 | * are represented as heap objects. The amount of memory referenced by | |
220 | * a heap object depends on the object's type, namely on the set of | |
221 | * attributes that have to be stored with objects of that type. Every | |
222 | * heap object type is allowed to define its own layout and | |
223 | * interpretation of the data stored in its cell (with some | |
224 | * restrictions, see below). | |
225 | * | |
226 | * One of the design goals of guile's type system is to make it possible | |
227 | * to store a scheme pair with as little memory usage as possible. The | |
228 | * minimum amount of memory that is required to store two scheme objects | |
229 | * (car and cdr of a pair) is the amount of memory required by two | |
230 | * scm_t_bits or SCM variables. Therefore pairs in guile are stored in | |
231 | * two words, and are tagged with a bit pattern in the SCM value, not | |
232 | * with a type tag on the heap. | |
7e3b25bf DH |
233 | * |
234 | * | |
235 | * Garbage collection | |
236 | * | |
c2597415 AW |
237 | * During garbage collection, unreachable objects on the heap will be |
238 | * freed. To determine the set of reachable objects, by default, the GC | |
239 | * just traces all words in all heap objects. It is possible to | |
240 | * register custom tracing ("marking") procedures. | |
241 | * | |
242 | * If an object is unreachable, by default, the GC just notes this fact | |
243 | * and moves on. Later allocations will clear out the memory associated | |
244 | * with the object, and re-use it. It is possible to register custom | |
245 | * finalizers, however. | |
246 | * | |
247 | * | |
248 | * Run-time type introspection | |
249 | * | |
250 | * Guile's type system is designed to make it possible to determine a | |
251 | * the type of a heap object from the object's first scm_t_bits | |
252 | * variable. (Given a SCM variable X holding a heap object, the macro | |
253 | * SCM_CELL_TYPE(X) will deliver the corresponding object's first | |
254 | * scm_t_bits variable.) | |
255 | * | |
256 | * If the object holds a scheme pair, then we already know that the | |
257 | * first scm_t_bits variable of the cell will hold a scheme object with | |
258 | * one of the following tc3-codes: #b000 (heap object), #b010 (small | |
259 | * integer), #b110 (small integer), #b100 (non-integer immediate). All | |
260 | * these tc3-codes have in common, that their least significant bit is | |
261 | * #b0. This fact is used by the garbage collector to identify cells | |
262 | * that hold pairs. The remaining tc3-codes are assigned as follows: | |
263 | * #b001 (class instance or, more precisely, a struct, of which a class | |
264 | * instance is a special case), #b011 (closure), #b101/#b111 (all | |
265 | * remaining heap object types). | |
7e3b25bf DH |
266 | * |
267 | * | |
268 | * Summary of type codes of scheme objects (SCM variables) | |
269 | * | |
270 | * Here is a summary of tagging bits as they might occur in a scheme object. | |
271 | * The notation is as follows: tc stands for type code as before, tc<n> with n | |
272 | * being a number indicates a type code formed by the n least significant bits | |
273 | * of the SCM variables corresponding scm_t_bits value. | |
274 | * | |
275 | * Note that (as has been explained above) tc1==1 can only occur in the first | |
c2597415 | 276 | * scm_t_bits variable of a cell belonging to a heap object that is |
7e3b25bf DH |
277 | * not a pair. For an explanation of the tc tags with tc1==1, see the next |
278 | * section with the summary of the type codes on the heap. | |
279 | * | |
280 | * tc1: | |
281 | * 0: For scheme objects, tc1==0 must be fulfilled. | |
282 | * (1: This can never be the case for a scheme object.) | |
283 | * | |
284 | * tc2: | |
c2597415 | 285 | * 00: Either a heap object or some non-integer immediate |
7e3b25bf DH |
286 | * (01: This can never be the case for a scheme object.) |
287 | * 10: Small integer | |
288 | * (11: This can never be the case for a scheme object.) | |
289 | * | |
290 | * tc3: | |
c2597415 | 291 | * 000: a heap object (pair, closure, class instance etc.) |
7e3b25bf DH |
292 | * (001: This can never be the case for a scheme object.) |
293 | * 010: an even small integer (least significant bit is 0). | |
294 | * (011: This can never be the case for a scheme object.) | |
295 | * 100: Non-integer immediate | |
296 | * (101: This can never be the case for a scheme object.) | |
297 | * 110: an odd small integer (least significant bit is 1). | |
298 | * (111: This can never be the case for a scheme object.) | |
299 | * | |
c2597415 AW |
300 | * The remaining bits of the heap objects form the pointer to the heap |
301 | * cell. The remaining bits of the small integers form the integer's | |
7e3b25bf DH |
302 | * value and sign. Thus, the only scheme objects for which a further |
303 | * subdivision is of interest are the ones with tc3==100. | |
304 | * | |
5065b40d DH |
305 | * tc8 (for objects with tc3==100): |
306 | * 00000-100: special objects ('flags') | |
307 | * 00001-100: characters | |
b7742c6b AW |
308 | * 00010-100: unused |
309 | * 00011-100: unused | |
7e3b25bf DH |
310 | * |
311 | * | |
312 | * Summary of type codes on the heap | |
313 | * | |
314 | * Here is a summary of tagging in scm_t_bits values as they might occur in | |
315 | * the first scm_t_bits variable of a heap cell. | |
316 | * | |
317 | * tc1: | |
318 | * 0: the cell belongs to a pair. | |
319 | * 1: the cell belongs to a non-pair. | |
320 | * | |
321 | * tc2: | |
322 | * 00: the cell belongs to a pair with no short integer in its car. | |
c2597415 | 323 | * 01: the cell belongs to a non-pair (struct or some other heap object). |
7e3b25bf | 324 | * 10: the cell belongs to a pair with a short integer in its car. |
c2597415 | 325 | * 11: the cell belongs to a non-pair (closure or some other heap object). |
7e3b25bf DH |
326 | * |
327 | * tc3: | |
c2597415 | 328 | * 000: the cell belongs to a pair with a heap object in its car. |
7e3b25bf DH |
329 | * 001: the cell belongs to a struct |
330 | * 010: the cell belongs to a pair with an even short integer in its car. | |
331 | * 011: the cell belongs to a closure | |
332 | * 100: the cell belongs to a pair with a non-integer immediate in its car. | |
c2597415 | 333 | * 101: the cell belongs to some other heap object. |
7e3b25bf | 334 | * 110: the cell belongs to a pair with an odd short integer in its car. |
c2597415 | 335 | * 111: the cell belongs to some other heap object. |
7e3b25bf DH |
336 | * |
337 | * tc7 (for tc3==1x1): | |
a32488ba AW |
338 | * See below for the list of types. Three special tc7-codes are of |
339 | * interest: numbers, ports and smobs in fact each represent | |
340 | * collections of types, which are subdivided using tc16-codes. | |
7e3b25bf DH |
341 | * |
342 | * tc16 (for tc7==scm_tc7_smob): | |
343 | * The largest part of the space of smob types is not subdivided in a | |
344 | * predefined way, since smobs can be added arbitrarily by user C code. | |
7e3b25bf | 345 | */ |
0f2d19dd | 346 | |
7e3b25bf DH |
347 | \f |
348 | ||
c2597415 | 349 | /* Checking if a SCM variable holds an immediate or a heap object: |
7e3b25bf DH |
350 | * This check can either be performed by checking for tc3==000 or tc3==00x, |
351 | * since for a SCM variable it is known that tc1==0. */ | |
f1267706 | 352 | #define SCM_IMP(x) (6 & SCM_UNPACK (x)) |
76189127 | 353 | #define SCM_NIMP(x) (!SCM_IMP (x)) |
8c5bb729 | 354 | #define SCM_HEAP_OBJECT_P(x) (SCM_NIMP (x)) |
0f2d19dd | 355 | |
7e3b25bf DH |
356 | /* Checking if a SCM variable holds an immediate integer: See numbers.h for |
357 | * the definition of the following macros: SCM_I_FIXNUM_BIT, | |
e11e83f3 | 358 | * SCM_MOST_POSITIVE_FIXNUM, SCM_I_INUMP, SCM_I_MAKINUM, SCM_I_INUM. */ |
0f2d19dd | 359 | |
7e3b25bf DH |
360 | /* Checking if a SCM variable holds a pair (for historical reasons, in Guile |
361 | * also known as a cons-cell): This is done by first checking that the SCM | |
c2597415 | 362 | * variable holds a heap object, and second, by checking that tc1==0 holds |
6fcc7d48 MV |
363 | * for the SCM_CELL_TYPE of the SCM variable. |
364 | */ | |
365 | ||
366 | #define SCM_I_CONSP(x) (!SCM_IMP (x) && ((1 & SCM_CELL_TYPE (x)) == 0)) | |
0f2d19dd | 367 | |
0f2d19dd JB |
368 | \f |
369 | ||
7e3b25bf | 370 | /* Definitions for tc2: */ |
0f2d19dd | 371 | |
6375e040 DH |
372 | #define scm_tc2_int 2 |
373 | ||
7e3b25bf DH |
374 | |
375 | /* Definitions for tc3: */ | |
376 | ||
904a077d MV |
377 | #define SCM_ITAG3(x) (7 & SCM_UNPACK (x)) |
378 | #define SCM_TYP3(x) (7 & SCM_CELL_TYPE (x)) | |
7e3b25bf | 379 | |
904a077d MV |
380 | #define scm_tc3_cons 0 |
381 | #define scm_tc3_struct 1 | |
6375e040 | 382 | #define scm_tc3_int_1 (scm_tc2_int + 0) |
314b8716 | 383 | #define scm_tc3_unused 3 |
c209c88e GB |
384 | #define scm_tc3_imm24 4 |
385 | #define scm_tc3_tc7_1 5 | |
6375e040 | 386 | #define scm_tc3_int_2 (scm_tc2_int + 4) |
c209c88e | 387 | #define scm_tc3_tc7_2 7 |
0f2d19dd JB |
388 | |
389 | ||
7e3b25bf | 390 | /* Definitions for tc7: */ |
0f2d19dd | 391 | |
d1ca2c64 | 392 | #define SCM_ITAG7(x) (127 & SCM_UNPACK (x)) |
445f675c | 393 | #define SCM_TYP7(x) (0x7f & SCM_CELL_TYPE (x)) |
dc7da0be AW |
394 | #define SCM_HAS_HEAP_TYPE(x, type, tag) \ |
395 | (SCM_NIMP (x) && type (x) == (tag)) | |
396 | #define SCM_HAS_TYP7(x, tag) (SCM_HAS_HEAP_TYPE (x, SCM_TYP7, tag)) | |
0f2d19dd | 397 | |
be8b62ca AW |
398 | /* If you change these numbers, change them also in (system vm |
399 | assembler). */ | |
400 | ||
28b06554 | 401 | #define scm_tc7_symbol 5 |
e5aca4b5 | 402 | #define scm_tc7_variable 7 |
0f2d19dd JB |
403 | |
404 | /* couple */ | |
405 | #define scm_tc7_vector 13 | |
406 | #define scm_tc7_wvect 15 | |
407 | ||
0f2d19dd | 408 | #define scm_tc7_string 21 |
534c55a9 | 409 | #define scm_tc7_number 23 |
fddf6000 | 410 | #define scm_tc7_stringbuf 39 |
807e5a66 | 411 | #define scm_tc7_bytevector 77 |
0f2d19dd | 412 | |
5b46a8c2 | 413 | #define scm_tc7_pointer 31 |
c99de5aa | 414 | #define scm_tc7_hashtable 29 |
9ea31741 AW |
415 | #define scm_tc7_fluid 37 |
416 | #define scm_tc7_dynamic_state 45 | |
417 | ||
6f3b0cc2 | 418 | #define scm_tc7_frame 47 |
e2fafeb9 | 419 | #define scm_tc7_keyword 53 |
35093075 | 420 | #define scm_tc7_unused_55 55 |
6f3b0cc2 | 421 | #define scm_tc7_vm_cont 71 |
afe5177e | 422 | |
9ede013f AW |
423 | #define scm_tc7_unused_17 61 |
424 | #define scm_tc7_unused_21 63 | |
e0755cd1 | 425 | #define scm_tc7_program 69 |
1c33be99 | 426 | #define scm_tc7_unused_79 79 |
26b26354 | 427 | #define scm_tc7_weak_set 85 |
7005c60f | 428 | #define scm_tc7_weak_table 87 |
91ee7515 AW |
429 | #define scm_tc7_array 93 |
430 | #define scm_tc7_bitvector 95 | |
df338a22 | 431 | #define scm_tc7_unused_12 101 |
31d845b4 | 432 | #define scm_tc7_unused_18 103 |
df338a22 AW |
433 | #define scm_tc7_unused_13 109 |
434 | #define scm_tc7_unused_14 111 | |
435 | #define scm_tc7_unused_15 117 | |
436 | #define scm_tc7_unused_16 119 | |
0f2d19dd | 437 | |
7e3b25bf | 438 | /* There are 256 port subtypes. */ |
0f2d19dd JB |
439 | #define scm_tc7_port 125 |
440 | ||
6375e040 DH |
441 | /* There are 256 smob subtypes. [**] If you change scm_tc7_smob, you must |
442 | * also change the places it is hard coded in this file and possibly others. | |
443 | * Dirk:FIXME:: Any hard coded reference to scm_tc7_smob must be replaced by a | |
7e3b25bf | 444 | * symbolic reference. */ |
0f2d19dd JB |
445 | #define scm_tc7_smob 127 /* DO NOT CHANGE [**] */ |
446 | ||
0f2d19dd | 447 | |
7e3b25bf DH |
448 | /* Definitions for tc16: */ |
449 | #define SCM_TYP16(x) (0xffff & SCM_CELL_TYPE (x)) | |
dc7da0be AW |
450 | #define SCM_HAS_TYP16(x, tag) (SCM_HAS_HEAP_TYPE (x, SCM_TYP16, tag)) |
451 | #define SCM_TYP16_PREDICATE(tag, x) (SCM_HAS_TYP16 (x, tag)) | |
7e3b25bf | 452 | |
f03314f9 | 453 | |
0f2d19dd | 454 | \f |
5065b40d | 455 | |
8ce94504 | 456 | /* {Immediate Values} |
0f2d19dd JB |
457 | */ |
458 | ||
5065b40d | 459 | enum scm_tc8_tags |
0f2d19dd | 460 | { |
5065b40d DH |
461 | scm_tc8_flag = scm_tc3_imm24 + 0x00, /* special objects ('flags') */ |
462 | scm_tc8_char = scm_tc3_imm24 + 0x08, /* characters */ | |
b7742c6b AW |
463 | scm_tc8_unused_0 = scm_tc3_imm24 + 0x10, |
464 | scm_tc8_unused_1 = scm_tc3_imm24 + 0x18 | |
0f2d19dd JB |
465 | }; |
466 | ||
f1267706 | 467 | #define SCM_ITAG8(X) (SCM_UNPACK (X) & 0xff) |
210c0325 AW |
468 | #define SCM_MAKE_ITAG8_BITS(X, TAG) (((X) << 8) + TAG) |
469 | #define SCM_MAKE_ITAG8(X, TAG) (SCM_PACK (SCM_MAKE_ITAG8_BITS (X, TAG))) | |
f1267706 | 470 | #define SCM_ITAG8_DATA(X) (SCM_UNPACK (X) >> 8) |
0f2d19dd | 471 | |
0f2d19dd | 472 | \f |
0f2d19dd | 473 | |
5065b40d DH |
474 | /* Flags (special objects). The indices of the flags must agree with the |
475 | * declarations in print.c: iflagnames. */ | |
476 | ||
477 | #define SCM_IFLAGP(n) (SCM_ITAG8 (n) == scm_tc8_flag) | |
210c0325 | 478 | #define SCM_MAKIFLAG_BITS(n) (SCM_MAKE_ITAG8_BITS ((n), scm_tc8_flag)) |
5065b40d | 479 | #define SCM_IFLAGNUM(n) (SCM_ITAG8_DATA (n)) |
e17d318f | 480 | |
45f4cbdf MW |
481 | /* |
482 | * IMPORTANT NOTE regarding IFLAG numbering!!! | |
483 | * | |
484 | * Several macros depend upon careful IFLAG numbering of SCM_BOOL_F, | |
485 | * SCM_BOOL_T, SCM_ELISP_NIL, SCM_EOL, and the two SCM_XXX_*_DONT_USE | |
486 | * constants. In particular: | |
487 | * | |
488 | * - SCM_BOOL_F and SCM_BOOL_T must differ in exactly one bit position. | |
489 | * (used to implement scm_is_bool_and_not_nil, aka scm_is_bool) | |
490 | * | |
491 | * - SCM_ELISP_NIL and SCM_BOOL_F must differ in exactly one bit position. | |
492 | * (used to implement scm_is_false_or_nil and | |
493 | * scm_is_true_and_not_nil) | |
494 | * | |
495 | * - SCM_ELISP_NIL and SCM_EOL must differ in exactly one bit position. | |
496 | * (used to implement scm_is_null_or_nil) | |
497 | * | |
498 | * - SCM_ELISP_NIL, SCM_BOOL_F, SCM_EOL, SCM_XXX_ANOTHER_LISP_FALSE_DONT_USE | |
499 | * must all be equal except for two bit positions. | |
500 | * (used to implement scm_is_lisp_false) | |
501 | * | |
f60c2c4e | 502 | * - SCM_ELISP_NIL, SCM_BOOL_F, SCM_BOOL_T, SCM_XXX_ANOTHER_BOOLEAN_DONT_USE_0 |
45f4cbdf MW |
503 | * must all be equal except for two bit positions. |
504 | * (used to implement scm_is_bool_or_nil) | |
505 | * | |
506 | * These properties allow the aforementioned macros to be implemented | |
507 | * by bitwise ANDing with a mask and then comparing with a constant, | |
508 | * using as a common basis the macro SCM_MATCHES_BITS_IN_COMMON, | |
509 | * defined below. The properties are checked at compile-time using | |
510 | * `verify' macros near the top of boolean.c and pairs.c. | |
511 | */ | |
210c0325 AW |
512 | #define SCM_BOOL_F_BITS SCM_MAKIFLAG_BITS (0) |
513 | #define SCM_ELISP_NIL_BITS SCM_MAKIFLAG_BITS (1) | |
514 | ||
515 | #define SCM_BOOL_F SCM_PACK (SCM_BOOL_F_BITS) | |
516 | #define SCM_ELISP_NIL SCM_PACK (SCM_ELISP_NIL_BITS) | |
45f4cbdf MW |
517 | |
518 | #ifdef BUILDING_LIBGUILE | |
210c0325 | 519 | #define SCM_XXX_ANOTHER_LISP_FALSE_DONT_USE SCM_MAKIFLAG_BITS (2) |
45f4cbdf MW |
520 | #endif |
521 | ||
210c0325 AW |
522 | #define SCM_EOL_BITS SCM_MAKIFLAG_BITS (3) |
523 | #define SCM_BOOL_T_BITS SCM_MAKIFLAG_BITS (4) | |
524 | ||
525 | #define SCM_EOL SCM_PACK (SCM_EOL_BITS) | |
526 | #define SCM_BOOL_T SCM_PACK (SCM_BOOL_T_BITS) | |
45f4cbdf MW |
527 | |
528 | #ifdef BUILDING_LIBGUILE | |
210c0325 AW |
529 | #define SCM_XXX_ANOTHER_BOOLEAN_DONT_USE_0 SCM_MAKIFLAG_BITS (5) |
530 | #define SCM_XXX_ANOTHER_BOOLEAN_DONT_USE_1 SCM_MAKIFLAG_BITS (6) | |
531 | #define SCM_XXX_ANOTHER_BOOLEAN_DONT_USE_2 SCM_MAKIFLAG_BITS (7) | |
45f4cbdf MW |
532 | #endif |
533 | ||
210c0325 AW |
534 | #define SCM_UNSPECIFIED_BITS SCM_MAKIFLAG_BITS (8) |
535 | #define SCM_UNDEFINED_BITS SCM_MAKIFLAG_BITS (9) | |
536 | #define SCM_EOF_VAL_BITS SCM_MAKIFLAG_BITS (10) | |
537 | ||
538 | #define SCM_UNSPECIFIED SCM_PACK (SCM_UNSPECIFIED_BITS) | |
539 | #define SCM_UNDEFINED SCM_PACK (SCM_UNDEFINED_BITS) | |
540 | #define SCM_EOF_VAL SCM_PACK (SCM_EOF_VAL_BITS) | |
e17d318f DH |
541 | |
542 | /* When a variable is unbound this is marked by the SCM_UNDEFINED | |
543 | * value. The following is an unbound value which can be handled on | |
544 | * the Scheme level, i.e., it can be stored in and retrieved from a | |
545 | * Scheme variable. This value is only intended to mark an unbound | |
546 | * slot in GOOPS. It is needed now, but we should probably rewrite | |
547 | * the code which handles this value in C so that SCM_UNDEFINED can be | |
548 | * used instead. It is not ideal to let this kind of unique and | |
549 | * strange values loose on the Scheme level. */ | |
210c0325 AW |
550 | #define SCM_UNBOUND_BITS SCM_MAKIFLAG_BITS (11) |
551 | #define SCM_UNBOUND SCM_PACK (SCM_UNBOUND_BITS) | |
e17d318f | 552 | |
68fb32d2 | 553 | #define SCM_UNBNDP(x) (scm_is_eq ((x), SCM_UNDEFINED)) |
e17d318f | 554 | |
45f4cbdf MW |
555 | /* |
556 | * SCM_MATCHES_BITS_IN_COMMON(x,a,b) returns 1 if and only if x | |
557 | * matches both a and b in every bit position where a and b are equal; | |
558 | * otherwise it returns 0. Bit positions where a and b differ are | |
559 | * ignored. | |
560 | * | |
561 | * This is used to efficiently compare against two values which differ | |
562 | * in exactly one bit position, or against four values which differ in | |
563 | * exactly two bit positions. It is the basis for the following | |
564 | * macros: | |
565 | * | |
566 | * scm_is_null_or_nil, | |
567 | * scm_is_false_or_nil, | |
568 | * scm_is_true_and_not_nil, | |
569 | * scm_is_lisp_false, | |
570 | * scm_is_lisp_true, | |
571 | * scm_is_bool_and_not_nil (aka scm_is_bool) | |
572 | * scm_is_bool_or_nil. | |
573 | */ | |
574 | #define SCM_MATCHES_BITS_IN_COMMON(x,a,b) \ | |
575 | ((SCM_UNPACK(x) & ~(SCM_UNPACK(a) ^ SCM_UNPACK(b))) == \ | |
576 | (SCM_UNPACK(a) & SCM_UNPACK(b))) | |
577 | ||
578 | /* | |
579 | * These macros are used for compile-time verification that the | |
580 | * constants have the properties needed for the above macro to work | |
581 | * properly. | |
582 | */ | |
583 | #ifdef BUILDING_LIBGUILE | |
584 | #define SCM_WITH_LEAST_SIGNIFICANT_1_BIT_CLEARED(x) ((x) & ((x)-1)) | |
585 | #define SCM_HAS_EXACTLY_ONE_BIT_SET(x) \ | |
586 | ((x) != 0 && SCM_WITH_LEAST_SIGNIFICANT_1_BIT_CLEARED (x) == 0) | |
587 | #define SCM_HAS_EXACTLY_TWO_BITS_SET(x) \ | |
588 | (SCM_HAS_EXACTLY_ONE_BIT_SET (SCM_WITH_LEAST_SIGNIFICANT_1_BIT_CLEARED (x))) | |
589 | ||
210c0325 AW |
590 | #define SCM_BITS_DIFFER_IN_EXACTLY_ONE_BIT_POSITION(a,b) \ |
591 | (SCM_HAS_EXACTLY_ONE_BIT_SET ((a) ^ (b))) | |
592 | #define SCM_BITS_DIFFER_IN_EXACTLY_TWO_BIT_POSITIONS(a,b,c,d) \ | |
593 | (SCM_HAS_EXACTLY_TWO_BITS_SET (((a) ^ (b)) | \ | |
594 | ((b) ^ (c)) | \ | |
595 | ((c) ^ (d)))) | |
45f4cbdf | 596 | #endif /* BUILDING_LIBGUILE */ |
5065b40d | 597 | \f |
e17d318f | 598 | |
904a077d | 599 | /* Dispatching aids: |
0f2d19dd | 600 | |
904a077d MV |
601 | When switching on SCM_TYP7 of a SCM value, use these fake case |
602 | labels to catch types that use fewer than 7 bits for tagging. */ | |
0f2d19dd | 603 | |
8ce94504 | 604 | /* For cons pairs with immediate values in the CAR |
0f2d19dd JB |
605 | */ |
606 | ||
6375e040 DH |
607 | #define scm_tcs_cons_imcar \ |
608 | scm_tc2_int + 0: case scm_tc2_int + 4: case scm_tc3_imm24 + 0:\ | |
609 | case scm_tc2_int + 8: case scm_tc2_int + 12: case scm_tc3_imm24 + 8:\ | |
610 | case scm_tc2_int + 16: case scm_tc2_int + 20: case scm_tc3_imm24 + 16:\ | |
611 | case scm_tc2_int + 24: case scm_tc2_int + 28: case scm_tc3_imm24 + 24:\ | |
612 | case scm_tc2_int + 32: case scm_tc2_int + 36: case scm_tc3_imm24 + 32:\ | |
613 | case scm_tc2_int + 40: case scm_tc2_int + 44: case scm_tc3_imm24 + 40:\ | |
614 | case scm_tc2_int + 48: case scm_tc2_int + 52: case scm_tc3_imm24 + 48:\ | |
615 | case scm_tc2_int + 56: case scm_tc2_int + 60: case scm_tc3_imm24 + 56:\ | |
616 | case scm_tc2_int + 64: case scm_tc2_int + 68: case scm_tc3_imm24 + 64:\ | |
617 | case scm_tc2_int + 72: case scm_tc2_int + 76: case scm_tc3_imm24 + 72:\ | |
618 | case scm_tc2_int + 80: case scm_tc2_int + 84: case scm_tc3_imm24 + 80:\ | |
619 | case scm_tc2_int + 88: case scm_tc2_int + 92: case scm_tc3_imm24 + 88:\ | |
620 | case scm_tc2_int + 96: case scm_tc2_int + 100: case scm_tc3_imm24 + 96:\ | |
621 | case scm_tc2_int + 104: case scm_tc2_int + 108: case scm_tc3_imm24 + 104:\ | |
622 | case scm_tc2_int + 112: case scm_tc2_int + 116: case scm_tc3_imm24 + 112:\ | |
623 | case scm_tc2_int + 120: case scm_tc2_int + 124: case scm_tc3_imm24 + 120 | |
0f2d19dd | 624 | |
c2597415 | 625 | /* For cons pairs with heap objects in the SCM_CAR |
0f2d19dd | 626 | */ |
6375e040 DH |
627 | #define scm_tcs_cons_nimcar \ |
628 | scm_tc3_cons + 0:\ | |
629 | case scm_tc3_cons + 8:\ | |
630 | case scm_tc3_cons + 16:\ | |
631 | case scm_tc3_cons + 24:\ | |
632 | case scm_tc3_cons + 32:\ | |
633 | case scm_tc3_cons + 40:\ | |
634 | case scm_tc3_cons + 48:\ | |
635 | case scm_tc3_cons + 56:\ | |
636 | case scm_tc3_cons + 64:\ | |
637 | case scm_tc3_cons + 72:\ | |
638 | case scm_tc3_cons + 80:\ | |
639 | case scm_tc3_cons + 88:\ | |
640 | case scm_tc3_cons + 96:\ | |
641 | case scm_tc3_cons + 104:\ | |
642 | case scm_tc3_cons + 112:\ | |
643 | case scm_tc3_cons + 120 | |
0f2d19dd | 644 | |
904a077d | 645 | /* For structs |
0f2d19dd | 646 | */ |
6375e040 DH |
647 | #define scm_tcs_struct \ |
648 | scm_tc3_struct + 0:\ | |
649 | case scm_tc3_struct + 8:\ | |
650 | case scm_tc3_struct + 16:\ | |
651 | case scm_tc3_struct + 24:\ | |
652 | case scm_tc3_struct + 32:\ | |
653 | case scm_tc3_struct + 40:\ | |
654 | case scm_tc3_struct + 48:\ | |
655 | case scm_tc3_struct + 56:\ | |
656 | case scm_tc3_struct + 64:\ | |
657 | case scm_tc3_struct + 72:\ | |
658 | case scm_tc3_struct + 80:\ | |
659 | case scm_tc3_struct + 88:\ | |
660 | case scm_tc3_struct + 96:\ | |
661 | case scm_tc3_struct + 104:\ | |
662 | case scm_tc3_struct + 112:\ | |
663 | case scm_tc3_struct + 120 | |
0f2d19dd | 664 | |
f5f2dcff DH |
665 | \f |
666 | ||
22a52da1 | 667 | #endif /* SCM_TAGS_H */ |
89e00824 ML |
668 | |
669 | /* | |
670 | Local Variables: | |
671 | c-file-style: "gnu" | |
672 | End: | |
673 | */ |