Ruby 1.9.3p327(2012-11-10revision37606)
|
00001 /********************************************************************** 00002 00003 ruby/ruby.h - 00004 00005 $Author: naruse $ 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 int rb_scan_args(int, const VALUE*, const char*, ...); 01157 VALUE rb_call_super(int, const VALUE*); 01158 01159 VALUE rb_gv_set(const char*, VALUE); 01160 VALUE rb_gv_get(const char*); 01161 VALUE rb_iv_get(VALUE, const char*); 01162 VALUE rb_iv_set(VALUE, const char*, VALUE); 01163 01164 VALUE rb_equal(VALUE,VALUE); 01165 01166 VALUE *rb_ruby_verbose_ptr(void); 01167 VALUE *rb_ruby_debug_ptr(void); 01168 #define ruby_verbose (*rb_ruby_verbose_ptr()) 01169 #define ruby_debug (*rb_ruby_debug_ptr()) 01170 01171 PRINTF_ARGS(NORETURN(void rb_raise(VALUE, const char*, ...)), 2, 3); 01172 PRINTF_ARGS(NORETURN(void rb_fatal(const char*, ...)), 1, 2); 01173 PRINTF_ARGS(NORETURN(void rb_bug(const char*, ...)), 1, 2); 01174 NORETURN(void rb_bug_errno(const char*, int)); 01175 NORETURN(void rb_sys_fail(const char*)); 01176 NORETURN(void rb_sys_fail_str(VALUE)); 01177 NORETURN(void rb_mod_sys_fail(VALUE, const char*)); 01178 NORETURN(void rb_mod_sys_fail_str(VALUE, VALUE)); 01179 NORETURN(void rb_iter_break(void)); 01180 NORETURN(void rb_exit(int)); 01181 NORETURN(void rb_notimplement(void)); 01182 VALUE rb_syserr_new(int, const char *); 01183 VALUE rb_syserr_new_str(int n, VALUE arg); 01184 NORETURN(void rb_syserr_fail(int, const char*)); 01185 NORETURN(void rb_syserr_fail_str(int, VALUE)); 01186 NORETURN(void rb_mod_syserr_fail(VALUE, int, const char*)); 01187 NORETURN(void rb_mod_syserr_fail_str(VALUE, int, VALUE)); 01188 01189 /* reports if `-W' specified */ 01190 PRINTF_ARGS(void rb_warning(const char*, ...), 1, 2); 01191 PRINTF_ARGS(void rb_compile_warning(const char *, int, const char*, ...), 3, 4); 01192 PRINTF_ARGS(void rb_sys_warning(const char*, ...), 1, 2); 01193 /* reports always */ 01194 PRINTF_ARGS(void rb_warn(const char*, ...), 1, 2); 01195 PRINTF_ARGS(void rb_compile_warn(const char *, int, const char*, ...), 3, 4); 01196 01197 typedef VALUE rb_block_call_func(VALUE, VALUE, int, VALUE*); 01198 01199 VALUE rb_each(VALUE); 01200 VALUE rb_yield(VALUE); 01201 VALUE rb_yield_values(int n, ...); 01202 VALUE rb_yield_values2(int n, const VALUE *argv); 01203 VALUE rb_yield_splat(VALUE); 01204 int rb_block_given_p(void); 01205 void rb_need_block(void); 01206 VALUE rb_iterate(VALUE(*)(VALUE),VALUE,VALUE(*)(ANYARGS),VALUE); 01207 VALUE rb_block_call(VALUE,ID,int,VALUE*,VALUE(*)(ANYARGS),VALUE); 01208 VALUE rb_rescue(VALUE(*)(ANYARGS),VALUE,VALUE(*)(ANYARGS),VALUE); 01209 VALUE rb_rescue2(VALUE(*)(ANYARGS),VALUE,VALUE(*)(ANYARGS),VALUE,...); 01210 VALUE rb_ensure(VALUE(*)(ANYARGS),VALUE,VALUE(*)(ANYARGS),VALUE); 01211 VALUE rb_catch(const char*,VALUE(*)(ANYARGS),VALUE); 01212 VALUE rb_catch_obj(VALUE,VALUE(*)(ANYARGS),VALUE); 01213 NORETURN(void rb_throw(const char*,VALUE)); 01214 NORETURN(void rb_throw_obj(VALUE,VALUE)); 01215 01216 VALUE rb_require(const char*); 01217 01218 #ifdef __ia64 01219 void ruby_init_stack(volatile VALUE*, void*); 01220 #define ruby_init_stack(addr) ruby_init_stack((addr), rb_ia64_bsp()) 01221 #else 01222 void ruby_init_stack(volatile VALUE*); 01223 #endif 01224 #define RUBY_INIT_STACK \ 01225 VALUE variable_in_this_stack_frame; \ 01226 ruby_init_stack(&variable_in_this_stack_frame); 01227 void ruby_init(void); 01228 void *ruby_options(int, char**); 01229 int ruby_run_node(void *); 01230 int ruby_exec_node(void *); 01231 int ruby_executable_node(void *n, int *status); 01232 01233 RUBY_EXTERN VALUE rb_mKernel; 01234 RUBY_EXTERN VALUE rb_mComparable; 01235 RUBY_EXTERN VALUE rb_mEnumerable; 01236 RUBY_EXTERN VALUE rb_mErrno; 01237 RUBY_EXTERN VALUE rb_mFileTest; 01238 RUBY_EXTERN VALUE rb_mGC; 01239 RUBY_EXTERN VALUE rb_mMath; 01240 RUBY_EXTERN VALUE rb_mProcess; 01241 RUBY_EXTERN VALUE rb_mWaitReadable; 01242 RUBY_EXTERN VALUE rb_mWaitWritable; 01243 01244 RUBY_EXTERN VALUE rb_cBasicObject; 01245 RUBY_EXTERN VALUE rb_cObject; 01246 RUBY_EXTERN VALUE rb_cArray; 01247 RUBY_EXTERN VALUE rb_cBignum; 01248 RUBY_EXTERN VALUE rb_cBinding; 01249 RUBY_EXTERN VALUE rb_cClass; 01250 RUBY_EXTERN VALUE rb_cCont; 01251 RUBY_EXTERN VALUE rb_cDir; 01252 RUBY_EXTERN VALUE rb_cData; 01253 RUBY_EXTERN VALUE rb_cFalseClass; 01254 RUBY_EXTERN VALUE rb_cEncoding; 01255 RUBY_EXTERN VALUE rb_cEnumerator; 01256 RUBY_EXTERN VALUE rb_cFile; 01257 RUBY_EXTERN VALUE rb_cFixnum; 01258 RUBY_EXTERN VALUE rb_cFloat; 01259 RUBY_EXTERN VALUE rb_cHash; 01260 RUBY_EXTERN VALUE rb_cInteger; 01261 RUBY_EXTERN VALUE rb_cIO; 01262 RUBY_EXTERN VALUE rb_cMatch; 01263 RUBY_EXTERN VALUE rb_cMethod; 01264 RUBY_EXTERN VALUE rb_cModule; 01265 RUBY_EXTERN VALUE rb_cNameErrorMesg; 01266 RUBY_EXTERN VALUE rb_cNilClass; 01267 RUBY_EXTERN VALUE rb_cNumeric; 01268 RUBY_EXTERN VALUE rb_cProc; 01269 RUBY_EXTERN VALUE rb_cRandom; 01270 RUBY_EXTERN VALUE rb_cRange; 01271 RUBY_EXTERN VALUE rb_cRational; 01272 RUBY_EXTERN VALUE rb_cComplex; 01273 RUBY_EXTERN VALUE rb_cRegexp; 01274 RUBY_EXTERN VALUE rb_cStat; 01275 RUBY_EXTERN VALUE rb_cString; 01276 RUBY_EXTERN VALUE rb_cStruct; 01277 RUBY_EXTERN VALUE rb_cSymbol; 01278 RUBY_EXTERN VALUE rb_cThread; 01279 RUBY_EXTERN VALUE rb_cTime; 01280 RUBY_EXTERN VALUE rb_cTrueClass; 01281 RUBY_EXTERN VALUE rb_cUnboundMethod; 01282 01283 RUBY_EXTERN VALUE rb_eException; 01284 RUBY_EXTERN VALUE rb_eStandardError; 01285 RUBY_EXTERN VALUE rb_eSystemExit; 01286 RUBY_EXTERN VALUE rb_eInterrupt; 01287 RUBY_EXTERN VALUE rb_eSignal; 01288 RUBY_EXTERN VALUE rb_eFatal; 01289 RUBY_EXTERN VALUE rb_eArgError; 01290 RUBY_EXTERN VALUE rb_eEOFError; 01291 RUBY_EXTERN VALUE rb_eIndexError; 01292 RUBY_EXTERN VALUE rb_eStopIteration; 01293 RUBY_EXTERN VALUE rb_eKeyError; 01294 RUBY_EXTERN VALUE rb_eRangeError; 01295 RUBY_EXTERN VALUE rb_eIOError; 01296 RUBY_EXTERN VALUE rb_eRuntimeError; 01297 RUBY_EXTERN VALUE rb_eSecurityError; 01298 RUBY_EXTERN VALUE rb_eSystemCallError; 01299 RUBY_EXTERN VALUE rb_eThreadError; 01300 RUBY_EXTERN VALUE rb_eTypeError; 01301 RUBY_EXTERN VALUE rb_eZeroDivError; 01302 RUBY_EXTERN VALUE rb_eNotImpError; 01303 RUBY_EXTERN VALUE rb_eNoMemError; 01304 RUBY_EXTERN VALUE rb_eNoMethodError; 01305 RUBY_EXTERN VALUE rb_eFloatDomainError; 01306 RUBY_EXTERN VALUE rb_eLocalJumpError; 01307 RUBY_EXTERN VALUE rb_eSysStackError; 01308 RUBY_EXTERN VALUE rb_eRegexpError; 01309 RUBY_EXTERN VALUE rb_eEncodingError; 01310 RUBY_EXTERN VALUE rb_eEncCompatError; 01311 01312 RUBY_EXTERN VALUE rb_eScriptError; 01313 RUBY_EXTERN VALUE rb_eNameError; 01314 RUBY_EXTERN VALUE rb_eSyntaxError; 01315 RUBY_EXTERN VALUE rb_eLoadError; 01316 01317 RUBY_EXTERN VALUE rb_eMathDomainError; 01318 01319 RUBY_EXTERN VALUE rb_stdin, rb_stdout, rb_stderr; 01320 01321 static inline VALUE 01322 rb_class_of(VALUE obj) 01323 { 01324 if (IMMEDIATE_P(obj)) { 01325 if (FIXNUM_P(obj)) return rb_cFixnum; 01326 if (obj == Qtrue) return rb_cTrueClass; 01327 if (SYMBOL_P(obj)) return rb_cSymbol; 01328 } 01329 else if (!RTEST(obj)) { 01330 if (obj == Qnil) return rb_cNilClass; 01331 if (obj == Qfalse) return rb_cFalseClass; 01332 } 01333 return RBASIC(obj)->klass; 01334 } 01335 01336 static inline int 01337 rb_type(VALUE obj) 01338 { 01339 if (IMMEDIATE_P(obj)) { 01340 if (FIXNUM_P(obj)) return T_FIXNUM; 01341 if (obj == Qtrue) return T_TRUE; 01342 if (SYMBOL_P(obj)) return T_SYMBOL; 01343 if (obj == Qundef) return T_UNDEF; 01344 } 01345 else if (!RTEST(obj)) { 01346 if (obj == Qnil) return T_NIL; 01347 if (obj == Qfalse) return T_FALSE; 01348 } 01349 return BUILTIN_TYPE(obj); 01350 } 01351 01352 #define RB_TYPE_P(obj, type) ( \ 01353 ((type) == T_FIXNUM) ? FIXNUM_P(obj) : \ 01354 ((type) == T_TRUE) ? ((obj) == Qtrue) : \ 01355 ((type) == T_FALSE) ? ((obj) == Qfalse) : \ 01356 ((type) == T_NIL) ? ((obj) == Qnil) : \ 01357 ((type) == T_UNDEF) ? ((obj) == Qundef) : \ 01358 ((type) == T_SYMBOL) ? SYMBOL_P(obj) : \ 01359 (!SPECIAL_CONST_P(obj) && BUILTIN_TYPE(obj) == (type))) 01360 01361 #ifdef __GNUC__ 01362 #define rb_type_p(obj, type) \ 01363 __extension__ (__builtin_constant_p(type) ? RB_TYPE_P((obj), (type)) : \ 01364 rb_type(obj) == (type)) 01365 #else 01366 #define rb_type_p(obj, type) (rb_type(obj) == (type)) 01367 #endif 01368 01369 #ifdef __GNUC__ 01370 #define rb_special_const_p(obj) \ 01371 __extension__ ({VALUE special_const_obj = (obj); (int)(SPECIAL_CONST_P(special_const_obj) ? Qtrue : Qfalse);}) 01372 #else 01373 static inline int 01374 rb_special_const_p(VALUE obj) 01375 { 01376 if (SPECIAL_CONST_P(obj)) return (int)Qtrue; 01377 return (int)Qfalse; 01378 } 01379 #endif 01380 01381 #include "ruby/missing.h" 01382 #include "ruby/intern.h" 01383 01384 #if defined(EXTLIB) && defined(USE_DLN_A_OUT) 01385 /* hook for external modules */ 01386 static char *dln_libs_to_be_linked[] = { EXTLIB, 0 }; 01387 #endif 01388 01389 #if (defined(__APPLE__) || defined(__NeXT__)) && defined(__MACH__) 01390 #define RUBY_GLOBAL_SETUP /* use linker option to link startup code with ObjC support */ 01391 #else 01392 #define RUBY_GLOBAL_SETUP 01393 #endif 01394 01395 void ruby_sysinit(int *, char ***); 01396 01397 #define RUBY_VM 1 /* YARV */ 01398 #define HAVE_NATIVETHREAD 01399 int ruby_native_thread_p(void); 01400 01401 #define RUBY_EVENT_NONE 0x0000 01402 #define RUBY_EVENT_LINE 0x0001 01403 #define RUBY_EVENT_CLASS 0x0002 01404 #define RUBY_EVENT_END 0x0004 01405 #define RUBY_EVENT_CALL 0x0008 01406 #define RUBY_EVENT_RETURN 0x0010 01407 #define RUBY_EVENT_C_CALL 0x0020 01408 #define RUBY_EVENT_C_RETURN 0x0040 01409 #define RUBY_EVENT_RAISE 0x0080 01410 #define RUBY_EVENT_ALL 0xffff 01411 #define RUBY_EVENT_VM 0x10000 01412 #define RUBY_EVENT_SWITCH 0x20000 01413 #define RUBY_EVENT_COVERAGE 0x40000 01414 01415 typedef unsigned int rb_event_flag_t; 01416 typedef void (*rb_event_hook_func_t)(rb_event_flag_t, VALUE data, VALUE, ID, VALUE klass); 01417 01418 typedef struct rb_event_hook_struct { 01419 rb_event_flag_t flag; 01420 rb_event_hook_func_t func; 01421 VALUE data; 01422 struct rb_event_hook_struct *next; 01423 } rb_event_hook_t; 01424 01425 #define RB_EVENT_HOOKS_HAVE_CALLBACK_DATA 1 01426 void rb_add_event_hook(rb_event_hook_func_t func, rb_event_flag_t events, 01427 VALUE data); 01428 int rb_remove_event_hook(rb_event_hook_func_t func); 01429 01430 /* locale insensitive functions */ 01431 01432 #define rb_isascii(c) ((unsigned long)(c) < 128) 01433 int rb_isalnum(int c); 01434 int rb_isalpha(int c); 01435 int rb_isblank(int c); 01436 int rb_iscntrl(int c); 01437 int rb_isdigit(int c); 01438 int rb_isgraph(int c); 01439 int rb_islower(int c); 01440 int rb_isprint(int c); 01441 int rb_ispunct(int c); 01442 int rb_isspace(int c); 01443 int rb_isupper(int c); 01444 int rb_isxdigit(int c); 01445 int rb_tolower(int c); 01446 int rb_toupper(int c); 01447 01448 #ifndef ISPRINT 01449 #define ISASCII(c) rb_isascii((unsigned char)(c)) 01450 #undef ISPRINT 01451 #define ISPRINT(c) rb_isprint((unsigned char)(c)) 01452 #define ISSPACE(c) rb_isspace((unsigned char)(c)) 01453 #define ISUPPER(c) rb_isupper((unsigned char)(c)) 01454 #define ISLOWER(c) rb_islower((unsigned char)(c)) 01455 #define ISALNUM(c) rb_isalnum((unsigned char)(c)) 01456 #define ISALPHA(c) rb_isalpha((unsigned char)(c)) 01457 #define ISDIGIT(c) rb_isdigit((unsigned char)(c)) 01458 #define ISXDIGIT(c) rb_isxdigit((unsigned char)(c)) 01459 #endif 01460 #define TOUPPER(c) rb_toupper((unsigned char)(c)) 01461 #define TOLOWER(c) rb_tolower((unsigned char)(c)) 01462 01463 int st_strcasecmp(const char *s1, const char *s2); 01464 int st_strncasecmp(const char *s1, const char *s2, size_t n); 01465 #define STRCASECMP(s1, s2) (st_strcasecmp((s1), (s2))) 01466 #define STRNCASECMP(s1, s2, n) (st_strncasecmp((s1), (s2), (n))) 01467 01468 unsigned long ruby_strtoul(const char *str, char **endptr, int base); 01469 #define STRTOUL(str, endptr, base) (ruby_strtoul((str), (endptr), (base))) 01470 01471 #define InitVM(ext) {void InitVM_##ext(void);InitVM_##ext();} 01472 01473 PRINTF_ARGS(int ruby_snprintf(char *str, size_t n, char const *fmt, ...), 3, 4); 01474 int ruby_vsnprintf(char *str, size_t n, char const *fmt, va_list ap); 01475 01476 #if defined __GNUC__ && __GNUC__ >= 4 01477 #pragma GCC visibility pop 01478 #endif 01479 01480 #ifndef RUBY_DONT_SUBST 01481 #include "ruby/subst.h" 01482 #endif 01483 01484 #if defined(__cplusplus) 01485 #if 0 01486 { /* satisfy cc-mode */ 01487 #endif 01488 } /* extern "C" { */ 01489 #endif 01490 #endif /* RUBY_RUBY_H */ 01491