diff options
Diffstat (limited to 'include/ruby')
| -rw-r--r-- | include/ruby/backward/classext.h | 4 | ||||
| -rw-r--r-- | include/ruby/backward/rubyio.h | 2 | ||||
| -rw-r--r-- | include/ruby/backward/rubysig.h | 15 | ||||
| -rw-r--r-- | include/ruby/backward/st.h | 2 | ||||
| -rw-r--r-- | include/ruby/backward/util.h | 2 | ||||
| -rw-r--r-- | include/ruby/debug.h | 110 | ||||
| -rw-r--r-- | include/ruby/defines.h | 173 | ||||
| -rw-r--r-- | include/ruby/encoding.h | 247 | ||||
| -rw-r--r-- | include/ruby/intern.h | 359 | ||||
| -rw-r--r-- | include/ruby/io.h | 82 | ||||
| -rw-r--r-- | include/ruby/missing.h | 71 | ||||
| -rw-r--r-- | include/ruby/oniguruma.h | 62 | ||||
| -rw-r--r-- | include/ruby/re.h | 9 | ||||
| -rw-r--r-- | include/ruby/regex.h | 8 | ||||
| -rw-r--r-- | include/ruby/ruby.h | 1486 | ||||
| -rw-r--r-- | include/ruby/st.h | 46 | ||||
| -rw-r--r-- | include/ruby/thread.h | 15 | ||||
| -rw-r--r-- | include/ruby/thread_native.h | 56 | ||||
| -rw-r--r-- | include/ruby/util.h | 25 | ||||
| -rw-r--r-- | include/ruby/version.h | 12 | ||||
| -rw-r--r-- | include/ruby/vm.h | 8 | ||||
| -rw-r--r-- | include/ruby/win32.h | 235 |
22 files changed, 1940 insertions, 1089 deletions
diff --git a/include/ruby/backward/classext.h b/include/ruby/backward/classext.h index 615e6f6858..9d5747316a 100644 --- a/include/ruby/backward/classext.h +++ b/include/ruby/backward/classext.h @@ -1,6 +1,6 @@ #if defined __GNUC__ #warning use of RClass internals is deprecated -#elif defined _MSC_VER || defined __BORLANDC__ +#elif defined _MSC_VER #pragma message("warning: use of RClass internals is deprecated") #endif @@ -13,6 +13,6 @@ typedef struct rb_deprecated_classext_struct { #undef RCLASS_SUPER(c) #define RCLASS_EXT(c) ((rb_deprecated_classext_t *)RCLASS(c)->ptr) -#define RCLASS_SUPER(c) (RCLASS_EXT(c)->super) +#define RCLASS_SUPER(c) (RCLASS(c)->super) #endif /* RUBY_BACKWARD_CLASSEXT_H */ diff --git a/include/ruby/backward/rubyio.h b/include/ruby/backward/rubyio.h index d5246db546..a6e3a7c78b 100644 --- a/include/ruby/backward/rubyio.h +++ b/include/ruby/backward/rubyio.h @@ -1,6 +1,6 @@ #if defined __GNUC__ #warning use "ruby/io.h" instead of "rubyio.h" -#elif defined _MSC_VER || defined __BORLANDC__ +#elif defined _MSC_VER #pragma message("warning: use \"ruby/io.h\" instead of \"rubyio.h\"") #endif #include "ruby/io.h" diff --git a/include/ruby/backward/rubysig.h b/include/ruby/backward/rubysig.h index f46679ae67..58b13cab1c 100644 --- a/include/ruby/backward/rubysig.h +++ b/include/ruby/backward/rubysig.h @@ -12,7 +12,7 @@ #if defined __GNUC__ #warning rubysig.h is obsolete -#elif defined _MSC_VER || defined __BORLANDC__ +#elif defined _MSC_VER #pragma message("warning: rubysig.h is obsolete") #endif @@ -27,24 +27,15 @@ extern "C" { #endif #endif -#if defined __GNUC__ && __GNUC__ >= 4 -#pragma GCC visibility push(default) -#endif +RUBY_SYMBOL_EXPORT_BEGIN -struct rb_blocking_region_buffer; -DEPRECATED(RUBY_EXTERN struct rb_blocking_region_buffer *rb_thread_blocking_region_begin(void)); -DEPRECATED(RUBY_EXTERN void rb_thread_blocking_region_end(struct rb_blocking_region_buffer *)); -#define TRAP_BEG do {struct rb_blocking_region_buffer *__region = rb_thread_blocking_region_begin(); -#define TRAP_END rb_thread_blocking_region_end(__region);} while (0) #define RUBY_CRITICAL(statements) do {statements;} while (0) #define DEFER_INTS (0) #define ENABLE_INTS (1) #define ALLOW_INTS do {CHECK_INTS;} while (0) #define CHECK_INTS rb_thread_check_ints() -#if defined __GNUC__ && __GNUC__ >= 4 -#pragma GCC visibility pop -#endif +RUBY_SYMBOL_EXPORT_END #if defined(__cplusplus) #if 0 diff --git a/include/ruby/backward/st.h b/include/ruby/backward/st.h index 514128e616..3e36d44cf8 100644 --- a/include/ruby/backward/st.h +++ b/include/ruby/backward/st.h @@ -1,6 +1,6 @@ #if defined __GNUC__ #warning use "ruby/st.h" instead of bare "st.h" -#elif defined _MSC_VER || defined __BORLANDC__ +#elif defined _MSC_VER #pragma message("warning: use \"ruby/st.h\" instead of bare \"st.h\"") #endif #include "ruby/st.h" diff --git a/include/ruby/backward/util.h b/include/ruby/backward/util.h index 6b47940ddc..11d32a2da8 100644 --- a/include/ruby/backward/util.h +++ b/include/ruby/backward/util.h @@ -1,6 +1,6 @@ #if defined __GNUC__ #warning use "ruby/util.h" instead of bare "util.h" -#elif defined _MSC_VER || defined __BORLANDC__ +#elif defined _MSC_VER #pragma message("warning: use \"ruby/util.h\" instead of bare \"util.h\"") #endif #include "ruby/util.h" diff --git a/include/ruby/debug.h b/include/ruby/debug.h new file mode 100644 index 0000000000..9bfc9b9a83 --- /dev/null +++ b/include/ruby/debug.h @@ -0,0 +1,110 @@ +/********************************************************************** + + ruby/debug.h - + + $Author: ko1 $ + created at: Tue Nov 20 20:35:08 2012 + + Copyright (C) 2012 Yukihiro Matsumoto + +**********************************************************************/ + +#ifndef RB_DEBUG_H +#define RB_DEBUG_H 1 + +#if defined(__cplusplus) +extern "C" { +#if 0 +} /* satisfy cc-mode */ +#endif +#endif + +RUBY_SYMBOL_EXPORT_BEGIN + +/* Note: This file contains experimental APIs. */ +/* APIs can be replaced at Ruby 2.0.1 or later */ + + +/* profile frames APIs */ +int rb_profile_frames(int start, int limit, VALUE *buff, int *lines); +VALUE rb_profile_frame_path(VALUE frame); +VALUE rb_profile_frame_absolute_path(VALUE frame); +VALUE rb_profile_frame_label(VALUE frame); +VALUE rb_profile_frame_base_label(VALUE frame); +VALUE rb_profile_frame_full_label(VALUE frame); +VALUE rb_profile_frame_first_lineno(VALUE frame); +VALUE rb_profile_frame_classpath(VALUE frame); +VALUE rb_profile_frame_singleton_method_p(VALUE frame); +VALUE rb_profile_frame_method_name(VALUE frame); +VALUE rb_profile_frame_qualified_method_name(VALUE frame); + +/* debug inspector APIs */ +typedef struct rb_debug_inspector_struct rb_debug_inspector_t; +typedef VALUE (*rb_debug_inspector_func_t)(const rb_debug_inspector_t *, void *); + +VALUE rb_debug_inspector_open(rb_debug_inspector_func_t func, void *data); +VALUE rb_debug_inspector_frame_self_get(const rb_debug_inspector_t *dc, long index); +VALUE rb_debug_inspector_frame_class_get(const rb_debug_inspector_t *dc, long index); +VALUE rb_debug_inspector_frame_binding_get(const rb_debug_inspector_t *dc, long index); +VALUE rb_debug_inspector_frame_iseq_get(const rb_debug_inspector_t *dc, long index); +VALUE rb_debug_inspector_backtrace_locations(const rb_debug_inspector_t *dc); + +/* Old style set_trace_func APIs */ + +/* duplicated def of include/ruby/ruby.h */ +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); + +int rb_remove_event_hook_with_data(rb_event_hook_func_t func, VALUE data); +void rb_thread_add_event_hook(VALUE thval, rb_event_hook_func_t func, rb_event_flag_t events, VALUE data); +int rb_thread_remove_event_hook(VALUE thval, rb_event_hook_func_t func); +int rb_thread_remove_event_hook_with_data(VALUE thval, rb_event_hook_func_t func, VALUE data); + +/* TracePoint APIs */ + +VALUE rb_tracepoint_new(VALUE target_thread_not_supported_yet, rb_event_flag_t events, void (*func)(VALUE, void *), void *data); +VALUE rb_tracepoint_enable(VALUE tpval); +VALUE rb_tracepoint_disable(VALUE tpval); +VALUE rb_tracepoint_enabled_p(VALUE tpval); + +typedef struct rb_trace_arg_struct rb_trace_arg_t; +rb_trace_arg_t *rb_tracearg_from_tracepoint(VALUE tpval); + +rb_event_flag_t rb_tracearg_event_flag(rb_trace_arg_t *trace_arg); +VALUE rb_tracearg_event(rb_trace_arg_t *trace_arg); +VALUE rb_tracearg_lineno(rb_trace_arg_t *trace_arg); +VALUE rb_tracearg_path(rb_trace_arg_t *trace_arg); +VALUE rb_tracearg_method_id(rb_trace_arg_t *trace_arg); +VALUE rb_tracearg_defined_class(rb_trace_arg_t *trace_arg); +VALUE rb_tracearg_binding(rb_trace_arg_t *trace_arg); +VALUE rb_tracearg_self(rb_trace_arg_t *trace_arg); +VALUE rb_tracearg_return_value(rb_trace_arg_t *trace_arg); +VALUE rb_tracearg_raised_exception(rb_trace_arg_t *trace_arg); +VALUE rb_tracearg_object(rb_trace_arg_t *trace_arg); + +/* Postponed Job API */ +typedef void (*rb_postponed_job_func_t)(void *arg); +int rb_postponed_job_register(unsigned int flags, rb_postponed_job_func_t func, void *data); +int rb_postponed_job_register_one(unsigned int flags, rb_postponed_job_func_t func, void *data); + +/* undocumented advanced tracing APIs */ + +typedef enum { + RUBY_EVENT_HOOK_FLAG_SAFE = 0x01, + RUBY_EVENT_HOOK_FLAG_DELETED = 0x02, + RUBY_EVENT_HOOK_FLAG_RAW_ARG = 0x04 +} rb_event_hook_flag_t; + +void rb_add_event_hook2(rb_event_hook_func_t func, rb_event_flag_t events, VALUE data, rb_event_hook_flag_t hook_flag); +void rb_thread_add_event_hook2(VALUE thval, rb_event_hook_func_t func, rb_event_flag_t events, VALUE data, rb_event_hook_flag_t hook_flag); + +RUBY_SYMBOL_EXPORT_END + +#if defined(__cplusplus) +#if 0 +{ /* satisfy cc-mode */ +#endif +} /* extern "C" { */ +#endif + +#endif /* RUBY_DEBUG_H */ diff --git a/include/ruby/defines.h b/include/ruby/defines.h index de0883d2c9..b4d75294d4 100644 --- a/include/ruby/defines.h +++ b/include/ruby/defines.h @@ -22,12 +22,53 @@ extern "C" { #include RUBY_EXTCONF_H #endif -#define RUBY - -# include <stddef.h> -#ifdef HAVE_STDLIB_H +/* AC_INCLUDES_DEFAULT */ +#include <stdio.h> +#ifdef HAVE_SYS_TYPES_H +# include <sys/types.h> +#endif +#ifdef HAVE_SYS_STAT_H +# include <sys/stat.h> +#endif +#ifdef STDC_HEADERS # include <stdlib.h> +# include <stddef.h> +#else +# ifdef HAVE_STDLIB_H +# include <stdlib.h> +# endif +#endif +#ifdef HAVE_STRING_H +# if !defined STDC_HEADERS && defined HAVE_MEMORY_H +# include <memory.h> +# endif +# include <string.h> +#endif +#ifdef HAVE_STRINGS_H +# include <strings.h> +#endif +#ifdef HAVE_INTTYPES_H +# include <inttypes.h> #endif +#ifdef HAVE_STDINT_H +# include <stdint.h> +#endif +#ifdef HAVE_UNISTD_H +# include <unistd.h> +#endif + +#ifdef HAVE_SYS_SELECT_H +# include <sys/select.h> +#endif + +#if defined HAVE_SETJMPEX_H && defined HAVE__SETJMPEX +#include <setjmpex.h> +#endif + +#include "ruby/missing.h" + +#define RUBY + #ifdef __cplusplus # ifndef HAVE_PROTOTYPES # define HAVE_PROTOTYPES 1 @@ -57,10 +98,13 @@ extern "C" { #define ANYARGS #endif -#if defined __GNUC__ && __GNUC__ >= 4 -#pragma GCC visibility push(default) +#ifndef RUBY_SYMBOL_EXPORT_BEGIN +# define RUBY_SYMBOL_EXPORT_BEGIN /* begin */ +# define RUBY_SYMBOL_EXPORT_END /* end */ #endif +RUBY_SYMBOL_EXPORT_BEGIN + #define xmalloc ruby_xmalloc #define xmalloc2 ruby_xmalloc2 #define xcalloc ruby_xcalloc @@ -68,11 +112,17 @@ extern "C" { #define xrealloc2 ruby_xrealloc2 #define xfree ruby_xfree -void *xmalloc(size_t); -void *xmalloc2(size_t,size_t); -void *xcalloc(size_t,size_t); -void *xrealloc(void*,size_t); -void *xrealloc2(void*,size_t,size_t); +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) +# define RUBY_ATTR_ALLOC_SIZE(params) __attribute__ ((__alloc_size__ params)) +#else +# define RUBY_ATTR_ALLOC_SIZE(params) +#endif + +void *xmalloc(size_t) RUBY_ATTR_ALLOC_SIZE((1)); +void *xmalloc2(size_t,size_t) RUBY_ATTR_ALLOC_SIZE((1,2)); +void *xcalloc(size_t,size_t) RUBY_ATTR_ALLOC_SIZE((1,2)); +void *xrealloc(void*,size_t) RUBY_ATTR_ALLOC_SIZE((2)); +void *xrealloc2(void*,size_t,size_t) RUBY_ATTR_ALLOC_SIZE((2,3)); void xfree(void*); #define STRINGIZE(expr) STRINGIZE0(expr) @@ -80,6 +130,10 @@ void xfree(void*); #define STRINGIZE0(expr) #expr #endif +#ifdef HAVE_LONG_LONG +# define HAVE_TRUE_LONG_LONG 1 +#endif + #if SIZEOF_LONG_LONG > 0 # define LONG_LONG long long #elif SIZEOF___INT64 > 0 @@ -89,55 +143,16 @@ void xfree(void*); # define SIZEOF_LONG_LONG SIZEOF___INT64 #endif -#if SIZEOF_INT*2 <= SIZEOF_LONG_LONG -# define BDIGIT unsigned int -# define SIZEOF_BDIGITS SIZEOF_INT -# define BDIGIT_DBL unsigned LONG_LONG -# define BDIGIT_DBL_SIGNED LONG_LONG -# define PRI_BDIGIT_PREFIX "" -# define PRI_BDIGIT_DBL_PREFIX PRI_LL_PREFIX -#elif SIZEOF_INT*2 <= SIZEOF_LONG -# define BDIGIT unsigned int -# define SIZEOF_BDIGITS SIZEOF_INT -# define BDIGIT_DBL unsigned long -# define BDIGIT_DBL_SIGNED long -# define PRI_BDIGIT_PREFIX "" -# define PRI_BDIGIT_DBL_PREFIX "l" -#elif SIZEOF_SHORT*2 <= SIZEOF_LONG -# define BDIGIT unsigned short -# define SIZEOF_BDIGITS SIZEOF_SHORT -# define BDIGIT_DBL unsigned long -# define BDIGIT_DBL_SIGNED long -# define PRI_BDIGIT_PREFIX "h" -# define PRI_BDIGIT_DBL_PREFIX "l" -#else -# define BDIGIT unsigned short -# define SIZEOF_BDIGITS (SIZEOF_LONG/2) -# define BDIGIT_DBL unsigned long -# define BDIGIT_DBL_SIGNED long -# define PRI_BDIGIT_PREFIX "h" -# define PRI_BDIGIT_DBL_PREFIX "l" -#endif - -#define PRIdBDIGIT PRI_BDIGIT_PREFIX"d" -#define PRIiBDIGIT PRI_BDIGIT_PREFIX"i" -#define PRIoBDIGIT PRI_BDIGIT_PREFIX"o" -#define PRIuBDIGIT PRI_BDIGIT_PREFIX"u" -#define PRIxBDIGIT PRI_BDIGIT_PREFIX"x" -#define PRIXBDIGIT PRI_BDIGIT_PREFIX"X" - -#define PRIdBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"d" -#define PRIiBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"i" -#define PRIoBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"o" -#define PRIuBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"u" -#define PRIxBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"x" -#define PRIXBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"X" - #ifdef __CYGWIN__ #undef _WIN32 #endif -#if defined(_WIN32) || defined(__EMX__) +#if defined(_WIN32) +/* + DOSISH mean MS-Windows style filesystem. + But you should use more precise macros like DOSISH_DRIVE_LETTER, PATH_SEP, + ENV_IGNORECASE or CASEFOLD_FILESYSTEM. + */ #define DOSISH 1 # define DOSISH_DRIVE_LETTER #endif @@ -153,17 +168,6 @@ void xfree(void*); #include "ruby/win32.h" #endif -#if defined(__BEOS__) && !defined(__HAIKU__) && !defined(BONE) -#include <net/socket.h> /* intern.h needs fd_set definition */ -#elif defined (__SYMBIAN32__) && defined (HAVE_SYS_SELECT_H) -# include <sys/select.h> -#endif - -#ifdef __SYMBIAN32__ -# define FALSE 0 -# define TRUE 1 -#endif - #ifdef RUBY_EXPORT #undef RUBY_EXTERN @@ -217,7 +221,7 @@ void rb_ia64_flushrs(void); #define PATH_ENV "PATH" -#if defined(DOSISH) && !defined(__EMX__) +#if defined(DOSISH) #define ENV_IGNORECASE #endif @@ -237,23 +241,48 @@ void rb_ia64_flushrs(void); #define RUBY_PLATFORM "unknown-unknown" #endif +#ifndef FUNC_MINIMIZED +#define FUNC_MINIMIZED(x) x +#endif +#ifndef FUNC_UNOPTIMIZED +#define FUNC_UNOPTIMIZED(x) x +#endif #ifndef RUBY_ALIAS_FUNCTION_TYPE #define RUBY_ALIAS_FUNCTION_TYPE(type, prot, name, args) \ - type prot {return name args;} + FUNC_MINIMIZED(type prot) {return (type)name args;} #endif #ifndef RUBY_ALIAS_FUNCTION_VOID #define RUBY_ALIAS_FUNCTION_VOID(prot, name, args) \ - void prot {name args;} + FUNC_MINIMIZED(void prot) {name args;} #endif #ifndef RUBY_ALIAS_FUNCTION #define RUBY_ALIAS_FUNCTION(prot, name, args) \ RUBY_ALIAS_FUNCTION_TYPE(VALUE, prot, name, args) #endif -#if defined __GNUC__ && __GNUC__ >= 4 -#pragma GCC visibility pop +#ifndef UNALIGNED_WORD_ACCESS +# if defined(__i386) || defined(__i386__) || defined(_M_IX86) || \ + defined(__x86_64) || defined(__x86_64__) || defined(_M_AMD64) || \ + defined(__powerpc64__) || \ + defined(__mc68020__) +# define UNALIGNED_WORD_ACCESS 1 +# else +# define UNALIGNED_WORD_ACCESS 0 +# endif +#endif +#ifndef PACKED_STRUCT +# define PACKED_STRUCT(x) x +#endif +#ifndef PACKED_STRUCT_UNALIGNED +# if UNALIGNED_WORD_ACCESS +# define PACKED_STRUCT_UNALIGNED(x) PACKED_STRUCT(x) +# else +# define PACKED_STRUCT_UNALIGNED(x) x +# endif #endif +RUBY_SYMBOL_EXPORT_END + #if defined(__cplusplus) #if 0 { /* satisfy cc-mode */ diff --git a/include/ruby/encoding.h b/include/ruby/encoding.h index 41640ec7e0..5ea2cda116 100644 --- a/include/ruby/encoding.h +++ b/include/ruby/encoding.h @@ -22,82 +22,115 @@ extern "C" { #include <stdarg.h> #include "ruby/oniguruma.h" -#if defined __GNUC__ && __GNUC__ >= 4 -#pragma GCC visibility push(default) -#endif - -#define ENCODING_INLINE_MAX 1023 -#define ENCODING_SHIFT (FL_USHIFT+10) -#define ENCODING_MASK (((VALUE)ENCODING_INLINE_MAX)<<ENCODING_SHIFT) - -#define ENCODING_SET_INLINED(obj,i) do {\ - RBASIC(obj)->flags &= ~ENCODING_MASK;\ - RBASIC(obj)->flags |= (VALUE)(i) << ENCODING_SHIFT;\ -} while (0) -#define ENCODING_SET(obj,i) do {\ - VALUE rb_encoding_set_obj = (obj); \ - int encoding_set_enc_index = (i); \ - if (encoding_set_enc_index < ENCODING_INLINE_MAX) \ - ENCODING_SET_INLINED(rb_encoding_set_obj, encoding_set_enc_index); \ - else \ - rb_enc_set_index(rb_encoding_set_obj, encoding_set_enc_index); \ +RUBY_SYMBOL_EXPORT_BEGIN + +enum ruby_encoding_consts { + RUBY_ENCODING_INLINE_MAX = 127, + RUBY_ENCODING_SHIFT = (RUBY_FL_USHIFT+10), + RUBY_ENCODING_MASK = (RUBY_ENCODING_INLINE_MAX<<RUBY_ENCODING_SHIFT + /* RUBY_FL_USER10..RUBY_FL_USER16 */), + RUBY_ENCODING_MAXNAMELEN = 42 +}; + +#define ENCODING_INLINE_MAX RUBY_ENCODING_INLINE_MAX +#define ENCODING_SHIFT RUBY_ENCODING_SHIFT +#define ENCODING_MASK RUBY_ENCODING_MASK + +#define RB_ENCODING_SET_INLINED(obj,i) do {\ + RBASIC(obj)->flags &= ~RUBY_ENCODING_MASK;\ + RBASIC(obj)->flags |= (VALUE)(i) << RUBY_ENCODING_SHIFT;\ } while (0) +#define RB_ENCODING_SET(obj,i) rb_enc_set_index((obj), (i)) -#define ENCODING_GET_INLINED(obj) (int)((RBASIC(obj)->flags & ENCODING_MASK)>>ENCODING_SHIFT) -#define ENCODING_GET(obj) \ - (ENCODING_GET_INLINED(obj) != ENCODING_INLINE_MAX ? \ - ENCODING_GET_INLINED(obj) : \ +#define RB_ENCODING_GET_INLINED(obj) \ + (int)((RBASIC(obj)->flags & RUBY_ENCODING_MASK)>>RUBY_ENCODING_SHIFT) +#define RB_ENCODING_GET(obj) \ + (RB_ENCODING_GET_INLINED(obj) != RUBY_ENCODING_INLINE_MAX ? \ + RB_ENCODING_GET_INLINED(obj) : \ rb_enc_get_index(obj)) -#define ENCODING_IS_ASCII8BIT(obj) (ENCODING_GET_INLINED(obj) == 0) - -#define ENCODING_MAXNAMELEN 42 +#define RB_ENCODING_IS_ASCII8BIT(obj) (RB_ENCODING_GET_INLINED(obj) == 0) + +#define ENCODING_SET_INLINED(obj,i) RB_ENCODING_SET_INLINED(obj,i) +#define ENCODING_SET(obj,i) RB_ENCODING_SET(obj,i) +#define ENCODING_GET_INLINED(obj) RB_ENCODING_GET_INLINED(obj) +#define ENCODING_GET(obj) RB_ENCODING_GET(obj) +#define ENCODING_IS_ASCII8BIT(obj) RB_ENCODING_IS_ASCII8BIT(obj) +#define ENCODING_MAXNAMELEN RUBY_ENCODING_MAXNAMELEN + +enum ruby_coderange_type { + RUBY_ENC_CODERANGE_UNKNOWN = 0, + RUBY_ENC_CODERANGE_7BIT = ((int)RUBY_FL_USER8), + RUBY_ENC_CODERANGE_VALID = ((int)RUBY_FL_USER9), + RUBY_ENC_CODERANGE_BROKEN = ((int)(RUBY_FL_USER8|RUBY_FL_USER9)), + RUBY_ENC_CODERANGE_MASK = (RUBY_ENC_CODERANGE_7BIT| + RUBY_ENC_CODERANGE_VALID| + RUBY_ENC_CODERANGE_BROKEN) +}; -#define ENC_CODERANGE_MASK ((int)(FL_USER8|FL_USER9)) -#define ENC_CODERANGE_UNKNOWN 0 -#define ENC_CODERANGE_7BIT ((int)FL_USER8) -#define ENC_CODERANGE_VALID ((int)FL_USER9) -#define ENC_CODERANGE_BROKEN ((int)(FL_USER8|FL_USER9)) -#define ENC_CODERANGE(obj) ((int)RBASIC(obj)->flags & ENC_CODERANGE_MASK) -#define ENC_CODERANGE_ASCIIONLY(obj) (ENC_CODERANGE(obj) == ENC_CODERANGE_7BIT) -#define ENC_CODERANGE_SET(obj,cr) (RBASIC(obj)->flags = \ - (RBASIC(obj)->flags & ~ENC_CODERANGE_MASK) | (cr)) -#define ENC_CODERANGE_CLEAR(obj) ENC_CODERANGE_SET((obj),0) +static inline int +rb_enc_coderange_clean_p(int cr) +{ + return (cr ^ (cr >> 1)) & RUBY_ENC_CODERANGE_7BIT; +} +#define RB_ENC_CODERANGE_CLEAN_P(cr) rb_enc_coderange_clean_p(cr) +#define RB_ENC_CODERANGE(obj) ((int)RBASIC(obj)->flags & RUBY_ENC_CODERANGE_MASK) +#define RB_ENC_CODERANGE_ASCIIONLY(obj) (RB_ENC_CODERANGE(obj) == RUBY_ENC_CODERANGE_7BIT) +#define RB_ENC_CODERANGE_SET(obj,cr) (\ + RBASIC(obj)->flags = \ + (RBASIC(obj)->flags & ~RUBY_ENC_CODERANGE_MASK) | (cr)) +#define RB_ENC_CODERANGE_CLEAR(obj) RB_ENC_CODERANGE_SET((obj),0) /* assumed ASCII compatibility */ -#define ENC_CODERANGE_AND(a, b) \ - ((a) == ENC_CODERANGE_7BIT ? (b) : \ - (a) == ENC_CODERANGE_VALID ? ((b) == ENC_CODERANGE_7BIT ? ENC_CODERANGE_VALID : (b)) : \ - ENC_CODERANGE_UNKNOWN) +#define RB_ENC_CODERANGE_AND(a, b) \ + ((a) == RUBY_ENC_CODERANGE_7BIT ? (b) : \ + (a) != RUBY_ENC_CODERANGE_VALID ? RUBY_ENC_CODERANGE_UNKNOWN : \ + (b) == RUBY_ENC_CODERANGE_7BIT ? RUBY_ENC_CODERANGE_VALID : (b)) -#define ENCODING_CODERANGE_SET(obj, encindex, cr) \ +#define RB_ENCODING_CODERANGE_SET(obj, encindex, cr) \ do { \ VALUE rb_encoding_coderange_obj = (obj); \ - ENCODING_SET(rb_encoding_coderange_obj, (encindex)); \ - ENC_CODERANGE_SET(rb_encoding_coderange_obj, (cr)); \ + RB_ENCODING_SET(rb_encoding_coderange_obj, (encindex)); \ + RB_ENC_CODERANGE_SET(rb_encoding_coderange_obj, (cr)); \ } while (0) -typedef OnigEncodingType rb_encoding; +#define ENC_CODERANGE_MASK RUBY_ENC_CODERANGE_MASK +#define ENC_CODERANGE_UNKNOWN RUBY_ENC_CODERANGE_UNKNOWN +#define ENC_CODERANGE_7BIT RUBY_ENC_CODERANGE_7BIT +#define ENC_CODERANGE_VALID RUBY_ENC_CODERANGE_VALID +#define ENC_CODERANGE_BROKEN RUBY_ENC_CODERANGE_BROKEN +#define ENC_CODERANGE_CLEAN_P(cr) RB_ENC_CODERANGE_CLEAN_P(cr) +#define ENC_CODERANGE(obj) RB_ENC_CODERANGE(obj) +#define ENC_CODERANGE_ASCIIONLY(obj) RB_ENC_CODERANGE_ASCIIONLY(obj) +#define ENC_CODERANGE_SET(obj,cr) RB_ENC_CODERANGE_SET(obj,cr) +#define ENC_CODERANGE_CLEAR(obj) RB_ENC_CODERANGE_CLEAR(obj) +#define ENC_CODERANGE_AND(a, b) RB_ENC_CODERANGE_AND(a, b) +#define ENCODING_CODERANGE_SET(obj, encindex, cr) RB_ENCODING_CODERANGE_SET(obj, encindex, cr) + +typedef const OnigEncodingType rb_encoding; int rb_char_to_option_kcode(int c, int *option, int *kcode); int rb_enc_replicate(const char *, rb_encoding *); int rb_define_dummy_encoding(const char *); -#define rb_enc_to_index(enc) ((enc) ? ENC_TO_ENCINDEX(enc) : 0) +int rb_enc_dummy_p(rb_encoding *enc); +int rb_enc_to_index(rb_encoding *enc); int rb_enc_get_index(VALUE obj); void rb_enc_set_index(VALUE obj, int encindex); int rb_enc_find_index(const char *name); int rb_to_encoding_index(VALUE); -rb_encoding* rb_to_encoding(VALUE); -rb_encoding* rb_find_encoding(VALUE); -rb_encoding* rb_enc_get(VALUE); -rb_encoding* rb_enc_compatible(VALUE,VALUE); -rb_encoding* rb_enc_check(VALUE,VALUE); +rb_encoding *rb_to_encoding(VALUE); +rb_encoding *rb_find_encoding(VALUE); +rb_encoding *rb_enc_get(VALUE); +rb_encoding *rb_enc_compatible(VALUE,VALUE); +rb_encoding *rb_enc_check(VALUE,VALUE); VALUE rb_enc_associate_index(VALUE, int); VALUE rb_enc_associate(VALUE, rb_encoding*); void rb_enc_copy(VALUE dst, VALUE src); VALUE rb_enc_str_new(const char*, long, rb_encoding*); +VALUE rb_enc_str_new_cstr(const char*, rb_encoding*); +VALUE rb_enc_str_new_static(const char*, long, rb_encoding*); VALUE rb_enc_reg_new(const char*, long, rb_encoding*, int); PRINTF_ARGS(VALUE rb_enc_sprintf(rb_encoding *, const char*, ...), 2, 3); VALUE rb_enc_vsprintf(rb_encoding *, const char*, va_list); @@ -112,13 +145,28 @@ VALUE rb_str_export_to_enc(VALUE, rb_encoding *); VALUE rb_str_conv_enc(VALUE str, rb_encoding *from, rb_encoding *to); VALUE rb_str_conv_enc_opts(VALUE str, rb_encoding *from, rb_encoding *to, int ecflags, VALUE ecopts); +#if defined(__GNUC__) && !defined(__PCC__) +#define rb_enc_str_new(str, len, enc) __extension__ ( \ +{ \ + (__builtin_constant_p(str) && __builtin_constant_p(len)) ? \ + rb_enc_str_new_static((str), (len), (enc)) : \ + rb_enc_str_new((str), (len), (enc)); \ +}) +#define rb_enc_str_new_cstr(str, enc) __extension__ ( \ +{ \ + (__builtin_constant_p(str)) ? \ + rb_enc_str_new_static((str), (long)strlen(str), (enc)) : \ + rb_enc_str_new_cstr((str), (enc)); \ +}) +#endif + PRINTF_ARGS(NORETURN(void rb_enc_raise(rb_encoding *, VALUE, const char*, ...)), 3, 4); /* index -> rb_encoding */ -rb_encoding* rb_enc_from_index(int idx); +rb_encoding *rb_enc_from_index(int idx); /* name -> rb_encoding */ -rb_encoding * rb_enc_find(const char *name); +rb_encoding *rb_enc_find(const char *name); /* rb_encoding * -> name */ #define rb_enc_name(enc) (enc)->name @@ -156,6 +204,9 @@ unsigned int rb_enc_codepoint(const char *p, const char *e, rb_encoding *enc); /* -> codelen>0 or raise exception */ int rb_enc_codelen(int code, rb_encoding *enc); +/* -> 0 for invalid codepoint */ +int rb_enc_code_to_mbclen(int code, rb_encoding *enc); +#define rb_enc_code_to_mbclen(c, enc) ONIGENC_CODE_TO_MBCLEN((enc), (c)); /* code,ptr,encoding -> write buf */ #define rb_enc_mbcput(c,buf,enc) ONIGENC_CODE_TO_MBC((enc),(c),(UChar*)(buf)) @@ -203,9 +254,15 @@ rb_encoding *rb_locale_encoding(void); rb_encoding *rb_filesystem_encoding(void); rb_encoding *rb_default_external_encoding(void); rb_encoding *rb_default_internal_encoding(void); +#ifndef rb_ascii8bit_encindex int rb_ascii8bit_encindex(void); +#endif +#ifndef rb_utf8_encindex int rb_utf8_encindex(void); +#endif +#ifndef rb_usascii_encindex int rb_usascii_encindex(void); +#endif int rb_locale_encindex(void); int rb_filesystem_encindex(void); VALUE rb_enc_default_external(void); @@ -221,21 +278,9 @@ char *rb_enc_path_end(const char *,const char *,rb_encoding*); const char *ruby_enc_find_basename(const char *name, long *baselen, long *alllen, rb_encoding *enc); const char *ruby_enc_find_extname(const char *name, long *len, rb_encoding *enc); ID rb_check_id_cstr(const char *ptr, long len, rb_encoding *enc); +VALUE rb_check_symbol_cstr(const char *ptr, long len, rb_encoding *enc); RUBY_EXTERN VALUE rb_cEncoding; -#define ENC_DUMMY_FLAG (1<<24) -#define ENC_INDEX_MASK (~(~0U<<24)) - -#define ENC_TO_ENCINDEX(enc) (int)((enc)->ruby_encoding_index & ENC_INDEX_MASK) - -#define ENC_DUMMY_P(enc) ((enc)->ruby_encoding_index & ENC_DUMMY_FLAG) -#define ENC_SET_DUMMY(enc) ((enc)->ruby_encoding_index |= ENC_DUMMY_FLAG) - -static inline int -rb_enc_dummy_p(rb_encoding *enc) -{ - return ENC_DUMMY_P(enc) != 0; -} /* econv stuff */ @@ -299,50 +344,70 @@ VALUE rb_econv_str_convert(rb_econv_t *ec, VALUE src, int flags); VALUE rb_econv_substr_convert(rb_econv_t *ec, VALUE src, long byteoff, long bytesize, int flags); VALUE rb_econv_str_append(rb_econv_t *ec, VALUE src, VALUE dst, int flags); VALUE rb_econv_substr_append(rb_econv_t *ec, VALUE src, long byteoff, long bytesize, VALUE dst, int flags); +VALUE rb_econv_append(rb_econv_t *ec, const char *bytesrc, long bytesize, VALUE dst, int flags); void rb_econv_binmode(rb_econv_t *ec); +enum ruby_econv_flag_type { /* flags for rb_econv_open */ + RUBY_ECONV_ERROR_HANDLER_MASK = 0x000000ff, -#define ECONV_ERROR_HANDLER_MASK 0x000000ff - -#define ECONV_INVALID_MASK 0x0000000f -#define ECONV_INVALID_REPLACE 0x00000002 + RUBY_ECONV_INVALID_MASK = 0x0000000f, + RUBY_ECONV_INVALID_REPLACE = 0x00000002, -#define ECONV_UNDEF_MASK 0x000000f0 -#define ECONV_UNDEF_REPLACE 0x00000020 -#define ECONV_UNDEF_HEX_CHARREF 0x00000030 + RUBY_ECONV_UNDEF_MASK = 0x000000f0, + RUBY_ECONV_UNDEF_REPLACE = 0x00000020, + RUBY_ECONV_UNDEF_HEX_CHARREF = 0x00000030, -#define ECONV_DECORATOR_MASK 0x0000ff00 -#define ECONV_NEWLINE_DECORATOR_MASK 0x00003f00 -#define ECONV_NEWLINE_DECORATOR_READ_MASK 0x00000f00 -#define ECONV_NEWLINE_DECORATOR_WRITE_MASK 0x00003000 + RUBY_ECONV_DECORATOR_MASK = 0x0000ff00, + RUBY_ECONV_NEWLINE_DECORATOR_MASK = 0x00003f00, + RUBY_ECONV_NEWLINE_DECORATOR_READ_MASK = 0x00000f00, + RUBY_ECONV_NEWLINE_DECORATOR_WRITE_MASK = 0x00003000, -#define ECONV_UNIVERSAL_NEWLINE_DECORATOR 0x00000100 -#define ECONV_CRLF_NEWLINE_DECORATOR 0x00001000 -#define ECONV_CR_NEWLINE_DECORATOR 0x00002000 -#define ECONV_XML_TEXT_DECORATOR 0x00004000 -#define ECONV_XML_ATTR_CONTENT_DECORATOR 0x00008000 + RUBY_ECONV_UNIVERSAL_NEWLINE_DECORATOR = 0x00000100, + RUBY_ECONV_CRLF_NEWLINE_DECORATOR = 0x00001000, + RUBY_ECONV_CR_NEWLINE_DECORATOR = 0x00002000, + RUBY_ECONV_XML_TEXT_DECORATOR = 0x00004000, + RUBY_ECONV_XML_ATTR_CONTENT_DECORATOR = 0x00008000, -#define ECONV_STATEFUL_DECORATOR_MASK 0x00f00000 -#define ECONV_XML_ATTR_QUOTE_DECORATOR 0x00100000 + RUBY_ECONV_STATEFUL_DECORATOR_MASK = 0x00f00000, + RUBY_ECONV_XML_ATTR_QUOTE_DECORATOR = 0x00100000, + RUBY_ECONV_DEFAULT_NEWLINE_DECORATOR = #if defined(RUBY_TEST_CRLF_ENVIRONMENT) || defined(_WIN32) -#define ECONV_DEFAULT_NEWLINE_DECORATOR ECONV_CRLF_NEWLINE_DECORATOR + RUBY_ECONV_CRLF_NEWLINE_DECORATOR, #else -#define ECONV_DEFAULT_NEWLINE_DECORATOR 0 + 0, #endif - +#define ECONV_ERROR_HANDLER_MASK RUBY_ECONV_ERROR_HANDLER_MASK +#define ECONV_INVALID_MASK RUBY_ECONV_INVALID_MASK +#define ECONV_INVALID_REPLACE RUBY_ECONV_INVALID_REPLACE +#define ECONV_UNDEF_MASK RUBY_ECONV_UNDEF_MASK +#define ECONV_UNDEF_REPLACE RUBY_ECONV_UNDEF_REPLACE +#define ECONV_UNDEF_HEX_CHARREF RUBY_ECONV_UNDEF_HEX_CHARREF +#define ECONV_DECORATOR_MASK RUBY_ECONV_DECORATOR_MASK +#define ECONV_NEWLINE_DECORATOR_MASK RUBY_ECONV_NEWLINE_DECORATOR_MASK +#define ECONV_NEWLINE_DECORATOR_READ_MASK RUBY_ECONV_NEWLINE_DECORATOR_READ_MASK +#define ECONV_NEWLINE_DECORATOR_WRITE_MASK RUBY_ECONV_NEWLINE_DECORATOR_WRITE_MASK +#define ECONV_UNIVERSAL_NEWLINE_DECORATOR RUBY_ECONV_UNIVERSAL_NEWLINE_DECORATOR +#define ECONV_CRLF_NEWLINE_DECORATOR RUBY_ECONV_CRLF_NEWLINE_DECORATOR +#define ECONV_CR_NEWLINE_DECORATOR RUBY_ECONV_CR_NEWLINE_DECORATOR +#define ECONV_XML_TEXT_DECORATOR RUBY_ECONV_XML_TEXT_DECORATOR +#define ECONV_XML_ATTR_CONTENT_DECORATOR RUBY_ECONV_XML_ATTR_CONTENT_DECORATOR +#define ECONV_STATEFUL_DECORATOR_MASK RUBY_ECONV_STATEFUL_DECORATOR_MASK +#define ECONV_XML_ATTR_QUOTE_DECORATOR RUBY_ECONV_XML_ATTR_QUOTE_DECORATOR +#define ECONV_DEFAULT_NEWLINE_DECORATOR RUBY_ECONV_DEFAULT_NEWLINE_DECORATOR /* end of flags for rb_econv_open */ /* flags for rb_econv_convert */ -#define ECONV_PARTIAL_INPUT 0x00010000 -#define ECONV_AFTER_OUTPUT 0x00020000 + RUBY_ECONV_PARTIAL_INPUT = 0x00010000, + RUBY_ECONV_AFTER_OUTPUT = 0x00020000, +#define ECONV_PARTIAL_INPUT RUBY_ECONV_PARTIAL_INPUT +#define ECONV_AFTER_OUTPUT RUBY_ECONV_AFTER_OUTPUT /* end of flags for rb_econv_convert */ +RUBY_ECONV_FLAGS_PLACEHOLDER}; -#if defined __GNUC__ && __GNUC__ >= 4 -#pragma GCC visibility pop -#endif +RUBY_SYMBOL_EXPORT_END #if defined(__cplusplus) #if 0 diff --git a/include/ruby/intern.h b/include/ruby/intern.h index f954232b48..aec2d528ca 100644 --- a/include/ruby/intern.h +++ b/include/ruby/intern.h @@ -31,11 +31,10 @@ extern "C" { #else # include <varargs.h> #endif + #include "ruby/st.h" -#if defined __GNUC__ && __GNUC__ >= 4 -#pragma GCC visibility push(default) -#endif +RUBY_SYMBOL_EXPORT_BEGIN /* * Functions and variables that are used by more than one source file of @@ -49,20 +48,22 @@ void rb_mem_clear(register VALUE*, register long); VALUE rb_assoc_new(VALUE, VALUE); VALUE rb_check_array_type(VALUE); VALUE rb_ary_new(void); -VALUE rb_ary_new2(long); -VALUE rb_ary_new3(long,...); -VALUE rb_ary_new4(long, const VALUE *); +VALUE rb_ary_new_capa(long capa); +VALUE rb_ary_new_from_args(long n, ...); +VALUE rb_ary_new_from_values(long n, const VALUE *elts); VALUE rb_ary_tmp_new(long); void rb_ary_free(VALUE); void rb_ary_modify(VALUE); VALUE rb_ary_freeze(VALUE); -VALUE rb_ary_aref(int, VALUE*, VALUE); +VALUE rb_ary_shared_with_p(VALUE, VALUE); +VALUE rb_ary_aref(int, const VALUE*, VALUE); VALUE rb_ary_subseq(VALUE, long, long); void rb_ary_store(VALUE, long, VALUE); VALUE rb_ary_dup(VALUE); VALUE rb_ary_resurrect(VALUE ary); VALUE rb_ary_to_ary(VALUE); VALUE rb_ary_to_s(VALUE); +VALUE rb_ary_cat(VALUE, const VALUE *, long); VALUE rb_ary_push(VALUE, VALUE); VALUE rb_ary_pop(VALUE); VALUE rb_ary_shift(VALUE); @@ -84,38 +85,31 @@ VALUE rb_ary_rassoc(VALUE, VALUE); VALUE rb_ary_includes(VALUE, VALUE); VALUE rb_ary_cmp(VALUE, VALUE); VALUE rb_ary_replace(VALUE copy, VALUE orig); -VALUE rb_get_values_at(VALUE, long, int, VALUE*, VALUE(*)(VALUE,long)); +VALUE rb_get_values_at(VALUE, long, int, const VALUE*, VALUE(*)(VALUE,long)); VALUE rb_ary_resize(VALUE ary, long len); +#define rb_ary_new2 rb_ary_new_capa +#define rb_ary_new3 rb_ary_new_from_args +#define rb_ary_new4 rb_ary_new_from_values /* bignum.c */ -VALUE rb_big_new(long, int); +VALUE rb_big_new(size_t, int); int rb_bigzero_p(VALUE x); VALUE rb_big_clone(VALUE); void rb_big_2comp(VALUE); VALUE rb_big_norm(VALUE); -void rb_big_resize(VALUE big, long len); -VALUE rb_uint2big(VALUE); -VALUE rb_int2big(SIGNED_VALUE); -VALUE rb_uint2inum(VALUE); -VALUE rb_int2inum(SIGNED_VALUE); +void rb_big_resize(VALUE big, size_t len); VALUE rb_cstr_to_inum(const char*, int, int); VALUE rb_str_to_inum(VALUE, int, int); VALUE rb_cstr2inum(const char*, int); VALUE rb_str2inum(VALUE, int); VALUE rb_big2str(VALUE, int); -VALUE rb_big2str0(VALUE, int, int); -SIGNED_VALUE rb_big2long(VALUE); +long rb_big2long(VALUE); #define rb_big2int(x) rb_big2long(x) -VALUE rb_big2ulong(VALUE); +unsigned long rb_big2ulong(VALUE); #define rb_big2uint(x) rb_big2ulong(x) -VALUE rb_big2ulong_pack(VALUE x); #if HAVE_LONG_LONG -VALUE rb_ll2inum(LONG_LONG); -VALUE rb_ull2inum(unsigned LONG_LONG); LONG_LONG rb_big2ll(VALUE); unsigned LONG_LONG rb_big2ull(VALUE); #endif /* HAVE_LONG_LONG */ -DEPRECATED(void rb_quad_pack(char*,VALUE)); -DEPRECATED(VALUE rb_quad_unpack(const char*,int)); void rb_big_pack(VALUE val, unsigned long *buf, long num_longs); VALUE rb_big_unpack(unsigned long *buf, long num_longs); int rb_uv_to_utf8(char[6],unsigned long); @@ -123,6 +117,7 @@ VALUE rb_dbl2big(double); double rb_big2dbl(VALUE); VALUE rb_big_cmp(VALUE, VALUE); VALUE rb_big_eq(VALUE, VALUE); +VALUE rb_big_eql(VALUE, VALUE); VALUE rb_big_plus(VALUE, VALUE); VALUE rb_big_minus(VALUE, VALUE); VALUE rb_big_mul(VALUE, VALUE); @@ -136,6 +131,34 @@ VALUE rb_big_or(VALUE, VALUE); VALUE rb_big_xor(VALUE, VALUE); VALUE rb_big_lshift(VALUE, VALUE); VALUE rb_big_rshift(VALUE, VALUE); +VALUE rb_big_hash(VALUE); + +/* For rb_integer_pack and rb_integer_unpack: */ +/* "MS" in MSWORD and MSBYTE means "most significant" */ +/* "LS" in LSWORD and LSBYTE means "least significant" */ +#define INTEGER_PACK_MSWORD_FIRST 0x01 +#define INTEGER_PACK_LSWORD_FIRST 0x02 +#define INTEGER_PACK_MSBYTE_FIRST 0x10 +#define INTEGER_PACK_LSBYTE_FIRST 0x20 +#define INTEGER_PACK_NATIVE_BYTE_ORDER 0x40 +#define INTEGER_PACK_2COMP 0x80 +#define INTEGER_PACK_FORCE_GENERIC_IMPLEMENTATION 0x400 +/* For rb_integer_unpack: */ +#define INTEGER_PACK_FORCE_BIGNUM 0x100 +#define INTEGER_PACK_NEGATIVE 0x200 +/* Combinations: */ +#define INTEGER_PACK_LITTLE_ENDIAN \ + (INTEGER_PACK_LSWORD_FIRST | \ + INTEGER_PACK_LSBYTE_FIRST) +#define INTEGER_PACK_BIG_ENDIAN \ + (INTEGER_PACK_MSWORD_FIRST | \ + INTEGER_PACK_MSBYTE_FIRST) +int rb_integer_pack(VALUE val, void *words, size_t numwords, size_t wordsize, size_t nails, int flags); +VALUE rb_integer_unpack(const void *words, size_t numwords, size_t wordsize, size_t nails, int flags); +size_t rb_absint_size(VALUE val, int *nlz_bits_ret); +size_t rb_absint_numwords(VALUE val, size_t word_numbits, size_t *nlz_bits_ret); +int rb_absint_singlebit_p(VALUE val); + /* rational.c */ VALUE rb_rational_raw(VALUE, VALUE); #define rb_rational_raw1(x) rb_rational_raw((x), INT2FIX(1)) @@ -146,6 +169,10 @@ VALUE rb_rational_new(VALUE, VALUE); VALUE rb_Rational(VALUE, VALUE); #define rb_Rational1(x) rb_Rational((x), INT2FIX(1)) #define rb_Rational2(x,y) rb_Rational((x), (y)) +VALUE rb_rational_num(VALUE rat); +VALUE rb_rational_den(VALUE rat); +VALUE rb_flt_rationalize_with_prec(VALUE, VALUE); +VALUE rb_flt_rationalize(VALUE); /* complex.c */ VALUE rb_complex_raw(VALUE, VALUE); #define rb_complex_raw1(x) rb_complex_raw((x), INT2FIX(0)) @@ -157,11 +184,12 @@ VALUE rb_complex_polar(VALUE, VALUE); VALUE rb_Complex(VALUE, VALUE); #define rb_Complex1(x) rb_Complex((x), INT2FIX(0)) #define rb_Complex2(x,y) rb_Complex((x), (y)) +DEPRECATED(VALUE rb_complex_set_real(VALUE, VALUE)); +DEPRECATED(VALUE rb_complex_set_imag(VALUE, VALUE)); /* class.c */ VALUE rb_class_boot(VALUE); VALUE rb_class_new(VALUE); VALUE rb_mod_init_copy(VALUE, VALUE); -VALUE rb_class_init_copy(VALUE, VALUE); VALUE rb_singleton_class_clone(VALUE); void rb_singleton_class_attached(VALUE,VALUE); VALUE rb_make_metaclass(VALUE, VALUE); @@ -176,11 +204,11 @@ VALUE rb_include_class_new(VALUE, VALUE); VALUE rb_mod_included_modules(VALUE); VALUE rb_mod_include_p(VALUE, VALUE); VALUE rb_mod_ancestors(VALUE); -VALUE rb_class_instance_methods(int, VALUE*, VALUE); -VALUE rb_class_public_instance_methods(int, VALUE*, VALUE); -VALUE rb_class_protected_instance_methods(int, VALUE*, VALUE); -VALUE rb_class_private_instance_methods(int, VALUE*, VALUE); -VALUE rb_obj_singleton_methods(int, VALUE*, VALUE); +VALUE rb_class_instance_methods(int, const VALUE*, VALUE); +VALUE rb_class_public_instance_methods(int, const VALUE*, VALUE); +VALUE rb_class_protected_instance_methods(int, const VALUE*, VALUE); +VALUE rb_class_private_instance_methods(int, const VALUE*, VALUE); +VALUE rb_obj_singleton_methods(int, const VALUE*, VALUE); void rb_define_method_id(VALUE, ID, VALUE (*)(ANYARGS), int); void rb_frozen_class_p(VALUE); void rb_undef(VALUE, ID); @@ -193,47 +221,54 @@ int rb_cmpint(VALUE, VALUE, VALUE); NORETURN(void rb_cmperr(VALUE, VALUE)); /* cont.c */ VALUE rb_fiber_new(VALUE (*)(ANYARGS), VALUE); -VALUE rb_fiber_resume(VALUE fib, int argc, VALUE *args); -VALUE rb_fiber_yield(int argc, VALUE *args); +VALUE rb_fiber_resume(VALUE fib, int argc, const VALUE *argv); +VALUE rb_fiber_yield(int argc, const VALUE *argv); VALUE rb_fiber_current(void); VALUE rb_fiber_alive_p(VALUE); /* enum.c */ -VALUE rb_enum_values_pack(int, VALUE*); +VALUE rb_enum_values_pack(int, const VALUE*); /* enumerator.c */ -VALUE rb_enumeratorize(VALUE, VALUE, int, VALUE *); -#define RETURN_ENUMERATOR(obj, argc, argv) do { \ +VALUE rb_enumeratorize(VALUE, VALUE, int, const VALUE *); +typedef VALUE rb_enumerator_size_func(VALUE, VALUE, VALUE); +VALUE rb_enumeratorize_with_size(VALUE, VALUE, int, const VALUE *, rb_enumerator_size_func *); +#ifndef RUBY_EXPORT +#define rb_enumeratorize_with_size(obj, id, argc, argv, size_fn) \ + rb_enumeratorize_with_size(obj, id, argc, argv, (rb_enumerator_size_func *)(size_fn)) +#endif +#define SIZED_ENUMERATOR(obj, argc, argv, size_fn) \ + rb_enumeratorize_with_size((obj), ID2SYM(rb_frame_this_func()), \ + (argc), (argv), (size_fn)) +#define RETURN_SIZED_ENUMERATOR(obj, argc, argv, size_fn) do { \ if (!rb_block_given_p()) \ - return rb_enumeratorize((obj), ID2SYM(rb_frame_this_func()),\ - (argc), (argv)); \ + return SIZED_ENUMERATOR(obj, argc, argv, size_fn); \ } while (0) +#define RETURN_ENUMERATOR(obj, argc, argv) RETURN_SIZED_ENUMERATOR(obj, argc, argv, 0) /* error.c */ VALUE rb_exc_new(VALUE, const char*, long); -VALUE rb_exc_new2(VALUE, const char*); -VALUE rb_exc_new3(VALUE, VALUE); +VALUE rb_exc_new_cstr(VALUE, const char*); +VALUE rb_exc_new_str(VALUE, VALUE); +#define rb_exc_new2 rb_exc_new_cstr +#define rb_exc_new3 rb_exc_new_str PRINTF_ARGS(NORETURN(void rb_loaderror(const char*, ...)), 1, 2); PRINTF_ARGS(NORETURN(void rb_loaderror_with_path(VALUE path, const char*, ...)), 2, 3); PRINTF_ARGS(NORETURN(void rb_name_error(ID, const char*, ...)), 2, 3); PRINTF_ARGS(NORETURN(void rb_name_error_str(VALUE, const char*, ...)), 2, 3); NORETURN(void rb_invalid_str(const char*, const char*)); -PRINTF_ARGS(void rb_compile_error(const char*, int, const char*, ...), 3, 4); -PRINTF_ARGS(void rb_compile_error_with_enc(const char*, int, void *, const char*, ...), 4, 5); -PRINTF_ARGS(void rb_compile_error_append(const char*, ...), 1, 2); +DEPRECATED(PRINTF_ARGS(void rb_compile_error(const char*, int, const char*, ...), 3, 4)); +DEPRECATED(PRINTF_ARGS(void rb_compile_error_with_enc(const char*, int, void *, const char*, ...), 4, 5)); +DEPRECATED(PRINTF_ARGS(void rb_compile_error_append(const char*, ...), 1, 2)); NORETURN(void rb_error_frozen(const char*)); +NORETURN(void rb_error_frozen_object(VALUE)); void rb_error_untrusted(VALUE); void rb_check_frozen(VALUE); void rb_check_trusted(VALUE); #define rb_check_frozen_internal(obj) do { \ VALUE frozen_obj = (obj); \ if (OBJ_FROZEN(frozen_obj)) { \ - rb_error_frozen(rb_obj_classname(frozen_obj)); \ - } \ - } while (0) -#define rb_check_trusted_internal(obj) do { \ - VALUE untrusted_obj = (obj); \ - if (!OBJ_UNTRUSTED(untrusted_obj)) { \ - rb_error_untrusted(untrusted_obj); \ + rb_error_frozen_object(frozen_obj); \ } \ } while (0) +#define rb_check_trusted_internal(obj) ((void) 0) #ifdef __GNUC__ #define rb_check_frozen(obj) __extension__({rb_check_frozen_internal(obj);}) #define rb_check_trusted(obj) __extension__({rb_check_trusted_internal(obj);}) @@ -253,19 +288,23 @@ rb_check_trusted_inline(VALUE obj) #endif void rb_check_copyable(VALUE obj, VALUE orig); -#define OBJ_INIT_COPY(obj, orig) \ +#define RB_OBJ_INIT_COPY(obj, orig) \ ((obj) != (orig) && (rb_obj_init_copy((obj), (orig)), 1)) +#define OBJ_INIT_COPY(obj, orig) RB_OBJ_INIT_COPY(obj, orig) /* eval.c */ int rb_sourceline(void); const char *rb_sourcefile(void); -VALUE rb_check_funcall(VALUE, ID, int, VALUE*); +VALUE rb_check_funcall(VALUE, ID, int, const VALUE*); NORETURN(void rb_error_arity(int, int, int)); -#define rb_check_arity(argc, min, max) do { \ - if (((argc) < (min)) || ((argc) > (max) && (max) != UNLIMITED_ARGUMENTS)) \ - rb_error_arity(argc, min, max); \ - } while(0) +#define rb_check_arity rb_check_arity /* for ifdef */ +static inline void +rb_check_arity(int argc, int min, int max) +{ + if ((argc < min) || (max != UNLIMITED_ARGUMENTS && argc > max)) + rb_error_arity(argc, min, max); +} #if defined(NFDBITS) && defined(HAVE_RB_FD_INIT) typedef struct { @@ -281,6 +320,8 @@ void rb_fd_clr(int, rb_fdset_t *); int rb_fd_isset(int, const rb_fdset_t *); void rb_fd_copy(rb_fdset_t *, const fd_set *, int); void rb_fd_dup(rb_fdset_t *dst, const rb_fdset_t *src); + +struct timeval; int rb_fd_select(int, rb_fdset_t *, rb_fdset_t *, rb_fdset_t *, struct timeval *); #define rb_fd_ptr(f) ((f)->fdset) @@ -330,19 +371,30 @@ typedef fd_set rb_fdset_t; NORETURN(void rb_exc_raise(VALUE)); NORETURN(void rb_exc_fatal(VALUE)); -VALUE rb_f_exit(int,VALUE*); -VALUE rb_f_abort(int,VALUE*); +VALUE rb_f_exit(int, const VALUE*); +VALUE rb_f_abort(int, const VALUE*); void rb_remove_method(VALUE, const char*); void rb_remove_method_id(VALUE, ID); -#define rb_disable_super(klass, name) ((void)0) -#define rb_enable_super(klass, name) ((void)0) +DEPRECATED(static inline void rb_disable_super(void)); +DEPRECATED(static inline void rb_enable_super(void)); +static inline void rb_disable_super(void) +{ + /* obsolete - no use */ +} +static inline void rb_enable_super(void) +{ + rb_warning("rb_enable_super() is obsolete"); +} +#define rb_disable_super(klass, name) rb_disable_super() +#define rb_enable_super(klass, name) rb_enable_super() #define HAVE_RB_DEFINE_ALLOC_FUNC 1 typedef VALUE (*rb_alloc_func_t)(VALUE); void rb_define_alloc_func(VALUE, rb_alloc_func_t); void rb_undef_alloc_func(VALUE); rb_alloc_func_t rb_get_alloc_func(VALUE); -void rb_clear_cache(void); -void rb_clear_cache_by_class(VALUE); +DEPRECATED(void rb_clear_cache(void)); +void rb_clear_constant_cache(void); +void rb_clear_method_cache_by_class(VALUE); void rb_alias(VALUE, ID, ID); void rb_attr(VALUE,ID,int,int,int); int rb_method_boundp(VALUE, ID, int); @@ -350,15 +402,19 @@ int rb_method_basic_definition_p(VALUE, ID); VALUE rb_eval_cmd(VALUE, VALUE, int); int rb_obj_respond_to(VALUE, ID, int); int rb_respond_to(VALUE, ID); -VALUE rb_f_notimplement(int argc, VALUE *argv, VALUE obj); +VALUE rb_f_notimplement(int argc, const VALUE *argv, VALUE obj); +#if !defined(RUBY_EXPORT) && defined(_WIN32) +RUBY_EXTERN VALUE (*const rb_f_notimplement_)(int, const VALUE *, VALUE); +#define rb_f_notimplement (*rb_f_notimplement_) +#endif void rb_interrupt(void); VALUE rb_apply(VALUE, ID, VALUE); void rb_backtrace(void); ID rb_frame_this_func(void); -VALUE rb_obj_instance_eval(int, VALUE*, VALUE); -VALUE rb_obj_instance_exec(int, VALUE*, VALUE); -VALUE rb_mod_module_eval(int, VALUE*, VALUE); -VALUE rb_mod_module_exec(int, VALUE*, VALUE); +VALUE rb_obj_instance_eval(int, const VALUE*, VALUE); +VALUE rb_obj_instance_exec(int, const VALUE*, VALUE); +VALUE rb_mod_module_eval(int, const VALUE*, VALUE); +VALUE rb_mod_module_exec(int, const VALUE*, VALUE); void rb_load(VALUE, int); void rb_load_protect(VALUE, int, int*); NORETURN(void rb_jump_tag(int)); @@ -367,20 +423,21 @@ int rb_feature_provided(const char *, const char **); void rb_provide(const char*); VALUE rb_f_require(VALUE, VALUE); VALUE rb_require_safe(VALUE, int); -void rb_obj_call_init(VALUE, int, VALUE*); -VALUE rb_class_new_instance(int, VALUE*, VALUE); +void rb_obj_call_init(VALUE, int, const VALUE*); +VALUE rb_class_new_instance(int, const VALUE*, VALUE); VALUE rb_block_proc(void); -VALUE rb_f_lambda(void); +VALUE rb_block_lambda(void); VALUE rb_proc_new(VALUE (*)(ANYARGS/* VALUE yieldarg[, VALUE procarg] */), VALUE); VALUE rb_obj_is_proc(VALUE); VALUE rb_proc_call(VALUE, VALUE); -VALUE rb_proc_call_with_block(VALUE, int argc, VALUE *argv, VALUE); +VALUE rb_proc_call_with_block(VALUE, int argc, const VALUE *argv, VALUE); int rb_proc_arity(VALUE); VALUE rb_proc_lambda_p(VALUE); VALUE rb_binding_new(void); VALUE rb_obj_method(VALUE, VALUE); VALUE rb_obj_is_method(VALUE); -VALUE rb_method_call(int, VALUE*, VALUE); +VALUE rb_method_call(int, const VALUE*, VALUE); +VALUE rb_method_call_with_block(int, const VALUE *, VALUE, VALUE); int rb_mod_method_arity(VALUE, ID); int rb_obj_method_arity(VALUE, ID); VALUE rb_protect(VALUE (*)(VALUE), VALUE, int*); @@ -391,16 +448,15 @@ void rb_thread_wait_fd(int); int rb_thread_fd_writable(int); void rb_thread_fd_close(int); int rb_thread_alone(void); -void rb_thread_polling(void); void rb_thread_sleep(int); void rb_thread_sleep_forever(void); +void rb_thread_sleep_deadly(void); VALUE rb_thread_stop(void); VALUE rb_thread_wakeup(VALUE); VALUE rb_thread_wakeup_alive(VALUE); VALUE rb_thread_run(VALUE); VALUE rb_thread_kill(VALUE); VALUE rb_thread_create(VALUE (*)(ANYARGS), void*); -DEPRECATED(int rb_thread_select(int, fd_set *, fd_set *, fd_set *, struct timeval *)); int rb_thread_fd_select(int, rb_fdset_t *, rb_fdset_t *, rb_fdset_t *, struct timeval *); void rb_thread_wait_for(struct timeval); VALUE rb_thread_current(void); @@ -412,12 +468,13 @@ void rb_thread_atfork_before_exec(void); VALUE rb_exec_recursive(VALUE(*)(VALUE, VALUE, int),VALUE,VALUE); VALUE rb_exec_recursive_paired(VALUE(*)(VALUE, VALUE, int),VALUE,VALUE,VALUE); VALUE rb_exec_recursive_outer(VALUE(*)(VALUE, VALUE, int),VALUE,VALUE); +VALUE rb_exec_recursive_paired_outer(VALUE(*)(VALUE, VALUE, int),VALUE,VALUE,VALUE); /* dir.c */ VALUE rb_dir_getwd(void); /* file.c */ -VALUE rb_file_s_expand_path(int, VALUE *); +VALUE rb_file_s_expand_path(int, const VALUE *); VALUE rb_file_expand_path(VALUE, VALUE); -VALUE rb_file_s_absolute_path(int, VALUE *); +VALUE rb_file_s_absolute_path(int, const VALUE *); VALUE rb_file_absolute_path(VALUE, VALUE); VALUE rb_file_dirname(VALUE fname); int rb_find_file_ext_safe(VALUE*, const char* const*, int); @@ -430,7 +487,7 @@ int rb_is_absolute_path(const char *); /* gc.c */ NORETURN(void rb_memerror(void)); int rb_during_gc(void); -void rb_gc_mark_locations(VALUE*, VALUE*); +void rb_gc_mark_locations(const VALUE*, const VALUE*); void rb_mark_tbl(struct st_table*); void rb_mark_set(struct st_table*); void rb_mark_hash(struct st_table*); @@ -444,7 +501,11 @@ void rb_gc_call_finalizer_at_exit(void); VALUE rb_gc_enable(void); VALUE rb_gc_disable(void); VALUE rb_gc_start(void); -void rb_gc_set_params(void); +VALUE rb_define_finalizer(VALUE, VALUE); +VALUE rb_undefine_finalizer(VALUE); +size_t rb_gc_count(void); +size_t rb_gc_stat(VALUE); +VALUE rb_gc_latest_gc_info(VALUE); /* hash.c */ void st_foreach_safe(struct st_table *, int (*)(ANYARGS), st_data_t); VALUE rb_check_hash_type(VALUE); @@ -458,14 +519,19 @@ VALUE rb_hash_lookup(VALUE, VALUE); VALUE rb_hash_lookup2(VALUE, VALUE, VALUE); VALUE rb_hash_fetch(VALUE, VALUE); VALUE rb_hash_aset(VALUE, VALUE, VALUE); +VALUE rb_hash_clear(VALUE); VALUE rb_hash_delete_if(VALUE); VALUE rb_hash_delete(VALUE,VALUE); +VALUE rb_hash_set_ifnone(VALUE hash, VALUE ifnone); typedef VALUE rb_hash_update_func(VALUE newkey, VALUE oldkey, VALUE value); VALUE rb_hash_update_by(VALUE hash1, VALUE hash2, rb_hash_update_func *func); struct st_table *rb_hash_tbl(VALUE); int rb_path_check(const char*); int rb_env_path_tainted(void); VALUE rb_env_clear(void); +VALUE rb_hash_size(VALUE); +DEPRECATED(int rb_hash_iter_lev(VALUE)); +DEPRECATED(VALUE rb_hash_ifnone(VALUE)); /* io.c */ #define rb_defout rb_stdout RUBY_EXTERN VALUE rb_fs; @@ -484,9 +550,9 @@ VALUE rb_io_eof(VALUE); VALUE rb_io_binmode(VALUE); VALUE rb_io_ascii8bit_binmode(VALUE); VALUE rb_io_addstr(VALUE, VALUE); -VALUE rb_io_printf(int, VALUE*, VALUE); -VALUE rb_io_print(int, VALUE*, VALUE); -VALUE rb_io_puts(int, VALUE*, VALUE); +VALUE rb_io_printf(int, const VALUE*, VALUE); +VALUE rb_io_print(int, const VALUE*, VALUE); +VALUE rb_io_puts(int, const VALUE*, VALUE); VALUE rb_io_fdopen(int, int, const char*); VALUE rb_io_get_io(VALUE); VALUE rb_file_open(const char*, const char*); @@ -515,6 +581,7 @@ NORETURN(void rb_num_zerodiv(void)); VALUE rb_num_coerce_bin(VALUE, VALUE, ID); VALUE rb_num_coerce_cmp(VALUE, VALUE, ID); VALUE rb_num_coerce_relop(VALUE, VALUE, ID); +VALUE rb_num_coerce_bit(VALUE, VALUE, ID); VALUE rb_num2fix(VALUE); VALUE rb_fix2str(VALUE, int); VALUE rb_dbl_cmp(double, double); @@ -557,8 +624,6 @@ VALUE rb_Hash(VALUE); double rb_cstr_to_dbl(const char*, int); double rb_str_to_dbl(VALUE, int); /* parse.y */ -RUBY_EXTERN int ruby_sourceline; -RUBY_EXTERN char *ruby_sourcefile; ID rb_id_attrset(ID); int rb_is_const_id(ID); int rb_is_global_id(ID); @@ -573,29 +638,15 @@ VALUE rb_backref_get(void); void rb_backref_set(VALUE); VALUE rb_lastline_get(void); void rb_lastline_set(VALUE); -VALUE rb_sym_all_symbols(void); /* process.c */ void rb_last_status_set(int status, rb_pid_t pid); VALUE rb_last_status_get(void); -struct rb_exec_arg { - VALUE execarg_obj; -}; -DEPRECATED(int rb_proc_exec_n(int, VALUE*, const char*)); int rb_proc_exec(const char*); -DEPRECATED(VALUE rb_exec_arg_init(int argc, VALUE *argv, int accept_shell, struct rb_exec_arg *e)); -DEPRECATED(int rb_exec_arg_addopt(struct rb_exec_arg *e, VALUE key, VALUE val)); -DEPRECATED(void rb_exec_arg_fixup(struct rb_exec_arg *e)); -DEPRECATED(int rb_run_exec_options(const struct rb_exec_arg *e, struct rb_exec_arg *s)); -DEPRECATED(int rb_run_exec_options_err(const struct rb_exec_arg *e, struct rb_exec_arg *s, char*, size_t)); -DEPRECATED(int rb_exec(const struct rb_exec_arg*)); -DEPRECATED(int rb_exec_err(const struct rb_exec_arg*, char*, size_t)); -DEPRECATED(rb_pid_t rb_fork(int*, int (*)(void*), void*, VALUE)); -DEPRECATED(rb_pid_t rb_fork_err(int*, int (*)(void*, char*, size_t), void*, VALUE, char*, size_t)); -VALUE rb_f_exec(int,VALUE*); +VALUE rb_f_exec(int, const VALUE*); rb_pid_t rb_waitpid(rb_pid_t pid, int *status, int flags); void rb_syswait(rb_pid_t pid); -rb_pid_t rb_spawn(int, VALUE*); -rb_pid_t rb_spawn_err(int, VALUE*, char*, size_t); +rb_pid_t rb_spawn(int, const VALUE*); +rb_pid_t rb_spawn_err(int, const VALUE*, char*, size_t); VALUE rb_proc_times(VALUE); VALUE rb_detach_process(rb_pid_t pid); /* range.c */ @@ -636,8 +687,9 @@ int rb_reg_options(VALUE); RUBY_EXTERN VALUE rb_argv0; VALUE rb_get_argv(void); void *rb_load_file(const char*); +void *rb_load_file_str(VALUE); /* signal.c */ -VALUE rb_f_kill(int, VALUE*); +VALUE rb_f_kill(int, const VALUE*); #ifdef POSIX_SIGNAL #define posix_signal ruby_posix_signal RETSIGTYPE (*posix_signal(int, RETSIGTYPE (*)(int)))(int); @@ -656,16 +708,11 @@ VALUE rb_str_format(int, const VALUE *, VALUE); /* string.c */ VALUE rb_str_new(const char*, long); VALUE rb_str_new_cstr(const char*); -VALUE rb_str_new2(const char*); VALUE rb_str_new_shared(VALUE); -VALUE rb_str_new3(VALUE); VALUE rb_str_new_frozen(VALUE); -VALUE rb_str_new4(VALUE); VALUE rb_str_new_with_class(VALUE, const char*, long); -VALUE rb_str_new5(VALUE, const char*, long); VALUE rb_tainted_str_new_cstr(const char*); VALUE rb_tainted_str_new(const char*, long); -VALUE rb_tainted_str_new2(const char*); VALUE rb_external_str_new(const char*, long); VALUE rb_external_str_new_cstr(const char*); VALUE rb_locale_str_new(const char*, long); @@ -678,7 +725,11 @@ VALUE rb_str_buf_new2(const char*); VALUE rb_str_tmp_new(long); VALUE rb_usascii_str_new(const char*, long); VALUE rb_usascii_str_new_cstr(const char*); -VALUE rb_usascii_str_new2(const char*); +VALUE rb_utf8_str_new(const char*, long); +VALUE rb_utf8_str_new_cstr(const char*); +VALUE rb_str_new_static(const char *, long); +VALUE rb_usascii_str_new_static(const char *, long); +VALUE rb_utf8_str_new_static(const char *, long); void rb_str_free(VALUE); void rb_str_shared_replace(VALUE, VALUE); VALUE rb_str_buf_append(VALUE, VALUE); @@ -699,12 +750,14 @@ VALUE rb_str_times(VALUE, VALUE); long rb_str_sublen(VALUE, long); VALUE rb_str_substr(VALUE, long, long); VALUE rb_str_subseq(VALUE, long, long); +char *rb_str_subpos(VALUE, long, long*); void rb_str_modify(VALUE); void rb_str_modify_expand(VALUE, long); VALUE rb_str_freeze(VALUE); void rb_str_set_len(VALUE, long); VALUE rb_str_resize(VALUE, long); VALUE rb_str_cat(VALUE, const char*, long); +VALUE rb_str_cat_cstr(VALUE, const char*); VALUE rb_str_cat2(VALUE, const char*); VALUE rb_str_append(VALUE, VALUE); VALUE rb_str_concat(VALUE, VALUE); @@ -727,8 +780,8 @@ VALUE rb_str_replace(VALUE, VALUE); VALUE rb_str_inspect(VALUE); VALUE rb_str_dump(VALUE); VALUE rb_str_split(VALUE, const char*); -void rb_str_associate(VALUE, VALUE); -VALUE rb_str_associated(VALUE); +DEPRECATED(void rb_str_associate(VALUE, VALUE)); +DEPRECATED(VALUE rb_str_associated(VALUE)); void rb_str_setter(VALUE, ID, VALUE*); VALUE rb_str_intern(VALUE); VALUE rb_sym_to_s(VALUE); @@ -737,13 +790,35 @@ VALUE rb_str_length(VALUE); long rb_str_offset(VALUE, long); size_t rb_str_capacity(VALUE); VALUE rb_str_ellipsize(VALUE, long); +VALUE rb_str_scrub(VALUE, VALUE); +/* symbol.c */ +VALUE rb_sym_all_symbols(void); + #if defined(__GNUC__) && !defined(__PCC__) +#define rb_str_new(str, len) __extension__ ( \ +{ \ + (__builtin_constant_p(str) && __builtin_constant_p(len)) ? \ + rb_str_new_static((str), (len)) : \ + rb_str_new((str), (len)); \ +}) #define rb_str_new_cstr(str) __extension__ ( \ { \ (__builtin_constant_p(str)) ? \ - rb_str_new((str), (long)strlen(str)) : \ + rb_str_new_static((str), (long)strlen(str)) : \ rb_str_new_cstr(str); \ }) +#define rb_usascii_str_new(str, len) __extension__ ( \ +{ \ + (__builtin_constant_p(str) && __builtin_constant_p(len)) ? \ + rb_usascii_str_new_static((str), (len)) : \ + rb_usascii_str_new((str), (len)); \ +}) +#define rb_utf8_str_new(str, len) __extension__ ( \ +{ \ + (__builtin_constant_p(str) && __builtin_constant_p(len)) ? \ + rb_utf8_str_new_static((str), (len)) : \ + rb_utf8_str_new((str), (len)); \ +}) #define rb_tainted_str_new_cstr(str) __extension__ ( \ { \ (__builtin_constant_p(str)) ? \ @@ -753,9 +828,15 @@ VALUE rb_str_ellipsize(VALUE, long); #define rb_usascii_str_new_cstr(str) __extension__ ( \ { \ (__builtin_constant_p(str)) ? \ - rb_usascii_str_new((str), (long)strlen(str)) : \ + rb_usascii_str_new_static((str), (long)strlen(str)) : \ rb_usascii_str_new_cstr(str); \ }) +#define rb_utf8_str_new_cstr(str) __extension__ ( \ +{ \ + (__builtin_constant_p(str)) ? \ + rb_utf8_str_new_static((str), (long)strlen(str)) : \ + rb_utf8_str_new_cstr(str); \ +}) #define rb_external_str_new_cstr(str) __extension__ ( \ { \ (__builtin_constant_p(str)) ? \ @@ -775,23 +856,17 @@ VALUE rb_str_ellipsize(VALUE, long); (str), (long)strlen(str)) : \ rb_str_buf_new_cstr(str); \ }) -#define rb_str_buf_cat2(str, ptr) __extension__ ( \ -{ \ - (__builtin_constant_p(ptr)) ? \ - rb_str_buf_cat((str), (ptr), (long)strlen(ptr)) : \ - rb_str_buf_cat2((str), (ptr)); \ -}) -#define rb_str_cat2(str, ptr) __extension__ ( \ +#define rb_str_cat_cstr(str, ptr) __extension__ ( \ { \ (__builtin_constant_p(ptr)) ? \ rb_str_cat((str), (ptr), (long)strlen(ptr)) : \ - rb_str_cat2((str), (ptr)); \ + rb_str_cat_cstr((str), (ptr)); \ }) -#define rb_exc_new2(klass, ptr) __extension__ ( \ +#define rb_exc_new_cstr(klass, ptr) __extension__ ( \ { \ (__builtin_constant_p(ptr)) ? \ rb_exc_new((klass), (ptr), (long)strlen(ptr)) : \ - rb_exc_new2((klass), (ptr)); \ + rb_exc_new_cstr((klass), (ptr)); \ }) #endif #define rb_str_new2 rb_str_new_cstr @@ -801,28 +876,40 @@ VALUE rb_str_ellipsize(VALUE, long); #define rb_tainted_str_new2 rb_tainted_str_new_cstr #define rb_str_buf_new2 rb_str_buf_new_cstr #define rb_usascii_str_new2 rb_usascii_str_new_cstr +#define rb_str_buf_cat rb_str_cat +#define rb_str_buf_cat2 rb_str_cat_cstr +#define rb_str_cat2 rb_str_cat_cstr +#define rb_strlen_lit(str) (sizeof(str "") - 1) +#define rb_str_new_lit(str) rb_str_new_static((str), rb_strlen_lit(str)) +#define rb_usascii_str_new_lit(str) rb_usascii_str_new_static((str), rb_strlen_lit(str)) +#define rb_utf8_str_new_lit(str) rb_utf8_str_new_static((str), rb_strlen_lit(str)) +#define rb_enc_str_new_lit(str, enc) rb_enc_str_new_static((str), rb_strlen_lit(str), (enc)) +#define rb_str_new_literal(str) rb_str_new_lit(str) +#define rb_usascii_str_new_literal(str) rb_usascii_str_new_lit(str) +#define rb_utf8_str_new_literal(str) rb_utf8_str_new_lit(str) +#define rb_enc_str_new_literal(str, enc) rb_enc_str_new_lit(str, enc) + /* struct.c */ VALUE rb_struct_new(VALUE, ...); VALUE rb_struct_define(const char*, ...); +VALUE rb_struct_define_under(VALUE, const char*, ...); VALUE rb_struct_alloc(VALUE, VALUE); VALUE rb_struct_initialize(VALUE, VALUE); VALUE rb_struct_aref(VALUE, VALUE); VALUE rb_struct_aset(VALUE, VALUE, VALUE); VALUE rb_struct_getmember(VALUE, ID); -DEPRECATED(VALUE rb_struct_iv_get(VALUE, const char*)); VALUE rb_struct_s_members(VALUE); VALUE rb_struct_members(VALUE); VALUE rb_struct_alloc_noinit(VALUE); VALUE rb_struct_define_without_accessor(const char *, VALUE, rb_alloc_func_t, ...); +VALUE rb_struct_define_without_accessor_under(VALUE outer, const char *class_name, VALUE super, rb_alloc_func_t alloc, ...); + /* thread.c */ typedef void rb_unblock_function_t(void *); typedef VALUE rb_blocking_function_t(void *); void rb_thread_check_ints(void); int rb_thread_interrupted(VALUE thval); -/* Use rb_thread_call_without_gvl family instead. */ -DEPRECATED(VALUE rb_thread_blocking_region(rb_blocking_function_t *func, void *data1, - rb_unblock_function_t *ubf, void *data2)); #define RUBY_UBF_IO ((rb_unblock_function_t *)-1) #define RUBY_UBF_PROCESS ((rb_unblock_function_t *)-1) VALUE rb_mutex_new(void); @@ -833,8 +920,10 @@ VALUE rb_mutex_unlock(VALUE mutex); VALUE rb_mutex_sleep(VALUE self, VALUE timeout); VALUE rb_mutex_synchronize(VALUE mutex, VALUE (*func)(VALUE arg), VALUE arg); /* time.c */ +void rb_timespec_now(struct timespec *); VALUE rb_time_new(time_t, long); VALUE rb_time_nano_new(time_t, long); +VALUE rb_time_timespec_new(const struct timespec *, int); VALUE rb_time_num_new(VALUE, VALUE); struct timeval rb_time_interval(VALUE num); struct timeval rb_time_timeval(VALUE time); @@ -842,20 +931,21 @@ struct timespec rb_time_timespec(VALUE time); /* variable.c */ VALUE rb_mod_name(VALUE); VALUE rb_class_path(VALUE); +VALUE rb_class_path_cached(VALUE); void rb_set_class_path(VALUE, VALUE, const char*); void rb_set_class_path_string(VALUE, VALUE, VALUE); VALUE rb_path_to_class(VALUE); VALUE rb_path2class(const char*); void rb_name_class(VALUE, ID); VALUE rb_class_name(VALUE); -void rb_autoload(VALUE, ID, const char*); +DEPRECATED(void rb_autoload(VALUE, ID, const char*)); VALUE rb_autoload_load(VALUE, ID); VALUE rb_autoload_p(VALUE, ID); -VALUE rb_f_trace_var(int, VALUE*); -VALUE rb_f_untrace_var(int, VALUE*); +VALUE rb_f_trace_var(int, const VALUE*); +VALUE rb_f_untrace_var(int, const VALUE*); VALUE rb_f_global_variables(void); void rb_alias_variable(ID, ID); -struct st_table* rb_generic_ivar_table(VALUE); +DEPRECATED(struct st_table* rb_generic_ivar_table(VALUE)); void rb_copy_generic_ivar(VALUE,VALUE); void rb_free_generic_ivar(VALUE); VALUE rb_ivar_get(VALUE, ID); @@ -863,15 +953,13 @@ VALUE rb_ivar_set(VALUE, ID, VALUE); VALUE rb_ivar_defined(VALUE, ID); void rb_ivar_foreach(VALUE, int (*)(ANYARGS), st_data_t); st_index_t rb_ivar_count(VALUE); -VALUE rb_iv_set(VALUE, const char*, VALUE); -VALUE rb_iv_get(VALUE, const char*); VALUE rb_attr_get(VALUE, ID); VALUE rb_obj_instance_variables(VALUE); VALUE rb_obj_remove_instance_variable(VALUE, VALUE); void *rb_mod_const_at(VALUE, void*); void *rb_mod_const_of(VALUE, void*); VALUE rb_const_list(void*); -VALUE rb_mod_constants(int, VALUE *, VALUE); +VALUE rb_mod_constants(int, const VALUE *, VALUE); VALUE rb_mod_remove_const(VALUE, VALUE); int rb_const_defined(VALUE, ID); int rb_const_defined_at(VALUE, ID); @@ -888,20 +976,21 @@ VALUE rb_cvar_get(VALUE, ID); void rb_cv_set(VALUE, const char*, VALUE); VALUE rb_cv_get(VALUE, const char*); void rb_define_class_variable(VALUE, const char*, VALUE); -VALUE rb_mod_class_variables(int, VALUE*, VALUE); +VALUE rb_mod_class_variables(int, const VALUE*, VALUE); VALUE rb_mod_remove_cvar(VALUE, VALUE); ID rb_frame_callee(void); VALUE rb_str_succ(VALUE); VALUE rb_time_succ(VALUE); -void rb_frame_pop(void); int rb_frame_method_id_and_class(ID *idp, VALUE *klassp); VALUE rb_make_backtrace(void); -VALUE rb_make_exception(int, VALUE*); +VALUE rb_make_exception(int, const VALUE*); -#if defined __GNUC__ && __GNUC__ >= 4 -#pragma GCC visibility pop -#endif +/* deprecated */ +DEPRECATED(void rb_frame_pop(void)); + + +RUBY_SYMBOL_EXPORT_END #if defined(__cplusplus) #if 0 diff --git a/include/ruby/io.h b/include/ruby/io.h index 07be55c46c..029522bedc 100644 --- a/include/ruby/io.h +++ b/include/ruby/io.h @@ -29,7 +29,17 @@ extern "C" { #include "ruby/config.h" #if defined(HAVE_POLL) +# ifdef _AIX +# define reqevents events +# define rtnevents revents +# endif # include <poll.h> +# ifdef _AIX +# undef reqevents +# undef rtnevents +# undef events +# undef revents +# endif # define RB_WAITFD_IN POLLIN # define RB_WAITFD_PRI POLLPRI # define RB_WAITFD_OUT POLLOUT @@ -39,20 +49,19 @@ extern "C" { # define RB_WAITFD_OUT 0x004 #endif -#if defined __GNUC__ && __GNUC__ >= 4 -#pragma GCC visibility push(default) -#endif +RUBY_SYMBOL_EXPORT_BEGIN -typedef struct { +PACKED_STRUCT_UNALIGNED(struct rb_io_buffer_t { char *ptr; /* off + len <= capa */ int off; int len; int capa; -} rb_io_buffer_t; +}); +typedef struct rb_io_buffer_t rb_io_buffer_t; typedef struct rb_io_t { - int fd; /* file descriptor */ FILE *stdio_file; /* stdio ptr for read/write if available */ + int fd; /* file descriptor */ int mode; /* mode flags: FMODE_XXXs */ rb_pid_t pid; /* child's pid (for pipes) */ int lineno; /* number of lines read */ @@ -81,9 +90,9 @@ typedef struct rb_io_t { rb_econv_t *writeconv; VALUE writeconv_asciicompat; + int writeconv_initialized; int writeconv_pre_ecflags; VALUE writeconv_pre_ecopts; - int writeconv_initialized; VALUE write_lock; } rb_io_t; @@ -100,59 +109,30 @@ typedef struct rb_io_t { #define FMODE_APPEND 0x00000040 #define FMODE_CREATE 0x00000080 /* #define FMODE_NOREVLOOKUP 0x00000100 */ -#define FMODE_WSPLIT 0x00000200 -#define FMODE_WSPLIT_INITIALIZED 0x00000400 #define FMODE_TRUNC 0x00000800 #define FMODE_TEXTMODE 0x00001000 /* #define FMODE_PREP 0x00010000 */ #define FMODE_SETENC_BY_BOM 0x00100000 +/* #define FMODE_UNIX 0x00200000 */ +/* #define FMODE_INET 0x00400000 */ +/* #define FMODE_INET6 0x00800000 */ #define GetOpenFile(obj,fp) rb_io_check_closed((fp) = RFILE(rb_io_taint_check(obj))->fptr) #define RB_IO_BUFFER_INIT(buf) do {\ - (buf).ptr = NULL;\ - (buf).off = 0;\ - (buf).len = 0;\ - (buf).capa = 0;\ + [<"internal macro RB_IO_BUFFER_INIT() is used">];\ } while (0) #define MakeOpenFile(obj, fp) do {\ - if (RFILE(obj)->fptr) {\ - rb_io_close(obj);\ - rb_io_fptr_finalize(RFILE(obj)->fptr);\ - RFILE(obj)->fptr = 0;\ - }\ - (fp) = 0;\ - RB_IO_FPTR_NEW(fp);\ - RFILE(obj)->fptr = (fp);\ + (fp) = rb_io_make_open_file(obj);\ } while (0) #define RB_IO_FPTR_NEW(fp) do {\ - (fp) = ALLOC(rb_io_t);\ - (fp)->fd = -1;\ - (fp)->stdio_file = NULL;\ - (fp)->mode = 0;\ - (fp)->pid = 0;\ - (fp)->lineno = 0;\ - (fp)->pathv = Qnil;\ - (fp)->finalize = 0;\ - RB_IO_BUFFER_INIT((fp)->wbuf);\ - RB_IO_BUFFER_INIT((fp)->rbuf);\ - RB_IO_BUFFER_INIT((fp)->cbuf);\ - (fp)->readconv = NULL;\ - (fp)->writeconv = NULL;\ - (fp)->writeconv_asciicompat = Qnil;\ - (fp)->writeconv_pre_ecflags = 0;\ - (fp)->writeconv_pre_ecopts = Qnil;\ - (fp)->writeconv_initialized = 0;\ - (fp)->tied_io_for_writing = 0;\ - (fp)->encs.enc = NULL;\ - (fp)->encs.enc2 = NULL;\ - (fp)->encs.ecflags = 0;\ - (fp)->encs.ecopts = Qnil;\ - (fp)->write_lock = 0;\ + [<"internal macro RB_IO_FPTR_NEW() is used">];\ } while (0) +rb_io_t *rb_io_make_open_file(VALUE obj); + FILE *rb_io_stdio_file(rb_io_t *fptr); FILE *rb_fdopen(int, const char*); @@ -179,19 +159,21 @@ int rb_io_extract_encoding_option(VALUE opt, rb_encoding **enc_p, rb_encoding ** ssize_t rb_io_bufwrite(VALUE io, const void *buf, size_t size); /* compatibility for ruby 1.8 and older */ -#define rb_io_mode_flags(modestr) rb_io_modestr_fmode(modestr) -#define rb_io_modenum_flags(oflags) rb_io_oflags_fmode(oflags) +#define rb_io_mode_flags(modestr) [<"rb_io_mode_flags() is obsolete; use rb_io_modestr_fmode()">] +#define rb_io_modenum_flags(oflags) [<"rb_io_modenum_flags() is obsolete; use rb_io_oflags_fmode()">] VALUE rb_io_taint_check(VALUE); NORETURN(void rb_eof_error(void)); void rb_io_read_check(rb_io_t*); int rb_io_read_pending(rb_io_t*); -DEPRECATED(void rb_read_check(FILE*)); -#if defined __GNUC__ && __GNUC__ >= 4 -#pragma GCC visibility pop -#endif +struct stat; +VALUE rb_stat_new(const struct stat *); + +/* gc.c */ + +RUBY_SYMBOL_EXPORT_END #if defined(__cplusplus) #if 0 diff --git a/include/ruby/missing.h b/include/ruby/missing.h index 1297c43a7a..3474ca256f 100644 --- a/include/ruby/missing.h +++ b/include/ruby/missing.h @@ -21,22 +21,40 @@ extern "C" { #include "ruby/config.h" #include <stddef.h> #include <math.h> /* for INFINITY and NAN */ +#ifdef RUBY_ALTERNATIVE_MALLOC_HEADER +# include RUBY_ALTERNATIVE_MALLOC_HEADER +#endif #ifdef RUBY_EXTCONF_H #include RUBY_EXTCONF_H #endif +#if !defined(HAVE_STRUCT_TIMEVAL) || !defined(HAVE_STRUCT_TIMESPEC) +#if defined(HAVE_TIME_H) +# include <time.h> +#endif #if defined(HAVE_SYS_TIME_H) -# include <sys/time.h> -#elif !defined(_WIN32) -# define time_t long +# include <sys/time.h> +#endif +#endif + +#ifndef M_PI +# define M_PI 3.14159265358979323846 +#endif +#ifndef M_PI_2 +# define M_PI_2 (M_PI/2) +#endif + +#ifndef RUBY_SYMBOL_EXPORT_BEGIN +# define RUBY_SYMBOL_EXPORT_BEGIN /* begin */ +# define RUBY_SYMBOL_EXPORT_END /* end */ +#endif + +#if !defined(HAVE_STRUCT_TIMEVAL) struct timeval { time_t tv_sec; /* seconds */ long tv_usec; /* microseconds */ }; -#endif -#if defined(HAVE_SYS_TYPES_H) -# include <sys/types.h> -#endif +#endif /* HAVE_STRUCT_TIMEVAL */ #if !defined(HAVE_STRUCT_TIMESPEC) struct timespec { @@ -52,11 +70,6 @@ struct timezone { }; #endif -#if defined(HAVE___SYSCALL) && (defined(__APPLE__) || defined(__OpenBSD__)) -/* Mac OS X and OpenBSD have __syscall but don't define it in headers */ -off_t __syscall(quad_t number, ...); -#endif - #ifdef RUBY_EXPORT #undef RUBY_EXTERN #endif @@ -64,9 +77,7 @@ off_t __syscall(quad_t number, ...); #define RUBY_EXTERN extern #endif -#if defined __GNUC__ && __GNUC__ >= 4 -#pragma GCC visibility push(default) -#endif +RUBY_SYMBOL_EXPORT_BEGIN #ifndef HAVE_ACOSH RUBY_EXTERN double acosh(double); @@ -125,24 +136,20 @@ RUBY_EXTERN double lgamma_r(double, int *); RUBY_EXTERN double cbrt(double); #endif -#if !defined(INFINITY) || !defined(NAN) +#if !defined(HAVE_INFINITY) || !defined(HAVE_NAN) union bytesequence4_or_float { unsigned char bytesequence[4]; float float_value; }; #endif -#ifdef INFINITY -# define HAVE_INFINITY -#else +#ifndef INFINITY /** @internal */ RUBY_EXTERN const union bytesequence4_or_float rb_infinity; # define INFINITY (rb_infinity.float_value) #endif -#ifdef NAN -# define HAVE_NAN -#else +#ifndef NAN /** @internal */ RUBY_EXTERN const union bytesequence4_or_float rb_nan; # define NAN (rb_nan.float_value) @@ -167,6 +174,17 @@ RUBY_EXTERN int isnan(double); # endif #endif +#ifndef isfinite +# ifndef HAVE_ISFINITE +# define HAVE_ISFINITE 1 +# define isfinite(x) finite(x) +# endif +#endif + +#ifndef HAVE_NEXTAFTER +RUBY_EXTERN double nextafter(double x, double y); +#endif + /* #ifndef HAVE_MEMCMP RUBY_EXTERN int memcmp(const void *, const void *, size_t); @@ -231,10 +249,15 @@ RUBY_EXTERN int ruby_close(int); RUBY_EXTERN void setproctitle(const char *fmt, ...); #endif -#if defined __GNUC__ && __GNUC__ >= 4 -#pragma GCC visibility pop +#ifndef HAVE_EXPLICIT_BZERO +RUBY_EXTERN void explicit_bzero(void *b, size_t len); +# if defined SecureZeroMemory +# define explicit_bzero(b, len) SecureZeroMemory(b, len) +# endif #endif +RUBY_SYMBOL_EXPORT_END + #if defined(__cplusplus) #if 0 { /* satisfy cc-mode */ diff --git a/include/ruby/oniguruma.h b/include/ruby/oniguruma.h index c01b6f7bb4..519c0ac336 100644 --- a/include/ruby/oniguruma.h +++ b/include/ruby/oniguruma.h @@ -5,7 +5,7 @@ **********************************************************************/ /*- * Copyright (c) 2002-2009 K.Kosako <sndgk393 AT ybb DOT ne DOT jp> - * Copyright (c) 2011-2012 K.Takata <kentkt AT csc DOT jp> + * Copyright (c) 2011-2014 K.Takata <kentkt AT csc DOT jp> * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -39,8 +39,8 @@ extern "C" { #define ONIGURUMA #define ONIGURUMA_VERSION_MAJOR 5 -#define ONIGURUMA_VERSION_MINOR 13 -#define ONIGURUMA_VERSION_TEENY 1 +#define ONIGURUMA_VERSION_MINOR 15 +#define ONIGURUMA_VERSION_TEENY 0 #ifdef __cplusplus # ifndef HAVE_PROTOTYPES @@ -98,9 +98,7 @@ extern "C" { #define ONIG_EXTERN extern #endif -#if defined __GNUC__ && __GNUC__ >= 4 -#pragma GCC visibility push(default) -#endif +RUBY_SYMBOL_EXPORT_BEGIN #include <stddef.h> /* for size_t */ @@ -158,29 +156,29 @@ typedef struct { typedef int (*OnigApplyAllCaseFoldFunc)(OnigCodePoint from, OnigCodePoint* to, int to_len, void* arg); typedef struct OnigEncodingTypeST { - int (*precise_mbc_enc_len)(const OnigUChar* p,const OnigUChar* e, struct OnigEncodingTypeST* enc); + int (*precise_mbc_enc_len)(const OnigUChar* p,const OnigUChar* e, const struct OnigEncodingTypeST* enc); const char* name; int max_enc_len; int min_enc_len; - int (*is_mbc_newline)(const OnigUChar* p, const OnigUChar* end, struct OnigEncodingTypeST* enc); - OnigCodePoint (*mbc_to_code)(const OnigUChar* p, const OnigUChar* end, struct OnigEncodingTypeST* enc); - int (*code_to_mbclen)(OnigCodePoint code, struct OnigEncodingTypeST* enc); - int (*code_to_mbc)(OnigCodePoint code, OnigUChar *buf, struct OnigEncodingTypeST* enc); - int (*mbc_case_fold)(OnigCaseFoldType flag, const OnigUChar** pp, const OnigUChar* end, OnigUChar* to, struct OnigEncodingTypeST* enc); - int (*apply_all_case_fold)(OnigCaseFoldType flag, OnigApplyAllCaseFoldFunc f, void* arg, struct OnigEncodingTypeST* enc); - int (*get_case_fold_codes_by_str)(OnigCaseFoldType flag, const OnigUChar* p, const OnigUChar* end, OnigCaseFoldCodeItem acs[], struct OnigEncodingTypeST* enc); - int (*property_name_to_ctype)(struct OnigEncodingTypeST* enc, OnigUChar* p, OnigUChar* end); - int (*is_code_ctype)(OnigCodePoint code, OnigCtype ctype, struct OnigEncodingTypeST* enc); - int (*get_ctype_code_range)(OnigCtype ctype, OnigCodePoint* sb_out, const OnigCodePoint* ranges[], struct OnigEncodingTypeST* enc); - OnigUChar* (*left_adjust_char_head)(const OnigUChar* start, const OnigUChar* p, const OnigUChar* end, struct OnigEncodingTypeST* enc); - int (*is_allowed_reverse_match)(const OnigUChar* p, const OnigUChar* end, struct OnigEncodingTypeST* enc); + int (*is_mbc_newline)(const OnigUChar* p, const OnigUChar* end, const struct OnigEncodingTypeST* enc); + OnigCodePoint (*mbc_to_code)(const OnigUChar* p, const OnigUChar* end, const struct OnigEncodingTypeST* enc); + int (*code_to_mbclen)(OnigCodePoint code, const struct OnigEncodingTypeST* enc); + int (*code_to_mbc)(OnigCodePoint code, OnigUChar *buf, const struct OnigEncodingTypeST* enc); + int (*mbc_case_fold)(OnigCaseFoldType flag, const OnigUChar** pp, const OnigUChar* end, OnigUChar* to, const struct OnigEncodingTypeST* enc); + int (*apply_all_case_fold)(OnigCaseFoldType flag, OnigApplyAllCaseFoldFunc f, void* arg, const struct OnigEncodingTypeST* enc); + int (*get_case_fold_codes_by_str)(OnigCaseFoldType flag, const OnigUChar* p, const OnigUChar* end, OnigCaseFoldCodeItem acs[], const struct OnigEncodingTypeST* enc); + int (*property_name_to_ctype)(const struct OnigEncodingTypeST* enc, const OnigUChar* p, const OnigUChar* end); + int (*is_code_ctype)(OnigCodePoint code, OnigCtype ctype, const struct OnigEncodingTypeST* enc); + int (*get_ctype_code_range)(OnigCtype ctype, OnigCodePoint* sb_out, const OnigCodePoint* ranges[], const struct OnigEncodingTypeST* enc); + OnigUChar* (*left_adjust_char_head)(const OnigUChar* start, const OnigUChar* p, const OnigUChar* end, const struct OnigEncodingTypeST* enc); + int (*is_allowed_reverse_match)(const OnigUChar* p, const OnigUChar* end, const struct OnigEncodingTypeST* enc); int ruby_encoding_index; unsigned int flags; } OnigEncodingType; -typedef OnigEncodingType* OnigEncoding; +typedef const OnigEncodingType* OnigEncoding; -ONIG_EXTERN OnigEncodingType OnigEncodingASCII; +ONIG_EXTERN const OnigEncodingType OnigEncodingASCII; #define ONIG_ENCODING_ASCII (&OnigEncodingASCII) @@ -258,7 +256,7 @@ ONIG_EXTERN OnigEncodingType OnigEncodingASCII; #define ONIGENC_PRECISE_MBC_ENC_LEN(enc,p,e) (enc)->precise_mbc_enc_len(p,e,enc) ONIG_EXTERN -int onigenc_mbclen_approximate P_((const OnigUChar* p,const OnigUChar* e, struct OnigEncodingTypeST* enc)); +int onigenc_mbclen_approximate P_((const OnigUChar* p,const OnigUChar* e, const struct OnigEncodingTypeST* enc)); #define ONIGENC_MBC_ENC_LEN(enc,p,e) onigenc_mbclen_approximate(p,e,enc) #define ONIGENC_MBC_MAXLEN(enc) ((enc)->max_enc_len) @@ -340,6 +338,7 @@ int onigenc_str_bytelen_null P_((OnigEncoding enc, const OnigUChar* p)); /* config parameters */ #define ONIG_NREGION 10 #define ONIG_MAX_BACKREF_NUM 1000 +#define ONIG_MAX_CAPTURE_GROUP_NUM 32767 #define ONIG_MAX_REPEAT_NUM 100000 #define ONIG_MAX_MULTI_BYTE_RANGES_NUM 10000 /* constants */ @@ -371,7 +370,9 @@ typedef unsigned int OnigOptionType; #define ONIG_OPTION_WORD_BOUND_ALL_RANGE (ONIG_OPTION_POSIX_BRACKET_ALL_RANGE << 1) /* options (newline) */ #define ONIG_OPTION_NEWLINE_CRLF (ONIG_OPTION_WORD_BOUND_ALL_RANGE << 1) -#define ONIG_OPTION_MAXBIT ONIG_OPTION_NEWLINE_CRLF /* limit */ +#define ONIG_OPTION_NOTBOS (ONIG_OPTION_NEWLINE_CRLF << 1) +#define ONIG_OPTION_NOTEOS (ONIG_OPTION_NOTBOS << 1) +#define ONIG_OPTION_MAXBIT ONIG_OPTION_NOTEOS /* limit */ #define ONIG_OPTION_ON(options,regopt) ((options) |= (regopt)) #define ONIG_OPTION_OFF(options,regopt) ((options) &= ~(regopt)) @@ -584,6 +585,7 @@ ONIG_EXTERN const OnigSyntaxType* OnigDefaultSyntax; #define ONIGERR_NEVER_ENDING_RECURSION -221 #define ONIGERR_GROUP_NUMBER_OVER_FOR_CAPTURE_HISTORY -222 #define ONIGERR_INVALID_CHAR_PROPERTY_NAME -223 +#define ONIGERR_TOO_MANY_CAPTURE_GROUPS -224 #define ONIGERR_INVALID_CODE_POINT_VALUE -400 #define ONIGERR_INVALID_WIDE_CHAR_VALUE -400 #define ONIGERR_TOO_BIG_WIDE_CHAR_VALUE -401 @@ -672,13 +674,15 @@ typedef struct re_pattern_buffer { unsigned int bt_mem_end; /* need backtrack flag */ int stack_pop_level; int repeat_range_alloc; + + OnigOptionType options; + OnigRepeatRange* repeat_range; OnigEncoding enc; - OnigOptionType options; const OnigSyntaxType* syntax; - OnigCaseFoldType case_fold_flag; void* name_table; + OnigCaseFoldType case_fold_flag; /* optimization info (string search, char-map and anchors) */ int optimize; /* optimize flag */ @@ -710,7 +714,7 @@ typedef struct { int num_of_elements; OnigEncoding pattern_enc; OnigEncoding target_enc; - OnigSyntaxType* syntax; + const OnigSyntaxType* syntax; OnigOptionType option; OnigCaseFoldType case_fold_flag; } OnigCompileInfo; @@ -809,7 +813,7 @@ void onig_set_syntax_options P_((OnigSyntaxType* syntax, OnigOptionType options) ONIG_EXTERN int onig_set_meta_char P_((OnigSyntaxType* syntax, unsigned int what, OnigCodePoint code)); ONIG_EXTERN -void onig_copy_encoding P_((OnigEncoding to, OnigEncoding from)); +void onig_copy_encoding P_((OnigEncodingType *to, OnigEncoding from)); ONIG_EXTERN OnigCaseFoldType onig_get_default_case_fold_flag P_((void)); ONIG_EXTERN @@ -825,9 +829,7 @@ const char* onig_version P_((void)); ONIG_EXTERN const char* onig_copyright P_((void)); -#if defined __GNUC__ && __GNUC__ >= 4 -#pragma GCC visibility pop -#endif +RUBY_SYMBOL_EXPORT_END #ifdef __cplusplus #if 0 diff --git a/include/ruby/re.h b/include/ruby/re.h index 4039ba1800..166f254aa5 100644 --- a/include/ruby/re.h +++ b/include/ruby/re.h @@ -24,9 +24,7 @@ extern "C" { #include "ruby/regex.h" -#if defined __GNUC__ && __GNUC__ >= 4 -#pragma GCC visibility push(default) -#endif +RUBY_SYMBOL_EXPORT_BEGIN typedef struct re_pattern_buffer Regexp; @@ -60,10 +58,9 @@ long rb_reg_adjust_startpos(VALUE, VALUE, long, int); void rb_match_busy(VALUE); VALUE rb_reg_quote(VALUE); regex_t *rb_reg_prepare_re(VALUE re, VALUE str); +int rb_reg_region_copy(struct re_registers *, const struct re_registers *); -#if defined __GNUC__ && __GNUC__ >= 4 -#pragma GCC visibility pop -#endif +RUBY_SYMBOL_EXPORT_END #if defined(__cplusplus) #if 0 diff --git a/include/ruby/regex.h b/include/ruby/regex.h index aeb6418d0a..024bed4a4e 100644 --- a/include/ruby/regex.h +++ b/include/ruby/regex.h @@ -24,9 +24,7 @@ extern "C" { #include "oniguruma.h" #endif -#if defined __GNUC__ && __GNUC__ >= 4 -#pragma GCC visibility push(default) -#endif +RUBY_SYMBOL_EXPORT_BEGIN #ifndef ONIG_RUBY_M17N @@ -36,9 +34,7 @@ ONIG_EXTERN OnigEncoding OnigEncDefaultCharEncoding; #endif /* ifndef ONIG_RUBY_M17N */ -#if defined __GNUC__ && __GNUC__ >= 4 -#pragma GCC visibility pop -#endif +RUBY_SYMBOL_EXPORT_END #if defined(__cplusplus) #if 0 diff --git a/include/ruby/ruby.h b/include/ruby/ruby.h index 3e513cc63d..dccfdc763a 100644 --- a/include/ruby/ruby.h +++ b/include/ruby/ruby.h @@ -26,6 +26,15 @@ extern "C" { #include RUBY_EXTCONF_H #endif +#if defined(__cplusplus) +/* __builtin_choose_expr and __builtin_types_compatible aren't available + * on C++. See https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html */ +# undef HAVE_BUILTIN___BUILTIN_CHOOSE_EXPR_CONSTANT_P +# undef HAVE_BUILTIN___BUILTIN_TYPES_COMPATIBLE_P +#endif + +#include "defines.h" + #define NORETURN_STYLE_NEW 1 #ifndef NORETURN # define NORETURN(x) x @@ -33,11 +42,24 @@ extern "C" { #ifndef DEPRECATED # define DEPRECATED(x) x #endif +#ifndef DEPRECATED_BY +# define DEPRECATED_BY(n,x) DEPRECATED(x) +#endif +#ifndef DEPRECATED_TYPE +# define DEPRECATED_TYPE(mesg, decl) decl +#endif #ifndef NOINLINE # define NOINLINE(x) x #endif +#ifndef ASSUME +# ifdef UNREACHABLE +# define ASSUME(x) (LIKELY(!!(x)) ? (void)0 : UNREACHABLE) +# else +# define ASSUME(x) ((void)(x)) +# endif +#endif #ifndef UNREACHABLE -# define UNREACHABLE /* unreachable */ +# define UNREACHABLE ((void)0) /* unreachable */ #endif #ifdef __GNUC__ @@ -47,39 +69,36 @@ extern "C" { #define PRINTF_ARGS(decl, string_index, first_to_check) decl #endif -#ifdef HAVE_STRING_H -# include <string.h> -#else -# include <strings.h> -#endif +#define RUBY_MACRO_SELECT(base, n) TOKEN_PASTE(base, n) #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 <stdio.h> -#include "defines.h" +RUBY_SYMBOL_EXPORT_BEGIN -#if defined __GNUC__ && __GNUC__ >= 4 -#pragma GCC visibility push(default) -#endif - -#if defined(HAVE_ALLOCA_H) -#include <alloca.h> +/* Make alloca work the best possible way. */ +#ifdef __GNUC__ +# ifndef atarist +# ifndef alloca +# define alloca __builtin_alloca +# endif +# endif /* atarist */ #else +# ifdef HAVE_ALLOCA_H +# include <alloca.h> +# else # ifdef _AIX #pragma alloca -# endif -#endif +# else +# ifndef alloca /* predefined by HP cc +Olibcalls */ +void *alloca(); +# endif +# endif /* AIX */ +# endif /* HAVE_ALLOCA_H */ +#endif /* __GNUC__ */ #if defined HAVE_UINTPTR_T && 0 typedef uintptr_t VALUE; @@ -106,7 +125,7 @@ typedef unsigned LONG_LONG ID; 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 SIZEOF_LONG_LONG +#ifdef HAVE_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]; @@ -118,20 +137,27 @@ typedef char ruby_check_sizeof_voidp[SIZEOF_VOIDP == sizeof(void*) ? 1 : -1]; #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 PRIoVALUE PRIoPTR #define PRIuVALUE PRIuPTR #define PRIxVALUE PRIxPTR #define PRIXVALUE PRIXPTR -#define PRIsVALUE PRIiPTR +#define PRIsVALUE PRIiPTR"" RUBY_PRI_VALUE_MARK #else #define PRIdVALUE PRI_VALUE_PREFIX"d" #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" +#define PRIsVALUE PRI_VALUE_PREFIX"i" RUBY_PRI_VALUE_MARK #endif #ifndef PRI_VALUE_PREFIX # define PRI_VALUE_PREFIX "" @@ -184,7 +210,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 compliment) long */ + /* assuming 32bit(2's complement) long */ # define LONG_MAX 2147483647 # endif # endif @@ -222,10 +248,12 @@ typedef char ruby_check_sizeof_voidp[SIZEOF_VOIDP == sizeof(void*) ? 1 : -1]; # endif #endif -#define FIXNUM_MAX (LONG_MAX>>1) -#define FIXNUM_MIN RSHIFT((long)LONG_MIN,1) +#define RUBY_FIXNUM_MAX (LONG_MAX>>1) +#define RUBY_FIXNUM_MIN RSHIFT((long)LONG_MIN,1) +#define FIXNUM_MAX RUBY_FIXNUM_MAX +#define FIXNUM_MIN RUBY_FIXNUM_MIN -#define INT2FIX(i) ((VALUE)(((SIGNED_VALUE)(i))<<1 | FIXNUM_FLAG)) +#define INT2FIX(i) (((VALUE)(i))<<1 | RUBY_FIXNUM_FLAG) #define LONG2FIX(i) INT2FIX(i) #define rb_fix_new(v) INT2FIX(v) VALUE rb_int2inum(SIGNED_VALUE); @@ -242,6 +270,7 @@ 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 @@ -249,6 +278,7 @@ 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) @@ -337,18 +367,44 @@ rb_long2int_inline(long n) #define MODET2NUM(v) INT2NUM(v) #endif -#define FIX2LONG(x) (long)RSHIFT((SIGNED_VALUE)(x),1) -#define FIX2ULONG(x) ((((VALUE)(x))>>1)&LONG_MAX) -#define FIXNUM_P(f) (((int)(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) - -#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) +#define RB_FIX2LONG(x) ((long)RSHIFT((SIGNED_VALUE)(x),1)) +static inline long +rb_fix2long(VALUE x) +{ + return RB_FIX2LONG(x); +} +#define RB_FIX2ULONG(x) ((unsigned long)RB_FIX2LONG(x)) +static inline unsigned long +rb_fix2ulong(VALUE x) +{ + return RB_FIX2ULONG(x); +} +#define RB_FIXNUM_P(f) (((int)(SIGNED_VALUE)(f))&RUBY_FIXNUM_FLAG) +#define RB_POSFIXABLE(f) ((f) < RUBY_FIXNUM_MAX+1) +#define RB_NEGFIXABLE(f) ((f) >= RUBY_FIXNUM_MIN) +#define RB_FIXABLE(f) (RB_POSFIXABLE(f) && RB_NEGFIXABLE(f)) +#define FIX2LONG(x) RB_FIX2LONG(x) +#define FIX2ULONG(x) RB_FIX2ULONG(x) +#define FIXNUM_P(f) RB_FIXNUM_P(f) +#define POSFIXABLE(f) RB_POSFIXABLE(f) +#define NEGFIXABLE(f) RB_NEGFIXABLE(f) +#define FIXABLE(f) RB_FIXABLE(f) + +#define RB_IMMEDIATE_P(x) ((VALUE)(x) & RUBY_IMMEDIATE_MASK) +#define IMMEDIATE_P(x) RB_IMMEDIATE_P(x) + +ID rb_sym2id(VALUE); +VALUE rb_id2sym(ID); +#define RB_STATIC_SYM_P(x) (((VALUE)(x)&~((~(VALUE)0)<<RUBY_SPECIAL_SHIFT)) == RUBY_SYMBOL_FLAG) +#define RB_DYNAMIC_SYM_P(x) (!RB_SPECIAL_CONST_P(x) && RB_BUILTIN_TYPE(x) == (RUBY_T_SYMBOL)) +#define RB_SYMBOL_P(x) (RB_STATIC_SYM_P(x)||RB_DYNAMIC_SYM_P(x)) +#define RB_ID2SYM(x) (rb_id2sym(x)) +#define RB_SYM2ID(x) (rb_sym2id(x)) +#define STATIC_SYM_P(x) RB_STATIC_SYM_P(x) +#define DYNAMIC_SYM_P(x) RB_DYNAMIC_SYM_P(x) +#define SYMBOL_P(x) RB_SYMBOL_P(x) +#define ID2SYM(x) RB_ID2SYM(x) +#define SYM2ID(x) RB_SYM2ID(x) #ifndef USE_FLONUM #if SIZEOF_VALUE >= SIZEOF_DOUBLE @@ -359,62 +415,41 @@ rb_long2int_inline(long n) #endif #if USE_FLONUM -#define FLONUM_P(x) ((((int)(SIGNED_VALUE)(x))&FLONUM_MASK) == FLONUM_FLAG) +#define RB_FLONUM_P(x) ((((int)(SIGNED_VALUE)(x))&RUBY_FLONUM_MASK) == RUBY_FLONUM_FLAG) #else -#define FLONUM_P(x) 0 +#define RB_FLONUM_P(x) 0 #endif +#define FLONUM_P(x) RB_FLONUM_P(x) /* 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_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, + RUBY_FIXNUM_FLAG = 0x01, /* ...xxxx xxx1 */ RUBY_FLONUM_MASK = 0x03, - RUBY_FLONUM_FLAG = 0x02, - RUBY_SYMBOL_FLAG = 0x0c, - RUBY_SPECIAL_SHIFT = 8 + RUBY_FLONUM_FLAG = 0x02, /* ...xxxx xx10 */ + RUBY_SYMBOL_FLAG = 0x0c, /* ...0000 1100 */ #else - RUBY_Qfalse = 0, - RUBY_Qtrue = 2, - RUBY_Qnil = 4, - RUBY_Qundef = 6, + RUBY_Qfalse = 0, /* ...0000 0000 */ + RUBY_Qtrue = 2, /* ...0000 0010 */ + RUBY_Qnil = 4, /* ...0000 0100 */ + RUBY_Qundef = 6, /* ...0000 0110 */ RUBY_IMMEDIATE_MASK = 0x03, - RUBY_FIXNUM_FLAG = 0x01, + 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, - RUBY_SPECIAL_SHIFT = 8 + RUBY_SYMBOL_FLAG = 0x0e, /* ...0000 1110 */ #endif + RUBY_SPECIAL_SHIFT = 8 }; #define Qfalse ((VALUE)RUBY_Qfalse) @@ -429,8 +464,8 @@ enum ruby_special_consts { #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)) @@ -458,11 +493,12 @@ enum ruby_value_type { RUBY_T_FALSE = 0x13, RUBY_T_SYMBOL = 0x14, RUBY_T_FIXNUM = 0x15, + RUBY_T_UNDEF = 0x16, - RUBY_T_UNDEF = 0x1b, - RUBY_T_NODE = 0x1c, - RUBY_T_ICLASS = 0x1d, - RUBY_T_ZOMBIE = 0x1e, + RUBY_T_IMEMO = 0x1a, + RUBY_T_NODE = 0x1b, + RUBY_T_ICLASS = 0x1c, + RUBY_T_ZOMBIE = 0x1d, RUBY_T_MASK = 0x1f }; @@ -489,30 +525,55 @@ enum ruby_value_type { #define T_SYMBOL RUBY_T_SYMBOL #define T_RATIONAL RUBY_T_RATIONAL #define T_COMPLEX RUBY_T_COMPLEX +#define T_IMEMO RUBY_T_IMEMO #define T_UNDEF RUBY_T_UNDEF #define T_NODE RUBY_T_NODE #define T_ZOMBIE RUBY_T_ZOMBIE #define T_MASK RUBY_T_MASK -#define BUILTIN_TYPE(x) (int)(((struct RBasic*)(x))->flags & T_MASK) +#define RB_BUILTIN_TYPE(x) (int)(((struct RBasic*)(x))->flags & RUBY_T_MASK) +#define BUILTIN_TYPE(x) RB_BUILTIN_TYPE(x) static inline int rb_type(VALUE obj); #define TYPE(x) rb_type((VALUE)(x)) +#define RB_FLOAT_TYPE_P(obj) (\ + RB_FLONUM_P(obj) || \ + (!RB_SPECIAL_CONST_P(obj) && RB_BUILTIN_TYPE(obj) == RUBY_T_FLOAT)) + +#define RB_TYPE_P(obj, type) ( \ + ((type) == RUBY_T_FIXNUM) ? RB_FIXNUM_P(obj) : \ + ((type) == RUBY_T_TRUE) ? ((obj) == RUBY_Qtrue) : \ + ((type) == RUBY_T_FALSE) ? ((obj) == RUBY_Qfalse) : \ + ((type) == RUBY_T_NIL) ? ((obj) == RUBY_Qnil) : \ + ((type) == RUBY_T_UNDEF) ? ((obj) == RUBY_Qundef) : \ + ((type) == RUBY_T_SYMBOL) ? RB_SYMBOL_P(obj) : \ + ((type) == RUBY_T_FLOAT) ? RB_FLOAT_TYPE_P(obj) : \ + (!RB_SPECIAL_CONST_P(obj) && RB_BUILTIN_TYPE(obj) == (type))) + #ifdef __GNUC__ -#define RB_GC_GUARD_PTR(ptr) \ - __extension__ ({volatile VALUE *rb_gc_guarded_ptr = (ptr); rb_gc_guarded_ptr;}) -#else -#ifdef _MSC_VER +#define RB_GC_GUARD(v) \ + (*__extension__ ({ \ + volatile VALUE *rb_gc_guarded_ptr = &(v); \ + __asm__("" : : "m"(rb_gc_guarded_ptr)); \ + rb_gc_guarded_ptr; \ + })) +#elif defined _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) +#define RB_GC_GUARD(v) (*rb_gc_guarded_ptr(&(v))) +#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) + +#ifdef __GNUC__ +#define RB_UNUSED_VAR(x) x __attribute__ ((unused)) +#else +#define RB_UNUSED_VAR(x) x #endif -#define RB_GC_GUARD(v) (*RB_GC_GUARD_PTR(&(v))) void rb_check_type(VALUE,int); #define Check_Type(v,t) rb_check_type((VALUE)(v),(t)) @@ -527,13 +588,17 @@ 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) -/* obsolete macro - use SafeStringValue(v) */ -#define Check_SafeStr(v) rb_check_safe_str((VALUE)(v)) +#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 VALUE rb_str_export(VALUE); #define ExportStringValue(v) do {\ @@ -548,9 +613,37 @@ 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 1 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_2_error(void) __attribute__((error("$SAFE=2 to 4 are obsolete"))); +int ruby_safe_level_2_warning(void) __attribute__((warning("$SAFE=2 to 4 are obsolete"))); +# ifdef RUBY_EXPORT +# define ruby_safe_level_2_warning() ruby_safe_level_2_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_2_##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_2_##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)); @@ -558,68 +651,77 @@ NORETURN(void rb_insecure_operation(void)); VALUE rb_errinfo(void); void rb_set_errinfo(VALUE); -SIGNED_VALUE rb_num2long(VALUE); -VALUE rb_num2ulong(VALUE); +long rb_num2long(VALUE); +unsigned long rb_num2ulong(VALUE); static inline long rb_num2long_inline(VALUE x) { - if (FIXNUM_P(x)) - return FIX2LONG(x); + if (RB_FIXNUM_P(x)) + return RB_FIX2LONG(x); else - return (long)rb_num2long(x); + return rb_num2long(x); } -#define NUM2LONG(x) rb_num2long_inline(x) +#define RB_NUM2LONG(x) rb_num2long_inline(x) +#define NUM2LONG(x) RB_NUM2LONG(x) static inline unsigned long rb_num2ulong_inline(VALUE x) { - if (FIXNUM_P(x)) - return (unsigned long)FIX2LONG(x); + if (RB_FIXNUM_P(x)) + return RB_FIX2ULONG(x); else - return (unsigned long)rb_num2ulong(x); + return rb_num2ulong(x); } -#define NUM2ULONG(x) rb_num2ulong_inline(x) +#define RB_NUM2ULONG(x) rb_num2ulong_inline(x) +#define NUM2ULONG(x) RB_NUM2ULONG(x) #if SIZEOF_INT < SIZEOF_LONG long rb_num2int(VALUE); long rb_fix2int(VALUE); -#define FIX2INT(x) ((int)rb_fix2int((VALUE)(x))) +#define RB_FIX2INT(x) ((int)rb_fix2int((VALUE)(x))) static inline int rb_num2int_inline(VALUE x) { - if (FIXNUM_P(x)) - return FIX2INT(x); + if (RB_FIXNUM_P(x)) + return (int)rb_fix2int(x); else return (int)rb_num2int(x); } -#define NUM2INT(x) rb_num2int_inline(x) +#define RB_NUM2INT(x) rb_num2int_inline(x) unsigned long rb_num2uint(VALUE); -#define NUM2UINT(x) ((unsigned int)rb_num2uint(x)) +#define RB_NUM2UINT(x) ((unsigned int)rb_num2uint(x)) unsigned long rb_fix2uint(VALUE); -#define FIX2UINT(x) ((unsigned int)rb_fix2uint(x)) +#define RB_FIX2UINT(x) ((unsigned int)rb_fix2uint(x)) #else /* SIZEOF_INT < SIZEOF_LONG */ -#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)) +#define RB_NUM2INT(x) ((int)RB_NUM2LONG(x)) +#define RB_NUM2UINT(x) ((unsigned int)RB_NUM2ULONG(x)) +#define RB_FIX2INT(x) ((int)RB_FIX2LONG(x)) +#define RB_FIX2UINT(x) ((unsigned int)RB_FIX2ULONG(x)) #endif /* SIZEOF_INT < SIZEOF_LONG */ +#define NUM2INT(x) RB_NUM2INT(x) +#define NUM2UINT(x) RB_NUM2UINT(x) +#define FIX2INT(x) RB_FIX2INT(x) +#define FIX2UINT(x) RB_FIX2UINT(x) 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))) +#define RB_FIX2SHORT(x) (rb_fix2short((VALUE)(x))) +#define FIX2SHORT(x) RB_FIX2SHORT(x) static inline short rb_num2short_inline(VALUE x) { - if (FIXNUM_P(x)) - return FIX2SHORT(x); + if (RB_FIXNUM_P(x)) + return rb_fix2short(x); else return rb_num2short(x); } -#define NUM2SHORT(x) rb_num2short_inline(x) -#define NUM2USHORT(x) rb_num2ushort(x) +#define RB_NUM2SHORT(x) rb_num2short_inline(x) +#define RB_NUM2USHORT(x) rb_num2ushort(x) +#define NUM2SHORT(x) RB_NUM2SHORT(x) +#define NUM2USHORT(x) RB_NUM2USHORT(x) #ifdef HAVE_LONG_LONG LONG_LONG rb_num2ll(VALUE); @@ -627,19 +729,23 @@ unsigned LONG_LONG rb_num2ull(VALUE); static inline LONG_LONG rb_num2ll_inline(VALUE x) { - if (FIXNUM_P(x)) - return FIX2LONG(x); + if (RB_FIXNUM_P(x)) + return RB_FIX2LONG(x); else return rb_num2ll(x); } -# define NUM2LL(x) rb_num2ll_inline(x) -# define NUM2ULL(x) rb_num2ull(x) +# define RB_NUM2LL(x) rb_num2ll_inline(x) +# define RB_NUM2ULL(x) rb_num2ull(x) +# define NUM2LL(x) RB_NUM2LL(x) +# define NUM2ULL(x) RB_NUM2ULL(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) +#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 #endif #if defined(HAVE_LONG_LONG) && SIZEOF_SIZE_T > SIZEOF_LONG @@ -658,41 +764,153 @@ 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);\ - 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));\ -} while (0) -#define DUPSETUP(dup,obj) do {\ - 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) +VALUE rb_obj_setup(VALUE obj, VALUE klass, VALUE type); +#define RB_NEWOBJ(obj,type) type *(obj) = (type*)rb_newobj() +#define RB_NEWOBJ_OF(obj,type,klass,flags) type *(obj) = (type*)rb_newobj_of(klass, flags) +#define NEWOBJ(obj,type) RB_NEWOBJ(obj,type) +#define NEWOBJ_OF(obj,type,klass,flags) RB_NEWOBJ_OF(obj,type,klass,flags) /* core has special NEWOBJ_OF() in internal.h */ +#define OBJSETUP(obj,c,t) rb_obj_setup(obj, c, t) /* use NEWOBJ_OF instead of NEWOBJ()+OBJSETUP() */ +#define CLONESETUP(clone,obj) rb_clone_setup(clone,obj) +#define DUPSETUP(dup,obj) rb_dup_setup(dup,obj) + +#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 + +enum ruby_fl_type { + RUBY_FL_WB_PROTECTED = (1<<5), + RUBY_FL_PROMOTED0 = (1<<5), + RUBY_FL_PROMOTED1 = (1<<6), + RUBY_FL_PROMOTED = RUBY_FL_PROMOTED0|RUBY_FL_PROMOTED1, + RUBY_FL_FINALIZE = (1<<7), + RUBY_FL_TAINT = (1<<8), + RUBY_FL_UNTRUSTED = RUBY_FL_TAINT, + RUBY_FL_EXIVAR = (1<<10), + RUBY_FL_FREEZE = (1<<11), + + RUBY_FL_USHIFT = 12, + +#define RUBY_FL_USER_N(n) RUBY_FL_USER##n = (1<<(RUBY_FL_USHIFT+n)) + RUBY_FL_USER_N(0), + RUBY_FL_USER_N(1), + RUBY_FL_USER_N(2), + RUBY_FL_USER_N(3), + RUBY_FL_USER_N(4), + RUBY_FL_USER_N(5), + RUBY_FL_USER_N(6), + RUBY_FL_USER_N(7), + RUBY_FL_USER_N(8), + RUBY_FL_USER_N(9), + RUBY_FL_USER_N(10), + RUBY_FL_USER_N(11), + RUBY_FL_USER_N(12), + RUBY_FL_USER_N(13), + RUBY_FL_USER_N(14), + RUBY_FL_USER_N(15), + RUBY_FL_USER_N(16), + RUBY_FL_USER_N(17), + RUBY_FL_USER_N(18), +#if defined ENUM_OVER_INT || SIZEOF_INT*CHAR_BIT>12+19+1 + RUBY_FL_USER_N(19), +#else +#define RUBY_FL_USER19 (((VALUE)1)<<(RUBY_FL_USHIFT+19)) +#endif + + RUBY_ELTS_SHARED = RUBY_FL_USER2, + RUBY_FL_DUPPED = (RUBY_T_MASK|RUBY_FL_EXIVAR|RUBY_FL_TAINT), + RUBY_FL_SINGLETON = RUBY_FL_USER0 +}; struct RBasic { VALUE flags; - VALUE klass; + 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 */ + +#if defined(HAVE_BUILTIN___BUILTIN_CHOOSE_EXPR_CONSTANT_P) +# define RB_OBJ_WB_UNPROTECT_FOR(type, obj) \ + __extension__( \ + __builtin_choose_expr( \ + RGENGC_WB_PROTECTED_##type, \ + OBJ_WB_UNPROTECT((VALUE)(obj)), ((VALUE)(obj)))) +#else +# define RB_OBJ_WB_UNPROTECT_FOR(type, obj) \ + (RGENGC_WB_PROTECTED_##type ? \ + OBJ_WB_UNPROTECT((VALUE)(obj)) : ((VALUE)(obj))) +#endif + +#define RBASIC_CLASS(obj) (RBASIC(obj)->klass) + +#define ROBJECT_EMBED_LEN_MAX ROBJECT_EMBED_LEN_MAX +#define ROBJECT_EMBED ROBJECT_EMBED +enum { + ROBJECT_EMBED_LEN_MAX = 3, + ROBJECT_EMBED = RUBY_FL_USER1, + + ROBJECT_ENUM_END }; -#define ROBJECT_EMBED_LEN_MAX 3 struct RObject { struct RBasic basic; union { struct { - long numiv; + long numiv; /* only uses 32-bits */ VALUE *ivptr; - struct st_table *iv_index_tbl; /* shortcut for RCLASS_IV_INDEX_TBL(rb_obj_class(obj)) */ + void *iv_index_tbl; /* shortcut for RCLASS_IV_INDEX_TBL(rb_obj_class(obj)) */ } heap; VALUE ary[ROBJECT_EMBED_LEN_MAX]; } as; }; -#define ROBJECT_EMBED FL_USER1 #define ROBJECT_NUMIV(o) \ ((RBASIC(o)->flags & ROBJECT_EMBED) ? \ ROBJECT_EMBED_LEN_MAX : \ @@ -706,112 +924,54 @@ struct RObject { RCLASS_IV_INDEX_TBL(rb_obj_class(o)) : \ ROBJECT(o)->as.heap.iv_index_tbl) -/** @internal */ -typedef struct rb_classext_struct rb_classext_t; - +#define RClass RClassDeprecated +#ifndef __cplusplus +DEPRECATED_TYPE(("RClass is internal use only"), struct RClass { struct RBasic basic; - rb_classext_t *ptr; - struct st_table *m_tbl; - struct st_table *iv_index_tbl; -}; +}); +#endif #define RCLASS_SUPER(c) rb_class_get_superclass(c) #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 - -struct RFloat { - struct RBasic basic; - double float_value; +#define RMODULE_IS_OVERLAID RMODULE_IS_OVERLAID +#define RMODULE_IS_REFINEMENT RMODULE_IS_REFINEMENT +#define RMODULE_INCLUDED_INTO_REFINEMENT RMODULE_INCLUDED_INTO_REFINEMENT +enum { + RMODULE_IS_OVERLAID = RUBY_FL_USER2, + RMODULE_IS_REFINEMENT = RUBY_FL_USER3, + RMODULE_INCLUDED_INTO_REFINEMENT = RUBY_FL_USER4, + + RMODULE_ENUM_END }; +double rb_float_value(VALUE); +VALUE rb_float_new(double); 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 DBL2NUM(dbl) rb_float_new(dbl) -#define ELTS_SHARED FL_USER2 - -#define RSTRING_EMBED_LEN_MAX ((int)((sizeof(VALUE)*3)/sizeof(char)-1)) +#define RUBY_ELTS_SHARED RUBY_ELTS_SHARED +#define ELTS_SHARED RUBY_ELTS_SHARED + +#define RSTRING_NOEMBED RSTRING_NOEMBED +#define RSTRING_EMBED_LEN_MASK RSTRING_EMBED_LEN_MASK +#define RSTRING_EMBED_LEN_SHIFT RSTRING_EMBED_LEN_SHIFT +#define RSTRING_EMBED_LEN_MAX RSTRING_EMBED_LEN_MAX +#define RSTRING_FSTR RSTRING_FSTR +enum { + RSTRING_NOEMBED = RUBY_FL_USER1, + RSTRING_EMBED_LEN_MASK = (RUBY_FL_USER2|RUBY_FL_USER3|RUBY_FL_USER4| + RUBY_FL_USER5|RUBY_FL_USER6), + RSTRING_EMBED_LEN_SHIFT = (RUBY_FL_USHIFT+2), + RSTRING_EMBED_LEN_MAX = (int)((sizeof(VALUE)*3)/sizeof(char)-1), + RSTRING_FSTR = RUBY_FL_USER17, + + RSTRING_ENUM_END +}; struct RString { struct RBasic basic; union { @@ -826,9 +986,6 @@ struct RString { char ary[RSTRING_EMBED_LEN_MAX + 1]; } as; }; -#define RSTRING_NOEMBED FL_USER1 -#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)) @@ -850,7 +1007,19 @@ struct RString { ((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 +#define RARRAY_EMBED_FLAG RARRAY_EMBED_FLAG +#define RARRAY_EMBED_LEN_MASK RARRAY_EMBED_LEN_MASK +#define RARRAY_EMBED_LEN_MAX RARRAY_EMBED_LEN_MAX +#define RARRAY_EMBED_LEN_SHIFT RARRAY_EMBED_LEN_SHIFT +enum { + RARRAY_EMBED_LEN_MAX = 3, + RARRAY_EMBED_FLAG = RUBY_FL_USER1, + /* RUBY_FL_USER2 is for ELTS_SHARED */ + RARRAY_EMBED_LEN_MASK = (RUBY_FL_USER4|RUBY_FL_USER3), + RARRAY_EMBED_LEN_SHIFT = (RUBY_FL_USHIFT+3), + + RARRAY_ENUM_END +}; struct RArray { struct RBasic basic; union { @@ -860,30 +1029,42 @@ struct RArray { long capa; VALUE shared; } aux; - VALUE *ptr; + const VALUE *ptr; } heap; - VALUE ary[RARRAY_EMBED_LEN_MAX]; + const VALUE ary[RARRAY_EMBED_LEN_MAX]; } as; }; -#define RARRAY_EMBED_FLAG FL_USER1 -/* FL_USER2 is for ELTS_SHARED */ -#define RARRAY_EMBED_LEN_MASK (FL_USER4|FL_USER3) -#define RARRAY_EMBED_LEN_SHIFT (FL_USHIFT+3) -#define RARRAY_LEN(a) \ - ((RBASIC(a)->flags & RARRAY_EMBED_FLAG) ? \ - (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_EMBED_LEN(a) \ + (long)((RBASIC(a)->flags >> RARRAY_EMBED_LEN_SHIFT) & \ + (RARRAY_EMBED_LEN_MASK >> RARRAY_EMBED_LEN_SHIFT)) +#define RARRAY_LEN(a) rb_array_len(a) #define RARRAY_LENINT(ary) rb_long2int(RARRAY_LEN(ary)) +#define RARRAY_CONST_PTR(a) rb_array_const_ptr(a) + +#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(RB_OBJ_WB_UNPROTECT_FOR(ARRAY, a))) struct RRegexp { struct RBasic basic; struct re_pattern_buffer *ptr; - VALUE src; + const VALUE src; unsigned long usecnt; }; #define RREGEXP_SRC(r) RREGEXP(r)->src @@ -891,35 +1072,21 @@ 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) (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_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_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; }; -struct RRational { - struct RBasic basic; - VALUE num; - VALUE den; -}; - -struct RComplex { - struct RBasic basic; - VALUE real; - VALUE imag; -}; +#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 RData { struct RBasic basic; @@ -942,6 +1109,7 @@ struct rb_data_type_struct { const rb_data_type_t *parent; void *data; /* This area can be used for any purpose by a programmer who define the type. */ + VALUE flags; /* RUBY_FL_WB_PROTECTED */ }; #define HAVE_TYPE_RB_DATA_TYPE_T 1 @@ -966,8 +1134,17 @@ struct RTypedData { */ typedef void (*RUBY_DATA_FUNC)(void*); -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 *); +#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_wrap(VALUE,void*,RUBY_DATA_FUNC,RUBY_DATA_FUNC); +VALUE rb_data_object_zalloc(VALUE,size_t,RUBY_DATA_FUNC,RUBY_DATA_FUNC); +VALUE rb_data_typed_object_wrap(VALUE klass, void *datap, const rb_data_type_t *); +VALUE rb_data_typed_object_zalloc(VALUE klass, size_t size, const rb_data_type_t *type); 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 *); @@ -977,239 +1154,492 @@ void *rb_check_typeddata(VALUE, const rb_data_type_t *); #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 RUBY_FL_WB_PROTECTED /* THIS FLAG DEPENDS ON Ruby version */ +#define RUBY_TYPED_PROMOTED1 RUBY_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_wrap((klass),(sval),(RUBY_DATA_FUNC)(mark),(RUBY_DATA_FUNC)(free)) + +#define Data_Make_Struct0(result, klass, type, size, mark, free, sval) \ + VALUE result = rb_data_object_zalloc((klass), (size), \ + (RUBY_DATA_FUNC)(mark), \ + (RUBY_DATA_FUNC)(free)); \ + (void)((sval) = (type *)DATA_PTR(result)); +#ifdef __GNUC__ +#define Data_Make_Struct(klass,type,mark,free,sval) ({\ + Data_Make_Struct0(data_struct_obj, klass, type, sizeof(type), mark, free, sval); \ + data_struct_obj; \ +}) +#else #define Data_Make_Struct(klass,type,mark,free,sval) (\ - (sval) = ALLOC(type),\ - memset((sval), 0, sizeof(type)),\ - Data_Wrap_Struct((klass),(mark),(free),(sval))\ + rb_data_object_make((klass),(RUBY_DATA_FUNC)(mark),(RUBY_DATA_FUNC)(free),(void **)&(sval),sizeof(type)) \ ) +#endif #define TypedData_Wrap_Struct(klass,data_type,sval)\ - rb_data_typed_object_alloc((klass),(sval),(data_type)) + rb_data_typed_object_wrap((klass),(sval),(data_type)) + +#define TypedData_Make_Struct0(result, klass, type, size, data_type, sval) \ + VALUE result = rb_data_typed_object_zalloc(klass, size, data_type); \ + (void)((sval) = (type *)DATA_PTR(result)); +#ifdef __GNUC__ +#define TypedData_Make_Struct(klass, type, data_type, sval) ({\ + TypedData_Make_Struct0(data_struct_obj, klass, type, sizeof(type), data_type, sval); \ + data_struct_obj; \ +}) +#else #define TypedData_Make_Struct(klass, type, data_type, sval) (\ - (sval) = ALLOC(type),\ - memset((sval), 0, sizeof(type)),\ - TypedData_Wrap_Struct((klass),(data_type),(sval))\ + rb_data_typed_object_make((klass),(data_type),(void **)&(sval),sizeof(type)) \ ) +#endif -#define Data_Get_Struct(obj,type,sval) do {\ - Check_Type((obj), T_DATA); \ - (sval) = (type*)DATA_PTR(obj);\ -} while (0) +#define Data_Get_Struct(obj,type,sval) \ + ((sval) = (type*)rb_data_object_get(obj)) -#define TypedData_Get_Struct(obj,type,data_type,sval) do {\ - (sval) = (type*)rb_check_typeddata((obj), (data_type)); \ -} while (0) +#define TypedData_Get_Struct(obj,type,data_type,sval) \ + ((sval) = (type*)rb_check_typeddata((obj), (data_type))) + +#define RSTRUCT_EMBED_LEN_MAX RSTRUCT_EMBED_LEN_MAX +#define RSTRUCT_EMBED_LEN_MASK RSTRUCT_EMBED_LEN_MASK +#define RSTRUCT_EMBED_LEN_SHIFT RSTRUCT_EMBED_LEN_SHIFT +enum { + RSTRUCT_EMBED_LEN_MAX = 3, + RSTRUCT_EMBED_LEN_MASK = (RUBY_FL_USER2|RUBY_FL_USER1), + RSTRUCT_EMBED_LEN_SHIFT = (RUBY_FL_USHIFT+1), + + RSTRUCT_ENUM_END +}; -#define RSTRUCT_EMBED_LEN_MAX 3 struct RStruct { struct RBasic basic; union { struct { long len; - VALUE *ptr; + const VALUE *ptr; } heap; - VALUE ary[RSTRUCT_EMBED_LEN_MAX]; + const VALUE ary[RSTRUCT_EMBED_LEN_MAX]; } as; }; -#define RSTRUCT_EMBED_LEN_MASK (FL_USER2|FL_USER1) -#define RSTRUCT_EMBED_LEN_SHIFT (FL_USHIFT+1) -#define RSTRUCT_LEN(st) \ - ((RBASIC(st)->flags & RSTRUCT_EMBED_LEN_MASK) ? \ - (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_EMBED_LEN(st) \ + (long)((RBASIC(st)->flags >> RSTRUCT_EMBED_LEN_SHIFT) & \ + (RSTRUCT_EMBED_LEN_MASK >> RSTRUCT_EMBED_LEN_SHIFT)) +#define RSTRUCT_LEN(st) rb_struct_len(st) #define RSTRUCT_LENINT(st) rb_long2int(RSTRUCT_LEN(st)) +#define RSTRUCT_CONST_PTR(st) rb_struct_const_ptr(st) +#define RSTRUCT_PTR(st) ((VALUE *)RSTRUCT_CONST_PTR(RB_OBJ_WB_UNPROTECT_FOR(STRUCT, st))) -#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 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 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_RESERVED1 (((VALUE)1)<<5) -#define FL_RESERVED2 (((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) -#define FL_EXIVAR (((VALUE)1)<<10) -#define FL_FREEZE (((VALUE)1)<<11) - -#define FL_USHIFT 12 - -#define FL_USER0 (((VALUE)1)<<(FL_USHIFT+0)) -#define FL_USER1 (((VALUE)1)<<(FL_USHIFT+1)) -#define FL_USER2 (((VALUE)1)<<(FL_USHIFT+2)) -#define FL_USER3 (((VALUE)1)<<(FL_USHIFT+3)) -#define FL_USER4 (((VALUE)1)<<(FL_USHIFT+4)) -#define FL_USER5 (((VALUE)1)<<(FL_USHIFT+5)) -#define FL_USER6 (((VALUE)1)<<(FL_USHIFT+6)) -#define FL_USER7 (((VALUE)1)<<(FL_USHIFT+7)) -#define FL_USER8 (((VALUE)1)<<(FL_USHIFT+8)) -#define FL_USER9 (((VALUE)1)<<(FL_USHIFT+9)) -#define FL_USER10 (((VALUE)1)<<(FL_USHIFT+10)) -#define FL_USER11 (((VALUE)1)<<(FL_USHIFT+11)) -#define FL_USER12 (((VALUE)1)<<(FL_USHIFT+12)) -#define FL_USER13 (((VALUE)1)<<(FL_USHIFT+13)) -#define FL_USER14 (((VALUE)1)<<(FL_USHIFT+14)) -#define FL_USER15 (((VALUE)1)<<(FL_USHIFT+15)) -#define FL_USER16 (((VALUE)1)<<(FL_USHIFT+16)) -#define FL_USER17 (((VALUE)1)<<(FL_USHIFT+17)) -#define FL_USER18 (((VALUE)1)<<(FL_USHIFT+18)) -#define FL_USER19 (((VALUE)1)<<(FL_USHIFT+19)) - -#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(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_TAINTED(x) (!!FL_TEST((x), FL_TAINT)) -#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_FROZEN(x) (!!(FL_ABLE(x)?(RBASIC(x)->flags&(FL_FREEZE)):(FIXNUM_P(x)||FLONUM_P(x)))) -#define OBJ_FREEZE(x) FL_SET((x), FL_FREEZE) +#define FL_SINGLETON RUBY_FL_SINGLETON +#define FL_WB_PROTECTED RUBY_FL_WB_PROTECTED +#define FL_PROMOTED0 RUBY_FL_PROMOTED0 +#define FL_PROMOTED1 RUBY_FL_PROMOTED1 +#define FL_FINALIZE RUBY_FL_FINALIZE +#define FL_TAINT RUBY_FL_TAINT +#define FL_UNTRUSTED RUBY_FL_UNTRUSTED +#define FL_EXIVAR RUBY_FL_EXIVAR +#define FL_FREEZE RUBY_FL_FREEZE + +#define FL_USHIFT RUBY_FL_USHIFT + +#define FL_USER0 RUBY_FL_USER0 +#define FL_USER1 RUBY_FL_USER1 +#define FL_USER2 RUBY_FL_USER2 +#define FL_USER3 RUBY_FL_USER3 +#define FL_USER4 RUBY_FL_USER4 +#define FL_USER5 RUBY_FL_USER5 +#define FL_USER6 RUBY_FL_USER6 +#define FL_USER7 RUBY_FL_USER7 +#define FL_USER8 RUBY_FL_USER8 +#define FL_USER9 RUBY_FL_USER9 +#define FL_USER10 RUBY_FL_USER10 +#define FL_USER11 RUBY_FL_USER11 +#define FL_USER12 RUBY_FL_USER12 +#define FL_USER13 RUBY_FL_USER13 +#define FL_USER14 RUBY_FL_USER14 +#define FL_USER15 RUBY_FL_USER15 +#define FL_USER16 RUBY_FL_USER16 +#define FL_USER17 RUBY_FL_USER17 +#define FL_USER18 RUBY_FL_USER18 +#define FL_USER19 RUBY_FL_USER19 + +#define RB_SPECIAL_CONST_P(x) (RB_IMMEDIATE_P(x) || !RTEST(x)) +#define SPECIAL_CONST_P(x) RB_SPECIAL_CONST_P(x) + +#define RB_FL_ABLE(x) (!RB_SPECIAL_CONST_P(x) && RB_BUILTIN_TYPE(x) != RUBY_T_NODE) +#define RB_FL_TEST_RAW(x,f) (RBASIC(x)->flags&(f)) +#define RB_FL_TEST(x,f) (RB_FL_ABLE(x)?RB_FL_TEST_RAW((x),(f)):0) +#define RB_FL_ANY_RAW(x,f) RB_FL_TEST_RAW((x),(f)) +#define RB_FL_ANY(x,f) RB_FL_TEST((x),(f)) +#define RB_FL_ALL_RAW(x,f) (RB_FL_TEST_RAW((x),(f)) == (f)) +#define RB_FL_ALL(x,f) (RB_FL_TEST((x),(f)) == (f)) +#define RB_FL_SET_RAW(x,f) (void)(RBASIC(x)->flags |= (f)) +#define RB_FL_SET(x,f) (RB_FL_ABLE(x) ? RB_FL_SET_RAW(x, f) : (void)0) +#define RB_FL_UNSET_RAW(x,f) (void)(RBASIC(x)->flags &= ~(f)) +#define RB_FL_UNSET(x,f) (RB_FL_ABLE(x) ? RB_FL_UNSET_RAW(x, f) : (void)0) +#define RB_FL_REVERSE_RAW(x,f) (void)(RBASIC(x)->flags ^= (f)) +#define RB_FL_REVERSE(x,f) (RB_FL_ABLE(x) ? RB_FL_REVERSE_RAW(x, f) : (void)0) + +#define RB_OBJ_TAINTABLE(x) (RB_FL_ABLE(x) && RB_BUILTIN_TYPE(x) != RUBY_T_BIGNUM && RB_BUILTIN_TYPE(x) != RUBY_T_FLOAT) +#define RB_OBJ_TAINTED_RAW(x) RB_FL_TEST_RAW(x, RUBY_FL_TAINT) +#define RB_OBJ_TAINTED(x) (!!RB_FL_TEST((x), RUBY_FL_TAINT)) +#define RB_OBJ_TAINT_RAW(x) RB_FL_SET_RAW(x, RUBY_FL_TAINT) +#define RB_OBJ_TAINT(x) (RB_OBJ_TAINTABLE(x) ? RB_OBJ_TAINT_RAW(x) : (void)0) +#define RB_OBJ_UNTRUSTED(x) RB_OBJ_TAINTED(x) +#define RB_OBJ_UNTRUST(x) RB_OBJ_TAINT(x) +#define RB_OBJ_INFECT_RAW(x,s) RB_FL_SET_RAW(x, RB_OBJ_TAINTED_RAW(s)) +#define RB_OBJ_INFECT(x,s) ( \ + (RB_OBJ_TAINTABLE(x) && RB_FL_ABLE(s)) ? \ + RB_OBJ_INFECT_RAW(x, s) : (void)0) + +#define RB_OBJ_FROZEN_RAW(x) (RBASIC(x)->flags&RUBY_FL_FREEZE) +#define RB_OBJ_FROZEN(x) (!RB_FL_ABLE(x) || RB_OBJ_FROZEN_RAW(x)) +#define RB_OBJ_FREEZE_RAW(x) (void)(RBASIC(x)->flags |= RUBY_FL_FREEZE) +#define RB_OBJ_FREEZE(x) rb_obj_freeze_inline((VALUE)x) + +#define FL_ABLE(x) RB_FL_ABLE(x) +#define FL_TEST_RAW(x,f) RB_FL_TEST_RAW(x,f) +#define FL_TEST(x,f) RB_FL_TEST(x,f) +#define FL_ANY_RAW(x,f) RB_FL_ANY_RAW(x,f) +#define FL_ANY(x,f) RB_FL_ANY(x,f) +#define FL_ALL_RAW(x,f) RB_FL_ALL_RAW(x,f) +#define FL_ALL(x,f) RB_FL_ALL(x,f) +#define FL_SET_RAW(x,f) RB_FL_SET_RAW(x,f) +#define FL_SET(x,f) RB_FL_SET(x,f) +#define FL_UNSET_RAW(x,f) RB_FL_UNSET_RAW(x,f) +#define FL_UNSET(x,f) RB_FL_UNSET(x,f) +#define FL_REVERSE_RAW(x,f) RB_FL_REVERSE_RAW(x,f) +#define FL_REVERSE(x,f) RB_FL_REVERSE(x,f) + +#define OBJ_TAINTABLE(x) RB_OBJ_TAINTABLE(x) +#define OBJ_TAINTED_RAW(x) RB_OBJ_TAINTED_RAW(x) +#define OBJ_TAINTED(x) RB_OBJ_TAINTED(x) +#define OBJ_TAINT_RAW(x) RB_OBJ_TAINT_RAW(x) +#define OBJ_TAINT(x) RB_OBJ_TAINT(x) +#define OBJ_UNTRUSTED(x) RB_OBJ_UNTRUSTED(x) +#define OBJ_UNTRUST(x) RB_OBJ_UNTRUST(x) +#define OBJ_INFECT_RAW(x,s) RB_OBJ_INFECT_RAW(x,s) +#define OBJ_INFECT(x,s) RB_OBJ_INFECT(x,s) +#define OBJ_FROZEN_RAW(x) RB_OBJ_FROZEN_RAW(x) +#define OBJ_FROZEN(x) RB_OBJ_FROZEN(x) +#define OBJ_FREEZE_RAW(x) RB_OBJ_FREEZE_RAW(x) +#define OBJ_FREEZE(x) RB_OBJ_FREEZE(x) + +void rb_freeze_singleton_class(VALUE klass); + +static inline void +rb_obj_freeze_inline(VALUE x) +{ + if (RB_FL_ABLE(x)) { + RB_OBJ_FREEZE_RAW(x); + if (RBASIC_CLASS(x) && !(RBASIC(x)->flags & RUBY_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 + +#if defined(__GNUC__) && !defined(__NO_INLINE__) +#if defined(HAVE_BUILTIN___BUILTIN_CHOOSE_EXPR_CONSTANT_P) +RUBY_UNTYPED_DATA_FUNC(static inline VALUE rb_data_object_wrap_warning(VALUE,void*,RUBY_DATA_FUNC,RUBY_DATA_FUNC)); +#endif +RUBY_UNTYPED_DATA_FUNC(static inline void *rb_data_object_get_warning(VALUE)); + +static inline VALUE +rb_data_object_wrap_warning(VALUE klass, void *ptr, RUBY_DATA_FUNC mark, RUBY_DATA_FUNC free) +{ + return rb_data_object_wrap(klass, ptr, mark, free); +} + +#if defined(HAVE_BUILTIN___BUILTIN_CHOOSE_EXPR_CONSTANT_P) +#define rb_data_object_wrap_warning(klass, ptr, mark, free) \ + __extension__( \ + __builtin_choose_expr( \ + __builtin_constant_p(klass) && !(klass), \ + rb_data_object_wrap(klass, ptr, mark, free), \ + rb_data_object_wrap_warning(klass, ptr, mark, free))) +#endif +#endif + +static inline void * +rb_data_object_get(VALUE obj) +{ + Check_Type(obj, RUBY_T_DATA); + return ((struct RData *)obj)->data; +} + +#if defined(__GNUC__) && !defined(__NO_INLINE__) +static inline void * +rb_data_object_get_warning(VALUE obj) +{ + return rb_data_object_get(obj); +} +#endif + +static inline VALUE +rb_data_object_make(VALUE klass, RUBY_DATA_FUNC mark_func, RUBY_DATA_FUNC free_func, void **datap, size_t size) +{ + Data_Make_Struct0(result, klass, void, size, mark_func, free_func, *datap); + return result; +} + +static inline VALUE +rb_data_typed_object_make(VALUE klass, const rb_data_type_t *type, void **datap, size_t size) +{ + TypedData_Make_Struct0(result, klass, void, size, type, *datap); + return result; +} + +#ifndef rb_data_object_alloc +DEPRECATED_BY(rb_data_object_wrap, static inline VALUE rb_data_object_alloc(VALUE,void*,RUBY_DATA_FUNC,RUBY_DATA_FUNC)); +static inline VALUE +rb_data_object_alloc(VALUE klass, void *data, RUBY_DATA_FUNC dmark, RUBY_DATA_FUNC dfree) +{ + return rb_data_object_wrap(klass, data, dmark, dfree); +} +#endif + +#ifndef rb_data_typed_object_alloc +DEPRECATED_BY(rb_data_typed_object_wrap, static inline VALUE rb_data_typed_object_alloc(VALUE,void*,const rb_data_type_t*)); +static inline VALUE +rb_data_typed_object_alloc(VALUE klass, void *datap, const rb_data_type_t *type) +{ + return rb_data_typed_object_wrap(klass, datap, type); +} +#endif + +#if defined(__GNUC__) && !defined(__NO_INLINE__) +#define rb_data_object_wrap_0 rb_data_object_wrap +#define rb_data_object_wrap_1 rb_data_object_wrap_warning +#define rb_data_object_wrap RUBY_MACRO_SELECT(rb_data_object_wrap_, 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) +#define rb_data_object_make_0 rb_data_object_make +#define rb_data_object_make_1 rb_data_object_make_warning +#define rb_data_object_make RUBY_MACRO_SELECT(rb_data_object_make_, RUBY_UNTYPED_DATA_WARNING) +#endif + +#if USE_RGENGC +#define RB_OBJ_PROMOTED_RAW(x) RB_FL_ALL_RAW(x, RUBY_FL_PROMOTED) +#define RB_OBJ_PROMOTED(x) (RB_SPECIAL_CONST_P(x) ? 0 : RB_OBJ_PROMOTED_RAW(x)) +#define RB_OBJ_WB_UNPROTECT(x) rb_obj_wb_unprotect(x, __FILE__, __LINE__) + +void rb_gc_writebarrier(VALUE a, VALUE b); +void rb_gc_writebarrier_unprotect(VALUE obj); + +#else /* USE_RGENGC */ +#define RB_OBJ_PROMOTED(x) 0 +#define RB_OBJ_WB_UNPROTECT(x) rb_obj_wb_unprotect(x, __FILE__, __LINE__) +#endif +#define OBJ_PROMOTED_RAW(x) RB_OBJ_PROMOTED_RAW(x) +#define OBJ_PROMOTED(x) RB_OBJ_PROMOTED(x) +#define OBJ_WB_UNPROTECT(x) RB_OBJ_WB_UNPROTECT(x) + +/* 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 + +#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 (!RB_SPECIAL_CONST_P(b)) { + rb_gc_writebarrier(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; +} #if SIZEOF_INT < SIZEOF_LONG -# define INT2NUM(v) INT2FIX((int)(v)) -# define UINT2NUM(v) LONG2FIX((unsigned int)(v)) +# define RB_INT2NUM(v) INT2FIX((int)(v)) +# define RB_UINT2NUM(v) LONG2FIX((unsigned int)(v)) #else static inline VALUE rb_int2num_inline(int v) { - if (FIXABLE(v)) + if (RB_FIXABLE(v)) return INT2FIX(v); else return rb_int2big(v); } -#define INT2NUM(x) rb_int2num_inline(x) +#define RB_INT2NUM(x) rb_int2num_inline(x) static inline VALUE rb_uint2num_inline(unsigned int v) { - if (POSFIXABLE(v)) + if (RB_POSFIXABLE(v)) return LONG2FIX(v); else return rb_uint2big(v); } -#define UINT2NUM(x) rb_uint2num_inline(x) +#define RB_UINT2NUM(x) rb_uint2num_inline(x) #endif +#define INT2NUM(x) RB_INT2NUM(x) +#define UINT2NUM(x) RB_UINT2NUM(x) static inline VALUE rb_long2num_inline(long v) { - if (FIXABLE(v)) + if (RB_FIXABLE(v)) return LONG2FIX(v); else return rb_int2big(v); } -#define LONG2NUM(x) rb_long2num_inline(x) +#define RB_LONG2NUM(x) rb_long2num_inline(x) static inline VALUE rb_ulong2num_inline(unsigned long v) { - if (POSFIXABLE(v)) + if (RB_POSFIXABLE(v)) return LONG2FIX(v); else return rb_uint2big(v); } -#define ULONG2NUM(x) rb_ulong2num_inline(x) +#define RB_ULONG2NUM(x) rb_ulong2num_inline(x) static inline char rb_num2char_inline(VALUE x) { - if ((TYPE(x) == T_STRING) && (RSTRING_LEN(x)>=1)) + if (RB_TYPE_P(x, RUBY_T_STRING) && (RSTRING_LEN(x)>=1)) return RSTRING_PTR(x)[0]; else return (char)(NUM2INT(x) & 0xff); } -#define NUM2CHR(x) rb_num2char_inline(x) +#define RB_NUM2CHR(x) rb_num2char_inline(x) + +#define RB_CHR2FIX(x) INT2FIX((long)((x)&0xff)) + +#define LONG2NUM(x) RB_LONG2NUM(x) +#define ULONG2NUM(x) RB_ULONG2NUM(x) +#define NUM2CHR(x) RB_NUM2CHR(x) +#define CHR2FIX(x) RB_CHR2FIX(x) -#define CHR2FIX(x) INT2FIX((long)((x)&0xff)) +#define RB_ALLOC_N(type,n) ((type*)ruby_xmalloc2((n),sizeof(type))) +#define RB_ALLOC(type) ((type*)ruby_xmalloc(sizeof(type))) +#define RB_ZALLOC_N(type,n) ((type*)ruby_xcalloc((n),sizeof(type))) +#define RB_ZALLOC(type) (RB_ZALLOC_N(type,1)) +#define RB_REALLOC_N(var,type,n) ((var)=(type*)ruby_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 ALLOC_N(type,n) RB_ALLOC_N(type,n) +#define ALLOC(type) RB_ALLOC(type) +#define ZALLOC_N(type,n) RB_ZALLOC_N(type,n) +#define ZALLOC(type) RB_ZALLOC(type) +#define REALLOC_N(var,type,n) RB_REALLOC_N(var,type,n) #define ALLOCA_N(type,n) ((type*)alloca(sizeof(type)*(n))) -void *rb_alloc_tmp_buffer(volatile VALUE *store, long len); +void *rb_alloc_tmp_buffer(volatile VALUE *store, long len) RUBY_ATTR_ALLOC_SIZE((2)); void rb_free_tmp_buffer(volatile VALUE *store); +NORETURN(void ruby_malloc_size_overflow(size_t, size_t)); +static inline size_t +ruby_xmalloc2_size(const size_t count, const size_t elsize) +{ + if (count > SIZE_MAX / elsize) { + ruby_malloc_size_overflow(count, elsize); + } + return count * elsize; +} /* 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)) +# define RB_ALLOCV(v, n) rb_alloc_tmp_buffer(&(v), (n)) +# define RB_ALLOCV_N(type, v, n) \ + ((type*)RB_ALLOCV((v), ruby_xmalloc2_size((n), sizeof(type)))) #else -# define ALLOCV(v, n) ((n) < 1024 ? (RB_GC_GUARD(v) = 0, alloca(n)) : rb_alloc_tmp_buffer(&(v), (n))) +# define RUBY_ALLOCV_LIMIT 1024 +# define RB_ALLOCV(v, n) ((n) < RUBY_ALLOCV_LIMIT ? \ + (RB_GC_GUARD(v) = 0, alloca(n)) : \ + rb_alloc_tmp_buffer(&(v), (n))) +# define RB_ALLOCV_N(type, v, n) \ + ((type*)(ruby_xmalloc2_size((n), sizeof(type)) < RUBY_ALLOCV_LIMIT ? \ + (RB_GC_GUARD(v) = 0, alloca((n) * sizeof(type))) : \ + rb_alloc_tmp_buffer(&(v), (n) * sizeof(type)))) #endif -#define ALLOCV_N(type, v, n) ((type*)ALLOCV((v), sizeof(type)*(n))) -#define ALLOCV_END(v) rb_free_tmp_buffer(&(v)) +#define RB_ALLOCV_END(v) rb_free_tmp_buffer(&(v)) + +#define ALLOCV(v, n) RB_ALLOCV(v, n) +#define ALLOCV_N(type, v, n) RB_ALLOCV_N(type, v, n) +#define ALLOCV_END(v) RB_ALLOCV_END(v) #define MEMZERO(p,type,n) memset((p), 0, sizeof(type)*(n)) #define MEMCPY(p1,p2,type,n) memcpy((p1), (p2), sizeof(type)*(n)) @@ -1255,7 +1685,7 @@ 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*,VALUE*); +void rb_define_readonly_variable(const char*,const VALUE*); void rb_define_const(VALUE,const char*,VALUE); void rb_define_global_const(const char*,VALUE); @@ -1280,16 +1710,21 @@ 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) \ +#define RUBY_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)); \ result rb_intern_id_cache; \ } -#define CONST_ID(var, str) \ - do CONST_ID_CACHE((var) =, (str)) while (0) +#define RUBY_CONST_ID(var, str) \ + do RUBY_CONST_ID_CACHE((var) =, (str)) while (0) +#define CONST_ID_CACHE(result, str) RUBY_CONST_ID_CACHE(result, str) +#define CONST_ID(var, str) RUBY_CONST_ID(var, str) #ifdef __GNUC__ /* __builtin_constant_p and statement expression is available * since gcc-2.7.2.3 at least. */ @@ -1314,11 +1749,20 @@ 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_funcall2(VALUE, ID, int, const VALUE*); -VALUE rb_funcall3(VALUE, ID, int, const VALUE*); +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); 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*); @@ -1332,6 +1776,11 @@ VALUE *rb_ruby_debug_ptr(void); #define ruby_verbose (*rb_ruby_verbose_ptr()) #define ruby_debug (*rb_ruby_debug_ptr()) +/* for rb_readwrite_sys_fail first argument */ +enum rb_io_wait_readwrite {RB_IO_WAIT_READABLE, RB_IO_WAIT_WRITABLE}; +#define RB_IO_WAIT_READABLE RB_IO_WAIT_READABLE +#define RB_IO_WAIT_WRITABLE RB_IO_WAIT_WRITABLE + PRINTF_ARGS(NORETURN(void rb_raise(VALUE, const char*, ...)), 2, 3); PRINTF_ARGS(NORETURN(void rb_fatal(const char*, ...)), 1, 2); PRINTF_ARGS(NORETURN(void rb_bug(const char*, ...)), 1, 2); @@ -1340,6 +1789,7 @@ 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(enum rb_io_wait_readwrite, const char*)); NORETURN(void rb_iter_break(void)); NORETURN(void rb_iter_break_value(VALUE)); NORETURN(void rb_exit(int)); @@ -1350,6 +1800,7 @@ 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)); +NORETURN(void rb_readwrite_syserr_fail(enum rb_io_wait_readwrite, int, const char*)); /* reports if `-W' specified */ PRINTF_ARGS(void rb_warning(const char*, ...), 1, 2); @@ -1359,17 +1810,27 @@ 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); -typedef VALUE rb_block_call_func(VALUE, VALUE, int, VALUE*); +#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 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,VALUE*,VALUE(*)(ANYARGS),VALUE); +VALUE rb_block_call(VALUE,ID,int,const VALUE*,rb_block_call_func_t,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); @@ -1471,15 +1932,15 @@ RUBY_EXTERN VALUE rb_stdin, rb_stdout, rb_stderr; static inline VALUE 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; + if (RB_IMMEDIATE_P(obj)) { + if (RB_FIXNUM_P(obj)) return rb_cFixnum; + if (RB_FLONUM_P(obj)) return rb_cFloat; + if (obj == RUBY_Qtrue) return rb_cTrueClass; + if (RB_STATIC_SYM_P(obj)) return rb_cSymbol; } else if (!RTEST(obj)) { - if (obj == Qnil) return rb_cNilClass; - if (obj == Qfalse) return rb_cFalseClass; + if (obj == RUBY_Qnil) return rb_cNilClass; + if (obj == RUBY_Qfalse) return rb_cFalseClass; } return RBASIC(obj)->klass; } @@ -1487,32 +1948,20 @@ rb_class_of(VALUE obj) static inline int 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 (SYMBOL_P(obj)) return T_SYMBOL; - if (obj == Qundef) return T_UNDEF; + if (RB_IMMEDIATE_P(obj)) { + if (RB_FIXNUM_P(obj)) return RUBY_T_FIXNUM; + if (RB_FLONUM_P(obj)) return RUBY_T_FLOAT; + if (obj == RUBY_Qtrue) return RUBY_T_TRUE; + if (RB_STATIC_SYM_P(obj)) return RUBY_T_SYMBOL; + if (obj == RUBY_Qundef) return RUBY_T_UNDEF; } else if (!RTEST(obj)) { - if (obj == Qnil) return T_NIL; - if (obj == Qfalse) return T_FALSE; + if (obj == RUBY_Qnil) return RUBY_T_NIL; + if (obj == RUBY_Qfalse) return RUBY_T_FALSE; } - return BUILTIN_TYPE(obj); + return RB_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) : \ - ((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))) - #ifdef __GNUC__ #define rb_type_p(obj, type) \ __extension__ (__builtin_constant_p(type) ? RB_TYPE_P((obj), (type)) : \ @@ -1523,19 +1972,72 @@ rb_type(VALUE obj) #ifdef __GNUC__ #define rb_special_const_p(obj) \ - __extension__ ({VALUE special_const_obj = (obj); (int)(SPECIAL_CONST_P(special_const_obj) ? Qtrue : Qfalse);}) + __extension__ ({ \ + VALUE special_const_obj = (obj); \ + (int)(RB_SPECIAL_CONST_P(special_const_obj) ? RUBY_Qtrue : RUBY_Qfalse); \ + }) #else static inline int rb_special_const_p(VALUE obj) { - if (SPECIAL_CONST_P(obj)) return (int)Qtrue; - return (int)Qfalse; + if (RB_SPECIAL_CONST_P(obj)) return (int)RUBY_Qtrue; + return (int)RUBY_Qfalse; } #endif -#include "ruby/missing.h" #include "ruby/intern.h" +static inline void +rb_clone_setup(VALUE clone, VALUE obj) +{ + rb_obj_setup(clone, rb_singleton_class_clone(obj), RBASIC(obj)->flags); + rb_singleton_class_attached(RBASIC_CLASS(clone), clone); + if (RB_FL_TEST(obj, RUBY_FL_EXIVAR)) rb_copy_generic_ivar(clone, obj); +} + +static inline void +rb_dup_setup(VALUE dup, VALUE obj) +{ + rb_obj_setup(dup, rb_obj_class(obj), RB_FL_TEST_RAW(obj, RUBY_FL_DUPPED)); + if (RB_FL_TEST(obj, RUBY_FL_EXIVAR)) rb_copy_generic_ivar(dup, obj); +} + +static inline long +rb_array_len(VALUE a) +{ + return (RBASIC(a)->flags & RARRAY_EMBED_FLAG) ? + RARRAY_EMBED_LEN(a) : RARRAY(a)->as.heap.len; +} + +#if defined(__fcc__) || defined(__fcc_version) || \ + defined(__FCC__) || defined(__FCC_VERSION) +/* workaround for old version of Fujitsu C Compiler (fcc) */ +# define FIX_CONST_VALUE_PTR(x) ((const VALUE *)(x)) +#else +# define FIX_CONST_VALUE_PTR(x) (x) +#endif + +static inline const VALUE * +rb_array_const_ptr(VALUE a) +{ + return FIX_CONST_VALUE_PTR((RBASIC(a)->flags & RARRAY_EMBED_FLAG) ? + RARRAY(a)->as.ary : RARRAY(a)->as.heap.ptr); +} + +static inline long +rb_struct_len(VALUE st) +{ + return (RBASIC(st)->flags & RSTRUCT_EMBED_LEN_MASK) ? + RSTRUCT_EMBED_LEN(st) : RSTRUCT(st)->as.heap.len; +} + +static inline const VALUE * +rb_struct_const_ptr(VALUE st) +{ + return FIX_CONST_VALUE_PTR((RBASIC(st)->flags & RSTRUCT_EMBED_LEN_MASK) ? + RSTRUCT(st)->as.ary : RSTRUCT(st)->as.heap.ptr); +} + #if defined(EXTLIB) && defined(USE_DLN_A_OUT) /* hook for external modules */ static char *dln_libs_to_be_linked[] = { EXTLIB, 0 }; @@ -1545,6 +2047,7 @@ static char *dln_libs_to_be_linked[] = { EXTLIB, 0 }; #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 @@ -1555,10 +2058,34 @@ int ruby_native_thread_p(void); #define RUBY_EVENT_C_RETURN 0x0040 #define RUBY_EVENT_RAISE 0x0080 #define RUBY_EVENT_ALL 0x00ff -#define RUBY_EVENT_SWITCH 0x20000 -#define RUBY_EVENT_COVERAGE 0x40000 -typedef unsigned int rb_event_flag_t; +/* 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_FIBER_SWITCH 0x1000 +#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 RB_EVENT_HOOKS_HAVE_CALLBACK_DATA 1 @@ -1587,6 +2114,7 @@ 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)) @@ -1598,10 +2126,10 @@ int rb_toupper(int c); #define TOUPPER(c) rb_toupper((unsigned char)(c)) #define TOLOWER(c) rb_tolower((unsigned char)(c)) -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))) +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))) unsigned long ruby_strtoul(const char *str, char **endptr, int base); #define STRTOUL(str, endptr, base) (ruby_strtoul((str), (endptr), (base))) @@ -1619,7 +2147,7 @@ int ruby_vsnprintf(char *str, size_t n, char const *fmt, va_list ap); * @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. + * These functions are not a part of Ruby extension library API. * Extension libraries of Ruby should not depend on these functions. * @{ */ @@ -1681,9 +2209,7 @@ void ruby_sig_finalize(void); /*! @} */ -#if defined __GNUC__ && __GNUC__ >= 4 -#pragma GCC visibility pop -#endif +RUBY_SYMBOL_EXPORT_END #if defined(__cplusplus) #if 0 diff --git a/include/ruby/st.h b/include/ruby/st.h index c2294a92c1..190bad2a35 100644 --- a/include/ruby/st.h +++ b/include/ruby/st.h @@ -14,22 +14,7 @@ extern "C" { #include "ruby/defines.h" -#if defined STDC_HEADERS -#include <stddef.h> -#elif defined HAVE_STDLIB_H -#include <stdlib.h> -#endif - -#ifdef HAVE_STDINT_H -# include <stdint.h> -#endif -#ifdef HAVE_INTTYPES_H -# include <inttypes.h> -#endif - -#if defined __GNUC__ && __GNUC__ >= 4 -#pragma GCC visibility push(default) -#endif +RUBY_SYMBOL_EXPORT_BEGIN #if SIZEOF_LONG == SIZEOF_VOIDP typedef unsigned long st_data_t; @@ -74,6 +59,13 @@ struct st_hash_type { #define ST_INDEX_BITS (sizeof(st_index_t) * CHAR_BIT) +#if defined(HAVE_BUILTIN___BUILTIN_CHOOSE_EXPR) && defined(HAVE_BUILTIN___BUILTIN_TYPES_COMPATIBLE_P) +# define ST_DATA_COMPATIBLE_P(type) \ + __builtin_choose_expr(__builtin_types_compatible_p(type, st_data_t), 1, 0) +#else +# define ST_DATA_COMPATIBLE_P(type) 0 +#endif + struct st_table { const struct st_hash_type *type; st_index_t num_bins; @@ -86,7 +78,7 @@ struct st_table { * implementation-defined type. It is implementation-defined whether * atomic types are permitted. * In short, long and long long bit-field are implementation-defined - * feature. Therefore we want to supress a warning explicitly. + * feature. Therefore we want to suppress a warning explicitly. */ __extension__ #endif @@ -94,7 +86,7 @@ struct st_table { union { struct { struct st_table_entry **bins; - struct st_table_entry *head, *tail; + void *private_list_head[2]; } big; struct { struct st_packed_entry *entries; @@ -117,15 +109,23 @@ st_table *st_init_strcasetable(void); st_table *st_init_strcasetable_with_size(st_index_t); int st_delete(st_table *, st_data_t *, st_data_t *); /* returns 0:notfound 1:deleted */ int st_delete_safe(st_table *, st_data_t *, st_data_t *, st_data_t); +int st_shift(st_table *, st_data_t *, st_data_t *); /* returns 0:notfound 1:deleted */ int st_insert(st_table *, st_data_t, st_data_t); int st_insert2(st_table *, st_data_t, st_data_t, st_data_t (*)(st_data_t)); int st_lookup(st_table *, st_data_t, st_data_t *); int st_get_key(st_table *, st_data_t, st_data_t *); typedef int st_update_callback_func(st_data_t *key, st_data_t *value, st_data_t arg, int existing); +/* *key may be altered, but must equal to the old key, i.e., the + * results of hash() are same and compare() returns 0, otherwise the + * behavior is undefined */ int st_update(st_table *table, st_data_t key, st_update_callback_func *func, st_data_t arg); int st_foreach(st_table *, int (*)(ANYARGS), st_data_t); int st_foreach_check(st_table *, int (*)(ANYARGS), st_data_t, st_data_t); int st_reverse_foreach(st_table *, int (*)(ANYARGS), st_data_t); +st_index_t st_keys(st_table *table, st_data_t *keys, st_index_t size); +st_index_t st_keys_check(st_table *table, st_data_t *keys, st_index_t size, st_data_t never); +st_index_t st_values(st_table *table, st_data_t *values, st_index_t size); +st_index_t st_values_check(st_table *table, st_data_t *values, st_index_t size, st_data_t never); void st_add_direct(st_table *, st_data_t, st_data_t); void st_free_table(st_table *); void st_cleanup_safe(st_table *, st_data_t); @@ -133,8 +133,10 @@ void st_clear(st_table *); st_table *st_copy(st_table *); int st_numcmp(st_data_t, st_data_t); st_index_t st_numhash(st_data_t); -int st_strcasecmp(const char *s1, const char *s2); -int st_strncasecmp(const char *s1, const char *s2, size_t n); +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 st_strcasecmp st_locale_insensitive_strcasecmp +#define st_strncasecmp st_locale_insensitive_strncasecmp size_t st_memsize(const st_table *); st_index_t st_hash(const void *ptr, size_t len, st_index_t h); st_index_t st_hash_uint32(st_index_t h, uint32_t i); @@ -143,9 +145,7 @@ st_index_t st_hash_end(st_index_t h); st_index_t st_hash_start(st_index_t h); #define st_hash_start(h) ((st_index_t)(h)) -#if defined __GNUC__ && __GNUC__ >= 4 -#pragma GCC visibility pop -#endif +RUBY_SYMBOL_EXPORT_END #if defined(__cplusplus) #if 0 diff --git a/include/ruby/thread.h b/include/ruby/thread.h index d86a5d1e58..550f678e54 100644 --- a/include/ruby/thread.h +++ b/include/ruby/thread.h @@ -21,20 +21,19 @@ extern "C" { #include "ruby/intern.h" -#if defined __GNUC__ && __GNUC__ >= 4 -#pragma GCC visibility push(default) -#endif +RUBY_SYMBOL_EXPORT_BEGIN void *rb_thread_call_with_gvl(void *(*func)(void *), void *data1); + void *rb_thread_call_without_gvl(void *(*func)(void *), void *data1, rb_unblock_function_t *ubf, void *data2); -void *rb_thread_call_without_gvl2(void *(*func)(void *, int *), void *data1, - rb_unblock_function_t *ubf, void *data2); +void *rb_thread_call_without_gvl2(void *(*func)(void *), void *data1, + rb_unblock_function_t *ubf, void *data2); +#define RUBY_CALL_WO_GVL_FLAG_SKIP_CHECK_INTS_AFTER 0x01 +#define RUBY_CALL_WO_GVL_FLAG_SKIP_CHECK_INTS_ -#if defined __GNUC__ && __GNUC__ >= 4 -#pragma GCC visibility pop -#endif +RUBY_SYMBOL_EXPORT_END #if defined(__cplusplus) #if 0 diff --git a/include/ruby/thread_native.h b/include/ruby/thread_native.h new file mode 100644 index 0000000000..8e500c5a13 --- /dev/null +++ b/include/ruby/thread_native.h @@ -0,0 +1,56 @@ +/********************************************************************** + + thread_native.h - + + $Author: ko1 $ + created at: Wed May 14 19:37:31 2014 + + Copyright (C) 2014 Yukihiro Matsumoto + +**********************************************************************/ + +#ifndef RUBY_THREAD_NATIVE_H +#define RUBY_THREAD_NATIVE_H 1 + +/* + * This file contains wrapper APIs for native thread primitives + * which Ruby interpreter uses. + * + * Now, we only suppors pthread and Windows threads. + * + * If you want to use Ruby's Mutex and so on to synchronize Ruby Threads, + * please use Mutex directly. + */ + + +#if defined(_WIN32) +#include <windows.h> +typedef HANDLE rb_nativethread_id_t; + +typedef union rb_thread_lock_union { + HANDLE mutex; + CRITICAL_SECTION crit; +} rb_nativethread_lock_t; + +#elif defined(HAVE_PTHREAD_H) +#include <pthread.h> +typedef pthread_t rb_nativethread_id_t; +typedef pthread_mutex_t rb_nativethread_lock_t; + +#else +#error "unsupported thread type" + +#endif + +RUBY_SYMBOL_EXPORT_BEGIN + +rb_nativethread_id_t rb_nativethread_self(); + +void rb_nativethread_lock_initialize(rb_nativethread_lock_t *lock); +void rb_nativethread_lock_destroy(rb_nativethread_lock_t *lock); +void rb_nativethread_lock_lock(rb_nativethread_lock_t *lock); +void rb_nativethread_lock_unlock(rb_nativethread_lock_t *lock); + +RUBY_SYMBOL_EXPORT_END + +#endif diff --git a/include/ruby/util.h b/include/ruby/util.h index e82f537728..e9343b3390 100644 --- a/include/ruby/util.h +++ b/include/ruby/util.h @@ -45,24 +45,29 @@ extern "C" { #endif #endif -#if defined __GNUC__ && __GNUC__ >= 4 -#pragma GCC visibility push(default) -#endif +RUBY_SYMBOL_EXPORT_BEGIN + +#define DECIMAL_SIZE_OF_BITS(n) (((n) * 3010 + 9998) / 9999) +/* an approximation of ceil(n * log10(2)), up to 65536 at least */ #define scan_oct(s,l,e) ((int)ruby_scan_oct((s),(l),(e))) unsigned long ruby_scan_oct(const char *, size_t, size_t *); #define scan_hex(s,l,e) ((int)ruby_scan_hex((s),(l),(e))) unsigned long ruby_scan_hex(const char *, size_t, size_t *); +#ifdef HAVE_GNU_QSORT_R +# define ruby_qsort qsort_r +#else void ruby_qsort(void *, const size_t, const size_t, int (*)(const void *, const void *, void *), void *); +#endif void ruby_setenv(const char *, const char *); void ruby_unsetenv(const char *); #undef setenv #undef unsetenv #define setenv(name,val) ruby_setenv((name),(val)) -#define unsetenv(name,val) ruby_unsetenv(name); +#define unsetenv(name,val) ruby_unsetenv(name) char *ruby_strdup(const char *); #undef strdup @@ -75,19 +80,9 @@ double ruby_strtod(const char *, char **); #undef strtod #define strtod(s,e) ruby_strtod((s),(e)) -#if defined _MSC_VER && _MSC_VER >= 1300 -#pragma warning(push) -#pragma warning(disable:4723) -#endif -#if defined _MSC_VER && _MSC_VER >= 1300 -#pragma warning(pop) -#endif - void ruby_each_words(const char *, void (*)(const char*, int, void*), void *); -#if defined __GNUC__ && __GNUC__ >= 4 -#pragma GCC visibility pop -#endif +RUBY_SYMBOL_EXPORT_END #if defined(__cplusplus) #if 0 diff --git a/include/ruby/version.h b/include/ruby/version.h index b41b64fe66..bb1926f721 100644 --- a/include/ruby/version.h +++ b/include/ruby/version.h @@ -13,7 +13,7 @@ /* * This file contains only - * - never-changable informations, and + * - never-changeable informations, and * - interfaces accessible from extension libraries. * * Never try to check RUBY_VERSION_CODE etc in extension libraries, @@ -31,7 +31,7 @@ /* API version */ #define RUBY_API_VERSION_MAJOR 2 -#define RUBY_API_VERSION_MINOR 0 +#define RUBY_API_VERSION_MINOR 3 #define RUBY_API_VERSION_TEENY 0 #define RUBY_API_VERSION_CODE (RUBY_API_VERSION_MAJOR*10000+RUBY_API_VERSION_MINOR*100+RUBY_API_VERSION_TEENY) @@ -43,9 +43,7 @@ extern "C" { #endif #endif -#if defined __GNUC__ && __GNUC__ >= 4 -#pragma GCC visibility push(default) -#endif +RUBY_SYMBOL_EXPORT_BEGIN /* * Interfaces from extension libraries. @@ -63,9 +61,7 @@ RUBY_EXTERN const char ruby_description[]; RUBY_EXTERN const char ruby_copyright[]; RUBY_EXTERN const char ruby_engine[]; -#if defined __GNUC__ && __GNUC__ >= 4 -#pragma GCC visibility pop -#endif +RUBY_SYMBOL_EXPORT_END #if defined(__cplusplus) #if 0 diff --git a/include/ruby/vm.h b/include/ruby/vm.h index 1146bf5426..73345264bd 100644 --- a/include/ruby/vm.h +++ b/include/ruby/vm.h @@ -19,9 +19,7 @@ extern "C" { #endif #endif -#if defined __GNUC__ && __GNUC__ >= 4 -#pragma GCC visibility push(default) -#endif +RUBY_SYMBOL_EXPORT_BEGIN /* Place holder. * @@ -54,9 +52,7 @@ int ruby_vm_destruct(ruby_vm_t *vm); */ void ruby_vm_at_exit(void(*func)(ruby_vm_t *)); -#if defined __GNUC__ && __GNUC__ >= 4 -#pragma GCC visibility pop -#endif +RUBY_SYMBOL_EXPORT_END #if defined(__cplusplus) #if 0 diff --git a/include/ruby/win32.h b/include/ruby/win32.h index 9645cc888d..7bcd0e9125 100644 --- a/include/ruby/win32.h +++ b/include/ruby/win32.h @@ -8,9 +8,7 @@ extern "C" { #endif #endif -#if defined __GNUC__ && __GNUC__ >= 4 -#pragma GCC visibility push(default) -#endif +RUBY_SYMBOL_EXPORT_BEGIN /* * Copyright (c) 1993, Intergraph Corporation @@ -37,8 +35,14 @@ extern "C++" { /* template without extern "C++" */ #if !defined(_WIN64) && !defined(WIN32) #define WIN32 #endif +#if defined(_MSC_VER) && _MSC_VER <= 1200 +#include <windows.h> +#endif #include <winsock2.h> #include <ws2tcpip.h> +#if !defined(_MSC_VER) || _MSC_VER >= 1400 +#include <iphlpapi.h> +#endif #if defined(__cplusplus) && defined(_MSC_VER) } #endif @@ -76,7 +80,7 @@ extern "C++" { /* template without extern "C++" */ #endif #include <io.h> #include <malloc.h> -#if defined __MINGW32__ || __BORLANDC__ >= 0x0580 +#if defined __MINGW32__ # include <stdint.h> #else # if !defined(_INTPTR_T_DEFINED) @@ -87,6 +91,14 @@ typedef int intptr_t; # endif # define _INTPTR_T_DEFINED # endif +# if !defined(INTPTR_MAX) +# ifdef _WIN64 +# define INTPTR_MAX 9223372036854775807I64 +# else +# define INTPTR_MAX 2147483647 +# endif +# define INTPTR_MIN (-INTPTR_MAX-1) +# endif # if !defined(_UINTPTR_T_DEFINED) # ifdef _WIN64 typedef unsigned __int64 uintptr_t; @@ -95,6 +107,13 @@ typedef unsigned int uintptr_t; # endif # define _UINTPTR_T_DEFINED # endif +# if !defined(UINTPTR_MAX) +# ifdef _WIN64 +# define UINTPTR_MAX 18446744073709551615UI64 +# else +# define UINTPTR_MAX 4294967295U +# endif +# endif #endif #ifndef __MINGW32__ # define mode_t int @@ -108,27 +127,17 @@ typedef unsigned int uintptr_t; #define WNOHANG -1 -#undef getc -#undef putc -#undef fgetc -#undef fputc -#undef getchar -#undef putchar -#undef fgetchar -#undef fputchar +#define O_SHARE_DELETE 0x20000000 /* for rb_w32_open(), rb_w32_wopen() */ + +typedef int clockid_t; +#define CLOCK_REALTIME 0 +#define CLOCK_MONOTONIC 1 + #undef utime #undef lseek #undef stat #undef fstat -#define getc(_stream) rb_w32_getc(_stream) -#define getchar() rb_w32_getc(stdin) -#define putc(_c, _stream) rb_w32_putc(_c, _stream) -#define putchar(_c) rb_w32_putc(_c, stdout) #ifdef RUBY_EXPORT -#define fgetc(_stream) getc(_stream) -#define fputc(_c, _stream) putc(_c, _stream) -#define fgetchar() getchar() -#define fputchar(_c) putchar(_c) #define utime(_p, _t) rb_w32_utime(_p, _t) #define lseek(_f, _o, _w) _lseeki64(_f, _o, _w) @@ -143,28 +152,11 @@ typedef unsigned int uintptr_t; #define sleep(x) rb_w32_Sleep((x)*1000) #define Sleep(msec) (void)rb_w32_Sleep(msec) #define fstati64(fd,st) rb_w32_fstati64(fd,st) -#ifdef __BORLANDC__ -#define creat(p, m) _creat(p, m) -#define eof() _eof() -#define filelength(h) _filelength(h) -#define mktemp(t) _mktemp(t) -#define tell(h) _tell(h) -#define _open _sopen -#define sopen _sopen -#undef fopen -#define fopen(p, m) rb_w32_fopen(p, m) -#undef fdopen -#define fdopen(h, m) rb_w32_fdopen(h, m) -#undef fsopen -#define fsopen(p, m, sh) rb_w32_fsopen(p, m, sh) -#endif /* __BORLANDC__ */ #undef execv #define execv(path,argv) rb_w32_aspawn(P_OVERLAY,path,argv) -#if !defined(__BORLANDC__) #undef isatty #define isatty(h) rb_w32_isatty(h) -#endif /* __BORLANDC__ */ #undef mkdir #define mkdir(p, m) rb_w32_mkdir(p, m) @@ -177,10 +169,8 @@ typedef unsigned int uintptr_t; #if SIZEOF_OFF_T == 8 #define off_t __int64 #define stat stati64 -#define fstat(fd,st) _fstati64(fd,st) -#if defined(__BORLANDC__) -#define stati64(path, st) rb_w32_stati64(path, st) -#elif !defined(_MSC_VER) || RT_VER < 80 +#define fstat(fd,st) fstati64(fd,st) +#if !defined(_MSC_VER) || RUBY_MSVCRT_VERSION < 80 #define stati64 _stati64 #ifndef _stati64 #define _stati64(path, st) rb_w32_stati64(path, st) @@ -195,6 +185,7 @@ typedef unsigned int uintptr_t; extern int rb_w32_stat(const char *, struct stat *); extern int rb_w32_fstat(int, struct stat *); #endif +#define lstat(path,st) rb_w32_lstati64(path,st) #define access(path,mode) rb_w32_access(path,mode) #define strcasecmp _stricmp @@ -222,8 +213,27 @@ struct msghdr { int msg_flags; }; +/* for getifaddrs() and others */ +struct ifaddrs { + struct ifaddrs *ifa_next; + char *ifa_name; + u_int ifa_flags; + struct sockaddr *ifa_addr; + struct sockaddr *ifa_netmask; + struct sockaddr *ifa_broadaddr; + struct sockaddr *ifa_dstaddr; + void *ifa_data; +}; +#ifdef IF_NAMESIZE +#define IFNAMSIZ IF_NAMESIZE +#else +#define IFNAMSIZ 256 +#endif +#ifdef IFF_POINTTOPOINT +#define IFF_POINTOPOINT IFF_POINTTOPOINT +#endif + extern DWORD rb_w32_osid(void); -extern int rb_w32_cmdvector(const char *, char ***); extern rb_pid_t rb_w32_pipe_exec(const char *, const char *, int, int *, int *); extern int flock(int fd, int oper); extern int rb_w32_io_cancelable_p(int); @@ -257,7 +267,9 @@ extern struct protoent *WSAAPI rb_w32_getprotobyname(const char *); extern struct protoent *WSAAPI rb_w32_getprotobynumber(int); extern struct servent *WSAAPI rb_w32_getservbyname(const char *, const char *); extern struct servent *WSAAPI rb_w32_getservbyport(int, const char *); -extern int rb_w32_socketpair(int, int, int, int *); +extern int socketpair(int, int, int, int *); +extern int getifaddrs(struct ifaddrs **); +extern void freeifaddrs(struct ifaddrs *); extern char * rb_w32_getcwd(char *, int); extern char * rb_w32_ugetenv(const char *); extern char * rb_w32_getenv(const char *); @@ -267,24 +279,34 @@ extern char **rb_w32_get_environ(void); extern void rb_w32_free_environ(char **); extern int rb_w32_map_errno(DWORD); extern const char *WSAAPI rb_w32_inet_ntop(int,const void *,char *,size_t); +extern int WSAAPI rb_w32_inet_pton(int,const char *,void *); extern DWORD rb_w32_osver(void); extern int chown(const char *, int, int); extern int rb_w32_uchown(const char *, int, int); extern int link(const char *, const char *); extern int rb_w32_ulink(const char *, const char *); +extern ssize_t readlink(const char *, char *, size_t); +extern ssize_t rb_w32_ureadlink(const char *, char *, size_t); +extern ssize_t rb_w32_wreadlink(const WCHAR *, WCHAR *, size_t); +extern int symlink(const char *src, const char *link); +extern int rb_w32_usymlink(const char *src, const char *link); extern int gettimeofday(struct timeval *, struct timezone *); +extern int clock_gettime(clockid_t, struct timespec *); +extern int clock_getres(clockid_t, struct timespec *); extern rb_pid_t waitpid (rb_pid_t, int *, int); extern rb_pid_t rb_w32_spawn(int, const char *, const char*); extern rb_pid_t rb_w32_aspawn(int, const char *, char *const *); extern rb_pid_t rb_w32_aspawn_flags(int, const char *, char *const *, DWORD); +extern rb_pid_t rb_w32_uspawn(int, const char *, const char*); +extern rb_pid_t rb_w32_uaspawn(int, const char *, char *const *); +extern rb_pid_t rb_w32_uaspawn_flags(int, const char *, char *const *, DWORD); extern int kill(int, int); extern int fcntl(int, int, ...); +extern int rb_w32_set_nonblock(int); extern rb_pid_t rb_w32_getpid(void); extern rb_pid_t rb_w32_getppid(void); -#if !defined(__BORLANDC__) extern int rb_w32_isatty(int); -#endif extern int rb_w32_uchdir(const char *); extern int rb_w32_mkdir(const char *, int); extern int rb_w32_umkdir(const char *, int); @@ -295,19 +317,29 @@ extern int rb_w32_uunlink(const char *); extern int rb_w32_uchmod(const char *, int); extern int rb_w32_stati64(const char *, struct stati64 *); extern int rb_w32_ustati64(const char *, struct stati64 *); +extern int rb_w32_lstati64(const char *, struct stati64 *); +extern int rb_w32_ulstati64(const char *, struct stati64 *); extern int rb_w32_access(const char *, int); extern int rb_w32_uaccess(const char *, int); extern char rb_w32_fd_is_text(int); extern int rb_w32_fstati64(int, struct stati64 *); +extern int rb_w32_dup2(int, int); + +#include <float.h> -#ifdef __BORLANDC__ -extern off_t _lseeki64(int, off_t, int); -extern FILE *rb_w32_fopen(const char *, const char *); -extern FILE *rb_w32_fdopen(int, const char *); -extern FILE *rb_w32_fsopen(const char *, const char *, int); +#if defined _MSC_VER && _MSC_VER >= 1800 && defined INFINITY +#pragma warning(push) +#pragma warning(disable:4756) +static inline float +rb_infinity_float(void) +{ + return INFINITY; +} +#pragma warning(pop) +#undef INFINITY +#define INFINITY rb_infinity_float() #endif -#include <float.h> #if !defined __MINGW32__ || defined __NO_ISOCEXT #ifndef isnan #define isnan(x) _isnan(x) @@ -325,25 +357,14 @@ scalb(double a, long b) { return _scalb(a, b); } +#else +__declspec(dllimport) extern int finite(double); #endif #if !defined S_IFIFO && defined _S_IFIFO #define S_IFIFO _S_IFIFO #endif -#if 0 && defined __BORLANDC__ -#undef S_ISDIR -#undef S_ISFIFO -#undef S_ISBLK -#undef S_ISCHR -#undef S_ISREG -#define S_ISDIR(m) (((unsigned short)(m) & S_IFMT) == S_IFDIR) -#define S_ISFIFO(m) (((unsigned short)(m) & S_IFMT) == S_IFIFO) -#define S_ISBLK(m) (((unsigned short)(m) & S_IFMT) == S_IFBLK) -#define S_ISCHR(m) (((unsigned short)(m) & S_IFMT) == S_IFCHR) -#define S_ISREG(m) (((unsigned short)(m) & S_IFMT) == S_IFREG) -#endif - #if !defined S_IRUSR && !defined __MINGW32__ #define S_IRUSR 0400 #endif @@ -374,16 +395,17 @@ scalb(double a, long b) #define S_IXOTH 0001 #endif +#define S_IFLNK 0xa000 + /* * define this so we can do inplace editing */ #define SUFFIX -extern int rb_w32_ftruncate(int fd, off_t length); -extern int rb_w32_truncate(const char *path, off_t length); -extern off_t rb_w32_ftello(FILE *stream); -extern int rb_w32_fseeko(FILE *stream, off_t offset, int whence); +extern int rb_w32_ftruncate(int fd, off_t length); +extern int rb_w32_truncate(const char *path, off_t length); +extern int rb_w32_utruncate(const char *path, off_t length); #undef HAVE_FTRUNCATE #define HAVE_FTRUNCATE 1 @@ -401,20 +423,9 @@ extern int rb_w32_fseeko(FILE *stream, off_t offset, int whence); #define truncate rb_w32_truncate #endif -#undef HAVE_FSEEKO -#define HAVE_FSEEKO 1 -#if defined HAVE_FSEEKO64 -#define fseeko fseeko64 -#else -#define fseeko rb_w32_fseeko -#endif - -#undef HAVE_FTELLO -#define HAVE_FTELLO 1 -#if defined HAVE_FTELLO64 -#define ftello ftello64 -#else -#define ftello rb_w32_ftello +#if defined(_MSC_VER) && _MSC_VER >= 1400 && _MSC_VER < 1800 +#define strtoll _strtoi64 +#define strtoull _strtoui64 #endif /* @@ -428,6 +439,8 @@ extern rb_gid_t getegid (void); extern int setuid (rb_uid_t); extern int setgid (rb_gid_t); +extern int fstati64(int, struct stati64 *); + extern char *rb_w32_strerror(int); #ifdef RUBY_EXPORT @@ -565,15 +578,14 @@ extern char *rb_w32_strerror(int); #endif #define F_DUPFD 0 -#if 0 #define F_GETFD 1 #define F_SETFD 2 +#if 0 #define F_GETFL 3 #endif #define F_SETFL 4 -#if 0 +#define F_DUPFD_CLOEXEC 67 #define FD_CLOEXEC 1 /* F_GETFD, F_SETFD */ -#endif #define O_NONBLOCK 1 #undef FD_SET @@ -604,6 +616,9 @@ extern char *rb_w32_strerror(int); #undef inet_ntop #define inet_ntop(f,a,n,l) rb_w32_inet_ntop(f,a,n,l) +#undef inet_pton +#define inet_pton(f,s,d) rb_w32_inet_pton(f,s,d) + #undef accept #define accept(s, a, l) rb_w32_accept(s, a, l) @@ -673,9 +688,6 @@ extern char *rb_w32_strerror(int); #undef getservbyport #define getservbyport(p, pr) rb_w32_getservbyport(p, pr) -#undef socketpair -#define socketpair(a, t, p, s) rb_w32_socketpair(a, t, p, s) - #undef get_osfhandle #define get_osfhandle(h) rb_w32_get_osfhandle(h) @@ -690,6 +702,9 @@ extern char *rb_w32_strerror(int); #undef times #define times(t) rb_w32_times(t) + +#undef dup2 +#define dup2(o, n) rb_w32_dup2(o, n) #endif struct tms { @@ -706,8 +721,6 @@ struct tm *localtime_r(const time_t *, struct tm *); /* thread stuff */ int rb_w32_sleep(unsigned long msec); -int rb_w32_putc(int, FILE*); -int rb_w32_getc(FILE*); int rb_w32_open(const char *, int, ...); int rb_w32_uopen(const char *, int, ...); int rb_w32_wopen(const WCHAR *, int, ...); @@ -724,22 +737,23 @@ int rb_w32_wait_events_blocking(HANDLE *events, int num, DWORD timeout); int rb_w32_time_subtract(struct timeval *rest, const struct timeval *wait); int rb_w32_wrap_io_handle(HANDLE, int); int rb_w32_unwrap_io_handle(int); +WCHAR *rb_w32_mbstr_to_wstr(UINT, const char *, int, long *); +char *rb_w32_wstr_to_mbstr(UINT, const WCHAR *, int, long *); /* == ***CAUTION*** Since this function is very dangerous, ((*NEVER*)) * lock any HANDLEs(i.e. Mutex, Semaphore, CriticalSection and so on) or, -* use anything like TRAP_BEG...TRAP_END block structure, +* use anything like rb_thread_call_without_gvl, in asynchronous_func_t. */ typedef uintptr_t (*asynchronous_func_t)(uintptr_t self, int argc, uintptr_t* argv); uintptr_t rb_w32_asynchronize(asynchronous_func_t func, uintptr_t self, int argc, uintptr_t* argv, uintptr_t intrval); -#if defined __GNUC__ && __GNUC__ >= 4 -#pragma GCC visibility pop -#endif +RUBY_SYMBOL_EXPORT_END -#ifdef __MINGW_ATTRIB_PURE +#if (defined(__MINGW64_VERSION_MAJOR) || defined(__MINGW64__)) && !defined(__cplusplus) +#ifdef RUBY_MINGW64_BROKEN_FREXP_MODF /* License: Ruby's */ /* get rid of bugs in math.h of mingw */ #define frexp(_X, _Y) __extension__ ({\ @@ -757,13 +771,6 @@ uintptr_t rb_w32_asynchronize(asynchronous_func_t func, uintptr_t self, int argc }) #endif -#if defined(__cplusplus) -#if 0 -{ /* satisfy cc-mode */ -#endif -} /* extern "C" { */ -#endif - #if defined(__MINGW64__) /* * Use powl() instead of broken pow() of x86_64-w64-mingw32. @@ -776,24 +783,16 @@ rb_w32_pow(double x, double y) return powl(x, y); } #elif defined(__MINGW64_VERSION_MAJOR) -/* - * Set floating point precision for pow() of mingw-w64 x86. - * With default precision the result is not proper on WinXP. - */ -static inline double -rb_w32_pow(double x, double y) -{ - double r; - unsigned int default_control = _controlfp(0, 0); - _controlfp(_PC_64, _MCW_PC); - r = pow(x, y); - /* Restore setting */ - _controlfp(default_control, _MCW_PC); - return r; -} +double rb_w32_pow(double x, double y); #endif -#if defined(__MINGW64_VERSION_MAJOR) || defined(__MINGW64__) #define pow rb_w32_pow #endif +#if defined(__cplusplus) +#if 0 +{ /* satisfy cc-mode */ +#endif +} /* extern "C" { */ +#endif + #endif /* RUBY_WIN32_H */ |