00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
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 }
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
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
00077 #ifdef __GNUC__
00078 # ifndef atarist
00079 # ifndef alloca
00080 # define alloca __builtin_alloca
00081 # endif
00082 # endif
00083 #else
00084 # ifdef HAVE_ALLOCA_H
00085 # include <alloca.h>
00086 # else
00087 # ifdef _AIX
00088 #pragma alloca
00089 # else
00090 # ifndef alloca
00091 void *alloca();
00092 # endif
00093 # endif
00094 # endif
00095 #endif
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
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
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
00381 #define USE_SYMBOL_AS_METHOD_NAME 1
00382
00383
00384
00385
00386
00387
00388
00389
00390
00391
00392
00393
00394
00395
00396
00397
00398
00399
00400
00401
00402
00403
00404
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,
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)
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
00516
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
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
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
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;
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) {
00768 union {
00769 double d;
00770 VALUE v;
00771 } t;
00772
00773 VALUE b63 = (v >> 63);
00774
00775
00776
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
00801
00802
00803
00804
00805 if (t.v != 0x3000000000000000 &&
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
00812 return 0x8000000000000002;
00813 }
00814 else {
00815
00816 return rb_float_new_in_heap(d);
00817 }
00818 }
00819 }
00820
00821 #else
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
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;
00924 int iter_lev;
00925 VALUE ifnone;
00926 };
00927
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];
00967
00968 } function;
00969 const rb_data_type_t *parent;
00970 void *data;
00971
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;
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
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
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
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)
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
01232
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
01322
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
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
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
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
01572 static char *dln_libs_to_be_linked[] = { EXTLIB, 0 };
01573 #endif
01574
01575 #define RUBY_VM 1
01576 #define HAVE_NATIVETHREAD
01577 int ruby_native_thread_p(void);
01578
01579
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
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
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
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
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 {
01733 #endif
01734 }
01735 #endif
01736 #endif
01737
