mirror/guile
mirror/guile
1
Fork 0
mirror of https://git.savannah.gnu.org/git/guile.git synced 2025-05-31 17:30:24 +02:00
Code Activity
guile/libguile/__scm.h
Michael Livshin 1be6b49ccb * validate.h 
(SCM_NUM2{SIZE,PTRDIFF,SHORT,USHORT,BITS,UBITS,INT,UINT}[_DEF]):
new macros.

* unif.h: type renaming:
scm_array -> scm_array_t
scm_array_dim -> scm_array_dim_t
the old names are deprecated, all in-Guile uses changed.

* tags.h (scm_ubits_t): new typedef, representing unsigned
scm_bits_t.

* stacks.h: type renaming:
scm_info_frame -> scm_info_frame_t
scm_stack -> scm_stack_t
the old names are deprecated, all in-Guile uses changed.

* srcprop.h: type renaming:
scm_srcprops -> scm_srcprops_t
scm_srcprops_chunk -> scm_srcprops_chunk_t
the old names are deprecated, all in-Guile uses changed.

* gsubr.c, procs.c, print.c, ports.c, read.c, rdelim.c, ramap.c,
rw.c, smob.c, sort.c, srcprop.c, stacks.c, strings.c, strop.c,
strorder.c, strports.c, struct.c, symbols.c, unif.c, values.c,
vectors.c, vports.c, weaks.c:
various int/size_t -> size_t/scm_bits_t changes.

* random.h: type renaming:
scm_rstate -> scm_rstate_t
scm_rng -> scm_rng_t
scm_i_rstate -> scm_i_rstate_t
the old names are deprecated, all in-Guile uses changed.

* procs.h: type renaming:
scm_subr_entry -> scm_subr_entry_t
the old name is deprecated, all in-Guile uses changed.

* options.h (scm_option_t.val): unsigned long -> scm_bits_t.
type renaming:
scm_option -> scm_option_t
the old name is deprecated, all in-Guile uses changed.

* objects.c: various long -> scm_bits_t changes.
(scm_i_make_class_object): flags: unsigned long -> scm_ubits_t

* numbers.h (SCM_FIXNUM_BIT): deprecated, renamed to
SCM_I_FIXNUM_BIT.

* num2integral.i.c: new file, multiply included by numbers.c, used
to "templatize" the various integral <-> num conversion routines.

* numbers.c (scm_mkbig, scm_big2num, scm_adjbig, scm_normbig,
scm_copybig, scm_2ulong2big, scm_dbl2big, scm_big2dbl):
deprecated.
(scm_i_mkbig, scm_i_big2inum, scm_i_adjbig, scm_i_normbig,
scm_i_copybig, scm_i_short2big, scm_i_ushort2big, scm_i_int2big,
scm_i_uint2big, scm_i_long2big, scm_i_ulong2big, scm_i_bits2big,
scm_i_ubits2big, scm_i_size2big, scm_i_ptrdiff2big,
scm_i_long_long2big, scm_i_ulong_long2big, scm_i_dbl2big,
scm_i_big2dbl, scm_short2num, scm_ushort2num, scm_int2num,
scm_uint2num, scm_bits2num, scm_ubits2num, scm_size2num,
scm_ptrdiff2num, scm_num2short, scm_num2ushort, scm_num2int,
scm_num2uint, scm_num2bits, scm_num2ubits, scm_num2ptrdiff,
scm_num2size): new functions.

* modules.c (scm_module_reverse_lookup): i, n: int -> scm_bits_t.x

* load.c: change int -> size_t in various places (where the
variable is used to store a string length).
(search-path): call scm_done_free, not scm_done_malloc.

* list.c (scm_ilength): return a scm_bits_t, not long.
some other {int,long} -> scm_bits_t changes.

* hashtab.c: various [u]int -> scm_bits_t changes.
scm_ihashx_closure -> scm_ihashx_closure_t (and made a typedef).
(scm_ihashx): n: uint -> scm_bits_t
use scm_bits2num instead of scm_ulong2num.

* gsubr.c: various int -> scm_bits_t changes.

* gh_data.c (gh_scm2double): no loss of precision any more.

