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