Ruby: include/ruby/ruby.h Source File

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