diff options
Diffstat (limited to 'include/ruby/ruby.h')
| -rw-r--r-- | include/ruby/ruby.h | 1174 |
1 files changed, 371 insertions, 803 deletions
diff --git a/include/ruby/ruby.h b/include/ruby/ruby.h index cd03125990..0294b08363 100644 --- a/include/ruby/ruby.h +++ b/include/ruby/ruby.h @@ -21,12 +21,12 @@ extern "C" { #endif #endif +#ifndef RUBY_LIB_PREFIX #include "ruby/config.h" #ifdef RUBY_EXTCONF_H #include RUBY_EXTCONF_H #endif - -#include "defines.h" +#endif #define NORETURN_STYLE_NEW 1 #ifndef NORETURN @@ -38,9 +38,6 @@ extern "C" { #ifndef NOINLINE # define NOINLINE(x) x #endif -#ifndef UNREACHABLE -# define UNREACHABLE /* unreachable */ -#endif #ifdef __GNUC__ #define PRINTF_ARGS(decl, string_index, first_to_check) \ @@ -49,36 +46,40 @@ extern "C" { #define PRINTF_ARGS(decl, string_index, first_to_check) decl #endif -#define RUBY_MACRO_SELECT(base, n) TOKEN_PASTE(base, n) +#ifdef HAVE_STDLIB_H +# include <stdlib.h> +#endif + +#ifdef HAVE_STRING_H +# include <string.h> +#else +# include <strings.h> +#endif #ifdef HAVE_INTRINSICS_H # include <intrinsics.h> #endif +#ifdef HAVE_STDINT_H +# include <stdint.h> +#endif +#ifdef HAVE_INTTYPES_H +# include <inttypes.h> +#endif + #include <stdarg.h> +#include <stddef.h> +#include <stdio.h> -RUBY_SYMBOL_EXPORT_BEGIN +#include "defines.h" -/* Make alloca work the best possible way. */ -#ifdef __GNUC__ -# ifndef atarist -# ifndef alloca -# define alloca __builtin_alloca -# endif -# endif /* atarist */ +#if defined(HAVE_ALLOCA_H) +#include <alloca.h> #else -# ifdef HAVE_ALLOCA_H -# include <alloca.h> -# else # ifdef _AIX #pragma alloca -# else -# ifndef alloca /* predefined by HP cc +Olibcalls */ -void *alloca(); -# endif -# endif /* AIX */ -# endif /* HAVE_ALLOCA_H */ -#endif /* __GNUC__ */ +# endif +#endif #if defined HAVE_UINTPTR_T && 0 typedef uintptr_t VALUE; @@ -98,46 +99,32 @@ typedef unsigned LONG_LONG ID; # define SIGNED_VALUE LONG_LONG # define LONG_LONG_VALUE 1 # define SIZEOF_VALUE SIZEOF_LONG_LONG -# define PRI_VALUE_PREFIX PRI_LL_PREFIX +# define PRI_VALUE_PREFIX "ll" #else -# error ---->> ruby requires sizeof(void*) == sizeof(long) or sizeof(LONG_LONG) to be compiled. <<---- +# error ---->> ruby requires sizeof(void*) == sizeof(long) to be compiled. <<---- #endif typedef char ruby_check_sizeof_int[SIZEOF_INT == sizeof(int) ? 1 : -1]; typedef char ruby_check_sizeof_long[SIZEOF_LONG == sizeof(long) ? 1 : -1]; -#ifdef HAVE_LONG_LONG +#ifdef SIZEOF_LONG_LONG typedef char ruby_check_sizeof_long_long[SIZEOF_LONG_LONG == sizeof(LONG_LONG) ? 1 : -1]; #endif typedef char ruby_check_sizeof_voidp[SIZEOF_VOIDP == sizeof(void*) ? 1 : -1]; -#ifndef PRI_INT_PREFIX -#define PRI_INT_PREFIX "" -#endif -#ifndef PRI_LONG_PREFIX -#define PRI_LONG_PREFIX "l" -#endif - -#if SIZEOF_LONG == 8 -#define PRI_64_PREFIX PRI_LONG_PREFIX -#elif SIZEOF_LONG_LONG == 8 -#define PRI_64_PREFIX PRI_LL_PREFIX -#endif - -#define RUBY_PRI_VALUE_MARK "\v" #if defined PRIdPTR && !defined PRI_VALUE_PREFIX #define PRIdVALUE PRIdPTR +#define PRIiVALUE PRIiPTR #define PRIoVALUE PRIoPTR #define PRIuVALUE PRIuPTR #define PRIxVALUE PRIxPTR #define PRIXVALUE PRIXPTR -#define PRIsVALUE PRIiPTR"" RUBY_PRI_VALUE_MARK #else #define PRIdVALUE PRI_VALUE_PREFIX"d" +#define PRIiVALUE PRI_VALUE_PREFIX"i" #define PRIoVALUE PRI_VALUE_PREFIX"o" #define PRIuVALUE PRI_VALUE_PREFIX"u" #define PRIxVALUE PRI_VALUE_PREFIX"x" #define PRIXVALUE PRI_VALUE_PREFIX"X" -#define PRIsVALUE PRI_VALUE_PREFIX"i" RUBY_PRI_VALUE_MARK #endif #ifndef PRI_VALUE_PREFIX # define PRI_VALUE_PREFIX "" @@ -149,17 +136,18 @@ typedef char ruby_check_sizeof_voidp[SIZEOF_VOIDP == sizeof(void*) ? 1 : -1]; # elif SIZEOF_TIME_T == SIZEOF_LONG # define PRI_TIMET_PREFIX "l" # elif SIZEOF_TIME_T == SIZEOF_LONG_LONG -# define PRI_TIMET_PREFIX PRI_LL_PREFIX +# define PRI_TIMET_PREFIX "ll" # endif #endif -#if defined PRI_PTRDIFF_PREFIX +#if defined PRIdPTR +# define PRI_PTRDIFF_PREFIX "t" #elif SIZEOF_PTRDIFF_T == SIZEOF_INT -# define PRI_PTRDIFF_PREFIX "" +# define PRI_PTRDIFF_PREFIX #elif SIZEOF_PTRDIFF_T == SIZEOF_LONG # define PRI_PTRDIFF_PREFIX "l" #elif SIZEOF_PTRDIFF_T == SIZEOF_LONG_LONG -# define PRI_PTRDIFF_PREFIX PRI_LL_PREFIX +# define PRI_PTRDIFF_PREFIX "ll" #endif #define PRIdPTRDIFF PRI_PTRDIFF_PREFIX"d" #define PRIiPTRDIFF PRI_PTRDIFF_PREFIX"i" @@ -168,13 +156,14 @@ typedef char ruby_check_sizeof_voidp[SIZEOF_VOIDP == sizeof(void*) ? 1 : -1]; #define PRIxPTRDIFF PRI_PTRDIFF_PREFIX"x" #define PRIXPTRDIFF PRI_PTRDIFF_PREFIX"X" -#if defined PRI_SIZE_PREFIX +#if defined PRIdPTR +# define PRI_SIZE_PREFIX "z" #elif SIZEOF_SIZE_T == SIZEOF_INT -# define PRI_SIZE_PREFIX "" +# define PRI_SIZE_PREFIX #elif SIZEOF_SIZE_T == SIZEOF_LONG # define PRI_SIZE_PREFIX "l" #elif SIZEOF_SIZE_T == SIZEOF_LONG_LONG -# define PRI_SIZE_PREFIX PRI_LL_PREFIX +# define PRI_SIZE_PREFIX "ll" #endif #define PRIdSIZE PRI_SIZE_PREFIX"d" #define PRIiSIZE PRI_SIZE_PREFIX"i" @@ -190,7 +179,7 @@ typedef char ruby_check_sizeof_voidp[SIZEOF_VOIDP == sizeof(void*) ? 1 : -1]; # ifdef HAVE_LIMITS_H # include <limits.h> # else - /* assuming 32bit(2's complement) long */ + /* assuming 32bit(2's compliment) long */ # define LONG_MAX 2147483647 # endif # endif @@ -231,7 +220,7 @@ typedef char ruby_check_sizeof_voidp[SIZEOF_VOIDP == sizeof(void*) ? 1 : -1]; #define FIXNUM_MAX (LONG_MAX>>1) #define FIXNUM_MIN RSHIFT((long)LONG_MIN,1) -#define INT2FIX(i) (((VALUE)(i))<<1 | FIXNUM_FLAG) +#define INT2FIX(i) ((VALUE)(((SIGNED_VALUE)(i))<<1 | FIXNUM_FLAG)) #define LONG2FIX(i) INT2FIX(i) #define rb_fix_new(v) INT2FIX(v) VALUE rb_int2inum(SIGNED_VALUE); @@ -248,7 +237,6 @@ VALUE rb_ull2inum(unsigned LONG_LONG); #define ULL2NUM(v) rb_ull2inum(v) #endif -#ifndef OFFT2NUM #if SIZEOF_OFF_T > SIZEOF_LONG && defined(HAVE_LONG_LONG) # define OFFT2NUM(v) LL2NUM(v) #elif SIZEOF_OFF_T == SIZEOF_LONG @@ -256,7 +244,6 @@ VALUE rb_ull2inum(unsigned LONG_LONG); #else # define OFFT2NUM(v) INT2NUM(v) #endif -#endif #if SIZEOF_SIZE_T > SIZEOF_LONG && defined(HAVE_LONG_LONG) # define SIZET2NUM(v) ULL2NUM(v) @@ -306,16 +293,15 @@ NORETURN(void rb_out_of_int(SIGNED_VALUE num)); #endif #if SIZEOF_INT < SIZEOF_LONG +#define rb_long2int_internal(n, i) \ + int i = (int)(n); \ + if ((long)i != (n)) rb_out_of_int(n) +#ifdef __GNUC__ +#define rb_long2int(n) __extension__ ({long i2l_n = (n); rb_long2int_internal(i2l_n, i2l_i); i2l_i;}) +#else static inline int -rb_long2int_inline(long n) -{ - int i = (int)n; - if ((long)i != n) - rb_out_of_int(n); - - return i; -} -#define rb_long2int(n) rb_long2int_inline(n) +rb_long2int(long n) {rb_long2int_internal(n, i); return i;} +#endif #else #define rb_long2int(n) ((int)(n)) #endif @@ -338,72 +324,33 @@ rb_long2int_inline(long n) #ifndef NUM2GIDT #define NUM2GIDT(v) NUM2LONG(v) #endif -#ifndef NUM2MODET -#define NUM2MODET(v) NUM2INT(v) -#endif -#ifndef MODET2NUM -#define MODET2NUM(v) INT2NUM(v) -#endif -#define FIX2LONG(x) ((long)RSHIFT((SIGNED_VALUE)(x),1)) -#define FIX2ULONG(x) ((unsigned long)FIX2LONG(x)) -#define FIXNUM_P(f) (((int)(SIGNED_VALUE)(f))&FIXNUM_FLAG) +#define FIX2LONG(x) RSHIFT((SIGNED_VALUE)x,1) +#define FIX2ULONG(x) ((((VALUE)(x))>>1)&LONG_MAX) +#define FIXNUM_P(f) (((SIGNED_VALUE)(f))&FIXNUM_FLAG) #define POSFIXABLE(f) ((f) < FIXNUM_MAX+1) #define NEGFIXABLE(f) ((f) >= FIXNUM_MIN) #define FIXABLE(f) (POSFIXABLE(f) && NEGFIXABLE(f)) #define IMMEDIATE_P(x) ((VALUE)(x) & IMMEDIATE_MASK) -ID rb_sym2id(VALUE); -VALUE rb_id2sym(ID); -#define STATIC_SYM_P(x) (((VALUE)(x)&~((~(VALUE)0)<<RUBY_SPECIAL_SHIFT))==SYMBOL_FLAG) -#define DYNAMIC_SYM_P(x) (!SPECIAL_CONST_P(x) && BUILTIN_TYPE(x) == (T_SYMBOL)) -#define SYMBOL_P(x) (STATIC_SYM_P(x)||DYNAMIC_SYM_P(x)) -#define ID2SYM(x) (rb_id2sym(x)) -#define SYM2ID(x) (rb_sym2id(x)) - -#ifndef USE_FLONUM -#if SIZEOF_VALUE >= SIZEOF_DOUBLE -#define USE_FLONUM 1 -#else -#define USE_FLONUM 0 -#endif -#endif - -#if USE_FLONUM -#define FLONUM_P(x) ((((int)(SIGNED_VALUE)(x))&FLONUM_MASK) == FLONUM_FLAG) -#else -#define FLONUM_P(x) 0 -#endif +#define SYMBOL_P(x) (((VALUE)(x)&~(~(VALUE)0<<RUBY_SPECIAL_SHIFT))==SYMBOL_FLAG) +#define ID2SYM(x) (((VALUE)(x)<<RUBY_SPECIAL_SHIFT)|SYMBOL_FLAG) +#define SYM2ID(x) RSHIFT((unsigned long)(x),RUBY_SPECIAL_SHIFT) /* Module#methods, #singleton_methods and so on return Symbols */ #define USE_SYMBOL_AS_METHOD_NAME 1 /* special constants - i.e. non-zero and non-fixnum constants */ enum ruby_special_consts { -#if USE_FLONUM - RUBY_Qfalse = 0x00, /* ...0000 0000 */ - RUBY_Qtrue = 0x14, /* ...0001 0100 */ - RUBY_Qnil = 0x08, /* ...0000 1000 */ - RUBY_Qundef = 0x34, /* ...0011 0100 */ - - RUBY_IMMEDIATE_MASK = 0x07, - RUBY_FIXNUM_FLAG = 0x01, /* ...xxxx xxx1 */ - RUBY_FLONUM_MASK = 0x03, - RUBY_FLONUM_FLAG = 0x02, /* ...xxxx xx10 */ - RUBY_SYMBOL_FLAG = 0x0c, /* ...0000 1100 */ -#else - RUBY_Qfalse = 0, /* ...0000 0000 */ - RUBY_Qtrue = 2, /* ...0000 0010 */ - RUBY_Qnil = 4, /* ...0000 0100 */ - RUBY_Qundef = 6, /* ...0000 0110 */ + RUBY_Qfalse = 0, + RUBY_Qtrue = 2, + RUBY_Qnil = 4, + RUBY_Qundef = 6, RUBY_IMMEDIATE_MASK = 0x03, - RUBY_FIXNUM_FLAG = 0x01, /* ...xxxx xxx1 */ - RUBY_FLONUM_MASK = 0x00, /* any values ANDed with FLONUM_MASK cannot be FLONUM_FLAG */ - RUBY_FLONUM_FLAG = 0x02, - RUBY_SYMBOL_FLAG = 0x0e, /* ...0000 1110 */ -#endif + RUBY_FIXNUM_FLAG = 0x01, + RUBY_SYMBOL_FLAG = 0x0e, RUBY_SPECIAL_SHIFT = 8 }; @@ -413,14 +360,10 @@ enum ruby_special_consts { #define Qundef ((VALUE)RUBY_Qundef) /* undefined value for placeholder */ #define IMMEDIATE_MASK RUBY_IMMEDIATE_MASK #define FIXNUM_FLAG RUBY_FIXNUM_FLAG -#if USE_FLONUM -#define FLONUM_MASK RUBY_FLONUM_MASK -#define FLONUM_FLAG RUBY_FLONUM_FLAG -#endif #define SYMBOL_FLAG RUBY_SYMBOL_FLAG -#define RTEST(v) !(((VALUE)(v) & ~Qnil) == 0) -#define NIL_P(v) !((VALUE)(v) != Qnil) +#define RTEST(v) (((VALUE)(v) & ~Qnil) != 0) +#define NIL_P(v) ((VALUE)(v) == Qnil) #define CLASS_OF(v) rb_class_of((VALUE)(v)) @@ -489,48 +432,23 @@ enum ruby_value_type { static inline int rb_type(VALUE obj); #define TYPE(x) rb_type((VALUE)(x)) -#define RB_FLOAT_TYPE_P(obj) (FLONUM_P(obj) || (!SPECIAL_CONST_P(obj) && BUILTIN_TYPE(obj) == T_FLOAT)) - -#define RB_TYPE_P(obj, type) ( \ - ((type) == T_FIXNUM) ? FIXNUM_P(obj) : \ - ((type) == T_TRUE) ? ((obj) == Qtrue) : \ - ((type) == T_FALSE) ? ((obj) == Qfalse) : \ - ((type) == T_NIL) ? ((obj) == Qnil) : \ - ((type) == T_UNDEF) ? ((obj) == Qundef) : \ - ((type) == T_SYMBOL) ? SYMBOL_P(obj) : \ - ((type) == T_FLOAT) ? RB_FLOAT_TYPE_P(obj) : \ - (!SPECIAL_CONST_P(obj) && BUILTIN_TYPE(obj) == (type))) - -/* RB_GC_GUARD_PTR() is an intermediate macro, and has no effect by - * itself. don't use it directly */ #ifdef __GNUC__ #define RB_GC_GUARD_PTR(ptr) \ __extension__ ({volatile VALUE *rb_gc_guarded_ptr = (ptr); rb_gc_guarded_ptr;}) #else #ifdef _MSC_VER #pragma optimize("", off) +#endif static inline volatile VALUE *rb_gc_guarded_ptr(volatile VALUE *ptr) {return ptr;} +#ifdef _MSC_VER #pragma optimize("", on) -#else -volatile VALUE *rb_gc_guarded_ptr_val(volatile VALUE *ptr, VALUE val); -#define HAVE_RB_GC_GUARDED_PTR_VAL 1 -#define RB_GC_GUARD(v) (*rb_gc_guarded_ptr_val(&(v),(v))) #endif #define RB_GC_GUARD_PTR(ptr) rb_gc_guarded_ptr(ptr) #endif - -#ifndef RB_GC_GUARD #define RB_GC_GUARD(v) (*RB_GC_GUARD_PTR(&(v))) -#endif - -#ifdef __GNUC__ -#define RB_UNUSED_VAR(x) x __attribute__ ((unused)) -#else -#define RB_UNUSED_VAR(x) x -#endif void rb_check_type(VALUE,int); -#define Check_Type(v,t) rb_check_type((VALUE)(v),(t)) +#define Check_Type(v,t) rb_check_type((VALUE)(v),t) VALUE rb_str_to_str(VALUE); VALUE rb_string_value(volatile VALUE*); @@ -542,17 +460,13 @@ char *rb_string_value_cstr(volatile VALUE*); #define StringValueCStr(v) rb_string_value_cstr(&(v)) void rb_check_safe_obj(VALUE); +DEPRECATED(void rb_check_safe_str(VALUE)); #define SafeStringValue(v) do {\ StringValue(v);\ rb_check_safe_obj(v);\ } while (0) -#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4)) -void rb_check_safe_str(VALUE) __attribute__((error("rb_check_safe_str() and Check_SafeStr() are obsolete; use SafeStringValue() instead"))); -# define Check_SafeStr(v) rb_check_safe_str((VALUE)(v)) -#else -# define rb_check_safe_str(x) [<"rb_check_safe_str() is obsolete; use SafeStringValue() instead">] -# define Check_SafeStr(v) [<"Check_SafeStr() is obsolete; use SafeStringValue() instead">] -#endif +/* obsolete macro - use SafeStringValue(v) */ +#define Check_SafeStr(v) rb_check_safe_str((VALUE)(v)) VALUE rb_str_export(VALUE); #define ExportStringValue(v) do {\ @@ -567,37 +481,9 @@ VALUE rb_get_path(VALUE); VALUE rb_get_path_no_checksafe(VALUE); #define FilePathStringValue(v) ((v) = rb_get_path_no_checksafe(v)) -#define RUBY_SAFE_LEVEL_MAX 3 void rb_secure(int); int rb_safe_level(void); void rb_set_safe_level(int); -#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4)) -int ruby_safe_level_4_error(void) __attribute__((error("$SAFE=4 is obsolete"))); -int ruby_safe_level_4_warning(void) __attribute__((warning("$SAFE=4 is obsolete"))); -# ifdef RUBY_EXPORT -# define ruby_safe_level_4_warning() ruby_safe_level_4_error() -# endif -#if defined(HAVE_BUILTIN___BUILTIN_CHOOSE_EXPR_CONSTANT_P) -# define RUBY_SAFE_LEVEL_INVALID_P(level) \ - __extension__(\ - __builtin_choose_expr(\ - __builtin_constant_p(level), \ - ((level) < 0 || RUBY_SAFE_LEVEL_MAX < (level)), 0)) -# define RUBY_SAFE_LEVEL_CHECK(level, type) \ - __extension__(__builtin_choose_expr(RUBY_SAFE_LEVEL_INVALID_P(level), ruby_safe_level_4_##type(), (level))) -#else -/* in gcc 4.8 or earlier, __builtin_choose_expr() does not consider - * __builtin_constant_p(variable) a constant expression. - */ -# define RUBY_SAFE_LEVEL_INVALID_P(level) \ - __extension__(__builtin_constant_p(level) && \ - ((level) < 0 || RUBY_SAFE_LEVEL_MAX < (level))) -# define RUBY_SAFE_LEVEL_CHECK(level, type) \ - (RUBY_SAFE_LEVEL_INVALID_P(level) ? ruby_safe_level_4_##type() : (level)) -#endif -#define rb_secure(level) rb_secure(RUBY_SAFE_LEVEL_CHECK(level, warning)) -#define rb_set_safe_level(level) rb_set_safe_level(RUBY_SAFE_LEVEL_CHECK(level, error)) -#endif void rb_set_safe_level_force(int); void rb_secure_update(VALUE); NORETURN(void rb_insecure_operation(void)); @@ -605,95 +491,72 @@ NORETURN(void rb_insecure_operation(void)); VALUE rb_errinfo(void); void rb_set_errinfo(VALUE); -long rb_num2long(VALUE); -unsigned long rb_num2ulong(VALUE); +SIGNED_VALUE rb_num2long(VALUE); +VALUE rb_num2ulong(VALUE); +#define NUM2LONG_internal(x) (FIXNUM_P(x) ? FIX2LONG(x) : rb_num2long(x)) +#ifdef __GNUC__ +#define NUM2LONG(x) \ + __extension__ ({VALUE num2long_x = (x); NUM2LONG_internal(num2long_x);}) +#else static inline long -rb_num2long_inline(VALUE x) +NUM2LONG(VALUE x) { - if (FIXNUM_P(x)) - return FIX2LONG(x); - else - return rb_num2long(x); + return NUM2LONG_internal(x); } -#define NUM2LONG(x) rb_num2long_inline(x) -static inline unsigned long -rb_num2ulong_inline(VALUE x) -{ - if (FIXNUM_P(x)) - return (unsigned long)FIX2LONG(x); - else - return rb_num2ulong(x); -} -#define NUM2ULONG(x) rb_num2ulong_inline(x) +#endif +#define NUM2ULONG(x) rb_num2ulong((VALUE)x) #if SIZEOF_INT < SIZEOF_LONG long rb_num2int(VALUE); long rb_fix2int(VALUE); -#define FIX2INT(x) ((int)rb_fix2int((VALUE)(x))) - +#define FIX2INT(x) ((int)rb_fix2int((VALUE)x)) +#define NUM2INT_internal(x) (FIXNUM_P(x) ? FIX2INT(x) : (int)rb_num2int(x)) +#ifdef __GNUC__ +#define NUM2INT(x) \ + __extension__ ({VALUE num2int_x = (x); NUM2INT_internal(num2int_x);}) +#else static inline int -rb_num2int_inline(VALUE x) +NUM2INT(VALUE x) { - if (FIXNUM_P(x)) - return FIX2INT(x); - else - return (int)rb_num2int(x); + return NUM2INT_internal(x); } -#define NUM2INT(x) rb_num2int_inline(x) - +#endif unsigned long rb_num2uint(VALUE); #define NUM2UINT(x) ((unsigned int)rb_num2uint(x)) unsigned long rb_fix2uint(VALUE); #define FIX2UINT(x) ((unsigned int)rb_fix2uint(x)) -#else /* SIZEOF_INT < SIZEOF_LONG */ +#else #define NUM2INT(x) ((int)NUM2LONG(x)) #define NUM2UINT(x) ((unsigned int)NUM2ULONG(x)) #define FIX2INT(x) ((int)FIX2LONG(x)) #define FIX2UINT(x) ((unsigned int)FIX2ULONG(x)) -#endif /* SIZEOF_INT < SIZEOF_LONG */ - -short rb_num2short(VALUE); -unsigned short rb_num2ushort(VALUE); -short rb_fix2short(VALUE); -unsigned short rb_fix2ushort(VALUE); -#define FIX2SHORT(x) (rb_fix2short((VALUE)(x))) -static inline short -rb_num2short_inline(VALUE x) -{ - if (FIXNUM_P(x)) - return FIX2SHORT(x); - else - return rb_num2short(x); -} - -#define NUM2SHORT(x) rb_num2short_inline(x) -#define NUM2USHORT(x) rb_num2ushort(x) +#endif #ifdef HAVE_LONG_LONG LONG_LONG rb_num2ll(VALUE); unsigned LONG_LONG rb_num2ull(VALUE); +# define NUM2LL_internal(x) (FIXNUM_P(x) ? FIX2LONG(x) : rb_num2ll(x)) +# ifdef __GNUC__ +# define NUM2LL(x) \ + __extension__ ({VALUE num2ll_x = (x); NUM2LL_internal(num2ll_x);}) +# else static inline LONG_LONG -rb_num2ll_inline(VALUE x) +NUM2LL(VALUE x) { - if (FIXNUM_P(x)) - return FIX2LONG(x); - else - return rb_num2ll(x); + return NUM2LL_internal(x); } -# define NUM2LL(x) rb_num2ll_inline(x) -# define NUM2ULL(x) rb_num2ull(x) +# endif +# define NUM2ULL(x) rb_num2ull((VALUE)x) #endif -#if !defined(NUM2OFFT) -# if defined(HAVE_LONG_LONG) && SIZEOF_OFF_T > SIZEOF_LONG -# define NUM2OFFT(x) ((off_t)NUM2LL(x)) -# else -# define NUM2OFFT(x) NUM2LONG(x) -# endif +#if defined(HAVE_LONG_LONG) && SIZEOF_OFF_T > SIZEOF_LONG +# define NUM2OFFT(x) ((off_t)NUM2LL(x)) +#else +# define NUM2OFFT(x) NUM2LONG(x) #endif #if defined(HAVE_LONG_LONG) && SIZEOF_SIZE_T > SIZEOF_LONG # define NUM2SIZET(x) ((size_t)NUM2ULL(x)) -# define NUM2SSIZET(x) ((ssize_t)NUM2LL(x)) +# define NUM2SSIZET(x) ((size_t)NUM2LL(x)) #else # define NUM2SIZET(x) NUM2ULONG(x) # define NUM2SSIZET(x) NUM2LONG(x) @@ -706,89 +569,33 @@ VALUE rb_uint2big(VALUE); VALUE rb_int2big(SIGNED_VALUE); VALUE rb_newobj(void); -VALUE rb_newobj_of(VALUE, VALUE); -VALUE rb_obj_setup(VALUE obj, VALUE klass, VALUE type); -#define NEWOBJ(obj,type) type *(obj) = (type*)rb_newobj() -#define NEWOBJ_OF(obj,type,klass,flags) type *(obj) = (type*)rb_newobj_of(klass, flags) -#define OBJSETUP(obj,c,t) rb_obj_setup(obj, c, t) /* use NEWOBJ_OF instead of NEWOBJ()+OBJSETUP() */ +#define NEWOBJ(obj,type) type *obj = (type*)rb_newobj() +#define OBJSETUP(obj,c,t) do {\ + RBASIC(obj)->flags = (t);\ + RBASIC(obj)->klass = (c);\ + if (rb_safe_level() >= 3) FL_SET(obj, FL_TAINT | FL_UNTRUSTED);\ +} while (0) #define CLONESETUP(clone,obj) do {\ - OBJSETUP((clone),rb_singleton_class_clone((VALUE)(obj)),RBASIC(obj)->flags);\ - rb_singleton_class_attached(RBASIC(clone)->klass, (VALUE)(clone));\ - if (FL_TEST((obj), FL_EXIVAR)) rb_copy_generic_ivar((VALUE)(clone),(VALUE)(obj));\ + OBJSETUP(clone,rb_singleton_class_clone((VALUE)obj),RBASIC(obj)->flags);\ + rb_singleton_class_attached(RBASIC(clone)->klass, (VALUE)clone);\ + if (FL_TEST(obj, FL_EXIVAR)) rb_copy_generic_ivar((VALUE)clone,(VALUE)obj);\ } while (0) #define DUPSETUP(dup,obj) do {\ - OBJSETUP((dup),rb_obj_class(obj), (RBASIC(obj)->flags)&(T_MASK|FL_EXIVAR|FL_TAINT)); \ - if (FL_TEST((obj), FL_EXIVAR)) rb_copy_generic_ivar((VALUE)(dup),(VALUE)(obj));\ + OBJSETUP(dup,rb_obj_class(obj), (RBASIC(obj)->flags)&(T_MASK|FL_EXIVAR|FL_TAINT|FL_UNTRUSTED)); \ + if (FL_TEST(obj, FL_EXIVAR)) rb_copy_generic_ivar((VALUE)dup,(VALUE)obj);\ } while (0) -#ifndef USE_RGENGC -#define USE_RGENGC 1 -#ifndef USE_RINCGC -#define USE_RINCGC 1 -#endif -#endif - -#if USE_RGENGC == 0 -#define USE_RINCGC 0 -#endif - -#ifndef RGENGC_WB_PROTECTED_ARRAY -#define RGENGC_WB_PROTECTED_ARRAY 1 -#endif -#ifndef RGENGC_WB_PROTECTED_HASH -#define RGENGC_WB_PROTECTED_HASH 1 -#endif -#ifndef RGENGC_WB_PROTECTED_STRUCT -#define RGENGC_WB_PROTECTED_STRUCT 1 -#endif -#ifndef RGENGC_WB_PROTECTED_STRING -#define RGENGC_WB_PROTECTED_STRING 1 -#endif -#ifndef RGENGC_WB_PROTECTED_OBJECT -#define RGENGC_WB_PROTECTED_OBJECT 1 -#endif -#ifndef RGENGC_WB_PROTECTED_REGEXP -#define RGENGC_WB_PROTECTED_REGEXP 1 -#endif -#ifndef RGENGC_WB_PROTECTED_CLASS -#define RGENGC_WB_PROTECTED_CLASS 1 -#endif -#ifndef RGENGC_WB_PROTECTED_FLOAT -#define RGENGC_WB_PROTECTED_FLOAT 1 -#endif -#ifndef RGENGC_WB_PROTECTED_COMPLEX -#define RGENGC_WB_PROTECTED_COMPLEX 1 -#endif -#ifndef RGENGC_WB_PROTECTED_RATIONAL -#define RGENGC_WB_PROTECTED_RATIONAL 1 -#endif -#ifndef RGENGC_WB_PROTECTED_BIGNUM -#define RGENGC_WB_PROTECTED_BIGNUM 1 -#endif -#ifndef RGENGC_WB_PROTECTED_NODE_CREF -#define RGENGC_WB_PROTECTED_NODE_CREF 1 -#endif - struct RBasic { VALUE flags; - const VALUE klass; -} -#ifdef __GNUC__ - __attribute__((aligned(sizeof(VALUE)))) -#endif -; - -VALUE rb_obj_hide(VALUE obj); -VALUE rb_obj_reveal(VALUE obj, VALUE klass); /* do not use this API to change klass information */ - -#define RBASIC_CLASS(obj) (RBASIC(obj)->klass) + VALUE klass; +}; #define ROBJECT_EMBED_LEN_MAX 3 struct RObject { struct RBasic basic; union { struct { - long numiv; /* only uses 32-bits */ + long numiv; VALUE *ivptr; struct st_table *iv_index_tbl; /* shortcut for RCLASS_IV_INDEX_TBL(rb_obj_class(obj)) */ } heap; @@ -810,28 +617,30 @@ struct RObject { ROBJECT(o)->as.heap.iv_index_tbl) /** @internal */ -typedef struct rb_classext_struct rb_classext_t; +typedef struct { + VALUE super; + struct st_table *iv_tbl; +} rb_classext_t; struct RClass { struct RBasic basic; - VALUE super; rb_classext_t *ptr; - struct method_table_wrapper *m_tbl_wrapper; + struct st_table *m_tbl; + struct st_table *iv_index_tbl; }; -#define RCLASS_SUPER(c) rb_class_get_superclass(c) +#define RCLASS_IV_TBL(c) (RCLASS(c)->ptr->iv_tbl) +#define RCLASS_M_TBL(c) (RCLASS(c)->m_tbl) +#define RCLASS_SUPER(c) (RCLASS(c)->ptr->super) +#define RCLASS_IV_INDEX_TBL(c) (RCLASS(c)->iv_index_tbl) #define RMODULE_IV_TBL(m) RCLASS_IV_TBL(m) -#define RMODULE_CONST_TBL(m) RCLASS_CONST_TBL(m) #define RMODULE_M_TBL(m) RCLASS_M_TBL(m) #define RMODULE_SUPER(m) RCLASS_SUPER(m) -#define RMODULE_IS_OVERLAID FL_USER2 -#define RMODULE_IS_REFINEMENT FL_USER3 -#define RMODULE_INCLUDED_INTO_REFINEMENT FL_USER4 - -double rb_float_value(VALUE); -VALUE rb_float_new(double); -VALUE rb_float_new_in_heap(double); -#define RFLOAT_VALUE(v) rb_float_value(v) +struct RFloat { + struct RBasic basic; + double float_value; +}; +#define RFLOAT_VALUE(v) (RFLOAT(v)->float_value) #define DBL2NUM(dbl) rb_float_new(dbl) #define ELTS_SHARED FL_USER2 @@ -852,15 +661,12 @@ struct RString { } as; }; #define RSTRING_NOEMBED FL_USER1 -#define RSTRING_FSTR FL_USER17 #define RSTRING_EMBED_LEN_MASK (FL_USER2|FL_USER3|FL_USER4|FL_USER5|FL_USER6) #define RSTRING_EMBED_LEN_SHIFT (FL_USHIFT+2) -#define RSTRING_EMBED_LEN(str) \ - (long)((RBASIC(str)->flags >> RSTRING_EMBED_LEN_SHIFT) & \ - (RSTRING_EMBED_LEN_MASK >> RSTRING_EMBED_LEN_SHIFT)) #define RSTRING_LEN(str) \ (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? \ - RSTRING_EMBED_LEN(str) : \ + (long)((RBASIC(str)->flags >> RSTRING_EMBED_LEN_SHIFT) & \ + (RSTRING_EMBED_LEN_MASK >> RSTRING_EMBED_LEN_SHIFT)) : \ RSTRING(str)->as.heap.len) #define RSTRING_PTR(str) \ (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? \ @@ -868,13 +674,11 @@ struct RString { RSTRING(str)->as.heap.ptr) #define RSTRING_END(str) \ (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? \ - (RSTRING(str)->as.ary + RSTRING_EMBED_LEN(str)) : \ + (RSTRING(str)->as.ary + \ + ((RBASIC(str)->flags >> RSTRING_EMBED_LEN_SHIFT) & \ + (RSTRING_EMBED_LEN_MASK >> RSTRING_EMBED_LEN_SHIFT))) : \ (RSTRING(str)->as.heap.ptr + RSTRING(str)->as.heap.len)) #define RSTRING_LENINT(str) rb_long2int(RSTRING_LEN(str)) -#define RSTRING_GETMEM(str, ptrvar, lenvar) \ - (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? \ - ((ptrvar) = RSTRING(str)->as.ary, (lenvar) = RSTRING_EMBED_LEN(str)) : \ - ((ptrvar) = RSTRING(str)->as.heap.ptr, (lenvar) = RSTRING(str)->as.heap.len)) #define RARRAY_EMBED_LEN_MAX 3 struct RArray { @@ -886,9 +690,9 @@ struct RArray { long capa; VALUE shared; } aux; - const VALUE *ptr; + VALUE *ptr; } heap; - const VALUE ary[RARRAY_EMBED_LEN_MAX]; + VALUE ary[RARRAY_EMBED_LEN_MAX]; } as; }; #define RARRAY_EMBED_FLAG FL_USER1 @@ -900,38 +704,16 @@ struct RArray { (long)((RBASIC(a)->flags >> RARRAY_EMBED_LEN_SHIFT) & \ (RARRAY_EMBED_LEN_MASK >> RARRAY_EMBED_LEN_SHIFT)) : \ RARRAY(a)->as.heap.len) - +#define RARRAY_PTR(a) \ + ((RBASIC(a)->flags & RARRAY_EMBED_FLAG) ? \ + RARRAY(a)->as.ary : \ + RARRAY(a)->as.heap.ptr) #define RARRAY_LENINT(ary) rb_long2int(RARRAY_LEN(ary)) -#define RARRAY_CONST_PTR(a) \ - ((const VALUE *)((RBASIC(a)->flags & RARRAY_EMBED_FLAG) ? \ - RARRAY(a)->as.ary : \ - RARRAY(a)->as.heap.ptr)) - -#define RARRAY_PTR_USE_START(a) ((VALUE *)RARRAY_CONST_PTR(a)) -#define RARRAY_PTR_USE_END(a) /* */ - -#define RARRAY_PTR_USE(ary, ptr_name, expr) do { \ - const VALUE _ary = (ary); \ - VALUE *ptr_name = (VALUE *)RARRAY_PTR_USE_START(_ary); \ - expr; \ - RARRAY_PTR_USE_END(_ary); \ -} while (0) - -#define RARRAY_AREF(a, i) (RARRAY_CONST_PTR(a)[i]) -#define RARRAY_ASET(a, i, v) do { \ - const VALUE _ary = (a); \ - VALUE *ptr = (VALUE *)RARRAY_PTR_USE_START(_ary); \ - RB_OBJ_WRITE(_ary, &ptr[i], (v)); \ - RARRAY_PTR_USE_END(_ary); \ -} while (0) - -#define RARRAY_PTR(a) ((VALUE *)RARRAY_CONST_PTR(RGENGC_WB_PROTECTED_ARRAY ? OBJ_WB_UNPROTECT((VALUE)a) : ((VALUE)a))) - struct RRegexp { struct RBasic basic; struct re_pattern_buffer *ptr; - const VALUE src; + VALUE src; unsigned long usecnt; }; #define RREGEXP_SRC(r) RREGEXP(r)->src @@ -939,21 +721,35 @@ struct RRegexp { #define RREGEXP_SRC_LEN(r) RSTRING_LEN(RREGEXP(r)->src) #define RREGEXP_SRC_END(r) RSTRING_END(RREGEXP(r)->src) +struct RHash { + struct RBasic basic; + struct st_table *ntbl; /* possibly 0 */ + int iter_lev; + VALUE ifnone; +}; /* RHASH_TBL allocates st_table if not available. */ #define RHASH_TBL(h) rb_hash_tbl(h) -#define RHASH_ITER_LEV(h) rb_hash_iter_lev(h) -#define RHASH_IFNONE(h) rb_hash_ifnone(h) -#define RHASH_SIZE(h) NUM2SIZET(rb_hash_size(h)) +#define RHASH_ITER_LEV(h) (RHASH(h)->iter_lev) +#define RHASH_IFNONE(h) (RHASH(h)->ifnone) +#define RHASH_SIZE(h) (RHASH(h)->ntbl ? RHASH(h)->ntbl->num_entries : 0) #define RHASH_EMPTY_P(h) (RHASH_SIZE(h) == 0) -#define RHASH_SET_IFNONE(h, ifnone) rb_hash_set_ifnone((VALUE)h, ifnone) struct RFile { struct RBasic basic; struct rb_io_t *fptr; }; -#define RCOMPLEX_SET_REAL(cmp, r) RB_OBJ_WRITE((cmp), &((struct RComplex *)(cmp))->real,(r)) -#define RCOMPLEX_SET_IMAG(cmp, i) RB_OBJ_WRITE((cmp), &((struct RComplex *)(cmp))->imag,(i)) +struct RRational { + struct RBasic basic; + VALUE num; + VALUE den; +}; + +struct RComplex { + struct RBasic basic; + VALUE real; + VALUE imag; +}; struct RData { struct RBasic basic; @@ -962,26 +758,16 @@ struct RData { void *data; }; -typedef struct rb_data_type_struct rb_data_type_t; - -struct rb_data_type_struct { +typedef struct rb_data_type_struct { const char *wrap_struct_name; - struct { - void (*dmark)(void*); - void (*dfree)(void*); - size_t (*dsize)(const void *); - void *reserved[2]; /* For future extension. - This array *must* be filled with ZERO. */ - } function; - const rb_data_type_t *parent; + void (*dmark)(void*); + void (*dfree)(void*); + size_t (*dsize)(const void *); + void *reserved[3]; /* For future extension. + This array *must* be filled with ZERO. */ void *data; /* This area can be used for any purpose by a programmer who define the type. */ - VALUE flags; /* FL_WB_PROTECTED */ -}; - -#define HAVE_TYPE_RB_DATA_TYPE_T 1 -#define HAVE_RB_DATA_TYPE_T_FUNCTION 1 -#define HAVE_RB_DATA_TYPE_T_PARENT 1 +} rb_data_type_t; struct RTypedData { struct RBasic basic; @@ -997,54 +783,46 @@ struct RTypedData { #define RTYPEDDATA_DATA(v) (RTYPEDDATA(v)->data) /* -#define RUBY_DATA_FUNC(func) ((void (*)(void*))(func)) +#define RUBY_DATA_FUNC(func) ((void (*)(void*))func) */ typedef void (*RUBY_DATA_FUNC)(void*); -#ifndef RUBY_UNTYPED_DATA_WARNING -# if defined RUBY_EXPORT -# define RUBY_UNTYPED_DATA_WARNING 1 -# else -# define RUBY_UNTYPED_DATA_WARNING 0 -# endif -#endif VALUE rb_data_object_alloc(VALUE,void*,RUBY_DATA_FUNC,RUBY_DATA_FUNC); VALUE rb_data_typed_object_alloc(VALUE klass, void *datap, const rb_data_type_t *); -int rb_typeddata_inherited_p(const rb_data_type_t *child, const rb_data_type_t *parent); int rb_typeddata_is_kind_of(VALUE, const rb_data_type_t *); void *rb_check_typeddata(VALUE, const rb_data_type_t *); -#define Check_TypedStruct(v,t) rb_check_typeddata((VALUE)(v),(t)) +#define Check_TypedStruct(v,t) rb_check_typeddata((VALUE)(v),t) #define RUBY_DEFAULT_FREE ((RUBY_DATA_FUNC)-1) #define RUBY_NEVER_FREE ((RUBY_DATA_FUNC)0) #define RUBY_TYPED_DEFAULT_FREE RUBY_DEFAULT_FREE #define RUBY_TYPED_NEVER_FREE RUBY_NEVER_FREE -/* bits for rb_data_type_struct::flags */ -#define RUBY_TYPED_FREE_IMMEDIATELY 1 /* TYPE field */ -#define RUBY_TYPED_WB_PROTECTED FL_WB_PROTECTED /* THIS FLAG DEPENDS ON Ruby version */ -#define RUBY_TYPED_PROMOTED1 FL_PROMOTED1 /* THIS FLAG DEPENDS ON Ruby version */ - #define Data_Wrap_Struct(klass,mark,free,sval)\ - rb_data_object_alloc((klass),(sval),(RUBY_DATA_FUNC)(mark),(RUBY_DATA_FUNC)(free)) + rb_data_object_alloc(klass,sval,(RUBY_DATA_FUNC)mark,(RUBY_DATA_FUNC)free) #define Data_Make_Struct(klass,type,mark,free,sval) (\ - (sval) = ZALLOC(type),\ - Data_Wrap_Struct((klass),(mark),(free),(sval))\ + sval = ALLOC(type),\ + memset(sval, 0, sizeof(type)),\ + Data_Wrap_Struct(klass,mark,free,sval)\ ) #define TypedData_Wrap_Struct(klass,data_type,sval)\ - rb_data_typed_object_alloc((klass),(sval),(data_type)) + rb_data_typed_object_alloc(klass,sval,data_type) #define TypedData_Make_Struct(klass, type, data_type, sval) (\ - (sval) = ZALLOC(type),\ - TypedData_Wrap_Struct((klass),(data_type),(sval))\ + sval = ALLOC(type),\ + memset(sval, 0, sizeof(type)),\ + TypedData_Wrap_Struct(klass,data_type,sval)\ ) -#define Data_Get_Struct(obj,type,sval) \ - ((sval) = (type*)rb_data_object_get(obj)) +#define Data_Get_Struct(obj,type,sval) do {\ + Check_Type(obj, T_DATA); \ + sval = (type*)DATA_PTR(obj);\ +} while (0) -#define TypedData_Get_Struct(obj,type,data_type,sval) \ - ((sval) = (type*)rb_check_typeddata((obj), (data_type))) +#define TypedData_Get_Struct(obj,type,data_type,sval) do {\ + sval = (type*)rb_check_typeddata(obj, data_type); \ +} while (0) #define RSTRUCT_EMBED_LEN_MAX 3 struct RStruct { @@ -1052,9 +830,9 @@ struct RStruct { union { struct { long len; - const VALUE *ptr; + VALUE *ptr; } heap; - const VALUE ary[RSTRUCT_EMBED_LEN_MAX]; + VALUE ary[RSTRUCT_EMBED_LEN_MAX]; } as; }; #define RSTRUCT_EMBED_LEN_MASK (FL_USER2|FL_USER1) @@ -1064,40 +842,71 @@ struct RStruct { (long)((RBASIC(st)->flags >> RSTRUCT_EMBED_LEN_SHIFT) & \ (RSTRUCT_EMBED_LEN_MASK >> RSTRUCT_EMBED_LEN_SHIFT)) : \ RSTRUCT(st)->as.heap.len) +#define RSTRUCT_PTR(st) \ + ((RBASIC(st)->flags & RSTRUCT_EMBED_LEN_MASK) ? \ + RSTRUCT(st)->as.ary : \ + RSTRUCT(st)->as.heap.ptr) #define RSTRUCT_LENINT(st) rb_long2int(RSTRUCT_LEN(st)) -#define RSTRUCT_CONST_PTR(st) \ - ((RBASIC(st)->flags & RSTRUCT_EMBED_LEN_MASK) ? \ - RSTRUCT(st)->as.ary : \ - RSTRUCT(st)->as.heap.ptr) -#define RSTRUCT_PTR(st) ((VALUE *)RSTRUCT_CONST_PTR(RGENGC_WB_PROTECTED_STRUCT ? OBJ_WB_UNPROTECT((VALUE)st) : (VALUE)st)) -#define RSTRUCT_SET(st, idx, v) RB_OBJ_WRITE(st, &RSTRUCT_CONST_PTR(st)[idx], (v)) -#define RSTRUCT_GET(st, idx) (RSTRUCT_CONST_PTR(st)[idx]) - -#define RBIGNUM_SIGN(b) (FIX2LONG(rb_big_cmp((b), INT2FIX(0))) >= 0) -#define RBIGNUM_POSITIVE_P(b) (FIX2LONG(rb_big_cmp((b), INT2FIX(0))) >= 0) -#define RBIGNUM_NEGATIVE_P(b) (FIX2LONG(rb_big_cmp((b), INT2FIX(0))) < 0) +#define RBIGNUM_EMBED_LEN_MAX ((int)((sizeof(VALUE)*3)/sizeof(BDIGIT))) +struct RBignum { + struct RBasic basic; + union { + struct { + long len; + BDIGIT *digits; + } heap; + BDIGIT ary[RBIGNUM_EMBED_LEN_MAX]; + } as; +}; +#define RBIGNUM_SIGN_BIT FL_USER1 +/* sign: positive:1, negative:0 */ +#define RBIGNUM_SIGN(b) ((RBASIC(b)->flags & RBIGNUM_SIGN_BIT) != 0) +#define RBIGNUM_SET_SIGN(b,sign) \ + ((sign) ? (RBASIC(b)->flags |= RBIGNUM_SIGN_BIT) \ + : (RBASIC(b)->flags &= ~RBIGNUM_SIGN_BIT)) +#define RBIGNUM_POSITIVE_P(b) RBIGNUM_SIGN(b) +#define RBIGNUM_NEGATIVE_P(b) (!RBIGNUM_SIGN(b)) + +#define RBIGNUM_EMBED_FLAG FL_USER2 +#define RBIGNUM_EMBED_LEN_MASK (FL_USER5|FL_USER4|FL_USER3) +#define RBIGNUM_EMBED_LEN_SHIFT (FL_USHIFT+3) +#define RBIGNUM_LEN(b) \ + ((RBASIC(b)->flags & RBIGNUM_EMBED_FLAG) ? \ + (long)((RBASIC(b)->flags >> RBIGNUM_EMBED_LEN_SHIFT) & \ + (RBIGNUM_EMBED_LEN_MASK >> RBIGNUM_EMBED_LEN_SHIFT)) : \ + RBIGNUM(b)->as.heap.len) +/* LSB:RBIGNUM_DIGITS(b)[0], MSB:RBIGNUM_DIGITS(b)[RBIGNUM_LEN(b)-1] */ +#define RBIGNUM_DIGITS(b) \ + ((RBASIC(b)->flags & RBIGNUM_EMBED_FLAG) ? \ + RBIGNUM(b)->as.ary : \ + RBIGNUM(b)->as.heap.digits) +#define RBIGNUM_LENINT(b) rb_long2int(RBIGNUM_LEN(b)) #define R_CAST(st) (struct st*) #define RBASIC(obj) (R_CAST(RBasic)(obj)) #define ROBJECT(obj) (R_CAST(RObject)(obj)) #define RCLASS(obj) (R_CAST(RClass)(obj)) #define RMODULE(obj) RCLASS(obj) +#define RFLOAT(obj) (R_CAST(RFloat)(obj)) #define RSTRING(obj) (R_CAST(RString)(obj)) #define RREGEXP(obj) (R_CAST(RRegexp)(obj)) #define RARRAY(obj) (R_CAST(RArray)(obj)) +#define RHASH(obj) (R_CAST(RHash)(obj)) #define RDATA(obj) (R_CAST(RData)(obj)) #define RTYPEDDATA(obj) (R_CAST(RTypedData)(obj)) #define RSTRUCT(obj) (R_CAST(RStruct)(obj)) +#define RBIGNUM(obj) (R_CAST(RBignum)(obj)) #define RFILE(obj) (R_CAST(RFile)(obj)) +#define RRATIONAL(obj) (R_CAST(RRational)(obj)) +#define RCOMPLEX(obj) (R_CAST(RComplex)(obj)) #define FL_SINGLETON FL_USER0 -#define FL_WB_PROTECTED (((VALUE)1)<<5) -#define FL_PROMOTED0 (((VALUE)1)<<5) -#define FL_PROMOTED1 (((VALUE)1)<<6) +#define FL_MARK (((VALUE)1)<<5) +#define FL_RESERVED (((VALUE)1)<<6) /* will be used in the future GC */ #define FL_FINALIZE (((VALUE)1)<<7) #define FL_TAINT (((VALUE)1)<<8) -#define FL_UNTRUSTED FL_TAINT +#define FL_UNTRUSTED (((VALUE)1)<<9) #define FL_EXIVAR (((VALUE)1)<<10) #define FL_FREEZE (((VALUE)1)<<11) @@ -1127,248 +936,89 @@ struct RStruct { #define SPECIAL_CONST_P(x) (IMMEDIATE_P(x) || !RTEST(x)) #define FL_ABLE(x) (!SPECIAL_CONST_P(x) && BUILTIN_TYPE(x) != T_NODE) -#define FL_TEST_RAW(x,f) (RBASIC(x)->flags&(f)) -#define FL_TEST(x,f) (FL_ABLE(x)?FL_TEST_RAW((x),(f)):0) -#define FL_ANY(x,f) FL_TEST((x),(f)) -#define FL_ALL(x,f) (FL_TEST((x),(f)) == (f)) +#define FL_TEST(x,f) (FL_ABLE(x)?(RBASIC(x)->flags&(f)):0) +#define FL_ANY(x,f) FL_TEST(x,f) +#define FL_ALL(x,f) (FL_TEST(x,f) == (f)) #define FL_SET(x,f) do {if (FL_ABLE(x)) RBASIC(x)->flags |= (f);} while (0) #define FL_UNSET(x,f) do {if (FL_ABLE(x)) RBASIC(x)->flags &= ~(f);} while (0) #define FL_REVERSE(x,f) do {if (FL_ABLE(x)) RBASIC(x)->flags ^= (f);} while (0) -#define OBJ_TAINTABLE(x) (FL_ABLE(x) && BUILTIN_TYPE(x) != T_BIGNUM && BUILTIN_TYPE(x) != T_FLOAT) #define OBJ_TAINTED(x) (!!FL_TEST((x), FL_TAINT)) -#define OBJ_TAINT(x) (OBJ_TAINTABLE(x) ? (RBASIC(x)->flags |= FL_TAINT) : 0) -#define OBJ_UNTRUSTED(x) OBJ_TAINTED(x) -#define OBJ_UNTRUST(x) OBJ_TAINT(x) -#define OBJ_INFECT(x,s) ( \ - (OBJ_TAINTABLE(x) && FL_ABLE(s)) ? \ - RBASIC(x)->flags |= RBASIC(s)->flags & FL_TAINT : 0) - -#define OBJ_FROZEN(x) (FL_ABLE(x) ? !!(RBASIC(x)->flags&FL_FREEZE) : 1) -#define OBJ_FREEZE_RAW(x) (RBASIC(x)->flags |= FL_FREEZE) -#define OBJ_FREEZE(x) rb_obj_freeze_inline((VALUE)x) - -void rb_freeze_singleton_class(VALUE klass); - -static inline void -rb_obj_freeze_inline(VALUE x) -{ - if (FL_ABLE(x)) { - OBJ_FREEZE_RAW(x); - if (RBASIC_CLASS(x) && !(RBASIC(x)->flags & FL_SINGLETON)) { - rb_freeze_singleton_class(x); - } - } -} - -#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4)) -# define RUBY_UNTYPED_DATA_FUNC(func) func __attribute__((warning("untyped Data is unsafe; use TypedData instead"))) -#else -# define RUBY_UNTYPED_DATA_FUNC(func) DEPRECATED(func) -#endif - -RUBY_UNTYPED_DATA_FUNC(static inline VALUE rb_data_object_alloc_warning(VALUE,void*,RUBY_DATA_FUNC,RUBY_DATA_FUNC)); -RUBY_UNTYPED_DATA_FUNC(static inline void *rb_data_object_get_warning(VALUE)); - -static inline VALUE -rb_data_object_alloc_warning(VALUE klass, void *ptr, RUBY_DATA_FUNC mark, RUBY_DATA_FUNC free) -{ - return rb_data_object_alloc(klass, ptr, mark, free); -} - -#if defined(HAVE_BUILTIN___BUILTIN_CHOOSE_EXPR_CONSTANT_P) -#define rb_data_object_alloc_warning(klass, ptr, mark, free) \ - __extension__( \ - __builtin_choose_expr( \ - __builtin_constant_p(klass) && !(klass), \ - rb_data_object_alloc(klass, ptr, mark, free), \ - rb_data_object_alloc_warning(klass, ptr, mark, free))) -#endif - -static inline void * -rb_data_object_get(VALUE obj) -{ - Check_Type(obj, T_DATA); - return ((struct RData *)obj)->data; -} - -static inline void * -rb_data_object_get_warning(VALUE obj) -{ - return rb_data_object_get(obj); -} - -#define rb_data_object_alloc_0 rb_data_object_alloc -#define rb_data_object_alloc_1 rb_data_object_alloc_warning -#define rb_data_object_alloc RUBY_MACRO_SELECT(rb_data_object_alloc_, RUBY_UNTYPED_DATA_WARNING) -#define rb_data_object_get_0 rb_data_object_get -#define rb_data_object_get_1 rb_data_object_get_warning -#define rb_data_object_get RUBY_MACRO_SELECT(rb_data_object_get_, RUBY_UNTYPED_DATA_WARNING) - -#if USE_RGENGC -#define OBJ_PROMOTED_RAW(x) ((RBASIC(x)->flags & (FL_PROMOTED0|FL_PROMOTED1)) == (FL_PROMOTED0|FL_PROMOTED1)) -#define OBJ_PROMOTED(x) (SPECIAL_CONST_P(x) ? 0 : OBJ_PROMOTED_RAW(x)) -#define OBJ_WB_UNPROTECT(x) rb_obj_wb_unprotect(x, __FILE__, __LINE__) - -#if USE_RINCGC -int rb_gc_writebarrier_incremental(VALUE a, VALUE b); -#else -#define rb_gc_writebarrier_incremental(a, b) 0 -#endif -void rb_gc_writebarrier_generational(VALUE a, VALUE b); -void rb_gc_writebarrier_unprotect(VALUE obj); - -#else /* USE_RGENGC */ -#define OBJ_PROMOTED(x) 0 -#define OBJ_WB_UNPROTECT(x) rb_obj_wb_unprotect(x, __FILE__, __LINE__) -#endif - -/* Write barrier (WB) interfaces: - * - RB_OBJ_WRITE(a, slot, b): WB for new reference from `a' to `b'. - * Write `b' into `*slot'. `slot' is a pointer in `a'. - * - RB_OBJ_WRITTEN(a, oldv, b): WB for new reference from `a' to `b'. - * This doesn't write any values, but only a WB declaration. - * `oldv' is replaced value with `b' (not used in current Ruby). - * - * NOTE: The following core interfaces can be changed in the future. - * Please catch up if you want to insert WB into C-extensions - * correctly. - */ -#define RB_OBJ_WRITE(a, slot, b) rb_obj_write((VALUE)(a), (VALUE *)(slot), (VALUE)(b), __FILE__, __LINE__) -#define RB_OBJ_WRITTEN(a, oldv, b) rb_obj_written((VALUE)(a), (VALUE)(oldv), (VALUE)(b), __FILE__, __LINE__) - -#ifndef USE_RGENGC_LOGGING_WB_UNPROTECT -#define USE_RGENGC_LOGGING_WB_UNPROTECT 0 -#endif +#define OBJ_TAINT(x) FL_SET((x), FL_TAINT) +#define OBJ_UNTRUSTED(x) (!!FL_TEST((x), FL_UNTRUSTED)) +#define OBJ_UNTRUST(x) FL_SET((x), FL_UNTRUSTED) +#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) -#if USE_RGENGC_LOGGING_WB_UNPROTECT -void rb_gc_unprotect_logging(void *objptr, const char *filename, int line); -#define RGENGC_LOGGING_WB_UNPROTECT rb_gc_unprotect_logging -#endif - -static inline VALUE -rb_obj_wb_unprotect(VALUE x, RB_UNUSED_VAR(const char *filename), RB_UNUSED_VAR(int line)) -{ -#ifdef RGENGC_LOGGING_WB_UNPROTECT - RGENGC_LOGGING_WB_UNPROTECT((void *)x, filename, line); -#endif -#if USE_RGENGC - rb_gc_writebarrier_unprotect(x); -#endif - return x; -} - -static inline VALUE -rb_obj_written(VALUE a, RB_UNUSED_VAR(VALUE oldv), VALUE b, RB_UNUSED_VAR(const char *filename), RB_UNUSED_VAR(int line)) -{ -#ifdef RGENGC_LOGGING_OBJ_WRITTEN - RGENGC_LOGGING_OBJ_WRITTEN(a, oldv, b, filename, line); -#endif - -#if USE_RGENGC - if (!SPECIAL_CONST_P(b)) { - if (rb_gc_writebarrier_incremental(a, b) == 0) { - if (OBJ_PROMOTED_RAW(a) && !OBJ_PROMOTED_RAW(b)) { - rb_gc_writebarrier_generational(a, b); - } - } - } -#endif - - return a; -} - -static inline VALUE -rb_obj_write(VALUE a, VALUE *slot, VALUE b, RB_UNUSED_VAR(const char *filename), RB_UNUSED_VAR(int line)) -{ -#ifdef RGENGC_LOGGING_WRITE - RGENGC_LOGGING_WRITE(a, slot, b, filename, line); -#endif - - *slot = b; - -#if USE_RGENGC - rb_obj_written(a, Qundef /* ignore `oldv' now */, b, filename, line); -#endif - return a; -} +#define OBJ_FROZEN(x) (!!FL_TEST((x), FL_FREEZE)) +#define OBJ_FREEZE(x) FL_SET((x), FL_FREEZE) #if SIZEOF_INT < SIZEOF_LONG # define INT2NUM(v) INT2FIX((int)(v)) # define UINT2NUM(v) LONG2FIX((unsigned int)(v)) #else +# define INT2NUM_internal(v) (FIXABLE(v) ? INT2FIX(v) : rb_int2big(v)) +# ifdef __GNUC__ +# define INT2NUM(v) __extension__ ({int int2num_v = (v); INT2NUM_internal(int2num_v);}) +# else static inline VALUE -rb_int2num_inline(int v) +INT2NUM(int v) { - if (FIXABLE(v)) - return INT2FIX(v); - else - return rb_int2big(v); + return INT2NUM_internal(v); } -#define INT2NUM(x) rb_int2num_inline(x) +# endif +# define UINT2NUM_internal(v) (POSFIXABLE(v) ? LONG2FIX(v) : rb_uint2big(v)) +# ifdef __GNUC__ +# define UINT2NUM(v) __extension__ ({unsigned int uint2num_v = (v); UINT2NUM_internal(uint2num_v);}) +# else static inline VALUE -rb_uint2num_inline(unsigned int v) +UINT2NUM(unsigned int v) { - if (POSFIXABLE(v)) - return LONG2FIX(v); - else - return rb_uint2big(v); + return UINT2NUM_internal(v); } -#define UINT2NUM(x) rb_uint2num_inline(x) +# endif #endif +#define LONG2NUM_internal(v) (FIXABLE(v) ? LONG2FIX(v) : rb_int2big(v)) +#ifdef __GNUC__ +# define LONG2NUM(v) __extension__ ({long long2num_v = (v); LONG2NUM_internal(long2num_v);}) +#else static inline VALUE -rb_long2num_inline(long v) +LONG2NUM(long v) { - if (FIXABLE(v)) - return LONG2FIX(v); - else - return rb_int2big(v); + return LONG2NUM_internal(v); } -#define LONG2NUM(x) rb_long2num_inline(x) +#endif +#define ULONG2NUM_internal(v) (POSFIXABLE(v) ? LONG2FIX(v) : rb_uint2big(v)) +#ifdef __GNUC__ +# define ULONG2NUM(v) __extension__ ({unsigned long ulong2num_v = (v); ULONG2NUM_internal(ulong2num_v);}) +#else static inline VALUE -rb_ulong2num_inline(unsigned long v) +ULONG2NUM(unsigned long v) { - if (POSFIXABLE(v)) - return LONG2FIX(v); - else - return rb_uint2big(v); + return ULONG2NUM_internal(v); } -#define ULONG2NUM(x) rb_ulong2num_inline(x) +#endif +#define NUM2CHR_internal(x) (((TYPE(x) == T_STRING)&&(RSTRING_LEN(x)>=1))?\ + RSTRING_PTR(x)[0]:(char)(NUM2INT(x)&0xff)) +#ifdef __GNUC__ +# define NUM2CHR(x) __extension__ ({VALUE num2chr_x = (x); NUM2CHR_internal(num2chr_x);}) +#else static inline char -rb_num2char_inline(VALUE x) +NUM2CHR(VALUE x) { - if (RB_TYPE_P(x, T_STRING) && (RSTRING_LEN(x)>=1)) - return RSTRING_PTR(x)[0]; - else - return (char)(NUM2INT(x) & 0xff); + return NUM2CHR_internal(x); } -#define NUM2CHR(x) rb_num2char_inline(x) - +#endif #define CHR2FIX(x) INT2FIX((long)((x)&0xff)) -#define ALLOC_N(type,n) ((type*)xmalloc2((n),sizeof(type))) -#define ALLOC(type) ((type*)xmalloc(sizeof(type))) -#define ZALLOC_N(type,n) ((type*)xcalloc((n),sizeof(type))) -#define ZALLOC(type) (ZALLOC_N(type,1)) -#define REALLOC_N(var,type,n) ((var)=(type*)xrealloc2((char*)(var),(n),sizeof(type))) +#define ALLOC_N(type,n) (type*)xmalloc2((n),sizeof(type)) +#define ALLOC(type) (type*)xmalloc(sizeof(type)) +#define REALLOC_N(var,type,n) (var)=(type*)xrealloc2((char*)(var),(n),sizeof(type)) -#define ALLOCA_N(type,n) ((type*)alloca(sizeof(type)*(n))) - -void *rb_alloc_tmp_buffer(volatile VALUE *store, long len) RUBY_ATTR_ALLOC_SIZE((2)); -void rb_free_tmp_buffer(volatile VALUE *store); -/* allocates _n_ bytes temporary buffer and stores VALUE including it - * in _v_. _n_ may be evaluated twice. */ -#ifdef C_ALLOCA -# define ALLOCV(v, n) rb_alloc_tmp_buffer(&(v), (n)) -#else -# define ALLOCV(v, n) ((n) < 1024 ? (RB_GC_GUARD(v) = 0, alloca(n)) : rb_alloc_tmp_buffer(&(v), (n))) -#endif -#define ALLOCV_N(type, v, n) ((type*)ALLOCV((v), sizeof(type)*(n))) -#define ALLOCV_END(v) rb_free_tmp_buffer(&(v)) +#define ALLOCA_N(type,n) (type*)alloca(sizeof(type)*(n)) #define MEMZERO(p,type,n) memset((p), 0, sizeof(type)*(n)) #define MEMCPY(p1,p2,type,n) memcpy((p1), (p2), sizeof(type)*(n)) @@ -1389,7 +1039,6 @@ VALUE rb_define_module_under(VALUE, const char*); void rb_include_module(VALUE,VALUE); void rb_extend_object(VALUE,VALUE); -void rb_prepend_module(VALUE,VALUE); struct rb_global_variable; @@ -1414,11 +1063,11 @@ void rb_gvar_readonly_setter(VALUE val, ID id, void *data, struct rb_global_var void rb_define_variable(const char*,VALUE*); void rb_define_virtual_variable(const char*,VALUE(*)(ANYARGS),void(*)(ANYARGS)); void rb_define_hooked_variable(const char*,VALUE*,VALUE(*)(ANYARGS),void(*)(ANYARGS)); -void rb_define_readonly_variable(const char*,const VALUE*); +void rb_define_readonly_variable(const char*,VALUE*); void rb_define_const(VALUE,const char*,VALUE); void rb_define_global_const(const char*,VALUE); -#define RUBY_METHOD_FUNC(func) ((VALUE (*)(ANYARGS))(func)) +#define RUBY_METHOD_FUNC(func) ((VALUE (*)(ANYARGS))func) void rb_define_method(VALUE,const char*,VALUE(*)(ANYARGS),int); void rb_define_module_function(VALUE,const char*,VALUE(*)(ANYARGS),int); void rb_define_global_function(const char*,VALUE(*)(ANYARGS),int); @@ -1436,35 +1085,31 @@ ID rb_intern(const char*); ID rb_intern2(const char*, long); ID rb_intern_str(VALUE str); const char *rb_id2name(ID); -ID rb_check_id(volatile VALUE *); ID rb_to_id(VALUE); VALUE rb_id2str(ID); -VALUE rb_sym2str(VALUE); -VALUE rb_to_symbol(VALUE name); -VALUE rb_check_symbol(volatile VALUE *namep); #define CONST_ID_CACHE(result, str) \ { \ static ID rb_intern_id_cache; \ if (!rb_intern_id_cache) \ - rb_intern_id_cache = rb_intern2((str), (long)strlen(str)); \ + rb_intern_id_cache = rb_intern2(str, (long)strlen(str)); \ result rb_intern_id_cache; \ } #define CONST_ID(var, str) \ - do CONST_ID_CACHE((var) =, (str)) while (0) + do CONST_ID_CACHE(var =, str) while (0) #ifdef __GNUC__ /* __builtin_constant_p and statement expression is available * since gcc-2.7.2.3 at least. */ #define rb_intern(str) \ (__builtin_constant_p(str) ? \ - __extension__ (CONST_ID_CACHE((ID), (str))) : \ + __extension__ (CONST_ID_CACHE((ID), str)) : \ rb_intern(str)) #define rb_intern_const(str) \ (__builtin_constant_p(str) ? \ - __extension__ (rb_intern2((str), (long)strlen(str))) : \ + __extension__ (rb_intern2(str, (long)strlen(str))) : \ (rb_intern)(str)) #else -#define rb_intern_const(str) rb_intern2((str), (long)strlen(str)) +#define rb_intern_const(str) rb_intern2(str, (long)strlen(str)) #endif const char *rb_class2name(VALUE); @@ -1476,20 +1121,10 @@ VALUE rb_eval_string(const char*); VALUE rb_eval_string_protect(const char*, int*); VALUE rb_eval_string_wrap(const char*, int*); VALUE rb_funcall(VALUE, ID, int, ...); -VALUE rb_funcallv(VALUE, ID, int, const VALUE*); -VALUE rb_funcallv_public(VALUE, ID, int, const VALUE*); -#define rb_funcall2 rb_funcallv -#define rb_funcall3 rb_funcallv_public -VALUE rb_funcall_passing_block(VALUE, ID, int, const VALUE*); -VALUE rb_funcall_with_block(VALUE, ID, int, const VALUE*, VALUE); +VALUE rb_funcall2(VALUE, ID, int, const VALUE*); +VALUE rb_funcall3(VALUE, ID, int, const VALUE*); int rb_scan_args(int, const VALUE*, const char*, ...); VALUE rb_call_super(int, const VALUE*); -VALUE rb_current_receiver(void); -int rb_get_kwargs(VALUE keyword_hash, const ID *table, int required, int optional, VALUE *); -VALUE rb_extract_keywords(VALUE *orighash); - -/* rb_scan_args() format allows ':' for optional hash */ -#define HAVE_RB_SCAN_ARGS_OPTIONAL_HASH 1 VALUE rb_gv_set(const char*, VALUE); VALUE rb_gv_get(const char*); @@ -1508,20 +1143,10 @@ PRINTF_ARGS(NORETURN(void rb_fatal(const char*, ...)), 1, 2); PRINTF_ARGS(NORETURN(void rb_bug(const char*, ...)), 1, 2); NORETURN(void rb_bug_errno(const char*, int)); NORETURN(void rb_sys_fail(const char*)); -NORETURN(void rb_sys_fail_str(VALUE)); NORETURN(void rb_mod_sys_fail(VALUE, const char*)); -NORETURN(void rb_mod_sys_fail_str(VALUE, VALUE)); -NORETURN(void rb_readwrite_sys_fail(int, const char*)); NORETURN(void rb_iter_break(void)); -NORETURN(void rb_iter_break_value(VALUE)); NORETURN(void rb_exit(int)); NORETURN(void rb_notimplement(void)); -VALUE rb_syserr_new(int, const char *); -VALUE rb_syserr_new_str(int n, VALUE arg); -NORETURN(void rb_syserr_fail(int, const char*)); -NORETURN(void rb_syserr_fail_str(int, VALUE)); -NORETURN(void rb_mod_syserr_fail(VALUE, int, const char*)); -NORETURN(void rb_mod_syserr_fail_str(VALUE, int, VALUE)); /* reports if `-W' specified */ PRINTF_ARGS(void rb_warning(const char*, ...), 1, 2); @@ -1531,31 +1156,17 @@ PRINTF_ARGS(void rb_sys_warning(const char*, ...), 1, 2); PRINTF_ARGS(void rb_warn(const char*, ...), 1, 2); PRINTF_ARGS(void rb_compile_warn(const char *, int, const char*, ...), 3, 4); -/* for rb_readwrite_sys_fail first argument */ -#define RB_IO_WAIT_READABLE 0 -#define RB_IO_WAIT_WRITABLE 1 - -#define RUBY_BLOCK_CALL_FUNC_TAKES_BLOCKARG 1 -#define RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, callback_arg) \ - VALUE yielded_arg, VALUE callback_arg, int argc, const VALUE *argv, VALUE blockarg -typedef VALUE rb_block_call_func(RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, callback_arg)); - -#if defined RB_BLOCK_CALL_FUNC_STRICT && RB_BLOCK_CALL_FUNC_STRICT -typedef rb_block_call_func *rb_block_call_func_t; -#else -typedef VALUE (*rb_block_call_func_t)(ANYARGS); -#endif +typedef VALUE rb_block_call_func(VALUE, VALUE, int, VALUE*); VALUE rb_each(VALUE); VALUE rb_yield(VALUE); VALUE rb_yield_values(int n, ...); VALUE rb_yield_values2(int n, const VALUE *argv); VALUE rb_yield_splat(VALUE); -VALUE rb_yield_block(VALUE, VALUE, int, const VALUE *, VALUE); /* rb_block_call_func */ int rb_block_given_p(void); void rb_need_block(void); VALUE rb_iterate(VALUE(*)(VALUE),VALUE,VALUE(*)(ANYARGS),VALUE); -VALUE rb_block_call(VALUE,ID,int,const VALUE*,rb_block_call_func_t,VALUE); +VALUE rb_block_call(VALUE,ID,int,VALUE*,VALUE(*)(ANYARGS),VALUE); VALUE rb_rescue(VALUE(*)(ANYARGS),VALUE,VALUE(*)(ANYARGS),VALUE); VALUE rb_rescue2(VALUE(*)(ANYARGS),VALUE,VALUE(*)(ANYARGS),VALUE,...); VALUE rb_ensure(VALUE(*)(ANYARGS),VALUE,VALUE(*)(ANYARGS),VALUE); @@ -1566,6 +1177,20 @@ NORETURN(void rb_throw_obj(VALUE,VALUE)); VALUE rb_require(const char*); +#ifdef __ia64 +void ruby_init_stack(volatile VALUE*, void*); +#define ruby_init_stack(addr) ruby_init_stack(addr, rb_ia64_bsp()) +#else +void ruby_init_stack(volatile VALUE*); +#endif +#define RUBY_INIT_STACK \ + VALUE variable_in_this_stack_frame; \ + ruby_init_stack(&variable_in_this_stack_frame); +void ruby_init(void); +void *ruby_options(int, char**); +int ruby_run_node(void *); +int ruby_exec_node(void *); + RUBY_EXTERN VALUE rb_mKernel; RUBY_EXTERN VALUE rb_mComparable; RUBY_EXTERN VALUE rb_mEnumerable; @@ -1659,9 +1284,8 @@ rb_class_of(VALUE obj) { if (IMMEDIATE_P(obj)) { if (FIXNUM_P(obj)) return rb_cFixnum; - if (FLONUM_P(obj)) return rb_cFloat; if (obj == Qtrue) return rb_cTrueClass; - if (STATIC_SYM_P(obj)) return rb_cSymbol; + if (SYMBOL_P(obj)) return rb_cSymbol; } else if (!RTEST(obj)) { if (obj == Qnil) return rb_cNilClass; @@ -1675,21 +1299,29 @@ rb_type(VALUE obj) { if (IMMEDIATE_P(obj)) { if (FIXNUM_P(obj)) return T_FIXNUM; - if (FLONUM_P(obj)) return T_FLOAT; - if (obj == Qtrue) return T_TRUE; - if (STATIC_SYM_P(obj)) return T_SYMBOL; + if (obj == Qtrue) return T_TRUE; + if (SYMBOL_P(obj)) return T_SYMBOL; if (obj == Qundef) return T_UNDEF; } else if (!RTEST(obj)) { - if (obj == Qnil) return T_NIL; + if (obj == Qnil) return T_NIL; if (obj == Qfalse) return T_FALSE; } return BUILTIN_TYPE(obj); } +#define RB_TYPE_P(obj, type) ( \ + ((type) == T_FIXNUM) ? FIXNUM_P(obj) : \ + ((type) == T_TRUE) ? ((obj) == Qtrue) : \ + ((type) == T_FALSE) ? ((obj) == Qfalse) : \ + ((type) == T_NIL) ? ((obj) == Qnil) : \ + ((type) == T_UNDEF) ? ((obj) == Qundef) : \ + ((type) == T_SYMBOL) ? SYMBOL_P(obj) : \ + (!SPECIAL_CONST_P(obj) && BUILTIN_TYPE(obj) == (type))) + #ifdef __GNUC__ #define rb_type_p(obj, type) \ - __extension__ (__builtin_constant_p(type) ? RB_TYPE_P((obj), (type)) : \ + __extension__ (__builtin_constant_p(type) ? RB_TYPE_P(obj, type) : \ rb_type(obj) == (type)) #else #define rb_type_p(obj, type) (rb_type(obj) == (type)) @@ -1707,6 +1339,7 @@ rb_special_const_p(VALUE obj) } #endif +#include "ruby/missing.h" #include "ruby/intern.h" #if defined(EXTLIB) && defined(USE_DLN_A_OUT) @@ -1714,11 +1347,18 @@ rb_special_const_p(VALUE obj) static char *dln_libs_to_be_linked[] = { EXTLIB, 0 }; #endif +#if (defined(__APPLE__) || defined(__NeXT__)) && defined(__MACH__) +#define RUBY_GLOBAL_SETUP /* use linker option to link startup code with ObjC support */ +#else +#define RUBY_GLOBAL_SETUP +#endif + +void ruby_sysinit(int *, char ***); + #define RUBY_VM 1 /* YARV */ #define HAVE_NATIVETHREAD int ruby_native_thread_p(void); -/* traditional set_trace_func events */ #define RUBY_EVENT_NONE 0x0000 #define RUBY_EVENT_LINE 0x0001 #define RUBY_EVENT_CLASS 0x0002 @@ -1728,38 +1368,24 @@ int ruby_native_thread_p(void); #define RUBY_EVENT_C_CALL 0x0020 #define RUBY_EVENT_C_RETURN 0x0040 #define RUBY_EVENT_RAISE 0x0080 -#define RUBY_EVENT_ALL 0x00ff - -/* for TracePoint extended events */ -#define RUBY_EVENT_B_CALL 0x0100 -#define RUBY_EVENT_B_RETURN 0x0200 -#define RUBY_EVENT_THREAD_BEGIN 0x0400 -#define RUBY_EVENT_THREAD_END 0x0800 -#define RUBY_EVENT_TRACEPOINT_ALL 0xffff - -/* special events */ -#define RUBY_EVENT_SPECIFIED_LINE 0x010000 -#define RUBY_EVENT_COVERAGE 0x020000 - -/* internal events */ -#define RUBY_INTERNAL_EVENT_SWITCH 0x040000 -#define RUBY_EVENT_SWITCH 0x040000 /* obsolete name. this macro is for compatibility */ - /* 0x080000 */ -#define RUBY_INTERNAL_EVENT_NEWOBJ 0x100000 -#define RUBY_INTERNAL_EVENT_FREEOBJ 0x200000 -#define RUBY_INTERNAL_EVENT_GC_START 0x400000 -#define RUBY_INTERNAL_EVENT_GC_END_MARK 0x800000 -#define RUBY_INTERNAL_EVENT_GC_END_SWEEP 0x1000000 -#define RUBY_INTERNAL_EVENT_GC_ENTER 0x2000000 -#define RUBY_INTERNAL_EVENT_GC_EXIT 0x4000000 -#define RUBY_INTERNAL_EVENT_OBJSPACE_MASK 0x7f00000 -#define RUBY_INTERNAL_EVENT_MASK 0xfffe0000 - -typedef uint32_t rb_event_flag_t; -typedef void (*rb_event_hook_func_t)(rb_event_flag_t evflag, VALUE data, VALUE self, ID mid, VALUE klass); +#define RUBY_EVENT_ALL 0xffff +#define RUBY_EVENT_VM 0x10000 +#define RUBY_EVENT_SWITCH 0x20000 +#define RUBY_EVENT_COVERAGE 0x40000 + +typedef unsigned int rb_event_flag_t; +typedef void (*rb_event_hook_func_t)(rb_event_flag_t, VALUE data, VALUE, ID, VALUE klass); + +typedef struct rb_event_hook_struct { + rb_event_flag_t flag; + rb_event_hook_func_t func; + VALUE data; + struct rb_event_hook_struct *next; +} rb_event_hook_t; #define RB_EVENT_HOOKS_HAVE_CALLBACK_DATA 1 -void rb_add_event_hook(rb_event_hook_func_t func, rb_event_flag_t events, VALUE data); +void rb_add_event_hook(rb_event_hook_func_t func, rb_event_flag_t events, + VALUE data); int rb_remove_event_hook(rb_event_hook_func_t func); /* locale insensitive functions */ @@ -1784,7 +1410,6 @@ int rb_toupper(int c); #define ISASCII(c) rb_isascii((unsigned char)(c)) #undef ISPRINT #define ISPRINT(c) rb_isprint((unsigned char)(c)) -#define ISGRAPH(c) rb_isgraph((unsigned char)(c)) #define ISSPACE(c) rb_isspace((unsigned char)(c)) #define ISUPPER(c) rb_isupper((unsigned char)(c)) #define ISLOWER(c) rb_islower((unsigned char)(c)) @@ -1796,90 +1421,33 @@ int rb_toupper(int c); #define TOUPPER(c) rb_toupper((unsigned char)(c)) #define TOLOWER(c) rb_tolower((unsigned char)(c)) -int st_locale_insensitive_strcasecmp(const char *s1, const char *s2); -int st_locale_insensitive_strncasecmp(const char *s1, const char *s2, size_t n); -#define STRCASECMP(s1, s2) (st_locale_insensitive_strcasecmp((s1), (s2))) -#define STRNCASECMP(s1, s2, n) (st_locale_insensitive_strncasecmp((s1), (s2), (n))) +int st_strcasecmp(const char *s1, const char *s2); +int st_strncasecmp(const char *s1, const char *s2, size_t n); +#define STRCASECMP(s1, s2) (st_strcasecmp(s1, s2)) +#define STRNCASECMP(s1, s2, n) (st_strncasecmp(s1, s2, n)) unsigned long ruby_strtoul(const char *str, char **endptr, int base); -#define STRTOUL(str, endptr, base) (ruby_strtoul((str), (endptr), (base))) +#define STRTOUL(str, endptr, base) (ruby_strtoul(str, endptr, base)) #define InitVM(ext) {void InitVM_##ext(void);InitVM_##ext();} -PRINTF_ARGS(int ruby_snprintf(char *str, size_t n, char const *fmt, ...), 3, 4); +int ruby_snprintf(char *str, size_t n, char const *fmt, ...); int ruby_vsnprintf(char *str, size_t n, char const *fmt, va_list ap); - -#ifndef RUBY_DONT_SUBST -#include "ruby/subst.h" -#endif - -/** - * @defgroup embed CRuby Embedding APIs - * CRuby interpreter APIs. These are APIs to embed MRI interpreter into your - * program. - * These functions are not a part of Ruby extension library API. - * Extension libraries of Ruby should not depend on these functions. - * @{ - */ - -/** @defgroup ruby1 ruby(1) implementation - * A part of the implementation of ruby(1) command. - * Other programs that embed Ruby interpreter do not always need to use these - * functions. - * @{ - */ - -void ruby_sysinit(int *argc, char ***argv); -void ruby_init(void); -void* ruby_options(int argc, char** argv); -int ruby_executable_node(void *n, int *status); -int ruby_run_node(void *n); - -/* version.c */ -void ruby_show_version(void); -void ruby_show_copyright(void); - - -/*! A convenience macro to call ruby_init_stack(). Must be placed just after - * variable declarations */ -#define RUBY_INIT_STACK \ - VALUE variable_in_this_stack_frame; \ - ruby_init_stack(&variable_in_this_stack_frame); -/*! @} */ - -#ifdef __ia64 -void ruby_init_stack(volatile VALUE*, void*); -#define ruby_init_stack(addr) ruby_init_stack((addr), rb_ia64_bsp()) -#else -void ruby_init_stack(volatile VALUE*); +#undef snprintf +#undef vsnprintf +#define snprintf ruby_snprintf +#define vsnprintf ruby_vsnprintf + +#ifdef BROKEN_CLOSE +#undef getpeername +#define getpeername ruby_getpeername +#undef getsockname +#define getsockname ruby_getsockname +#undef shutdown +#define shutdown ruby_shutdown +#undef close +#define close ruby_close #endif -#define Init_stack(addr) ruby_init_stack(addr) - -int ruby_setup(void); -int ruby_cleanup(volatile int); - -void ruby_finalize(void); -NORETURN(void ruby_stop(int)); - -void ruby_set_stack_size(size_t); -int ruby_stack_check(void); -size_t ruby_stack_length(VALUE**); - -int ruby_exec_node(void *n); - -void ruby_script(const char* name); -void ruby_set_script_name(VALUE name); - -void ruby_prog_init(void); -void ruby_set_argv(int, char**); -void *ruby_process_options(int, char**); -void ruby_init_loadpath(void); -void ruby_incpush(const char*); -void ruby_sig_finalize(void); - -/*! @} */ - -RUBY_SYMBOL_EXPORT_END #if defined(__cplusplus) #if 0 |