libguile/__scm.h

   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,
   7  *   2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
   8  *
   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.
  13  *
  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.
  18  *
  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
  22  * 02110-1301 USA
  23  */
  24
  25 \f
  26
  27 /**********************************************************************
  28  This file is Guile's central public header.
  29
  30  When included by other files, this file should preceed any include
  31  other than __scm.h.
  32
  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.
  40
  41  "What's the difference between _scm.h and __scm.h?"
  42
  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.
  45
  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
  50    config header.
  51  **********************************************************************/
  52
  53 /* What did the configure script discover about the outside world?  */
  54 #include "libguile/scmconfig.h"
  55
  56 \f
  57
  58 /* {Compiler hints}
  59  *
  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.
  64  */
  65
  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))
  71 #else
  72 # define SCM_GNUC_PREREQ(maj, min) 0
  73 #endif
  74
  75 /* The macro SCM_NORETURN indicates that a function will never return.
  76  * Examples:
  77  *   1) int foo (char arg) SCM_NORETURN;
  78  */
  79 #ifdef __GNUC__
  80 #define SCM_NORETURN __attribute__ ((noreturn))
  81 #else
  82 #define SCM_NORETURN
  83 #endif
  84
  85 /* The macro SCM_UNUSED indicates that a function, function argument or
  86  * variable may potentially be unused.
  87  * Examples:
  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;
  91  */
  92 #ifdef __GNUC__
  93 #define SCM_UNUSED __attribute__ ((unused))
  94 #else
  95 #define SCM_UNUSED
  96 #endif
  97
  98
  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
 104 #else
 105 # define SCM_EXPECT(_expr, _value) (_expr)
 106 #endif
 107
 108 #define SCM_LIKELY(_expr)    SCM_EXPECT ((_expr), 1)
 109 #define SCM_UNLIKELY(_expr)  SCM_EXPECT ((_expr), 0)
 110
 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
 116
 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__))
 123 #else
 124 # define SCM_DEPRECATED  SCM_API
 125 #endif
 126
 127 /* The SCM_ALIGNED macro, when defined, can be used to instruct the compiler
 128  * to honor the given alignment constraint.  */
 129 #if defined __GNUC__
 130 # define SCM_ALIGNED(x)  __attribute__ ((aligned (x)))
 131 #elif defined __INTEL_COMPILER
 132 # define SCM_ALIGNED(x)  __declspec (align (x))
 133 #else
 134 /* Don't know how to align things.  */
 135 # undef SCM_ALIGNED
 136 #endif
 137
 138 /* The SCM_MALLOC macro can be used in function declarations to tell the
 139  * compiler that a function may be treated as if any non-NULL pointer it returns
 140  * cannot alias any other pointer valid when the function returns.  */
 141 #if SCM_GNUC_PREREQ (3, 0)
 142 # define SCM_MALLOC  __attribute__ ((__malloc__))
 143 #else
 144 # define SCM_MALLOC
 145 #endif
 146
 147 \f
 148
 149 /* SCM_API is a macro prepended to all function and data definitions
 150    which should be exported from libguile. */
 151
 152 #if defined BUILDING_LIBGUILE && defined HAVE_VISIBILITY
 153 # define SCM_API extern __attribute__((__visibility__("default")))
 154 #elif defined BUILDING_LIBGUILE && defined _MSC_VER
 155 # define SCM_API __declspec(dllexport) extern
 156 #elif defined _MSC_VER
 157 # define SCM_API __declspec(dllimport) extern
 158 #else
 159 # define SCM_API extern
 160 #endif
 161
 162 \f
 163
 164 /* We would like gnu89 extern inline semantics, not C99 extern inline
 165    semantics, so that we can be sure to avoid reifying definitions of
 166    inline functions in all compilation units, which is a possibility at
 167    low optimization levels, or if a user takes the address of an inline
 168    function.
 169
 170    Hence the `__gnu_inline__' attribute, in accordance with:
 171    http://gcc.gnu.org/gcc-4.3/porting_to.html .
 172
 173    With GCC 4.2, `__GNUC_STDC_INLINE__' is never defined (because C99 inline
 174    semantics are not supported), but a warning is issued in C99 mode if
 175    `__gnu_inline__' is not used.
 176
 177    Apple's GCC build >5400 (since Xcode 3.0) doesn't support GNU inline in
 178    C99 mode and doesn't define `__GNUC_STDC_INLINE__'.  Fall back to "static
 179    inline" in that case.  */
 180
 181 # if (defined __GNUC__) && (!(((defined __APPLE_CC__) && (__APPLE_CC__ > 5400)) && __STDC_VERSION__ >= 199901L))
 182 #  if (defined __GNUC_STDC_INLINE__) || (__GNUC__ == 4 && __GNUC_MINOR__ == 2)
 183 #   define SCM_C_EXTERN_INLINE                                  \
 184            extern __inline__ __attribute__ ((__gnu_inline__))
 185 #  else
 186 #   define SCM_C_EXTERN_INLINE extern __inline__
 187 #  endif
 188 # endif
 189
 190 /* SCM_INLINE is a macro prepended to all public inline function
 191    declarations.  Implementations of those functions should also be in
 192    the header file, prefixed by SCM_INLINE_IMPLEMENTATION, and protected
 193    by SCM_CAN_INLINE and a CPP define for the C file in question, like
 194    SCM_INLINE_C_INCLUDING_INLINE_H.  See inline.h for an example
 195    usage.  */
 196
 197 #if defined SCM_IMPLEMENT_INLINES
 198 /* Reifying functions to a file, whether or not inlining is available.  */
 199 # define SCM_CAN_INLINE 0
 200 # define SCM_INLINE SCM_API
 201 # define SCM_INLINE_IMPLEMENTATION
 202 #elif defined SCM_C_INLINE
 203 /* Declarations when inlining is available.  */
 204 # define SCM_CAN_INLINE 1
 205 # ifdef SCM_C_EXTERN_INLINE
 206 #  define SCM_INLINE SCM_C_EXTERN_INLINE
 207 # else
 208 /* Fall back to static inline if GNU "extern inline" is unavailable.  */
 209 #  define SCM_INLINE static SCM_C_INLINE
 210 # endif
 211 # define SCM_INLINE_IMPLEMENTATION SCM_INLINE
 212 #else
 213 /* Declarations when inlining is not available.  */
 214 # define SCM_CAN_INLINE 0
 215 # define SCM_INLINE SCM_API
 216 /* Don't define SCM_INLINE_IMPLEMENTATION; it should never be seen in
 217    this case.  */
 218 #endif
 219
 220 \f
 221
 222 /* {Debugging Options}
 223  *
 224  * These compile time options determine whether to include code that is only
 225  * useful for debugging guile itself or C level extensions to guile.  The
 226  * common prefix for all option macros of this kind is "SCM_DEBUG_".  It is
 227  * guaranteed that a macro named SCM_DEBUG_XXX is always defined (typically to
 228  * either 0 or 1), i. e. there is no need to test for the undefined case.
 229  * This allows to use these definitions comfortably within code, as in the
 230  * following example:
 231  *   #define FOO do { if (SCM_DEBUG_XXX) bar(); else baz(); } while (0)
 232  * Any sane compiler will remove the unused branch without any performance
 233  * penalty for the resulting code.
 234  *
 235  * Note:  Some SCM_DEBUG_XXX options are not settable at configure time.
 236  * To change the value of such options you will have to edit this header
 237  * file or give suitable options to make, like:
 238  *   make all CFLAGS="-DSCM_DEBUG_XXX=1 ..."
 239  */
 240
 241
 242 /* The value of SCM_DEBUG determines the default for most of the not yet
 243  * defined debugging options.  This allows, for example, to enable most of the
 244  * debugging options by simply defining SCM_DEBUG as 1.
 245  */
 246 #ifndef SCM_DEBUG
 247 #define SCM_DEBUG 0
 248 #endif
 249
 250 /* If SCM_DEBUG_CELL_ACCESSES is set to 1, cell accesses will perform
 251  * exhaustive parameter checking:  It will be verified that cell parameters
 252  * actually point to a valid heap cell.  Note:  If this option is enabled,
 253  * guile will run about ten times slower than normally.
 254  */
 255 #ifndef SCM_DEBUG_CELL_ACCESSES
 256 #define SCM_DEBUG_CELL_ACCESSES SCM_DEBUG
 257 #endif
 258
 259 /* If SCM_DEBUG_PAIR_ACCESSES is set to 1, accesses to cons cells will be
 260  * exhaustively checked.  Note:  If this option is enabled, guile will run
 261  * slower than normally.
 262  */
 263 #ifndef SCM_DEBUG_PAIR_ACCESSES
 264 #define SCM_DEBUG_PAIR_ACCESSES SCM_DEBUG
 265 #endif
 266
 267 /* If SCM_DEBUG_REST_ARGUMENT is set to 1, functions that take rest arguments
 268  * will check whether the rest arguments are actually passed as a proper list.
 269  * Otherwise, if SCM_DEBUG_REST_ARGUMENT is 0, functions that take rest
 270  * arguments will take it for granted that these are passed as a proper list.
 271  */
 272 #ifndef SCM_DEBUG_REST_ARGUMENT
 273 #define SCM_DEBUG_REST_ARGUMENT SCM_DEBUG
 274 #endif
 275
 276 /* The macro SCM_DEBUG_TYPING_STRICTNESS indicates what level of type checking
 277  * shall be performed with respect to the use of the SCM datatype.  The macro
 278  * may be defined to one of the values 0, 1 and 2.
 279  *
 280  * A value of 0 means that there will be no compile time type checking, since
 281  * the SCM datatype will be declared as an integral type.  This setting should
 282  * only be used on systems, where casting from integral types to pointers may
 283  * lead to loss of bit information.
 284  *
 285  * A value of 1 means that there will an intermediate level of compile time
 286  * type checking, since the SCM datatype will be declared as a pointer to an
 287  * undefined struct.  This setting is the default, since it does not cost
 288  * anything in terms of performance or code size.
 289  *
 290  * A value of 2 provides a maximum level of compile time type checking since
 291  * the SCM datatype will be declared as a struct.  This setting should be used
 292  * for _compile time_ type checking only, since the compiled result is likely
 293  * to be quite inefficient.  The right way to make use of this option is to do
 294  * a 'make clean; make CFLAGS=-DSCM_DEBUG_TYPING_STRICTNESS=2', fix your
 295  * errors, and then do 'make clean; make'.
 296  */
 297 #ifndef SCM_DEBUG_TYPING_STRICTNESS
 298 #define SCM_DEBUG_TYPING_STRICTNESS 1
 299 #endif
 300
 301 \f
 302
 303 /* {Feature Options}
 304  *
 305  * These compile time options determine whether code for certain features
 306  * should be compiled into guile.  The common prefix for all option macros
 307  * of this kind is "SCM_ENABLE_".  It is guaranteed that a macro named
 308  * SCM_ENABLE_XXX is defined to be either 0 or 1, i. e. there is no need to
 309  * test for the undefined case.  This allows to use these definitions
 310  * comfortably within code, as in the following example:
 311  *   #define FOO do { if (SCM_ENABLE_XXX) bar(); else baz(); } while (0)
 312  * Any sane compiler will remove the unused branch without any performance
 313  * penalty for the resulting code.
 314  *
 315  * Note:  Some SCM_ENABLE_XXX options are not settable at configure time.
 316  * To change the value of such options you will have to edit this header
 317  * file or give suitable options to make, like:
 318  *   make all CFLAGS="-DSCM_ENABLE_XXX=1 ..."
 319  */
 320
 321 /* If SCM_ENABLE_DEPRECATED is set to 1, deprecated code will be included in
 322  * guile, as well as some functions to issue run-time warnings about uses of
 323  * deprecated functions.
 324  */
 325 #ifndef SCM_ENABLE_DEPRECATED
 326 #define SCM_ENABLE_DEPRECATED 0
 327 #endif
 328
 329 \f
 330
 331 /* {Architecture and compiler properties}
 332  *
 333  * Guile as of today can only work on systems which fulfill at least the
 334  * following requirements:
 335  *
 336  * - scm_t_bits and SCM variables have at least 32 bits.
 337  *   Guile's type system is based on this assumption.
 338  *
 339  * - sizeof (scm_t_bits) >= sizeof (void*) and sizeof (SCM) >= sizeof (void*)
 340  *   Guile's type system is based on this assumption, since it must be
 341  *   possible to store pointers to cells on the heap in scm_t_bits and SCM
 342  *   variables.
 343  *
 344  * - sizeof (scm_t_bits) >= 4 and sizeof (scm_t_bits) is a power of 2.
 345  *   Guile's type system is based on this assumption.  In particular, it is
 346  *   assumed that cells, i. e. pairs of scm_t_bits variables, are eight
 347  *   character aligned.  This is because three bits of a scm_t_bits variable
 348  *   that is holding a pointer to a cell on the heap must be available for
 349  *   storing type data.
 350  *
 351  * - sizeof (scm_t_bits) <= sizeof (void*) and sizeof (SCM) <= sizeof (void*)
 352  *   In some parts of guile, scm_t_bits and SCM variables are passed to
 353  *   functions as void* arguments.  Together with the requirement above, this
 354  *   requires a one-to-one correspondence between the size of a void* and the
 355  *   sizes of scm_t_bits and SCM variables.
 356  *
 357  * - numbers are encoded using two's complement.
 358  *   The implementation of the bitwise scheme level operations is based on
 359  *   this assumption.
 360  *
 361  * - ... add more
 362  */
 363
 364 #ifdef CHAR_BIT
 365 # define SCM_CHAR_BIT CHAR_BIT
 366 #else
 367 # define SCM_CHAR_BIT 8
 368 #endif
 369
 370 #ifdef LONG_BIT
 371 # define SCM_LONG_BIT LONG_BIT
 372 #else
 373 # define SCM_LONG_BIT (SCM_CHAR_BIT * sizeof (long) / sizeof (char))
 374 #endif
 375
 376 #define SCM_I_UTYPE_MAX(type)      ((type)-1)
 377 #define SCM_I_TYPE_MAX(type,umax)  ((type)((umax)/2))
 378 #define SCM_I_TYPE_MIN(type,umax)  (-((type)((umax)/2))-1)
 379
 380 #define SCM_T_UINT8_MAX   SCM_I_UTYPE_MAX(scm_t_uint8)
 381 #define SCM_T_INT8_MIN    SCM_I_TYPE_MIN(scm_t_int8,SCM_T_UINT8_MAX)
 382 #define SCM_T_INT8_MAX    SCM_I_TYPE_MAX(scm_t_int8,SCM_T_UINT8_MAX)
 383
 384 #define SCM_T_UINT16_MAX  SCM_I_UTYPE_MAX(scm_t_uint16)
 385 #define SCM_T_INT16_MIN   SCM_I_TYPE_MIN(scm_t_int16,SCM_T_UINT16_MAX)
 386 #define SCM_T_INT16_MAX   SCM_I_TYPE_MAX(scm_t_int16,SCM_T_UINT16_MAX)
 387
 388 #define SCM_T_UINT32_MAX  SCM_I_UTYPE_MAX(scm_t_uint32)
 389 #define SCM_T_INT32_MIN   SCM_I_TYPE_MIN(scm_t_int32,SCM_T_UINT32_MAX)
 390 #define SCM_T_INT32_MAX   SCM_I_TYPE_MAX(scm_t_int32,SCM_T_UINT32_MAX)
 391
 392 #define SCM_T_UINT64_MAX  SCM_I_UTYPE_MAX(scm_t_uint64)
 393 #define SCM_T_INT64_MIN   SCM_I_TYPE_MIN(scm_t_int64,SCM_T_UINT64_MAX)
 394 #define SCM_T_INT64_MAX   SCM_I_TYPE_MAX(scm_t_int64,SCM_T_UINT64_MAX)
 395
 396 #define SCM_T_UINTMAX_MAX SCM_I_UTYPE_MAX(scm_t_uintmax)
 397 #define SCM_T_INTMAX_MIN  SCM_I_TYPE_MIN(scm_t_intmax,SCM_T_UINTMAX_MAX)
 398 #define SCM_T_INTMAX_MAX  SCM_I_TYPE_MAX(scm_t_intmax,SCM_T_UINTMAX_MAX)
 399
 400 #define SCM_T_UINTPTR_MAX SCM_I_UTYPE_MAX(scm_t_uintptr)
 401 #define SCM_T_INTPTR_MIN  SCM_I_TYPE_MIN(scm_t_intptr,SCM_T_UINTPTR_MAX)
 402 #define SCM_T_INTPTR_MAX  SCM_I_TYPE_MAX(scm_t_intptr,SCM_T_UINTPTR_MAX)
 403
 404 \f
 405
 406 #include "libguile/tags.h"
 407
 408
 409 /* The type of subrs, i.e., Scheme procedures implemented in C.  Empty
 410    function declarators are used internally for pointers to functions of
 411    any arity.  However, these are equivalent to `(void)' in C++, are
 412    obsolescent as of C99, and trigger `strict-prototypes' GCC warnings
 413    (bug #23681).  */
 414
 415 #ifdef BUILDING_LIBGUILE
 416 typedef SCM (* scm_t_subr) ();
 417 #else
 418 typedef void *scm_t_subr;
 419 #endif
 420
 421 \f
 422
 423 /* scm_i_jmp_buf
 424  *
 425  * The corresponding SCM_I_SETJMP and SCM_I_LONGJMP are defined in the
 426  * _scm.h private header.
 427  */
 428
 429 #if defined (vms)
 430 typedef int scm_i_jmp_buf[17];
 431
 432 #elif defined (_CRAY1)
 433 typedef int scm_i_jmp_buf[112];
 434
 435 #elif defined (__ia64__)
 436 # include <signal.h>
 437 # include <ucontext.h>
 438 typedef struct {
 439   ucontext_t ctx;
 440   int fresh;
 441 } scm_i_jmp_buf;
 442
 443 #else
 444 # include <setjmp.h>
 445 typedef jmp_buf scm_i_jmp_buf;
 446 #endif
 447
 448
 449 \f
 450
 451 /* If stack is not longword aligned then
 452  */
 453
 454 /* #define SHORT_ALIGN */
 455 #ifdef THINK_C
 456 # define SHORT_ALIGN
 457 #endif
 458 #ifdef MSDOS
 459 # define SHORT_ALIGN
 460 #endif
 461 #ifdef atarist
 462 # define SHORT_ALIGN
 463 #endif
 464
 465 #ifdef SHORT_ALIGN
 466 typedef short SCM_STACKITEM;
 467 #else
 468 typedef long SCM_STACKITEM;
 469 #endif
 470
 471 /* Cast pointer through (void *) in order to avoid compiler warnings
 472    when strict aliasing is enabled */
 473 #define SCM_STACK_PTR(ptr) ((SCM_STACKITEM *) (void *) (ptr))
 474 \f
 475
 476 #ifdef BUILDING_LIBGUILE
 477 #define SCM_TICK SCM_ASYNC_TICK
 478 #else
 479 #define SCM_TICK scm_async_tick ()
 480 #endif
 481
 482 \f
 483
 484 #ifndef SCM_MAGIC_SNARFER
 485 /* Let these macros pass through if
 486    we are snarfing;  thus we can tell the
 487    difference between the use of an actual
 488    number vs. the use of one of these macros --
 489    actual numbers in SCM_VALIDATE_* and SCM_ASSERT
 490    constructs must match the formal argument name,
 491    but using SCM_ARG* avoids the test */
 492
 493 #define SCM_ARGn                0
 494 #define SCM_ARG1                1
 495 #define SCM_ARG2                2
 496 #define SCM_ARG3                3
 497 #define SCM_ARG4                4
 498 #define SCM_ARG5                5
 499 #define SCM_ARG6                6
 500 #define SCM_ARG7                7
 501
 502 #endif /* SCM_MAGIC_SNARFER */
 503
 504 \f
 505
 506 /* Define SCM_C_INLINE_KEYWORD so that it can be used as a replacement
 507    for the "inline" keyword, expanding to nothing when "inline" is not
 508    available.
 509 */
 510
 511 #ifdef SCM_C_INLINE
 512 #define SCM_C_INLINE_KEYWORD SCM_C_INLINE
 513 #else
 514 #define SCM_C_INLINE_KEYWORD
 515 #endif
 516
 517 /* Handling thread-local storage (TLS).  */
 518
 519 #ifdef SCM_HAVE_THREAD_STORAGE_CLASS
 520 # define SCM_THREAD_LOCAL __thread
 521 #else
 522 # define SCM_THREAD_LOCAL
 523 #endif
 524
 525 #endif  /* SCM___SCM_H */
 526
 527 /*
 528   Local Variables:
 529   c-file-style: "gnu"
 530   End:
 531 */