libguile/tags.h

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