mirror/guile
mirror/guile
1
Fork 0
mirror of https://git.savannah.gnu.org/git/guile.git synced 2025-05-20 11:40:18 +02:00
Code Activity

SCM is either a union or scm_t_bits

Browse source 
* libguile/tags.h: Elide the SCM_DEBUG_TYPING_STRICTNESS==1 case.
  Instead just have a flag, SCM_USING_PREHISTORIC_COMPILER, which if set
  uses what was SCM_DEBUG_TYPING_STRICTNESS==0.

* libguile/__scm.h: Remove SCM_DEBUG_TYPING_STRICTNESS block.
This commit is contained in:
Andy Wingo 2011-05-15 10:49:44 +02:00
parent 8787d7a170
commit 80125469ef
2 changed files with 18 additions and 63 deletions
Download patch file Download diff file Expand all files Collapse all files

25
libguile/__scm.h
View file

@ -261,31 +261,6 @@
#define SCM_DEBUG_REST_ARGUMENT SCM_DEBUG
#endif
/* The macro SCM_DEBUG_TYPING_STRICTNESS indicates what level of type checking
* shall be performed with respect to the use of the SCM datatype. The macro
* may be defined to one of the values 0, 1 and 2.
*
* A value of 0 means that there will be no compile time type checking, since
* the SCM datatype will be declared as an integral type. This setting should
* only be used on systems, where casting from integral types to pointers may
* lead to loss of bit information.
*
* A value of 1 means that there will an intermediate level of compile time
* type checking, since the SCM datatype will be declared as a pointer to an
* undefined struct. This setting is the default, since it does not cost
* anything in terms of performance or code size.
*
* A value of 2 provides a maximum level of compile time type checking since
* the SCM datatype will be declared as a struct. This setting should be used
* for _compile time_ type checking only, since the compiled result is likely
* to be quite inefficient. The right way to make use of this option is to do
* a 'make clean; make CFLAGS=-DSCM_DEBUG_TYPING_STRICTNESS=2', fix your
* errors, and then do 'make clean; make'.
*/
#ifndef SCM_DEBUG_TYPING_STRICTNESS
#define SCM_DEBUG_TYPING_STRICTNESS 2
#endif
/* If SCM_DEBUG_DEBUGGING_SUPPORT is set to 1, guile will provide a set of
* special functions that support debugging with a debugger like gdb or
* debugging of guile internals on the scheme level. The behaviour of guile

56
libguile/tags.h
View file

@ -61,7 +61,6 @@
/* For dealing with the bit level representation of scheme objects we define
* scm_t_bits:
*/
typedef scm_t_intptr scm_t_signed_bits;
typedef scm_t_uintptr scm_t_bits;
@ -70,47 +69,28 @@ typedef scm_t_uintptr scm_t_bits;
#define SCM_T_BITS_MAX SCM_T_UINTPTR_MAX
/* But as external interface, we define SCM, which may, according to the
* desired level of type checking, be defined in several ways:
/* But as external interface, we pack the bits in a union. This makes
* the compiler treat SCM values as a disjoint type, allowing the
* detection of many common errors.
*/
#if (SCM_DEBUG_TYPING_STRICTNESS == 2)
typedef union SCM { scm_t_bits n; } SCM;
# define SCM_UNPACK(x) ((x).n)
# define SCM_PACK(x) ((SCM) { (scm_t_bits) (x) })
#elif (SCM_DEBUG_TYPING_STRICTNESS == 1)
/* This is the default, which provides an intermediate level of compile time
* type checking while still resulting in very efficient code.
union SCM
{
scm_t_bits n;
};
#ifndef SCM_USING_PREHISTORIC_COMPILER
/* With GCC at least, wrapping the bits in a union provides no
* performance penalty.
*/
typedef struct scm_unused_struct { char scm_unused_field; } *SCM;
/*
The 0?: constructions makes sure that the code is never executed,
and that there is no performance hit. However, the alternative is
compiled, and does generate a warning when used with the wrong
pointer type.
The Tru64 and ia64-hp-hpux11.23 compilers fail on `case (0?0=0:x)'
statements, so for them type-checking is disabled. */
#if defined __DECC || defined __HP_cc
# define SCM_UNPACK(x) ((scm_t_bits) (x))
typedef union SCM SCM;
#define SCM_UNPACK(x) ((x).n)
#define SCM_PACK(x) ((SCM) { (scm_t_bits) (x) })
#else
# define SCM_UNPACK(x) ((scm_t_bits) (0? (*(SCM*)0=(x)): x))
#endif
/*
There is no typechecking on SCM_PACK, since all kinds of types
(unsigned long, void*) go in SCM_PACK
/* But we do provide an escape valve for less capable compilers.
*/
# define SCM_PACK(x) ((SCM) (x))
#else
/* This should be used as a fall back solution for machines on which casting
* to a pointer may lead to loss of bit information, e. g. in the three least
* significant bits.
*/
typedef scm_t_bits SCM;
# define SCM_UNPACK(x) (x)
# define SCM_PACK(x) ((SCM) (x))
typedef scm_t_bits SCM;
#define SCM_UNPACK(x) (x)
#define SCM_PACK(x) ((SCM) (x))
#endif