* gh.h (gh_str2scm): len: int -> size_t
(gh_{get,set}_substr): start: int -> scm_bits_t,
len: int -> size_t
(gh_<num>2scm): n: int -> scm_bits_t
(gh_*vector_length): return scm_[u]size_t, not unsigned long.
(gh_length): return scm_bits_t, not unsigned long.

* fports.h: type renaming:
scm_fport -> scm_fport_t
the old name is deprecated, all in-Guile uses changed.

* fports.c (fport_fill_input): count: int -> scm_bits_t
(fport_flush): init_size, remaining, count: int -> scm_bits_t

* debug.h (scm_lookup_cstr, scm_lookup_soft, scm_evstr): removed
those prototypes, as the functions they prototype don't exist.

* fports.c (default_buffer_size): int -> size_t
(scm_fport_buffer_add): read_size, write_size: int -> scm_bits_t
default_size: int -> size_t
(scm_setvbuf): csize: int -> scm_bits_t

* fluids.c (n_fluids): int -> scm_bits_t
(grow_fluids): old_length, i: int -> scm_bits_t
(next_fluid_num, scm_fluid_ref, scm_fluid_set_x): n: int ->
scm_bits_t
(scm_c_with_fluids): flen, vlen: int -> scm_bits_t

* filesys.c (s_scm_open_fdes): changed calls to SCM_NUM2LONG to
the new and shiny SCM_NUM2INT.

* extensions.c: extension -> extension_t (and made a typedef).

* eval.h (SCM_IFRAME): cast to scm_bits_t, not int.  just so
there are no nasty surprises if/when the various deeply magic tag
bits move somewhere else.

* eval.c: changed the locals used to store results of SCM_IFRAME,
scm_ilength and such to be of type scm_bits_t (and not int/long).
(iqq): depth, edepth: int -> scm_bits_t
(scm_eval_stack): int -> scm_bits_t
(SCM_CEVAL): various vars are not scm_bits_t instead of int.
(check_map_args, scm_map, scm_for_each): len: long -> scm_bits_t
i: int -> scm_bits_t

* environments.c: changed the many calls to scm_ulong2num to
scm_ubits2num.
(import_environment_fold): proc_as_ul: ulong -> scm_ubits_t

* dynwind.c (scm_dowinds): delta: long -> scm_bits_t

* debug.h: type renaming:
scm_debug_info -> scm_debug_info_t
scm_debug_frame -> scm_debug_frame_t
the old names are deprecated, all in-Guile uses changed.
(scm_debug_eframe_size): int -> scm_bits_t

* debug.c (scm_init_debug): use scm_c_define instead of the
deprecated scm_define.

* continuations.h: type renaming:
scm_contregs -> scm_contregs_t
the old name is deprecated, all in-Guile uses changed.
(scm_contregs_t.num_stack_items): size_t -> scm_bits_t
(scm_contregs_t.num_stack_items): ulong -> scm_ubits_t

* continuations.c (scm_make_continuation): change the type of
stack_size form long to scm_bits_t.

* ports.h: type renaming:
scm_port_rw_active -> scm_port_rw_active_t (and made a typedef)
scm_port -> scm_port_t
scm_ptob_descriptor -> scm_ptob_descriptor_t
the old names are deprecated, all in-Guile uses changed.
(scm_port_t.entry): int -> scm_bits_t.
(scm_port_t.line_number): int -> long.
(scm_port_t.putback_buf_size): int -> size_t.

* __scm.h (long_long, ulong_long): deprecated (they pollute the
global namespace and have little value besides that).
(SCM_BITS_LENGTH): new, is the bit size of scm_bits_t (i.e. of an
SCM handle).
(ifdef spaghetti): include sys/types.h and sys/stdtypes.h, if they
exist (for size_t & ptrdiff_t)
(scm_sizet): deprecated.

* Makefile.am (noinst_HEADERS): add num2integral.i.c
2001-05-24 00:50:51 +00:00

