6 /* Copyright (C) 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2006,
7 * 2007, 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
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.
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.
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
27 /**********************************************************************
28 This file is Guile's central public header.
30 When included by other files, this file should preceed any include
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.
41 "What's the difference between _scm.h and __scm.h?"
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.
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
51 **********************************************************************/
53 /* What did the configure script discover about the outside world? */
54 #include "libguile/scmconfig.h"
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.
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))
72 # define SCM_GNUC_PREREQ(maj, min) 0
75 /* The macro SCM_NORETURN indicates that a function will never return.
77 * 1) int foo (char arg) SCM_NORETURN;
80 #define SCM_NORETURN __attribute__ ((noreturn))
85 /* The macro SCM_UNUSED indicates that a function, function argument or
86 * variable may potentially be unused.
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;
93 #define SCM_UNUSED __attribute__ ((unused))
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
105 # define SCM_EXPECT(_expr, _value) (_expr)
108 #define SCM_LIKELY(_expr) SCM_EXPECT ((_expr), 1)
109 #define SCM_UNLIKELY(_expr) SCM_EXPECT ((_expr), 0)
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
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__))
124 # define SCM_DEPRECATED SCM_API
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))
135 /* Don't know how to align things. */
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__))
149 /* {Supported Options}
151 * These may be defined or undefined.
154 /* #define GUILE_DEBUG_FREELIST */
157 /* Use engineering notation when converting numbers strings?
162 /* {Unsupported Options}
164 * These must be defined as given here.
168 /* Guile Scheme supports the #f/() distinction; Guile Lisp won't. We
169 have horrible plans for their unification. */
174 /* Random options (not yet supported or in final form). */
176 #define STACK_CHECKING
177 #undef NO_CEVAL_STACK_CHECKING
181 /* SCM_API is a macro prepended to all function and data definitions
182 which should be exported from libguile. */
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
191 # define SCM_API extern
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
202 Hence the `__gnu_inline__' attribute, in accordance with:
203 http://gcc.gnu.org/gcc-4.3/porting_to.html .
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.
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. */
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__))
218 # define SCM_C_EXTERN_INLINE extern __inline__
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
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
240 /* Fall back to static inline if GNU "extern inline" is unavailable. */
241 # define SCM_INLINE static SCM_C_INLINE
243 # define SCM_INLINE_IMPLEMENTATION SCM_INLINE
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
254 /* {Debugging Options}
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
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.
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 ..."
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.
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.
286 #ifndef SCM_DEBUG_MARKING_API
287 #define SCM_DEBUG_MARKING_API 0
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.
295 #ifndef SCM_DEBUG_CELL_ACCESSES
296 #define SCM_DEBUG_CELL_ACCESSES SCM_DEBUG
299 /* If SCM_DEBUG_INTERRUPTS is set to 1, with every deferring and allowing of
300 * interrupts a consistency check will be performed.
302 #ifndef SCM_DEBUG_INTERRUPTS
303 #define SCM_DEBUG_INTERRUPTS SCM_DEBUG
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.
310 #ifndef SCM_DEBUG_PAIR_ACCESSES
311 #define SCM_DEBUG_PAIR_ACCESSES SCM_DEBUG
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.
319 #ifndef SCM_DEBUG_REST_ARGUMENT
320 #define SCM_DEBUG_REST_ARGUMENT SCM_DEBUG
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.
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.
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.
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'.
344 #ifndef SCM_DEBUG_TYPING_STRICTNESS
345 #define SCM_DEBUG_TYPING_STRICTNESS 1
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.
360 #ifndef SCM_DEBUG_DEBUGGING_SUPPORT
361 #define SCM_DEBUG_DEBUGGING_SUPPORT SCM_DEBUG
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.
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 ..."
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.
388 #ifndef SCM_ENABLE_DEPRECATED
389 #define SCM_ENABLE_DEPRECATED 0
394 /* {Architecture and compiler properties}
396 * Guile as of today can only work on systems which fulfill at least the
397 * following requirements:
399 * - scm_t_bits and SCM variables have at least 32 bits.
400 * Guile's type system is based on this assumption.
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
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
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.
420 * - numbers are encoded using two's complement.
421 * The implementation of the bitwise scheme level operations is based on
428 # define SCM_CHAR_BIT CHAR_BIT
430 # define SCM_CHAR_BIT 8
434 # define SCM_LONG_BIT LONG_BIT
436 # define SCM_LONG_BIT (SCM_CHAR_BIT * sizeof (long) / sizeof (char))
440 # define SCM_CHAR_CODE_LIMIT (UCHAR_MAX + 1L)
442 # define SCM_CHAR_CODE_LIMIT 256L
445 #define SCM_I_UTYPE_MAX(type) ((type)-1)
446 #define SCM_I_TYPE_MAX(type,umax) ((type)((umax)/2))
447 #define SCM_I_TYPE_MIN(type,umax) (-((type)((umax)/2))-1)
449 #define SCM_T_UINT8_MAX SCM_I_UTYPE_MAX(scm_t_uint8)
450 #define SCM_T_INT8_MIN SCM_I_TYPE_MIN(scm_t_int8,SCM_T_UINT8_MAX)
451 #define SCM_T_INT8_MAX SCM_I_TYPE_MAX(scm_t_int8,SCM_T_UINT8_MAX)
453 #define SCM_T_UINT16_MAX SCM_I_UTYPE_MAX(scm_t_uint16)
454 #define SCM_T_INT16_MIN SCM_I_TYPE_MIN(scm_t_int16,SCM_T_UINT16_MAX)
455 #define SCM_T_INT16_MAX SCM_I_TYPE_MAX(scm_t_int16,SCM_T_UINT16_MAX)
457 #define SCM_T_UINT32_MAX SCM_I_UTYPE_MAX(scm_t_uint32)
458 #define SCM_T_INT32_MIN SCM_I_TYPE_MIN(scm_t_int32,SCM_T_UINT32_MAX)
459 #define SCM_T_INT32_MAX SCM_I_TYPE_MAX(scm_t_int32,SCM_T_UINT32_MAX)
461 #define SCM_T_UINT64_MAX SCM_I_UTYPE_MAX(scm_t_uint64)
462 #define SCM_T_INT64_MIN SCM_I_TYPE_MIN(scm_t_int64,SCM_T_UINT64_MAX)
463 #define SCM_T_INT64_MAX SCM_I_TYPE_MAX(scm_t_int64,SCM_T_UINT64_MAX)
465 #if SCM_SIZEOF_LONG_LONG
466 #define SCM_I_ULLONG_MAX SCM_I_UTYPE_MAX(unsigned long long)
467 #define SCM_I_LLONG_MIN SCM_I_TYPE_MIN(long long,SCM_I_ULLONG_MAX)
468 #define SCM_I_LLONG_MAX SCM_I_TYPE_MAX(long long,SCM_I_ULLONG_MAX)
471 #define SCM_T_UINTMAX_MAX SCM_I_UTYPE_MAX(scm_t_uintmax)
472 #define SCM_T_INTMAX_MIN SCM_I_TYPE_MIN(scm_t_intmax,SCM_T_UINTMAX_MAX)
473 #define SCM_T_INTMAX_MAX SCM_I_TYPE_MAX(scm_t_intmax,SCM_T_UINTMAX_MAX)
475 #define SCM_T_UINTPTR_MAX SCM_I_UTYPE_MAX(scm_t_uintptr)
476 #define SCM_T_INTPTR_MIN SCM_I_TYPE_MIN(scm_t_intptr,SCM_T_UINTPTR_MAX)
477 #define SCM_T_INTPTR_MAX SCM_I_TYPE_MAX(scm_t_intptr,SCM_T_UINTPTR_MAX)
479 #define SCM_I_SIZE_MAX SCM_I_UTYPE_MAX(size_t)
480 #define SCM_I_SSIZE_MIN SCM_I_TYPE_MIN(ssize_t,SCM_I_SIZE_MAX)
481 #define SCM_I_SSIZE_MAX SCM_I_TYPE_MAX(ssize_t,SCM_I_SIZE_MAX)
485 #include "libguile/tags.h"
488 /* The type of subrs, i.e., Scheme procedures implemented in C. Empty
489 function declarators are used internally for pointers to functions of
490 any arity. However, these are equivalent to `(void)' in C++, are
491 obsolescent as of C99, and trigger `strict-prototypes' GCC warnings
494 #ifdef BUILDING_LIBGUILE
495 typedef SCM (* scm_t_subr
) ();
497 typedef void *scm_t_subr
;
502 # ifndef CHEAP_CONTINUATIONS
503 typedef int jmp_buf[17];
504 extern int setjump(jmp_buf env
);
505 extern int longjump(jmp_buf env
, int ret
);
506 # define setjmp setjump
507 # define longjmp longjump
513 typedef int jmp_buf[112];
514 extern int setjump(jmp_buf env
);
515 extern int longjump(jmp_buf env
, int ret
);
516 # define setjmp setjump
517 # define longjmp longjump
518 # else /* ndef _CRAY1 */
519 # if defined (__ia64__)
520 /* For IA64, emulate the setjmp API using getcontext. */
522 # include <ucontext.h>
527 # define SCM_I_SETJMP(JB) \
529 getcontext (&((JB).ctx)), \
530 ((JB).fresh ? ((JB).fresh = 0, 0) : 1) )
531 # define SCM_I_LONGJMP(JB,VAL) scm_ia64_longjmp (&(JB), VAL)
532 void scm_ia64_longjmp (scm_i_jmp_buf
*, int);
533 # else /* ndef __ia64__ */
535 # endif /* ndef __ia64__ */
536 # endif /* ndef _CRAY1 */
537 #endif /* ndef vms */
539 /* For any platform where SCM_I_SETJMP hasn't been defined in some
540 special way above, map SCM_I_SETJMP, SCM_I_LONGJMP and
541 scm_i_jmp_buf to setjmp, longjmp and jmp_buf. */
543 #define scm_i_jmp_buf jmp_buf
544 #define SCM_I_SETJMP setjmp
545 #define SCM_I_LONGJMP longjmp
548 /* James Clark came up with this neat one instruction fix for
549 * continuations on the SPARC. It flushes the register windows so
550 * that all the state of the process is contained in the stack.
553 #if defined (sparc) || defined (__sparc__) || defined (__sparc)
554 # define SCM_FLUSH_REGISTER_WINDOWS asm("ta 3")
556 # define SCM_FLUSH_REGISTER_WINDOWS /* empty */
559 /* If stack is not longword aligned then
562 /* #define SHORT_ALIGN */
574 typedef short SCM_STACKITEM
;
576 typedef long SCM_STACKITEM
;
579 /* Cast pointer through (void *) in order to avoid compiler warnings
580 when strict aliasing is enabled */
581 #define SCM_STACK_PTR(ptr) ((SCM_STACKITEM *) (void *) (ptr))
584 SCM_API
void scm_async_tick (void);
586 #ifdef BUILDING_LIBGUILE
588 /* FIXME: should change names */
589 # define SCM_ASYNC_TICK \
592 if (SCM_UNLIKELY (SCM_I_CURRENT_THREAD->pending_asyncs)) \
593 scm_async_click (); \
597 /* SCM_ASYNC_TICK_WITH_CODE is only available to Guile itself */
598 # define SCM_ASYNC_TICK_WITH_CODE(thr, stmt) \
601 if (SCM_UNLIKELY (thr->pending_asyncs)) \
604 scm_async_click (); \
609 #else /* !BUILDING_LIBGUILE */
611 # define SCM_ASYNC_TICK (scm_async_tick ())
613 #endif /* !BUILDING_LIBGUILE */
616 /* Anthony Green writes:
617 When the compiler sees...
621 ...it doesn't actually promise to keep the critical code within the
622 boundries of the DEFER/ALLOW_INTS instructions. It may very well
623 schedule it outside of the magic defined in those macros.
625 However, GCC's volatile asm feature forms a barrier over which code is
626 never moved. So if you add...
628 ...to each of the DEFER_INTS and ALLOW_INTS macros, the critical
629 code will always remain in place. asm's without inputs or outputs
630 are implicitly volatile. */
632 #define SCM_FENCE asm /* volatile */ ("")
633 #elif defined (__INTEL_COMPILER) && defined (__ia64)
634 #define SCM_FENCE __memory_barrier()
642 SCM_THREAD_SWITCHING_CODE; \
653 #define SCM_ASSERT(_cond, _arg, _pos, _subr)
654 #define SCM_ASSERT_TYPE(_cond, _arg, _pos, _subr, _msg)
656 #define SCM_ASSERT(_cond, _arg, _pos, _subr) \
657 do { if (SCM_UNLIKELY (!(_cond))) \
658 scm_wrong_type_arg (_subr, _pos, _arg); } while (0)
659 #define SCM_ASSERT_TYPE(_cond, _arg, _pos, _subr, _msg) \
660 do { if (SCM_UNLIKELY (!(_cond))) \
661 scm_wrong_type_arg_msg(_subr, _pos, _arg, _msg); } while (0)
668 /* Dirk:FIXME:: In all of the SCM_WTA_DISPATCH_* macros it is assumed that
669 * 'gf' is zero if uninitialized. It would be cleaner if some valid SCM value
670 * like SCM_BOOL_F or SCM_UNDEFINED was chosen.
673 SCM_API SCM
scm_call_generic_0 (SCM gf
);
675 #define SCM_WTA_DISPATCH_0(gf, subr) \
676 return (SCM_UNPACK (gf) \
677 ? scm_call_generic_0 ((gf)) \
678 : (scm_error_num_args_subr ((subr)), SCM_UNSPECIFIED))
679 #define SCM_GASSERT0(cond, gf, subr) \
680 if (SCM_UNLIKELY(!(cond))) \
681 SCM_WTA_DISPATCH_0((gf), (subr))
683 SCM_API SCM
scm_call_generic_1 (SCM gf
, SCM a1
);
685 #define SCM_WTA_DISPATCH_1(gf, a1, pos, subr) \
686 return (SCM_UNPACK (gf) \
687 ? scm_call_generic_1 ((gf), (a1)) \
688 : (scm_wrong_type_arg ((subr), (pos), (a1)), SCM_UNSPECIFIED))
690 /* This form is for dispatching a subroutine. */
691 #define SCM_WTA_DISPATCH_1_SUBR(subr, a1, pos) \
692 return (SCM_UNPACK ((*SCM_SUBR_GENERIC (subr))) \
693 ? scm_call_generic_1 ((*SCM_SUBR_GENERIC (subr)), (a1)) \
694 : (scm_i_wrong_type_arg_symbol (SCM_SUBR_NAME (subr), (pos), (a1)), SCM_UNSPECIFIED))
696 #define SCM_GASSERT1(cond, gf, a1, pos, subr) \
697 if (SCM_UNLIKELY (!(cond))) \
698 SCM_WTA_DISPATCH_1((gf), (a1), (pos), (subr))
700 SCM_API SCM
scm_call_generic_2 (SCM gf
, SCM a1
, SCM a2
);
702 #define SCM_WTA_DISPATCH_2(gf, a1, a2, pos, subr) \
703 return (SCM_UNPACK (gf) \
704 ? scm_call_generic_2 ((gf), (a1), (a2)) \
705 : (scm_wrong_type_arg ((subr), (pos), \
706 (pos) == SCM_ARG1 ? (a1) : (a2)), \
708 #define SCM_GASSERT2(cond, gf, a1, a2, pos, subr) \
709 if (SCM_UNLIKELY (!(cond))) \
710 SCM_WTA_DISPATCH_2((gf), (a1), (a2), (pos), (subr))
712 SCM_API SCM
scm_apply_generic (SCM gf
, SCM args
);
714 #define SCM_WTA_DISPATCH_n(gf, args, pos, subr) \
715 return (SCM_UNPACK (gf) \
716 ? scm_apply_generic ((gf), (args)) \
717 : (scm_wrong_type_arg ((subr), (pos), \
718 scm_list_ref ((args), \
719 scm_from_int ((pos) - 1))), \
721 #define SCM_GASSERTn(cond, gf, args, pos, subr) \
722 if (SCM_UNLIKELY (!(cond))) \
723 SCM_WTA_DISPATCH_n((gf), (args), (pos), (subr))
725 #ifndef SCM_MAGIC_SNARFER
726 /* Let these macros pass through if
727 we are snarfing; thus we can tell the
728 difference between the use of an actual
729 number vs. the use of one of these macros --
730 actual numbers in SCM_VALIDATE_* and SCM_ASSERT
731 constructs must match the formal argument name,
732 but using SCM_ARG* avoids the test */
743 #endif /* SCM_MAGIC_SNARFER */
747 /* SCM_EXIT_SUCCESS is the default code to return from SCM if no errors
748 * were encountered. SCM_EXIT_FAILURE is the default code to return from
749 * SCM if errors were encountered. The return code can be explicitly
750 * specified in a SCM program with (scm_quit <n>).
753 #ifndef SCM_EXIT_SUCCESS
755 #define SCM_EXIT_SUCCESS 1
757 #define SCM_EXIT_SUCCESS 0
759 #endif /* ndef SCM_EXIT_SUCCESS */
760 #ifndef SCM_EXIT_FAILURE
762 #define SCM_EXIT_FAILURE 2
764 #define SCM_EXIT_FAILURE 1
766 #endif /* ndef SCM_EXIT_FAILURE */
768 /* Define SCM_C_INLINE_KEYWORD so that it can be used as a replacement
769 for the "inline" keyword, expanding to nothing when "inline" is not
774 #define SCM_C_INLINE_KEYWORD SCM_C_INLINE
776 #define SCM_C_INLINE_KEYWORD
779 /* Handling thread-local storage (TLS). */
781 #ifdef SCM_HAVE_THREAD_STORAGE_CLASS
782 # define SCM_THREAD_LOCAL __thread
784 # define SCM_THREAD_LOCAL
787 #endif /* SCM___SCM_H */