X-Git-Url: http://git.hcoop.net/bpt/guile.git/blobdiff_plain/54778cd31205b1f50397cf7bf92f7d8b37c99870..cb1cfc42a4f5ac4d60a64b425795432a0388ad7e:/libguile/tags.h diff --git a/libguile/tags.h b/libguile/tags.h dissimilarity index 85% index 74317caaf..6a6c35233 100644 --- a/libguile/tags.h +++ b/libguile/tags.h @@ -1,604 +1,691 @@ -/* classes: h_files */ - -#ifndef TAGSH -#define TAGSH -/* Copyright (C) 1995, 96, 97, 98, 99, 2000 Free Software Foundation, Inc. - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2, or (at your option) - * any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this software; see the file COPYING. If not, write to - * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, - * Boston, MA 02111-1307 USA - * - * As a special exception, the Free Software Foundation gives permission - * for additional uses of the text contained in its release of GUILE. - * - * The exception is that, if you link the GUILE library with other files - * to produce an executable, this does not by itself cause the - * resulting executable to be covered by the GNU General Public License. - * Your use of that executable is in no way restricted on account of - * linking the GUILE library code into it. - * - * This exception does not however invalidate any other reasons why - * the executable file might be covered by the GNU General Public License. - * - * This exception applies only to the code released by the - * Free Software Foundation under the name GUILE. If you copy - * code from other Free Software Foundation releases into a copy of - * GUILE, as the General Public License permits, the exception does - * not apply to the code that you add in this way. To avoid misleading - * anyone as to the status of such modified files, you must delete - * this exception notice from them. - * - * If you write modifications of your own for GUILE, it is your choice - * whether to permit this exception to apply to your modifications. - * If you do not wish that, delete this exception notice. */ - -/* Software engineering face-lift by Greg J. Badros, 11-Dec-1999, - gjb@cs.washington.edu, http://www.cs.washington.edu/homes/gjb */ - - - -/** This file defines the format of SCM values and cons pairs. - ** It is here that tag bits are assigned for various purposes. - **/ - - - -/* #define SCM_STRICT_TYPING */ -/* #define SCM_VOIDP_TEST */ - -/* In the beginning was the Word: - */ -typedef long scm_bits_t; - -/* But as external interface, we use SCM, which may, according to the desired - * level of type checking, be defined in several ways: - */ -#if defined (SCM_STRICT_TYPING) -/* Use this for _compile time_ type checking only, since the compiled result - * will be quite inefficient. The right way to make use of this mode is to do - * a 'make clean' of your project, 'make all CFLAGS=-DSCM_STRICT_TYPING', fix - * your errors, and then do 'make clean; make all'. -*/ - typedef union { struct { scm_bits_t n; } n; } SCM; - static SCM scm_pack(scm_bits_t b) { SCM s; s.n.n = b; return s; } - #define SCM_UNPACK(x) ((x).n.n) - #define SCM_PACK(x) (scm_pack ((scm_bits_t) (x))) -#elif defined (SCM_VOIDP_TEST) -/* This is the default, which provides an intermediate level of compile time - * type checking while still resulting in very efficient code. - */ - typedef void * SCM; - #define SCM_UNPACK(x) ((scm_bits_t) (x)) - #define SCM_PACK(x) ((SCM) (x)) -#else -/* This should be used as a fall back solution for machines on which casting - * to a pointer may lead to loss of bit information, e. g. in the three least - * significant bits. - */ - typedef scm_bits_t SCM; - #define SCM_UNPACK(x) (x) - #define SCM_PACK(x) ((scm_bits_t) (x)) -#endif - - -/* SCM values can not be compared by using the operator ==. Use the following - * macro instead, which is the equivalent of the scheme predicate 'eq?'. - */ -#define SCM_EQ_P(x, y) (SCM_UNPACK (x) == SCM_UNPACK (y)) - - -/* SCM_UNPACK_CAR is a convenience for treating the CAR of X as a word */ -#define SCM_UNPACK_CAR(x) SCM_UNPACK (SCM_CAR (x)) - - - -/* SCM variables can contain: - * - * Non-objects -- meaning that the tag-related macros don't apply to them - * in the usual way. - * - * Immediates -- meaning that the variable contains an entire Scheme object. - * - * Non-immediates -- meaning that the variable holds a (possibly - * tagged) pointer into the cons pair heap. - * - * Non-objects are distinguished from other values by careful coding - * only (i.e., programmers must keep track of any SCM variables they - * create that don't contain ordinary scheme values). - * - * All immediates and non-immediates must have a 0 in bit 0. Only - * non-object values can have a 1 in bit 0. In some cases, bit 0 of a - * word in the heap is used for the GC tag so during garbage - * collection, that bit might be 1 even in an immediate or - * non-immediate value. In other cases, bit 0 of a word in the heap - * is used to tag a pointer to a GLOC (VM global variable address) or - * the header of a struct. But whenever an SCM variable holds a - * normal Scheme value, bit 0 is 0. - * - * Immediates and non-immediates are distinguished by bits two and four. - * Immediate values must have a 1 in at least one of those bits. Does - * this (or any other detail of tagging) seem arbitrary? Try changing it! - * (Not always impossible but it is fair to say that many details of tags - * are mutually dependent). */ - -#define SCM_IMP(x) (6 & SCM_UNPACK (x)) -#define SCM_NIMP(x) (!SCM_IMP (x)) - -/* Here is a summary of tagging in SCM values as they might occur in - * SCM variables or in the heap. - * - * low bits meaning - * - * - * 0 Most objects except... - * 1 ...glocs and structs (this tag valid only in a SCM_CAR or - * in the header of a struct's data). - * - * 00 heap addresses and many immediates (not integers) - * 01 glocs/structs, some tc7_ codes - * 10 immediate integers - * 11 various tc7_ codes including, tc16_ codes. - * - * - * 000 heap address - * 001 glocs/structs - * 010 integer - * 011 closure - * 100 immediates - * 101 tc7_ - * 110 integer - * 111 tc7_ - * - * - * 100 --- IMMEDIATES - * - * Looking at the seven final bits of an immediate: - * - * 0000-100 short instruction - * 0001-100 short instruction - * 0010-100 short instruction - * 0011-100 short instruction - * 0100-100 short instruction - * 0101-100 short instruction - * 0110-100 various immediates and long instructions - * 0111-100 short instruction - * 1000-100 short instruction - * 1001-100 short instruction - * 1010-100 short instruction - * 1011-100 short instruction - * 1100-100 short instruction - * 1101-100 short instruction - * 1110-100 immediate characters - * 1111-100 ilocs - * - * Some of the 0110100 immediates are long instructions (they dispatch - * in two steps compared to one step for a short instruction). - * The two steps are, (1) dispatch on 7 bits to the long instruction - * handler, (2) dispatch on 7 additional bits. - * - * One way to think of it is that there are 128 short instructions, - * with the 13 immediates above being some of the most interesting. - * - * Also noteworthy are the groups of 16 7-bit instructions implied by - * some of the 3-bit tags. For example, closure references consist - * of an 8-bit aligned address tagged with 011. There are 16 identical 7-bit - * instructions, all ending 011, which are invoked by evaluating closures. - * - * In other words, if you hand the evaluator a closure, the evaluator - * treats the closure as a graph of virtual machine instructions. - * A closure is a pair with a pointer to the body of the procedure - * in the CDR and a pointer to the environment of the closure in the CAR. - * The environment pointer is tagged 011 which implies that the least - * significant 7 bits of the environment pointer also happen to be - * a virtual machine instruction we could call "SELF" (for self-evaluating - * object). - * - * A less trivial example are the 16 instructions ending 000. If those - * bits tag the CAR of a pair, then evidently the pair is an ordinary - * cons pair and should be evaluated as a procedure application. The sixteen, - * 7-bit 000 instructions are all "NORMAL-APPLY" (Things get trickier. - * For example, if the CAR of a procedure application is a symbol, the NORMAL-APPLY - * instruction will, as a side effect, overwrite that CAR with a new instruction - * that contains a cached address for the variable named by the symbol.) - * - * Here is a summary of tags in the CAR of a non-immediate: - * - * HEAP CELL: G=gc_mark; 1 during mark, 0 other times. - * - * cons ..........SCM car..............0 ...........SCM cdr.............G - * gloc ..........SCM vcell..........001 ...........SCM cdr.............G - * struct ..........void * type........001 ...........void * data.........G - * closure ..........SCM code...........011 ...........SCM env.............G - * tc7 .........long length....Gxxxx1S1 ..........void *data............ - * - * - * - * 101 & 111 --- tc7_ types - * - * tc7_tags are 7 bit tags ending in 1x1. These tags - * occur only in the CAR of heap cells, and have the - * handy property that all bits of the CAR above the - * bottom eight can be used to store a length, thus - * saving a word in the body itself. Thus, we use them - * for strings, symbols, and vectors (among other - * things). - * - * SCM_LENGTH returns the bits in "length" (see the diagram). - * SCM_CHARS returns the data cast to "char *" - * SCM_CDR returns the data cast to "SCM" - * TYP7(X) returns bits 0...6 of SCM_CAR (X) - * - * For the interpretation of SCM_LENGTH and SCM_CHARS - * that applies to a particular type, see the header file - * for that type. - * - * Sometimes we choose the bottom seven bits carefully, - * so that the 2-valued bit (called S bit) can be masked - * off to reveal a common type. - * - * TYP7S(X) returns TYP7, but masking out the option bit S. - * - * For example, all strings have 0010 in the 'xxxx' bits - * in the diagram above, the S bit says whether it's a - * substring. - * - * for example: - * S - * scm_tc7_string = G0010101 - * scm_tc7_substring = G0010111 - * - * TYP7S turns both string tags into tc7_string; thus, - * testing TYP7S against tc7_string is a quick way to - * test for any kind of string, shared or unshared. - * - * Some TC7 types are subdivided into 256 subtypes giving - * rise to the macros: - * - * TYP16 - * TYP16S - * GCTYP16 - * - * TYP16S functions similarly wrt to TYP16 as TYP7S to TYP7, - * but a different option bit is used (bit 2 for TYP7S, - * bit 8 for TYP16S). - * */ - - - - -/* {Non-immediate values.} - * - * If X is non-immediate, it is necessary to look at SCM_CAR (X) to - * figure out Xs type. X may be a cons pair, in which case the value - * SCM_CAR (x) will be either an immediate or non-immediate value. X - * may be something other than a cons pair, in which case the value - * SCM_CAR (x) will be a non-object value. - * - * All immediates and non-immediates have a 0 in bit 0. We - * additionally preserve the invariant that all non-object values - * stored in the SCM_CAR of a non-immediate object have a 1 in bit 1: - */ - -#define SCM_SLOPPY_NCONSP(x) (1 & SCM_UNPACK_CAR (x)) -#define SCM_SLOPPY_CONSP(x) (!SCM_SLOPPY_NCONSP (x)) - -#define SCM_NCONSP(x) (SCM_IMP (x) || SCM_SLOPPY_NCONSP (x)) -#define SCM_CONSP(x) (SCM_NIMP (x) && SCM_SLOPPY_CONSP (x)) - - -/* SCM_ECONSP should be used instead of SCM_CONSP at places where GLOCS - * can be expected to occur. - */ -#define SCM_ECONSP(x) \ - (SCM_NIMP (x) \ - && (SCM_SLOPPY_CONSP (x) \ - || (SCM_TYP3 (x) == 1 \ - && (SCM_CDR ((SCM) SCM_STRUCT_VTABLE_DATA (x)) \ - != (SCM) 0)))) -#define SCM_NECONSP(x) \ - (SCM_IMP (x) \ - || (SCM_SLOPPY_NCONSP (x) \ - && (SCM_TYP3 (x) != 1 \ - || (SCM_CDR ((SCM) SCM_STRUCT_VTABLE_DATA (x)) \ - == (SCM) 0)))) - - - -#define SCM_CELLP(x) (!SCM_NCELLP (x)) -#define SCM_NCELLP(x) ((sizeof (scm_cell) - 1) & SCM_UNPACK (x)) - -#define SCM_DOUBLE_CELLP(x) (!SCM_NDOUBLE_CELLP (x)) -#define SCM_NDOUBLE_CELLP(x) ((2 * sizeof (scm_cell) - 1) & SCM_UNPACK (x)) - -/* See numbers.h for macros relating to immediate integers. - */ - -#define SCM_ITAG3(x) (7 & SCM_UNPACK (x)) -#define SCM_TYP3(x) (7 & SCM_UNPACK_CAR (x)) -#define scm_tc3_cons 0 -#define scm_tc3_cons_gloc 1 -#define scm_tc3_int_1 2 -#define scm_tc3_closure 3 -#define scm_tc3_imm24 4 -#define scm_tc3_tc7_1 5 -#define scm_tc3_int_2 6 -#define scm_tc3_tc7_2 7 - - -/* - * Do not change the three bit tags. - */ - - -#define SCM_TYP7(x) (0x7f & SCM_UNPACK_CAR (x)) -#define SCM_TYP7S(x) ((0x7f & ~2) & SCM_UNPACK_CAR (x)) - - -#define SCM_TYP16(x) (0xffff & SCM_UNPACK_CAR (x)) -#define SCM_TYP16S(x) (0xfeff & SCM_UNPACK_CAR (x)) -#define SCM_GCTYP16(x) (0xff7f & SCM_UNPACK_CAR (x)) - - - -/* Testing and Changing GC Marks in Various Standard Positions - */ -#define SCM_GCCDR(x) SCM_PACK(~1L & SCM_UNPACK (SCM_CDR (x))) -#define SCM_GCMARKP(x) (1 & SCM_UNPACK (SCM_CDR (x))) -#define SCM_GC8MARKP(x) (0x80 & SCM_UNPACK_CAR (x)) -#define SCM_SETGCMARK(x) SCM_SETOR_CDR (x, 1) -#define SCM_CLRGCMARK(x) SCM_SETAND_CDR (x, ~1L) -#define SCM_SETGC8MARK(x) SCM_SETOR_CAR (x, 0x80) -#define SCM_CLRGC8MARK(x) SCM_SETAND_CAR (x, ~0x80L) - - - - -/* couple */ -#define scm_tc7_ssymbol 5 -#define scm_tc7_msymbol 7 - -/* couple */ -#define scm_tc7_vector 13 -#define scm_tc7_wvect 15 - -/* couple */ -#define scm_tc7_string 21 -#define scm_tc7_substring 23 - -/* Many of the following should be turned - * into structs or smobs. We need back some - * of these 7 bit tags! - */ -#define scm_tc7_pws 31 -#define scm_tc7_lvector 39 - -#ifdef HAVE_ARRAYS -#define scm_tc7_llvect 29 -#define scm_tc7_uvect 37 -#define scm_tc7_fvect 45 -#define scm_tc7_dvect 47 -#define scm_tc7_cvect 53 -#define scm_tc7_svect 55 -#define scm_tc7_bvect 71 -#define scm_tc7_byvect 77 -#define scm_tc7_ivect 79 -#endif - -#define scm_tc7_contin 61 -#define scm_tc7_cclo 63 -#define scm_tc7_rpsubr 69 -#define scm_tc7_subr_0 85 -#define scm_tc7_subr_1 87 -#define scm_tc7_cxr 93 -#define scm_tc7_subr_3 95 -#define scm_tc7_subr_2 101 -#define scm_tc7_asubr 103 -#define scm_tc7_subr_1o 109 -#define scm_tc7_subr_2o 111 -#define scm_tc7_lsubr_2 117 -#define scm_tc7_lsubr 119 - - -/* There are 256 port subtypes. Here are the first few. - * These must agree with the init function in ports.c - */ -#define scm_tc7_port 125 - -#define scm_tc16_fport (scm_tc7_port + 0 * 256L) -/* scm_tc16_pipe was here. */ -#define scm_tc16_strport (scm_tc7_port + 2 * 256L) -#define scm_tc16_sfport (scm_tc7_port + 3 * 256L) - - -/* There are 256 smob subtypes. Here are the first four. - */ - -#define scm_tc7_smob 127 /* DO NOT CHANGE [**] */ - -/* [**] If you change scm_tc7_smob, you must also change - * the places it is hard coded in this file and possibly others. - */ - - -/* scm_tc_free_cell is also the 0th smob type. We place this - * in free cells to tell the conservative marker not to trace it. - */ -#define scm_tc_free_cell 0x007f - -/* Smob type 1 (note the dependency on the predicate SCM_NUMP) - */ -#define scm_tc16_big 0x017f - -/* Smob types 2 and 3: - */ -#define scm_tc16_real 0x027f -#define scm_tc16_complex 0x037f - -/* The following four macros are now deprecated: */ -#define scm_tc16_flo scm_tc16_real -#define scm_tc_flo 0x017fL -#define scm_tc_dblr scm_tc16_real -#define scm_tc_dblc scm_tc16_complex - -/* Smob type 4 allocated, but not initialized cells; - this is required to prevent the gc from hosing your cells if - you have to allocate while creating the cell*/ -#define scm_tc16_allocated 0x047f - - -/* {Immediate Values} - */ - -enum scm_tags -{ - scm_tc8_char = 0xf4, - scm_tc8_iloc = 0xfc -}; - -#define SCM_ITAG8(X) (SCM_UNPACK (X) & 0xff) -#define SCM_MAKE_ITAG8(X, TAG) SCM_PACK (((X) << 8) + TAG) -#define SCM_ITAG8_DATA(X) (SCM_UNPACK (X) >> 8) - - - -/* Immediate Symbols, Special Symbols, Flags (various constants). - */ - -/* SCM_ISYMP tests for ISPCSYM and ISYM */ -#define SCM_ISYMP(n) ((0x187 & SCM_UNPACK (n)) == 4) - -/* SCM_IFLAGP tests for ISPCSYM, ISYM and IFLAG */ -#define SCM_IFLAGP(n) ((0x87 & SCM_UNPACK (n)) == 4) -#define SCM_ISYMNUM(n) (SCM_UNPACK (n) >> 9) -#define SCM_ISYMCHARS(n) (scm_isymnames[SCM_ISYMNUM (n)]) -#define SCM_MAKSPCSYM(n) SCM_PACK (((n) << 9) + ((n) << 3) + 4L) -#define SCM_MAKISYM(n) SCM_PACK (((n) << 9) + 0x74L) -#define SCM_MAKIFLAG(n) SCM_PACK (((n) << 9) + 0x174L) - -extern char *scm_isymnames[]; /* defined in print.c */ - -/* This table must agree with the declarations - * in repl.c: {Names of immediate symbols}. - * - * These are used only in eval but their values - * have to be allocated here. - * - */ - -#define SCM_IM_AND SCM_MAKSPCSYM (0) -#define SCM_IM_BEGIN SCM_MAKSPCSYM (1) -#define SCM_IM_CASE SCM_MAKSPCSYM (2) -#define SCM_IM_COND SCM_MAKSPCSYM (3) -#define SCM_IM_DO SCM_MAKSPCSYM (4) -#define SCM_IM_IF SCM_MAKSPCSYM (5) -#define SCM_IM_LAMBDA SCM_MAKSPCSYM (6) -#define SCM_IM_LET SCM_MAKSPCSYM (7) -#define SCM_IM_LETSTAR SCM_MAKSPCSYM (8) -#define SCM_IM_LETREC SCM_MAKSPCSYM (9) -#define SCM_IM_OR SCM_MAKSPCSYM (10) -#define SCM_IM_QUOTE SCM_MAKSPCSYM (11) -#define SCM_IM_SET_X SCM_MAKSPCSYM (12) -#define SCM_IM_DEFINE SCM_MAKSPCSYM (13) -#define SCM_IM_APPLY SCM_MAKISYM (14) -#define SCM_IM_CONT SCM_MAKISYM (15) -#define SCM_BOOL_F SCM_MAKIFLAG (16) -#define SCM_BOOL_T SCM_MAKIFLAG (17) -#define SCM_UNDEFINED SCM_MAKIFLAG (18) -#define SCM_EOF_VAL SCM_MAKIFLAG (19) -#define SCM_EOL SCM_MAKIFLAG (20) -#define SCM_UNSPECIFIED SCM_MAKIFLAG (21) -#define SCM_IM_DISPATCH SCM_MAKISYM (22) -#define SCM_IM_SLOT_REF SCM_MAKISYM (23) -#define SCM_IM_SLOT_SET_X SCM_MAKISYM (24) - -/* Multi-language support */ - -#define SCM_IM_NIL_COND SCM_MAKISYM (25) -#define SCM_IM_NIL_IFY SCM_MAKISYM (26) -#define SCM_IM_T_IFY SCM_MAKISYM (27) -#define SCM_IM_0_COND SCM_MAKISYM (28) -#define SCM_IM_0_IFY SCM_MAKISYM (29) -#define SCM_IM_1_IFY SCM_MAKISYM (30) -#define SCM_IM_BIND SCM_MAKISYM (31) - -#define SCM_IM_DELAY SCM_MAKISYM (32) - -/* When a variable is unbound this is marked by the SCM_UNDEFINED - * value. The following is an unbound value which can be handled on - * the Scheme level, i.e., it can be stored in and retrieved from a - * Scheme variable. This value is only intended to mark an unbound - * slot in GOOPS. It is needed now, but we should probably rewrite - * the code which handles this value in C so that SCM_UNDEFINED can be - * used instead. It is not ideal to let this kind of unique and - * strange values loose on the Scheme level. - */ -#define SCM_UNBOUND SCM_MAKIFLAG (33) - -#define SCM_UNBNDP(x) (SCM_EQ_P ((x), SCM_UNDEFINED)) - - - -/* Dispatching aids: */ - - -/* For cons pairs with immediate values in the CAR - */ - -#define scm_tcs_cons_imcar 2:case 4:case 6:case 10:\ - case 12:case 14:case 18:case 20:\ - case 22:case 26:case 28:case 30:\ - case 34:case 36:case 38:case 42:\ - case 44:case 46:case 50:case 52:\ - case 54:case 58:case 60:case 62:\ - case 66:case 68:case 70:case 74:\ - case 76:case 78:case 82:case 84:\ - case 86:case 90:case 92:case 94:\ - case 98:case 100:case 102:case 106:\ - case 108:case 110:case 114:case 116:\ - case 118:case 122:case 124:case 126 - -/* For cons pairs with non-immediate values in the SCM_CAR - */ -#define scm_tcs_cons_nimcar 0:case 8:case 16:case 24:\ - case 32:case 40:case 48:case 56:\ - case 64:case 72:case 80:case 88:\ - case 96:case 104:case 112:case 120 - -/* A CONS_GLOC occurs in code. It's CAR is a pointer to the - * CDR of a variable. The low order bits of the CAR are 001. - * The CDR of the gloc is the code continuation. - */ -#define scm_tcs_cons_gloc 1:case 9:case 17:case 25:\ - case 33:case 41:case 49:case 57:\ - case 65:case 73:case 81:case 89:\ - case 97:case 105:case 113:case 121 - -#define scm_tcs_closures 3:case 11:case 19:case 27:\ - case 35:case 43:case 51:case 59:\ - case 67:case 75:case 83:case 91:\ - case 99:case 107:case 115:case 123 - -#define scm_tcs_subrs scm_tc7_asubr:case scm_tc7_subr_0:case scm_tc7_subr_1:case scm_tc7_cxr:\ - case scm_tc7_subr_3:case scm_tc7_subr_2:case scm_tc7_rpsubr:case scm_tc7_subr_1o:\ - case scm_tc7_subr_2o:case scm_tc7_lsubr_2:case scm_tc7_lsubr - -#define scm_tcs_symbols scm_tc7_ssymbol:case scm_tc7_msymbol - -#endif /* TAGSH */ - -/* - Local Variables: - c-file-style: "gnu" - End: -*/ +/* classes: h_files */ + +#ifndef SCM_TAGS_H +#define SCM_TAGS_H + +/* Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004 + * Free Software Foundation, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + + +/** This file defines the format of SCM values and cons pairs. + ** It is here that tag bits are assigned for various purposes. + **/ + +/* picks up scmconfig.h too */ +#include "libguile/__scm.h" + +#if HAVE_INTTYPES_H +# include /* for INTPTR_MAX and friends */ +#else +# if HAVE_STDINT_H +# include /* for INTPTR_MAX and friends */ +# endif +#endif + + + +/* In the beginning was the Word: + * + * For the representation of scheme objects and their handling, Guile provides + * two types: scm_t_bits and SCM. + * + * - scm_t_bits values can hold bit patterns of non-objects and objects: + * + * Non-objects -- in this case the value may not be changed into a SCM value + * in any way. + * + * Objects -- in this case the value may be changed into a SCM value using + * the SCM_PACK macro. + * + * - SCM values can hold proper scheme objects only. They can be changed into + * a scm_t_bits value using the SCM_UNPACK macro. + * + * When working in the domain of scm_t_bits values, programmers must keep + * track of any scm_t_bits value they create that is not a proper scheme + * object. This makes sure that in the domain of SCM values developers can + * rely on the fact that they are dealing with proper scheme objects only. + * Thus, the distinction between scm_t_bits and SCM values helps to identify + * those parts of the code where special care has to be taken not to create + * bad SCM values. + */ + +/* For dealing with the bit level representation of scheme objects we define + * scm_t_bits: + */ +/* On Solaris 7 and 8, /usr/include/sys/int_limits.h defines + INTPTR_MAX and UINTPTR_MAX to empty, INTPTR_MIN is not defined. + To avoid uintptr_t and intptr_t in this case we require + UINTPTR_MAX-0 != 0 etc. */ +#if SCM_SIZEOF_INTPTR_T != 0 && defined(INTPTR_MAX) && defined(INTPTR_MIN) \ + && INTPTR_MAX-0 != 0 && INTPTR_MIN-0 != 0 \ + && SCM_SIZEOF_UINTPTR_T != 0 && defined(UINTPTR_MAX) && UINTPTR_MAX-0 != 0 + +typedef intptr_t scm_t_signed_bits; +#define SCM_T_SIGNED_BITS_MAX INTPTR_MAX +#define SCM_T_SIGNED_BITS_MIN INTPTR_MIN +typedef uintptr_t scm_t_bits; +#define SIZEOF_SCM_T_BITS SCM_SIZEOF_UINTPTR_T +#define SCM_T_BITS_MAX UINTPTR_MAX + +#else + +typedef signed long scm_t_signed_bits; +#define SCM_T_SIGNED_BITS_MAX LONG_MAX +#define SCM_T_SIGNED_BITS_MIN LONG_MIN +typedef unsigned long scm_t_bits; +#define SIZEOF_SCM_T_BITS SCM_SIZEOF_UNSIGNED_LONG +#define SCM_T_BITS_MAX ULONG_MAX + +#endif + +/* But as external interface, we define SCM, which may, according to the + * desired level of type checking, be defined in several ways: + */ +#if (SCM_DEBUG_TYPING_STRICTNESS == 2) + typedef union { struct { scm_t_bits n; } n; } SCM; + static SCM scm_pack(scm_t_bits b) { SCM s; s.n.n = b; return s; } +# define SCM_UNPACK(x) ((x).n.n) +# define SCM_PACK(x) (scm_pack ((scm_t_bits) (x))) +#elif (SCM_DEBUG_TYPING_STRICTNESS == 1) +/* This is the default, which provides an intermediate level of compile time + * type checking while still resulting in very efficient code. + */ + typedef struct scm_unused_struct * SCM; + +/* + The 0?: constructions makes sure that the code is never executed, + and that there is no performance hit. However, the alternative is + compiled, and does generate a warning when used with the wrong + pointer type. + */ +# define SCM_UNPACK(x) ((scm_t_bits) (0? (*(SCM*)0=(x)): x)) + +/* + There is no typechecking on SCM_PACK, since all kinds of types + (unsigned long, void*) go in SCM_PACK + */ +# define SCM_PACK(x) ((SCM) (x)) + +#else +/* This should be used as a fall back solution for machines on which casting + * to a pointer may lead to loss of bit information, e. g. in the three least + * significant bits. + */ + typedef scm_t_bits SCM; +# define SCM_UNPACK(x) (x) +# define SCM_PACK(x) ((SCM) (x)) +#endif + + +/* SCM values can not be compared by using the operator ==. Use the following + * macro instead, which is the equivalent of the scheme predicate 'eq?'. + */ +#define scm_is_eq(x, y) (SCM_UNPACK (x) == SCM_UNPACK (y)) + + + +/* Representation of scheme objects: + * + * Guile's type system is designed to work on systems where scm_t_bits and SCM + * variables consist of at least 32 bits. The objects that a SCM variable can + * represent belong to one of the following two major categories: + * + * - Immediates -- meaning that the SCM variable contains an entire Scheme + * object. That means, all the object's data (including the type tagging + * information that is required to identify the object's type) must fit into + * 32 bits. + * + * - Non-immediates -- meaning that the SCM variable holds a pointer into the + * heap of cells (see below). On systems where a pointer needs more than 32 + * bits this means that scm_t_bits and SCM variables need to be large enough + * to hold such pointers. In contrast to immediates, the object's data of + * a non-immediate can consume arbitrary amounts of memory: The heap cell + * being pointed to consists of at least two scm_t_bits variables and thus + * can be used to hold pointers to malloc'ed memory of any size. + * + * The 'heap' is the memory area that is under control of Guile's garbage + * collector. It holds 'single-cells' or 'double-cells', which consist of + * either two or four scm_t_bits variables, respectively. It is guaranteed + * that the address of a cell on the heap is 8-byte aligned. That is, since + * non-immediates hold a cell address, the three least significant bits of a + * non-immediate can be used to store additional information. The bits are + * used to store information about the object's type and thus are called + * tc3-bits, where tc stands for type-code. + * + * For a given SCM value, the distinction whether it holds an immediate or + * non-immediate object is based on the tc3-bits (see above) of its scm_t_bits + * equivalent: If the tc3-bits equal #b000, then the SCM value holds a + * non-immediate, and the scm_t_bits variable's value is just the pointer to + * the heap cell. + * + * Summarized, the data of a scheme object that is represented by a SCM + * variable consists of a) the SCM variable itself, b) in case of + * non-immediates the data of the single-cell or double-cell the SCM object + * points to, c) in case of non-immediates potentially additional data outside + * of the heap (like for example malloc'ed data), and d) in case of + * non-immediates potentially additional data inside of the heap, since data + * stored in b) and c) may hold references to other cells. + * + * + * Immediates + * + * Operations on immediate objects can typically be processed faster than on + * non-immediates. The reason is that the object's data can be extracted + * directly from the SCM variable (or rather a corresponding scm_t_bits + * variable), instead of having to perform additional memory accesses to + * obtain the object's data from the heap. In order to get the best possible + * performance frequently used data types should be realized as immediates. + * This is, as has been mentioned above, only possible if the objects can be + * represented with 32 bits (including type tagging). + * + * In Guile, the following data types and special objects are realized as + * immediates: booleans, characters, small integers (see below), the empty + * list, the end of file object, the 'unspecified' object (which is delivered + * as a return value by functions for which the return value is unspecified), + * a 'nil' object used in the elisp-compatibility mode and certain other + * 'special' objects which are only used internally in Guile. + * + * Integers in Guile can be arbitrarily large. On the other hand, integers + * are one of the most frequently used data types. Especially integers with + * less than 32 bits are commonly used. Thus, internally and transparently + * for application code guile distinguishes between small and large integers. + * Whether an integer is a large or a small integer depends on the number of + * bits needed to represent its value. Small integers are those which can be + * represented as immediates. Since they don't require more than a fixed + * number of bits for their representation, they are also known as 'fixnums'. + * + * The tc3-combinations #b010 and #b110 are used to represent small integers, + * which allows to use the most significant bit of the tc3-bits to be part of + * the integer value being represented. This means that all integers with up + * to 30 bits (including one bit for the sign) can be represented as + * immediates. On systems where SCM and scm_t_bits variables hold more than + * 32 bits, the amount of bits usable for small integers will even be larger. + * The tc3-code #b100 is shared among booleans, characters and the other + * special objects listed above. + * + * + * Non-Immediates + * + * All object types not mentioned above in the list of immedate objects are + * represented as non-immediates. Whether a non-immediate scheme object is + * represented by a single-cell or a double-cell depends on the object's type, + * namely on the set of attributes that have to be stored with objects of that + * type. Every non-immediate type is allowed to define its own layout and + * interpretation of the data stored in its cell (with some restrictions, see + * below). + * + * One of the design goals of guile's type system is to make it possible to + * store a scheme pair with as little memory usage as possible. The minimum + * amount of memory that is required to store two scheme objects (car and cdr + * of a pair) is the amount of memory required by two scm_t_bits or SCM + * variables. Therefore pairs in guile are stored in single-cells. + * + * Another design goal for the type system is to store procedure objects + * created by lambda expresssions (closures) and class instances (goops + * objects) with as little memory usage as possible. Closures are represented + * by a reference to the function code and a reference to the closure's + * environment. Class instances are represented by a reference to the + * instance's class definition and a reference to the instance's data. Thus, + * closures as well as class instances also can be stored in single-cells. + * + * Certain other non-immediate types also store their data in single-cells. + * By design decision, the heap is split into areas for single-cells and + * double-cells, but not into areas for single-cells-holding-pairs and areas + * for single-cells-holding-non-pairs. Any single-cell on the heap therefore + * can hold pairs (consisting of two scm_t_bits variables representing two + * scheme objects - the car and cdr of the pair) and non-pairs (consisting of + * two scm_t_bits variables that hold bit patterns as defined by the layout of + * the corresponding object's type). + * + * + * Garbage collection + * + * During garbage collection, unreachable cells on the heap will be freed. + * That is, the garbage collector will detect cells which have no SCM variable + * pointing towards them. In order to properly release all memory belonging + * to the object to which a cell belongs, the gc needs to be able to interpret + * the cell contents in the correct way. That means that the gc needs to be + * able to determine the object type associated with a cell only from the cell + * itself. + * + * Consequently, if the gc detects an unreachable single-cell, those two + * scm_t_bits variables must provide enough information to determine whether + * they belong to a pair (i. e. both scm_t_bits variables represent valid + * scheme objects), to a closure, a class instance or if they belong to any + * other non-immediate. Guile's type system is designed to make it possible + * to determine a the type to which a cell belongs in the majority of cases + * from the cell's first scm_t_bits variable. (Given a SCM variable X holding + * a non-immediate object, the macro SCM_CELL_TYPE(X) will deliver the + * corresponding cell's first scm_t_bits variable.) + * + * If the cell holds a scheme pair, then we already know that the first + * scm_t_bits variable of the cell will hold a scheme object with one of the + * following tc3-codes: #b000 (non-immediate), #b010 (small integer), #b100 + * (small integer), #b110 (non-integer immediate). All these tc3-codes have + * in common, that their least significant bit is #b0. This fact is used by + * the garbage collector to identify cells that hold pairs. The remaining + * tc3-codes are assigned as follows: #b001 (class instance or, more + * precisely, a struct, of which a class instance is a special case), #b011 + * (closure), #b101/#b111 (all remaining non-immediate types). + * + * + * Summary of type codes of scheme objects (SCM variables) + * + * Here is a summary of tagging bits as they might occur in a scheme object. + * The notation is as follows: tc stands for type code as before, tc with n + * being a number indicates a type code formed by the n least significant bits + * of the SCM variables corresponding scm_t_bits value. + * + * Note that (as has been explained above) tc1==1 can only occur in the first + * scm_t_bits variable of a cell belonging to a non-immediate object that is + * not a pair. For an explanation of the tc tags with tc1==1, see the next + * section with the summary of the type codes on the heap. + * + * tc1: + * 0: For scheme objects, tc1==0 must be fulfilled. + * (1: This can never be the case for a scheme object.) + * + * tc2: + * 00: Either a non-immediate or some non-integer immediate + * (01: This can never be the case for a scheme object.) + * 10: Small integer + * (11: This can never be the case for a scheme object.) + * + * tc3: + * 000: a non-immediate object (pair, closure, class instance etc.) + * (001: This can never be the case for a scheme object.) + * 010: an even small integer (least significant bit is 0). + * (011: This can never be the case for a scheme object.) + * 100: Non-integer immediate + * (101: This can never be the case for a scheme object.) + * 110: an odd small integer (least significant bit is 1). + * (111: This can never be the case for a scheme object.) + * + * The remaining bits of the non-immediate objects form the pointer to the + * heap cell. The remaining bits of the small integers form the integer's + * value and sign. Thus, the only scheme objects for which a further + * subdivision is of interest are the ones with tc3==100. + * + * tc8 (for objects with tc3==100): + * 00000-100: special objects ('flags') + * 00001-100: characters + * 00010-100: evaluator byte codes ('isyms') + * 00011-100: evaluator byte codes ('ilocs') + * + * + * Summary of type codes on the heap + * + * Here is a summary of tagging in scm_t_bits values as they might occur in + * the first scm_t_bits variable of a heap cell. + * + * tc1: + * 0: the cell belongs to a pair. + * 1: the cell belongs to a non-pair. + * + * tc2: + * 00: the cell belongs to a pair with no short integer in its car. + * 01: the cell belongs to a non-pair (struct or some other non-immediate). + * 10: the cell belongs to a pair with a short integer in its car. + * 11: the cell belongs to a non-pair (closure or some other non-immediate). + * + * tc3: + * 000: the cell belongs to a pair with a non-immediate in its car. + * 001: the cell belongs to a struct + * 010: the cell belongs to a pair with an even short integer in its car. + * 011: the cell belongs to a closure + * 100: the cell belongs to a pair with a non-integer immediate in its car. + * 101: the cell belongs to some other non-immediate. + * 110: the cell belongs to a pair with an odd short integer in its car. + * 111: the cell belongs to some other non-immediate. + * + * tc7 (for tc3==1x1): + * See below for the list of types. Note the special case of scm_tc7_vector + * and scm_tc7_wvect: vectors and weak vectors are treated the same in many + * cases. Thus, their tc7-codes are chosen to only differ in one bit. This + * makes it possible to check an object at the same time for being a vector + * or a weak vector by comparing its tc7 code with that bit masked (using + * the TYP7S macro). Three more special tc7-codes are of interest: + * numbers, ports and smobs in fact each represent collections of types, + * which are subdivided using tc16-codes. + * + * tc16 (for tc7==scm_tc7_smob): + * The largest part of the space of smob types is not subdivided in a + * predefined way, since smobs can be added arbitrarily by user C code. + * However, while Guile also defines a number of smob types throughout, + * there is one smob type, namely scm_tc_free_cell, for which Guile assumes + * that it is declared first and thus gets a known-in-advance tc16-code. + * The reason of requiring a fixed tc16-code for this type is performance. + */ + + + +/* Checking if a SCM variable holds an immediate or a non-immediate object: + * This check can either be performed by checking for tc3==000 or tc3==00x, + * since for a SCM variable it is known that tc1==0. */ +#define SCM_IMP(x) (6 & SCM_UNPACK (x)) +#define SCM_NIMP(x) (!SCM_IMP (x)) + +/* Checking if a SCM variable holds an immediate integer: See numbers.h for + * the definition of the following macros: SCM_I_FIXNUM_BIT, + * SCM_MOST_POSITIVE_FIXNUM, SCM_I_INUMP, SCM_I_MAKINUM, SCM_I_INUM. */ + +/* Checking if a SCM variable holds a pair (for historical reasons, in Guile + * also known as a cons-cell): This is done by first checking that the SCM + * variable holds a non-immediate, and second, by checking that tc1==0 holds + * for the SCM_CELL_TYPE of the SCM variable. +*/ + +#define SCM_I_CONSP(x) (!SCM_IMP (x) && ((1 & SCM_CELL_TYPE (x)) == 0)) + + + +/* Definitions for tc2: */ + +#define scm_tc2_int 2 + + +/* Definitions for tc3: */ + +#define SCM_ITAG3(x) (7 & SCM_UNPACK (x)) +#define SCM_TYP3(x) (7 & SCM_CELL_TYPE (x)) + +#define scm_tc3_cons 0 +#define scm_tc3_struct 1 +#define scm_tc3_int_1 (scm_tc2_int + 0) +#define scm_tc3_closure 3 +#define scm_tc3_imm24 4 +#define scm_tc3_tc7_1 5 +#define scm_tc3_int_2 (scm_tc2_int + 4) +#define scm_tc3_tc7_2 7 + + +/* Definitions for tc7: */ + +#define SCM_ITAG7(x) (127 & SCM_UNPACK (x)) +#define SCM_TYP7(x) (0x7f & SCM_CELL_TYPE (x)) +#define SCM_TYP7S(x) ((0x7f & ~2) & SCM_CELL_TYPE (x)) + +#define scm_tc7_symbol 5 +#define scm_tc7_variable 7 + +/* couple */ +#define scm_tc7_vector 13 +#define scm_tc7_wvect 15 + +#define scm_tc7_string 21 +#define scm_tc7_number 23 +#define scm_tc7_stringbuf 39 + +/* Many of the following should be turned + * into structs or smobs. We need back some + * of these 7 bit tags! */ + +#define scm_tc7_pws 31 + +#define scm_tc7_unused_1 29 +#define scm_tc7_unused_2 37 +#define scm_tc7_unused_3 45 +#define scm_tc7_unused_4 47 +#define scm_tc7_unused_5 53 +#define scm_tc7_unused_6 55 +#define scm_tc7_unused_7 71 +#define scm_tc7_unused_8 77 +#define scm_tc7_unused_9 79 + +#define scm_tc7_dsubr 61 +#define scm_tc7_cclo 63 +#define scm_tc7_rpsubr 69 +#define scm_tc7_subr_0 85 +#define scm_tc7_subr_1 87 +#define scm_tc7_cxr 93 +#define scm_tc7_subr_3 95 +#define scm_tc7_subr_2 101 +#define scm_tc7_asubr 103 +#define scm_tc7_subr_1o 109 +#define scm_tc7_subr_2o 111 +#define scm_tc7_lsubr_2 117 +#define scm_tc7_lsubr 119 + +/* There are 256 port subtypes. */ +#define scm_tc7_port 125 + +/* There are 256 smob subtypes. [**] If you change scm_tc7_smob, you must + * also change the places it is hard coded in this file and possibly others. + * Dirk:FIXME:: Any hard coded reference to scm_tc7_smob must be replaced by a + * symbolic reference. */ +#define scm_tc7_smob 127 /* DO NOT CHANGE [**] */ + + +/* Definitions for tc16: */ +#define SCM_TYP16(x) (0xffff & SCM_CELL_TYPE (x)) +#define SCM_TYP16_PREDICATE(tag, x) (!SCM_IMP (x) && SCM_TYP16 (x) == (tag)) + + +/* Here is the first smob subtype. */ + +/* scm_tc_free_cell is the 0th smob type. We place this in free cells to tell + * the conservative marker not to trace it. */ +#define scm_tc_free_cell (scm_tc7_smob + 0 * 256L) + + + +/* {Immediate Values} + */ + +enum scm_tc8_tags +{ + scm_tc8_flag = scm_tc3_imm24 + 0x00, /* special objects ('flags') */ + scm_tc8_char = scm_tc3_imm24 + 0x08, /* characters */ + scm_tc8_isym = scm_tc3_imm24 + 0x10, /* evaluator byte codes ('isyms') */ + scm_tc8_iloc = scm_tc3_imm24 + 0x18 /* evaluator byte codes ('ilocs') */ +}; + +#define SCM_ITAG8(X) (SCM_UNPACK (X) & 0xff) +#define SCM_MAKE_ITAG8(X, TAG) SCM_PACK (((X) << 8) + TAG) +#define SCM_ITAG8_DATA(X) (SCM_UNPACK (X) >> 8) + + + +/* Flags (special objects). The indices of the flags must agree with the + * declarations in print.c: iflagnames. */ + +#define SCM_IFLAGP(n) (SCM_ITAG8 (n) == scm_tc8_flag) +#define SCM_MAKIFLAG(n) SCM_MAKE_ITAG8 ((n), scm_tc8_flag) +#define SCM_IFLAGNUM(n) (SCM_ITAG8_DATA (n)) + +#define SCM_BOOL_F SCM_MAKIFLAG (0) +#define SCM_BOOL_T SCM_MAKIFLAG (1) +#define SCM_UNDEFINED SCM_MAKIFLAG (2) +#define SCM_EOF_VAL SCM_MAKIFLAG (3) +#define SCM_EOL SCM_MAKIFLAG (4) +#define SCM_UNSPECIFIED SCM_MAKIFLAG (5) + +/* When a variable is unbound this is marked by the SCM_UNDEFINED + * value. The following is an unbound value which can be handled on + * the Scheme level, i.e., it can be stored in and retrieved from a + * Scheme variable. This value is only intended to mark an unbound + * slot in GOOPS. It is needed now, but we should probably rewrite + * the code which handles this value in C so that SCM_UNDEFINED can be + * used instead. It is not ideal to let this kind of unique and + * strange values loose on the Scheme level. */ +#define SCM_UNBOUND SCM_MAKIFLAG (6) + +/* The Elisp nil value. */ +#define SCM_ELISP_NIL SCM_MAKIFLAG (7) + + +#define SCM_UNBNDP(x) (scm_is_eq ((x), SCM_UNDEFINED)) + + + +/* Evaluator byte codes ('immediate symbols'). These constants are used only + * in eval but their values have to be allocated here. The indices of the + * SCM_IM_ symbols must agree with the declarations in print.c: + * scm_isymnames. */ + +#define SCM_ISYMP(n) (SCM_ITAG8 (n) == scm_tc8_isym) +#define SCM_MAKISYM(n) SCM_MAKE_ITAG8 ((n), scm_tc8_isym) + +#define SCM_IM_AND SCM_MAKISYM (0) +#define SCM_IM_BEGIN SCM_MAKISYM (1) +#define SCM_IM_CASE SCM_MAKISYM (2) +#define SCM_IM_COND SCM_MAKISYM (3) +#define SCM_IM_DO SCM_MAKISYM (4) +#define SCM_IM_IF SCM_MAKISYM (5) +#define SCM_IM_LAMBDA SCM_MAKISYM (6) +#define SCM_IM_LET SCM_MAKISYM (7) +#define SCM_IM_LETSTAR SCM_MAKISYM (8) +#define SCM_IM_LETREC SCM_MAKISYM (9) +#define SCM_IM_OR SCM_MAKISYM (10) +#define SCM_IM_QUOTE SCM_MAKISYM (11) +#define SCM_IM_SET_X SCM_MAKISYM (12) +#define SCM_IM_DEFINE SCM_MAKISYM (13) +#define SCM_IM_APPLY SCM_MAKISYM (14) +#define SCM_IM_CONT SCM_MAKISYM (15) +#define SCM_IM_DISPATCH SCM_MAKISYM (16) +#define SCM_IM_SLOT_REF SCM_MAKISYM (17) +#define SCM_IM_SLOT_SET_X SCM_MAKISYM (18) +#define SCM_IM_DELAY SCM_MAKISYM (19) +#define SCM_IM_FUTURE SCM_MAKISYM (20) +#define SCM_IM_CALL_WITH_VALUES SCM_MAKISYM (21) +#define SCM_IM_ELSE SCM_MAKISYM (22) +#define SCM_IM_ARROW SCM_MAKISYM (23) +#define SCM_IM_NIL_COND SCM_MAKISYM (24) /* Multi-language support */ +#define SCM_IM_BIND SCM_MAKISYM (25) /* Multi-language support */ + + + +/* Dispatching aids: + + When switching on SCM_TYP7 of a SCM value, use these fake case + labels to catch types that use fewer than 7 bits for tagging. */ + +/* For cons pairs with immediate values in the CAR + */ + +#define scm_tcs_cons_imcar \ + scm_tc2_int + 0: case scm_tc2_int + 4: case scm_tc3_imm24 + 0:\ + case scm_tc2_int + 8: case scm_tc2_int + 12: case scm_tc3_imm24 + 8:\ + case scm_tc2_int + 16: case scm_tc2_int + 20: case scm_tc3_imm24 + 16:\ + case scm_tc2_int + 24: case scm_tc2_int + 28: case scm_tc3_imm24 + 24:\ + case scm_tc2_int + 32: case scm_tc2_int + 36: case scm_tc3_imm24 + 32:\ + case scm_tc2_int + 40: case scm_tc2_int + 44: case scm_tc3_imm24 + 40:\ + case scm_tc2_int + 48: case scm_tc2_int + 52: case scm_tc3_imm24 + 48:\ + case scm_tc2_int + 56: case scm_tc2_int + 60: case scm_tc3_imm24 + 56:\ + case scm_tc2_int + 64: case scm_tc2_int + 68: case scm_tc3_imm24 + 64:\ + case scm_tc2_int + 72: case scm_tc2_int + 76: case scm_tc3_imm24 + 72:\ + case scm_tc2_int + 80: case scm_tc2_int + 84: case scm_tc3_imm24 + 80:\ + case scm_tc2_int + 88: case scm_tc2_int + 92: case scm_tc3_imm24 + 88:\ + case scm_tc2_int + 96: case scm_tc2_int + 100: case scm_tc3_imm24 + 96:\ + case scm_tc2_int + 104: case scm_tc2_int + 108: case scm_tc3_imm24 + 104:\ + case scm_tc2_int + 112: case scm_tc2_int + 116: case scm_tc3_imm24 + 112:\ + case scm_tc2_int + 120: case scm_tc2_int + 124: case scm_tc3_imm24 + 120 + +/* For cons pairs with non-immediate values in the SCM_CAR + */ +#define scm_tcs_cons_nimcar \ + scm_tc3_cons + 0:\ + case scm_tc3_cons + 8:\ + case scm_tc3_cons + 16:\ + case scm_tc3_cons + 24:\ + case scm_tc3_cons + 32:\ + case scm_tc3_cons + 40:\ + case scm_tc3_cons + 48:\ + case scm_tc3_cons + 56:\ + case scm_tc3_cons + 64:\ + case scm_tc3_cons + 72:\ + case scm_tc3_cons + 80:\ + case scm_tc3_cons + 88:\ + case scm_tc3_cons + 96:\ + case scm_tc3_cons + 104:\ + case scm_tc3_cons + 112:\ + case scm_tc3_cons + 120 + +/* For structs + */ +#define scm_tcs_struct \ + scm_tc3_struct + 0:\ + case scm_tc3_struct + 8:\ + case scm_tc3_struct + 16:\ + case scm_tc3_struct + 24:\ + case scm_tc3_struct + 32:\ + case scm_tc3_struct + 40:\ + case scm_tc3_struct + 48:\ + case scm_tc3_struct + 56:\ + case scm_tc3_struct + 64:\ + case scm_tc3_struct + 72:\ + case scm_tc3_struct + 80:\ + case scm_tc3_struct + 88:\ + case scm_tc3_struct + 96:\ + case scm_tc3_struct + 104:\ + case scm_tc3_struct + 112:\ + case scm_tc3_struct + 120 + +/* For closures + */ +#define scm_tcs_closures \ + scm_tc3_closure + 0:\ + case scm_tc3_closure + 8:\ + case scm_tc3_closure + 16:\ + case scm_tc3_closure + 24:\ + case scm_tc3_closure + 32:\ + case scm_tc3_closure + 40:\ + case scm_tc3_closure + 48:\ + case scm_tc3_closure + 56:\ + case scm_tc3_closure + 64:\ + case scm_tc3_closure + 72:\ + case scm_tc3_closure + 80:\ + case scm_tc3_closure + 88:\ + case scm_tc3_closure + 96:\ + case scm_tc3_closure + 104:\ + case scm_tc3_closure + 112:\ + case scm_tc3_closure + 120 + +/* For subrs + */ +#define scm_tcs_subrs \ + scm_tc7_asubr:\ + case scm_tc7_subr_0:\ + case scm_tc7_subr_1:\ + case scm_tc7_dsubr:\ + case scm_tc7_cxr:\ + case scm_tc7_subr_3:\ + case scm_tc7_subr_2:\ + case scm_tc7_rpsubr:\ + case scm_tc7_subr_1o:\ + case scm_tc7_subr_2o:\ + case scm_tc7_lsubr_2:\ + case scm_tc7_lsubr + + + +#if (SCM_ENABLE_DEPRECATED == 1) + +#define SCM_CELLP(x) (((sizeof (scm_t_cell) - 1) & SCM_UNPACK (x)) == 0) +#define SCM_NCELLP(x) (!SCM_CELLP (x)) + +#endif + +#endif /* SCM_TAGS_H */ + +/* + Local Variables: + c-file-style: "gnu" + End: +*/