647 lines
18 KiB
C
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* classes: h_files */
#ifndef __SCMH
#define __SCMH
/* Copyright (C) 1995,1996,1998,1999,2000,2001 Free Software Foundation, Inc.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this software; see the file COPYING. If not, write to
* the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307 USA
*
* As a special exception, the Free Software Foundation gives permission
* for additional uses of the text contained in its release of GUILE.
*
* The exception is that, if you link the GUILE library with other files
* to produce an executable, this does not by itself cause the
* resulting executable to be covered by the GNU General Public License.
* Your use of that executable is in no way restricted on account of
* linking the GUILE library code into it.
*
* This exception does not however invalidate any other reasons why
* the executable file might be covered by the GNU General Public License.
*
* This exception applies only to the code released by the
* Free Software Foundation under the name GUILE. If you copy
* code from other Free Software Foundation releases into a copy of
* GUILE, as the General Public License permits, the exception does
* not apply to the code that you add in this way. To avoid misleading
* anyone as to the status of such modified files, you must delete
* this exception notice from them.
*
* If you write modifications of your own for GUILE, it is your choice
* whether to permit this exception to apply to your modifications.
* If you do not wish that, delete this exception notice. */
/* "What's the difference between _scm.h and __scm.h?"
_scm.h is not installed; it's only visible to the libguile sources
themselves.
__scm.h is installed, and is #included by <libguile.h>. If both
the client and libguile need some piece of information, and it
doesn't fit well into the header file for any particular module, it
should go in __scm.h. */
/* {Supported Options}
*
* These may be defined or undefined.
*/
/* Old async mechanism */
/* #define GUILE_OLD_ASYNC_CLICK */
/* #define GUILE_DEBUG_FREELIST */
/* If the compile FLAG `SCM_CAUTIOUS' is #defined then the number of
* arguments is always checked for application of closures. If the
* compile FLAG `SCM_RECKLESS' is #defined then they are not checked.
* Otherwise, number of argument checks for closures are made only when
* the function position (whose value is the closure) of a combination is
* not an ILOC or GLOC. When the function position of a combination is a
* symbol it will be checked only the first time it is evaluated because
* it will then be replaced with an ILOC or GLOC.
*/
#undef SCM_RECKLESS
#define SCM_CAUTIOUS
/* After looking up a local for the first time, rewrite the
* code graph, caching its position.
*/
#define MEMOIZE_LOCALS
/* All the number support there is.
*/
#define BIGNUMS
/* GC should relinquish empty cons-pair arenas. */
/* cmm:FIXME look at this after done mangling the GC */
/* #define GC_FREE_SEGMENTS */
/* Provide a scheme-accessible count-down timer that
* generates a pseudo-interrupt.
*/
#define TICKS
/* Use engineering notation when converting numbers strings?
*/
#undef ENGNOT
/* {Unsupported Options}
*
* These must be defined as given here.
*/
#define CCLO
/* Guile Scheme supports the #f/() distinction; Guile Lisp won't. We
have horrible plans for their unification. */
#undef SICP
/* Random options (not yet supported or in final form). */
#define STACK_CHECKING
#undef NO_CEVAL_STACK_CHECKING
/* What did the configure script discover about the outside world? */
#include "libguile/scmconfig.h"
/* {Debugging Options}
*
* These compile time options determine whether to include code that is only
* useful for debugging guile itself or C level extensions to guile. The
* common prefix for all option macros of this kind is "SCM_DEBUG_". It is
* guaranteed that a macro named SCM_DEBUG_XXX is defined to be either 0 or 1,
* i. e. there is no need to test for the undefined case. This allows to use
* these definitions comfortably in macro code, as in the following example:
* #define FOO do { if (SCM_DEBUG_XXX) bar(); else baz(); } while (0)
* Any sane compiler will remove the unused branch without any performance
* penalty for the resulting code.
*
* Note: Some SCM_DEBUG_XXX options are not settable at configure time.
* To change the value of such options you will have to edit this header
* file or give suitable options to make, like:
* make all CFLAGS="-DSCM_DEBUG_XXX=1 ..."
*/
/* The value of SCM_DEBUG determines the default for most of the not yet
* defined debugging options. This allows, for example, to enable most of the
* debugging options by simply defining SCM_DEBUG as 1.
*/
#ifndef SCM_DEBUG
#define SCM_DEBUG 0
#endif
/* If SCM_DEBUG_CELL_ACCESSES is set to 1, cell accesses will perform
* exhaustive parameter checking: It will be verified that cell parameters
* actually point to a valid heap cell. Note: If this option is enabled,
* guile will run about ten times slower than normally.
*/
#ifndef SCM_DEBUG_CELL_ACCESSES
#define SCM_DEBUG_CELL_ACCESSES SCM_DEBUG
#endif
/* If SCM_DEBUG_DEPRECATED is set to 1, deprecated code is not compiled. This
* can be used by developers to get rid of references to deprecated code.
*/
#ifndef SCM_DEBUG_DEPRECATED
#define SCM_DEBUG_DEPRECATED SCM_DEBUG
#endif
/* If SCM_DEBUG_INTERRUPTS is set to 1, with every deferring and allowing of
* interrupts a consistency check will be performed.
*/
#ifndef SCM_DEBUG_INTERRUPTS
#define SCM_DEBUG_INTERRUPTS SCM_DEBUG
#endif
/* If SCM_DEBUG_REST_ARGUMENT is set to 1, functions that take rest arguments
* will check whether the rest arguments are actually passed as a proper list.
* Otherwise, if SCM_DEBUG_REST_ARGUMENT is 0, functions that take rest
* arguments will take it for granted that these are passed as a proper list.
*/
#ifndef SCM_DEBUG_REST_ARGUMENT
#define SCM_DEBUG_REST_ARGUMENT SCM_DEBUG
#endif
/* Use this for _compile time_ type checking only, since the compiled result
* will be quite inefficient. The right way to make use of this option is to
* do a 'make clean; make CFLAGS=-DSCM_DEBUG_TYPING_STRICTNESS=1', fix your
* errors, and then do 'make clean; make'.
*/
#ifndef SCM_DEBUG_TYPING_STRICTNESS
#define SCM_DEBUG_TYPING_STRICTNESS 0
#endif
/* If SCM_ENABLE_VCELLS is set to 1, a couple of functions that deal
* with vcells are defined for compatability reasons. Supporting
* vcells reduces performance however.
*
* We use a dedicated macro instead of just SCM_DEBUG_DEPRECATED so
* that code the belongs to the `vcell' feature is easier to find.
*/
#define SCM_ENABLE_VCELLS !SCM_DEBUG_DEPRECATED
#ifdef HAVE_LONG_LONGS
/* Some auto-generated .h files contain unused prototypes
* that need these typedefs.
*/
#if (SCM_DEBUG_DEPRECATED == 0)
typedef long long long_long;
typedef unsigned long long ulong_long;
#endif
#endif /* HAVE_LONG_LONGS */
/* {Architecture and compiler properties}
*
* Guile as of today can only work on systems which fulfill at least the
* following requirements:
* - long ints have at least 32 bits.
* Guile's type system is based on this assumption.
* - long ints consist of at least four characters.
* It is assumed that cells, i. e. pairs of long ints, are eight character
* aligned, because three bits of a cell pointer are used for type data.
* - sizeof (void*) == sizeof (long int)
* Pointers are stored in SCM objects, and sometimes SCM objects are passed
* as void*. Thus, there has to be a one-to-one correspondence.
* - numbers are encoded using two's complement.
* The implementation of the bitwise scheme level operations is based on
* this assumption.
* - ... add more
*/
#ifdef HAVE_LIMITS_H
# include <limits.h>
#endif
#ifdef CHAR_BIT
# define SCM_CHAR_BIT CHAR_BIT
#else
# define SCM_CHAR_BIT 8
#endif
#ifdef LONG_BIT
# define SCM_LONG_BIT LONG_BIT
#else
# define SCM_LONG_BIT (SCM_CHAR_BIT * sizeof (long) / sizeof (char))
#endif
#define SCM_BITS_LENGTH (SCM_CHAR_BIT * SCM_SIZEOF_BITS_T)
#ifdef UCHAR_MAX
# define SCM_CHAR_CODE_LIMIT (UCHAR_MAX + 1L)
#else
# define SCM_CHAR_CODE_LIMIT 256L
#endif
#ifdef STDC_HEADERS
# include <stdlib.h>
# if HAVE_SYS_TYPES_H
# include <sys/types.h>
# endif
# if HAVE_SYS_STDTYPES_H
# include <sys/stdtypes.h>
# endif
# include <stddef.h>
#endif /* def STDC_HEADERS */
#if (SCM_DEBUG_DEPRECATED == 0)
# define scm_sizet size_t
#endif
#include "libguile/tags.h"
#ifdef vms
# ifndef CHEAP_CONTINUATIONS
typedef int jmp_buf[17];
extern int setjump(jmp_buf env);
extern int longjump(jmp_buf env, int ret);
# define setjmp setjump
# define longjmp longjump
# else
# include <setjmp.h>
# endif
#else /* ndef vms */
# ifdef _CRAY1
typedef int jmp_buf[112];
extern int setjump(jmp_buf env);
extern int longjump(jmp_buf env, int ret);
# define setjmp setjump
# define longjmp longjump
# else /* ndef _CRAY1 */
# include <setjmp.h>
# endif /* ndef _CRAY1 */
#endif /* ndef vms */
/* James Clark came up with this neat one instruction fix for
* continuations on the SPARC. It flushes the register windows so
* that all the state of the process is contained in the stack.
*/
#ifdef sparc
# define SCM_FLUSH_REGISTER_WINDOWS asm("ta 3")
#else
# define SCM_FLUSH_REGISTER_WINDOWS /* empty */
#endif
/* If stack is not longword aligned then
*/
/* #define SHORT_ALIGN */
#ifdef THINK_C
# define SHORT_ALIGN
#endif
#ifdef MSDOS
# define SHORT_ALIGN
#endif
#ifdef atarist
# define SHORT_ALIGN
#endif
#ifdef SHORT_ALIGN
typedef short SCM_STACKITEM;
#else
typedef long SCM_STACKITEM;
#endif
#ifndef USE_THREADS
#define SCM_CRITICAL_SECTION_START
#define SCM_CRITICAL_SECTION_END
#define SCM_THREAD_SWITCHING_CODE
#endif
#ifdef GUILE_OLD_ASYNC_CLICK
extern unsigned int scm_async_clock;
#define SCM_ASYNC_TICK \
do { \
if (0 == --scm_async_clock) \
scm_async_click (); \
} while(0)
#else
extern int scm_asyncs_pending_p;
#define SCM_ASYNC_TICK /*fixme* should change names */ \
do { \
if (scm_asyncs_pending_p) \
scm_async_click (); \
} while (0)
#endif
#if (SCM_DEBUG_INTERRUPTS == 1)
#include <stdio.h>
#define SCM_CHECK_NOT_DISABLED \
do { \
if (scm_ints_disabled) \
fprintf(stderr, "ints already disabled (at %s:%d)\n", \
__FILE__, __LINE__); \
} while (0)
#define SCM_CHECK_NOT_ENABLED \
do { \
if (!scm_ints_disabled) \
fprintf(stderr, "ints already enabled (at %s:%d)\n", \
__FILE__, __LINE__); \
} while (0)
#else
#define SCM_CHECK_NOT_DISABLED
#define SCM_CHECK_NOT_ENABLED
#endif
/* Anthony Green writes:
When the compiler sees...
DEFER_INTS;
[critical code here]
ALLOW_INTS;
...it doesn't actually promise to keep the critical code within the
boundries of the DEFER/ALLOW_INTS instructions. It may very well
schedule it outside of the magic defined in those macros.
However, GCC's volatile asm feature forms a barrier over which code is
never moved. So if you add...
asm ("");
...to each of the DEFER_INTS and ALLOW_INTS macros, the critical
code will always remain in place. asm's without inputs or outputs
are implicitly volatile. */
#ifdef __GNUC__
#define SCM_FENCE asm /* volatile */ ("")
#else
#define SCM_FENCE
#endif
#define SCM_DEFER_INTS \
do { \
SCM_FENCE; \
SCM_CHECK_NOT_DISABLED; \
SCM_CRITICAL_SECTION_START; \
SCM_FENCE; \
scm_ints_disabled = 1; \
SCM_FENCE; \
} while (0)
#define SCM_ALLOW_INTS_ONLY \
do { \
SCM_CRITICAL_SECTION_END; \
scm_ints_disabled = 0; \
} while (0)
#define SCM_ALLOW_INTS \
do { \
SCM_FENCE; \
SCM_CHECK_NOT_ENABLED; \
SCM_CRITICAL_SECTION_END; \
SCM_FENCE; \
scm_ints_disabled = 0; \
SCM_FENCE; \
SCM_THREAD_SWITCHING_CODE; \
SCM_FENCE; \
} while (0)
#define SCM_REDEFER_INTS \
do { \
SCM_FENCE; \
SCM_CRITICAL_SECTION_START; \
++scm_ints_disabled; \
SCM_FENCE; \
} while (0)
#define SCM_REALLOW_INTS \
do { \
SCM_FENCE; \
SCM_CRITICAL_SECTION_END; \
SCM_FENCE; \
--scm_ints_disabled; \
SCM_FENCE; \
} while (0)
#define SCM_TICK \
do { \
SCM_ASYNC_TICK; \
SCM_THREAD_SWITCHING_CODE; \
} while (0)
/* Classification of critical sections
*
* When Guile moves to POSIX threads, it won't be possible to prevent
* context switching. In fact, the whole idea of context switching is
* bogus if threads are run by different processors. Therefore, we
* must ultimately eliminate all critical sections or enforce them by
* use of mutecis.
*
* All instances of SCM_DEFER_INTS and SCM_ALLOW_INTS should therefore
* be classified and replaced by one of the delimiters below. If you
* understand what this is all about, I'd like to encourage you to
* help with this task. The set of classes below must of course be
* incrementally augmented.
*
* MDJ 980419 <djurfeldt@nada.kth.se>
*/
/* A sections
*
* Allocation of a cell with type tag in the CAR.
*
* With POSIX threads, each thread will have a private pool of free
* cells. Therefore, this type of section can be removed. But! It
* is important that the CDR is initialized first (with the CAR still
* indicating a free cell) so that we can guarantee a consistent heap
* at all times.
*/
#define SCM_ENTER_A_SECTION SCM_CRITICAL_SECTION_START
#define SCM_EXIT_A_SECTION SCM_CRITICAL_SECTION_END
/** SCM_ASSERT
**
**/
#ifdef SCM_RECKLESS
#define SCM_ASSERT(_cond, _arg, _pos, _subr)
#define SCM_ASSERT_TYPE(_cond, _arg, _pos, _subr, _msg)
#define SCM_ASRTGO(_cond, _label)
#else
#define SCM_ASSERT(_cond, _arg, _pos, _subr) \
if (!(_cond)) \
scm_wrong_type_arg (_subr, _pos, _arg)
#define SCM_ASSERT_TYPE(_cond, _arg, _pos, _subr, _msg) \
if (!(_cond)) \
scm_wrong_type_arg_msg(_subr, _pos, _arg, _msg)
#define SCM_ASRTGO(_cond, _label) \
if (!(_cond)) \
goto _label
#endif
/*
* SCM_WTA_DISPATCH
*/
/* Dirk:FIXME:: In all of the SCM_WTA_DISPATCH_* macros it is assumed that
* 'gf' is zero if uninitialized. It would be cleaner if some valid SCM value
* like SCM_BOOL_F or SCM_UNDEFINED was chosen.
*/
extern SCM scm_call_generic_0 (SCM gf);
#define SCM_WTA_DISPATCH_0(gf, subr) \
return (SCM_UNPACK (gf) \
? scm_call_generic_0 ((gf)) \
: (scm_error_num_args_subr ((subr)), SCM_UNSPECIFIED))
#define SCM_GASSERT0(cond, gf, subr) \
if (!(cond)) SCM_WTA_DISPATCH_0((gf), (subr))
extern SCM scm_call_generic_1 (SCM gf, SCM a1);
#define SCM_WTA_DISPATCH_1(gf, a1, pos, subr) \
return (SCM_UNPACK (gf) \
? scm_call_generic_1 ((gf), (a1)) \
: (scm_wrong_type_arg ((subr), (pos), (a1)), SCM_UNSPECIFIED))
#define SCM_GASSERT1(cond, gf, a1, pos, subr) \
if (!(cond)) SCM_WTA_DISPATCH_1((gf), (a1), (pos), (subr))
extern SCM scm_call_generic_2 (SCM gf, SCM a1, SCM a2);
#define SCM_WTA_DISPATCH_2(gf, a1, a2, pos, subr) \
return (SCM_UNPACK (gf) \
? scm_call_generic_2 ((gf), (a1), (a2)) \
: (scm_wrong_type_arg ((subr), (pos), \
(pos) == SCM_ARG1 ? (a1) : (a2)), \
SCM_UNSPECIFIED))
#define SCM_GASSERT2(cond, gf, a1, a2, pos, subr) \
if (!(cond)) SCM_WTA_DISPATCH_2((gf), (a1), (a2), (pos), (subr))
extern SCM scm_apply_generic (SCM gf, SCM args);
#define SCM_WTA_DISPATCH_n(gf, args, pos, subr) \
return (SCM_UNPACK (gf) \
? scm_apply_generic ((gf), (args)) \
: (scm_wrong_type_arg ((subr), (pos), \
scm_list_ref ((args), \
SCM_MAKINUM ((pos) - 1))), \
SCM_UNSPECIFIED))
#define SCM_GASSERTn(cond, gf, args, pos, subr) \
if (!(cond)) SCM_WTA_DISPATCH_n((gf), (args), (pos), (subr))
#ifndef SCM_MAGIC_SNARFER
/* Let these macros pass through if
we are snarfing; thus we can tell the
difference between the use of an actual
number vs. the use of one of these macros --
actual numbers in SCM_VALIDATE_* and SCM_ASSERT
constructs must match the formal argument name,
but using SCM_ARG* avoids the test */
#define SCM_ARGn 0
#define SCM_ARG1 1
#define SCM_ARG2 2
#define SCM_ARG3 3
#define SCM_ARG4 4
#define SCM_ARG5 5
#define SCM_ARG6 6
#define SCM_ARG7 7
#if (SCM_DEBUG_DEPRECATED == 0)
/* Use SCM_WRONG_NUM_ARGS instead of: */
#define SCM_WNA 8
/* Use SCM_ASSERT_RANGE or SCM_VALIDATE_XXX_RANGE instead of: */
#define SCM_OUTOFRANGE 10
/* Use scm_memory_error instead of: */
#define SCM_NALLOC 11
#define SCM_HUP_SIGNAL 14
#define SCM_INT_SIGNAL 15
#define SCM_FPE_SIGNAL 16
#define SCM_BUS_SIGNAL 17
#define SCM_SEGV_SIGNAL 18
#define SCM_ALRM_SIGNAL 19
#define SCM_GC_SIGNAL 20
#define SCM_TICK_SIGNAL 21
#define SCM_SIG_ORD(X) ((X) - SCM_HUP_SIGNAL)
#define SCM_ORD_SIG(X) ((X) + SCM_HUP_SIGNAL)
#define SCM_NUM_SIGS (SCM_SIG_ORD (SCM_TICK_SIGNAL) + 1)
#endif /* SCM_DEBUG_DEPRECATED == 0 */
#endif /* SCM_MAGIC_SNARFER */
/* SCM_EXIT_SUCCESS is the default code to return from SCM if no errors
* were encountered. SCM_EXIT_FAILURE is the default code to return from
* SCM if errors were encountered. The return code can be explicitly
* specified in a SCM program with (scm_quit <n>).
*/
#ifndef SCM_EXIT_SUCCESS
#ifdef vms
#define SCM_EXIT_SUCCESS 1
#else
#define SCM_EXIT_SUCCESS 0
#endif /* def vms */
#endif /* ndef SCM_EXIT_SUCCESS */
#ifndef SCM_EXIT_FAILURE
#ifdef vms
#define SCM_EXIT_FAILURE 2
#else
#define SCM_EXIT_FAILURE 1
#endif /* def vms */
#endif /* ndef SCM_EXIT_FAILURE */
#endif /* __SCMH */
/*
Local Variables:
c-file-style: "gnu"
End:
*/
View git blame Copy permalink