diff options
Diffstat (limited to 'include/ruby/ruby.h')
| -rw-r--r-- | include/ruby/ruby.h | 508 |
1 files changed, 131 insertions, 377 deletions
diff --git a/include/ruby/ruby.h b/include/ruby/ruby.h index 833bd2d8de..2f97b33bc4 100644 --- a/include/ruby/ruby.h +++ b/include/ruby/ruby.h @@ -36,9 +36,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) \ @@ -73,26 +70,13 @@ extern "C" { #pragma GCC visibility push(default) #endif -/* 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; @@ -114,7 +98,7 @@ typedef unsigned LONG_LONG ID; # define SIZEOF_VALUE SIZEOF_LONG_LONG # define PRI_VALUE_PREFIX PRI_LL_PREFIX #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]; @@ -133,18 +117,18 @@ typedef char ruby_check_sizeof_voidp[SIZEOF_VOIDP == sizeof(void*) ? 1 : -1]; #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 #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" #endif #ifndef PRI_VALUE_PREFIX # define PRI_VALUE_PREFIX "" @@ -311,16 +295,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 @@ -363,59 +346,11 @@ rb_long2int_inline(long n) #define ID2SYM(x) (((VALUE)(x)<<RUBY_SPECIAL_SHIFT)|SYMBOL_FLAG) #define SYM2ID(x) RSHIFT((unsigned long)(x),RUBY_SPECIAL_SHIFT) -#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 - /* Module#methods, #singleton_methods and so on return Symbols */ #define USE_SYMBOL_AS_METHOD_NAME 1 -/* -!USE_FLONUM -------------------------- -...xxxx xxx1 Fixnum -...0000 1110 Symbol -...0000 0000 Qfalse -...0000 0010 Qtrue -...0000 0100 Qnil -...0000 0110 Qundef - -USE_FLONUM -------------------------- -...xxxx xxx1 Fixnum -...xxxx xx10 Flonum -...0000 1100 Symbol -...0000 0000 Qfalse 0x00 = 0 -...0000 1000 Qnil 0x08 = 8 -...0001 0100 Qtrue 0x14 = 20 -...0011 0100 Qundef 0x34 = 52 - */ - /* special constants - i.e. non-zero and non-fixnum constants */ enum ruby_special_consts { -#if USE_FLONUM - RUBY_Qfalse = 0x00, - RUBY_Qtrue = 0x14, - RUBY_Qnil = 0x08, - RUBY_Qundef = 0x34, - - RUBY_IMMEDIATE_MASK = 0x07, - RUBY_FIXNUM_FLAG = 0x01, - RUBY_FLONUM_MASK = 0x03, - RUBY_FLONUM_FLAG = 0x02, - RUBY_SYMBOL_FLAG = 0x0c, - RUBY_SPECIAL_SHIFT = 8 -#else RUBY_Qfalse = 0, RUBY_Qtrue = 2, RUBY_Qnil = 4, @@ -423,11 +358,8 @@ enum ruby_special_consts { RUBY_IMMEDIATE_MASK = 0x03, RUBY_FIXNUM_FLAG = 0x01, - RUBY_FLONUM_MASK = 0x00, /* any values ANDed with FLONUM_MASK cannot be FLONUM_FLAG */ - RUBY_FLONUM_FLAG = 0x02, RUBY_SYMBOL_FLAG = 0x0e, RUBY_SPECIAL_SHIFT = 8 -#endif }; #define Qfalse ((VALUE)RUBY_Qfalse) @@ -436,14 +368,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)) @@ -512,8 +440,6 @@ enum ruby_value_type { static inline int rb_type(VALUE obj); #define TYPE(x) rb_type((VALUE)(x)) -/* 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;}) @@ -529,12 +455,6 @@ static inline volatile VALUE *rb_gc_guarded_ptr(volatile VALUE *ptr) {return ptr #endif #define RB_GC_GUARD(v) (*RB_GC_GUARD_PTR(&(v))) -#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)) @@ -581,80 +501,59 @@ void rb_set_errinfo(VALUE); SIGNED_VALUE rb_num2long(VALUE); VALUE rb_num2ulong(VALUE); +#define NUM2LONG_internal(x) ((long)(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) -{ - if (FIXNUM_P(x)) - return FIX2LONG(x); - else - return (long)rb_num2long(x); -} -#define NUM2LONG(x) rb_num2long_inline(x) -static inline unsigned long -rb_num2ulong_inline(VALUE x) +NUM2LONG(VALUE x) { - if (FIXNUM_P(x)) - return (unsigned long)FIX2LONG(x); - else - return (unsigned long)rb_num2ulong(x); + return NUM2LONG_internal(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 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(HAVE_LONG_LONG) && SIZEOF_OFF_T > SIZEOF_LONG @@ -665,7 +564,7 @@ rb_num2ll_inline(VALUE x) #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) @@ -678,9 +577,7 @@ VALUE rb_uint2big(VALUE); VALUE rb_int2big(SIGNED_VALUE); VALUE rb_newobj(void); -VALUE rb_newobj_of(VALUE, VALUE); #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) do {\ RBASIC(obj)->flags = (t);\ RBASIC(obj)->klass = (c);\ @@ -699,11 +596,7 @@ VALUE rb_newobj_of(VALUE, VALUE); struct RBasic { VALUE flags; VALUE klass; -} -#ifdef __GNUC__ - __attribute__((aligned(sizeof(VALUE)))) -#endif -; +}; #define ROBJECT_EMBED_LEN_MAX 3 struct RObject { @@ -745,95 +638,12 @@ struct RClass { #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 struct RFloat { struct RBasic basic; double float_value; }; - -VALUE rb_float_new_in_heap(double); - -#if USE_FLONUM -#define RUBY_BIT_ROTL(v, n) (((v) << (n)) | ((v) >> ((sizeof(v) * 8) - n))) -#define RUBY_BIT_ROTR(v, n) (((v) >> (n)) | ((v) << ((sizeof(v) * 8) - n))) - -static inline double -rb_float_value(VALUE v) -{ - if (FLONUM_P(v)) { - if (v != (VALUE)0x8000000000000002) { /* LIKELY */ - union { - double d; - VALUE v; - } t; - - VALUE b63 = (v >> 63); - /* e: xx1... -> 011... */ - /* xx0... -> 100... */ - /* ^b63 */ - t.v = RUBY_BIT_ROTR((2 - b63) | (v & ~0x03), 3); - return t.d; - } - else { - return 0.0; - } - } - else { - return ((struct RFloat *)v)->float_value; - } -} - -static inline VALUE -rb_float_new(double d) -{ - union { - double d; - VALUE v; - } t; - int bits; - - t.d = d; - bits = (int)((VALUE)(t.v >> 60) & 0x7); - /* bits contains 3 bits of b62..b60. */ - /* bits - 3 = */ - /* b011 -> b000 */ - /* b100 -> b001 */ - - if (t.v != 0x3000000000000000 /* 1.72723e-77 */ && - !((bits-3) & ~0x01)) { - return (RUBY_BIT_ROTL(t.v, 3) & ~(VALUE)0x01) | 0x02; - } - else { - if (t.v == (VALUE)0) { - /* +0.0 */ - return 0x8000000000000002; - } - else { - /* out of range */ - return rb_float_new_in_heap(d); - } - } -} - -#else /* USE_FLONUM */ - -static inline double -rb_float_value(VALUE v) -{ - return ((struct RFloat *)v)->float_value; -} - -static inline VALUE -rb_float_new(double d) -{ - return rb_float_new_in_heap(d); -} -#endif - -#define RFLOAT_VALUE(v) rb_float_value(v) +#define RFLOAT_VALUE(v) (RFLOAT(v)->float_value) #define DBL2NUM(dbl) rb_float_new(dbl) #define ELTS_SHARED FL_USER2 @@ -1109,8 +919,8 @@ struct RBignum { #define RCOMPLEX(obj) (R_CAST(RComplex)(obj)) #define FL_SINGLETON FL_USER0 -#define FL_RESERVED1 (((VALUE)1)<<5) -#define FL_RESERVED2 (((VALUE)1)<<6) /* will be used in the future GC */ +#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 (((VALUE)1)<<9) @@ -1154,70 +964,71 @@ struct RBignum { #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) +#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) -#define OBJ_FROZEN(x) (!!(FL_ABLE(x)?(RBASIC(x)->flags&(FL_FREEZE)):(FIXNUM_P(x)||FLONUM_P(x)))) +#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 ((TYPE(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))) @@ -1257,7 +1068,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; @@ -1304,7 +1114,6 @@ 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); @@ -1344,13 +1153,9 @@ VALUE rb_funcall(VALUE, ID, int, ...); VALUE rb_funcall2(VALUE, ID, int, const VALUE*); VALUE rb_funcall3(VALUE, ID, int, const VALUE*); VALUE rb_funcall_passing_block(VALUE, ID, int, const VALUE*); -VALUE rb_funcall_with_block(VALUE, ID, int, const VALUE*, VALUE); int rb_scan_args(int, const VALUE*, const char*, ...); VALUE rb_call_super(int, const VALUE*); -/* 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*); VALUE rb_iv_get(VALUE, const char*); @@ -1372,7 +1177,6 @@ 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_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 *); @@ -1411,6 +1215,21 @@ 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 *); +int ruby_executable_node(void *n, int *status); + RUBY_EXTERN VALUE rb_mKernel; RUBY_EXTERN VALUE rb_mComparable; RUBY_EXTERN VALUE rb_mEnumerable; @@ -1504,7 +1323,6 @@ 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 (SYMBOL_P(obj)) return rb_cSymbol; } @@ -1520,20 +1338,17 @@ 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 (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_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) : \ @@ -1541,7 +1356,6 @@ rb_type(VALUE obj) ((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))) #ifdef __GNUC__ @@ -1572,11 +1386,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 @@ -1586,25 +1407,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 +#define RUBY_EVENT_ALL 0xffff +#define RUBY_EVENT_VM 0x10000 +#define RUBY_EVENT_SWITCH 0x20000 +#define RUBY_EVENT_COVERAGE 0x40000 -/* special events */ -#define RUBY_EVENT_SPECIFIED_LINE 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 unsigned long rb_event_flag_t; -typedef void (*rb_event_hook_func_t)(rb_event_flag_t evflag, VALUE data, VALUE self, ID mid, 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 */ @@ -1653,80 +1473,14 @@ unsigned long ruby_strtoul(const char *str, char **endptr, int base); PRINTF_ARGS(int ruby_snprintf(char *str, size_t n, char const *fmt, ...), 3, 4); 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 extention 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*); -#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); - -/*! @} */ - #if defined __GNUC__ && __GNUC__ >= 4 #pragma GCC visibility pop #endif +#ifndef RUBY_DONT_SUBST +#include "ruby/subst.h" +#endif + #if defined(__cplusplus) #if 0 { /* satisfy cc-mode */ |