Ruby  2.0.0p247(2013-06-27revision41674)
include/ruby/ruby.h
Go to the documentation of this file.
00001 /**********************************************************************
00002 
00003   ruby/ruby.h -
00004 
00005   $Author: nagachika $
00006   created at: Thu Jun 10 14:26:32 JST 1993
00007 
00008   Copyright (C) 1993-2008 Yukihiro Matsumoto
00009   Copyright (C) 2000  Network Applied Communication Laboratory, Inc.
00010   Copyright (C) 2000  Information-technology Promotion Agency, Japan
00011 
00012 **********************************************************************/
00013 
00014 #ifndef RUBY_RUBY_H
00015 #define RUBY_RUBY_H 1
00016 
00017 #if defined(__cplusplus)
00018 extern "C" {
00019 #if 0
00020 } /* satisfy cc-mode */
00021 #endif
00022 #endif
00023 
00024 #include "ruby/config.h"
00025 #ifdef RUBY_EXTCONF_H
00026 #include RUBY_EXTCONF_H
00027 #endif
00028 
00029 #define NORETURN_STYLE_NEW 1
00030 #ifndef NORETURN
00031 # define NORETURN(x) x
00032 #endif
00033 #ifndef DEPRECATED
00034 # define DEPRECATED(x) x
00035 #endif
00036 #ifndef NOINLINE
00037 # define NOINLINE(x) x
00038 #endif
00039 #ifndef UNREACHABLE
00040 # define UNREACHABLE            /* unreachable */
00041 #endif
00042 
00043 #ifdef __GNUC__
00044 #define PRINTF_ARGS(decl, string_index, first_to_check) \
00045   decl __attribute__((format(printf, string_index, first_to_check)))
00046 #else
00047 #define PRINTF_ARGS(decl, string_index, first_to_check) decl
00048 #endif
00049 
00050 #ifdef HAVE_STRING_H
00051 # include <string.h>
00052 #else
00053 # include <strings.h>
00054 #endif
00055 
00056 #ifdef HAVE_INTRINSICS_H
00057 # include <intrinsics.h>
00058 #endif
00059 
00060 #ifdef HAVE_STDINT_H
00061 # include <stdint.h>
00062 #endif
00063 #ifdef HAVE_INTTYPES_H
00064 # include <inttypes.h>
00065 #endif
00066 
00067 #include <stdarg.h>
00068 #include <stdio.h>
00069 
00070 #include "defines.h"
00071 
00072 #if defined __GNUC__ && __GNUC__ >= 4
00073 #pragma GCC visibility push(default)
00074 #endif
00075 
00076 /* Make alloca work the best possible way.  */
00077 #ifdef __GNUC__
00078 # ifndef atarist
00079 #  ifndef alloca
00080 #   define alloca __builtin_alloca
00081 #  endif
00082 # endif /* atarist */
00083 #else
00084 # ifdef HAVE_ALLOCA_H
00085 #  include <alloca.h>
00086 # else
00087 #  ifdef _AIX
00088 #pragma alloca
00089 #  else
00090 #   ifndef alloca               /* predefined by HP cc +Olibcalls */
00091 void *alloca();
00092 #   endif
00093 #  endif /* AIX */
00094 # endif /* HAVE_ALLOCA_H */
00095 #endif /* __GNUC__ */
00096 
00097 #if defined HAVE_UINTPTR_T && 0
00098 typedef uintptr_t VALUE;
00099 typedef uintptr_t ID;
00100 # define SIGNED_VALUE intptr_t
00101 # define SIZEOF_VALUE SIZEOF_UINTPTR_T
00102 # undef PRI_VALUE_PREFIX
00103 #elif SIZEOF_LONG == SIZEOF_VOIDP
00104 typedef unsigned long VALUE;
00105 typedef unsigned long ID;
00106 # define SIGNED_VALUE long
00107 # define SIZEOF_VALUE SIZEOF_LONG
00108 # define PRI_VALUE_PREFIX "l"
00109 #elif SIZEOF_LONG_LONG == SIZEOF_VOIDP
00110 typedef unsigned LONG_LONG VALUE;
00111 typedef unsigned LONG_LONG ID;
00112 # define SIGNED_VALUE LONG_LONG
00113 # define LONG_LONG_VALUE 1
00114 # define SIZEOF_VALUE SIZEOF_LONG_LONG
00115 # define PRI_VALUE_PREFIX PRI_LL_PREFIX
00116 #else
00117 # error ---->> ruby requires sizeof(void*) == sizeof(long) or sizeof(LONG_LONG) to be compiled. <<----
00118 #endif
00119 
00120 typedef char ruby_check_sizeof_int[SIZEOF_INT == sizeof(int) ? 1 : -1];
00121 typedef char ruby_check_sizeof_long[SIZEOF_LONG == sizeof(long) ? 1 : -1];
00122 #ifdef SIZEOF_LONG_LONG
00123 typedef char ruby_check_sizeof_long_long[SIZEOF_LONG_LONG == sizeof(LONG_LONG) ? 1 : -1];
00124 #endif
00125 typedef char ruby_check_sizeof_voidp[SIZEOF_VOIDP == sizeof(void*) ? 1 : -1];
00126 
00127 #ifndef PRI_INT_PREFIX
00128 #define PRI_INT_PREFIX ""
00129 #endif
00130 #ifndef PRI_LONG_PREFIX
00131 #define PRI_LONG_PREFIX "l"
00132 #endif
00133 
00134 #if defined PRIdPTR && !defined PRI_VALUE_PREFIX
00135 #define PRIdVALUE PRIdPTR
00136 #define PRIoVALUE PRIoPTR
00137 #define PRIuVALUE PRIuPTR
00138 #define PRIxVALUE PRIxPTR
00139 #define PRIXVALUE PRIXPTR
00140 #define PRIsVALUE PRIiPTR
00141 #else
00142 #define PRIdVALUE PRI_VALUE_PREFIX"d"
00143 #define PRIoVALUE PRI_VALUE_PREFIX"o"
00144 #define PRIuVALUE PRI_VALUE_PREFIX"u"
00145 #define PRIxVALUE PRI_VALUE_PREFIX"x"
00146 #define PRIXVALUE PRI_VALUE_PREFIX"X"
00147 #define PRIsVALUE PRI_VALUE_PREFIX"i"
00148 #endif
00149 #ifndef PRI_VALUE_PREFIX
00150 # define PRI_VALUE_PREFIX ""
00151 #endif
00152 
00153 #ifndef PRI_TIMET_PREFIX
00154 # if SIZEOF_TIME_T == SIZEOF_INT
00155 #  define PRI_TIMET_PREFIX
00156 # elif SIZEOF_TIME_T == SIZEOF_LONG
00157 #  define PRI_TIMET_PREFIX "l"
00158 # elif SIZEOF_TIME_T == SIZEOF_LONG_LONG
00159 #  define PRI_TIMET_PREFIX PRI_LL_PREFIX
00160 # endif
00161 #endif
00162 
00163 #if defined PRI_PTRDIFF_PREFIX
00164 #elif SIZEOF_PTRDIFF_T == SIZEOF_INT
00165 # define PRI_PTRDIFF_PREFIX ""
00166 #elif SIZEOF_PTRDIFF_T == SIZEOF_LONG
00167 # define PRI_PTRDIFF_PREFIX "l"
00168 #elif SIZEOF_PTRDIFF_T == SIZEOF_LONG_LONG
00169 # define PRI_PTRDIFF_PREFIX PRI_LL_PREFIX
00170 #endif
00171 #define PRIdPTRDIFF PRI_PTRDIFF_PREFIX"d"
00172 #define PRIiPTRDIFF PRI_PTRDIFF_PREFIX"i"
00173 #define PRIoPTRDIFF PRI_PTRDIFF_PREFIX"o"
00174 #define PRIuPTRDIFF PRI_PTRDIFF_PREFIX"u"
00175 #define PRIxPTRDIFF PRI_PTRDIFF_PREFIX"x"
00176 #define PRIXPTRDIFF PRI_PTRDIFF_PREFIX"X"
00177 
00178 #if defined PRI_SIZE_PREFIX
00179 #elif SIZEOF_SIZE_T == SIZEOF_INT
00180 # define PRI_SIZE_PREFIX ""
00181 #elif SIZEOF_SIZE_T == SIZEOF_LONG
00182 # define PRI_SIZE_PREFIX "l"
00183 #elif SIZEOF_SIZE_T == SIZEOF_LONG_LONG
00184 # define PRI_SIZE_PREFIX PRI_LL_PREFIX
00185 #endif
00186 #define PRIdSIZE PRI_SIZE_PREFIX"d"
00187 #define PRIiSIZE PRI_SIZE_PREFIX"i"
00188 #define PRIoSIZE PRI_SIZE_PREFIX"o"
00189 #define PRIuSIZE PRI_SIZE_PREFIX"u"
00190 #define PRIxSIZE PRI_SIZE_PREFIX"x"
00191 #define PRIXSIZE PRI_SIZE_PREFIX"X"
00192 
00193 #ifdef __STDC__
00194 # include <limits.h>
00195 #else
00196 # ifndef LONG_MAX
00197 #  ifdef HAVE_LIMITS_H
00198 #   include <limits.h>
00199 #  else
00200     /* assuming 32bit(2's compliment) long */
00201 #   define LONG_MAX 2147483647
00202 #  endif
00203 # endif
00204 # ifndef LONG_MIN
00205 #  define LONG_MIN (-LONG_MAX-1)
00206 # endif
00207 # ifndef CHAR_BIT
00208 #  define CHAR_BIT 8
00209 # endif
00210 #endif
00211 
00212 #ifdef HAVE_LONG_LONG
00213 # ifndef LLONG_MAX
00214 #  ifdef LONG_LONG_MAX
00215 #   define LLONG_MAX  LONG_LONG_MAX
00216 #  else
00217 #   ifdef _I64_MAX
00218 #    define LLONG_MAX _I64_MAX
00219 #   else
00220     /* assuming 64bit(2's complement) long long */
00221 #    define LLONG_MAX 9223372036854775807LL
00222 #   endif
00223 #  endif
00224 # endif
00225 # ifndef LLONG_MIN
00226 #  ifdef LONG_LONG_MIN
00227 #   define LLONG_MIN  LONG_LONG_MIN
00228 #  else
00229 #   ifdef _I64_MIN
00230 #    define LLONG_MIN _I64_MIN
00231 #   else
00232 #    define LLONG_MIN (-LLONG_MAX-1)
00233 #   endif
00234 #  endif
00235 # endif
00236 #endif
00237 
00238 #define FIXNUM_MAX (LONG_MAX>>1)
00239 #define FIXNUM_MIN RSHIFT((long)LONG_MIN,1)
00240 
00241 #define INT2FIX(i) ((VALUE)(((SIGNED_VALUE)(i))<<1 | FIXNUM_FLAG))
00242 #define LONG2FIX(i) INT2FIX(i)
00243 #define rb_fix_new(v) INT2FIX(v)
00244 VALUE rb_int2inum(SIGNED_VALUE);
00245 
00246 #define rb_int_new(v) rb_int2inum(v)
00247 VALUE rb_uint2inum(VALUE);
00248 
00249 #define rb_uint_new(v) rb_uint2inum(v)
00250 
00251 #ifdef HAVE_LONG_LONG
00252 VALUE rb_ll2inum(LONG_LONG);
00253 #define LL2NUM(v) rb_ll2inum(v)
00254 VALUE rb_ull2inum(unsigned LONG_LONG);
00255 #define ULL2NUM(v) rb_ull2inum(v)
00256 #endif
00257 
00258 #if SIZEOF_OFF_T > SIZEOF_LONG && defined(HAVE_LONG_LONG)
00259 # define OFFT2NUM(v) LL2NUM(v)
00260 #elif SIZEOF_OFF_T == SIZEOF_LONG
00261 # define OFFT2NUM(v) LONG2NUM(v)
00262 #else
00263 # define OFFT2NUM(v) INT2NUM(v)
00264 #endif
00265 
00266 #if SIZEOF_SIZE_T > SIZEOF_LONG && defined(HAVE_LONG_LONG)
00267 # define SIZET2NUM(v) ULL2NUM(v)
00268 # define SSIZET2NUM(v) LL2NUM(v)
00269 #elif SIZEOF_SIZE_T == SIZEOF_LONG
00270 # define SIZET2NUM(v) ULONG2NUM(v)
00271 # define SSIZET2NUM(v) LONG2NUM(v)
00272 #else
00273 # define SIZET2NUM(v) UINT2NUM(v)
00274 # define SSIZET2NUM(v) INT2NUM(v)
00275 #endif
00276 
00277 #ifndef SIZE_MAX
00278 # if SIZEOF_SIZE_T > SIZEOF_LONG && defined(HAVE_LONG_LONG)
00279 #   define SIZE_MAX ULLONG_MAX
00280 #   define SIZE_MIN ULLONG_MIN
00281 # elif SIZEOF_SIZE_T == SIZEOF_LONG
00282 #   define SIZE_MAX ULONG_MAX
00283 #   define SIZE_MIN ULONG_MIN
00284 # elif SIZEOF_SIZE_T == SIZEOF_INT
00285 #   define SIZE_MAX UINT_MAX
00286 #   define SIZE_MIN UINT_MIN
00287 # else
00288 #   define SIZE_MAX USHRT_MAX
00289 #   define SIZE_MIN USHRT_MIN
00290 # endif
00291 #endif
00292 
00293 #ifndef SSIZE_MAX
00294 # if SIZEOF_SIZE_T > SIZEOF_LONG && defined(HAVE_LONG_LONG)
00295 #   define SSIZE_MAX LLONG_MAX
00296 #   define SSIZE_MIN LLONG_MIN
00297 # elif SIZEOF_SIZE_T == SIZEOF_LONG
00298 #   define SSIZE_MAX LONG_MAX
00299 #   define SSIZE_MIN LONG_MIN
00300 # elif SIZEOF_SIZE_T == SIZEOF_INT
00301 #   define SSIZE_MAX INT_MAX
00302 #   define SSIZE_MIN INT_MIN
00303 # else
00304 #   define SSIZE_MAX SHRT_MAX
00305 #   define SSIZE_MIN SHRT_MIN
00306 # endif
00307 #endif
00308 
00309 #if SIZEOF_INT < SIZEOF_VALUE
00310 NORETURN(void rb_out_of_int(SIGNED_VALUE num));
00311 #endif
00312 
00313 #if SIZEOF_INT < SIZEOF_LONG
00314 static inline int
00315 rb_long2int_inline(long n)
00316 {
00317     int i = (int)n;
00318     if ((long)i != n)
00319         rb_out_of_int(n);
00320 
00321     return i;
00322 }
00323 #define rb_long2int(n) rb_long2int_inline(n)
00324 #else
00325 #define rb_long2int(n) ((int)(n))
00326 #endif
00327 
00328 #ifndef PIDT2NUM
00329 #define PIDT2NUM(v) LONG2NUM(v)
00330 #endif
00331 #ifndef NUM2PIDT
00332 #define NUM2PIDT(v) NUM2LONG(v)
00333 #endif
00334 #ifndef UIDT2NUM
00335 #define UIDT2NUM(v) LONG2NUM(v)
00336 #endif
00337 #ifndef NUM2UIDT
00338 #define NUM2UIDT(v) NUM2LONG(v)
00339 #endif
00340 #ifndef GIDT2NUM
00341 #define GIDT2NUM(v) LONG2NUM(v)
00342 #endif
00343 #ifndef NUM2GIDT
00344 #define NUM2GIDT(v) NUM2LONG(v)
00345 #endif
00346 #ifndef NUM2MODET
00347 #define NUM2MODET(v) NUM2INT(v)
00348 #endif
00349 #ifndef MODET2NUM
00350 #define MODET2NUM(v) INT2NUM(v)
00351 #endif
00352 
00353 #define FIX2LONG(x) (long)RSHIFT((SIGNED_VALUE)(x),1)
00354 #define FIX2ULONG(x) ((((VALUE)(x))>>1)&LONG_MAX)
00355 #define FIXNUM_P(f) (((int)(SIGNED_VALUE)(f))&FIXNUM_FLAG)
00356 #define POSFIXABLE(f) ((f) < FIXNUM_MAX+1)
00357 #define NEGFIXABLE(f) ((f) >= FIXNUM_MIN)
00358 #define FIXABLE(f) (POSFIXABLE(f) && NEGFIXABLE(f))
00359 
00360 #define IMMEDIATE_P(x) ((VALUE)(x) & IMMEDIATE_MASK)
00361 
00362 #define SYMBOL_P(x) (((VALUE)(x)&~(~(VALUE)0<<RUBY_SPECIAL_SHIFT))==SYMBOL_FLAG)
00363 #define ID2SYM(x) (((VALUE)(x)<<RUBY_SPECIAL_SHIFT)|SYMBOL_FLAG)
00364 #define SYM2ID(x) RSHIFT((unsigned long)(x),RUBY_SPECIAL_SHIFT)
00365 
00366 #ifndef USE_FLONUM
00367 #if SIZEOF_VALUE >= SIZEOF_DOUBLE
00368 #define USE_FLONUM 1
00369 #else
00370 #define USE_FLONUM 0
00371 #endif
00372 #endif
00373 
00374 #if USE_FLONUM
00375 #define FLONUM_P(x) ((((int)(SIGNED_VALUE)(x))&FLONUM_MASK) == FLONUM_FLAG)
00376 #else
00377 #define FLONUM_P(x) 0
00378 #endif
00379 
00380 /* Module#methods, #singleton_methods and so on return Symbols */
00381 #define USE_SYMBOL_AS_METHOD_NAME 1
00382 
00383 /*
00384 !USE_FLONUM
00385 -------------------------
00386 ...xxxx xxx1 Fixnum
00387 ...0000 1110 Symbol
00388 ...0000 0000 Qfalse
00389 ...0000 0010 Qtrue
00390 ...0000 0100 Qnil
00391 ...0000 0110 Qundef
00392 
00393 USE_FLONUM
00394 -------------------------
00395 ...xxxx xxx1 Fixnum
00396 ...xxxx xx10 Flonum
00397 ...0000 1100 Symbol
00398 ...0000 0000 Qfalse  0x00 =  0
00399 ...0000 1000  Qnil   0x08 =  8
00400 ...0001 0100 Qtrue   0x14 = 20
00401 ...0011 0100 Qundef  0x34 = 52
00402  */
00403 
00404 /* special constants - i.e. non-zero and non-fixnum constants */
00405 enum ruby_special_consts {
00406 #if USE_FLONUM
00407     RUBY_Qfalse = 0x00,
00408     RUBY_Qtrue  = 0x14,
00409     RUBY_Qnil   = 0x08,
00410     RUBY_Qundef = 0x34,
00411 
00412     RUBY_IMMEDIATE_MASK = 0x07,
00413     RUBY_FIXNUM_FLAG    = 0x01,
00414     RUBY_FLONUM_MASK    = 0x03,
00415     RUBY_FLONUM_FLAG    = 0x02,
00416     RUBY_SYMBOL_FLAG    = 0x0c,
00417     RUBY_SPECIAL_SHIFT  = 8
00418 #else
00419     RUBY_Qfalse = 0,
00420     RUBY_Qtrue  = 2,
00421     RUBY_Qnil   = 4,
00422     RUBY_Qundef = 6,
00423 
00424     RUBY_IMMEDIATE_MASK = 0x03,
00425     RUBY_FIXNUM_FLAG    = 0x01,
00426     RUBY_FLONUM_MASK    = 0x00, /* any values ANDed with FLONUM_MASK cannot be FLONUM_FLAG */
00427     RUBY_FLONUM_FLAG    = 0x02,
00428     RUBY_SYMBOL_FLAG    = 0x0e,
00429     RUBY_SPECIAL_SHIFT  = 8
00430 #endif
00431 };
00432 
00433 #define Qfalse ((VALUE)RUBY_Qfalse)
00434 #define Qtrue  ((VALUE)RUBY_Qtrue)
00435 #define Qnil   ((VALUE)RUBY_Qnil)
00436 #define Qundef ((VALUE)RUBY_Qundef)     /* undefined value for placeholder */
00437 #define IMMEDIATE_MASK RUBY_IMMEDIATE_MASK
00438 #define FIXNUM_FLAG RUBY_FIXNUM_FLAG
00439 #if USE_FLONUM
00440 #define FLONUM_MASK RUBY_FLONUM_MASK
00441 #define FLONUM_FLAG RUBY_FLONUM_FLAG
00442 #endif
00443 #define SYMBOL_FLAG RUBY_SYMBOL_FLAG
00444 
00445 #define RTEST(v) !(((VALUE)(v) & ~Qnil) == 0)
00446 #define NIL_P(v) !((VALUE)(v) != Qnil)
00447 
00448 #define CLASS_OF(v) rb_class_of((VALUE)(v))
00449 
00450 enum ruby_value_type {
00451     RUBY_T_NONE   = 0x00,
00452 
00453     RUBY_T_OBJECT = 0x01,
00454     RUBY_T_CLASS  = 0x02,
00455     RUBY_T_MODULE = 0x03,
00456     RUBY_T_FLOAT  = 0x04,
00457     RUBY_T_STRING = 0x05,
00458     RUBY_T_REGEXP = 0x06,
00459     RUBY_T_ARRAY  = 0x07,
00460     RUBY_T_HASH   = 0x08,
00461     RUBY_T_STRUCT = 0x09,
00462     RUBY_T_BIGNUM = 0x0a,
00463     RUBY_T_FILE   = 0x0b,
00464     RUBY_T_DATA   = 0x0c,
00465     RUBY_T_MATCH  = 0x0d,
00466     RUBY_T_COMPLEX  = 0x0e,
00467     RUBY_T_RATIONAL = 0x0f,
00468 
00469     RUBY_T_NIL    = 0x11,
00470     RUBY_T_TRUE   = 0x12,
00471     RUBY_T_FALSE  = 0x13,
00472     RUBY_T_SYMBOL = 0x14,
00473     RUBY_T_FIXNUM = 0x15,
00474 
00475     RUBY_T_UNDEF  = 0x1b,
00476     RUBY_T_NODE   = 0x1c,
00477     RUBY_T_ICLASS = 0x1d,
00478     RUBY_T_ZOMBIE = 0x1e,
00479 
00480     RUBY_T_MASK   = 0x1f
00481 };
00482 
00483 #define T_NONE   RUBY_T_NONE
00484 #define T_NIL    RUBY_T_NIL
00485 #define T_OBJECT RUBY_T_OBJECT
00486 #define T_CLASS  RUBY_T_CLASS
00487 #define T_ICLASS RUBY_T_ICLASS
00488 #define T_MODULE RUBY_T_MODULE
00489 #define T_FLOAT  RUBY_T_FLOAT
00490 #define T_STRING RUBY_T_STRING
00491 #define T_REGEXP RUBY_T_REGEXP
00492 #define T_ARRAY  RUBY_T_ARRAY
00493 #define T_HASH   RUBY_T_HASH
00494 #define T_STRUCT RUBY_T_STRUCT
00495 #define T_BIGNUM RUBY_T_BIGNUM
00496 #define T_FILE   RUBY_T_FILE
00497 #define T_FIXNUM RUBY_T_FIXNUM
00498 #define T_TRUE   RUBY_T_TRUE
00499 #define T_FALSE  RUBY_T_FALSE
00500 #define T_DATA   RUBY_T_DATA
00501 #define T_MATCH  RUBY_T_MATCH
00502 #define T_SYMBOL RUBY_T_SYMBOL
00503 #define T_RATIONAL RUBY_T_RATIONAL
00504 #define T_COMPLEX RUBY_T_COMPLEX
00505 #define T_UNDEF  RUBY_T_UNDEF
00506 #define T_NODE   RUBY_T_NODE
00507 #define T_ZOMBIE RUBY_T_ZOMBIE
00508 #define T_MASK   RUBY_T_MASK
00509 
00510 #define BUILTIN_TYPE(x) (int)(((struct RBasic*)(x))->flags & T_MASK)
00511 
00512 static inline int rb_type(VALUE obj);
00513 #define TYPE(x) rb_type((VALUE)(x))
00514 
00515 /* RB_GC_GUARD_PTR() is an intermediate macro, and has no effect by
00516  * itself.  don't use it directly */
00517 #ifdef __GNUC__
00518 #define RB_GC_GUARD_PTR(ptr) \
00519     __extension__ ({volatile VALUE *rb_gc_guarded_ptr = (ptr); rb_gc_guarded_ptr;})
00520 #else
00521 #ifdef _MSC_VER
00522 #pragma optimize("", off)
00523 #endif
00524 static inline volatile VALUE *rb_gc_guarded_ptr(volatile VALUE *ptr) {return ptr;}
00525 #ifdef _MSC_VER
00526 #pragma optimize("", on)
00527 #endif
00528 #define RB_GC_GUARD_PTR(ptr) rb_gc_guarded_ptr(ptr)
00529 #endif
00530 #define RB_GC_GUARD(v) (*RB_GC_GUARD_PTR(&(v)))
00531 
00532 #ifdef __GNUC__
00533 #define RB_UNUSED_VAR(x) x __attribute__ ((unused)) 
00534 #else
00535 #define RB_UNUSED_VAR(x) x
00536 #endif
00537 
00538 void rb_check_type(VALUE,int);
00539 #define Check_Type(v,t) rb_check_type((VALUE)(v),(t))
00540 
00541 VALUE rb_str_to_str(VALUE);
00542 VALUE rb_string_value(volatile VALUE*);
00543 char *rb_string_value_ptr(volatile VALUE*);
00544 char *rb_string_value_cstr(volatile VALUE*);
00545 
00546 #define StringValue(v) rb_string_value(&(v))
00547 #define StringValuePtr(v) rb_string_value_ptr(&(v))
00548 #define StringValueCStr(v) rb_string_value_cstr(&(v))
00549 
00550 void rb_check_safe_obj(VALUE);
00551 DEPRECATED(void rb_check_safe_str(VALUE));
00552 #define SafeStringValue(v) do {\
00553     StringValue(v);\
00554     rb_check_safe_obj(v);\
00555 } while (0)
00556 /* obsolete macro - use SafeStringValue(v) */
00557 #define Check_SafeStr(v) rb_check_safe_str((VALUE)(v))
00558 
00559 VALUE rb_str_export(VALUE);
00560 #define ExportStringValue(v) do {\
00561     SafeStringValue(v);\
00562    (v) = rb_str_export(v);\
00563 } while (0)
00564 VALUE rb_str_export_locale(VALUE);
00565 
00566 VALUE rb_get_path(VALUE);
00567 #define FilePathValue(v) (RB_GC_GUARD(v) = rb_get_path(v))
00568 
00569 VALUE rb_get_path_no_checksafe(VALUE);
00570 #define FilePathStringValue(v) ((v) = rb_get_path_no_checksafe(v))
00571 
00572 void rb_secure(int);
00573 int rb_safe_level(void);
00574 void rb_set_safe_level(int);
00575 void rb_set_safe_level_force(int);
00576 void rb_secure_update(VALUE);
00577 NORETURN(void rb_insecure_operation(void));
00578 
00579 VALUE rb_errinfo(void);
00580 void rb_set_errinfo(VALUE);
00581 
00582 SIGNED_VALUE rb_num2long(VALUE);
00583 VALUE rb_num2ulong(VALUE);
00584 static inline long
00585 rb_num2long_inline(VALUE x)
00586 {
00587     if (FIXNUM_P(x))
00588         return FIX2LONG(x);
00589     else
00590         return (long)rb_num2long(x);
00591 }
00592 #define NUM2LONG(x) rb_num2long_inline(x)
00593 static inline unsigned long
00594 rb_num2ulong_inline(VALUE x)
00595 {
00596     if (FIXNUM_P(x))
00597         return (unsigned long)FIX2LONG(x);
00598     else
00599         return (unsigned long)rb_num2ulong(x);
00600 }
00601 #define NUM2ULONG(x) rb_num2ulong_inline(x)
00602 #if SIZEOF_INT < SIZEOF_LONG
00603 long rb_num2int(VALUE);
00604 long rb_fix2int(VALUE);
00605 #define FIX2INT(x) ((int)rb_fix2int((VALUE)(x)))
00606 
00607 static inline int
00608 rb_num2int_inline(VALUE x)
00609 {
00610     if (FIXNUM_P(x))
00611         return FIX2INT(x);
00612     else
00613         return (int)rb_num2int(x);
00614 }
00615 #define NUM2INT(x) rb_num2int_inline(x)
00616 
00617 unsigned long rb_num2uint(VALUE);
00618 #define NUM2UINT(x) ((unsigned int)rb_num2uint(x))
00619 unsigned long rb_fix2uint(VALUE);
00620 #define FIX2UINT(x) ((unsigned int)rb_fix2uint(x))
00621 #else /* SIZEOF_INT < SIZEOF_LONG */
00622 #define NUM2INT(x) ((int)NUM2LONG(x))
00623 #define NUM2UINT(x) ((unsigned int)NUM2ULONG(x))
00624 #define FIX2INT(x) ((int)FIX2LONG(x))
00625 #define FIX2UINT(x) ((unsigned int)FIX2ULONG(x))
00626 #endif /* SIZEOF_INT < SIZEOF_LONG */
00627 
00628 short rb_num2short(VALUE);
00629 unsigned short rb_num2ushort(VALUE);
00630 short rb_fix2short(VALUE);
00631 unsigned short rb_fix2ushort(VALUE);
00632 #define FIX2SHORT(x) (rb_fix2short((VALUE)(x)))
00633 static inline short
00634 rb_num2short_inline(VALUE x)
00635 {
00636     if (FIXNUM_P(x))
00637         return FIX2SHORT(x);
00638     else
00639         return rb_num2short(x);
00640 }
00641 
00642 #define NUM2SHORT(x) rb_num2short_inline(x)
00643 #define NUM2USHORT(x) rb_num2ushort(x)
00644 
00645 #ifdef HAVE_LONG_LONG
00646 LONG_LONG rb_num2ll(VALUE);
00647 unsigned LONG_LONG rb_num2ull(VALUE);
00648 static inline LONG_LONG
00649 rb_num2ll_inline(VALUE x)
00650 {
00651     if (FIXNUM_P(x))
00652         return FIX2LONG(x);
00653     else
00654         return rb_num2ll(x);
00655 }
00656 # define NUM2LL(x) rb_num2ll_inline(x)
00657 # define NUM2ULL(x) rb_num2ull(x)
00658 #endif
00659 
00660 #if defined(HAVE_LONG_LONG) && SIZEOF_OFF_T > SIZEOF_LONG
00661 # define NUM2OFFT(x) ((off_t)NUM2LL(x))
00662 #else
00663 # define NUM2OFFT(x) NUM2LONG(x)
00664 #endif
00665 
00666 #if defined(HAVE_LONG_LONG) && SIZEOF_SIZE_T > SIZEOF_LONG
00667 # define NUM2SIZET(x) ((size_t)NUM2ULL(x))
00668 # define NUM2SSIZET(x) ((ssize_t)NUM2LL(x))
00669 #else
00670 # define NUM2SIZET(x) NUM2ULONG(x)
00671 # define NUM2SSIZET(x) NUM2LONG(x)
00672 #endif
00673 
00674 double rb_num2dbl(VALUE);
00675 #define NUM2DBL(x) rb_num2dbl((VALUE)(x))
00676 
00677 VALUE rb_uint2big(VALUE);
00678 VALUE rb_int2big(SIGNED_VALUE);
00679 
00680 VALUE rb_newobj(void);
00681 VALUE rb_newobj_of(VALUE, VALUE);
00682 #define NEWOBJ(obj,type) type *(obj) = (type*)rb_newobj()
00683 #define NEWOBJ_OF(obj,type,klass,flags) type *(obj) = (type*)rb_newobj_of(klass, flags)
00684 #define OBJSETUP(obj,c,t) do {\
00685     RBASIC(obj)->flags = (t);\
00686     RBASIC(obj)->klass = (c);\
00687     if (rb_safe_level() >= 3) FL_SET((obj), FL_TAINT | FL_UNTRUSTED);\
00688 } while (0)
00689 #define CLONESETUP(clone,obj) do {\
00690     OBJSETUP((clone),rb_singleton_class_clone((VALUE)(obj)),RBASIC(obj)->flags);\
00691     rb_singleton_class_attached(RBASIC(clone)->klass, (VALUE)(clone));\
00692     if (FL_TEST((obj), FL_EXIVAR)) rb_copy_generic_ivar((VALUE)(clone),(VALUE)(obj));\
00693 } while (0)
00694 #define DUPSETUP(dup,obj) do {\
00695     OBJSETUP((dup),rb_obj_class(obj), (RBASIC(obj)->flags)&(T_MASK|FL_EXIVAR|FL_TAINT|FL_UNTRUSTED)); \
00696     if (FL_TEST((obj), FL_EXIVAR)) rb_copy_generic_ivar((VALUE)(dup),(VALUE)(obj));\
00697 } while (0)
00698 
00699 struct RBasic {
00700     VALUE flags;
00701     VALUE klass;
00702 }
00703 #ifdef __GNUC__
00704     __attribute__((aligned(sizeof(VALUE))))
00705 #endif
00706 ;
00707 
00708 #define ROBJECT_EMBED_LEN_MAX 3
00709 struct RObject {
00710     struct RBasic basic;
00711     union {
00712         struct {
00713             long numiv;
00714             VALUE *ivptr;
00715             struct st_table *iv_index_tbl; /* shortcut for RCLASS_IV_INDEX_TBL(rb_obj_class(obj)) */
00716         } heap;
00717         VALUE ary[ROBJECT_EMBED_LEN_MAX];
00718     } as;
00719 };
00720 #define ROBJECT_EMBED FL_USER1
00721 #define ROBJECT_NUMIV(o) \
00722     ((RBASIC(o)->flags & ROBJECT_EMBED) ? \
00723      ROBJECT_EMBED_LEN_MAX : \
00724      ROBJECT(o)->as.heap.numiv)
00725 #define ROBJECT_IVPTR(o) \
00726     ((RBASIC(o)->flags & ROBJECT_EMBED) ? \
00727      ROBJECT(o)->as.ary : \
00728      ROBJECT(o)->as.heap.ivptr)
00729 #define ROBJECT_IV_INDEX_TBL(o) \
00730     ((RBASIC(o)->flags & ROBJECT_EMBED) ? \
00731      RCLASS_IV_INDEX_TBL(rb_obj_class(o)) : \
00732      ROBJECT(o)->as.heap.iv_index_tbl)
00733 
00735 typedef struct rb_classext_struct rb_classext_t;
00736 
00737 struct RClass {
00738     struct RBasic basic;
00739     rb_classext_t *ptr;
00740     struct st_table *m_tbl;
00741     struct st_table *iv_index_tbl;
00742 };
00743 #define RCLASS_SUPER(c) rb_class_get_superclass(c)
00744 #define RMODULE_IV_TBL(m) RCLASS_IV_TBL(m)
00745 #define RMODULE_CONST_TBL(m) RCLASS_CONST_TBL(m)
00746 #define RMODULE_M_TBL(m) RCLASS_M_TBL(m)
00747 #define RMODULE_SUPER(m) RCLASS_SUPER(m)
00748 #define RMODULE_IS_OVERLAID FL_USER2
00749 #define RMODULE_IS_REFINEMENT FL_USER3
00750 #define RMODULE_INCLUDED_INTO_REFINEMENT FL_USER4
00751 
00752 struct RFloat {
00753     struct RBasic basic;
00754     double float_value;
00755 };
00756 
00757 VALUE rb_float_new_in_heap(double);
00758 
00759 #if USE_FLONUM
00760 #define RUBY_BIT_ROTL(v, n) (((v) << (n)) | ((v) >> ((sizeof(v) * 8) - n)))
00761 #define RUBY_BIT_ROTR(v, n) (((v) >> (n)) | ((v) << ((sizeof(v) * 8) - n)))
00762 
00763 static inline double
00764 rb_float_value(VALUE v)
00765 {
00766     if (FLONUM_P(v)) {
00767         if (v != (VALUE)0x8000000000000002) { /* LIKELY */
00768             union {
00769                 double d;
00770                 VALUE v;
00771             } t;
00772 
00773             VALUE b63 = (v >> 63);
00774             /* e: xx1... -> 011... */
00775             /*    xx0... -> 100... */
00776             /*      ^b63           */
00777             t.v = RUBY_BIT_ROTR((2 - b63) | (v & ~0x03), 3);
00778             return t.d;
00779         }
00780         else {
00781             return 0.0;
00782         }
00783     }
00784     else {
00785         return ((struct RFloat *)v)->float_value;
00786     }
00787 }
00788 
00789 static inline VALUE
00790 rb_float_new(double d)
00791 {
00792     union {
00793         double d;
00794         VALUE v;
00795     } t;
00796     int bits;
00797 
00798     t.d = d;
00799     bits = (int)((VALUE)(t.v >> 60) & 0x7);
00800     /* bits contains 3 bits of b62..b60. */
00801     /* bits - 3 = */
00802     /*   b011 -> b000 */
00803     /*   b100 -> b001 */
00804 
00805     if (t.v != 0x3000000000000000 /* 1.72723e-77 */ &&
00806         !((bits-3) & ~0x01)) {
00807         return (RUBY_BIT_ROTL(t.v, 3) & ~(VALUE)0x01) | 0x02;
00808     }
00809     else {
00810         if (t.v == (VALUE)0) {
00811             /* +0.0 */
00812             return 0x8000000000000002;
00813         }
00814         else {
00815             /* out of range */
00816             return rb_float_new_in_heap(d);
00817         }
00818     }
00819 }
00820 
00821 #else /* USE_FLONUM */
00822 
00823 static inline double
00824 rb_float_value(VALUE v)
00825 {
00826     return ((struct RFloat *)v)->float_value;
00827 }
00828 
00829 static inline VALUE
00830 rb_float_new(double d)
00831 {
00832     return rb_float_new_in_heap(d);
00833 }
00834 #endif
00835 
00836 #define RFLOAT_VALUE(v) rb_float_value(v)
00837 #define DBL2NUM(dbl)  rb_float_new(dbl)
00838 
00839 #define ELTS_SHARED FL_USER2
00840 
00841 #define RSTRING_EMBED_LEN_MAX ((int)((sizeof(VALUE)*3)/sizeof(char)-1))
00842 struct RString {
00843     struct RBasic basic;
00844     union {
00845         struct {
00846             long len;
00847             char *ptr;
00848             union {
00849                 long capa;
00850                 VALUE shared;
00851             } aux;
00852         } heap;
00853         char ary[RSTRING_EMBED_LEN_MAX + 1];
00854     } as;
00855 };
00856 #define RSTRING_NOEMBED FL_USER1
00857 #define RSTRING_EMBED_LEN_MASK (FL_USER2|FL_USER3|FL_USER4|FL_USER5|FL_USER6)
00858 #define RSTRING_EMBED_LEN_SHIFT (FL_USHIFT+2)
00859 #define RSTRING_EMBED_LEN(str) \
00860      (long)((RBASIC(str)->flags >> RSTRING_EMBED_LEN_SHIFT) & \
00861             (RSTRING_EMBED_LEN_MASK >> RSTRING_EMBED_LEN_SHIFT))
00862 #define RSTRING_LEN(str) \
00863     (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? \
00864      RSTRING_EMBED_LEN(str) : \
00865      RSTRING(str)->as.heap.len)
00866 #define RSTRING_PTR(str) \
00867     (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? \
00868      RSTRING(str)->as.ary : \
00869      RSTRING(str)->as.heap.ptr)
00870 #define RSTRING_END(str) \
00871     (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? \
00872      (RSTRING(str)->as.ary + RSTRING_EMBED_LEN(str)) : \
00873      (RSTRING(str)->as.heap.ptr + RSTRING(str)->as.heap.len))
00874 #define RSTRING_LENINT(str) rb_long2int(RSTRING_LEN(str))
00875 #define RSTRING_GETMEM(str, ptrvar, lenvar) \
00876     (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? \
00877      ((ptrvar) = RSTRING(str)->as.ary, (lenvar) = RSTRING_EMBED_LEN(str)) : \
00878      ((ptrvar) = RSTRING(str)->as.heap.ptr, (lenvar) = RSTRING(str)->as.heap.len))
00879 
00880 #define RARRAY_EMBED_LEN_MAX 3
00881 struct RArray {
00882     struct RBasic basic;
00883     union {
00884         struct {
00885             long len;
00886             union {
00887                 long capa;
00888                 VALUE shared;
00889             } aux;
00890             VALUE *ptr;
00891         } heap;
00892         VALUE ary[RARRAY_EMBED_LEN_MAX];
00893     } as;
00894 };
00895 #define RARRAY_EMBED_FLAG FL_USER1
00896 /* FL_USER2 is for ELTS_SHARED */
00897 #define RARRAY_EMBED_LEN_MASK (FL_USER4|FL_USER3)
00898 #define RARRAY_EMBED_LEN_SHIFT (FL_USHIFT+3)
00899 #define RARRAY_LEN(a) \
00900     ((RBASIC(a)->flags & RARRAY_EMBED_FLAG) ? \
00901      (long)((RBASIC(a)->flags >> RARRAY_EMBED_LEN_SHIFT) & \
00902          (RARRAY_EMBED_LEN_MASK >> RARRAY_EMBED_LEN_SHIFT)) : \
00903      RARRAY(a)->as.heap.len)
00904 #define RARRAY_PTR(a) \
00905     ((RBASIC(a)->flags & RARRAY_EMBED_FLAG) ? \
00906      RARRAY(a)->as.ary : \
00907      RARRAY(a)->as.heap.ptr)
00908 #define RARRAY_LENINT(ary) rb_long2int(RARRAY_LEN(ary))
00909 
00910 struct RRegexp {
00911     struct RBasic basic;
00912     struct re_pattern_buffer *ptr;
00913     VALUE src;
00914     unsigned long usecnt;
00915 };
00916 #define RREGEXP_SRC(r) RREGEXP(r)->src
00917 #define RREGEXP_SRC_PTR(r) RSTRING_PTR(RREGEXP(r)->src)
00918 #define RREGEXP_SRC_LEN(r) RSTRING_LEN(RREGEXP(r)->src)
00919 #define RREGEXP_SRC_END(r) RSTRING_END(RREGEXP(r)->src)
00920 
00921 struct RHash {
00922     struct RBasic basic;
00923     struct st_table *ntbl;      /* possibly 0 */
00924     int iter_lev;
00925     VALUE ifnone;
00926 };
00927 /* RHASH_TBL allocates st_table if not available. */
00928 #define RHASH_TBL(h) rb_hash_tbl(h)
00929 #define RHASH_ITER_LEV(h) (RHASH(h)->iter_lev)
00930 #define RHASH_IFNONE(h) (RHASH(h)->ifnone)
00931 #define RHASH_SIZE(h) (RHASH(h)->ntbl ? RHASH(h)->ntbl->num_entries : 0)
00932 #define RHASH_EMPTY_P(h) (RHASH_SIZE(h) == 0)
00933 
00934 struct RFile {
00935     struct RBasic basic;
00936     struct rb_io_t *fptr;
00937 };
00938 
00939 struct RRational {
00940     struct RBasic basic;
00941     VALUE num;
00942     VALUE den;
00943 };
00944 
00945 struct RComplex {
00946     struct RBasic basic;
00947     VALUE real;
00948     VALUE imag;
00949 };
00950 
00951 struct RData {
00952     struct RBasic basic;
00953     void (*dmark)(void*);
00954     void (*dfree)(void*);
00955     void *data;
00956 };
00957 
00958 typedef struct rb_data_type_struct rb_data_type_t;
00959 
00960 struct rb_data_type_struct {
00961     const char *wrap_struct_name;
00962     struct {
00963         void (*dmark)(void*);
00964         void (*dfree)(void*);
00965         size_t (*dsize)(const void *);
00966         void *reserved[2]; /* For future extension.
00967                               This array *must* be filled with ZERO. */
00968     } function;
00969     const rb_data_type_t *parent;
00970     void *data;        /* This area can be used for any purpose
00971                           by a programmer who define the type. */
00972 };
00973 
00974 #define HAVE_TYPE_RB_DATA_TYPE_T 1
00975 #define HAVE_RB_DATA_TYPE_T_FUNCTION 1
00976 #define HAVE_RB_DATA_TYPE_T_PARENT 1
00977 
00978 struct RTypedData {
00979     struct RBasic basic;
00980     const rb_data_type_t *type;
00981     VALUE typed_flag; /* 1 or not */
00982     void *data;
00983 };
00984 
00985 #define DATA_PTR(dta) (RDATA(dta)->data)
00986 
00987 #define RTYPEDDATA_P(v)    (RTYPEDDATA(v)->typed_flag == 1)
00988 #define RTYPEDDATA_TYPE(v) (RTYPEDDATA(v)->type)
00989 #define RTYPEDDATA_DATA(v) (RTYPEDDATA(v)->data)
00990 
00991 /*
00992 #define RUBY_DATA_FUNC(func) ((void (*)(void*))(func))
00993 */
00994 typedef void (*RUBY_DATA_FUNC)(void*);
00995 
00996 VALUE rb_data_object_alloc(VALUE,void*,RUBY_DATA_FUNC,RUBY_DATA_FUNC);
00997 VALUE rb_data_typed_object_alloc(VALUE klass, void *datap, const rb_data_type_t *);
00998 int rb_typeddata_inherited_p(const rb_data_type_t *child, const rb_data_type_t *parent);
00999 int rb_typeddata_is_kind_of(VALUE, const rb_data_type_t *);
01000 void *rb_check_typeddata(VALUE, const rb_data_type_t *);
01001 #define Check_TypedStruct(v,t) rb_check_typeddata((VALUE)(v),(t))
01002 #define RUBY_DEFAULT_FREE ((RUBY_DATA_FUNC)-1)
01003 #define RUBY_NEVER_FREE   ((RUBY_DATA_FUNC)0)
01004 #define RUBY_TYPED_DEFAULT_FREE RUBY_DEFAULT_FREE
01005 #define RUBY_TYPED_NEVER_FREE   RUBY_NEVER_FREE
01006 
01007 #define Data_Wrap_Struct(klass,mark,free,sval)\
01008     rb_data_object_alloc((klass),(sval),(RUBY_DATA_FUNC)(mark),(RUBY_DATA_FUNC)(free))
01009 
01010 #define Data_Make_Struct(klass,type,mark,free,sval) (\
01011     (sval) = ALLOC(type),\
01012     memset((sval), 0, sizeof(type)),\
01013     Data_Wrap_Struct((klass),(mark),(free),(sval))\
01014 )
01015 
01016 #define TypedData_Wrap_Struct(klass,data_type,sval)\
01017   rb_data_typed_object_alloc((klass),(sval),(data_type))
01018 
01019 #define TypedData_Make_Struct(klass, type, data_type, sval) (\
01020     (sval) = ALLOC(type),\
01021     memset((sval), 0, sizeof(type)),\
01022     TypedData_Wrap_Struct((klass),(data_type),(sval))\
01023 )
01024 
01025 #define Data_Get_Struct(obj,type,sval) do {\
01026     Check_Type((obj), T_DATA); \
01027     (sval) = (type*)DATA_PTR(obj);\
01028 } while (0)
01029 
01030 #define TypedData_Get_Struct(obj,type,data_type,sval) do {\
01031     (sval) = (type*)rb_check_typeddata((obj), (data_type)); \
01032 } while (0)
01033 
01034 #define RSTRUCT_EMBED_LEN_MAX 3
01035 struct RStruct {
01036     struct RBasic basic;
01037     union {
01038         struct {
01039             long len;
01040             VALUE *ptr;
01041         } heap;
01042         VALUE ary[RSTRUCT_EMBED_LEN_MAX];
01043     } as;
01044 };
01045 #define RSTRUCT_EMBED_LEN_MASK (FL_USER2|FL_USER1)
01046 #define RSTRUCT_EMBED_LEN_SHIFT (FL_USHIFT+1)
01047 #define RSTRUCT_LEN(st) \
01048     ((RBASIC(st)->flags & RSTRUCT_EMBED_LEN_MASK) ? \
01049      (long)((RBASIC(st)->flags >> RSTRUCT_EMBED_LEN_SHIFT) & \
01050             (RSTRUCT_EMBED_LEN_MASK >> RSTRUCT_EMBED_LEN_SHIFT)) : \
01051      RSTRUCT(st)->as.heap.len)
01052 #define RSTRUCT_PTR(st) \
01053     ((RBASIC(st)->flags & RSTRUCT_EMBED_LEN_MASK) ? \
01054      RSTRUCT(st)->as.ary : \
01055      RSTRUCT(st)->as.heap.ptr)
01056 #define RSTRUCT_LENINT(st) rb_long2int(RSTRUCT_LEN(st))
01057 
01058 #define RBIGNUM_EMBED_LEN_MAX ((int)((sizeof(VALUE)*3)/sizeof(BDIGIT)))
01059 struct RBignum {
01060     struct RBasic basic;
01061     union {
01062         struct {
01063             long len;
01064             BDIGIT *digits;
01065         } heap;
01066         BDIGIT ary[RBIGNUM_EMBED_LEN_MAX];
01067     } as;
01068 };
01069 #define RBIGNUM_SIGN_BIT FL_USER1
01070 /* sign: positive:1, negative:0 */
01071 #define RBIGNUM_SIGN(b) ((RBASIC(b)->flags & RBIGNUM_SIGN_BIT) != 0)
01072 #define RBIGNUM_SET_SIGN(b,sign) \
01073   ((sign) ? (RBASIC(b)->flags |= RBIGNUM_SIGN_BIT) \
01074           : (RBASIC(b)->flags &= ~RBIGNUM_SIGN_BIT))
01075 #define RBIGNUM_POSITIVE_P(b) RBIGNUM_SIGN(b)
01076 #define RBIGNUM_NEGATIVE_P(b) (!RBIGNUM_SIGN(b))
01077 
01078 #define RBIGNUM_EMBED_FLAG FL_USER2
01079 #define RBIGNUM_EMBED_LEN_MASK (FL_USER5|FL_USER4|FL_USER3)
01080 #define RBIGNUM_EMBED_LEN_SHIFT (FL_USHIFT+3)
01081 #define RBIGNUM_LEN(b) \
01082     ((RBASIC(b)->flags & RBIGNUM_EMBED_FLAG) ? \
01083      (long)((RBASIC(b)->flags >> RBIGNUM_EMBED_LEN_SHIFT) & \
01084             (RBIGNUM_EMBED_LEN_MASK >> RBIGNUM_EMBED_LEN_SHIFT)) : \
01085      RBIGNUM(b)->as.heap.len)
01086 /* LSB:RBIGNUM_DIGITS(b)[0], MSB:RBIGNUM_DIGITS(b)[RBIGNUM_LEN(b)-1] */
01087 #define RBIGNUM_DIGITS(b) \
01088     ((RBASIC(b)->flags & RBIGNUM_EMBED_FLAG) ? \
01089      RBIGNUM(b)->as.ary : \
01090      RBIGNUM(b)->as.heap.digits)
01091 #define RBIGNUM_LENINT(b) rb_long2int(RBIGNUM_LEN(b))
01092 
01093 #define R_CAST(st)   (struct st*)
01094 #define RBASIC(obj)  (R_CAST(RBasic)(obj))
01095 #define ROBJECT(obj) (R_CAST(RObject)(obj))
01096 #define RCLASS(obj)  (R_CAST(RClass)(obj))
01097 #define RMODULE(obj) RCLASS(obj)
01098 #define RFLOAT(obj)  (R_CAST(RFloat)(obj))
01099 #define RSTRING(obj) (R_CAST(RString)(obj))
01100 #define RREGEXP(obj) (R_CAST(RRegexp)(obj))
01101 #define RARRAY(obj)  (R_CAST(RArray)(obj))
01102 #define RHASH(obj)   (R_CAST(RHash)(obj))
01103 #define RDATA(obj)   (R_CAST(RData)(obj))
01104 #define RTYPEDDATA(obj)   (R_CAST(RTypedData)(obj))
01105 #define RSTRUCT(obj) (R_CAST(RStruct)(obj))
01106 #define RBIGNUM(obj) (R_CAST(RBignum)(obj))
01107 #define RFILE(obj)   (R_CAST(RFile)(obj))
01108 #define RRATIONAL(obj) (R_CAST(RRational)(obj))
01109 #define RCOMPLEX(obj) (R_CAST(RComplex)(obj))
01110 
01111 #define FL_SINGLETON FL_USER0
01112 #define FL_RESERVED1 (((VALUE)1)<<5)
01113 #define FL_RESERVED2 (((VALUE)1)<<6) /* will be used in the future GC */
01114 #define FL_FINALIZE  (((VALUE)1)<<7)
01115 #define FL_TAINT     (((VALUE)1)<<8)
01116 #define FL_UNTRUSTED (((VALUE)1)<<9)
01117 #define FL_EXIVAR    (((VALUE)1)<<10)
01118 #define FL_FREEZE    (((VALUE)1)<<11)
01119 
01120 #define FL_USHIFT    12
01121 
01122 #define FL_USER0     (((VALUE)1)<<(FL_USHIFT+0))
01123 #define FL_USER1     (((VALUE)1)<<(FL_USHIFT+1))
01124 #define FL_USER2     (((VALUE)1)<<(FL_USHIFT+2))
01125 #define FL_USER3     (((VALUE)1)<<(FL_USHIFT+3))
01126 #define FL_USER4     (((VALUE)1)<<(FL_USHIFT+4))
01127 #define FL_USER5     (((VALUE)1)<<(FL_USHIFT+5))
01128 #define FL_USER6     (((VALUE)1)<<(FL_USHIFT+6))
01129 #define FL_USER7     (((VALUE)1)<<(FL_USHIFT+7))
01130 #define FL_USER8     (((VALUE)1)<<(FL_USHIFT+8))
01131 #define FL_USER9     (((VALUE)1)<<(FL_USHIFT+9))
01132 #define FL_USER10    (((VALUE)1)<<(FL_USHIFT+10))
01133 #define FL_USER11    (((VALUE)1)<<(FL_USHIFT+11))
01134 #define FL_USER12    (((VALUE)1)<<(FL_USHIFT+12))
01135 #define FL_USER13    (((VALUE)1)<<(FL_USHIFT+13))
01136 #define FL_USER14    (((VALUE)1)<<(FL_USHIFT+14))
01137 #define FL_USER15    (((VALUE)1)<<(FL_USHIFT+15))
01138 #define FL_USER16    (((VALUE)1)<<(FL_USHIFT+16))
01139 #define FL_USER17    (((VALUE)1)<<(FL_USHIFT+17))
01140 #define FL_USER18    (((VALUE)1)<<(FL_USHIFT+18))
01141 #define FL_USER19    (((VALUE)1)<<(FL_USHIFT+19))
01142 
01143 #define SPECIAL_CONST_P(x) (IMMEDIATE_P(x) || !RTEST(x))
01144 
01145 #define FL_ABLE(x) (!SPECIAL_CONST_P(x) && BUILTIN_TYPE(x) != T_NODE)
01146 #define FL_TEST(x,f) (FL_ABLE(x)?(RBASIC(x)->flags&(f)):0)
01147 #define FL_ANY(x,f) FL_TEST((x),(f))
01148 #define FL_ALL(x,f) (FL_TEST((x),(f)) == (f))
01149 #define FL_SET(x,f) do {if (FL_ABLE(x)) RBASIC(x)->flags |= (f);} while (0)
01150 #define FL_UNSET(x,f) do {if (FL_ABLE(x)) RBASIC(x)->flags &= ~(f);} while (0)
01151 #define FL_REVERSE(x,f) do {if (FL_ABLE(x)) RBASIC(x)->flags ^= (f);} while (0)
01152 
01153 #define OBJ_TAINTED(x) (!!FL_TEST((x), FL_TAINT))
01154 #define OBJ_TAINT(x) FL_SET((x), FL_TAINT)
01155 #define OBJ_UNTRUSTED(x) (!!FL_TEST((x), FL_UNTRUSTED))
01156 #define OBJ_UNTRUST(x) FL_SET((x), FL_UNTRUSTED)
01157 #define OBJ_INFECT(x,s) do { \
01158   if (FL_ABLE(x) && FL_ABLE(s)) \
01159     RBASIC(x)->flags |= RBASIC(s)->flags & \
01160                         (FL_TAINT | FL_UNTRUSTED); \
01161 } while (0)
01162 
01163 #define OBJ_FROZEN(x) (!!(FL_ABLE(x)?(RBASIC(x)->flags&(FL_FREEZE)):(FIXNUM_P(x)||FLONUM_P(x))))
01164 #define OBJ_FREEZE(x) FL_SET((x), FL_FREEZE)
01165 
01166 #if SIZEOF_INT < SIZEOF_LONG
01167 # define INT2NUM(v) INT2FIX((int)(v))
01168 # define UINT2NUM(v) LONG2FIX((unsigned int)(v))
01169 #else
01170 static inline VALUE
01171 rb_int2num_inline(int v)
01172 {
01173     if (FIXABLE(v))
01174         return INT2FIX(v);
01175     else
01176         return rb_int2big(v);
01177 }
01178 #define INT2NUM(x) rb_int2num_inline(x)
01179 
01180 static inline VALUE
01181 rb_uint2num_inline(unsigned int v)
01182 {
01183     if (POSFIXABLE(v))
01184         return LONG2FIX(v);
01185     else
01186         return rb_uint2big(v);
01187 }
01188 #define UINT2NUM(x) rb_uint2num_inline(x)
01189 #endif
01190 
01191 static inline VALUE
01192 rb_long2num_inline(long v)
01193 {
01194     if (FIXABLE(v))
01195         return LONG2FIX(v);
01196     else
01197         return rb_int2big(v);
01198 }
01199 #define LONG2NUM(x) rb_long2num_inline(x)
01200 
01201 static inline VALUE
01202 rb_ulong2num_inline(unsigned long v)
01203 {
01204     if (POSFIXABLE(v))
01205         return LONG2FIX(v);
01206     else
01207         return rb_uint2big(v);
01208 }
01209 #define ULONG2NUM(x) rb_ulong2num_inline(x)
01210 
01211 static inline char
01212 rb_num2char_inline(VALUE x)
01213 {
01214     if ((TYPE(x) == T_STRING) && (RSTRING_LEN(x)>=1))
01215         return RSTRING_PTR(x)[0];
01216     else
01217         return (char)(NUM2INT(x) & 0xff);
01218 }
01219 #define NUM2CHR(x) rb_num2char_inline(x)
01220 
01221 #define CHR2FIX(x) INT2FIX((long)((x)&0xff))
01222 
01223 #define ALLOC_N(type,n) ((type*)xmalloc2((n),sizeof(type)))
01224 #define ALLOC(type) ((type*)xmalloc(sizeof(type)))
01225 #define REALLOC_N(var,type,n) ((var)=(type*)xrealloc2((char*)(var),(n),sizeof(type)))
01226 
01227 #define ALLOCA_N(type,n) ((type*)alloca(sizeof(type)*(n)))
01228 
01229 void *rb_alloc_tmp_buffer(volatile VALUE *store, long len);
01230 void rb_free_tmp_buffer(volatile VALUE *store);
01231 /* allocates _n_ bytes temporary buffer and stores VALUE including it
01232  * in _v_.  _n_ may be evaluated twice. */
01233 #ifdef C_ALLOCA
01234 # define ALLOCV(v, n) rb_alloc_tmp_buffer(&(v), (n))
01235 #else
01236 # define ALLOCV(v, n) ((n) < 1024 ? (RB_GC_GUARD(v) = 0, alloca(n)) : rb_alloc_tmp_buffer(&(v), (n)))
01237 #endif
01238 #define ALLOCV_N(type, v, n) ((type*)ALLOCV((v), sizeof(type)*(n)))
01239 #define ALLOCV_END(v) rb_free_tmp_buffer(&(v))
01240 
01241 #define MEMZERO(p,type,n) memset((p), 0, sizeof(type)*(n))
01242 #define MEMCPY(p1,p2,type,n) memcpy((p1), (p2), sizeof(type)*(n))
01243 #define MEMMOVE(p1,p2,type,n) memmove((p1), (p2), sizeof(type)*(n))
01244 #define MEMCMP(p1,p2,type,n) memcmp((p1), (p2), sizeof(type)*(n))
01245 
01246 void rb_obj_infect(VALUE,VALUE);
01247 
01248 typedef int ruby_glob_func(const char*,VALUE, void*);
01249 void rb_glob(const char*,void(*)(const char*,VALUE,void*),VALUE);
01250 int ruby_glob(const char*,int,ruby_glob_func*,VALUE);
01251 int ruby_brace_glob(const char*,int,ruby_glob_func*,VALUE);
01252 
01253 VALUE rb_define_class(const char*,VALUE);
01254 VALUE rb_define_module(const char*);
01255 VALUE rb_define_class_under(VALUE, const char*, VALUE);
01256 VALUE rb_define_module_under(VALUE, const char*);
01257 
01258 void rb_include_module(VALUE,VALUE);
01259 void rb_extend_object(VALUE,VALUE);
01260 void rb_prepend_module(VALUE,VALUE);
01261 
01262 struct rb_global_variable;
01263 
01264 typedef VALUE rb_gvar_getter_t(ID id, void *data, struct rb_global_variable *gvar);
01265 typedef void  rb_gvar_setter_t(VALUE val, ID id, void *data, struct rb_global_variable *gvar);
01266 typedef void  rb_gvar_marker_t(VALUE *var);
01267 
01268 VALUE rb_gvar_undef_getter(ID id, void *data, struct rb_global_variable *gvar);
01269 void  rb_gvar_undef_setter(VALUE val, ID id, void *data, struct rb_global_variable *gvar);
01270 void  rb_gvar_undef_marker(VALUE *var);
01271 
01272 VALUE rb_gvar_val_getter(ID id, void *data, struct rb_global_variable *gvar);
01273 void  rb_gvar_val_setter(VALUE val, ID id, void *data, struct rb_global_variable *gvar);
01274 void  rb_gvar_val_marker(VALUE *var);
01275 
01276 VALUE rb_gvar_var_getter(ID id, void *data, struct rb_global_variable *gvar);
01277 void  rb_gvar_var_setter(VALUE val, ID id, void *data, struct rb_global_variable *gvar);
01278 void  rb_gvar_var_marker(VALUE *var);
01279 
01280 void  rb_gvar_readonly_setter(VALUE val, ID id, void *data, struct rb_global_variable *gvar);
01281 
01282 void rb_define_variable(const char*,VALUE*);
01283 void rb_define_virtual_variable(const char*,VALUE(*)(ANYARGS),void(*)(ANYARGS));
01284 void rb_define_hooked_variable(const char*,VALUE*,VALUE(*)(ANYARGS),void(*)(ANYARGS));
01285 void rb_define_readonly_variable(const char*,VALUE*);
01286 void rb_define_const(VALUE,const char*,VALUE);
01287 void rb_define_global_const(const char*,VALUE);
01288 
01289 #define RUBY_METHOD_FUNC(func) ((VALUE (*)(ANYARGS))(func))
01290 void rb_define_method(VALUE,const char*,VALUE(*)(ANYARGS),int);
01291 void rb_define_module_function(VALUE,const char*,VALUE(*)(ANYARGS),int);
01292 void rb_define_global_function(const char*,VALUE(*)(ANYARGS),int);
01293 
01294 void rb_undef_method(VALUE,const char*);
01295 void rb_define_alias(VALUE,const char*,const char*);
01296 void rb_define_attr(VALUE,const char*,int,int);
01297 
01298 void rb_global_variable(VALUE*);
01299 void rb_gc_register_mark_object(VALUE);
01300 void rb_gc_register_address(VALUE*);
01301 void rb_gc_unregister_address(VALUE*);
01302 
01303 ID rb_intern(const char*);
01304 ID rb_intern2(const char*, long);
01305 ID rb_intern_str(VALUE str);
01306 const char *rb_id2name(ID);
01307 ID rb_check_id(volatile VALUE *);
01308 ID rb_to_id(VALUE);
01309 VALUE rb_id2str(ID);
01310 
01311 #define CONST_ID_CACHE(result, str)                     \
01312     {                                                   \
01313         static ID rb_intern_id_cache;                   \
01314         if (!rb_intern_id_cache)                        \
01315             rb_intern_id_cache = rb_intern2((str), (long)strlen(str)); \
01316         result rb_intern_id_cache;                      \
01317     }
01318 #define CONST_ID(var, str) \
01319     do CONST_ID_CACHE((var) =, (str)) while (0)
01320 #ifdef __GNUC__
01321 /* __builtin_constant_p and statement expression is available
01322  * since gcc-2.7.2.3 at least. */
01323 #define rb_intern(str) \
01324     (__builtin_constant_p(str) ? \
01325         __extension__ (CONST_ID_CACHE((ID), (str))) : \
01326         rb_intern(str))
01327 #define rb_intern_const(str) \
01328     (__builtin_constant_p(str) ? \
01329      __extension__ (rb_intern2((str), (long)strlen(str))) : \
01330      (rb_intern)(str))
01331 #else
01332 #define rb_intern_const(str) rb_intern2((str), (long)strlen(str))
01333 #endif
01334 
01335 const char *rb_class2name(VALUE);
01336 const char *rb_obj_classname(VALUE);
01337 
01338 void rb_p(VALUE);
01339 
01340 VALUE rb_eval_string(const char*);
01341 VALUE rb_eval_string_protect(const char*, int*);
01342 VALUE rb_eval_string_wrap(const char*, int*);
01343 VALUE rb_funcall(VALUE, ID, int, ...);
01344 VALUE rb_funcall2(VALUE, ID, int, const VALUE*);
01345 VALUE rb_funcall3(VALUE, ID, int, const VALUE*);
01346 VALUE rb_funcall_passing_block(VALUE, ID, int, const VALUE*);
01347 VALUE rb_funcall_with_block(VALUE, ID, int, const VALUE*, VALUE);
01348 int rb_scan_args(int, const VALUE*, const char*, ...);
01349 VALUE rb_call_super(int, const VALUE*);
01350 
01351 /* rb_scan_args() format allows ':' for optional hash */
01352 #define HAVE_RB_SCAN_ARGS_OPTIONAL_HASH 1
01353 
01354 VALUE rb_gv_set(const char*, VALUE);
01355 VALUE rb_gv_get(const char*);
01356 VALUE rb_iv_get(VALUE, const char*);
01357 VALUE rb_iv_set(VALUE, const char*, VALUE);
01358 
01359 VALUE rb_equal(VALUE,VALUE);
01360 
01361 VALUE *rb_ruby_verbose_ptr(void);
01362 VALUE *rb_ruby_debug_ptr(void);
01363 #define ruby_verbose (*rb_ruby_verbose_ptr())
01364 #define ruby_debug   (*rb_ruby_debug_ptr())
01365 
01366 PRINTF_ARGS(NORETURN(void rb_raise(VALUE, const char*, ...)), 2, 3);
01367 PRINTF_ARGS(NORETURN(void rb_fatal(const char*, ...)), 1, 2);
01368 PRINTF_ARGS(NORETURN(void rb_bug(const char*, ...)), 1, 2);
01369 NORETURN(void rb_bug_errno(const char*, int));
01370 NORETURN(void rb_sys_fail(const char*));
01371 NORETURN(void rb_sys_fail_str(VALUE));
01372 NORETURN(void rb_mod_sys_fail(VALUE, const char*));
01373 NORETURN(void rb_mod_sys_fail_str(VALUE, VALUE));
01374 NORETURN(void rb_iter_break(void));
01375 NORETURN(void rb_iter_break_value(VALUE));
01376 NORETURN(void rb_exit(int));
01377 NORETURN(void rb_notimplement(void));
01378 VALUE rb_syserr_new(int, const char *);
01379 VALUE rb_syserr_new_str(int n, VALUE arg);
01380 NORETURN(void rb_syserr_fail(int, const char*));
01381 NORETURN(void rb_syserr_fail_str(int, VALUE));
01382 NORETURN(void rb_mod_syserr_fail(VALUE, int, const char*));
01383 NORETURN(void rb_mod_syserr_fail_str(VALUE, int, VALUE));
01384 
01385 /* reports if `-W' specified */
01386 PRINTF_ARGS(void rb_warning(const char*, ...), 1, 2);
01387 PRINTF_ARGS(void rb_compile_warning(const char *, int, const char*, ...), 3, 4);
01388 PRINTF_ARGS(void rb_sys_warning(const char*, ...), 1, 2);
01389 /* reports always */
01390 PRINTF_ARGS(void rb_warn(const char*, ...), 1, 2);
01391 PRINTF_ARGS(void rb_compile_warn(const char *, int, const char*, ...), 3, 4);
01392 
01393 typedef VALUE rb_block_call_func(VALUE, VALUE, int, VALUE*);
01394 
01395 VALUE rb_each(VALUE);
01396 VALUE rb_yield(VALUE);
01397 VALUE rb_yield_values(int n, ...);
01398 VALUE rb_yield_values2(int n, const VALUE *argv);
01399 VALUE rb_yield_splat(VALUE);
01400 int rb_block_given_p(void);
01401 void rb_need_block(void);
01402 VALUE rb_iterate(VALUE(*)(VALUE),VALUE,VALUE(*)(ANYARGS),VALUE);
01403 VALUE rb_block_call(VALUE,ID,int,VALUE*,VALUE(*)(ANYARGS),VALUE);
01404 VALUE rb_rescue(VALUE(*)(ANYARGS),VALUE,VALUE(*)(ANYARGS),VALUE);
01405 VALUE rb_rescue2(VALUE(*)(ANYARGS),VALUE,VALUE(*)(ANYARGS),VALUE,...);
01406 VALUE rb_ensure(VALUE(*)(ANYARGS),VALUE,VALUE(*)(ANYARGS),VALUE);
01407 VALUE rb_catch(const char*,VALUE(*)(ANYARGS),VALUE);
01408 VALUE rb_catch_obj(VALUE,VALUE(*)(ANYARGS),VALUE);
01409 NORETURN(void rb_throw(const char*,VALUE));
01410 NORETURN(void rb_throw_obj(VALUE,VALUE));
01411 
01412 VALUE rb_require(const char*);
01413 
01414 RUBY_EXTERN VALUE rb_mKernel;
01415 RUBY_EXTERN VALUE rb_mComparable;
01416 RUBY_EXTERN VALUE rb_mEnumerable;
01417 RUBY_EXTERN VALUE rb_mErrno;
01418 RUBY_EXTERN VALUE rb_mFileTest;
01419 RUBY_EXTERN VALUE rb_mGC;
01420 RUBY_EXTERN VALUE rb_mMath;
01421 RUBY_EXTERN VALUE rb_mProcess;
01422 RUBY_EXTERN VALUE rb_mWaitReadable;
01423 RUBY_EXTERN VALUE rb_mWaitWritable;
01424 
01425 RUBY_EXTERN VALUE rb_cBasicObject;
01426 RUBY_EXTERN VALUE rb_cObject;
01427 RUBY_EXTERN VALUE rb_cArray;
01428 RUBY_EXTERN VALUE rb_cBignum;
01429 RUBY_EXTERN VALUE rb_cBinding;
01430 RUBY_EXTERN VALUE rb_cClass;
01431 RUBY_EXTERN VALUE rb_cCont;
01432 RUBY_EXTERN VALUE rb_cDir;
01433 RUBY_EXTERN VALUE rb_cData;
01434 RUBY_EXTERN VALUE rb_cFalseClass;
01435 RUBY_EXTERN VALUE rb_cEncoding;
01436 RUBY_EXTERN VALUE rb_cEnumerator;
01437 RUBY_EXTERN VALUE rb_cFile;
01438 RUBY_EXTERN VALUE rb_cFixnum;
01439 RUBY_EXTERN VALUE rb_cFloat;
01440 RUBY_EXTERN VALUE rb_cHash;
01441 RUBY_EXTERN VALUE rb_cInteger;
01442 RUBY_EXTERN VALUE rb_cIO;
01443 RUBY_EXTERN VALUE rb_cMatch;
01444 RUBY_EXTERN VALUE rb_cMethod;
01445 RUBY_EXTERN VALUE rb_cModule;
01446 RUBY_EXTERN VALUE rb_cNameErrorMesg;
01447 RUBY_EXTERN VALUE rb_cNilClass;
01448 RUBY_EXTERN VALUE rb_cNumeric;
01449 RUBY_EXTERN VALUE rb_cProc;
01450 RUBY_EXTERN VALUE rb_cRandom;
01451 RUBY_EXTERN VALUE rb_cRange;
01452 RUBY_EXTERN VALUE rb_cRational;
01453 RUBY_EXTERN VALUE rb_cComplex;
01454 RUBY_EXTERN VALUE rb_cRegexp;
01455 RUBY_EXTERN VALUE rb_cStat;
01456 RUBY_EXTERN VALUE rb_cString;
01457 RUBY_EXTERN VALUE rb_cStruct;
01458 RUBY_EXTERN VALUE rb_cSymbol;
01459 RUBY_EXTERN VALUE rb_cThread;
01460 RUBY_EXTERN VALUE rb_cTime;
01461 RUBY_EXTERN VALUE rb_cTrueClass;
01462 RUBY_EXTERN VALUE rb_cUnboundMethod;
01463 
01464 RUBY_EXTERN VALUE rb_eException;
01465 RUBY_EXTERN VALUE rb_eStandardError;
01466 RUBY_EXTERN VALUE rb_eSystemExit;
01467 RUBY_EXTERN VALUE rb_eInterrupt;
01468 RUBY_EXTERN VALUE rb_eSignal;
01469 RUBY_EXTERN VALUE rb_eFatal;
01470 RUBY_EXTERN VALUE rb_eArgError;
01471 RUBY_EXTERN VALUE rb_eEOFError;
01472 RUBY_EXTERN VALUE rb_eIndexError;
01473 RUBY_EXTERN VALUE rb_eStopIteration;
01474 RUBY_EXTERN VALUE rb_eKeyError;
01475 RUBY_EXTERN VALUE rb_eRangeError;
01476 RUBY_EXTERN VALUE rb_eIOError;
01477 RUBY_EXTERN VALUE rb_eRuntimeError;
01478 RUBY_EXTERN VALUE rb_eSecurityError;
01479 RUBY_EXTERN VALUE rb_eSystemCallError;
01480 RUBY_EXTERN VALUE rb_eThreadError;
01481 RUBY_EXTERN VALUE rb_eTypeError;
01482 RUBY_EXTERN VALUE rb_eZeroDivError;
01483 RUBY_EXTERN VALUE rb_eNotImpError;
01484 RUBY_EXTERN VALUE rb_eNoMemError;
01485 RUBY_EXTERN VALUE rb_eNoMethodError;
01486 RUBY_EXTERN VALUE rb_eFloatDomainError;
01487 RUBY_EXTERN VALUE rb_eLocalJumpError;
01488 RUBY_EXTERN VALUE rb_eSysStackError;
01489 RUBY_EXTERN VALUE rb_eRegexpError;
01490 RUBY_EXTERN VALUE rb_eEncodingError;
01491 RUBY_EXTERN VALUE rb_eEncCompatError;
01492 
01493 RUBY_EXTERN VALUE rb_eScriptError;
01494 RUBY_EXTERN VALUE rb_eNameError;
01495 RUBY_EXTERN VALUE rb_eSyntaxError;
01496 RUBY_EXTERN VALUE rb_eLoadError;
01497 
01498 RUBY_EXTERN VALUE rb_eMathDomainError;
01499 
01500 RUBY_EXTERN VALUE rb_stdin, rb_stdout, rb_stderr;
01501 
01502 static inline VALUE
01503 rb_class_of(VALUE obj)
01504 {
01505     if (IMMEDIATE_P(obj)) {
01506         if (FIXNUM_P(obj)) return rb_cFixnum;
01507         if (FLONUM_P(obj)) return rb_cFloat;
01508         if (obj == Qtrue)  return rb_cTrueClass;
01509         if (SYMBOL_P(obj)) return rb_cSymbol;
01510     }
01511     else if (!RTEST(obj)) {
01512         if (obj == Qnil)   return rb_cNilClass;
01513         if (obj == Qfalse) return rb_cFalseClass;
01514     }
01515     return RBASIC(obj)->klass;
01516 }
01517 
01518 static inline int
01519 rb_type(VALUE obj)
01520 {
01521     if (IMMEDIATE_P(obj)) {
01522         if (FIXNUM_P(obj)) return T_FIXNUM;
01523         if (FLONUM_P(obj)) return T_FLOAT;
01524         if (obj == Qtrue)  return T_TRUE;
01525         if (SYMBOL_P(obj)) return T_SYMBOL;
01526         if (obj == Qundef) return T_UNDEF;
01527     }
01528     else if (!RTEST(obj)) {
01529         if (obj == Qnil)   return T_NIL;
01530         if (obj == Qfalse) return T_FALSE;
01531     }
01532     return BUILTIN_TYPE(obj);
01533 }
01534 
01535 #define RB_FLOAT_TYPE_P(obj) (FLONUM_P(obj) || (!SPECIAL_CONST_P(obj) && BUILTIN_TYPE(obj) == T_FLOAT))
01536 
01537 #define RB_TYPE_P(obj, type) ( \
01538         ((type) == T_FIXNUM) ? FIXNUM_P(obj) : \
01539         ((type) == T_TRUE) ? ((obj) == Qtrue) : \
01540         ((type) == T_FALSE) ? ((obj) == Qfalse) : \
01541         ((type) == T_NIL) ? ((obj) == Qnil) : \
01542         ((type) == T_UNDEF) ? ((obj) == Qundef) : \
01543         ((type) == T_SYMBOL) ? SYMBOL_P(obj) : \
01544         ((type) == T_FLOAT) ? RB_FLOAT_TYPE_P(obj) : \
01545         (!SPECIAL_CONST_P(obj) && BUILTIN_TYPE(obj) == (type)))
01546 
01547 #ifdef __GNUC__
01548 #define rb_type_p(obj, type) \
01549     __extension__ (__builtin_constant_p(type) ? RB_TYPE_P((obj), (type)) : \
01550                    rb_type(obj) == (type))
01551 #else
01552 #define rb_type_p(obj, type) (rb_type(obj) == (type))
01553 #endif
01554 
01555 #ifdef __GNUC__
01556 #define rb_special_const_p(obj) \
01557     __extension__ ({VALUE special_const_obj = (obj); (int)(SPECIAL_CONST_P(special_const_obj) ? Qtrue : Qfalse);})
01558 #else
01559 static inline int
01560 rb_special_const_p(VALUE obj)
01561 {
01562     if (SPECIAL_CONST_P(obj)) return (int)Qtrue;
01563     return (int)Qfalse;
01564 }
01565 #endif
01566 
01567 #include "ruby/missing.h"
01568 #include "ruby/intern.h"
01569 
01570 #if defined(EXTLIB) && defined(USE_DLN_A_OUT)
01571 /* hook for external modules */
01572 static char *dln_libs_to_be_linked[] = { EXTLIB, 0 };
01573 #endif
01574 
01575 #define RUBY_VM 1 /* YARV */
01576 #define HAVE_NATIVETHREAD
01577 int ruby_native_thread_p(void);
01578 
01579 /* traditional set_trace_func events */
01580 #define RUBY_EVENT_NONE      0x0000
01581 #define RUBY_EVENT_LINE      0x0001
01582 #define RUBY_EVENT_CLASS     0x0002
01583 #define RUBY_EVENT_END       0x0004
01584 #define RUBY_EVENT_CALL      0x0008
01585 #define RUBY_EVENT_RETURN    0x0010
01586 #define RUBY_EVENT_C_CALL    0x0020
01587 #define RUBY_EVENT_C_RETURN  0x0040
01588 #define RUBY_EVENT_RAISE     0x0080
01589 #define RUBY_EVENT_ALL       0x00ff
01590 
01591 /* for TracePoint extended events */
01592 #define RUBY_EVENT_B_CALL          0x0100
01593 #define RUBY_EVENT_B_RETURN        0x0200
01594 #define RUBY_EVENT_THREAD_BEGIN    0x0400
01595 #define RUBY_EVENT_THREAD_END      0x0800
01596 #define RUBY_EVENT_TRACEPOINT_ALL  0xFFFF
01597 
01598 /* special events */
01599 #define RUBY_EVENT_SPECIFIED_LINE 0x10000
01600 #define RUBY_EVENT_SWITCH         0x20000
01601 #define RUBY_EVENT_COVERAGE       0x40000
01602 
01603 typedef unsigned long rb_event_flag_t;
01604 typedef void (*rb_event_hook_func_t)(rb_event_flag_t evflag, VALUE data, VALUE self, ID mid, VALUE klass);
01605 
01606 #define RB_EVENT_HOOKS_HAVE_CALLBACK_DATA 1
01607 void rb_add_event_hook(rb_event_hook_func_t func, rb_event_flag_t events, VALUE data);
01608 int rb_remove_event_hook(rb_event_hook_func_t func);
01609 
01610 /* locale insensitive functions */
01611 
01612 #define rb_isascii(c) ((unsigned long)(c) < 128)
01613 int rb_isalnum(int c);
01614 int rb_isalpha(int c);
01615 int rb_isblank(int c);
01616 int rb_iscntrl(int c);
01617 int rb_isdigit(int c);
01618 int rb_isgraph(int c);
01619 int rb_islower(int c);
01620 int rb_isprint(int c);
01621 int rb_ispunct(int c);
01622 int rb_isspace(int c);
01623 int rb_isupper(int c);
01624 int rb_isxdigit(int c);
01625 int rb_tolower(int c);
01626 int rb_toupper(int c);
01627 
01628 #ifndef ISPRINT
01629 #define ISASCII(c) rb_isascii((unsigned char)(c))
01630 #undef ISPRINT
01631 #define ISPRINT(c) rb_isprint((unsigned char)(c))
01632 #define ISSPACE(c) rb_isspace((unsigned char)(c))
01633 #define ISUPPER(c) rb_isupper((unsigned char)(c))
01634 #define ISLOWER(c) rb_islower((unsigned char)(c))
01635 #define ISALNUM(c) rb_isalnum((unsigned char)(c))
01636 #define ISALPHA(c) rb_isalpha((unsigned char)(c))
01637 #define ISDIGIT(c) rb_isdigit((unsigned char)(c))
01638 #define ISXDIGIT(c) rb_isxdigit((unsigned char)(c))
01639 #endif
01640 #define TOUPPER(c) rb_toupper((unsigned char)(c))
01641 #define TOLOWER(c) rb_tolower((unsigned char)(c))
01642 
01643 int st_strcasecmp(const char *s1, const char *s2);
01644 int st_strncasecmp(const char *s1, const char *s2, size_t n);
01645 #define STRCASECMP(s1, s2) (st_strcasecmp((s1), (s2)))
01646 #define STRNCASECMP(s1, s2, n) (st_strncasecmp((s1), (s2), (n)))
01647 
01648 unsigned long ruby_strtoul(const char *str, char **endptr, int base);
01649 #define STRTOUL(str, endptr, base) (ruby_strtoul((str), (endptr), (base)))
01650 
01651 #define InitVM(ext) {void InitVM_##ext(void);InitVM_##ext();}
01652 
01653 PRINTF_ARGS(int ruby_snprintf(char *str, size_t n, char const *fmt, ...), 3, 4);
01654 int ruby_vsnprintf(char *str, size_t n, char const *fmt, va_list ap);
01655 
01656 #ifndef RUBY_DONT_SUBST
01657 #include "ruby/subst.h"
01658 #endif
01659 
01676 void ruby_sysinit(int *argc, char ***argv);
01677 void ruby_init(void);
01678 void* ruby_options(int argc, char** argv);
01679 int ruby_executable_node(void *n, int *status);
01680 int ruby_run_node(void *n);
01681 
01682 /* version.c */
01683 void ruby_show_version(void);
01684 void ruby_show_copyright(void);
01685 
01686 
01689 #define RUBY_INIT_STACK \
01690     VALUE variable_in_this_stack_frame; \
01691     ruby_init_stack(&variable_in_this_stack_frame);
01692 
01694 #ifdef __ia64
01695 void ruby_init_stack(volatile VALUE*, void*);
01696 #define ruby_init_stack(addr) ruby_init_stack((addr), rb_ia64_bsp())
01697 #else
01698 void ruby_init_stack(volatile VALUE*);
01699 #endif
01700 #define Init_stack(addr) ruby_init_stack(addr)
01701 
01702 int ruby_setup(void);
01703 int ruby_cleanup(volatile int);
01704 
01705 void ruby_finalize(void);
01706 NORETURN(void ruby_stop(int));
01707 
01708 void ruby_set_stack_size(size_t);
01709 int ruby_stack_check(void);
01710 size_t ruby_stack_length(VALUE**);
01711 
01712 int ruby_exec_node(void *n);
01713 
01714 void ruby_script(const char* name);
01715 void ruby_set_script_name(VALUE name);
01716 
01717 void ruby_prog_init(void);
01718 void ruby_set_argv(int, char**);
01719 void *ruby_process_options(int, char**);
01720 void ruby_init_loadpath(void);
01721 void ruby_incpush(const char*);
01722 void ruby_sig_finalize(void);
01723 
01726 #if defined __GNUC__ && __GNUC__ >= 4
01727 #pragma GCC visibility pop
01728 #endif
01729 
01730 #if defined(__cplusplus)
01731 #if 0
01732 { /* satisfy cc-mode */
01733 #endif
01734 }  /* extern "C" { */
01735 #endif
01736 #endif /* RUBY_RUBY_H */
01737