libguile/__scm.h

   1 /* classes: h_files */
   2
   3 #ifndef SCM___SCM_H
   4 #define SCM___SCM_H
   5
   6 /* Copyright (C) 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2006,
   7  *   2007, 2008, 2009, 2010, 2011, 2012, 2013 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 /**********************************************************************
  28  This file is Guile's central public header.
  29
  30  When included by other files, this file should preceed any include
  31  other than __scm.h.
  32
  33  Under *NO* circumstances should new items be added to the global
  34  namespace (via adding #define, typedef, or similar to this file) with
  35  generic names.  This usually means that any new names should be
  36  prefixed by either SCM_ or GUILE_.  i.e. do *not* #define HAVE_FOO or
  37  SIZEOF_BAR.  See configure.in, gen-scmconfig.h.in, and
  38  gen-scmconfig.c for examples of how to properly handle this issue.
  39  The main documentation is in gen-scmconfig.c.
  40
  41  "What's the difference between _scm.h and __scm.h?"
  42
  43    _scm.h is not installed; it's only visible to the libguile sources
  44    themselves, and it includes config.h, the private config header.
  45
  46    __scm.h is installed, and is #included by <libguile.h>.  If both
  47    the client and libguile need some piece of information, and it
  48    doesn't fit well into the header file for any particular module, it
  49    should go in __scm.h.  __scm.h includes scmconfig.h, the public
  50    config header.
  51  **********************************************************************/
  52
  53 /* What did the configure script discover about the outside world?  */
  54 #include "libguile/scmconfig.h"
  55
  56 \f
  57
  58 /* {Compiler hints}
  59  *
  60  * The following macros are used to provide additional information for the
  61  * compiler, which may help to do better error checking and code
  62  * optimization.  A second benefit of these macros is, that they also provide
  63  * additional information to the developers.
  64  */
  65
  66 /* Return true (non-zero) if GCC version MAJ.MIN or later is being used
  67  * (macro taken from glibc.)  */
  68 #if defined __GNUC__ && defined __GNUC_MINOR__
  69 # define SCM_GNUC_PREREQ(maj, min) \
  70         ((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min))
  71 #else
  72 # define SCM_GNUC_PREREQ(maj, min) 0
  73 #endif
  74
  75 /* The macro SCM_NORETURN indicates that a function will never return.
  76  * Examples:
  77  *   1) int foo (char arg) SCM_NORETURN;
  78  */
  79 #ifdef __GNUC__
  80 #define SCM_NORETURN __attribute__ ((__noreturn__))
  81 #else
  82 #define SCM_NORETURN
  83 #endif
  84
  85 /* The macro SCM_UNUSED indicates that a function, function argument or
  86  * variable may potentially be unused.
  87  * Examples:
  88  *   1) static int unused_function (char arg) SCM_UNUSED;
  89  *   2) int foo (char unused_argument SCM_UNUSED);
  90  *   3) int unused_variable SCM_UNUSED;
  91  */
  92 #ifdef __GNUC__
  93 #define SCM_UNUSED __attribute__ ((unused))
  94 #else
  95 #define SCM_UNUSED
  96 #endif
  97
  98
  99 /* The SCM_EXPECT macros provide branch prediction hints to the compiler.  To
 100  * use only in places where the result of the expression under "normal"
 101  * circumstances is known.  */
 102 #if SCM_GNUC_PREREQ (3, 0)
 103 # define SCM_EXPECT    __builtin_expect
 104 #else
 105 # define SCM_EXPECT(_expr, _value) (_expr)
 106 #endif
 107
 108 #define SCM_LIKELY(_expr)    SCM_EXPECT ((_expr), 1)
 109 #define SCM_UNLIKELY(_expr)  SCM_EXPECT ((_expr), 0)
 110
 111 /* The SCM_INTERNAL macro makes it possible to explicitly declare a function
 112  * as having "internal" linkage.  However our current tack on this problem is
 113  * to use GCC 4's -fvisibility=hidden, making functions internal by default,
 114  * and then SCM_API marks them for export. */
 115 #define SCM_INTERNAL  extern
 116
 117 /* The SCM_DEPRECATED macro is used in declarations of deprecated functions
 118  * or variables.  Defining `SCM_BUILDING_DEPRECATED_CODE' allows deprecated
 119  * functions to be implemented in terms of deprecated functions, and allows
 120  * deprecated functions to be referred to by `scm_c_define_gsubr ()'.  */
 121 #if !defined (SCM_BUILDING_DEPRECATED_CODE) && SCM_GNUC_PREREQ (3, 0)
 122 # define SCM_DEPRECATED  SCM_API __attribute__ ((__deprecated__))
 123 #else
 124 # define SCM_DEPRECATED  SCM_API
 125 #endif
 126
 127 /* The SCM_ALIGNED macro, when defined, can be used to instruct the compiler
 128  * to honor the given alignment constraint.  */
 129 /* Sun Studio supports alignment since Sun Studio 12 */
 130 #if defined __GNUC__ || (defined( __SUNPRO_C ) && (__SUNPRO_C - 0 >= 0x590))
 131 # define SCM_ALIGNED(x)  __attribute__ ((aligned (x)))
 132 #elif defined __INTEL_COMPILER
 133 # define SCM_ALIGNED(x)  __declspec (align (x))
 134 #else
 135 /* Don't know how to align things.  */
 136 # undef SCM_ALIGNED
 137 #endif
 138
 139 /* The SCM_MALLOC macro can be used in function declarations to tell the
 140  * compiler that a function may be treated as if any non-NULL pointer it returns
 141  * cannot alias any other pointer valid when the function returns.  */
 142 #if SCM_GNUC_PREREQ (3, 0)
 143 # define SCM_MALLOC  __attribute__ ((__malloc__))
 144 #else
 145 # define SCM_MALLOC
 146 #endif
 147
 148 \f
 149 /* {Supported Options}
 150  *
 151  * These may be defined or undefined.
 152  */
 153
 154 /* #define GUILE_DEBUG_FREELIST */
 155
 156
 157 /* Use engineering notation when converting numbers strings?
 158  */
 159 #undef ENGNOT
 160
 161 \f
 162 /* {Unsupported Options}
 163  *
 164  * These must be defined as given here.
 165  */
 166
 167
 168 /* Guile Scheme supports the #f/() distinction; Guile Lisp won't.  We
 169    have horrible plans for their unification.  */
 170 #undef SICP
 171
 172 \f
 173
 174 /* Random options (not yet supported or in final form). */
 175
 176 #define STACK_CHECKING
 177 #undef NO_CEVAL_STACK_CHECKING
 178
 179 \f
 180
 181 /* SCM_API is a macro prepended to all function and data definitions
 182    which should be exported from libguile. */
 183
 184 #if defined BUILDING_LIBGUILE && defined HAVE_VISIBILITY
 185 # define SCM_API extern __attribute__((__visibility__("default")))
 186 #elif defined BUILDING_LIBGUILE && defined _MSC_VER
 187 # define SCM_API __declspec(dllexport) extern
 188 #elif defined _MSC_VER
 189 # define SCM_API __declspec(dllimport) extern
 190 #else
 191 # define SCM_API extern
 192 #endif
 193
 194 \f
 195
 196 /* We would like gnu89 extern inline semantics, not C99 extern inline
 197    semantics, so that we can be sure to avoid reifying definitions of
 198    inline functions in all compilation units, which is a possibility at
 199    low optimization levels, or if a user takes the address of an inline
 200    function.
 201
 202    Hence the `__gnu_inline__' attribute, in accordance with:
 203    http://gcc.gnu.org/gcc-4.3/porting_to.html .
 204
 205    With GCC 4.2, `__GNUC_STDC_INLINE__' is never defined (because C99 inline
 206    semantics are not supported), but a warning is issued in C99 mode if
 207    `__gnu_inline__' is not used.
 208
 209    Apple's GCC build >5400 (since Xcode 3.0) doesn't support GNU inline in
 210    C99 mode and doesn't define `__GNUC_STDC_INLINE__'.  Fall back to "static
 211    inline" in that case.  */
 212
 213 # if (defined __GNUC__) && (!(((defined __APPLE_CC__) && (__APPLE_CC__ > 5400)) && __STDC_VERSION__ >= 199901L))
 214 #  if (defined __GNUC_STDC_INLINE__) || (__GNUC__ == 4 && __GNUC_MINOR__ == 2)
 215 #   define SCM_C_EXTERN_INLINE                                  \
 216            extern __inline__ __attribute__ ((__gnu_inline__))
 217 #  else
 218 #   define SCM_C_EXTERN_INLINE extern __inline__
 219 #  endif
 220 # endif
 221
 222 /* SCM_INLINE is a macro prepended to all public inline function
 223    declarations.  Implementations of those functions should also be in
 224    the header file, prefixed by SCM_INLINE_IMPLEMENTATION, and protected
 225    by SCM_CAN_INLINE and a CPP define for the C file in question, like
 226    SCM_INLINE_C_INCLUDING_INLINE_H.  See inline.h for an example
 227    usage.  */
 228
 229 #if defined SCM_IMPLEMENT_INLINES
 230 /* Reifying functions to a file, whether or not inlining is available.  */
 231 # define SCM_CAN_INLINE 0
 232 # define SCM_INLINE SCM_API
 233 # define SCM_INLINE_IMPLEMENTATION
 234 #elif defined SCM_C_INLINE
 235 /* Declarations when inlining is available.  */
 236 # define SCM_CAN_INLINE 1
 237 # ifdef SCM_C_EXTERN_INLINE
 238 #  define SCM_INLINE SCM_C_EXTERN_INLINE
 239 # else
 240 /* Fall back to static inline if GNU "extern inline" is unavailable.  */
 241 #  define SCM_INLINE static SCM_C_INLINE
 242 # endif
 243 # define SCM_INLINE_IMPLEMENTATION SCM_INLINE
 244 #else
 245 /* Declarations when inlining is not available.  */
 246 # define SCM_CAN_INLINE 0
 247 # define SCM_INLINE SCM_API
 248 /* Don't define SCM_INLINE_IMPLEMENTATION; it should never be seen in
 249    this case.  */
 250 #endif
 251
 252 \f
 253
 254 /* {Debugging Options}
 255  *
 256  * These compile time options determine whether to include code that is only
 257  * useful for debugging guile itself or C level extensions to guile.  The
 258  * common prefix for all option macros of this kind is "SCM_DEBUG_".  It is
 259  * guaranteed that a macro named SCM_DEBUG_XXX is always defined (typically to
 260  * either 0 or 1), i. e. there is no need to test for the undefined case.
 261  * This allows to use these definitions comfortably within code, as in the
 262  * following example:
 263  *   #define FOO do { if (SCM_DEBUG_XXX) bar(); else baz(); } while (0)
 264  * Any sane compiler will remove the unused branch without any performance
 265  * penalty for the resulting code.
 266  *
 267  * Note:  Some SCM_DEBUG_XXX options are not settable at configure time.
 268  * To change the value of such options you will have to edit this header
 269  * file or give suitable options to make, like:
 270  *   make all CFLAGS="-DSCM_DEBUG_XXX=1 ..."
 271  */
 272
 273
 274 /* The value of SCM_DEBUG determines the default for most of the not yet
 275  * defined debugging options.  This allows, for example, to enable most of the
 276  * debugging options by simply defining SCM_DEBUG as 1.
 277  */
 278 #ifndef SCM_DEBUG
 279 #define SCM_DEBUG 0
 280 #endif
 281
 282 /* For debugging purposes: define this is to ensure nobody is using
 283  * the mark bits outside of the marking phase.  This is meant for
 284  * debugging purposes only.
 285  */
 286 #ifndef SCM_DEBUG_MARKING_API
 287 #define SCM_DEBUG_MARKING_API 0
 288 #endif
 289
 290 /* If SCM_DEBUG_CELL_ACCESSES is set to 1, cell accesses will perform
 291  * exhaustive parameter checking:  It will be verified that cell parameters
 292  * actually point to a valid heap cell.  Note:  If this option is enabled,
 293  * guile will run about ten times slower than normally.
 294  */
 295 #ifndef SCM_DEBUG_CELL_ACCESSES
 296 #define SCM_DEBUG_CELL_ACCESSES SCM_DEBUG
 297 #endif
 298
 299 /* If SCM_DEBUG_INTERRUPTS is set to 1, with every deferring and allowing of
 300  * interrupts a consistency check will be performed.
 301  */
 302 #ifndef SCM_DEBUG_INTERRUPTS
 303 #define SCM_DEBUG_INTERRUPTS SCM_DEBUG
 304 #endif
 305
 306 /* If SCM_DEBUG_PAIR_ACCESSES is set to 1, accesses to cons cells will be
 307  * exhaustively checked.  Note:  If this option is enabled, guile will run
 308  * slower than normally.
 309  */
 310 #ifndef SCM_DEBUG_PAIR_ACCESSES
 311 #define SCM_DEBUG_PAIR_ACCESSES SCM_DEBUG
 312 #endif
 313
 314 /* If SCM_DEBUG_REST_ARGUMENT is set to 1, functions that take rest arguments
 315  * will check whether the rest arguments are actually passed as a proper list.
 316  * Otherwise, if SCM_DEBUG_REST_ARGUMENT is 0, functions that take rest
 317  * arguments will take it for granted that these are passed as a proper list.
 318  */
 319 #ifndef SCM_DEBUG_REST_ARGUMENT
 320 #define SCM_DEBUG_REST_ARGUMENT SCM_DEBUG
 321 #endif
 322
 323 /* The macro SCM_DEBUG_TYPING_STRICTNESS indicates what level of type checking
 324  * shall be performed with respect to the use of the SCM datatype.  The macro
 325  * may be defined to one of the values 0, 1 and 2.
 326  *
 327  * A value of 0 means that there will be no compile time type checking, since
 328  * the SCM datatype will be declared as an integral type.  This setting should
 329  * only be used on systems, where casting from integral types to pointers may
 330  * lead to loss of bit information.
 331  *
 332  * A value of 1 means that there will an intermediate level of compile time
 333  * type checking, since the SCM datatype will be declared as a pointer to an
 334  * undefined struct.  This setting is the default, since it does not cost
 335  * anything in terms of performance or code size.
 336  *
 337  * A value of 2 provides a maximum level of compile time type checking since
 338  * the SCM datatype will be declared as a struct.  This setting should be used
 339  * for _compile time_ type checking only, since the compiled result is likely
 340  * to be quite inefficient.  The right way to make use of this option is to do
 341  * a 'make clean; make CFLAGS=-DSCM_DEBUG_TYPING_STRICTNESS=2', fix your
 342  * errors, and then do 'make clean; make'.
 343  */
 344 #ifndef SCM_DEBUG_TYPING_STRICTNESS
 345 #define SCM_DEBUG_TYPING_STRICTNESS 1
 346 #endif
 347
 348 /* If SCM_DEBUG_DEBUGGING_SUPPORT is set to 1, guile will provide a set of
 349  * special functions that support debugging with a debugger like gdb or
 350  * debugging of guile internals on the scheme level.  The behaviour of guile
 351  * is not changed by this macro, only the set of functions that are available
 352  * will differ.  All functions that are introduced this way have the prefix
 353  * 'scm_dbg_' on the C level and the prefix 'dbg-' on the scheme level.  This
 354  * allows to easily determine the set of support functions, given that your
 355  * debugger or repl provide automatic name completion.  Note that these
 356  * functions are intended to be used during interactive debugging sessions
 357  * only.  They are not considered part of guile's official API.  They may
 358  * change or disappear without notice or deprecation phase.
 359  */
 360 #ifndef SCM_DEBUG_DEBUGGING_SUPPORT
 361 #define SCM_DEBUG_DEBUGGING_SUPPORT SCM_DEBUG
 362 #endif
 363
 364 \f
 365
 366 /* {Feature Options}
 367  *
 368  * These compile time options determine whether code for certain features
 369  * should be compiled into guile.  The common prefix for all option macros
 370  * of this kind is "SCM_ENABLE_".  It is guaranteed that a macro named
 371  * SCM_ENABLE_XXX is defined to be either 0 or 1, i. e. there is no need to
 372  * test for the undefined case.  This allows to use these definitions
 373  * comfortably within code, as in the following example:
 374  *   #define FOO do { if (SCM_ENABLE_XXX) bar(); else baz(); } while (0)
 375  * Any sane compiler will remove the unused branch without any performance
 376  * penalty for the resulting code.
 377  *
 378  * Note:  Some SCM_ENABLE_XXX options are not settable at configure time.
 379  * To change the value of such options you will have to edit this header
 380  * file or give suitable options to make, like:
 381  *   make all CFLAGS="-DSCM_ENABLE_XXX=1 ..."
 382  */
 383
 384 /* If SCM_ENABLE_DEPRECATED is set to 1, deprecated code will be included in
 385  * guile, as well as some functions to issue run-time warnings about uses of
 386  * deprecated functions.
 387  */
 388 #ifndef SCM_ENABLE_DEPRECATED
 389 #define SCM_ENABLE_DEPRECATED 0
 390 #endif
 391
 392 \f
 393
 394 /* {Architecture and compiler properties}
 395  *
 396  * Guile as of today can only work on systems which fulfill at least the
 397  * following requirements:
 398  *
 399  * - scm_t_bits and SCM variables have at least 32 bits.
 400  *   Guile's type system is based on this assumption.
 401  *
 402  * - sizeof (scm_t_bits) >= sizeof (void*) and sizeof (SCM) >= sizeof (void*)
 403  *   Guile's type system is based on this assumption, since it must be
 404  *   possible to store pointers to cells on the heap in scm_t_bits and SCM
 405  *   variables.
 406  *
 407  * - sizeof (scm_t_bits) >= 4 and sizeof (scm_t_bits) is a power of 2.
 408  *   Guile's type system is based on this assumption.  In particular, it is
 409  *   assumed that cells, i. e. pairs of scm_t_bits variables, are eight
 410  *   character aligned.  This is because three bits of a scm_t_bits variable
 411  *   that is holding a pointer to a cell on the heap must be available for
 412  *   storing type data.
 413  *
 414  * - sizeof (scm_t_bits) <= sizeof (void*) and sizeof (SCM) <= sizeof (void*)
 415  *   In some parts of guile, scm_t_bits and SCM variables are passed to
 416  *   functions as void* arguments.  Together with the requirement above, this
 417  *   requires a one-to-one correspondence between the size of a void* and the
 418  *   sizes of scm_t_bits and SCM variables.
 419  *
 420  * - numbers are encoded using two's complement.
 421  *   The implementation of the bitwise scheme level operations is based on
 422  *   this assumption.
 423  *
 424  * - ... add more
 425  */
 426
 427 #ifdef CHAR_BIT
 428 # define SCM_CHAR_BIT CHAR_BIT
 429 #else
 430 # define SCM_CHAR_BIT 8
 431 #endif
 432
 433 #ifdef LONG_BIT
 434 # define SCM_LONG_BIT LONG_BIT
 435 #else
 436 # define SCM_LONG_BIT (SCM_SIZEOF_LONG * 8)
 437 #endif
 438
 439 #define SCM_I_UTYPE_MAX(type)      ((type)-1)
 440 #define SCM_I_TYPE_MAX(type,umax)  ((type)((umax)/2))
 441 #define SCM_I_TYPE_MIN(type,umax)  (-((type)((umax)/2))-1)
 442
 443 #define SCM_T_UINT8_MAX   SCM_I_UTYPE_MAX(scm_t_uint8)
 444 #define SCM_T_INT8_MIN    SCM_I_TYPE_MIN(scm_t_int8,SCM_T_UINT8_MAX)
 445 #define SCM_T_INT8_MAX    SCM_I_TYPE_MAX(scm_t_int8,SCM_T_UINT8_MAX)
 446
 447 #define SCM_T_UINT16_MAX  SCM_I_UTYPE_MAX(scm_t_uint16)
 448 #define SCM_T_INT16_MIN   SCM_I_TYPE_MIN(scm_t_int16,SCM_T_UINT16_MAX)
 449 #define SCM_T_INT16_MAX   SCM_I_TYPE_MAX(scm_t_int16,SCM_T_UINT16_MAX)
 450
 451 #define SCM_T_UINT32_MAX  SCM_I_UTYPE_MAX(scm_t_uint32)
 452 #define SCM_T_INT32_MIN   SCM_I_TYPE_MIN(scm_t_int32,SCM_T_UINT32_MAX)
 453 #define SCM_T_INT32_MAX   SCM_I_TYPE_MAX(scm_t_int32,SCM_T_UINT32_MAX)
 454
 455 #define SCM_T_UINT64_MAX  SCM_I_UTYPE_MAX(scm_t_uint64)
 456 #define SCM_T_INT64_MIN   SCM_I_TYPE_MIN(scm_t_int64,SCM_T_UINT64_MAX)
 457 #define SCM_T_INT64_MAX   SCM_I_TYPE_MAX(scm_t_int64,SCM_T_UINT64_MAX)
 458
 459 #if SCM_SIZEOF_LONG_LONG
 460 #define SCM_I_ULLONG_MAX  SCM_I_UTYPE_MAX(unsigned long long)
 461 #define SCM_I_LLONG_MIN   SCM_I_TYPE_MIN(long long,SCM_I_ULLONG_MAX)
 462 #define SCM_I_LLONG_MAX   SCM_I_TYPE_MAX(long long,SCM_I_ULLONG_MAX)
 463 #endif
 464
 465 #define SCM_T_UINTMAX_MAX SCM_I_UTYPE_MAX(scm_t_uintmax)
 466 #define SCM_T_INTMAX_MIN  SCM_I_TYPE_MIN(scm_t_intmax,SCM_T_UINTMAX_MAX)
 467 #define SCM_T_INTMAX_MAX  SCM_I_TYPE_MAX(scm_t_intmax,SCM_T_UINTMAX_MAX)
 468
 469 #define SCM_T_UINTPTR_MAX SCM_I_UTYPE_MAX(scm_t_uintptr)
 470 #define SCM_T_INTPTR_MIN  SCM_I_TYPE_MIN(scm_t_intptr,SCM_T_UINTPTR_MAX)
 471 #define SCM_T_INTPTR_MAX  SCM_I_TYPE_MAX(scm_t_intptr,SCM_T_UINTPTR_MAX)
 472
 473 #define SCM_I_SIZE_MAX    SCM_I_UTYPE_MAX(size_t)
 474 #define SCM_I_SSIZE_MIN   SCM_I_TYPE_MIN(ssize_t,SCM_I_SIZE_MAX)
 475 #define SCM_I_SSIZE_MAX   SCM_I_TYPE_MAX(ssize_t,SCM_I_SIZE_MAX)
 476
 477 \f
 478
 479 #include "libguile/tags.h"
 480
 481
 482 /* The type of subrs, i.e., Scheme procedures implemented in C.  Empty
 483    function declarators are used internally for pointers to functions of
 484    any arity.  However, these are equivalent to `(void)' in C++, are
 485    obsolescent as of C99, and trigger `strict-prototypes' GCC warnings
 486    (bug #23681).  */
 487
 488 #ifdef BUILDING_LIBGUILE
 489 typedef SCM (* scm_t_subr) ();
 490 #else
 491 typedef void *scm_t_subr;
 492 #endif
 493
 494 \f
 495 #ifdef vms
 496 # ifndef CHEAP_CONTINUATIONS
 497    typedef int jmp_buf[17];
 498    extern int setjump(jmp_buf env);
 499    extern int longjump(jmp_buf env, int ret);
 500 #  define setjmp setjump
 501 #  define longjmp longjump
 502 # else
 503 #  include <setjmp.h>
 504 # endif
 505 #else                           /* ndef vms */
 506 # ifdef _CRAY1
 507     typedef int jmp_buf[112];
 508     extern int setjump(jmp_buf env);
 509     extern int longjump(jmp_buf env, int ret);
 510 #  define setjmp setjump
 511 #  define longjmp longjump
 512 # else                          /* ndef _CRAY1 */
 513 #  if defined (__ia64__)
 514 /* For IA64, emulate the setjmp API using getcontext. */
 515 #   include <signal.h>
 516 #   include <ucontext.h>
 517     typedef struct {
 518       ucontext_t ctx;
 519       int fresh;
 520     } scm_i_jmp_buf;
 521 #   define SCM_I_SETJMP(JB)                             \
 522       ( (JB).fresh = 1,                                 \
 523         getcontext (&((JB).ctx)),                       \
 524         ((JB).fresh ? ((JB).fresh = 0, 0) : 1) )
 525 #   define SCM_I_LONGJMP(JB,VAL) scm_ia64_longjmp (&(JB), VAL)
 526     void scm_ia64_longjmp (scm_i_jmp_buf *, int);
 527 #  else                         /* ndef __ia64__ */
 528 #   include <setjmp.h>
 529 #  endif                        /* ndef __ia64__ */
 530 # endif                         /* ndef _CRAY1 */
 531 #endif                          /* ndef vms */
 532
 533 /* For any platform where SCM_I_SETJMP hasn't been defined in some
 534    special way above, map SCM_I_SETJMP, SCM_I_LONGJMP and
 535    scm_i_jmp_buf to setjmp, longjmp and jmp_buf. */
 536 #ifndef SCM_I_SETJMP
 537 #define scm_i_jmp_buf jmp_buf
 538 #define SCM_I_SETJMP setjmp
 539 #define SCM_I_LONGJMP longjmp
 540 #endif
 541
 542 /* James Clark came up with this neat one instruction fix for
 543  * continuations on the SPARC.  It flushes the register windows so
 544  * that all the state of the process is contained in the stack.
 545  */
 546
 547 #if defined (sparc) || defined (__sparc__) || defined (__sparc)
 548 # define SCM_FLUSH_REGISTER_WINDOWS asm("ta 3")
 549 #else
 550 # define SCM_FLUSH_REGISTER_WINDOWS /* empty */
 551 #endif
 552
 553 /* If stack is not longword aligned then
 554  */
 555
 556 /* #define SHORT_ALIGN */
 557 #ifdef THINK_C
 558 # define SHORT_ALIGN
 559 #endif
 560 #ifdef MSDOS
 561 # define SHORT_ALIGN
 562 #endif
 563 #ifdef atarist
 564 # define SHORT_ALIGN
 565 #endif
 566
 567 #ifdef SHORT_ALIGN
 568 typedef short SCM_STACKITEM;
 569 #else
 570 typedef long SCM_STACKITEM;
 571 #endif
 572
 573 /* Cast pointer through (void *) in order to avoid compiler warnings
 574    when strict aliasing is enabled */
 575 #define SCM_STACK_PTR(ptr) ((SCM_STACKITEM *) (void *) (ptr))
 576 \f
 577
 578 SCM_API void scm_async_tick (void);
 579
 580 #ifdef BUILDING_LIBGUILE
 581
 582 /* FIXME: should change names */
 583 # define SCM_ASYNC_TICK                                                 \
 584     do                                                                  \
 585       {                                                                 \
 586         if (SCM_UNLIKELY (SCM_I_CURRENT_THREAD->pending_asyncs))        \
 587           scm_async_click ();                                           \
 588       }                                                                 \
 589     while (0)
 590
 591 /* SCM_ASYNC_TICK_WITH_CODE is only available to Guile itself */
 592 # define SCM_ASYNC_TICK_WITH_CODE(thr, stmt)                            \
 593     do                                                                  \
 594       {                                                                 \
 595         if (SCM_UNLIKELY (thr->pending_asyncs))                         \
 596           {                                                             \
 597             stmt;                                                       \
 598             scm_async_click ();                                         \
 599           }                                                             \
 600       }                                                                 \
 601     while (0)
 602
 603 #else /* !BUILDING_LIBGUILE */
 604
 605 # define SCM_ASYNC_TICK  (scm_async_tick ())
 606
 607 #endif /* !BUILDING_LIBGUILE */
 608
 609
 610 /* Anthony Green writes:
 611    When the compiler sees...
 612            DEFER_INTS;
 613            [critical code here]
 614            ALLOW_INTS;
 615    ...it doesn't actually promise to keep the critical code within the
 616    boundries of the DEFER/ALLOW_INTS instructions. It may very well
 617    schedule it outside of the magic defined in those macros.
 618
 619    However, GCC's volatile asm feature forms a barrier over which code is
 620    never moved. So if you add...
 621            asm ("");
 622    ...to each of the DEFER_INTS and ALLOW_INTS macros, the critical
 623    code will always remain in place.  asm's without inputs or outputs
 624    are implicitly volatile. */
 625 #ifdef __GNUC__
 626 #define SCM_FENCE asm /* volatile */ ("")
 627 #elif defined (__INTEL_COMPILER) && defined (__ia64)
 628 #define SCM_FENCE __memory_barrier()
 629 #else
 630 #define SCM_FENCE
 631 #endif
 632
 633 #define SCM_TICK \
 634 do { \
 635   SCM_ASYNC_TICK; \
 636   SCM_THREAD_SWITCHING_CODE; \
 637 } while (0)
 638
 639 \f
 640
 641 /** SCM_ASSERT
 642  **
 643  **/
 644
 645
 646 #ifdef SCM_RECKLESS
 647 #define SCM_ASSERT(_cond, _arg, _pos, _subr)
 648 #define SCM_ASSERT_TYPE(_cond, _arg, _pos, _subr, _msg)
 649 #else
 650 #define SCM_ASSERT(_cond, _arg, _pos, _subr)                    \
 651         do { if (SCM_UNLIKELY (!(_cond)))                       \
 652           scm_wrong_type_arg (_subr, _pos, _arg); } while (0)
 653 #define SCM_ASSERT_TYPE(_cond, _arg, _pos, _subr, _msg)                 \
 654         do { if (SCM_UNLIKELY (!(_cond)))                               \
 655           scm_wrong_type_arg_msg(_subr, _pos, _arg, _msg);  } while (0)
 656 #endif
 657
 658 /*
 659  * SCM_WTA_DISPATCH
 660  */
 661
 662 /* Dirk:FIXME:: In all of the SCM_WTA_DISPATCH_* macros it is assumed that
 663  * 'gf' is zero if uninitialized.  It would be cleaner if some valid SCM value
 664  * like SCM_BOOL_F or SCM_UNDEFINED was chosen.
 665  */
 666
 667 SCM_API SCM scm_call_generic_0 (SCM gf);
 668
 669 #define SCM_WTA_DISPATCH_0(gf, subr)                            \
 670   return (SCM_UNPACK (gf)                                       \
 671           ? scm_call_generic_0 ((gf))                           \
 672           : (scm_error_num_args_subr ((subr)), SCM_UNSPECIFIED))
 673 #define SCM_GASSERT0(cond, gf, subr)            \
 674   if (SCM_UNLIKELY(!(cond)))            \
 675     SCM_WTA_DISPATCH_0((gf), (subr))
 676
 677 SCM_API SCM scm_call_generic_1 (SCM gf, SCM a1);
 678
 679 #define SCM_WTA_DISPATCH_1(gf, a1, pos, subr)                   \
 680   return (SCM_UNPACK (gf)                                       \
 681           ? scm_call_generic_1 ((gf), (a1))                     \
 682           : (scm_wrong_type_arg ((subr), (pos), (a1)), SCM_UNSPECIFIED))
 683
 684 /* This form is for dispatching a subroutine.  */
 685 #define SCM_WTA_DISPATCH_1_SUBR(subr, a1, pos)                          \
 686   return (SCM_UNPACK ((*SCM_SUBR_GENERIC (subr)))                       \
 687           ? scm_call_generic_1 ((*SCM_SUBR_GENERIC (subr)), (a1))       \
 688           : (scm_i_wrong_type_arg_symbol (SCM_SUBR_NAME (subr), (pos), (a1)), SCM_UNSPECIFIED))
 689
 690 #define SCM_GASSERT1(cond, gf, a1, pos, subr)           \
 691   if (SCM_UNLIKELY (!(cond)))                   \
 692     SCM_WTA_DISPATCH_1((gf), (a1), (pos), (subr))
 693
 694 SCM_API SCM scm_call_generic_2 (SCM gf, SCM a1, SCM a2);
 695
 696 #define SCM_WTA_DISPATCH_2(gf, a1, a2, pos, subr)                       \
 697   return (SCM_UNPACK (gf)                                               \
 698           ? scm_call_generic_2 ((gf), (a1), (a2))                       \
 699           : (scm_wrong_type_arg ((subr), (pos),                         \
 700                                  (pos) == SCM_ARG1 ? (a1) : (a2)),      \
 701              SCM_UNSPECIFIED))
 702 #define SCM_GASSERT2(cond, gf, a1, a2, pos, subr)       \
 703   if (SCM_UNLIKELY (!(cond)))                   \
 704     SCM_WTA_DISPATCH_2((gf), (a1), (a2), (pos), (subr))
 705
 706 SCM_API SCM scm_apply_generic (SCM gf, SCM args);
 707
 708 #define SCM_WTA_DISPATCH_n(gf, args, pos, subr)                           \
 709   return (SCM_UNPACK (gf)                                                 \
 710           ? scm_apply_generic ((gf), (args))                              \
 711           : (scm_wrong_type_arg ((subr), (pos),                           \
 712                                  scm_list_ref ((args),                    \
 713                                                scm_from_int ((pos) - 1))), \
 714              SCM_UNSPECIFIED))
 715 #define SCM_GASSERTn(cond, gf, args, pos, subr)         \
 716   if (SCM_UNLIKELY (!(cond)))                   \
 717     SCM_WTA_DISPATCH_n((gf), (args), (pos), (subr))
 718
 719 #ifndef SCM_MAGIC_SNARFER
 720 /* Let these macros pass through if
 721    we are snarfing;  thus we can tell the
 722    difference between the use of an actual
 723    number vs. the use of one of these macros --
 724    actual numbers in SCM_VALIDATE_* and SCM_ASSERT
 725    constructs must match the formal argument name,
 726    but using SCM_ARG* avoids the test */
 727
 728 #define SCM_ARGn                0
 729 #define SCM_ARG1                1
 730 #define SCM_ARG2                2
 731 #define SCM_ARG3                3
 732 #define SCM_ARG4                4
 733 #define SCM_ARG5                5
 734 #define SCM_ARG6                6
 735 #define SCM_ARG7                7
 736
 737 #endif /* SCM_MAGIC_SNARFER */
 738
 739 \f
 740
 741 /* SCM_EXIT_SUCCESS is the default code to return from SCM if no errors
 742  * were encountered.  SCM_EXIT_FAILURE is the default code to return from
 743  * SCM if errors were encountered.  The return code can be explicitly
 744  * specified in a SCM program with (scm_quit <n>).
 745  */
 746
 747 #ifndef SCM_EXIT_SUCCESS
 748 #ifdef vms
 749 #define SCM_EXIT_SUCCESS 1
 750 #else
 751 #define SCM_EXIT_SUCCESS 0
 752 #endif /* def vms */
 753 #endif /* ndef SCM_EXIT_SUCCESS */
 754 #ifndef SCM_EXIT_FAILURE
 755 #ifdef vms
 756 #define SCM_EXIT_FAILURE 2
 757 #else
 758 #define SCM_EXIT_FAILURE 1
 759 #endif /* def vms */
 760 #endif /* ndef SCM_EXIT_FAILURE */
 761
 762 /* Define SCM_C_INLINE_KEYWORD so that it can be used as a replacement
 763    for the "inline" keyword, expanding to nothing when "inline" is not
 764    available.
 765 */
 766
 767 #ifdef SCM_C_INLINE
 768 #define SCM_C_INLINE_KEYWORD SCM_C_INLINE
 769 #else
 770 #define SCM_C_INLINE_KEYWORD
 771 #endif
 772
 773 /* Handling thread-local storage (TLS).  */
 774
 775 #ifdef SCM_HAVE_THREAD_STORAGE_CLASS
 776 # define SCM_THREAD_LOCAL __thread
 777 #else
 778 # define SCM_THREAD_LOCAL
 779 #endif
 780
 781 #endif  /* SCM___SCM_H */
 782
 783 /*
 784   Local Variables:
 785   c-file-style: "gnu"
 786   End:
 787 */