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