Expose some of the string/stringbuf internal flags and tags.
[bpt/guile.git] / libguile / __scm.h
CommitLineData
0f2d19dd
JB
1/* classes: h_files */
2
729dbac3
DH
3#ifndef SCM___SCM_H
4#define SCM___SCM_H
8c494e99 5
d3cf93bc 6/* Copyright (C) 1995,1996,1998,1999,2000,2001,2002,2003, 2006, 2007, 2008 Free Software Foundation, Inc.
8c494e99 7 *
d3cf93bc
NJ
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
8c494e99 12 *
d3cf93bc 13 * This library is distributed in the hope that it will be useful,
0f2d19dd 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
d3cf93bc
NJ
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
8c494e99 17 *
d3cf93bc
NJ
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 */
8c494e99 22
0f2d19dd 23\f
176067df 24
92e6989f
RB
25/**********************************************************************
26 This file is Guile's central public header.
27
28 When included by other files, this file should preceed any include
29 other than __scm.h.
30
31 Under *NO* circumstances should new items be added to the global
32 namespace (via adding #define, typedef, or similar to this file) with
33 generic names. This usually means that any new names should be
34 prefixed by either SCM_ or GUILE_. i.e. do *not* #define HAVE_FOO or
35 SIZEOF_BAR. See configure.in, gen-scmconfig.h.in, and
36 gen-scmconfig.c for examples of how to properly handle this issue.
37 The main documentation is in gen-scmconfig.c.
38
39 "What's the difference between _scm.h and __scm.h?"
176067df
JB
40
41 _scm.h is not installed; it's only visible to the libguile sources
92e6989f 42 themselves, and it includes config.h, the private config header.
176067df
JB
43
44 __scm.h is installed, and is #included by <libguile.h>. If both
45 the client and libguile need some piece of information, and it
46 doesn't fit well into the header file for any particular module, it
92e6989f
RB
47 should go in __scm.h. __scm.h includes scmconfig.h, the public
48 config header.
49 **********************************************************************/
50
51/* What did the configure script discover about the outside world? */
52#include "libguile/scmconfig.h"
176067df 53
92e6989f 54\f
176067df 55
e81d98ec
DH
56/* {Compiler hints}
57 *
58 * The following macros are used to provide additional information for the
59 * compiler, which may help to do better error checking and code
60 * optimization. A second benefit of these macros is, that they also provide
61 * additional information to the developers.
62 */
63
64/* The macro SCM_NORETURN indicates that a function will never return.
65 * Examples:
66 * 1) int foo (char arg) SCM_NORETURN;
67 */
68#ifdef __GNUC__
69#define SCM_NORETURN __attribute__ ((noreturn))
70#else
71#define SCM_NORETURN
72#endif
73
74/* The macro SCM_UNUSED indicates that a function, function argument or
75 * variable may potentially be unused.
76 * Examples:
77 * 1) static int unused_function (char arg) SCM_UNUSED;
78 * 2) int foo (char unused_argument SCM_UNUSED);
79 * 3) int unused_variable SCM_UNUSED;
80 */
81#ifdef __GNUC__
82#define SCM_UNUSED __attribute__ ((unused))
83#else
84#define SCM_UNUSED
85#endif
86
87
9cc37597
LC
88/* The SCM_EXPECT macros provide branch prediction hints to the compiler. To
89 * use only in places where the result of the expression under "normal"
90 * circumstances is known. */
91#if defined(__GNUC__) && (__GNUC__ >= 3)
92# define SCM_EXPECT __builtin_expect
93#else
94# define SCM_EXPECT(_expr, _value) (_expr)
95#endif
96
97#define SCM_LIKELY(_expr) SCM_EXPECT ((_expr), 1)
98#define SCM_UNLIKELY(_expr) SCM_EXPECT ((_expr), 0)
99
102dbb6f
LC
100/* The SCM_INTERNAL macro makes it possible to explicitly declare a function
101 * as having "internal" linkage. */
102#if (defined __GNUC__) && \
103 ((__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ == 3))
3e28462f 104# define SCM_INTERNAL extern __attribute__ ((__visibility__ ("internal")))
102dbb6f 105#else
3e28462f 106# define SCM_INTERNAL extern
102dbb6f
LC
107#endif
108
9cc37597
LC
109
110\f
0f2d19dd
JB
111/* {Supported Options}
112 *
113 * These may be defined or undefined.
114 */
115
16d35552 116/* #define GUILE_DEBUG_FREELIST */
70d63753 117
0f2d19dd
JB
118/* All the number support there is.
119 */
0f2d19dd
JB
120#define BIGNUMS
121
686765af
ML
122/* GC should relinquish empty cons-pair arenas. */
123/* cmm:FIXME look at this after done mangling the GC */
124/* #define GC_FREE_SEGMENTS */
0f2d19dd
JB
125
126/* Provide a scheme-accessible count-down timer that
127 * generates a pseudo-interrupt.
128 */
129#define TICKS
130
131
132/* Use engineering notation when converting numbers strings?
133 */
134#undef ENGNOT
135
0f2d19dd
JB
136\f
137/* {Unsupported Options}
138 *
3c205827 139 * These must be defined as given here.
0f2d19dd
JB
140 */
141
142
143#define CCLO
3c205827
JB
144
145/* Guile Scheme supports the #f/() distinction; Guile Lisp won't. We
146 have horrible plans for their unification. */
147#undef SICP
0f2d19dd
JB
148
149\f
150
80c78696 151/* Random options (not yet supported or in final form). */
0f2d19dd 152
80c78696
MD
153#define STACK_CHECKING
154#undef NO_CEVAL_STACK_CHECKING
0f2d19dd 155
43ff3170 156\f
3a9809df 157
1174045c
MV
158/* SCM_API is a macro prepended to all function and data definitions
159 which should be exported or imported in the resulting dynamic link
8f99e3f3 160 library (DLL) in the Win32 port. */
1174045c 161
8f99e3f3 162#if defined (SCM_IMPORT)
1174045c 163# define SCM_API __declspec (dllimport) extern
8f99e3f3 164#elif defined (SCM_EXPORT) || defined (DLL_EXPORT)
1174045c
MV
165# define SCM_API __declspec (dllexport) extern
166#else
167# define SCM_API extern
168#endif
169
170\f
171
3a9809df
DH
172/* {Debugging Options}
173 *
174 * These compile time options determine whether to include code that is only
175 * useful for debugging guile itself or C level extensions to guile. The
176 * common prefix for all option macros of this kind is "SCM_DEBUG_". It is
fce0b22d
DH
177 * guaranteed that a macro named SCM_DEBUG_XXX is always defined (typically to
178 * either 0 or 1), i. e. there is no need to test for the undefined case.
179 * This allows to use these definitions comfortably within code, as in the
180 * following example:
3a9809df
DH
181 * #define FOO do { if (SCM_DEBUG_XXX) bar(); else baz(); } while (0)
182 * Any sane compiler will remove the unused branch without any performance
183 * penalty for the resulting code.
184 *
185 * Note: Some SCM_DEBUG_XXX options are not settable at configure time.
186 * To change the value of such options you will have to edit this header
56100716
DH
187 * file or give suitable options to make, like:
188 * make all CFLAGS="-DSCM_DEBUG_XXX=1 ..."
3a9809df
DH
189 */
190
191
c8a54c4b
DH
192/* The value of SCM_DEBUG determines the default for most of the not yet
193 * defined debugging options. This allows, for example, to enable most of the
194 * debugging options by simply defining SCM_DEBUG as 1.
195 */
196#ifndef SCM_DEBUG
197#define SCM_DEBUG 0
198#endif
199
7ddb9baf
HWN
200/* For debugging purposes: define this is to ensure nobody is using
201 * the mark bits outside of the marking phase. This is meant for
202 * debugging purposes only.
203 */
204#ifndef SCM_DEBUG_MARKING_API
205#define SCM_DEBUG_MARKING_API 0
206#endif
207
46d53380
DH
208/* If SCM_DEBUG_CELL_ACCESSES is set to 1, cell accesses will perform
209 * exhaustive parameter checking: It will be verified that cell parameters
210 * actually point to a valid heap cell. Note: If this option is enabled,
211 * guile will run about ten times slower than normally.
212 */
213#ifndef SCM_DEBUG_CELL_ACCESSES
214#define SCM_DEBUG_CELL_ACCESSES SCM_DEBUG
215#endif
216
216eedfc
DH
217/* If SCM_DEBUG_INTERRUPTS is set to 1, with every deferring and allowing of
218 * interrupts a consistency check will be performed.
219 */
220#ifndef SCM_DEBUG_INTERRUPTS
221#define SCM_DEBUG_INTERRUPTS SCM_DEBUG
222#endif
223
e81d98ec
DH
224/* If SCM_DEBUG_PAIR_ACCESSES is set to 1, accesses to cons cells will be
225 * exhaustively checked. Note: If this option is enabled, guile will run
226 * slower than normally.
227 */
228#ifndef SCM_DEBUG_PAIR_ACCESSES
229#define SCM_DEBUG_PAIR_ACCESSES SCM_DEBUG
230#endif
231
af45e3b0
DH
232/* If SCM_DEBUG_REST_ARGUMENT is set to 1, functions that take rest arguments
233 * will check whether the rest arguments are actually passed as a proper list.
234 * Otherwise, if SCM_DEBUG_REST_ARGUMENT is 0, functions that take rest
235 * arguments will take it for granted that these are passed as a proper list.
c8a54c4b 236 */
af45e3b0
DH
237#ifndef SCM_DEBUG_REST_ARGUMENT
238#define SCM_DEBUG_REST_ARGUMENT SCM_DEBUG
3a9809df
DH
239#endif
240
fce0b22d
DH
241/* The macro SCM_DEBUG_TYPING_STRICTNESS indicates what level of type checking
242 * shall be performed with respect to the use of the SCM datatype. The macro
243 * may be defined to one of the values 0, 1 and 2.
244 *
245 * A value of 0 means that there will be no compile time type checking, since
246 * the SCM datatype will be declared as an integral type. This setting should
247 * only be used on systems, where casting from integral types to pointers may
248 * lead to loss of bit information.
249 *
250 * A value of 1 means that there will an intermediate level of compile time
251 * type checking, since the SCM datatype will be declared as a pointer to an
252 * undefined struct. This setting is the default, since it does not cost
253 * anything in terms of performance or code size.
254 *
255 * A value of 2 provides a maximum level of compile time type checking since
256 * the SCM datatype will be declared as a struct. This setting should be used
257 * for _compile time_ type checking only, since the compiled result is likely
258 * to be quite inefficient. The right way to make use of this option is to do
259 * a 'make clean; make CFLAGS=-DSCM_DEBUG_TYPING_STRICTNESS=2', fix your
56100716 260 * errors, and then do 'make clean; make'.
c8a54c4b 261 */
56100716 262#ifndef SCM_DEBUG_TYPING_STRICTNESS
729dbac3 263#define SCM_DEBUG_TYPING_STRICTNESS 1
56100716
DH
264#endif
265
d0624e39
DH
266/* If SCM_DEBUG_DEBUGGING_SUPPORT is set to 1, guile will provide a set of
267 * special functions that support debugging with a debugger like gdb or
268 * debugging of guile internals on the scheme level. The behaviour of guile
269 * is not changed by this macro, only the set of functions that are available
270 * will differ. All functions that are introduced this way have the prefix
271 * 'scm_dbg_' on the C level and the prefix 'dbg-' on the scheme level. This
272 * allows to easily determine the set of support functions, given that your
273 * debugger or repl provide automatic name completion. Note that these
274 * functions are intended to be used during interactive debugging sessions
275 * only. They are not considered part of guile's official API. They may
276 * change or disappear without notice or deprecation phase.
94fb5a6e 277 */
d0624e39
DH
278#ifndef SCM_DEBUG_DEBUGGING_SUPPORT
279#define SCM_DEBUG_DEBUGGING_SUPPORT SCM_DEBUG
94fb5a6e
DH
280#endif
281
3a9809df
DH
282\f
283
8c494e99
DH
284/* {Feature Options}
285 *
286 * These compile time options determine whether code for certain features
287 * should be compiled into guile. The common prefix for all option macros
288 * of this kind is "SCM_ENABLE_". It is guaranteed that a macro named
289 * SCM_ENABLE_XXX is defined to be either 0 or 1, i. e. there is no need to
290 * test for the undefined case. This allows to use these definitions
291 * comfortably within code, as in the following example:
292 * #define FOO do { if (SCM_ENABLE_XXX) bar(); else baz(); } while (0)
293 * Any sane compiler will remove the unused branch without any performance
294 * penalty for the resulting code.
295 *
296 * Note: Some SCM_ENABLE_XXX options are not settable at configure time.
297 * To change the value of such options you will have to edit this header
298 * file or give suitable options to make, like:
299 * make all CFLAGS="-DSCM_ENABLE_XXX=1 ..."
0f2d19dd 300 */
1be6b49c 301
8c494e99
DH
302/* If SCM_ENABLE_DEPRECATED is set to 1, deprecated code will be included in
303 * guile, as well as some functions to issue run-time warnings about uses of
304 * deprecated functions.
305 */
306#ifndef SCM_ENABLE_DEPRECATED
307#define SCM_ENABLE_DEPRECATED 0
1be6b49c 308#endif
0f2d19dd 309
b971d089 310\f
0f2d19dd 311
5c75b29f 312/* {Architecture and compiler properties}
0f2d19dd 313 *
5c75b29f
DH
314 * Guile as of today can only work on systems which fulfill at least the
315 * following requirements:
59c4bb82
DH
316 *
317 * - scm_t_bits and SCM variables have at least 32 bits.
5c75b29f 318 * Guile's type system is based on this assumption.
59c4bb82
DH
319 *
320 * - sizeof (scm_t_bits) >= sizeof (void*) and sizeof (SCM) >= sizeof (void*)
321 * Guile's type system is based on this assumption, since it must be
322 * possible to store pointers to cells on the heap in scm_t_bits and SCM
323 * variables.
324 *
325 * - sizeof (scm_t_bits) >= 4 and sizeof (scm_t_bits) is a power of 2.
326 * Guile's type system is based on this assumption. In particular, it is
327 * assumed that cells, i. e. pairs of scm_t_bits variables, are eight
328 * character aligned. This is because three bits of a scm_t_bits variable
329 * that is holding a pointer to a cell on the heap must be available for
330 * storing type data.
331 *
332 * - sizeof (scm_t_bits) <= sizeof (void*) and sizeof (SCM) <= sizeof (void*)
333 * In some parts of guile, scm_t_bits and SCM variables are passed to
334 * functions as void* arguments. Together with the requirement above, this
335 * requires a one-to-one correspondence between the size of a void* and the
336 * sizes of scm_t_bits and SCM variables.
337 *
5c75b29f
DH
338 * - numbers are encoded using two's complement.
339 * The implementation of the bitwise scheme level operations is based on
340 * this assumption.
59c4bb82 341 *
5c75b29f 342 * - ... add more
0f2d19dd
JB
343 */
344
5c75b29f
DH
345#ifdef CHAR_BIT
346# define SCM_CHAR_BIT CHAR_BIT
347#else
348# define SCM_CHAR_BIT 8
349#endif
350
351#ifdef LONG_BIT
352# define SCM_LONG_BIT LONG_BIT
353#else
354# define SCM_LONG_BIT (SCM_CHAR_BIT * sizeof (long) / sizeof (char))
355#endif
356
357#ifdef UCHAR_MAX
358# define SCM_CHAR_CODE_LIMIT (UCHAR_MAX + 1L)
0f2d19dd 359#else
e2806c10 360# define SCM_CHAR_CODE_LIMIT 256L
5c75b29f
DH
361#endif
362
e88d45aa
MV
363#define SCM_I_UTYPE_MAX(type) ((type)-1)
364#define SCM_I_TYPE_MAX(type,umax) ((type)((umax)/2))
365#define SCM_I_TYPE_MIN(type,umax) (-((type)((umax)/2))-1)
366
367#define SCM_T_UINT8_MAX SCM_I_UTYPE_MAX(scm_t_uint8)
368#define SCM_T_INT8_MIN SCM_I_TYPE_MIN(scm_t_int8,SCM_T_UINT8_MAX)
369#define SCM_T_INT8_MAX SCM_I_TYPE_MAX(scm_t_int8,SCM_T_UINT8_MAX)
370
371#define SCM_T_UINT16_MAX SCM_I_UTYPE_MAX(scm_t_uint16)
372#define SCM_T_INT16_MIN SCM_I_TYPE_MIN(scm_t_int16,SCM_T_UINT16_MAX)
373#define SCM_T_INT16_MAX SCM_I_TYPE_MAX(scm_t_int16,SCM_T_UINT16_MAX)
374
375#define SCM_T_UINT32_MAX SCM_I_UTYPE_MAX(scm_t_uint32)
376#define SCM_T_INT32_MIN SCM_I_TYPE_MIN(scm_t_int32,SCM_T_UINT32_MAX)
377#define SCM_T_INT32_MAX SCM_I_TYPE_MAX(scm_t_int32,SCM_T_UINT32_MAX)
378
379#if SCM_HAVE_T_INT64
380#define SCM_T_UINT64_MAX SCM_I_UTYPE_MAX(scm_t_uint64)
381#define SCM_T_INT64_MIN SCM_I_TYPE_MIN(scm_t_int64,SCM_T_UINT64_MAX)
382#define SCM_T_INT64_MAX SCM_I_TYPE_MAX(scm_t_int64,SCM_T_UINT64_MAX)
383#endif
384
385#if SCM_SIZEOF_LONG_LONG
386#define SCM_I_ULLONG_MAX SCM_I_UTYPE_MAX(unsigned long long)
387#define SCM_I_LLONG_MIN SCM_I_TYPE_MIN(long long,SCM_I_ULLONG_MAX)
388#define SCM_I_LLONG_MAX SCM_I_TYPE_MAX(long long,SCM_I_ULLONG_MAX)
389#endif
390
391#define SCM_T_UINTMAX_MAX SCM_I_UTYPE_MAX(scm_t_uintmax)
392#define SCM_T_INTMAX_MIN SCM_I_TYPE_MIN(scm_t_intmax,SCM_T_UINTMAX_MAX)
393#define SCM_T_INTMAX_MAX SCM_I_TYPE_MAX(scm_t_intmax,SCM_T_UINTMAX_MAX)
394
395#define SCM_I_SIZE_MAX SCM_I_UTYPE_MAX(size_t)
396#define SCM_I_SSIZE_MIN SCM_I_TYPE_MIN(ssize_t,SCM_I_SIZE_MAX)
397#define SCM_I_SSIZE_MAX SCM_I_TYPE_MAX(ssize_t,SCM_I_SIZE_MAX)
398
0f2d19dd
JB
399\f
400
2a1d8241 401#include "libguile/tags.h"
0f2d19dd
JB
402
403\f
404#ifdef vms
405# ifndef CHEAP_CONTINUATIONS
406 typedef int jmp_buf[17];
407 extern int setjump(jmp_buf env);
408 extern int longjump(jmp_buf env, int ret);
409# define setjmp setjump
410# define longjmp longjump
411# else
412# include <setjmp.h>
413# endif
414#else /* ndef vms */
415# ifdef _CRAY1
416 typedef int jmp_buf[112];
417 extern int setjump(jmp_buf env);
418 extern int longjump(jmp_buf env, int ret);
419# define setjmp setjump
420# define longjmp longjump
421# else /* ndef _CRAY1 */
346e4402
NJ
422# if defined (__ia64__)
423/* For IA64, emulate the setjmp API using getcontext. */
424# include <signal.h>
425# include <ucontext.h>
426 typedef struct {
427 ucontext_t ctx;
428 int fresh;
429 } jmp_buf;
430# define setjmp(JB) \
431 ( (JB).fresh = 1, \
432 getcontext (&((JB).ctx)), \
433 ((JB).fresh ? ((JB).fresh = 0, 0) : 1) )
434# define longjmp(JB,VAL) scm_ia64_longjmp (&(JB), VAL)
435 void scm_ia64_longjmp (jmp_buf *, int);
436# else /* ndef __ia64__ */
437# include <setjmp.h>
438# endif /* ndef __ia64__ */
0f2d19dd
JB
439# endif /* ndef _CRAY1 */
440#endif /* ndef vms */
441
0f2d19dd
JB
442/* James Clark came up with this neat one instruction fix for
443 * continuations on the SPARC. It flushes the register windows so
3dd84ef1 444 * that all the state of the process is contained in the stack.
0f2d19dd
JB
445 */
446
7c12f0ac 447#if defined (sparc) || defined (__sparc__) || defined (__sparc)
0f2d19dd
JB
448# define SCM_FLUSH_REGISTER_WINDOWS asm("ta 3")
449#else
450# define SCM_FLUSH_REGISTER_WINDOWS /* empty */
451#endif
452
3dd84ef1 453/* If stack is not longword aligned then
0f2d19dd
JB
454 */
455
456/* #define SHORT_ALIGN */
457#ifdef THINK_C
458# define SHORT_ALIGN
459#endif
460#ifdef MSDOS
461# define SHORT_ALIGN
462#endif
463#ifdef atarist
464# define SHORT_ALIGN
465#endif
466
467#ifdef SHORT_ALIGN
468typedef short SCM_STACKITEM;
469#else
470typedef long SCM_STACKITEM;
471#endif
79f55b7c
MD
472
473/* Cast pointer through (void *) in order to avoid compiler warnings
474 when strict aliasing is enabled */
475#define SCM_STACK_PTR(ptr) ((SCM_STACKITEM *) (void *) (ptr))
0f2d19dd
JB
476\f
477
9f0e55a6
MD
478#define SCM_ASYNC_TICK /*fixme* should change names */ \
479do { \
9de87eea 480 if (SCM_I_CURRENT_THREAD->pending_asyncs) \
9f0e55a6
MD
481 scm_async_click (); \
482} while (0)
25d3ee9d 483
0f2d19dd 484
8417b665
JB
485/* Anthony Green writes:
486 When the compiler sees...
487 DEFER_INTS;
488 [critical code here]
489 ALLOW_INTS;
490 ...it doesn't actually promise to keep the critical code within the
491 boundries of the DEFER/ALLOW_INTS instructions. It may very well
492 schedule it outside of the magic defined in those macros.
493
494 However, GCC's volatile asm feature forms a barrier over which code is
495 never moved. So if you add...
35eec738
JB
496 asm ("");
497 ...to each of the DEFER_INTS and ALLOW_INTS macros, the critical
498 code will always remain in place. asm's without inputs or outputs
499 are implicitly volatile. */
8417b665 500#ifdef __GNUC__
35eec738 501#define SCM_FENCE asm /* volatile */ ("")
189b66ba
MV
502#elif defined (__INTEL_COMPILER) && defined (__ia64)
503#define SCM_FENCE __memory_barrier()
8417b665
JB
504#else
505#define SCM_FENCE
506#endif
507
c72cc5fb 508#define SCM_TICK \
bfc69694 509do { \
cd911565 510 SCM_ASYNC_TICK; \
216eedfc 511 SCM_THREAD_SWITCHING_CODE; \
bfc69694 512} while (0)
0f2d19dd
JB
513
514\f
515
516/** SCM_ASSERT
3dd84ef1 517 **
0f2d19dd
JB
518 **/
519
520
521#ifdef SCM_RECKLESS
522#define SCM_ASSERT(_cond, _arg, _pos, _subr)
23deee81 523#define SCM_ASSERT_TYPE(_cond, _arg, _pos, _subr, _msg)
0f2d19dd
JB
524#define SCM_ASRTGO(_cond, _label)
525#else
9cc37597
LC
526#define SCM_ASSERT(_cond, _arg, _pos, _subr) \
527 do { if (SCM_UNLIKELY (!(_cond))) \
aeb4c2e1 528 scm_wrong_type_arg (_subr, _pos, _arg); } while (0)
9cc37597
LC
529#define SCM_ASSERT_TYPE(_cond, _arg, _pos, _subr, _msg) \
530 do { if (SCM_UNLIKELY (!(_cond))) \
aeb4c2e1 531 scm_wrong_type_arg_msg(_subr, _pos, _arg, _msg); } while (0)
9cc37597
LC
532#define SCM_ASRTGO(_cond, _label) \
533 do { if (SCM_UNLIKELY (!(_cond))) \
aeb4c2e1 534 goto _label; } while (0)
0f2d19dd 535#endif
95b88819 536
9de33deb
MD
537/*
538 * SCM_WTA_DISPATCH
539 */
540
451e591c
DH
541/* Dirk:FIXME:: In all of the SCM_WTA_DISPATCH_* macros it is assumed that
542 * 'gf' is zero if uninitialized. It would be cleaner if some valid SCM value
543 * like SCM_BOOL_F or SCM_UNDEFINED was chosen.
544 */
545
1174045c 546SCM_API SCM scm_call_generic_0 (SCM gf);
b3c8a0f5 547
e68fc829 548#define SCM_WTA_DISPATCH_0(gf, subr) \
c07b3fef
MD
549 return (SCM_UNPACK (gf) \
550 ? scm_call_generic_0 ((gf)) \
e68fc829 551 : (scm_error_num_args_subr ((subr)), SCM_UNSPECIFIED))
9cc37597
LC
552#define SCM_GASSERT0(cond, gf, subr) \
553 if (SCM_UNLIKELY(!(cond))) \
554 SCM_WTA_DISPATCH_0((gf), (subr))
b3c8a0f5 555
1174045c 556SCM_API SCM scm_call_generic_1 (SCM gf, SCM a1);
9de33deb 557
c07b3fef
MD
558#define SCM_WTA_DISPATCH_1(gf, a1, pos, subr) \
559 return (SCM_UNPACK (gf) \
560 ? scm_call_generic_1 ((gf), (a1)) \
561 : (scm_wrong_type_arg ((subr), (pos), (a1)), SCM_UNSPECIFIED))
9cc37597
LC
562#define SCM_GASSERT1(cond, gf, a1, pos, subr) \
563 if (SCM_UNLIKELY (!(cond))) \
564 SCM_WTA_DISPATCH_1((gf), (a1), (pos), (subr))
9de33deb 565
1174045c 566SCM_API SCM scm_call_generic_2 (SCM gf, SCM a1, SCM a2);
9de33deb 567
c07b3fef
MD
568#define SCM_WTA_DISPATCH_2(gf, a1, a2, pos, subr) \
569 return (SCM_UNPACK (gf) \
570 ? scm_call_generic_2 ((gf), (a1), (a2)) \
571 : (scm_wrong_type_arg ((subr), (pos), \
572 (pos) == SCM_ARG1 ? (a1) : (a2)), \
573 SCM_UNSPECIFIED))
9cc37597
LC
574#define SCM_GASSERT2(cond, gf, a1, a2, pos, subr) \
575 if (SCM_UNLIKELY (!(cond))) \
576 SCM_WTA_DISPATCH_2((gf), (a1), (a2), (pos), (subr))
9de33deb 577
1174045c 578SCM_API SCM scm_apply_generic (SCM gf, SCM args);
89c358b1 579
c07b3fef
MD
580#define SCM_WTA_DISPATCH_n(gf, args, pos, subr) \
581 return (SCM_UNPACK (gf) \
582 ? scm_apply_generic ((gf), (args)) \
583 : (scm_wrong_type_arg ((subr), (pos), \
584 scm_list_ref ((args), \
93ccaef0 585 scm_from_int ((pos) - 1))), \
c07b3fef 586 SCM_UNSPECIFIED))
9cc37597
LC
587#define SCM_GASSERTn(cond, gf, args, pos, subr) \
588 if (SCM_UNLIKELY (!(cond))) \
589 SCM_WTA_DISPATCH_n((gf), (args), (pos), (subr))
89c358b1 590
c751e5e3
GB
591#ifndef SCM_MAGIC_SNARFER
592/* Let these macros pass through if
593 we are snarfing; thus we can tell the
594 difference between the use of an actual
595 number vs. the use of one of these macros --
f5421cfc 596 actual numbers in SCM_VALIDATE_* and SCM_ASSERT
c751e5e3
GB
597 constructs must match the formal argument name,
598 but using SCM_ARG* avoids the test */
599
0f2d19dd
JB
600#define SCM_ARGn 0
601#define SCM_ARG1 1
602#define SCM_ARG2 2
603#define SCM_ARG3 3
604#define SCM_ARG4 4
605#define SCM_ARG5 5
1146b6cd 606#define SCM_ARG6 6
3dd84ef1 607#define SCM_ARG7 7
0f2d19dd 608
c751e5e3 609#endif /* SCM_MAGIC_SNARFER */
0f2d19dd 610
0f2d19dd
JB
611\f
612
613/* SCM_EXIT_SUCCESS is the default code to return from SCM if no errors
614 * were encountered. SCM_EXIT_FAILURE is the default code to return from
615 * SCM if errors were encountered. The return code can be explicitly
616 * specified in a SCM program with (scm_quit <n>).
617 */
618
619#ifndef SCM_EXIT_SUCCESS
620#ifdef vms
621#define SCM_EXIT_SUCCESS 1
622#else
623#define SCM_EXIT_SUCCESS 0
624#endif /* def vms */
625#endif /* ndef SCM_EXIT_SUCCESS */
626#ifndef SCM_EXIT_FAILURE
627#ifdef vms
628#define SCM_EXIT_FAILURE 2
629#else
630#define SCM_EXIT_FAILURE 1
631#endif /* def vms */
632#endif /* ndef SCM_EXIT_FAILURE */
633
570b6821
MV
634/* Define SCM_C_INLINE_KEYWORD so that it can be used as a replacement
635 for the "inline" keyword, expanding to nothing when "inline" is not
636 available.
637*/
638
639#ifdef SCM_C_INLINE
640#define SCM_C_INLINE_KEYWORD SCM_C_INLINE
641#else
642#define SCM_C_INLINE_KEYWORD
643#endif
644
729dbac3 645#endif /* SCM___SCM_H */
89e00824
ML
646
647/*
648 Local Variables:
649 c-file-style: "gnu"
650 End:
651*/