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