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