1 /* classes: h_files */ 2 3 #ifndef SCM_TAGS_H 4 #define SCM_TAGS_H 5 6 /* Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004,2008 7 * Free Software Foundation, Inc. 8 * 9 * This library is free software; you can redistribute it and/or 10 * modify it under the terms of the GNU Lesser General Public 11 * License as published by the Free Software Foundation; either 12 * version 2.1 of the License, or (at your option) any later version. 13 * 14 * This library is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 17 * Lesser General Public License for more details. 18 * 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 21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 22 */ 23 24 25 26 /** This file defines the format of SCM values and cons pairs. 27 ** It is here that tag bits are assigned for various purposes. 28 **/ 29 30 /* picks up scmconfig.h too */ 31 #include "libguile/__scm.h" 32 33 #if HAVE_INTTYPES_H 34 # include <inttypes.h> /* for INTPTR_MAX and friends */ 35 #else 36 # if HAVE_STDINT_H 37 # include <stdint.h> /* for INTPTR_MAX and friends */ 38 # endif 39 #endif 40 41 42 43 /* In the beginning was the Word: 44 * 45 * For the representation of scheme objects and their handling, Guile provides 46 * two types: scm_t_bits and SCM. 47 * 48 * - scm_t_bits values can hold bit patterns of non-objects and objects: 49 * 50 * Non-objects -- in this case the value may not be changed into a SCM value 51 * in any way. 52 * 53 * Objects -- in this case the value may be changed into a SCM value using 54 * the SCM_PACK macro. 55 * 56 * - SCM values can hold proper scheme objects only. They can be changed into 57 * a scm_t_bits value using the SCM_UNPACK macro. 58 * 59 * When working in the domain of scm_t_bits values, programmers must keep 60 * track of any scm_t_bits value they create that is not a proper scheme 61 * object. This makes sure that in the domain of SCM values developers can 62 * rely on the fact that they are dealing with proper scheme objects only. 63 * Thus, the distinction between scm_t_bits and SCM values helps to identify 64 * those parts of the code where special care has to be taken not to create 65 * bad SCM values. 66 */ 67 68 /* For dealing with the bit level representation of scheme objects we define 69 * scm_t_bits: 70 */ 71 /* On Solaris 7 and 8, /usr/include/sys/int_limits.h defines 72 INTPTR_MAX and UINTPTR_MAX to empty, INTPTR_MIN is not defined. 73 To avoid uintptr_t and intptr_t in this case we require 74 UINTPTR_MAX-0 != 0 etc. */ 75 #if SCM_SIZEOF_INTPTR_T != 0 && defined(INTPTR_MAX) && defined(INTPTR_MIN) \ 76 && INTPTR_MAX-0 != 0 && INTPTR_MIN-0 != 0 \ 77 && SCM_SIZEOF_UINTPTR_T != 0 && defined(UINTPTR_MAX) && UINTPTR_MAX-0 != 0 78 79 typedef intptr_t scm_t_signed_bits; 80 #define SCM_T_SIGNED_BITS_MAX INTPTR_MAX 81 #define SCM_T_SIGNED_BITS_MIN INTPTR_MIN 82 typedef uintptr_t scm_t_bits; 83 #define SIZEOF_SCM_T_BITS SCM_SIZEOF_UINTPTR_T 84 #define SCM_T_BITS_MAX UINTPTR_MAX 85 86 #else 87 88 typedef signed long scm_t_signed_bits; 89 #define SCM_T_SIGNED_BITS_MAX LONG_MAX 90 #define SCM_T_SIGNED_BITS_MIN LONG_MIN 91 typedef unsigned long scm_t_bits; 92 #define SIZEOF_SCM_T_BITS SCM_SIZEOF_UNSIGNED_LONG 93 #define SCM_T_BITS_MAX ULONG_MAX 94 95 #endif 96 97 /* But as external interface, we define SCM, which may, according to the 98 * desired level of type checking, be defined in several ways: 99 */ 100 #if (SCM_DEBUG_TYPING_STRICTNESS == 2) 101 typedef union { struct { scm_t_bits n; } n; } SCM; scm_pack(scm_t_bits b)102 static SCM scm_pack(scm_t_bits b) { SCM s; s.n.n = b; return s; } 103 # define SCM_UNPACK(x) ((x).n.n) 104 # define SCM_PACK(x) (scm_pack ((scm_t_bits) (x))) 105 #elif (SCM_DEBUG_TYPING_STRICTNESS == 1) 106 /* This is the default, which provides an intermediate level of compile time 107 * type checking while still resulting in very efficient code. 108 */ 109 typedef struct scm_unused_struct * SCM; 110 111 /* 112 The 0?: constructions makes sure that the code is never executed, 113 and that there is no performance hit. However, the alternative is 114 compiled, and does generate a warning when used with the wrong 115 pointer type. 116 117 The Tru64 and ia64-hp-hpux11.23 compilers fail on `case (0?0=0:x)' 118 statements, so for them type-checking is disabled. */ 119 #if defined __DECC || defined __HP_cc 120 # define SCM_UNPACK(x) ((scm_t_bits) (x)) 121 #else 122 # define SCM_UNPACK(x) ((scm_t_bits) (0? (*(SCM*)0=(x)): x)) 123 #endif 124 125 /* 126 There is no typechecking on SCM_PACK, since all kinds of types 127 (unsigned long, void*) go in SCM_PACK 128 */ 129 # define SCM_PACK(x) ((SCM) (x)) 130 131 #else 132 /* This should be used as a fall back solution for machines on which casting 133 * to a pointer may lead to loss of bit information, e. g. in the three least 134 * significant bits. 135 */ 136 typedef scm_t_bits SCM; 137 # define SCM_UNPACK(x) (x) 138 # define SCM_PACK(x) ((SCM) (x)) 139 #endif 140 141 142 /* SCM values can not be compared by using the operator ==. Use the following 143 * macro instead, which is the equivalent of the scheme predicate 'eq?'. 144 */ 145 #define scm_is_eq(x, y) (SCM_UNPACK (x) == SCM_UNPACK (y)) 146 147 148 149 /* Representation of scheme objects: 150 * 151 * Guile's type system is designed to work on systems where scm_t_bits and SCM 152 * variables consist of at least 32 bits. The objects that a SCM variable can 153 * represent belong to one of the following two major categories: 154 * 155 * - Immediates -- meaning that the SCM variable contains an entire Scheme 156 * object. That means, all the object's data (including the type tagging 157 * information that is required to identify the object's type) must fit into 158 * 32 bits. 159 * 160 * - Non-immediates -- meaning that the SCM variable holds a pointer into the 161 * heap of cells (see below). On systems where a pointer needs more than 32 162 * bits this means that scm_t_bits and SCM variables need to be large enough 163 * to hold such pointers. In contrast to immediates, the object's data of 164 * a non-immediate can consume arbitrary amounts of memory: The heap cell 165 * being pointed to consists of at least two scm_t_bits variables and thus 166 * can be used to hold pointers to malloc'ed memory of any size. 167 * 168 * The 'heap' is the memory area that is under control of Guile's garbage 169 * collector. It holds 'single-cells' or 'double-cells', which consist of 170 * either two or four scm_t_bits variables, respectively. It is guaranteed 171 * that the address of a cell on the heap is 8-byte aligned. That is, since 172 * non-immediates hold a cell address, the three least significant bits of a 173 * non-immediate can be used to store additional information. The bits are 174 * used to store information about the object's type and thus are called 175 * tc3-bits, where tc stands for type-code. 176 * 177 * For a given SCM value, the distinction whether it holds an immediate or 178 * non-immediate object is based on the tc3-bits (see above) of its scm_t_bits 179 * equivalent: If the tc3-bits equal #b000, then the SCM value holds a 180 * non-immediate, and the scm_t_bits variable's value is just the pointer to 181 * the heap cell. 182 * 183 * Summarized, the data of a scheme object that is represented by a SCM 184 * variable consists of a) the SCM variable itself, b) in case of 185 * non-immediates the data of the single-cell or double-cell the SCM object 186 * points to, c) in case of non-immediates potentially additional data outside 187 * of the heap (like for example malloc'ed data), and d) in case of 188 * non-immediates potentially additional data inside of the heap, since data 189 * stored in b) and c) may hold references to other cells. 190 * 191 * 192 * Immediates 193 * 194 * Operations on immediate objects can typically be processed faster than on 195 * non-immediates. The reason is that the object's data can be extracted 196 * directly from the SCM variable (or rather a corresponding scm_t_bits 197 * variable), instead of having to perform additional memory accesses to 198 * obtain the object's data from the heap. In order to get the best possible 199 * performance frequently used data types should be realized as immediates. 200 * This is, as has been mentioned above, only possible if the objects can be 201 * represented with 32 bits (including type tagging). 202 * 203 * In Guile, the following data types and special objects are realized as 204 * immediates: booleans, characters, small integers (see below), the empty 205 * list, the end of file object, the 'unspecified' object (which is delivered 206 * as a return value by functions for which the return value is unspecified), 207 * a 'nil' object used in the elisp-compatibility mode and certain other 208 * 'special' objects which are only used internally in Guile. 209 * 210 * Integers in Guile can be arbitrarily large. On the other hand, integers 211 * are one of the most frequently used data types. Especially integers with 212 * less than 32 bits are commonly used. Thus, internally and transparently 213 * for application code guile distinguishes between small and large integers. 214 * Whether an integer is a large or a small integer depends on the number of 215 * bits needed to represent its value. Small integers are those which can be 216 * represented as immediates. Since they don't require more than a fixed 217 * number of bits for their representation, they are also known as 'fixnums'. 218 * 219 * The tc3-combinations #b010 and #b110 are used to represent small integers, 220 * which allows to use the most significant bit of the tc3-bits to be part of 221 * the integer value being represented. This means that all integers with up 222 * to 30 bits (including one bit for the sign) can be represented as 223 * immediates. On systems where SCM and scm_t_bits variables hold more than 224 * 32 bits, the amount of bits usable for small integers will even be larger. 225 * The tc3-code #b100 is shared among booleans, characters and the other 226 * special objects listed above. 227 * 228 * 229 * Non-Immediates 230 * 231 * All object types not mentioned above in the list of immedate objects are 232 * represented as non-immediates. Whether a non-immediate scheme object is 233 * represented by a single-cell or a double-cell depends on the object's type, 234 * namely on the set of attributes that have to be stored with objects of that 235 * type. Every non-immediate type is allowed to define its own layout and 236 * interpretation of the data stored in its cell (with some restrictions, see 237 * below). 238 * 239 * One of the design goals of guile's type system is to make it possible to 240 * store a scheme pair with as little memory usage as possible. The minimum 241 * amount of memory that is required to store two scheme objects (car and cdr 242 * of a pair) is the amount of memory required by two scm_t_bits or SCM 243 * variables. Therefore pairs in guile are stored in single-cells. 244 * 245 * Another design goal for the type system is to store procedure objects 246 * created by lambda expresssions (closures) and class instances (goops 247 * objects) with as little memory usage as possible. Closures are represented 248 * by a reference to the function code and a reference to the closure's 249 * environment. Class instances are represented by a reference to the 250 * instance's class definition and a reference to the instance's data. Thus, 251 * closures as well as class instances also can be stored in single-cells. 252 * 253 * Certain other non-immediate types also store their data in single-cells. 254 * By design decision, the heap is split into areas for single-cells and 255 * double-cells, but not into areas for single-cells-holding-pairs and areas 256 * for single-cells-holding-non-pairs. Any single-cell on the heap therefore 257 * can hold pairs (consisting of two scm_t_bits variables representing two 258 * scheme objects - the car and cdr of the pair) and non-pairs (consisting of 259 * two scm_t_bits variables that hold bit patterns as defined by the layout of 260 * the corresponding object's type). 261 * 262 * 263 * Garbage collection 264 * 265 * During garbage collection, unreachable cells on the heap will be freed. 266 * That is, the garbage collector will detect cells which have no SCM variable 267 * pointing towards them. In order to properly release all memory belonging 268 * to the object to which a cell belongs, the gc needs to be able to interpret 269 * the cell contents in the correct way. That means that the gc needs to be 270 * able to determine the object type associated with a cell only from the cell 271 * itself. 272 * 273 * Consequently, if the gc detects an unreachable single-cell, those two 274 * scm_t_bits variables must provide enough information to determine whether 275 * they belong to a pair (i. e. both scm_t_bits variables represent valid 276 * scheme objects), to a closure, a class instance or if they belong to any 277 * other non-immediate. Guile's type system is designed to make it possible 278 * to determine a the type to which a cell belongs in the majority of cases 279 * from the cell's first scm_t_bits variable. (Given a SCM variable X holding 280 * a non-immediate object, the macro SCM_CELL_TYPE(X) will deliver the 281 * corresponding cell's first scm_t_bits variable.) 282 * 283 * If the cell holds a scheme pair, then we already know that the first 284 * scm_t_bits variable of the cell will hold a scheme object with one of the 285 * following tc3-codes: #b000 (non-immediate), #b010 (small integer), #b100 286 * (small integer), #b110 (non-integer immediate). All these tc3-codes have 287 * in common, that their least significant bit is #b0. This fact is used by 288 * the garbage collector to identify cells that hold pairs. The remaining 289 * tc3-codes are assigned as follows: #b001 (class instance or, more 290 * precisely, a struct, of which a class instance is a special case), #b011 291 * (closure), #b101/#b111 (all remaining non-immediate types). 292 * 293 * 294 * Summary of type codes of scheme objects (SCM variables) 295 * 296 * Here is a summary of tagging bits as they might occur in a scheme object. 297 * The notation is as follows: tc stands for type code as before, tc<n> with n 298 * being a number indicates a type code formed by the n least significant bits 299 * of the SCM variables corresponding scm_t_bits value. 300 * 301 * Note that (as has been explained above) tc1==1 can only occur in the first 302 * scm_t_bits variable of a cell belonging to a non-immediate object that is 303 * not a pair. For an explanation of the tc tags with tc1==1, see the next 304 * section with the summary of the type codes on the heap. 305 * 306 * tc1: 307 * 0: For scheme objects, tc1==0 must be fulfilled. 308 * (1: This can never be the case for a scheme object.) 309 * 310 * tc2: 311 * 00: Either a non-immediate or some non-integer immediate 312 * (01: This can never be the case for a scheme object.) 313 * 10: Small integer 314 * (11: This can never be the case for a scheme object.) 315 * 316 * tc3: 317 * 000: a non-immediate object (pair, closure, class instance etc.) 318 * (001: This can never be the case for a scheme object.) 319 * 010: an even small integer (least significant bit is 0). 320 * (011: This can never be the case for a scheme object.) 321 * 100: Non-integer immediate 322 * (101: This can never be the case for a scheme object.) 323 * 110: an odd small integer (least significant bit is 1). 324 * (111: This can never be the case for a scheme object.) 325 * 326 * The remaining bits of the non-immediate objects form the pointer to the 327 * heap cell. The remaining bits of the small integers form the integer's 328 * value and sign. Thus, the only scheme objects for which a further 329 * subdivision is of interest are the ones with tc3==100. 330 * 331 * tc8 (for objects with tc3==100): 332 * 00000-100: special objects ('flags') 333 * 00001-100: characters 334 * 00010-100: evaluator byte codes ('isyms') 335 * 00011-100: evaluator byte codes ('ilocs') 336 * 337 * 338 * Summary of type codes on the heap 339 * 340 * Here is a summary of tagging in scm_t_bits values as they might occur in 341 * the first scm_t_bits variable of a heap cell. 342 * 343 * tc1: 344 * 0: the cell belongs to a pair. 345 * 1: the cell belongs to a non-pair. 346 * 347 * tc2: 348 * 00: the cell belongs to a pair with no short integer in its car. 349 * 01: the cell belongs to a non-pair (struct or some other non-immediate). 350 * 10: the cell belongs to a pair with a short integer in its car. 351 * 11: the cell belongs to a non-pair (closure or some other non-immediate). 352 * 353 * tc3: 354 * 000: the cell belongs to a pair with a non-immediate in its car. 355 * 001: the cell belongs to a struct 356 * 010: the cell belongs to a pair with an even short integer in its car. 357 * 011: the cell belongs to a closure 358 * 100: the cell belongs to a pair with a non-integer immediate in its car. 359 * 101: the cell belongs to some other non-immediate. 360 * 110: the cell belongs to a pair with an odd short integer in its car. 361 * 111: the cell belongs to some other non-immediate. 362 * 363 * tc7 (for tc3==1x1): 364 * See below for the list of types. Note the special case of scm_tc7_vector 365 * and scm_tc7_wvect: vectors and weak vectors are treated the same in many 366 * cases. Thus, their tc7-codes are chosen to only differ in one bit. This 367 * makes it possible to check an object at the same time for being a vector 368 * or a weak vector by comparing its tc7 code with that bit masked (using 369 * the TYP7S macro). Three more special tc7-codes are of interest: 370 * numbers, ports and smobs in fact each represent collections of types, 371 * which are subdivided using tc16-codes. 372 * 373 * tc16 (for tc7==scm_tc7_smob): 374 * The largest part of the space of smob types is not subdivided in a 375 * predefined way, since smobs can be added arbitrarily by user C code. 376 * However, while Guile also defines a number of smob types throughout, 377 * there is one smob type, namely scm_tc_free_cell, for which Guile assumes 378 * that it is declared first and thus gets a known-in-advance tc16-code. 379 * The reason of requiring a fixed tc16-code for this type is performance. 380 */ 381 382 383 384 /* Checking if a SCM variable holds an immediate or a non-immediate object: 385 * This check can either be performed by checking for tc3==000 or tc3==00x, 386 * since for a SCM variable it is known that tc1==0. */ 387 #define SCM_IMP(x) (6 & SCM_UNPACK (x)) 388 #define SCM_NIMP(x) (!SCM_IMP (x)) 389 390 /* Checking if a SCM variable holds an immediate integer: See numbers.h for 391 * the definition of the following macros: SCM_I_FIXNUM_BIT, 392 * SCM_MOST_POSITIVE_FIXNUM, SCM_I_INUMP, SCM_I_MAKINUM, SCM_I_INUM. */ 393 394 /* Checking if a SCM variable holds a pair (for historical reasons, in Guile 395 * also known as a cons-cell): This is done by first checking that the SCM 396 * variable holds a non-immediate, and second, by checking that tc1==0 holds 397 * for the SCM_CELL_TYPE of the SCM variable. 398 */ 399 400 #define SCM_I_CONSP(x) (!SCM_IMP (x) && ((1 & SCM_CELL_TYPE (x)) == 0)) 401 402 403 404 /* Definitions for tc2: */ 405 406 #define scm_tc2_int 2 407 408 409 /* Definitions for tc3: */ 410 411 #define SCM_ITAG3(x) (7 & SCM_UNPACK (x)) 412 #define SCM_TYP3(x) (7 & SCM_CELL_TYPE (x)) 413 414 #define scm_tc3_cons 0 415 #define scm_tc3_struct 1 416 #define scm_tc3_int_1 (scm_tc2_int + 0) 417 #define scm_tc3_closure 3 418 #define scm_tc3_imm24 4 419 #define scm_tc3_tc7_1 5 420 #define scm_tc3_int_2 (scm_tc2_int + 4) 421 #define scm_tc3_tc7_2 7 422 423 424 /* Definitions for tc7: */ 425 426 #define SCM_ITAG7(x) (127 & SCM_UNPACK (x)) 427 #define SCM_TYP7(x) (0x7f & SCM_CELL_TYPE (x)) 428 #define SCM_TYP7S(x) ((0x7f & ~2) & SCM_CELL_TYPE (x)) 429 430 #define scm_tc7_symbol 5 431 #define scm_tc7_variable 7 432 433 /* couple */ 434 #define scm_tc7_vector 13 435 #define scm_tc7_wvect 15 436 437 #define scm_tc7_string 21 438 #define scm_tc7_number 23 439 #define scm_tc7_stringbuf 39 440 441 /* Many of the following should be turned 442 * into structs or smobs. We need back some 443 * of these 7 bit tags! */ 444 445 #define scm_tc7_pws 31 446 447 #define scm_tc7_unused_1 29 448 #define scm_tc7_unused_2 37 449 #define scm_tc7_unused_3 45 450 #define scm_tc7_unused_4 47 451 #define scm_tc7_unused_5 53 452 #define scm_tc7_unused_6 55 453 #define scm_tc7_unused_7 71 454 #define scm_tc7_unused_8 77 455 #define scm_tc7_unused_9 79 456 457 #define scm_tc7_dsubr 61 458 #define scm_tc7_cclo 63 459 #define scm_tc7_rpsubr 69 460 #define scm_tc7_subr_0 85 461 #define scm_tc7_subr_1 87 462 #define scm_tc7_cxr 93 463 #define scm_tc7_subr_3 95 464 #define scm_tc7_subr_2 101 465 #define scm_tc7_asubr 103 466 #define scm_tc7_subr_1o 109 467 #define scm_tc7_subr_2o 111 468 #define scm_tc7_lsubr_2 117 469 #define scm_tc7_lsubr 119 470 471 /* There are 256 port subtypes. */ 472 #define scm_tc7_port 125 473 474 /* There are 256 smob subtypes. [**] If you change scm_tc7_smob, you must 475 * also change the places it is hard coded in this file and possibly others. 476 * Dirk:FIXME:: Any hard coded reference to scm_tc7_smob must be replaced by a 477 * symbolic reference. */ 478 #define scm_tc7_smob 127 /* DO NOT CHANGE [**] */ 479 480 481 /* Definitions for tc16: */ 482 #define SCM_TYP16(x) (0xffff & SCM_CELL_TYPE (x)) 483 #define SCM_TYP16_PREDICATE(tag, x) (!SCM_IMP (x) && SCM_TYP16 (x) == (tag)) 484 485 486 /* Here is the first smob subtype. */ 487 488 /* scm_tc_free_cell is the 0th smob type. We place this in free cells to tell 489 * the conservative marker not to trace it. */ 490 #define scm_tc_free_cell (scm_tc7_smob + 0 * 256L) 491 492 493 494 /* {Immediate Values} 495 */ 496 497 enum scm_tc8_tags 498 { 499 scm_tc8_flag = scm_tc3_imm24 + 0x00, /* special objects ('flags') */ 500 scm_tc8_char = scm_tc3_imm24 + 0x08, /* characters */ 501 scm_tc8_isym = scm_tc3_imm24 + 0x10, /* evaluator byte codes ('isyms') */ 502 scm_tc8_iloc = scm_tc3_imm24 + 0x18 /* evaluator byte codes ('ilocs') */ 503 }; 504 505 #define SCM_ITAG8(X) (SCM_UNPACK (X) & 0xff) 506 #define SCM_MAKE_ITAG8(X, TAG) SCM_PACK (((X) << 8) + TAG) 507 #define SCM_ITAG8_DATA(X) (SCM_UNPACK (X) >> 8) 508 509 510 511 /* Flags (special objects). The indices of the flags must agree with the 512 * declarations in print.c: iflagnames. */ 513 514 #define SCM_IFLAGP(n) (SCM_ITAG8 (n) == scm_tc8_flag) 515 #define SCM_MAKIFLAG(n) SCM_MAKE_ITAG8 ((n), scm_tc8_flag) 516 #define SCM_IFLAGNUM(n) (SCM_ITAG8_DATA (n)) 517 518 #define SCM_BOOL_F SCM_MAKIFLAG (0) 519 #define SCM_BOOL_T SCM_MAKIFLAG (1) 520 #define SCM_UNDEFINED SCM_MAKIFLAG (2) 521 #define SCM_EOF_VAL SCM_MAKIFLAG (3) 522 #define SCM_EOL SCM_MAKIFLAG (4) 523 #define SCM_UNSPECIFIED SCM_MAKIFLAG (5) 524 525 /* When a variable is unbound this is marked by the SCM_UNDEFINED 526 * value. The following is an unbound value which can be handled on 527 * the Scheme level, i.e., it can be stored in and retrieved from a 528 * Scheme variable. This value is only intended to mark an unbound 529 * slot in GOOPS. It is needed now, but we should probably rewrite 530 * the code which handles this value in C so that SCM_UNDEFINED can be 531 * used instead. It is not ideal to let this kind of unique and 532 * strange values loose on the Scheme level. */ 533 #define SCM_UNBOUND SCM_MAKIFLAG (6) 534 535 /* The Elisp nil value. */ 536 #define SCM_ELISP_NIL SCM_MAKIFLAG (7) 537 538 539 #define SCM_UNBNDP(x) (scm_is_eq ((x), SCM_UNDEFINED)) 540 541 542 543 /* Evaluator byte codes ('immediate symbols'). These constants are used only 544 * in eval but their values have to be allocated here. The indices of the 545 * SCM_IM_ symbols must agree with the declarations in print.c: 546 * scm_isymnames. */ 547 548 #define SCM_ISYMP(n) (SCM_ITAG8 (n) == scm_tc8_isym) 549 #define SCM_MAKISYM(n) SCM_MAKE_ITAG8 ((n), scm_tc8_isym) 550 551 #define SCM_IM_AND SCM_MAKISYM (0) 552 #define SCM_IM_BEGIN SCM_MAKISYM (1) 553 #define SCM_IM_CASE SCM_MAKISYM (2) 554 #define SCM_IM_COND SCM_MAKISYM (3) 555 #define SCM_IM_DO SCM_MAKISYM (4) 556 #define SCM_IM_IF SCM_MAKISYM (5) 557 #define SCM_IM_LAMBDA SCM_MAKISYM (6) 558 #define SCM_IM_LET SCM_MAKISYM (7) 559 #define SCM_IM_LETSTAR SCM_MAKISYM (8) 560 #define SCM_IM_LETREC SCM_MAKISYM (9) 561 #define SCM_IM_OR SCM_MAKISYM (10) 562 #define SCM_IM_QUOTE SCM_MAKISYM (11) 563 #define SCM_IM_SET_X SCM_MAKISYM (12) 564 #define SCM_IM_DEFINE SCM_MAKISYM (13) 565 #define SCM_IM_APPLY SCM_MAKISYM (14) 566 #define SCM_IM_CONT SCM_MAKISYM (15) 567 #define SCM_IM_DISPATCH SCM_MAKISYM (16) 568 #define SCM_IM_SLOT_REF SCM_MAKISYM (17) 569 #define SCM_IM_SLOT_SET_X SCM_MAKISYM (18) 570 #define SCM_IM_DELAY SCM_MAKISYM (19) 571 #define SCM_IM_FUTURE SCM_MAKISYM (20) 572 #define SCM_IM_CALL_WITH_VALUES SCM_MAKISYM (21) 573 #define SCM_IM_ELSE SCM_MAKISYM (22) 574 #define SCM_IM_ARROW SCM_MAKISYM (23) 575 #define SCM_IM_NIL_COND SCM_MAKISYM (24) /* Multi-language support */ 576 #define SCM_IM_BIND SCM_MAKISYM (25) /* Multi-language support */ 577 578 579 580 /* Dispatching aids: 581 582 When switching on SCM_TYP7 of a SCM value, use these fake case 583 labels to catch types that use fewer than 7 bits for tagging. */ 584 585 /* For cons pairs with immediate values in the CAR 586 */ 587 588 #define scm_tcs_cons_imcar \ 589 scm_tc2_int + 0: case scm_tc2_int + 4: case scm_tc3_imm24 + 0:\ 590 case scm_tc2_int + 8: case scm_tc2_int + 12: case scm_tc3_imm24 + 8:\ 591 case scm_tc2_int + 16: case scm_tc2_int + 20: case scm_tc3_imm24 + 16:\ 592 case scm_tc2_int + 24: case scm_tc2_int + 28: case scm_tc3_imm24 + 24:\ 593 case scm_tc2_int + 32: case scm_tc2_int + 36: case scm_tc3_imm24 + 32:\ 594 case scm_tc2_int + 40: case scm_tc2_int + 44: case scm_tc3_imm24 + 40:\ 595 case scm_tc2_int + 48: case scm_tc2_int + 52: case scm_tc3_imm24 + 48:\ 596 case scm_tc2_int + 56: case scm_tc2_int + 60: case scm_tc3_imm24 + 56:\ 597 case scm_tc2_int + 64: case scm_tc2_int + 68: case scm_tc3_imm24 + 64:\ 598 case scm_tc2_int + 72: case scm_tc2_int + 76: case scm_tc3_imm24 + 72:\ 599 case scm_tc2_int + 80: case scm_tc2_int + 84: case scm_tc3_imm24 + 80:\ 600 case scm_tc2_int + 88: case scm_tc2_int + 92: case scm_tc3_imm24 + 88:\ 601 case scm_tc2_int + 96: case scm_tc2_int + 100: case scm_tc3_imm24 + 96:\ 602 case scm_tc2_int + 104: case scm_tc2_int + 108: case scm_tc3_imm24 + 104:\ 603 case scm_tc2_int + 112: case scm_tc2_int + 116: case scm_tc3_imm24 + 112:\ 604 case scm_tc2_int + 120: case scm_tc2_int + 124: case scm_tc3_imm24 + 120 605 606 /* For cons pairs with non-immediate values in the SCM_CAR 607 */ 608 #define scm_tcs_cons_nimcar \ 609 scm_tc3_cons + 0:\ 610 case scm_tc3_cons + 8:\ 611 case scm_tc3_cons + 16:\ 612 case scm_tc3_cons + 24:\ 613 case scm_tc3_cons + 32:\ 614 case scm_tc3_cons + 40:\ 615 case scm_tc3_cons + 48:\ 616 case scm_tc3_cons + 56:\ 617 case scm_tc3_cons + 64:\ 618 case scm_tc3_cons + 72:\ 619 case scm_tc3_cons + 80:\ 620 case scm_tc3_cons + 88:\ 621 case scm_tc3_cons + 96:\ 622 case scm_tc3_cons + 104:\ 623 case scm_tc3_cons + 112:\ 624 case scm_tc3_cons + 120 625 626 /* For structs 627 */ 628 #define scm_tcs_struct \ 629 scm_tc3_struct + 0:\ 630 case scm_tc3_struct + 8:\ 631 case scm_tc3_struct + 16:\ 632 case scm_tc3_struct + 24:\ 633 case scm_tc3_struct + 32:\ 634 case scm_tc3_struct + 40:\ 635 case scm_tc3_struct + 48:\ 636 case scm_tc3_struct + 56:\ 637 case scm_tc3_struct + 64:\ 638 case scm_tc3_struct + 72:\ 639 case scm_tc3_struct + 80:\ 640 case scm_tc3_struct + 88:\ 641 case scm_tc3_struct + 96:\ 642 case scm_tc3_struct + 104:\ 643 case scm_tc3_struct + 112:\ 644 case scm_tc3_struct + 120 645 646 /* For closures 647 */ 648 #define scm_tcs_closures \ 649 scm_tc3_closure + 0:\ 650 case scm_tc3_closure + 8:\ 651 case scm_tc3_closure + 16:\ 652 case scm_tc3_closure + 24:\ 653 case scm_tc3_closure + 32:\ 654 case scm_tc3_closure + 40:\ 655 case scm_tc3_closure + 48:\ 656 case scm_tc3_closure + 56:\ 657 case scm_tc3_closure + 64:\ 658 case scm_tc3_closure + 72:\ 659 case scm_tc3_closure + 80:\ 660 case scm_tc3_closure + 88:\ 661 case scm_tc3_closure + 96:\ 662 case scm_tc3_closure + 104:\ 663 case scm_tc3_closure + 112:\ 664 case scm_tc3_closure + 120 665 666 /* For subrs 667 */ 668 #define scm_tcs_subrs \ 669 scm_tc7_asubr:\ 670 case scm_tc7_subr_0:\ 671 case scm_tc7_subr_1:\ 672 case scm_tc7_dsubr:\ 673 case scm_tc7_cxr:\ 674 case scm_tc7_subr_3:\ 675 case scm_tc7_subr_2:\ 676 case scm_tc7_rpsubr:\ 677 case scm_tc7_subr_1o:\ 678 case scm_tc7_subr_2o:\ 679 case scm_tc7_lsubr_2:\ 680 case scm_tc7_lsubr 681 682 683 684 #if (SCM_ENABLE_DEPRECATED == 1) 685 686 #define SCM_CELLP(x) (((sizeof (scm_t_cell) - 1) & SCM_UNPACK (x)) == 0) 687 #define SCM_NCELLP(x) (!SCM_CELLP (x)) 688 689 #endif 690 691 #endif /* SCM_TAGS_H */ 692 693 /* 694 Local Variables: 695 c-file-style: "gnu" 696 End: 697 */ 698