diff options
Diffstat (limited to 'include/ruby')
| -rw-r--r-- | include/ruby/backward/classext.h | 18 | ||||
| -rw-r--r-- | include/ruby/backward/rubysig.h | 9 | ||||
| -rw-r--r-- | include/ruby/debug.h | 110 | ||||
| -rw-r--r-- | include/ruby/defines.h | 244 | ||||
| -rw-r--r-- | include/ruby/encoding.h | 134 | ||||
| -rw-r--r-- | include/ruby/intern.h | 502 | ||||
| -rw-r--r-- | include/ruby/io.h | 123 | ||||
| -rw-r--r-- | include/ruby/missing.h | 77 | ||||
| -rw-r--r-- | include/ruby/oniguruma.h | 140 | ||||
| -rw-r--r-- | include/ruby/re.h | 6 | ||||
| -rw-r--r-- | include/ruby/regex.h | 4 | ||||
| -rw-r--r-- | include/ruby/ruby.h | 1174 | ||||
| -rw-r--r-- | include/ruby/st.h | 70 | ||||
| -rw-r--r-- | include/ruby/subst.h | 19 | ||||
| -rw-r--r-- | include/ruby/thread.h | 45 | ||||
| -rw-r--r-- | include/ruby/thread_native.h | 56 | ||||
| -rw-r--r-- | include/ruby/util.h | 30 | ||||
| -rw-r--r-- | include/ruby/version.h | 13 | ||||
| -rw-r--r-- | include/ruby/vm.h | 22 | ||||
| -rw-r--r-- | include/ruby/win32.h | 251 |
20 files changed, 956 insertions, 2091 deletions
diff --git a/include/ruby/backward/classext.h b/include/ruby/backward/classext.h deleted file mode 100644 index 33f3b014b8..0000000000 --- a/include/ruby/backward/classext.h +++ /dev/null @@ -1,18 +0,0 @@ -#if defined __GNUC__ -#warning use of RClass internals is deprecated -#elif defined _MSC_VER || defined __BORLANDC__ -#pragma message("warning: use of RClass internals is deprecated") -#endif - -#ifndef RUBY_BACKWARD_CLASSEXT_H -#define RUBY_BACKWARD_CLASSEXT_H 1 - -typedef struct rb_deprecated_classext_struct { - VALUE super; -} rb_deprecated_classext_t; - -#undef RCLASS_SUPER(c) -#define RCLASS_EXT(c) ((rb_deprecated_classext_t *)RCLASS(c)->ptr) -#define RCLASS_SUPER(c) (RCLASS(c)->super) - -#endif /* RUBY_BACKWARD_CLASSEXT_H */ diff --git a/include/ruby/backward/rubysig.h b/include/ruby/backward/rubysig.h index ade4fe27bd..3952f7e85e 100644 --- a/include/ruby/backward/rubysig.h +++ b/include/ruby/backward/rubysig.h @@ -27,16 +27,17 @@ extern "C" { #endif #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() -RUBY_SYMBOL_EXPORT_END - #if defined(__cplusplus) #if 0 { /* satisfy cc-mode */ diff --git a/include/ruby/debug.h b/include/ruby/debug.h deleted file mode 100644 index 9bfc9b9a83..0000000000 --- a/include/ruby/debug.h +++ /dev/null @@ -1,110 +0,0 @@ -/********************************************************************** - - 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 f83ced006c..7bb2788aaf 100644 --- a/include/ruby/defines.h +++ b/include/ruby/defines.h @@ -17,58 +17,9 @@ extern "C" { #endif #endif -#include "ruby/config.h" -#ifdef RUBY_EXTCONF_H -#include RUBY_EXTCONF_H -#endif - -/* 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 +#include <stdlib.h> #ifdef __cplusplus # ifndef HAVE_PROTOTYPES # define HAVE_PROTOTYPES 1 @@ -98,13 +49,6 @@ extern "C" { #define ANYARGS #endif -#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 @@ -112,17 +56,11 @@ RUBY_SYMBOL_EXPORT_BEGIN #define xrealloc2 ruby_xrealloc2 #define xfree ruby_xfree -#if defined(__GNUC__) && __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 *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); void xfree(void*); #define STRINGIZE(expr) STRINGIZE0(expr) @@ -130,10 +68,6 @@ 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 @@ -143,6 +77,44 @@ 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 +#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 +#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 +#else +# define BDIGIT unsigned short +# define SIZEOF_BDIGITS (SIZEOF_LONG/2) +# define BDIGIT_DBL unsigned long +# define BDIGIT_DBL_SIGNED long +#endif + +#ifdef INFINITY +# define HAVE_INFINITY +#else +/** @internal */ +extern const unsigned char rb_infinity[]; +# define INFINITY (*(float *)rb_infinity) +#endif + +#ifdef NAN +# define HAVE_NAN +#else +/** @internal */ +extern const unsigned char rb_nan[]; +# define NAN (*(float *)rb_nan) +#endif + #ifdef __CYGWIN__ #undef _WIN32 #endif @@ -159,12 +131,89 @@ void xfree(void*); #endif #endif +#ifdef __NeXT__ +/* NextStep, OpenStep, Rhapsody */ +#ifndef S_IRUSR +#define S_IRUSR 0000400 /* read permission, owner */ +#endif +#ifndef S_IRGRP +#define S_IRGRP 0000040 /* read permission, group */ +#endif +#ifndef S_IROTH +#define S_IROTH 0000004 /* read permission, other */ +#endif +#ifndef S_IWUSR +#define S_IWUSR 0000200 /* write permission, owner */ +#endif +#ifndef S_IWGRP +#define S_IWGRP 0000020 /* write permission, group */ +#endif +#ifndef S_IWOTH +#define S_IWOTH 0000002 /* write permission, other */ +#endif +#ifndef S_IXUSR +#define S_IXUSR 0000100 /* execute/search permission, owner */ +#endif +#ifndef S_IXGRP +#define S_IXGRP 0000010 /* execute/search permission, group */ +#endif +#ifndef S_IXOTH +#define S_IXOTH 0000001 /* execute/search permission, other */ +#endif +#ifndef S_IRWXU +#define S_IRWXU 0000700 /* read, write, execute permissions, owner */ +#endif +#ifndef S_IRWXG +#define S_IRWXG 0000070 /* read, write, execute permissions, group */ +#endif +#ifndef S_IRWXO +#define S_IRWXO 0000007 /* read, write, execute permissions, other */ +#endif +#ifndef S_ISBLK +#define S_ISBLK(mode) (((mode) & (0170000)) == (0060000)) +#endif +#ifndef S_ISCHR +#define S_ISCHR(mode) (((mode) & (0170000)) == (0020000)) +#endif +#ifndef S_ISDIR +#define S_ISDIR(mode) (((mode) & (0170000)) == (0040000)) +#endif +#ifndef S_ISFIFO +#define S_ISFIFO(mode) (((mode) & (0170000)) == (0010000)) +#endif +#ifndef S_ISREG +#define S_ISREG(mode) (((mode) & (0170000)) == (0100000)) +#endif +#ifndef __APPLE__ +/* NextStep, OpenStep (but not Rhapsody) */ +#ifndef GETPGRP_VOID +#define GETPGRP_VOID 1 +#endif +#ifndef WNOHANG +#define WNOHANG 01 +#endif +#ifndef WUNTRACED +#define WUNTRACED 02 +#endif +#ifndef X_OK +#define X_OK 1 +#endif +#endif /* __APPLE__ */ +#endif /* NeXT */ + #ifdef _WIN32 #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 @@ -183,10 +232,6 @@ void xfree(void*); #endif -#ifndef RUBY_FUNC_EXPORTED -#define RUBY_FUNC_EXPORTED -#endif - #ifndef RUBY_EXTERN #define RUBY_EXTERN extern #endif @@ -200,9 +245,22 @@ void xfree(void*); /* MB_CUR_MAX will not work well in C locale */ #endif -#if defined(__sparc) -void rb_sparc_flush_register_windows(void); -# define FLUSH_REGISTER_WINDOWS rb_sparc_flush_register_windows() +#if defined(sparc) || defined(__sparc__) +static inline void +flush_register_windows(void) +{ + asm +#ifdef __GNUC__ + volatile +#endif +# if defined(__sparc_v9__) || defined(__sparcv9) || defined(__arch64__) + ("flushw") +# else + ("ta 0x03") +# endif /* trap always to flush register windows if we are on a Sparc system */ + ; +} +# define FLUSH_REGISTER_WINDOWS flush_register_windows() #elif defined(__ia64) void *rb_ia64_bsp(void); void rb_ia64_flushrs(void); @@ -240,12 +298,9 @@ void rb_ia64_flushrs(void); #define RUBY_PLATFORM "unknown-unknown" #endif -#ifndef FUNC_MINIMIZED -#define FUNC_MINIMIZED(x) x -#endif #ifndef RUBY_ALIAS_FUNCTION_TYPE #define RUBY_ALIAS_FUNCTION_TYPE(type, prot, name, args) \ - FUNC_MINIMIZED(type prot) {return name args;} + type prot {return name args;} #endif #ifndef RUBY_ALIAS_FUNCTION_VOID #define RUBY_ALIAS_FUNCTION_VOID(prot, name, args) \ @@ -256,29 +311,6 @@ void rb_ia64_flushrs(void); RUBY_ALIAS_FUNCTION_TYPE(VALUE, prot, name, args) #endif -#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 7d33e538de..1573b5b200 100644 --- a/include/ruby/encoding.h +++ b/include/ruby/encoding.h @@ -22,17 +22,22 @@ extern "C" { #include <stdarg.h> #include "ruby/oniguruma.h" -RUBY_SYMBOL_EXPORT_BEGIN - -#define ENCODING_INLINE_MAX 127 +#define ENCODING_INLINE_MAX 1023 #define ENCODING_SHIFT (FL_USHIFT+10) -#define ENCODING_MASK (((VALUE)ENCODING_INLINE_MAX)<<ENCODING_SHIFT) /* FL_USER10|FL_USER11|FL_USER12|FL_USER13|FL_USER14|FL_USER15|FL_USER16 */ +#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) rb_enc_set_index((obj), (i)) +#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); \ +} while (0) #define ENCODING_GET_INLINED(obj) (int)((RBASIC(obj)->flags & ENCODING_MASK)>>ENCODING_SHIFT) #define ENCODING_GET(obj) \ @@ -53,12 +58,12 @@ RUBY_SYMBOL_EXPORT_BEGIN #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) +#define ENC_CODERANGE_CLEAR(obj) 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)) : \ + (a == ENC_CODERANGE_7BIT ? b : \ + a == ENC_CODERANGE_VALID ? (b == ENC_CODERANGE_7BIT ? ENC_CODERANGE_VALID : b) : \ ENC_CODERANGE_UNKNOWN) #define ENCODING_CODERANGE_SET(obj, encindex, cr) \ @@ -68,30 +73,24 @@ RUBY_SYMBOL_EXPORT_BEGIN ENC_CODERANGE_SET(rb_encoding_coderange_obj, (cr)); \ } while (0) -typedef const OnigEncodingType rb_encoding; - -int rb_char_to_option_kcode(int c, int *option, int *kcode); +typedef OnigEncodingType rb_encoding; int rb_enc_replicate(const char *, rb_encoding *); int rb_define_dummy_encoding(const char *); -int rb_enc_dummy_p(rb_encoding *enc); -int rb_enc_to_index(rb_encoding *enc); +#define rb_enc_to_index(enc) ((enc) ? ENC_TO_ENCINDEX(enc) : 0) 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_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); @@ -106,28 +105,11 @@ 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 @@ -161,37 +143,33 @@ unsigned int rb_enc_codepoint_len(const char *p, const char *e, int *len, rb_enc unsigned int rb_enc_codepoint(const char *p, const char *e, rb_encoding *enc); /* overriding macro */ #define rb_enc_codepoint(p,e,enc) rb_enc_codepoint_len((p),(e),0,(enc)) -#define rb_enc_mbc_to_codepoint(p, e, enc) ONIGENC_MBC_TO_CODE((enc),(UChar*)(p),(UChar*)(e)) +#define rb_enc_mbc_to_codepoint(p, e, enc) ONIGENC_MBC_TO_CODE(enc,(UChar*)(p),(UChar*)(e)) /* -> 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)) +#define rb_enc_mbcput(c,buf,enc) ONIGENC_CODE_TO_MBC(enc,c,(UChar*)(buf)) /* start, ptr, end, encoding -> prev_char */ -#define rb_enc_prev_char(s,p,e,enc) ((char *)onigenc_get_prev_char_head((enc),(UChar*)(s),(UChar*)(p),(UChar*)(e))) +#define rb_enc_prev_char(s,p,e,enc) (char *)onigenc_get_prev_char_head(enc,(UChar*)(s),(UChar*)(p),(UChar*)(e)) /* start, ptr, end, encoding -> next_char */ -#define rb_enc_left_char_head(s,p,e,enc) ((char *)onigenc_get_left_adjust_char_head((enc),(UChar*)(s),(UChar*)(p),(UChar*)(e))) -#define rb_enc_right_char_head(s,p,e,enc) ((char *)onigenc_get_right_adjust_char_head((enc),(UChar*)(s),(UChar*)(p),(UChar*)(e))) -#define rb_enc_step_back(s,p,e,n,enc) ((char *)onigenc_step_back((enc),(UChar*)(s),(UChar*)(p),(UChar*)(e),(int)(n))) +#define rb_enc_left_char_head(s,p,e,enc) (char *)onigenc_get_left_adjust_char_head(enc,(UChar*)(s),(UChar*)(p),(UChar*)(e)) +#define rb_enc_right_char_head(s,p,e,enc) (char *)onigenc_get_right_adjust_char_head(enc,(UChar*)(s),(UChar*)(p),(UChar*)(e)) /* ptr, ptr, encoding -> newline_or_not */ -#define rb_enc_is_newline(p,end,enc) ONIGENC_IS_MBC_NEWLINE((enc),(UChar*)(p),(UChar*)(end)) +#define rb_enc_is_newline(p,end,enc) ONIGENC_IS_MBC_NEWLINE(enc,(UChar*)(p),(UChar*)(end)) -#define rb_enc_isctype(c,t,enc) ONIGENC_IS_CODE_CTYPE((enc),(c),(t)) +#define rb_enc_isctype(c,t,enc) ONIGENC_IS_CODE_CTYPE(enc,c,t) #define rb_enc_isascii(c,enc) ONIGENC_IS_CODE_ASCII(c) -#define rb_enc_isalpha(c,enc) ONIGENC_IS_CODE_ALPHA((enc),(c)) -#define rb_enc_islower(c,enc) ONIGENC_IS_CODE_LOWER((enc),(c)) -#define rb_enc_isupper(c,enc) ONIGENC_IS_CODE_UPPER((enc),(c)) -#define rb_enc_ispunct(c,enc) ONIGENC_IS_CODE_PUNCT((enc),(c)) -#define rb_enc_isalnum(c,enc) ONIGENC_IS_CODE_ALNUM((enc),(c)) -#define rb_enc_isprint(c,enc) ONIGENC_IS_CODE_PRINT((enc),(c)) -#define rb_enc_isspace(c,enc) ONIGENC_IS_CODE_SPACE((enc),(c)) -#define rb_enc_isdigit(c,enc) ONIGENC_IS_CODE_DIGIT((enc),(c)) +#define rb_enc_isalpha(c,enc) ONIGENC_IS_CODE_ALPHA(enc,c) +#define rb_enc_islower(c,enc) ONIGENC_IS_CODE_LOWER(enc,c) +#define rb_enc_isupper(c,enc) ONIGENC_IS_CODE_UPPER(enc,c) +#define rb_enc_ispunct(c,enc) ONIGENC_IS_CODE_PUNCT(enc,c) +#define rb_enc_isalnum(c,enc) ONIGENC_IS_CODE_ALNUM(enc,c) +#define rb_enc_isprint(c,enc) ONIGENC_IS_CODE_PRINT(enc,c) +#define rb_enc_isspace(c,enc) ONIGENC_IS_CODE_SPACE(enc,c) +#define rb_enc_isdigit(c,enc) ONIGENC_IS_CODE_DIGIT(enc,c) #define rb_enc_asciicompat(enc) (rb_enc_mbminlen(enc)==1 && !rb_enc_dummy_p(enc)) @@ -215,15 +193,9 @@ 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); @@ -232,16 +204,21 @@ void rb_enc_set_default_external(VALUE encoding); void rb_enc_set_default_internal(VALUE encoding); VALUE rb_locale_charmap(VALUE klass); long rb_memsearch(const void*,long,const void*,long,rb_encoding*); -char *rb_enc_path_next(const char *,const char *,rb_encoding*); -char *rb_enc_path_skip_prefix(const char *,const char *,rb_encoding*); -char *rb_enc_path_last_separator(const char *,const char *,rb_encoding*); -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 */ @@ -260,7 +237,6 @@ typedef struct rb_econv_t rb_econv_t; VALUE rb_str_encode(VALUE str, VALUE to, int ecflags, VALUE ecopts); int rb_econv_has_convpath_p(const char* from_encoding, const char* to_encoding); -int rb_econv_prepare_options(VALUE opthash, VALUE *ecopts, int ecflags); int rb_econv_prepare_opts(VALUE opthash, VALUE *ecopts); rb_econv_t *rb_econv_open(const char *source_encoding, const char *destination_encoding, int ecflags); @@ -305,7 +281,6 @@ 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); @@ -321,9 +296,6 @@ void rb_econv_binmode(rb_econv_t *ec); #define 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 #define ECONV_UNIVERSAL_NEWLINE_DECORATOR 0x00000100 #define ECONV_CRLF_NEWLINE_DECORATOR 0x00001000 @@ -334,12 +306,6 @@ void rb_econv_binmode(rb_econv_t *ec); #define ECONV_STATEFUL_DECORATOR_MASK 0x00f00000 #define ECONV_XML_ATTR_QUOTE_DECORATOR 0x00100000 -#if defined(RUBY_TEST_CRLF_ENVIRONMENT) || defined(_WIN32) -#define ECONV_DEFAULT_NEWLINE_DECORATOR ECONV_CRLF_NEWLINE_DECORATOR -#else -#define ECONV_DEFAULT_NEWLINE_DECORATOR 0 -#endif - /* end of flags for rb_econv_open */ /* flags for rb_econv_convert */ @@ -347,8 +313,6 @@ void rb_econv_binmode(rb_econv_t *ec); #define ECONV_AFTER_OUTPUT 0x00020000 /* end of flags for rb_econv_convert */ -RUBY_SYMBOL_EXPORT_END - #if defined(__cplusplus) #if 0 { /* satisfy cc-mode */ diff --git a/include/ruby/intern.h b/include/ruby/intern.h index 00474a739b..f0cff67928 100644 --- a/include/ruby/intern.h +++ b/include/ruby/intern.h @@ -21,49 +21,37 @@ extern "C" { #endif #endif -#include "ruby/defines.h" -#ifdef RUBY_EXTCONF_H -#include RUBY_EXTCONF_H -#endif - #ifdef HAVE_STDARG_PROTOTYPES # include <stdarg.h> #else # include <varargs.h> #endif - #include "ruby/st.h" -RUBY_SYMBOL_EXPORT_BEGIN - /* * Functions and variables that are used by more than one source file of * the kernel. */ -#define UNLIMITED_ARGUMENTS (-1) +#define ID_ALLOCATOR 1 /* array.c */ 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_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_new2(long); +VALUE rb_ary_new3(long,...); +VALUE rb_ary_new4(long, const VALUE *); VALUE rb_ary_tmp_new(long); void rb_ary_free(VALUE); -void rb_ary_modify(VALUE); VALUE rb_ary_freeze(VALUE); -VALUE rb_ary_shared_with_p(VALUE, VALUE); -VALUE rb_ary_aref(int, const VALUE*, VALUE); +VALUE rb_ary_aref(int, 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); @@ -71,8 +59,8 @@ VALUE rb_ary_unshift(VALUE, VALUE); VALUE rb_ary_entry(VALUE, long); VALUE rb_ary_each(VALUE); VALUE rb_ary_join(VALUE, VALUE); +VALUE rb_ary_print_on(VALUE, VALUE); VALUE rb_ary_reverse(VALUE); -VALUE rb_ary_rotate(VALUE, long); VALUE rb_ary_sort(VALUE); VALUE rb_ary_sort_bang(VALUE); VALUE rb_ary_delete(VALUE, VALUE); @@ -85,31 +73,36 @@ 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, 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 +VALUE rb_get_values_at(VALUE, long, int, VALUE*, VALUE(*)(VALUE,long)); /* bignum.c */ -VALUE rb_big_new(size_t, int); +VALUE rb_big_new(long, 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, size_t len); +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); 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); -long rb_big2long(VALUE); +VALUE rb_big2str0(VALUE, int, int); +SIGNED_VALUE rb_big2long(VALUE); #define rb_big2int(x) rb_big2long(x) -unsigned long rb_big2ulong(VALUE); +VALUE rb_big2ulong(VALUE); #define rb_big2uint(x) rb_big2ulong(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 */ +void rb_quad_pack(char*,VALUE); +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); @@ -117,7 +110,6 @@ 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); @@ -131,64 +123,32 @@ VALUE rb_big_or(VALUE, VALUE); VALUE rb_big_xor(VALUE, VALUE); VALUE rb_big_lshift(VALUE, VALUE); VALUE rb_big_rshift(VALUE, 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)) -#define rb_rational_raw2(x,y) rb_rational_raw((x), (y)) +#define rb_rational_raw1(x) rb_rational_raw(x, INT2FIX(1)) +#define rb_rational_raw2(x,y) rb_rational_raw(x, y) VALUE rb_rational_new(VALUE, VALUE); -#define rb_rational_new1(x) rb_rational_new((x), INT2FIX(1)) -#define rb_rational_new2(x,y) rb_rational_new((x), (y)) +#define rb_rational_new1(x) rb_rational_new(x, INT2FIX(1)) +#define rb_rational_new2(x,y) rb_rational_new(x, y) 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); +#define rb_Rational1(x) rb_Rational(x, INT2FIX(1)) +#define rb_Rational2(x,y) rb_Rational(x, y) /* complex.c */ VALUE rb_complex_raw(VALUE, VALUE); -#define rb_complex_raw1(x) rb_complex_raw((x), INT2FIX(0)) -#define rb_complex_raw2(x,y) rb_complex_raw((x), (y)) +#define rb_complex_raw1(x) rb_complex_raw(x, INT2FIX(0)) +#define rb_complex_raw2(x,y) rb_complex_raw(x, y) VALUE rb_complex_new(VALUE, VALUE); -#define rb_complex_new1(x) rb_complex_new((x), INT2FIX(0)) -#define rb_complex_new2(x,y) rb_complex_new((x), (y)) +#define rb_complex_new1(x) rb_complex_new(x, INT2FIX(0)) +#define rb_complex_new2(x,y) rb_complex_new(x, y) 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)); +#define rb_Complex1(x) rb_Complex(x, INT2FIX(0)) +#define rb_Complex2(x,y) rb_Complex(x, y) /* 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); @@ -199,15 +159,14 @@ VALUE rb_define_class_id_under(VALUE, ID, VALUE); VALUE rb_module_new(void); VALUE rb_define_module_id(ID); VALUE rb_define_module_id_under(VALUE, ID); -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, 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); +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); void rb_define_method_id(VALUE, ID, VALUE (*)(ANYARGS), int); void rb_frozen_class_p(VALUE); void rb_undef(VALUE, ID); @@ -220,89 +179,34 @@ 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, const VALUE *argv); -VALUE rb_fiber_yield(int argc, const VALUE *argv); +VALUE rb_fiber_resume(VALUE fib, int argc, VALUE *args); +VALUE rb_fiber_yield(int argc, VALUE *args); VALUE rb_fiber_current(void); VALUE rb_fiber_alive_p(VALUE); /* enum.c */ -VALUE rb_enum_values_pack(int, const VALUE*); /* enumerator.c */ -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 { \ +VALUE rb_enumeratorize(VALUE, VALUE, int, VALUE *); +#define RETURN_ENUMERATOR(obj, argc, argv) do { \ if (!rb_block_given_p()) \ - return SIZED_ENUMERATOR(obj, argc, argv, size_fn); \ + return rb_enumeratorize(obj, ID2SYM(rb_frame_this_func()), \ + argc, argv); \ } 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_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 +VALUE rb_exc_new2(VALUE, const char*); +VALUE rb_exc_new3(VALUE, VALUE); 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); +NORETURN(void rb_load_fail(const char*)); 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_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);}) -#else -static inline void -rb_check_frozen_inline(VALUE obj) -{ - rb_check_frozen_internal(obj); -} -#define rb_check_frozen(obj) rb_check_frozen_inline(obj) -static inline void -rb_check_trusted_inline(VALUE obj) -{ - rb_check_trusted_internal(obj); -} -#define rb_check_trusted(obj) rb_check_trusted_inline(obj) -#endif -void rb_check_copyable(VALUE obj, VALUE orig); - -#define OBJ_INIT_COPY(obj, orig) \ - ((obj) != (orig) && (rb_obj_init_copy((obj), (orig)), 1)) - /* eval.c */ int rb_sourceline(void); const char *rb_sourcefile(void); -VALUE rb_check_funcall(VALUE, ID, int, const VALUE*); - -NORETURN(void rb_error_arity(int, int, int)); -#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); -} +VALUE rb_check_funcall(VALUE, ID, int, VALUE*); #if defined(NFDBITS) && defined(HAVE_RB_FD_INIT) typedef struct { @@ -310,16 +214,13 @@ typedef struct { fd_set *fdset; } rb_fdset_t; -void rb_fd_init(rb_fdset_t *); +void rb_fd_init(volatile rb_fdset_t *); void rb_fd_term(rb_fdset_t *); void rb_fd_zero(rb_fdset_t *); void rb_fd_set(int, rb_fdset_t *); 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) @@ -332,18 +233,14 @@ typedef struct { fd_set *fdset; } rb_fdset_t; -void rb_fd_init(rb_fdset_t *); +void rb_fd_init(volatile rb_fdset_t *); void rb_fd_term(rb_fdset_t *); #define rb_fd_zero(f) ((f)->fdset->fd_count = 0) void rb_fd_set(int, rb_fdset_t *); -#define rb_fd_clr(n, f) rb_w32_fdclr((n), (f)->fdset) -#define rb_fd_isset(n, f) rb_w32_fdisset((n), (f)->fdset) -#define rb_fd_copy(d, s, n) rb_w32_fd_copy((d), (s), (n)) -void rb_w32_fd_copy(rb_fdset_t *, const fd_set *, int); -#define rb_fd_dup(d, s) rb_w32_fd_dup((d), (s)) -void rb_w32_fd_dup(rb_fdset_t *dst, const rb_fdset_t *src); -#define rb_fd_select(n, rfds, wfds, efds, timeout) rb_w32_select((n), (rfds) ? ((rb_fdset_t*)(rfds))->fdset : NULL, (wfds) ? ((rb_fdset_t*)(wfds))->fdset : NULL, (efds) ? ((rb_fdset_t*)(efds))->fdset: NULL, (timeout)) -#define rb_fd_resize(n, f) ((void)(f)) +#define rb_fd_clr(n, f) rb_w32_fdclr(n, (f)->fdset) +#define rb_fd_isset(n, f) rb_w32_fdisset(n, (f)->fdset) +#define rb_fd_select(n, rfds, wfds, efds, timeout) rb_w32_select(n, (rfds) ? ((rb_fdset_t*)rfds)->fdset : NULL, (wfds) ? ((rb_fdset_t*)wfds)->fdset : NULL, (efds) ? ((rb_fdset_t*)efds)->fdset: NULL, timeout) +#define rb_fd_resize(n, f) (void)(f) #define rb_fd_ptr(f) ((f)->fdset) #define rb_fd_max(f) ((f)->fdset->fd_count) @@ -352,47 +249,34 @@ void rb_w32_fd_dup(rb_fdset_t *dst, const rb_fdset_t *src); typedef fd_set rb_fdset_t; #define rb_fd_zero(f) FD_ZERO(f) -#define rb_fd_set(n, f) FD_SET((n), (f)) -#define rb_fd_clr(n, f) FD_CLR((n), (f)) -#define rb_fd_isset(n, f) FD_ISSET((n), (f)) +#define rb_fd_set(n, f) FD_SET(n, f) +#define rb_fd_clr(n, f) FD_CLR(n, f) +#define rb_fd_isset(n, f) FD_ISSET(n, f) #define rb_fd_copy(d, s, n) (*(d) = *(s)) -#define rb_fd_dup(d, s) (*(d) = *(s)) -#define rb_fd_resize(n, f) ((void)(f)) +#define rb_fd_resize(n, f) (void)(f) #define rb_fd_ptr(f) (f) #define rb_fd_init(f) FD_ZERO(f) -#define rb_fd_init_copy(d, s) (*(d) = *(s)) -#define rb_fd_term(f) ((void)(f)) +#define rb_fd_term(f) (void)(f) #define rb_fd_max(f) FD_SETSIZE -#define rb_fd_select(n, rfds, wfds, efds, timeout) select((n), (rfds), (wfds), (efds), (timeout)) +#define rb_fd_select(n, rfds, wfds, efds, timeout) select(n, rfds, wfds, efds, timeout) #endif NORETURN(void rb_exc_raise(VALUE)); NORETURN(void rb_exc_fatal(VALUE)); -VALUE rb_f_exit(int, const VALUE*); -VALUE rb_f_abort(int, const VALUE*); +VALUE rb_f_exit(int,VALUE*); +VALUE rb_f_abort(int,VALUE*); void rb_remove_method(VALUE, const char*); void rb_remove_method_id(VALUE, ID); -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 rb_disable_super(klass, name) ((void)0) +#define rb_enable_super(klass, name) ((void)0) #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); -DEPRECATED(void rb_clear_cache(void)); -void rb_clear_constant_cache(void); -void rb_clear_method_cache_by_class(VALUE); +void rb_clear_cache(void); +void rb_clear_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); @@ -400,15 +284,15 @@ 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, const VALUE *argv, VALUE obj); +VALUE rb_f_notimplement(int argc, VALUE *argv, VALUE obj); 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, 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); +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); void rb_load(VALUE, int); void rb_load_protect(VALUE, int, int*); NORETURN(void rb_jump_tag(int)); @@ -417,40 +301,43 @@ 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, const VALUE*); -VALUE rb_class_new_instance(int, const VALUE*, VALUE); +void rb_obj_call_init(VALUE, int, VALUE*); +VALUE rb_class_new_instance(int, VALUE*, VALUE); VALUE rb_block_proc(void); -VALUE rb_block_lambda(void); +VALUE rb_f_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, const VALUE *argv, VALUE); +VALUE rb_proc_call_with_block(VALUE, int argc, 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, const VALUE*, VALUE); -VALUE rb_method_call_with_block(int, const VALUE *, VALUE, VALUE); +VALUE rb_method_call(int, VALUE*, VALUE); int rb_mod_method_arity(VALUE, ID); int rb_obj_method_arity(VALUE, ID); VALUE rb_protect(VALUE (*)(VALUE), VALUE, int*); void rb_set_end_proc(void (*)(VALUE), VALUE); +void rb_mark_end_proc(void); void rb_exec_end_proc(void); +void ruby_finalize(void); +NORETURN(void ruby_stop(int)); +int ruby_cleanup(volatile int); +void rb_gc_mark_threads(void); void rb_thread_schedule(void); 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*); +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); @@ -462,26 +349,34 @@ 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, const VALUE *); +VALUE rb_file_s_expand_path(int, VALUE *); VALUE rb_file_expand_path(VALUE, VALUE); -VALUE rb_file_s_absolute_path(int, const VALUE *); +VALUE rb_file_s_absolute_path(int, VALUE *); VALUE rb_file_absolute_path(VALUE, VALUE); VALUE rb_file_dirname(VALUE fname); +void rb_file_const(const char*, VALUE); +int rb_file_load_ok(const char *); int rb_find_file_ext_safe(VALUE*, const char* const*, int); VALUE rb_find_file_safe(VALUE, int); int rb_find_file_ext(VALUE*, const char* const*); VALUE rb_find_file(VALUE); +char *rb_path_next(const char *); +char *rb_path_skip_prefix(const char *); +char *rb_path_last_separator(const char *); +char *rb_path_end(const char *); VALUE rb_file_directory_p(VALUE,VALUE); VALUE rb_str_encode_ospath(VALUE); int rb_is_absolute_path(const char *); /* gc.c */ +void ruby_set_stack_size(size_t); NORETURN(void rb_memerror(void)); +int ruby_stack_check(void); +size_t ruby_stack_length(VALUE**); int rb_during_gc(void); -void rb_gc_mark_locations(const VALUE*, const VALUE*); +void rb_gc_mark_locations(VALUE*, VALUE*); void rb_mark_tbl(struct st_table*); void rb_mark_set(struct st_table*); void rb_mark_hash(struct st_table*); @@ -495,14 +390,9 @@ void rb_gc_call_finalizer_at_exit(void); VALUE rb_gc_enable(void); VALUE rb_gc_disable(void); VALUE rb_gc_start(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); +#define Init_stack(addr) ruby_init_stack(addr) /* hash.c */ void st_foreach_safe(struct st_table *, int (*)(ANYARGS), st_data_t); -VALUE rb_check_hash_type(VALUE); void rb_hash_foreach(VALUE, int (*)(ANYARGS), VALUE); VALUE rb_hash(VALUE); VALUE rb_hash_new(void); @@ -513,19 +403,12 @@ 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; @@ -544,9 +427,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, const VALUE*, VALUE); -VALUE rb_io_print(int, const VALUE*, VALUE); -VALUE rb_io_puts(int, const 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_fdopen(int, int, const char*); VALUE rb_io_get_io(VALUE); VALUE rb_file_open(const char*, const char*); @@ -556,26 +439,17 @@ void rb_write_error(const char*); void rb_write_error2(const char*, long); void rb_close_before_exec(int lowfd, int maxhint, VALUE noclose_fds); int rb_pipe(int *pipes); -int rb_reserved_fd_p(int fd); -int rb_cloexec_open(const char *pathname, int flags, mode_t mode); -int rb_cloexec_dup(int oldfd); -int rb_cloexec_dup2(int oldfd, int newfd); -int rb_cloexec_pipe(int fildes[2]); -int rb_cloexec_fcntl_dupfd(int fd, int minfd); -#define RB_RESERVED_FD_P(fd) rb_reserved_fd_p(fd) -void rb_update_max_fd(int fd); -void rb_fd_fix_cloexec(int fd); /* marshal.c */ VALUE rb_marshal_dump(VALUE, VALUE); VALUE rb_marshal_load(VALUE); void rb_marshal_define_compat(VALUE newclass, VALUE oldclass, VALUE (*dumper)(VALUE), VALUE (*loader)(VALUE, VALUE)); /* numeric.c */ -NORETURN(void rb_num_zerodiv(void)); +void rb_num_zerodiv(void); #define RB_NUM_COERCE_FUNCS_NEED_OPID 1 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_float_new(double); VALUE rb_num2fix(VALUE); VALUE rb_fix2str(VALUE, int); VALUE rb_dbl_cmp(double, double); @@ -601,35 +475,31 @@ VALUE rb_obj_id(VALUE); VALUE rb_obj_class(VALUE); VALUE rb_class_real(VALUE); VALUE rb_class_inherited_p(VALUE, VALUE); -VALUE rb_class_superclass(VALUE); -VALUE rb_class_get_superclass(VALUE); VALUE rb_convert_type(VALUE,int,const char*,const char*); VALUE rb_check_convert_type(VALUE,int,const char*,const char*); VALUE rb_check_to_integer(VALUE, const char *); VALUE rb_check_to_float(VALUE); VALUE rb_to_int(VALUE); -VALUE rb_check_to_int(VALUE); VALUE rb_Integer(VALUE); VALUE rb_to_float(VALUE); VALUE rb_Float(VALUE); VALUE rb_String(VALUE); VALUE rb_Array(VALUE); -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); +void rb_gc_mark_parser(void); int rb_is_const_id(ID); -int rb_is_global_id(ID); int rb_is_instance_id(ID); -int rb_is_attrset_id(ID); int rb_is_class_id(ID); int rb_is_local_id(ID); int rb_is_junk_id(ID); int rb_symname_p(const char*); int rb_sym_interned_p(VALUE); +void rb_gc_mark_symbols(void); VALUE rb_backref_get(void); void rb_backref_set(VALUE); VALUE rb_lastline_get(void); @@ -638,12 +508,29 @@ 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 { + int argc; + VALUE *argv; + const char *prog; + VALUE options; + VALUE redirect_fds; +}; +int rb_proc_exec_n(int, VALUE*, const char*); int rb_proc_exec(const char*); -VALUE rb_f_exec(int, const VALUE*); +VALUE rb_exec_arg_init(int argc, VALUE *argv, int accept_shell, struct rb_exec_arg *e); +int rb_exec_arg_addopt(struct rb_exec_arg *e, VALUE key, VALUE val); +void rb_exec_arg_fixup(struct rb_exec_arg *e); +int rb_run_exec_options(const struct rb_exec_arg *e, struct rb_exec_arg *s); +int rb_run_exec_options_err(const struct rb_exec_arg *e, struct rb_exec_arg *s, char*, size_t); +int rb_exec(const struct rb_exec_arg*); +int rb_exec_err(const struct rb_exec_arg*, char*, size_t); +rb_pid_t rb_fork(int*, int (*)(void*), void*, VALUE); +rb_pid_t rb_fork_err(int*, int (*)(void*, char*, size_t), void*, VALUE, char*, size_t); +VALUE rb_f_exec(int,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, const VALUE*); -rb_pid_t rb_spawn_err(int, const VALUE*, char*, size_t); +rb_pid_t rb_spawn(int, VALUE*); +rb_pid_t rb_spawn_err(int, VALUE*, char*, size_t); VALUE rb_proc_times(VALUE); VALUE rb_detach_process(rb_pid_t pid); /* range.c */ @@ -658,8 +545,6 @@ VALUE rb_random_bytes(VALUE rnd, long n); VALUE rb_random_int(VALUE rnd, VALUE max); unsigned int rb_random_int32(VALUE rnd); double rb_random_real(VALUE rnd); -unsigned long rb_random_ulong_limited(VALUE rnd, unsigned long limit); -unsigned long rb_genrand_ulong_limited(unsigned long i); /* re.c */ #define rb_memcmp memcmp int rb_memcicmp(const void*,const void*,long); @@ -684,13 +569,20 @@ 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); +void ruby_script(const char*); +void ruby_prog_init(void); +void ruby_set_argv(int, char**); +void *ruby_process_options(int, char**); +void ruby_init_loadpath(void); +void ruby_incpush(const char*); /* signal.c */ -VALUE rb_f_kill(int, const VALUE*); +VALUE rb_f_kill(int, VALUE*); +void rb_gc_mark_trap_list(void); #ifdef POSIX_SIGNAL #define posix_signal ruby_posix_signal RETSIGTYPE (*posix_signal(int, RETSIGTYPE (*)(int)))(int); #endif +void ruby_sig_finalize(void); void rb_trap_exit(void); void rb_trap_exec(void); const char *ruby_signal_name(int); @@ -705,11 +597,16 @@ 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); @@ -722,11 +619,7 @@ 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_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); +VALUE rb_usascii_str_new2(const char*); void rb_str_free(VALUE); void rb_str_shared_replace(VALUE, VALUE); VALUE rb_str_buf_append(VALUE, VALUE); @@ -735,9 +628,7 @@ VALUE rb_str_buf_cat2(VALUE, const char*); VALUE rb_str_buf_cat_ascii(VALUE, const char*); VALUE rb_obj_as_string(VALUE); VALUE rb_check_string_type(VALUE); -void rb_must_asciicompat(VALUE); VALUE rb_str_dup(VALUE); -VALUE rb_str_resurrect(VALUE str); VALUE rb_str_locktmp(VALUE); VALUE rb_str_unlocktmp(VALUE); VALUE rb_str_dup_frozen(VALUE); @@ -747,14 +638,11 @@ 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); @@ -763,8 +651,8 @@ st_index_t rb_hash_start(st_index_t); st_index_t rb_hash_uint32(st_index_t, uint32_t); st_index_t rb_hash_uint(st_index_t, st_index_t); st_index_t rb_hash_end(st_index_t); -#define rb_hash_uint32(h, i) st_hash_uint32((h), (i)) -#define rb_hash_uint(h, i) st_hash_uint((h), (i)) +#define rb_hash_uint32(h, i) st_hash_uint32(h, i) +#define rb_hash_uint(h, i) st_hash_uint(h, i) #define rb_hash_end(h) st_hash_end(h) st_index_t rb_str_hash(VALUE); int rb_str_hash_cmp(VALUE,VALUE); @@ -777,8 +665,8 @@ VALUE rb_str_replace(VALUE, VALUE); VALUE rb_str_inspect(VALUE); VALUE rb_str_dump(VALUE); VALUE rb_str_split(VALUE, const char*); -DEPRECATED(void rb_str_associate(VALUE, VALUE)); -DEPRECATED(VALUE rb_str_associated(VALUE)); +void rb_str_associate(VALUE, VALUE); +VALUE rb_str_associated(VALUE); void rb_str_setter(VALUE, ID, VALUE*); VALUE rb_str_intern(VALUE); VALUE rb_sym_to_s(VALUE); @@ -786,86 +674,61 @@ long rb_str_strlen(VALUE); 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); - -#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)); \ -}) +#if defined __GNUC__ #define rb_str_new_cstr(str) __extension__ ( \ { \ (__builtin_constant_p(str)) ? \ - rb_str_new_static((str), (long)strlen(str)) : \ + rb_str_new(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)) ? \ - rb_tainted_str_new((str), (long)strlen(str)) : \ + rb_tainted_str_new(str, (long)strlen(str)) : \ rb_tainted_str_new_cstr(str); \ }) #define rb_usascii_str_new_cstr(str) __extension__ ( \ { \ (__builtin_constant_p(str)) ? \ - rb_usascii_str_new_static((str), (long)strlen(str)) : \ + rb_usascii_str_new(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_str_new_literal(str) rb_str_new_static((str), sizeof(str)-1) -#define rb_usascii_str_new_literal(str) rb_usascii_str_new_static((str), sizeof(str)-1) -#define rb_utf8_str_new_literal(str) rb_utf8_str_new_static((str), sizeof(str)-1) -#define rb_enc_str_new_literal(str, enc) rb_enc_str_new_static((str), sizeof(str)-1, (enc)) #define rb_external_str_new_cstr(str) __extension__ ( \ { \ (__builtin_constant_p(str)) ? \ - rb_external_str_new((str), (long)strlen(str)) : \ + rb_external_str_new(str, (long)strlen(str)) : \ rb_external_str_new_cstr(str); \ }) #define rb_locale_str_new_cstr(str) __extension__ ( \ { \ (__builtin_constant_p(str)) ? \ - rb_locale_str_new((str), (long)strlen(str)) : \ + rb_locale_str_new(str, (long)strlen(str)) : \ rb_locale_str_new_cstr(str); \ }) #define rb_str_buf_new_cstr(str) __extension__ ( \ { \ (__builtin_constant_p(str)) ? \ rb_str_buf_cat(rb_str_buf_new((long)strlen(str)), \ - (str), (long)strlen(str)) : \ + str, (long)strlen(str)) : \ rb_str_buf_new_cstr(str); \ }) -#define rb_str_cat_cstr(str, ptr) __extension__ ( \ +#define rb_str_buf_cat2(str, ptr) __extension__ ( \ { \ (__builtin_constant_p(ptr)) ? \ - rb_str_cat((str), (ptr), (long)strlen(ptr)) : \ - rb_str_cat_cstr((str), (ptr)); \ + rb_str_buf_cat(str, ptr, (long)strlen(ptr)) : \ + rb_str_buf_cat2(str, ptr); \ }) -#define rb_exc_new_cstr(klass, ptr) __extension__ ( \ +#define rb_str_cat2(str, ptr) __extension__ ( \ { \ (__builtin_constant_p(ptr)) ? \ - rb_exc_new((klass), (ptr), (long)strlen(ptr)) : \ - rb_exc_new_cstr((klass), (ptr)); \ + rb_str_cat(str, ptr, (long)strlen(ptr)) : \ + rb_str_cat2(str, ptr); \ +}) +#define rb_exc_new2(klass, ptr) __extension__ ( \ +{ \ + (__builtin_constant_p(ptr)) ? \ + rb_exc_new(klass, ptr, (long)strlen(ptr)) : \ + rb_exc_new2(klass, ptr); \ }) #endif #define rb_str_new2 rb_str_new_cstr @@ -875,30 +738,26 @@ VALUE rb_str_scrub(VALUE, VALUE); #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 /* 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); - +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); @@ -908,17 +767,17 @@ VALUE rb_mutex_lock(VALUE mutex); 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); +VALUE rb_barrier_new(void); +VALUE rb_barrier_wait(VALUE self); +VALUE rb_barrier_release(VALUE self); +VALUE rb_barrier_destroy(VALUE self); /* time.c */ VALUE rb_time_new(time_t, long); VALUE rb_time_nano_new(time_t, long); VALUE rb_time_num_new(VALUE, VALUE); -struct timeval rb_time_interval(VALUE num); -struct timeval rb_time_timeval(VALUE time); -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); @@ -928,25 +787,30 @@ VALUE rb_class_name(VALUE); 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, const VALUE*); -VALUE rb_f_untrace_var(int, const VALUE*); +void rb_gc_mark_global_tbl(void); +VALUE rb_f_trace_var(int, VALUE*); +VALUE rb_f_untrace_var(int, VALUE*); VALUE rb_f_global_variables(void); void rb_alias_variable(ID, ID); struct st_table* rb_generic_ivar_table(VALUE); void rb_copy_generic_ivar(VALUE,VALUE); +void rb_mark_generic_ivar(VALUE); +void rb_mark_generic_ivar_tbl(void); void rb_free_generic_ivar(VALUE); VALUE rb_ivar_get(VALUE, ID); 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, const VALUE *, VALUE); +VALUE rb_mod_constants(int, VALUE *, VALUE); VALUE rb_mod_remove_const(VALUE, VALUE); int rb_const_defined(VALUE, ID); int rb_const_defined_at(VALUE, ID); @@ -963,21 +827,17 @@ 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, const VALUE*, VALUE); +VALUE rb_mod_class_variables(VALUE); VALUE rb_mod_remove_cvar(VALUE, VALUE); +/* version.c */ +void ruby_show_version(void); +void ruby_show_copyright(void); 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, const VALUE*); - -/* 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 048090c27a..f0f83fc329 100644 --- a/include/ruby/io.h +++ b/include/ruby/io.h @@ -27,48 +27,24 @@ extern "C" { #include <stdio_ext.h> #endif -#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 -#else -# define RB_WAITFD_IN 0x001 -# define RB_WAITFD_PRI 0x002 -# define RB_WAITFD_OUT 0x004 -#endif - -RUBY_SYMBOL_EXPORT_BEGIN - -PACKED_STRUCT_UNALIGNED(struct rb_io_buffer_t { - char *ptr; /* off + len <= capa */ - int off; - int len; - int capa; -}); -typedef struct rb_io_buffer_t rb_io_buffer_t; - typedef struct rb_io_t { - FILE *stdio_file; /* stdio ptr for read/write if available */ int fd; /* file descriptor */ + FILE *stdio_file; /* stdio ptr for read/write if available */ int mode; /* mode flags: FMODE_XXXs */ rb_pid_t pid; /* child's pid (for pipes) */ int lineno; /* number of lines read */ VALUE pathv; /* pathname for file */ void (*finalize)(struct rb_io_t*,int); /* finalize proc */ - rb_io_buffer_t wbuf, rbuf; + char *wbuf; /* wbuf_off + wbuf_len <= wbuf_capa */ + int wbuf_off; + int wbuf_len; + int wbuf_capa; + + char *rbuf; /* rbuf_off + rbuf_len <= rbuf_capa */ + int rbuf_off; + int rbuf_len; + int rbuf_capa; VALUE tied_io_for_writing; @@ -86,13 +62,16 @@ typedef struct rb_io_t { } encs; rb_econv_t *readconv; - rb_io_buffer_t cbuf; + char *cbuf; /* cbuf_off + cbuf_len <= cbuf_capa */ + int cbuf_off; + int cbuf_len; + int cbuf_capa; 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; @@ -109,6 +88,8 @@ 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 */ @@ -116,20 +97,47 @@ typedef struct rb_io_t { #define GetOpenFile(obj,fp) rb_io_check_closed((fp) = RFILE(rb_io_taint_check(obj))->fptr) -#define RB_IO_BUFFER_INIT(buf) do {\ - [<"internal macro RB_IO_BUFFER_INIT() is used">];\ -} while (0) - #define MakeOpenFile(obj, fp) do {\ - (fp) = rb_io_make_open_file(obj);\ -} while (0) - -#define RB_IO_FPTR_NEW(fp) do {\ - [<"internal macro RB_IO_FPTR_NEW() is used">];\ + if (RFILE(obj)->fptr) {\ + rb_io_close(obj);\ + rb_io_fptr_finalize(RFILE(obj)->fptr);\ + RFILE(obj)->fptr = 0;\ + }\ + fp = 0;\ + fp = RFILE(obj)->fptr = 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;\ + fp->wbuf = NULL;\ + fp->wbuf_off = 0;\ + fp->wbuf_len = 0;\ + fp->wbuf_capa = 0;\ + fp->rbuf = NULL;\ + fp->rbuf_off = 0;\ + fp->rbuf_len = 0;\ + fp->rbuf_capa = 0;\ + fp->readconv = NULL;\ + fp->cbuf = NULL;\ + fp->cbuf_off = 0;\ + fp->cbuf_len = 0;\ + fp->cbuf_capa = 0;\ + 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;\ } 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*); @@ -138,39 +146,24 @@ int rb_io_modestr_oflags(const char *modestr); int rb_io_oflags_fmode(int oflags); void rb_io_check_writable(rb_io_t*); void rb_io_check_readable(rb_io_t*); -void rb_io_check_char_readable(rb_io_t *fptr); -void rb_io_check_byte_readable(rb_io_t *fptr); int rb_io_fptr_finalize(rb_io_t*); void rb_io_synchronized(rb_io_t*); void rb_io_check_initialized(rb_io_t*); void rb_io_check_closed(rb_io_t*); -VALUE rb_io_get_io(VALUE io); -VALUE rb_io_check_io(VALUE io); -VALUE rb_io_get_write_io(VALUE io); -VALUE rb_io_set_write_io(VALUE io, VALUE w); int rb_io_wait_readable(int); int rb_io_wait_writable(int); -int rb_wait_for_single_fd(int fd, int events, struct timeval *tv); void rb_io_set_nonblock(rb_io_t *fptr); -int rb_io_extract_encoding_option(VALUE opt, rb_encoding **enc_p, rb_encoding **enc2_p, int *fmode_p); -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_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()">] +#define rb_io_mode_flags(modestr) rb_io_modestr_fmode(modestr) +#define rb_io_modenum_flags(oflags) rb_io_oflags_fmode(oflags) 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*); - -struct stat; -VALUE rb_stat_new(const struct stat *); - -/* gc.c */ - -RUBY_SYMBOL_EXPORT_END +DEPRECATED(void rb_read_check(FILE*)); #if defined(__cplusplus) #if 0 diff --git a/include/ruby/missing.h b/include/ruby/missing.h index 161d95430a..62d65b0aff 100644 --- a/include/ruby/missing.h +++ b/include/ruby/missing.h @@ -18,36 +18,18 @@ extern "C" { #endif #endif -#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> -#endif -#endif - -#ifndef RUBY_SYMBOL_EXPORT_BEGIN -# define RUBY_SYMBOL_EXPORT_BEGIN /* begin */ -# define RUBY_SYMBOL_EXPORT_END /* end */ -#endif - -#if !defined(HAVE_STRUCT_TIMEVAL) +# include <sys/time.h> +#elif !defined(_WIN32) +# define time_t long struct timeval { time_t tv_sec; /* seconds */ long tv_usec; /* microseconds */ }; -#endif /* HAVE_STRUCT_TIMEVAL */ +#endif +#if defined(HAVE_SYS_TYPES_H) +# include <sys/types.h> +#endif #if !defined(HAVE_STRUCT_TIMESPEC) struct timespec { @@ -63,15 +45,10 @@ struct timezone { }; #endif -#ifdef RUBY_EXPORT -#undef RUBY_EXTERN -#endif #ifndef RUBY_EXTERN #define RUBY_EXTERN extern #endif -RUBY_SYMBOL_EXPORT_BEGIN - #ifndef HAVE_ACOSH RUBY_EXTERN double acosh(double); RUBY_EXTERN double asinh(double); @@ -90,10 +67,6 @@ RUBY_EXTERN int dup2(int, int); RUBY_EXTERN int eaccess(const char*, int); #endif -#ifndef HAVE_ROUND -RUBY_EXTERN double round(double); /* numeric.c */ -#endif - #ifndef HAVE_FINITE RUBY_EXTERN int finite(double); #endif @@ -129,35 +102,9 @@ RUBY_EXTERN double lgamma_r(double, int *); RUBY_EXTERN double cbrt(double); #endif -#if !defined(INFINITY) || !defined(NAN) -union bytesequence4_or_float { - unsigned char bytesequence[4]; - float float_value; -}; -#endif - -#ifdef INFINITY -# define HAVE_INFINITY -#else -/** @internal */ -RUBY_EXTERN const union bytesequence4_or_float rb_infinity; -# define INFINITY (rb_infinity.float_value) -#endif - -#ifdef NAN -# define HAVE_NAN -#else -/** @internal */ -RUBY_EXTERN const union bytesequence4_or_float rb_nan; -# define NAN (rb_nan.float_value) -#endif - #ifndef isinf # ifndef HAVE_ISINF # if defined(HAVE_FINITE) && defined(HAVE_ISNAN) -# ifdef HAVE_IEEEFP_H -# include <ieeefp.h> -# endif # define isinf(x) (!finite(x) && !isnan(x)) # else RUBY_EXTERN int isinf(double); @@ -171,10 +118,6 @@ RUBY_EXTERN int isnan(double); # 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); @@ -235,12 +178,6 @@ RUBY_EXTERN int ruby_shutdown(int, int); RUBY_EXTERN int ruby_close(int); #endif -#ifndef HAVE_SETPROCTITLE -RUBY_EXTERN void setproctitle(const char *fmt, ...); -#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 2530f61427..41628ed4af 100644 --- a/include/ruby/oniguruma.h +++ b/include/ruby/oniguruma.h @@ -1,11 +1,10 @@ #ifndef ONIGURUMA_H #define ONIGURUMA_H /********************************************************************** - oniguruma.h - Onigmo (Oniguruma-mod) (regular expression library) + oniguruma.h - Oniguruma (regular expression library) **********************************************************************/ /*- - * Copyright (c) 2002-2009 K.Kosako <sndgk393 AT ybb DOT ne DOT jp> - * Copyright (c) 2011-2014 K.Takata <kentkt AT csc DOT jp> + * Copyright (c) 2002-2008 K.Kosako <sndgk393 AT ybb DOT ne DOT jp> * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -39,8 +38,8 @@ extern "C" { #define ONIGURUMA #define ONIGURUMA_VERSION_MAJOR 5 -#define ONIGURUMA_VERSION_MINOR 15 -#define ONIGURUMA_VERSION_TEENY 0 +#define ONIGURUMA_VERSION_MINOR 9 +#define ONIGURUMA_VERSION_TEENY 2 #ifdef __cplusplus # ifndef HAVE_PROTOTYPES @@ -98,10 +97,6 @@ extern "C" { #define ONIG_EXTERN extern #endif -RUBY_SYMBOL_EXPORT_BEGIN - -#include <stddef.h> /* for size_t */ - /* PART: character encoding */ #ifndef ONIG_ESCAPE_UCHAR_COLLISION @@ -109,10 +104,9 @@ RUBY_SYMBOL_EXPORT_BEGIN #endif typedef unsigned char OnigUChar; -typedef unsigned int OnigCodePoint; +typedef unsigned int OnigCodePoint; typedef unsigned int OnigCtype; typedef size_t OnigDistance; -typedef ptrdiff_t OnigPosition; #define ONIG_INFINITE_DISTANCE ~((OnigDistance )0) @@ -156,29 +150,28 @@ 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, const struct OnigEncodingTypeST* enc); + int (*precise_mbc_enc_len)(const OnigUChar* p,const OnigUChar* e, struct OnigEncodingTypeST* enc); const char* name; int max_enc_len; int min_enc_len; - 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, OnigUChar* p, 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 (*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 ruby_encoding_index; - unsigned int flags; } OnigEncodingType; -typedef const OnigEncodingType* OnigEncoding; +typedef OnigEncodingType* OnigEncoding; -ONIG_EXTERN const OnigEncodingType OnigEncodingASCII; +ONIG_EXTERN OnigEncodingType OnigEncodingASCII; #define ONIG_ENCODING_ASCII (&OnigEncodingASCII) @@ -207,12 +200,17 @@ ONIG_EXTERN const OnigEncodingType OnigEncodingASCII; #define ONIGENC_CTYPE_ALNUM 13 /* alpha || digit */ #define ONIGENC_CTYPE_ASCII 14 #define ONIGENC_MAX_STD_CTYPE ONIGENC_CTYPE_ASCII +#define ONIGENC_CTYPE_SPECIAL_MASK 128 +#define ONIGENC_CTYPE_S /* [\t\n\v\f\r\s] */ \ + ONIGENC_CTYPE_SPECIAL_MASK | ONIGENC_CTYPE_SPACE +#define ONIGENC_CTYPE_D /* [0-9] */ \ + ONIGENC_CTYPE_SPECIAL_MASK | ONIGENC_CTYPE_DIGIT +#define ONIGENC_CTYPE_W /* [0-9A-Za-z_] */ \ + ONIGENC_CTYPE_SPECIAL_MASK | ONIGENC_CTYPE_WORD +#define ONIGENC_CTYPE_SPECIAL_P(ctype) ((ctype) & ONIGENC_CTYPE_SPECIAL_MASK) -/* flags */ -#define ONIGENC_FLAG_NONE 0U -#define ONIGENC_FLAG_UNICODE 1U -#define onig_enc_len(enc,p,e) ONIGENC_MBC_ENC_LEN(enc, p, e) +#define onig_enc_len(enc,p,e) ONIGENC_MBC_ENC_LEN(enc, p, e) #define ONIGENC_IS_UNDEF(enc) ((enc) == ONIG_ENCODING_UNDEF) #define ONIGENC_IS_SINGLEBYTE(enc) (ONIGENC_MBC_MAXLEN(enc) == 1) @@ -221,10 +219,6 @@ ONIG_EXTERN const OnigEncodingType OnigEncodingASCII; #define ONIGENC_IS_CODE_ASCII(code) ((code) < 128) #define ONIGENC_IS_MBC_WORD(enc,s,end) \ ONIGENC_IS_CODE_WORD(enc,ONIGENC_MBC_TO_CODE(enc,s,end)) -#define ONIGENC_IS_MBC_ASCII_WORD(enc,s,end) \ - onigenc_ascii_is_code_ctype( \ - ONIGENC_MBC_TO_CODE(enc,s,end),ONIGENC_CTYPE_WORD,enc) -#define ONIGENC_IS_UNICODE(enc) ((enc)->flags & ONIGENC_FLAG_UNICODE) #define ONIGENC_NAME(enc) ((enc)->name) @@ -256,7 +250,7 @@ ONIG_EXTERN const 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, const struct OnigEncodingTypeST* enc)); +int onigenc_mbclen_approximate P_((const OnigUChar* p,const OnigUChar* e, 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) @@ -338,7 +332,6 @@ 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 */ @@ -353,7 +346,6 @@ typedef unsigned int OnigOptionType; #define ONIG_OPTION_IGNORECASE 1U #define ONIG_OPTION_EXTEND (ONIG_OPTION_IGNORECASE << 1) #define ONIG_OPTION_MULTILINE (ONIG_OPTION_EXTEND << 1) -#define ONIG_OPTION_DOTALL ONIG_OPTION_MULTILINE #define ONIG_OPTION_SINGLELINE (ONIG_OPTION_MULTILINE << 1) #define ONIG_OPTION_FIND_LONGEST (ONIG_OPTION_SINGLELINE << 1) #define ONIG_OPTION_FIND_NOT_EMPTY (ONIG_OPTION_FIND_LONGEST << 1) @@ -364,15 +356,7 @@ typedef unsigned int OnigOptionType; #define ONIG_OPTION_NOTBOL (ONIG_OPTION_CAPTURE_GROUP << 1) #define ONIG_OPTION_NOTEOL (ONIG_OPTION_NOTBOL << 1) #define ONIG_OPTION_POSIX_REGION (ONIG_OPTION_NOTEOL << 1) -/* options (ctype range) */ -#define ONIG_OPTION_ASCII_RANGE (ONIG_OPTION_POSIX_REGION << 1) -#define ONIG_OPTION_POSIX_BRACKET_ALL_RANGE (ONIG_OPTION_ASCII_RANGE << 1) -#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_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_MAXBIT ONIG_OPTION_POSIX_REGION /* limit */ #define ONIG_OPTION_ON(options,regopt) ((options) |= (regopt)) #define ONIG_OPTION_OFF(options,regopt) ((options) &= ~(regopt)) @@ -394,11 +378,9 @@ ONIG_EXTERN const OnigSyntaxType OnigSyntaxEmacs; ONIG_EXTERN const OnigSyntaxType OnigSyntaxGrep; ONIG_EXTERN const OnigSyntaxType OnigSyntaxGnuRegex; ONIG_EXTERN const OnigSyntaxType OnigSyntaxJava; -ONIG_EXTERN const OnigSyntaxType OnigSyntaxPerl58; -ONIG_EXTERN const OnigSyntaxType OnigSyntaxPerl58_NG; ONIG_EXTERN const OnigSyntaxType OnigSyntaxPerl; +ONIG_EXTERN const OnigSyntaxType OnigSyntaxPerl_NG; ONIG_EXTERN const OnigSyntaxType OnigSyntaxRuby; -ONIG_EXTERN const OnigSyntaxType OnigSyntaxPython; /* predefined syntaxes (see regsyntax.c) */ #define ONIG_SYNTAX_ASIS (&OnigSyntaxASIS) @@ -408,11 +390,9 @@ ONIG_EXTERN const OnigSyntaxType OnigSyntaxPython; #define ONIG_SYNTAX_GREP (&OnigSyntaxGrep) #define ONIG_SYNTAX_GNU_REGEX (&OnigSyntaxGnuRegex) #define ONIG_SYNTAX_JAVA (&OnigSyntaxJava) -#define ONIG_SYNTAX_PERL58 (&OnigSyntaxPerl58) -#define ONIG_SYNTAX_PERL58_NG (&OnigSyntaxPerl58_NG) #define ONIG_SYNTAX_PERL (&OnigSyntaxPerl) +#define ONIG_SYNTAX_PERL_NG (&OnigSyntaxPerl_NG) #define ONIG_SYNTAX_RUBY (&OnigSyntaxRuby) -#define ONIG_SYNTAX_PYTHON (&OnigSyntaxPython) /* default syntax */ ONIG_EXTERN const OnigSyntaxType* OnigDefaultSyntax; @@ -450,12 +430,11 @@ ONIG_EXTERN const OnigSyntaxType* OnigDefaultSyntax; #define ONIG_SYN_OP_ESC_OCTAL3 (1U<<28) /* \OOO */ #define ONIG_SYN_OP_ESC_X_HEX2 (1U<<29) /* \xHH */ #define ONIG_SYN_OP_ESC_X_BRACE_HEX8 (1U<<30) /* \x{7HHHHHHH} */ -#define ONIG_SYN_OP_ESC_O_BRACE_OCTAL (1U<<31) /* \o{OOO} */ /* NOTIMPL */ #define ONIG_SYN_OP2_ESC_CAPITAL_Q_QUOTE (1U<<0) /* \Q...\E */ #define ONIG_SYN_OP2_QMARK_GROUP_EFFECT (1U<<1) /* (?...) */ -#define ONIG_SYN_OP2_OPTION_PERL (1U<<2) /* (?imsxadlu), (?-imsx), (?^imsxalu) */ -#define ONIG_SYN_OP2_OPTION_RUBY (1U<<3) /* (?imxadu), (?-imx) */ +#define ONIG_SYN_OP2_OPTION_PERL (1U<<2) /* (?imsx),(?-imsx) */ +#define ONIG_SYN_OP2_OPTION_RUBY (1U<<3) /* (?imx), (?-imx) */ #define ONIG_SYN_OP2_PLUS_POSSESSIVE_REPEAT (1U<<4) /* ?+,*+,++ */ #define ONIG_SYN_OP2_PLUS_POSSESSIVE_INTERVAL (1U<<5) /* {n,m}+ */ #define ONIG_SYN_OP2_CCLASS_SET_OP (1U<<6) /* [...&&..[..]..] */ @@ -473,17 +452,6 @@ ONIG_EXTERN const OnigSyntaxType* OnigDefaultSyntax; /* #define ONIG_SYN_OP2_CHAR_PROPERTY_PREFIX_IS (1U<<18) */ #define ONIG_SYN_OP2_ESC_H_XDIGIT (1U<<19) /* \h, \H */ #define ONIG_SYN_OP2_INEFFECTIVE_ESCAPE (1U<<20) /* \ */ -#define ONIG_SYN_OP2_ESC_CAPITAL_R_LINEBREAK (1U<<21) /* \R as (?>\x0D\x0A|[\x0A-\x0D\x{85}\x{2028}\x{2029}]) */ -#define ONIG_SYN_OP2_ESC_CAPITAL_X_EXTENDED_GRAPHEME_CLUSTER (1U<<22) /* \X as (?>\P{M}\p{M}*) */ -#define ONIG_SYN_OP2_ESC_V_VERTICAL_WHITESPACE (1U<<23) /* \v, \V -- Perl */ /* NOTIMPL */ -#define ONIG_SYN_OP2_ESC_H_HORIZONTAL_WHITESPACE (1U<<24) /* \h, \H -- Perl */ /* NOTIMPL */ -#define ONIG_SYN_OP2_ESC_CAPITAL_K_KEEP (1U<<25) /* \K */ -#define ONIG_SYN_OP2_ESC_G_BRACE_BACKREF (1U<<26) /* \g{name}, \g{n} */ -#define ONIG_SYN_OP2_QMARK_SUBEXP_CALL (1U<<27) /* (?&name), (?n), (?R), (?0) */ -#define ONIG_SYN_OP2_QMARK_VBAR_BRANCH_RESET (1U<<28) /* (?|...) */ /* NOTIMPL */ -#define ONIG_SYN_OP2_QMARK_LPAREN_CONDITION (1U<<29) /* (?(cond)yes...|no...) */ -#define ONIG_SYN_OP2_QMARK_CAPITAL_P_NAMED_GROUP (1U<<30) /* (?P<name>...), (?P=name), (?P>name) -- Python/PCRE */ -#define ONIG_SYN_OP2_OPTION_JAVA (1U<<31) /* (?idmsux), (?-idmsux) */ /* NOTIMPL */ /* syntax (behavior) */ #define ONIG_SYN_CONTEXT_INDEP_ANCHORS (1U<<31) /* not implemented */ @@ -497,7 +465,6 @@ ONIG_EXTERN const OnigSyntaxType* OnigDefaultSyntax; #define ONIG_SYN_CAPTURE_ONLY_NAMED_GROUP (1U<<7) /* see doc/RE */ #define ONIG_SYN_ALLOW_MULTIPLEX_DEFINITION_NAME (1U<<8) /* (?<x>)(?<x>) */ #define ONIG_SYN_FIXED_INTERVAL_IS_GREEDY_ONLY (1U<<9) /* a{n}?=(?:a{n})? */ -#define ONIG_SYN_ALLOW_MULTIPLEX_DEFINITION_NAME_CALL (1U<<10) /* (?<x>)(?<x>)(?&x) */ /* syntax (behavior) in char class [...] */ #define ONIG_SYN_NOT_NEWLINE_IN_NEGATIVE_CC (1U<<20) /* [^...] */ @@ -534,7 +501,7 @@ ONIG_EXTERN const OnigSyntaxType* OnigDefaultSyntax; #define ONIGERR_UNDEFINED_BYTECODE -13 #define ONIGERR_UNEXPECTED_BYTECODE -14 #define ONIGERR_MATCH_STACK_LIMIT_OVER -15 -#define ONIGERR_DEFAULT_ENCODING_IS_NOT_SET -21 +#define ONIGERR_DEFAULT_ENCODING_IS_NOT_SETTED -21 #define ONIGERR_SPECIFIED_ENCODING_CANT_CONVERT_TO_WIDE_CHAR -22 /* general error */ #define ONIGERR_INVALID_ARGUMENT -30 @@ -561,7 +528,6 @@ ONIG_EXTERN const OnigSyntaxType* OnigDefaultSyntax; #define ONIGERR_INVALID_POSIX_BRACKET_TYPE -121 #define ONIGERR_INVALID_LOOK_BEHIND_PATTERN -122 #define ONIGERR_INVALID_REPEAT_RANGE_PATTERN -123 -#define ONIGERR_INVALID_CONDITION_PATTERN -124 /* values error (syntax error) */ #define ONIGERR_TOO_BIG_NUMBER -200 #define ONIGERR_TOO_BIG_NUMBER_FOR_REPEAT_RANGE -201 @@ -573,7 +539,6 @@ ONIG_EXTERN const OnigSyntaxType* OnigDefaultSyntax; #define ONIGERR_TOO_BIG_BACKREF_NUMBER -207 #define ONIGERR_INVALID_BACKREF -208 #define ONIGERR_NUMBERED_BACKREF_OR_CALL_NOT_ALLOWED -209 -#define ONIGERR_TOO_SHORT_DIGITS -210 #define ONIGERR_TOO_LONG_WIDE_CHAR_VALUE -212 #define ONIGERR_EMPTY_GROUP_NAME -214 #define ONIGERR_INVALID_GROUP_NAME -215 @@ -585,7 +550,6 @@ 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 @@ -603,8 +567,8 @@ ONIG_EXTERN const OnigSyntaxType* OnigDefaultSyntax; typedef struct OnigCaptureTreeNodeStruct { int group; /* group number */ - OnigPosition beg; - OnigPosition end; + int beg; + int end; int allocated; int num_childs; struct OnigCaptureTreeNodeStruct** childs; @@ -614,8 +578,8 @@ typedef struct OnigCaptureTreeNodeStruct { struct re_registers { int allocated; int num_regs; - OnigPosition* beg; - OnigPosition* end; + int* beg; + int* end; /* extended */ OnigCaptureTreeNode* history_root; /* capture history tree root */ }; @@ -674,15 +638,13 @@ 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; - void* name_table; OnigCaseFoldType case_fold_flag; + void* name_table; /* optimization info (string search, char-map and anchors) */ int optimize; /* optimize flag */ @@ -714,7 +676,7 @@ typedef struct { int num_of_elements; OnigEncoding pattern_enc; OnigEncoding target_enc; - const OnigSyntaxType* syntax; + OnigSyntaxType* syntax; OnigOptionType option; OnigCaseFoldType case_fold_flag; } OnigCompileInfo; @@ -723,7 +685,7 @@ typedef struct { ONIG_EXTERN int onig_init P_((void)); ONIG_EXTERN -int onig_error_code_to_str PV_((OnigUChar* s, OnigPosition err_code, ...)); +int onig_error_code_to_str PV_((OnigUChar* s, int err_code, ...)); ONIG_EXTERN void onig_set_warn_func P_((OnigWarnFunc f)); ONIG_EXTERN @@ -731,7 +693,7 @@ void onig_set_verb_warn_func P_((OnigWarnFunc f)); ONIG_EXTERN int onig_new P_((OnigRegex*, const OnigUChar* pattern, const OnigUChar* pattern_end, OnigOptionType option, OnigEncoding enc, const OnigSyntaxType* syntax, OnigErrorInfo* einfo)); ONIG_EXTERN -int onig_reg_init P_((OnigRegex reg, OnigOptionType option, OnigCaseFoldType case_fold_flag, OnigEncoding enc, const OnigSyntaxType* syntax)); +int onig_reg_init P_((regex_t* reg, OnigOptionType option, OnigCaseFoldType case_fold_flag, OnigEncoding enc, const OnigSyntaxType* syntax)); ONIG_EXTERN int onig_new_without_alloc P_((OnigRegex, const OnigUChar* pattern, const OnigUChar* pattern_end, OnigOptionType option, OnigEncoding enc, OnigSyntaxType* syntax, OnigErrorInfo* einfo)); ONIG_EXTERN @@ -745,11 +707,9 @@ int onig_recompile P_((OnigRegex, const OnigUChar* pattern, const OnigUChar* pat ONIG_EXTERN int onig_recompile_deluxe P_((OnigRegex reg, const OnigUChar* pattern, const OnigUChar* pattern_end, OnigCompileInfo* ci, OnigErrorInfo* einfo)); ONIG_EXTERN -OnigPosition onig_search P_((OnigRegex, const OnigUChar* str, const OnigUChar* end, const OnigUChar* start, const OnigUChar* range, OnigRegion* region, OnigOptionType option)); +long onig_search P_((OnigRegex, const OnigUChar* str, const OnigUChar* end, const OnigUChar* start, const OnigUChar* range, OnigRegion* region, OnigOptionType option)); ONIG_EXTERN -OnigPosition onig_search_gpos P_((OnigRegex, const OnigUChar* str, const OnigUChar* end, const OnigUChar* global_pos, const OnigUChar* start, const OnigUChar* range, OnigRegion* region, OnigOptionType option)); -ONIG_EXTERN -OnigPosition onig_match P_((OnigRegex, const OnigUChar* str, const OnigUChar* end, const OnigUChar* at, OnigRegion* region, OnigOptionType option)); +long onig_match P_((OnigRegex, const OnigUChar* str, const OnigUChar* end, const OnigUChar* at, OnigRegion* region, OnigOptionType option)); ONIG_EXTERN OnigRegion* onig_region_new P_((void)); ONIG_EXTERN @@ -779,7 +739,7 @@ int onig_number_of_capture_histories P_((OnigRegex reg)); ONIG_EXTERN OnigCaptureTreeNode* onig_get_capture_tree P_((OnigRegion* region)); ONIG_EXTERN -int onig_capture_tree_traverse P_((OnigRegion* region, int at, int(*callback_func)(int,OnigPosition,OnigPosition,int,int,void*), void* arg)); +int onig_capture_tree_traverse P_((OnigRegion* region, int at, int(*callback_func)(int,int,int,int,int,void*), void* arg)); ONIG_EXTERN int onig_noname_group_capture_is_active P_((OnigRegex reg)); ONIG_EXTERN @@ -813,7 +773,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_((OnigEncodingType *to, OnigEncoding from)); +void onig_copy_encoding P_((OnigEncoding to, OnigEncoding from)); ONIG_EXTERN OnigCaseFoldType onig_get_default_case_fold_flag P_((void)); ONIG_EXTERN @@ -829,8 +789,6 @@ const char* onig_version P_((void)); ONIG_EXTERN const char* onig_copyright P_((void)); -RUBY_SYMBOL_EXPORT_END - #ifdef __cplusplus #if 0 { /* satisfy cc-mode */ diff --git a/include/ruby/re.h b/include/ruby/re.h index 166f254aa5..c60ab96016 100644 --- a/include/ruby/re.h +++ b/include/ruby/re.h @@ -24,8 +24,6 @@ extern "C" { #include "ruby/regex.h" -RUBY_SYMBOL_EXPORT_BEGIN - typedef struct re_pattern_buffer Regexp; struct rmatch_offset { @@ -57,10 +55,6 @@ VALUE rb_reg_regsub(VALUE, VALUE, struct re_registers *, VALUE); 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 *); - -RUBY_SYMBOL_EXPORT_END #if defined(__cplusplus) #if 0 diff --git a/include/ruby/regex.h b/include/ruby/regex.h index 024bed4a4e..a63e2f6a4c 100644 --- a/include/ruby/regex.h +++ b/include/ruby/regex.h @@ -24,8 +24,6 @@ extern "C" { #include "oniguruma.h" #endif -RUBY_SYMBOL_EXPORT_BEGIN - #ifndef ONIG_RUBY_M17N ONIG_EXTERN OnigEncoding OnigEncDefaultCharEncoding; @@ -34,8 +32,6 @@ ONIG_EXTERN OnigEncoding OnigEncDefaultCharEncoding; #endif /* ifndef ONIG_RUBY_M17N */ -RUBY_SYMBOL_EXPORT_END - #if defined(__cplusplus) #if 0 { /* satisfy cc-mode */ diff --git a/include/ruby/ruby.h b/include/ruby/ruby.h index cd03125990..0294b08363 100644 --- a/include/ruby/ruby.h +++ b/include/ruby/ruby.h @@ -21,12 +21,12 @@ extern "C" { #endif #endif +#ifndef RUBY_LIB_PREFIX #include "ruby/config.h" #ifdef RUBY_EXTCONF_H #include RUBY_EXTCONF_H #endif - -#include "defines.h" +#endif #define NORETURN_STYLE_NEW 1 #ifndef NORETURN @@ -38,9 +38,6 @@ extern "C" { #ifndef NOINLINE # define NOINLINE(x) x #endif -#ifndef UNREACHABLE -# define UNREACHABLE /* unreachable */ -#endif #ifdef __GNUC__ #define PRINTF_ARGS(decl, string_index, first_to_check) \ @@ -49,36 +46,40 @@ extern "C" { #define PRINTF_ARGS(decl, string_index, first_to_check) decl #endif -#define RUBY_MACRO_SELECT(base, n) TOKEN_PASTE(base, n) +#ifdef HAVE_STDLIB_H +# include <stdlib.h> +#endif + +#ifdef HAVE_STRING_H +# include <string.h> +#else +# include <strings.h> +#endif #ifdef HAVE_INTRINSICS_H # include <intrinsics.h> #endif +#ifdef HAVE_STDINT_H +# include <stdint.h> +#endif +#ifdef HAVE_INTTYPES_H +# include <inttypes.h> +#endif + #include <stdarg.h> +#include <stddef.h> +#include <stdio.h> -RUBY_SYMBOL_EXPORT_BEGIN +#include "defines.h" -/* Make alloca work the best possible way. */ -#ifdef __GNUC__ -# ifndef atarist -# ifndef alloca -# define alloca __builtin_alloca -# endif -# endif /* atarist */ +#if defined(HAVE_ALLOCA_H) +#include <alloca.h> #else -# ifdef HAVE_ALLOCA_H -# include <alloca.h> -# else # ifdef _AIX #pragma alloca -# else -# ifndef alloca /* predefined by HP cc +Olibcalls */ -void *alloca(); -# endif -# endif /* AIX */ -# endif /* HAVE_ALLOCA_H */ -#endif /* __GNUC__ */ +# endif +#endif #if defined HAVE_UINTPTR_T && 0 typedef uintptr_t VALUE; @@ -98,46 +99,32 @@ typedef unsigned LONG_LONG ID; # define SIGNED_VALUE LONG_LONG # define LONG_LONG_VALUE 1 # define SIZEOF_VALUE SIZEOF_LONG_LONG -# define PRI_VALUE_PREFIX PRI_LL_PREFIX +# define PRI_VALUE_PREFIX "ll" #else -# error ---->> ruby requires sizeof(void*) == sizeof(long) or sizeof(LONG_LONG) to be compiled. <<---- +# error ---->> ruby requires sizeof(void*) == sizeof(long) to be compiled. <<---- #endif typedef char ruby_check_sizeof_int[SIZEOF_INT == sizeof(int) ? 1 : -1]; typedef char ruby_check_sizeof_long[SIZEOF_LONG == sizeof(long) ? 1 : -1]; -#ifdef HAVE_LONG_LONG +#ifdef SIZEOF_LONG_LONG typedef char ruby_check_sizeof_long_long[SIZEOF_LONG_LONG == sizeof(LONG_LONG) ? 1 : -1]; #endif typedef char ruby_check_sizeof_voidp[SIZEOF_VOIDP == sizeof(void*) ? 1 : -1]; -#ifndef PRI_INT_PREFIX -#define PRI_INT_PREFIX "" -#endif -#ifndef PRI_LONG_PREFIX -#define PRI_LONG_PREFIX "l" -#endif - -#if SIZEOF_LONG == 8 -#define PRI_64_PREFIX PRI_LONG_PREFIX -#elif SIZEOF_LONG_LONG == 8 -#define PRI_64_PREFIX PRI_LL_PREFIX -#endif - -#define RUBY_PRI_VALUE_MARK "\v" #if defined PRIdPTR && !defined PRI_VALUE_PREFIX #define PRIdVALUE PRIdPTR +#define PRIiVALUE PRIiPTR #define PRIoVALUE PRIoPTR #define PRIuVALUE PRIuPTR #define PRIxVALUE PRIxPTR #define PRIXVALUE PRIXPTR -#define PRIsVALUE PRIiPTR"" RUBY_PRI_VALUE_MARK #else #define PRIdVALUE PRI_VALUE_PREFIX"d" +#define PRIiVALUE PRI_VALUE_PREFIX"i" #define PRIoVALUE PRI_VALUE_PREFIX"o" #define PRIuVALUE PRI_VALUE_PREFIX"u" #define PRIxVALUE PRI_VALUE_PREFIX"x" #define PRIXVALUE PRI_VALUE_PREFIX"X" -#define PRIsVALUE PRI_VALUE_PREFIX"i" RUBY_PRI_VALUE_MARK #endif #ifndef PRI_VALUE_PREFIX # define PRI_VALUE_PREFIX "" @@ -149,17 +136,18 @@ typedef char ruby_check_sizeof_voidp[SIZEOF_VOIDP == sizeof(void*) ? 1 : -1]; # elif SIZEOF_TIME_T == SIZEOF_LONG # define PRI_TIMET_PREFIX "l" # elif SIZEOF_TIME_T == SIZEOF_LONG_LONG -# define PRI_TIMET_PREFIX PRI_LL_PREFIX +# define PRI_TIMET_PREFIX "ll" # endif #endif -#if defined PRI_PTRDIFF_PREFIX +#if defined PRIdPTR +# define PRI_PTRDIFF_PREFIX "t" #elif SIZEOF_PTRDIFF_T == SIZEOF_INT -# define PRI_PTRDIFF_PREFIX "" +# define PRI_PTRDIFF_PREFIX #elif SIZEOF_PTRDIFF_T == SIZEOF_LONG # define PRI_PTRDIFF_PREFIX "l" #elif SIZEOF_PTRDIFF_T == SIZEOF_LONG_LONG -# define PRI_PTRDIFF_PREFIX PRI_LL_PREFIX +# define PRI_PTRDIFF_PREFIX "ll" #endif #define PRIdPTRDIFF PRI_PTRDIFF_PREFIX"d" #define PRIiPTRDIFF PRI_PTRDIFF_PREFIX"i" @@ -168,13 +156,14 @@ typedef char ruby_check_sizeof_voidp[SIZEOF_VOIDP == sizeof(void*) ? 1 : -1]; #define PRIxPTRDIFF PRI_PTRDIFF_PREFIX"x" #define PRIXPTRDIFF PRI_PTRDIFF_PREFIX"X" -#if defined PRI_SIZE_PREFIX +#if defined PRIdPTR +# define PRI_SIZE_PREFIX "z" #elif SIZEOF_SIZE_T == SIZEOF_INT -# define PRI_SIZE_PREFIX "" +# define PRI_SIZE_PREFIX #elif SIZEOF_SIZE_T == SIZEOF_LONG # define PRI_SIZE_PREFIX "l" #elif SIZEOF_SIZE_T == SIZEOF_LONG_LONG -# define PRI_SIZE_PREFIX PRI_LL_PREFIX +# define PRI_SIZE_PREFIX "ll" #endif #define PRIdSIZE PRI_SIZE_PREFIX"d" #define PRIiSIZE PRI_SIZE_PREFIX"i" @@ -190,7 +179,7 @@ typedef char ruby_check_sizeof_voidp[SIZEOF_VOIDP == sizeof(void*) ? 1 : -1]; # ifdef HAVE_LIMITS_H # include <limits.h> # else - /* assuming 32bit(2's complement) long */ + /* assuming 32bit(2's compliment) long */ # define LONG_MAX 2147483647 # endif # endif @@ -231,7 +220,7 @@ typedef char ruby_check_sizeof_voidp[SIZEOF_VOIDP == sizeof(void*) ? 1 : -1]; #define FIXNUM_MAX (LONG_MAX>>1) #define FIXNUM_MIN RSHIFT((long)LONG_MIN,1) -#define INT2FIX(i) (((VALUE)(i))<<1 | FIXNUM_FLAG) +#define INT2FIX(i) ((VALUE)(((SIGNED_VALUE)(i))<<1 | FIXNUM_FLAG)) #define LONG2FIX(i) INT2FIX(i) #define rb_fix_new(v) INT2FIX(v) VALUE rb_int2inum(SIGNED_VALUE); @@ -248,7 +237,6 @@ VALUE rb_ull2inum(unsigned LONG_LONG); #define ULL2NUM(v) rb_ull2inum(v) #endif -#ifndef OFFT2NUM #if SIZEOF_OFF_T > SIZEOF_LONG && defined(HAVE_LONG_LONG) # define OFFT2NUM(v) LL2NUM(v) #elif SIZEOF_OFF_T == SIZEOF_LONG @@ -256,7 +244,6 @@ VALUE rb_ull2inum(unsigned LONG_LONG); #else # define OFFT2NUM(v) INT2NUM(v) #endif -#endif #if SIZEOF_SIZE_T > SIZEOF_LONG && defined(HAVE_LONG_LONG) # define SIZET2NUM(v) ULL2NUM(v) @@ -306,16 +293,15 @@ NORETURN(void rb_out_of_int(SIGNED_VALUE num)); #endif #if SIZEOF_INT < SIZEOF_LONG +#define rb_long2int_internal(n, i) \ + int i = (int)(n); \ + if ((long)i != (n)) rb_out_of_int(n) +#ifdef __GNUC__ +#define rb_long2int(n) __extension__ ({long i2l_n = (n); rb_long2int_internal(i2l_n, i2l_i); i2l_i;}) +#else static inline int -rb_long2int_inline(long n) -{ - int i = (int)n; - if ((long)i != n) - rb_out_of_int(n); - - return i; -} -#define rb_long2int(n) rb_long2int_inline(n) +rb_long2int(long n) {rb_long2int_internal(n, i); return i;} +#endif #else #define rb_long2int(n) ((int)(n)) #endif @@ -338,72 +324,33 @@ rb_long2int_inline(long n) #ifndef NUM2GIDT #define NUM2GIDT(v) NUM2LONG(v) #endif -#ifndef NUM2MODET -#define NUM2MODET(v) NUM2INT(v) -#endif -#ifndef MODET2NUM -#define MODET2NUM(v) INT2NUM(v) -#endif -#define FIX2LONG(x) ((long)RSHIFT((SIGNED_VALUE)(x),1)) -#define FIX2ULONG(x) ((unsigned long)FIX2LONG(x)) -#define FIXNUM_P(f) (((int)(SIGNED_VALUE)(f))&FIXNUM_FLAG) +#define FIX2LONG(x) RSHIFT((SIGNED_VALUE)x,1) +#define FIX2ULONG(x) ((((VALUE)(x))>>1)&LONG_MAX) +#define FIXNUM_P(f) (((SIGNED_VALUE)(f))&FIXNUM_FLAG) #define POSFIXABLE(f) ((f) < FIXNUM_MAX+1) #define NEGFIXABLE(f) ((f) >= FIXNUM_MIN) #define FIXABLE(f) (POSFIXABLE(f) && NEGFIXABLE(f)) #define IMMEDIATE_P(x) ((VALUE)(x) & IMMEDIATE_MASK) -ID rb_sym2id(VALUE); -VALUE rb_id2sym(ID); -#define STATIC_SYM_P(x) (((VALUE)(x)&~((~(VALUE)0)<<RUBY_SPECIAL_SHIFT))==SYMBOL_FLAG) -#define DYNAMIC_SYM_P(x) (!SPECIAL_CONST_P(x) && BUILTIN_TYPE(x) == (T_SYMBOL)) -#define SYMBOL_P(x) (STATIC_SYM_P(x)||DYNAMIC_SYM_P(x)) -#define ID2SYM(x) (rb_id2sym(x)) -#define SYM2ID(x) (rb_sym2id(x)) - -#ifndef USE_FLONUM -#if SIZEOF_VALUE >= SIZEOF_DOUBLE -#define USE_FLONUM 1 -#else -#define USE_FLONUM 0 -#endif -#endif - -#if USE_FLONUM -#define FLONUM_P(x) ((((int)(SIGNED_VALUE)(x))&FLONUM_MASK) == FLONUM_FLAG) -#else -#define FLONUM_P(x) 0 -#endif +#define SYMBOL_P(x) (((VALUE)(x)&~(~(VALUE)0<<RUBY_SPECIAL_SHIFT))==SYMBOL_FLAG) +#define ID2SYM(x) (((VALUE)(x)<<RUBY_SPECIAL_SHIFT)|SYMBOL_FLAG) +#define SYM2ID(x) RSHIFT((unsigned long)(x),RUBY_SPECIAL_SHIFT) /* Module#methods, #singleton_methods and so on return Symbols */ #define USE_SYMBOL_AS_METHOD_NAME 1 /* special constants - i.e. non-zero and non-fixnum constants */ enum ruby_special_consts { -#if USE_FLONUM - RUBY_Qfalse = 0x00, /* ...0000 0000 */ - RUBY_Qtrue = 0x14, /* ...0001 0100 */ - RUBY_Qnil = 0x08, /* ...0000 1000 */ - RUBY_Qundef = 0x34, /* ...0011 0100 */ - - RUBY_IMMEDIATE_MASK = 0x07, - RUBY_FIXNUM_FLAG = 0x01, /* ...xxxx xxx1 */ - RUBY_FLONUM_MASK = 0x03, - RUBY_FLONUM_FLAG = 0x02, /* ...xxxx xx10 */ - RUBY_SYMBOL_FLAG = 0x0c, /* ...0000 1100 */ -#else - RUBY_Qfalse = 0, /* ...0000 0000 */ - RUBY_Qtrue = 2, /* ...0000 0010 */ - RUBY_Qnil = 4, /* ...0000 0100 */ - RUBY_Qundef = 6, /* ...0000 0110 */ + RUBY_Qfalse = 0, + RUBY_Qtrue = 2, + RUBY_Qnil = 4, + RUBY_Qundef = 6, RUBY_IMMEDIATE_MASK = 0x03, - RUBY_FIXNUM_FLAG = 0x01, /* ...xxxx xxx1 */ - RUBY_FLONUM_MASK = 0x00, /* any values ANDed with FLONUM_MASK cannot be FLONUM_FLAG */ - RUBY_FLONUM_FLAG = 0x02, - RUBY_SYMBOL_FLAG = 0x0e, /* ...0000 1110 */ -#endif + RUBY_FIXNUM_FLAG = 0x01, + RUBY_SYMBOL_FLAG = 0x0e, RUBY_SPECIAL_SHIFT = 8 }; @@ -413,14 +360,10 @@ enum ruby_special_consts { #define Qundef ((VALUE)RUBY_Qundef) /* undefined value for placeholder */ #define IMMEDIATE_MASK RUBY_IMMEDIATE_MASK #define FIXNUM_FLAG RUBY_FIXNUM_FLAG -#if USE_FLONUM -#define FLONUM_MASK RUBY_FLONUM_MASK -#define FLONUM_FLAG RUBY_FLONUM_FLAG -#endif #define SYMBOL_FLAG RUBY_SYMBOL_FLAG -#define RTEST(v) !(((VALUE)(v) & ~Qnil) == 0) -#define NIL_P(v) !((VALUE)(v) != Qnil) +#define RTEST(v) (((VALUE)(v) & ~Qnil) != 0) +#define NIL_P(v) ((VALUE)(v) == Qnil) #define CLASS_OF(v) rb_class_of((VALUE)(v)) @@ -489,48 +432,23 @@ enum ruby_value_type { static inline int rb_type(VALUE obj); #define TYPE(x) rb_type((VALUE)(x)) -#define RB_FLOAT_TYPE_P(obj) (FLONUM_P(obj) || (!SPECIAL_CONST_P(obj) && BUILTIN_TYPE(obj) == T_FLOAT)) - -#define RB_TYPE_P(obj, type) ( \ - ((type) == T_FIXNUM) ? FIXNUM_P(obj) : \ - ((type) == T_TRUE) ? ((obj) == Qtrue) : \ - ((type) == T_FALSE) ? ((obj) == Qfalse) : \ - ((type) == T_NIL) ? ((obj) == Qnil) : \ - ((type) == T_UNDEF) ? ((obj) == Qundef) : \ - ((type) == T_SYMBOL) ? SYMBOL_P(obj) : \ - ((type) == T_FLOAT) ? RB_FLOAT_TYPE_P(obj) : \ - (!SPECIAL_CONST_P(obj) && BUILTIN_TYPE(obj) == (type))) - -/* RB_GC_GUARD_PTR() is an intermediate macro, and has no effect by - * itself. don't use it directly */ #ifdef __GNUC__ #define RB_GC_GUARD_PTR(ptr) \ __extension__ ({volatile VALUE *rb_gc_guarded_ptr = (ptr); rb_gc_guarded_ptr;}) #else #ifdef _MSC_VER #pragma optimize("", off) +#endif static inline volatile VALUE *rb_gc_guarded_ptr(volatile VALUE *ptr) {return ptr;} +#ifdef _MSC_VER #pragma optimize("", on) -#else -volatile VALUE *rb_gc_guarded_ptr_val(volatile VALUE *ptr, VALUE val); -#define HAVE_RB_GC_GUARDED_PTR_VAL 1 -#define RB_GC_GUARD(v) (*rb_gc_guarded_ptr_val(&(v),(v))) #endif #define RB_GC_GUARD_PTR(ptr) rb_gc_guarded_ptr(ptr) #endif - -#ifndef RB_GC_GUARD #define RB_GC_GUARD(v) (*RB_GC_GUARD_PTR(&(v))) -#endif - -#ifdef __GNUC__ -#define RB_UNUSED_VAR(x) x __attribute__ ((unused)) -#else -#define RB_UNUSED_VAR(x) x -#endif void rb_check_type(VALUE,int); -#define Check_Type(v,t) rb_check_type((VALUE)(v),(t)) +#define Check_Type(v,t) rb_check_type((VALUE)(v),t) VALUE rb_str_to_str(VALUE); VALUE rb_string_value(volatile VALUE*); @@ -542,17 +460,13 @@ char *rb_string_value_cstr(volatile VALUE*); #define StringValueCStr(v) rb_string_value_cstr(&(v)) void rb_check_safe_obj(VALUE); +DEPRECATED(void rb_check_safe_str(VALUE)); #define SafeStringValue(v) do {\ StringValue(v);\ rb_check_safe_obj(v);\ } while (0) -#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4)) -void rb_check_safe_str(VALUE) __attribute__((error("rb_check_safe_str() and Check_SafeStr() are obsolete; use SafeStringValue() instead"))); -# define Check_SafeStr(v) rb_check_safe_str((VALUE)(v)) -#else -# define rb_check_safe_str(x) [<"rb_check_safe_str() is obsolete; use SafeStringValue() instead">] -# define Check_SafeStr(v) [<"Check_SafeStr() is obsolete; use SafeStringValue() instead">] -#endif +/* obsolete macro - use SafeStringValue(v) */ +#define Check_SafeStr(v) rb_check_safe_str((VALUE)(v)) VALUE rb_str_export(VALUE); #define ExportStringValue(v) do {\ @@ -567,37 +481,9 @@ VALUE rb_get_path(VALUE); VALUE rb_get_path_no_checksafe(VALUE); #define FilePathStringValue(v) ((v) = rb_get_path_no_checksafe(v)) -#define RUBY_SAFE_LEVEL_MAX 3 void rb_secure(int); int rb_safe_level(void); void rb_set_safe_level(int); -#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4)) -int ruby_safe_level_4_error(void) __attribute__((error("$SAFE=4 is obsolete"))); -int ruby_safe_level_4_warning(void) __attribute__((warning("$SAFE=4 is obsolete"))); -# ifdef RUBY_EXPORT -# define ruby_safe_level_4_warning() ruby_safe_level_4_error() -# endif -#if defined(HAVE_BUILTIN___BUILTIN_CHOOSE_EXPR_CONSTANT_P) -# define RUBY_SAFE_LEVEL_INVALID_P(level) \ - __extension__(\ - __builtin_choose_expr(\ - __builtin_constant_p(level), \ - ((level) < 0 || RUBY_SAFE_LEVEL_MAX < (level)), 0)) -# define RUBY_SAFE_LEVEL_CHECK(level, type) \ - __extension__(__builtin_choose_expr(RUBY_SAFE_LEVEL_INVALID_P(level), ruby_safe_level_4_##type(), (level))) -#else -/* in gcc 4.8 or earlier, __builtin_choose_expr() does not consider - * __builtin_constant_p(variable) a constant expression. - */ -# define RUBY_SAFE_LEVEL_INVALID_P(level) \ - __extension__(__builtin_constant_p(level) && \ - ((level) < 0 || RUBY_SAFE_LEVEL_MAX < (level))) -# define RUBY_SAFE_LEVEL_CHECK(level, type) \ - (RUBY_SAFE_LEVEL_INVALID_P(level) ? ruby_safe_level_4_##type() : (level)) -#endif -#define rb_secure(level) rb_secure(RUBY_SAFE_LEVEL_CHECK(level, warning)) -#define rb_set_safe_level(level) rb_set_safe_level(RUBY_SAFE_LEVEL_CHECK(level, error)) -#endif void rb_set_safe_level_force(int); void rb_secure_update(VALUE); NORETURN(void rb_insecure_operation(void)); @@ -605,95 +491,72 @@ NORETURN(void rb_insecure_operation(void)); VALUE rb_errinfo(void); void rb_set_errinfo(VALUE); -long rb_num2long(VALUE); -unsigned long rb_num2ulong(VALUE); +SIGNED_VALUE rb_num2long(VALUE); +VALUE rb_num2ulong(VALUE); +#define NUM2LONG_internal(x) (FIXNUM_P(x) ? FIX2LONG(x) : rb_num2long(x)) +#ifdef __GNUC__ +#define NUM2LONG(x) \ + __extension__ ({VALUE num2long_x = (x); NUM2LONG_internal(num2long_x);}) +#else static inline long -rb_num2long_inline(VALUE x) +NUM2LONG(VALUE x) { - if (FIXNUM_P(x)) - return FIX2LONG(x); - else - return rb_num2long(x); + return NUM2LONG_internal(x); } -#define NUM2LONG(x) rb_num2long_inline(x) -static inline unsigned long -rb_num2ulong_inline(VALUE x) -{ - if (FIXNUM_P(x)) - return (unsigned long)FIX2LONG(x); - else - return rb_num2ulong(x); -} -#define NUM2ULONG(x) rb_num2ulong_inline(x) +#endif +#define NUM2ULONG(x) rb_num2ulong((VALUE)x) #if SIZEOF_INT < SIZEOF_LONG long rb_num2int(VALUE); long rb_fix2int(VALUE); -#define FIX2INT(x) ((int)rb_fix2int((VALUE)(x))) - +#define FIX2INT(x) ((int)rb_fix2int((VALUE)x)) +#define NUM2INT_internal(x) (FIXNUM_P(x) ? FIX2INT(x) : (int)rb_num2int(x)) +#ifdef __GNUC__ +#define NUM2INT(x) \ + __extension__ ({VALUE num2int_x = (x); NUM2INT_internal(num2int_x);}) +#else static inline int -rb_num2int_inline(VALUE x) +NUM2INT(VALUE x) { - if (FIXNUM_P(x)) - return FIX2INT(x); - else - return (int)rb_num2int(x); + return NUM2INT_internal(x); } -#define NUM2INT(x) rb_num2int_inline(x) - +#endif unsigned long rb_num2uint(VALUE); #define NUM2UINT(x) ((unsigned int)rb_num2uint(x)) unsigned long rb_fix2uint(VALUE); #define FIX2UINT(x) ((unsigned int)rb_fix2uint(x)) -#else /* SIZEOF_INT < SIZEOF_LONG */ +#else #define NUM2INT(x) ((int)NUM2LONG(x)) #define NUM2UINT(x) ((unsigned int)NUM2ULONG(x)) #define FIX2INT(x) ((int)FIX2LONG(x)) #define FIX2UINT(x) ((unsigned int)FIX2ULONG(x)) -#endif /* SIZEOF_INT < SIZEOF_LONG */ - -short rb_num2short(VALUE); -unsigned short rb_num2ushort(VALUE); -short rb_fix2short(VALUE); -unsigned short rb_fix2ushort(VALUE); -#define FIX2SHORT(x) (rb_fix2short((VALUE)(x))) -static inline short -rb_num2short_inline(VALUE x) -{ - if (FIXNUM_P(x)) - return FIX2SHORT(x); - else - return rb_num2short(x); -} - -#define NUM2SHORT(x) rb_num2short_inline(x) -#define NUM2USHORT(x) rb_num2ushort(x) +#endif #ifdef HAVE_LONG_LONG LONG_LONG rb_num2ll(VALUE); unsigned LONG_LONG rb_num2ull(VALUE); +# define NUM2LL_internal(x) (FIXNUM_P(x) ? FIX2LONG(x) : rb_num2ll(x)) +# ifdef __GNUC__ +# define NUM2LL(x) \ + __extension__ ({VALUE num2ll_x = (x); NUM2LL_internal(num2ll_x);}) +# else static inline LONG_LONG -rb_num2ll_inline(VALUE x) +NUM2LL(VALUE x) { - if (FIXNUM_P(x)) - return FIX2LONG(x); - else - return rb_num2ll(x); + return NUM2LL_internal(x); } -# define NUM2LL(x) rb_num2ll_inline(x) -# define NUM2ULL(x) rb_num2ull(x) +# endif +# define NUM2ULL(x) rb_num2ull((VALUE)x) #endif -#if !defined(NUM2OFFT) -# if defined(HAVE_LONG_LONG) && SIZEOF_OFF_T > SIZEOF_LONG -# define NUM2OFFT(x) ((off_t)NUM2LL(x)) -# else -# define NUM2OFFT(x) NUM2LONG(x) -# endif +#if defined(HAVE_LONG_LONG) && SIZEOF_OFF_T > SIZEOF_LONG +# define NUM2OFFT(x) ((off_t)NUM2LL(x)) +#else +# define NUM2OFFT(x) NUM2LONG(x) #endif #if defined(HAVE_LONG_LONG) && SIZEOF_SIZE_T > SIZEOF_LONG # define NUM2SIZET(x) ((size_t)NUM2ULL(x)) -# define NUM2SSIZET(x) ((ssize_t)NUM2LL(x)) +# define NUM2SSIZET(x) ((size_t)NUM2LL(x)) #else # define NUM2SIZET(x) NUM2ULONG(x) # define NUM2SSIZET(x) NUM2LONG(x) @@ -706,89 +569,33 @@ VALUE rb_uint2big(VALUE); VALUE rb_int2big(SIGNED_VALUE); VALUE rb_newobj(void); -VALUE rb_newobj_of(VALUE, VALUE); -VALUE rb_obj_setup(VALUE obj, VALUE klass, VALUE type); -#define NEWOBJ(obj,type) type *(obj) = (type*)rb_newobj() -#define NEWOBJ_OF(obj,type,klass,flags) type *(obj) = (type*)rb_newobj_of(klass, flags) -#define OBJSETUP(obj,c,t) rb_obj_setup(obj, c, t) /* use NEWOBJ_OF instead of NEWOBJ()+OBJSETUP() */ +#define NEWOBJ(obj,type) type *obj = (type*)rb_newobj() +#define OBJSETUP(obj,c,t) do {\ + RBASIC(obj)->flags = (t);\ + RBASIC(obj)->klass = (c);\ + if (rb_safe_level() >= 3) FL_SET(obj, FL_TAINT | FL_UNTRUSTED);\ +} while (0) #define CLONESETUP(clone,obj) do {\ - OBJSETUP((clone),rb_singleton_class_clone((VALUE)(obj)),RBASIC(obj)->flags);\ - rb_singleton_class_attached(RBASIC(clone)->klass, (VALUE)(clone));\ - if (FL_TEST((obj), FL_EXIVAR)) rb_copy_generic_ivar((VALUE)(clone),(VALUE)(obj));\ + OBJSETUP(clone,rb_singleton_class_clone((VALUE)obj),RBASIC(obj)->flags);\ + rb_singleton_class_attached(RBASIC(clone)->klass, (VALUE)clone);\ + if (FL_TEST(obj, FL_EXIVAR)) rb_copy_generic_ivar((VALUE)clone,(VALUE)obj);\ } while (0) #define DUPSETUP(dup,obj) do {\ - OBJSETUP((dup),rb_obj_class(obj), (RBASIC(obj)->flags)&(T_MASK|FL_EXIVAR|FL_TAINT)); \ - if (FL_TEST((obj), FL_EXIVAR)) rb_copy_generic_ivar((VALUE)(dup),(VALUE)(obj));\ + OBJSETUP(dup,rb_obj_class(obj), (RBASIC(obj)->flags)&(T_MASK|FL_EXIVAR|FL_TAINT|FL_UNTRUSTED)); \ + if (FL_TEST(obj, FL_EXIVAR)) rb_copy_generic_ivar((VALUE)dup,(VALUE)obj);\ } while (0) -#ifndef USE_RGENGC -#define USE_RGENGC 1 -#ifndef USE_RINCGC -#define USE_RINCGC 1 -#endif -#endif - -#if USE_RGENGC == 0 -#define USE_RINCGC 0 -#endif - -#ifndef RGENGC_WB_PROTECTED_ARRAY -#define RGENGC_WB_PROTECTED_ARRAY 1 -#endif -#ifndef RGENGC_WB_PROTECTED_HASH -#define RGENGC_WB_PROTECTED_HASH 1 -#endif -#ifndef RGENGC_WB_PROTECTED_STRUCT -#define RGENGC_WB_PROTECTED_STRUCT 1 -#endif -#ifndef RGENGC_WB_PROTECTED_STRING -#define RGENGC_WB_PROTECTED_STRING 1 -#endif -#ifndef RGENGC_WB_PROTECTED_OBJECT -#define RGENGC_WB_PROTECTED_OBJECT 1 -#endif -#ifndef RGENGC_WB_PROTECTED_REGEXP -#define RGENGC_WB_PROTECTED_REGEXP 1 -#endif -#ifndef RGENGC_WB_PROTECTED_CLASS -#define RGENGC_WB_PROTECTED_CLASS 1 -#endif -#ifndef RGENGC_WB_PROTECTED_FLOAT -#define RGENGC_WB_PROTECTED_FLOAT 1 -#endif -#ifndef RGENGC_WB_PROTECTED_COMPLEX -#define RGENGC_WB_PROTECTED_COMPLEX 1 -#endif -#ifndef RGENGC_WB_PROTECTED_RATIONAL -#define RGENGC_WB_PROTECTED_RATIONAL 1 -#endif -#ifndef RGENGC_WB_PROTECTED_BIGNUM -#define RGENGC_WB_PROTECTED_BIGNUM 1 -#endif -#ifndef RGENGC_WB_PROTECTED_NODE_CREF -#define RGENGC_WB_PROTECTED_NODE_CREF 1 -#endif - struct RBasic { VALUE flags; - const VALUE klass; -} -#ifdef __GNUC__ - __attribute__((aligned(sizeof(VALUE)))) -#endif -; - -VALUE rb_obj_hide(VALUE obj); -VALUE rb_obj_reveal(VALUE obj, VALUE klass); /* do not use this API to change klass information */ - -#define RBASIC_CLASS(obj) (RBASIC(obj)->klass) + VALUE klass; +}; #define ROBJECT_EMBED_LEN_MAX 3 struct RObject { struct RBasic basic; union { struct { - long numiv; /* only uses 32-bits */ + long numiv; VALUE *ivptr; struct st_table *iv_index_tbl; /* shortcut for RCLASS_IV_INDEX_TBL(rb_obj_class(obj)) */ } heap; @@ -810,28 +617,30 @@ struct RObject { ROBJECT(o)->as.heap.iv_index_tbl) /** @internal */ -typedef struct rb_classext_struct rb_classext_t; +typedef struct { + VALUE super; + struct st_table *iv_tbl; +} rb_classext_t; struct RClass { struct RBasic basic; - VALUE super; rb_classext_t *ptr; - struct method_table_wrapper *m_tbl_wrapper; + struct st_table *m_tbl; + struct st_table *iv_index_tbl; }; -#define RCLASS_SUPER(c) rb_class_get_superclass(c) +#define RCLASS_IV_TBL(c) (RCLASS(c)->ptr->iv_tbl) +#define RCLASS_M_TBL(c) (RCLASS(c)->m_tbl) +#define RCLASS_SUPER(c) (RCLASS(c)->ptr->super) +#define RCLASS_IV_INDEX_TBL(c) (RCLASS(c)->iv_index_tbl) #define RMODULE_IV_TBL(m) RCLASS_IV_TBL(m) -#define RMODULE_CONST_TBL(m) RCLASS_CONST_TBL(m) #define RMODULE_M_TBL(m) RCLASS_M_TBL(m) #define RMODULE_SUPER(m) RCLASS_SUPER(m) -#define RMODULE_IS_OVERLAID FL_USER2 -#define RMODULE_IS_REFINEMENT FL_USER3 -#define RMODULE_INCLUDED_INTO_REFINEMENT FL_USER4 - -double rb_float_value(VALUE); -VALUE rb_float_new(double); -VALUE rb_float_new_in_heap(double); -#define RFLOAT_VALUE(v) rb_float_value(v) +struct RFloat { + struct RBasic basic; + double float_value; +}; +#define RFLOAT_VALUE(v) (RFLOAT(v)->float_value) #define DBL2NUM(dbl) rb_float_new(dbl) #define ELTS_SHARED FL_USER2 @@ -852,15 +661,12 @@ struct RString { } as; }; #define RSTRING_NOEMBED FL_USER1 -#define RSTRING_FSTR FL_USER17 #define RSTRING_EMBED_LEN_MASK (FL_USER2|FL_USER3|FL_USER4|FL_USER5|FL_USER6) #define RSTRING_EMBED_LEN_SHIFT (FL_USHIFT+2) -#define RSTRING_EMBED_LEN(str) \ - (long)((RBASIC(str)->flags >> RSTRING_EMBED_LEN_SHIFT) & \ - (RSTRING_EMBED_LEN_MASK >> RSTRING_EMBED_LEN_SHIFT)) #define RSTRING_LEN(str) \ (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? \ - RSTRING_EMBED_LEN(str) : \ + (long)((RBASIC(str)->flags >> RSTRING_EMBED_LEN_SHIFT) & \ + (RSTRING_EMBED_LEN_MASK >> RSTRING_EMBED_LEN_SHIFT)) : \ RSTRING(str)->as.heap.len) #define RSTRING_PTR(str) \ (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? \ @@ -868,13 +674,11 @@ struct RString { RSTRING(str)->as.heap.ptr) #define RSTRING_END(str) \ (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? \ - (RSTRING(str)->as.ary + RSTRING_EMBED_LEN(str)) : \ + (RSTRING(str)->as.ary + \ + ((RBASIC(str)->flags >> RSTRING_EMBED_LEN_SHIFT) & \ + (RSTRING_EMBED_LEN_MASK >> RSTRING_EMBED_LEN_SHIFT))) : \ (RSTRING(str)->as.heap.ptr + RSTRING(str)->as.heap.len)) #define RSTRING_LENINT(str) rb_long2int(RSTRING_LEN(str)) -#define RSTRING_GETMEM(str, ptrvar, lenvar) \ - (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? \ - ((ptrvar) = RSTRING(str)->as.ary, (lenvar) = RSTRING_EMBED_LEN(str)) : \ - ((ptrvar) = RSTRING(str)->as.heap.ptr, (lenvar) = RSTRING(str)->as.heap.len)) #define RARRAY_EMBED_LEN_MAX 3 struct RArray { @@ -886,9 +690,9 @@ struct RArray { long capa; VALUE shared; } aux; - const VALUE *ptr; + VALUE *ptr; } heap; - const VALUE ary[RARRAY_EMBED_LEN_MAX]; + VALUE ary[RARRAY_EMBED_LEN_MAX]; } as; }; #define RARRAY_EMBED_FLAG FL_USER1 @@ -900,38 +704,16 @@ struct RArray { (long)((RBASIC(a)->flags >> RARRAY_EMBED_LEN_SHIFT) & \ (RARRAY_EMBED_LEN_MASK >> RARRAY_EMBED_LEN_SHIFT)) : \ RARRAY(a)->as.heap.len) - +#define RARRAY_PTR(a) \ + ((RBASIC(a)->flags & RARRAY_EMBED_FLAG) ? \ + RARRAY(a)->as.ary : \ + RARRAY(a)->as.heap.ptr) #define RARRAY_LENINT(ary) rb_long2int(RARRAY_LEN(ary)) -#define RARRAY_CONST_PTR(a) \ - ((const VALUE *)((RBASIC(a)->flags & RARRAY_EMBED_FLAG) ? \ - RARRAY(a)->as.ary : \ - RARRAY(a)->as.heap.ptr)) - -#define RARRAY_PTR_USE_START(a) ((VALUE *)RARRAY_CONST_PTR(a)) -#define RARRAY_PTR_USE_END(a) /* */ - -#define RARRAY_PTR_USE(ary, ptr_name, expr) do { \ - const VALUE _ary = (ary); \ - VALUE *ptr_name = (VALUE *)RARRAY_PTR_USE_START(_ary); \ - expr; \ - RARRAY_PTR_USE_END(_ary); \ -} while (0) - -#define RARRAY_AREF(a, i) (RARRAY_CONST_PTR(a)[i]) -#define RARRAY_ASET(a, i, v) do { \ - const VALUE _ary = (a); \ - VALUE *ptr = (VALUE *)RARRAY_PTR_USE_START(_ary); \ - RB_OBJ_WRITE(_ary, &ptr[i], (v)); \ - RARRAY_PTR_USE_END(_ary); \ -} while (0) - -#define RARRAY_PTR(a) ((VALUE *)RARRAY_CONST_PTR(RGENGC_WB_PROTECTED_ARRAY ? OBJ_WB_UNPROTECT((VALUE)a) : ((VALUE)a))) - struct RRegexp { struct RBasic basic; struct re_pattern_buffer *ptr; - const VALUE src; + VALUE src; unsigned long usecnt; }; #define RREGEXP_SRC(r) RREGEXP(r)->src @@ -939,21 +721,35 @@ struct RRegexp { #define RREGEXP_SRC_LEN(r) RSTRING_LEN(RREGEXP(r)->src) #define RREGEXP_SRC_END(r) RSTRING_END(RREGEXP(r)->src) +struct RHash { + struct RBasic basic; + struct st_table *ntbl; /* possibly 0 */ + int iter_lev; + VALUE ifnone; +}; /* RHASH_TBL allocates st_table if not available. */ #define RHASH_TBL(h) rb_hash_tbl(h) -#define RHASH_ITER_LEV(h) rb_hash_iter_lev(h) -#define RHASH_IFNONE(h) rb_hash_ifnone(h) -#define RHASH_SIZE(h) NUM2SIZET(rb_hash_size(h)) +#define RHASH_ITER_LEV(h) (RHASH(h)->iter_lev) +#define RHASH_IFNONE(h) (RHASH(h)->ifnone) +#define RHASH_SIZE(h) (RHASH(h)->ntbl ? RHASH(h)->ntbl->num_entries : 0) #define RHASH_EMPTY_P(h) (RHASH_SIZE(h) == 0) -#define RHASH_SET_IFNONE(h, ifnone) rb_hash_set_ifnone((VALUE)h, ifnone) struct RFile { struct RBasic basic; struct rb_io_t *fptr; }; -#define RCOMPLEX_SET_REAL(cmp, r) RB_OBJ_WRITE((cmp), &((struct RComplex *)(cmp))->real,(r)) -#define RCOMPLEX_SET_IMAG(cmp, i) RB_OBJ_WRITE((cmp), &((struct RComplex *)(cmp))->imag,(i)) +struct RRational { + struct RBasic basic; + VALUE num; + VALUE den; +}; + +struct RComplex { + struct RBasic basic; + VALUE real; + VALUE imag; +}; struct RData { struct RBasic basic; @@ -962,26 +758,16 @@ struct RData { void *data; }; -typedef struct rb_data_type_struct rb_data_type_t; - -struct rb_data_type_struct { +typedef struct rb_data_type_struct { const char *wrap_struct_name; - struct { - void (*dmark)(void*); - void (*dfree)(void*); - size_t (*dsize)(const void *); - void *reserved[2]; /* For future extension. - This array *must* be filled with ZERO. */ - } function; - const rb_data_type_t *parent; + void (*dmark)(void*); + void (*dfree)(void*); + size_t (*dsize)(const void *); + void *reserved[3]; /* For future extension. + This array *must* be filled with ZERO. */ void *data; /* This area can be used for any purpose by a programmer who define the type. */ - VALUE flags; /* FL_WB_PROTECTED */ -}; - -#define HAVE_TYPE_RB_DATA_TYPE_T 1 -#define HAVE_RB_DATA_TYPE_T_FUNCTION 1 -#define HAVE_RB_DATA_TYPE_T_PARENT 1 +} rb_data_type_t; struct RTypedData { struct RBasic basic; @@ -997,54 +783,46 @@ struct RTypedData { #define RTYPEDDATA_DATA(v) (RTYPEDDATA(v)->data) /* -#define RUBY_DATA_FUNC(func) ((void (*)(void*))(func)) +#define RUBY_DATA_FUNC(func) ((void (*)(void*))func) */ typedef void (*RUBY_DATA_FUNC)(void*); -#ifndef RUBY_UNTYPED_DATA_WARNING -# if defined RUBY_EXPORT -# define RUBY_UNTYPED_DATA_WARNING 1 -# else -# define RUBY_UNTYPED_DATA_WARNING 0 -# endif -#endif VALUE rb_data_object_alloc(VALUE,void*,RUBY_DATA_FUNC,RUBY_DATA_FUNC); VALUE rb_data_typed_object_alloc(VALUE klass, void *datap, const rb_data_type_t *); -int rb_typeddata_inherited_p(const rb_data_type_t *child, const rb_data_type_t *parent); int rb_typeddata_is_kind_of(VALUE, const rb_data_type_t *); void *rb_check_typeddata(VALUE, const rb_data_type_t *); -#define Check_TypedStruct(v,t) rb_check_typeddata((VALUE)(v),(t)) +#define Check_TypedStruct(v,t) rb_check_typeddata((VALUE)(v),t) #define RUBY_DEFAULT_FREE ((RUBY_DATA_FUNC)-1) #define RUBY_NEVER_FREE ((RUBY_DATA_FUNC)0) #define RUBY_TYPED_DEFAULT_FREE RUBY_DEFAULT_FREE #define RUBY_TYPED_NEVER_FREE RUBY_NEVER_FREE -/* bits for rb_data_type_struct::flags */ -#define RUBY_TYPED_FREE_IMMEDIATELY 1 /* TYPE field */ -#define RUBY_TYPED_WB_PROTECTED FL_WB_PROTECTED /* THIS FLAG DEPENDS ON Ruby version */ -#define RUBY_TYPED_PROMOTED1 FL_PROMOTED1 /* THIS FLAG DEPENDS ON Ruby version */ - #define Data_Wrap_Struct(klass,mark,free,sval)\ - rb_data_object_alloc((klass),(sval),(RUBY_DATA_FUNC)(mark),(RUBY_DATA_FUNC)(free)) + rb_data_object_alloc(klass,sval,(RUBY_DATA_FUNC)mark,(RUBY_DATA_FUNC)free) #define Data_Make_Struct(klass,type,mark,free,sval) (\ - (sval) = ZALLOC(type),\ - Data_Wrap_Struct((klass),(mark),(free),(sval))\ + sval = ALLOC(type),\ + memset(sval, 0, sizeof(type)),\ + Data_Wrap_Struct(klass,mark,free,sval)\ ) #define TypedData_Wrap_Struct(klass,data_type,sval)\ - rb_data_typed_object_alloc((klass),(sval),(data_type)) + rb_data_typed_object_alloc(klass,sval,data_type) #define TypedData_Make_Struct(klass, type, data_type, sval) (\ - (sval) = ZALLOC(type),\ - TypedData_Wrap_Struct((klass),(data_type),(sval))\ + sval = ALLOC(type),\ + memset(sval, 0, sizeof(type)),\ + TypedData_Wrap_Struct(klass,data_type,sval)\ ) -#define Data_Get_Struct(obj,type,sval) \ - ((sval) = (type*)rb_data_object_get(obj)) +#define Data_Get_Struct(obj,type,sval) do {\ + Check_Type(obj, T_DATA); \ + sval = (type*)DATA_PTR(obj);\ +} while (0) -#define TypedData_Get_Struct(obj,type,data_type,sval) \ - ((sval) = (type*)rb_check_typeddata((obj), (data_type))) +#define TypedData_Get_Struct(obj,type,data_type,sval) do {\ + sval = (type*)rb_check_typeddata(obj, data_type); \ +} while (0) #define RSTRUCT_EMBED_LEN_MAX 3 struct RStruct { @@ -1052,9 +830,9 @@ struct RStruct { union { struct { long len; - const VALUE *ptr; + VALUE *ptr; } heap; - const VALUE ary[RSTRUCT_EMBED_LEN_MAX]; + VALUE ary[RSTRUCT_EMBED_LEN_MAX]; } as; }; #define RSTRUCT_EMBED_LEN_MASK (FL_USER2|FL_USER1) @@ -1064,40 +842,71 @@ struct RStruct { (long)((RBASIC(st)->flags >> RSTRUCT_EMBED_LEN_SHIFT) & \ (RSTRUCT_EMBED_LEN_MASK >> RSTRUCT_EMBED_LEN_SHIFT)) : \ RSTRUCT(st)->as.heap.len) +#define RSTRUCT_PTR(st) \ + ((RBASIC(st)->flags & RSTRUCT_EMBED_LEN_MASK) ? \ + RSTRUCT(st)->as.ary : \ + RSTRUCT(st)->as.heap.ptr) #define RSTRUCT_LENINT(st) rb_long2int(RSTRUCT_LEN(st)) -#define RSTRUCT_CONST_PTR(st) \ - ((RBASIC(st)->flags & RSTRUCT_EMBED_LEN_MASK) ? \ - RSTRUCT(st)->as.ary : \ - RSTRUCT(st)->as.heap.ptr) -#define RSTRUCT_PTR(st) ((VALUE *)RSTRUCT_CONST_PTR(RGENGC_WB_PROTECTED_STRUCT ? OBJ_WB_UNPROTECT((VALUE)st) : (VALUE)st)) -#define RSTRUCT_SET(st, idx, v) RB_OBJ_WRITE(st, &RSTRUCT_CONST_PTR(st)[idx], (v)) -#define RSTRUCT_GET(st, idx) (RSTRUCT_CONST_PTR(st)[idx]) - -#define RBIGNUM_SIGN(b) (FIX2LONG(rb_big_cmp((b), INT2FIX(0))) >= 0) -#define RBIGNUM_POSITIVE_P(b) (FIX2LONG(rb_big_cmp((b), INT2FIX(0))) >= 0) -#define RBIGNUM_NEGATIVE_P(b) (FIX2LONG(rb_big_cmp((b), INT2FIX(0))) < 0) +#define RBIGNUM_EMBED_LEN_MAX ((int)((sizeof(VALUE)*3)/sizeof(BDIGIT))) +struct RBignum { + struct RBasic basic; + union { + struct { + long len; + BDIGIT *digits; + } heap; + BDIGIT ary[RBIGNUM_EMBED_LEN_MAX]; + } as; +}; +#define RBIGNUM_SIGN_BIT FL_USER1 +/* sign: positive:1, negative:0 */ +#define RBIGNUM_SIGN(b) ((RBASIC(b)->flags & RBIGNUM_SIGN_BIT) != 0) +#define RBIGNUM_SET_SIGN(b,sign) \ + ((sign) ? (RBASIC(b)->flags |= RBIGNUM_SIGN_BIT) \ + : (RBASIC(b)->flags &= ~RBIGNUM_SIGN_BIT)) +#define RBIGNUM_POSITIVE_P(b) RBIGNUM_SIGN(b) +#define RBIGNUM_NEGATIVE_P(b) (!RBIGNUM_SIGN(b)) + +#define RBIGNUM_EMBED_FLAG FL_USER2 +#define RBIGNUM_EMBED_LEN_MASK (FL_USER5|FL_USER4|FL_USER3) +#define RBIGNUM_EMBED_LEN_SHIFT (FL_USHIFT+3) +#define RBIGNUM_LEN(b) \ + ((RBASIC(b)->flags & RBIGNUM_EMBED_FLAG) ? \ + (long)((RBASIC(b)->flags >> RBIGNUM_EMBED_LEN_SHIFT) & \ + (RBIGNUM_EMBED_LEN_MASK >> RBIGNUM_EMBED_LEN_SHIFT)) : \ + RBIGNUM(b)->as.heap.len) +/* LSB:RBIGNUM_DIGITS(b)[0], MSB:RBIGNUM_DIGITS(b)[RBIGNUM_LEN(b)-1] */ +#define RBIGNUM_DIGITS(b) \ + ((RBASIC(b)->flags & RBIGNUM_EMBED_FLAG) ? \ + RBIGNUM(b)->as.ary : \ + RBIGNUM(b)->as.heap.digits) +#define RBIGNUM_LENINT(b) rb_long2int(RBIGNUM_LEN(b)) #define R_CAST(st) (struct st*) #define RBASIC(obj) (R_CAST(RBasic)(obj)) #define ROBJECT(obj) (R_CAST(RObject)(obj)) #define RCLASS(obj) (R_CAST(RClass)(obj)) #define RMODULE(obj) RCLASS(obj) +#define RFLOAT(obj) (R_CAST(RFloat)(obj)) #define RSTRING(obj) (R_CAST(RString)(obj)) #define RREGEXP(obj) (R_CAST(RRegexp)(obj)) #define RARRAY(obj) (R_CAST(RArray)(obj)) +#define RHASH(obj) (R_CAST(RHash)(obj)) #define RDATA(obj) (R_CAST(RData)(obj)) #define RTYPEDDATA(obj) (R_CAST(RTypedData)(obj)) #define RSTRUCT(obj) (R_CAST(RStruct)(obj)) +#define RBIGNUM(obj) (R_CAST(RBignum)(obj)) #define RFILE(obj) (R_CAST(RFile)(obj)) +#define RRATIONAL(obj) (R_CAST(RRational)(obj)) +#define RCOMPLEX(obj) (R_CAST(RComplex)(obj)) #define FL_SINGLETON FL_USER0 -#define FL_WB_PROTECTED (((VALUE)1)<<5) -#define FL_PROMOTED0 (((VALUE)1)<<5) -#define FL_PROMOTED1 (((VALUE)1)<<6) +#define FL_MARK (((VALUE)1)<<5) +#define FL_RESERVED (((VALUE)1)<<6) /* will be used in the future GC */ #define FL_FINALIZE (((VALUE)1)<<7) #define FL_TAINT (((VALUE)1)<<8) -#define FL_UNTRUSTED FL_TAINT +#define FL_UNTRUSTED (((VALUE)1)<<9) #define FL_EXIVAR (((VALUE)1)<<10) #define FL_FREEZE (((VALUE)1)<<11) @@ -1127,248 +936,89 @@ struct RStruct { #define SPECIAL_CONST_P(x) (IMMEDIATE_P(x) || !RTEST(x)) #define FL_ABLE(x) (!SPECIAL_CONST_P(x) && BUILTIN_TYPE(x) != T_NODE) -#define FL_TEST_RAW(x,f) (RBASIC(x)->flags&(f)) -#define FL_TEST(x,f) (FL_ABLE(x)?FL_TEST_RAW((x),(f)):0) -#define FL_ANY(x,f) FL_TEST((x),(f)) -#define FL_ALL(x,f) (FL_TEST((x),(f)) == (f)) +#define FL_TEST(x,f) (FL_ABLE(x)?(RBASIC(x)->flags&(f)):0) +#define FL_ANY(x,f) FL_TEST(x,f) +#define FL_ALL(x,f) (FL_TEST(x,f) == (f)) #define FL_SET(x,f) do {if (FL_ABLE(x)) RBASIC(x)->flags |= (f);} while (0) #define FL_UNSET(x,f) do {if (FL_ABLE(x)) RBASIC(x)->flags &= ~(f);} while (0) #define FL_REVERSE(x,f) do {if (FL_ABLE(x)) RBASIC(x)->flags ^= (f);} while (0) -#define OBJ_TAINTABLE(x) (FL_ABLE(x) && BUILTIN_TYPE(x) != T_BIGNUM && BUILTIN_TYPE(x) != T_FLOAT) #define OBJ_TAINTED(x) (!!FL_TEST((x), FL_TAINT)) -#define OBJ_TAINT(x) (OBJ_TAINTABLE(x) ? (RBASIC(x)->flags |= FL_TAINT) : 0) -#define OBJ_UNTRUSTED(x) OBJ_TAINTED(x) -#define OBJ_UNTRUST(x) OBJ_TAINT(x) -#define OBJ_INFECT(x,s) ( \ - (OBJ_TAINTABLE(x) && FL_ABLE(s)) ? \ - RBASIC(x)->flags |= RBASIC(s)->flags & FL_TAINT : 0) - -#define OBJ_FROZEN(x) (FL_ABLE(x) ? !!(RBASIC(x)->flags&FL_FREEZE) : 1) -#define OBJ_FREEZE_RAW(x) (RBASIC(x)->flags |= FL_FREEZE) -#define OBJ_FREEZE(x) rb_obj_freeze_inline((VALUE)x) - -void rb_freeze_singleton_class(VALUE klass); - -static inline void -rb_obj_freeze_inline(VALUE x) -{ - if (FL_ABLE(x)) { - OBJ_FREEZE_RAW(x); - if (RBASIC_CLASS(x) && !(RBASIC(x)->flags & FL_SINGLETON)) { - rb_freeze_singleton_class(x); - } - } -} - -#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4)) -# define RUBY_UNTYPED_DATA_FUNC(func) func __attribute__((warning("untyped Data is unsafe; use TypedData instead"))) -#else -# define RUBY_UNTYPED_DATA_FUNC(func) DEPRECATED(func) -#endif - -RUBY_UNTYPED_DATA_FUNC(static inline VALUE rb_data_object_alloc_warning(VALUE,void*,RUBY_DATA_FUNC,RUBY_DATA_FUNC)); -RUBY_UNTYPED_DATA_FUNC(static inline void *rb_data_object_get_warning(VALUE)); - -static inline VALUE -rb_data_object_alloc_warning(VALUE klass, void *ptr, RUBY_DATA_FUNC mark, RUBY_DATA_FUNC free) -{ - return rb_data_object_alloc(klass, ptr, mark, free); -} - -#if defined(HAVE_BUILTIN___BUILTIN_CHOOSE_EXPR_CONSTANT_P) -#define rb_data_object_alloc_warning(klass, ptr, mark, free) \ - __extension__( \ - __builtin_choose_expr( \ - __builtin_constant_p(klass) && !(klass), \ - rb_data_object_alloc(klass, ptr, mark, free), \ - rb_data_object_alloc_warning(klass, ptr, mark, free))) -#endif - -static inline void * -rb_data_object_get(VALUE obj) -{ - Check_Type(obj, T_DATA); - return ((struct RData *)obj)->data; -} - -static inline void * -rb_data_object_get_warning(VALUE obj) -{ - return rb_data_object_get(obj); -} - -#define rb_data_object_alloc_0 rb_data_object_alloc -#define rb_data_object_alloc_1 rb_data_object_alloc_warning -#define rb_data_object_alloc RUBY_MACRO_SELECT(rb_data_object_alloc_, RUBY_UNTYPED_DATA_WARNING) -#define rb_data_object_get_0 rb_data_object_get -#define rb_data_object_get_1 rb_data_object_get_warning -#define rb_data_object_get RUBY_MACRO_SELECT(rb_data_object_get_, RUBY_UNTYPED_DATA_WARNING) - -#if USE_RGENGC -#define OBJ_PROMOTED_RAW(x) ((RBASIC(x)->flags & (FL_PROMOTED0|FL_PROMOTED1)) == (FL_PROMOTED0|FL_PROMOTED1)) -#define OBJ_PROMOTED(x) (SPECIAL_CONST_P(x) ? 0 : OBJ_PROMOTED_RAW(x)) -#define OBJ_WB_UNPROTECT(x) rb_obj_wb_unprotect(x, __FILE__, __LINE__) - -#if USE_RINCGC -int rb_gc_writebarrier_incremental(VALUE a, VALUE b); -#else -#define rb_gc_writebarrier_incremental(a, b) 0 -#endif -void rb_gc_writebarrier_generational(VALUE a, VALUE b); -void rb_gc_writebarrier_unprotect(VALUE obj); - -#else /* USE_RGENGC */ -#define OBJ_PROMOTED(x) 0 -#define OBJ_WB_UNPROTECT(x) rb_obj_wb_unprotect(x, __FILE__, __LINE__) -#endif - -/* Write barrier (WB) interfaces: - * - RB_OBJ_WRITE(a, slot, b): WB for new reference from `a' to `b'. - * Write `b' into `*slot'. `slot' is a pointer in `a'. - * - RB_OBJ_WRITTEN(a, oldv, b): WB for new reference from `a' to `b'. - * This doesn't write any values, but only a WB declaration. - * `oldv' is replaced value with `b' (not used in current Ruby). - * - * NOTE: The following core interfaces can be changed in the future. - * Please catch up if you want to insert WB into C-extensions - * correctly. - */ -#define RB_OBJ_WRITE(a, slot, b) rb_obj_write((VALUE)(a), (VALUE *)(slot), (VALUE)(b), __FILE__, __LINE__) -#define RB_OBJ_WRITTEN(a, oldv, b) rb_obj_written((VALUE)(a), (VALUE)(oldv), (VALUE)(b), __FILE__, __LINE__) - -#ifndef USE_RGENGC_LOGGING_WB_UNPROTECT -#define USE_RGENGC_LOGGING_WB_UNPROTECT 0 -#endif +#define OBJ_TAINT(x) FL_SET((x), FL_TAINT) +#define OBJ_UNTRUSTED(x) (!!FL_TEST((x), FL_UNTRUSTED)) +#define OBJ_UNTRUST(x) FL_SET((x), FL_UNTRUSTED) +#define OBJ_INFECT(x,s) do {if (FL_ABLE(x) && FL_ABLE(s)) RBASIC(x)->flags |= RBASIC(s)->flags & (FL_TAINT | FL_UNTRUSTED);} while (0) -#if USE_RGENGC_LOGGING_WB_UNPROTECT -void rb_gc_unprotect_logging(void *objptr, const char *filename, int line); -#define RGENGC_LOGGING_WB_UNPROTECT rb_gc_unprotect_logging -#endif - -static inline VALUE -rb_obj_wb_unprotect(VALUE x, RB_UNUSED_VAR(const char *filename), RB_UNUSED_VAR(int line)) -{ -#ifdef RGENGC_LOGGING_WB_UNPROTECT - RGENGC_LOGGING_WB_UNPROTECT((void *)x, filename, line); -#endif -#if USE_RGENGC - rb_gc_writebarrier_unprotect(x); -#endif - return x; -} - -static inline VALUE -rb_obj_written(VALUE a, RB_UNUSED_VAR(VALUE oldv), VALUE b, RB_UNUSED_VAR(const char *filename), RB_UNUSED_VAR(int line)) -{ -#ifdef RGENGC_LOGGING_OBJ_WRITTEN - RGENGC_LOGGING_OBJ_WRITTEN(a, oldv, b, filename, line); -#endif - -#if USE_RGENGC - if (!SPECIAL_CONST_P(b)) { - if (rb_gc_writebarrier_incremental(a, b) == 0) { - if (OBJ_PROMOTED_RAW(a) && !OBJ_PROMOTED_RAW(b)) { - rb_gc_writebarrier_generational(a, b); - } - } - } -#endif - - return a; -} - -static inline VALUE -rb_obj_write(VALUE a, VALUE *slot, VALUE b, RB_UNUSED_VAR(const char *filename), RB_UNUSED_VAR(int line)) -{ -#ifdef RGENGC_LOGGING_WRITE - RGENGC_LOGGING_WRITE(a, slot, b, filename, line); -#endif - - *slot = b; - -#if USE_RGENGC - rb_obj_written(a, Qundef /* ignore `oldv' now */, b, filename, line); -#endif - return a; -} +#define OBJ_FROZEN(x) (!!FL_TEST((x), FL_FREEZE)) +#define OBJ_FREEZE(x) FL_SET((x), FL_FREEZE) #if SIZEOF_INT < SIZEOF_LONG # define INT2NUM(v) INT2FIX((int)(v)) # define UINT2NUM(v) LONG2FIX((unsigned int)(v)) #else +# define INT2NUM_internal(v) (FIXABLE(v) ? INT2FIX(v) : rb_int2big(v)) +# ifdef __GNUC__ +# define INT2NUM(v) __extension__ ({int int2num_v = (v); INT2NUM_internal(int2num_v);}) +# else static inline VALUE -rb_int2num_inline(int v) +INT2NUM(int v) { - if (FIXABLE(v)) - return INT2FIX(v); - else - return rb_int2big(v); + return INT2NUM_internal(v); } -#define INT2NUM(x) rb_int2num_inline(x) +# endif +# define UINT2NUM_internal(v) (POSFIXABLE(v) ? LONG2FIX(v) : rb_uint2big(v)) +# ifdef __GNUC__ +# define UINT2NUM(v) __extension__ ({unsigned int uint2num_v = (v); UINT2NUM_internal(uint2num_v);}) +# else static inline VALUE -rb_uint2num_inline(unsigned int v) +UINT2NUM(unsigned int v) { - if (POSFIXABLE(v)) - return LONG2FIX(v); - else - return rb_uint2big(v); + return UINT2NUM_internal(v); } -#define UINT2NUM(x) rb_uint2num_inline(x) +# endif #endif +#define LONG2NUM_internal(v) (FIXABLE(v) ? LONG2FIX(v) : rb_int2big(v)) +#ifdef __GNUC__ +# define LONG2NUM(v) __extension__ ({long long2num_v = (v); LONG2NUM_internal(long2num_v);}) +#else static inline VALUE -rb_long2num_inline(long v) +LONG2NUM(long v) { - if (FIXABLE(v)) - return LONG2FIX(v); - else - return rb_int2big(v); + return LONG2NUM_internal(v); } -#define LONG2NUM(x) rb_long2num_inline(x) +#endif +#define ULONG2NUM_internal(v) (POSFIXABLE(v) ? LONG2FIX(v) : rb_uint2big(v)) +#ifdef __GNUC__ +# define ULONG2NUM(v) __extension__ ({unsigned long ulong2num_v = (v); ULONG2NUM_internal(ulong2num_v);}) +#else static inline VALUE -rb_ulong2num_inline(unsigned long v) +ULONG2NUM(unsigned long v) { - if (POSFIXABLE(v)) - return LONG2FIX(v); - else - return rb_uint2big(v); + return ULONG2NUM_internal(v); } -#define ULONG2NUM(x) rb_ulong2num_inline(x) +#endif +#define NUM2CHR_internal(x) (((TYPE(x) == T_STRING)&&(RSTRING_LEN(x)>=1))?\ + RSTRING_PTR(x)[0]:(char)(NUM2INT(x)&0xff)) +#ifdef __GNUC__ +# define NUM2CHR(x) __extension__ ({VALUE num2chr_x = (x); NUM2CHR_internal(num2chr_x);}) +#else static inline char -rb_num2char_inline(VALUE x) +NUM2CHR(VALUE x) { - if (RB_TYPE_P(x, T_STRING) && (RSTRING_LEN(x)>=1)) - return RSTRING_PTR(x)[0]; - else - return (char)(NUM2INT(x) & 0xff); + return NUM2CHR_internal(x); } -#define NUM2CHR(x) rb_num2char_inline(x) - +#endif #define CHR2FIX(x) INT2FIX((long)((x)&0xff)) -#define ALLOC_N(type,n) ((type*)xmalloc2((n),sizeof(type))) -#define ALLOC(type) ((type*)xmalloc(sizeof(type))) -#define ZALLOC_N(type,n) ((type*)xcalloc((n),sizeof(type))) -#define ZALLOC(type) (ZALLOC_N(type,1)) -#define REALLOC_N(var,type,n) ((var)=(type*)xrealloc2((char*)(var),(n),sizeof(type))) +#define ALLOC_N(type,n) (type*)xmalloc2((n),sizeof(type)) +#define ALLOC(type) (type*)xmalloc(sizeof(type)) +#define REALLOC_N(var,type,n) (var)=(type*)xrealloc2((char*)(var),(n),sizeof(type)) -#define ALLOCA_N(type,n) ((type*)alloca(sizeof(type)*(n))) - -void *rb_alloc_tmp_buffer(volatile VALUE *store, long len) RUBY_ATTR_ALLOC_SIZE((2)); -void rb_free_tmp_buffer(volatile VALUE *store); -/* allocates _n_ bytes temporary buffer and stores VALUE including it - * in _v_. _n_ may be evaluated twice. */ -#ifdef C_ALLOCA -# define ALLOCV(v, n) rb_alloc_tmp_buffer(&(v), (n)) -#else -# define ALLOCV(v, n) ((n) < 1024 ? (RB_GC_GUARD(v) = 0, alloca(n)) : rb_alloc_tmp_buffer(&(v), (n))) -#endif -#define ALLOCV_N(type, v, n) ((type*)ALLOCV((v), sizeof(type)*(n))) -#define ALLOCV_END(v) rb_free_tmp_buffer(&(v)) +#define ALLOCA_N(type,n) (type*)alloca(sizeof(type)*(n)) #define MEMZERO(p,type,n) memset((p), 0, sizeof(type)*(n)) #define MEMCPY(p1,p2,type,n) memcpy((p1), (p2), sizeof(type)*(n)) @@ -1389,7 +1039,6 @@ VALUE rb_define_module_under(VALUE, const char*); void rb_include_module(VALUE,VALUE); void rb_extend_object(VALUE,VALUE); -void rb_prepend_module(VALUE,VALUE); struct rb_global_variable; @@ -1414,11 +1063,11 @@ void rb_gvar_readonly_setter(VALUE val, ID id, void *data, struct rb_global_var void rb_define_variable(const char*,VALUE*); void rb_define_virtual_variable(const char*,VALUE(*)(ANYARGS),void(*)(ANYARGS)); void rb_define_hooked_variable(const char*,VALUE*,VALUE(*)(ANYARGS),void(*)(ANYARGS)); -void rb_define_readonly_variable(const char*,const VALUE*); +void rb_define_readonly_variable(const char*,VALUE*); void rb_define_const(VALUE,const char*,VALUE); void rb_define_global_const(const char*,VALUE); -#define RUBY_METHOD_FUNC(func) ((VALUE (*)(ANYARGS))(func)) +#define RUBY_METHOD_FUNC(func) ((VALUE (*)(ANYARGS))func) void rb_define_method(VALUE,const char*,VALUE(*)(ANYARGS),int); void rb_define_module_function(VALUE,const char*,VALUE(*)(ANYARGS),int); void rb_define_global_function(const char*,VALUE(*)(ANYARGS),int); @@ -1436,35 +1085,31 @@ ID rb_intern(const char*); ID rb_intern2(const char*, long); ID rb_intern_str(VALUE str); const char *rb_id2name(ID); -ID rb_check_id(volatile VALUE *); ID rb_to_id(VALUE); VALUE rb_id2str(ID); -VALUE rb_sym2str(VALUE); -VALUE rb_to_symbol(VALUE name); -VALUE rb_check_symbol(volatile VALUE *namep); #define CONST_ID_CACHE(result, str) \ { \ static ID rb_intern_id_cache; \ if (!rb_intern_id_cache) \ - rb_intern_id_cache = rb_intern2((str), (long)strlen(str)); \ + rb_intern_id_cache = rb_intern2(str, (long)strlen(str)); \ result rb_intern_id_cache; \ } #define CONST_ID(var, str) \ - do CONST_ID_CACHE((var) =, (str)) while (0) + do CONST_ID_CACHE(var =, str) while (0) #ifdef __GNUC__ /* __builtin_constant_p and statement expression is available * since gcc-2.7.2.3 at least. */ #define rb_intern(str) \ (__builtin_constant_p(str) ? \ - __extension__ (CONST_ID_CACHE((ID), (str))) : \ + __extension__ (CONST_ID_CACHE((ID), str)) : \ rb_intern(str)) #define rb_intern_const(str) \ (__builtin_constant_p(str) ? \ - __extension__ (rb_intern2((str), (long)strlen(str))) : \ + __extension__ (rb_intern2(str, (long)strlen(str))) : \ (rb_intern)(str)) #else -#define rb_intern_const(str) rb_intern2((str), (long)strlen(str)) +#define rb_intern_const(str) rb_intern2(str, (long)strlen(str)) #endif const char *rb_class2name(VALUE); @@ -1476,20 +1121,10 @@ VALUE rb_eval_string(const char*); VALUE rb_eval_string_protect(const char*, int*); VALUE rb_eval_string_wrap(const char*, int*); VALUE rb_funcall(VALUE, ID, int, ...); -VALUE rb_funcallv(VALUE, ID, int, const VALUE*); -VALUE rb_funcallv_public(VALUE, ID, int, const VALUE*); -#define rb_funcall2 rb_funcallv -#define rb_funcall3 rb_funcallv_public -VALUE rb_funcall_passing_block(VALUE, ID, int, const VALUE*); -VALUE rb_funcall_with_block(VALUE, ID, int, const VALUE*, VALUE); +VALUE rb_funcall2(VALUE, ID, int, const VALUE*); +VALUE rb_funcall3(VALUE, ID, int, const VALUE*); int rb_scan_args(int, const VALUE*, const char*, ...); VALUE rb_call_super(int, const VALUE*); -VALUE rb_current_receiver(void); -int rb_get_kwargs(VALUE keyword_hash, const ID *table, int required, int optional, VALUE *); -VALUE rb_extract_keywords(VALUE *orighash); - -/* rb_scan_args() format allows ':' for optional hash */ -#define HAVE_RB_SCAN_ARGS_OPTIONAL_HASH 1 VALUE rb_gv_set(const char*, VALUE); VALUE rb_gv_get(const char*); @@ -1508,20 +1143,10 @@ PRINTF_ARGS(NORETURN(void rb_fatal(const char*, ...)), 1, 2); PRINTF_ARGS(NORETURN(void rb_bug(const char*, ...)), 1, 2); NORETURN(void rb_bug_errno(const char*, int)); NORETURN(void rb_sys_fail(const char*)); -NORETURN(void rb_sys_fail_str(VALUE)); NORETURN(void rb_mod_sys_fail(VALUE, const char*)); -NORETURN(void rb_mod_sys_fail_str(VALUE, VALUE)); -NORETURN(void rb_readwrite_sys_fail(int, const char*)); NORETURN(void rb_iter_break(void)); -NORETURN(void rb_iter_break_value(VALUE)); NORETURN(void rb_exit(int)); NORETURN(void rb_notimplement(void)); -VALUE rb_syserr_new(int, const char *); -VALUE rb_syserr_new_str(int n, VALUE arg); -NORETURN(void rb_syserr_fail(int, const char*)); -NORETURN(void rb_syserr_fail_str(int, VALUE)); -NORETURN(void rb_mod_syserr_fail(VALUE, int, const char*)); -NORETURN(void rb_mod_syserr_fail_str(VALUE, int, VALUE)); /* reports if `-W' specified */ PRINTF_ARGS(void rb_warning(const char*, ...), 1, 2); @@ -1531,31 +1156,17 @@ PRINTF_ARGS(void rb_sys_warning(const char*, ...), 1, 2); PRINTF_ARGS(void rb_warn(const char*, ...), 1, 2); PRINTF_ARGS(void rb_compile_warn(const char *, int, const char*, ...), 3, 4); -/* for rb_readwrite_sys_fail first argument */ -#define RB_IO_WAIT_READABLE 0 -#define RB_IO_WAIT_WRITABLE 1 - -#define RUBY_BLOCK_CALL_FUNC_TAKES_BLOCKARG 1 -#define RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, callback_arg) \ - VALUE yielded_arg, VALUE callback_arg, int argc, const VALUE *argv, VALUE blockarg -typedef VALUE rb_block_call_func(RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, callback_arg)); - -#if defined RB_BLOCK_CALL_FUNC_STRICT && RB_BLOCK_CALL_FUNC_STRICT -typedef rb_block_call_func *rb_block_call_func_t; -#else -typedef VALUE (*rb_block_call_func_t)(ANYARGS); -#endif +typedef VALUE rb_block_call_func(VALUE, VALUE, int, VALUE*); VALUE rb_each(VALUE); VALUE rb_yield(VALUE); VALUE rb_yield_values(int n, ...); VALUE rb_yield_values2(int n, const VALUE *argv); VALUE rb_yield_splat(VALUE); -VALUE rb_yield_block(VALUE, VALUE, int, const VALUE *, VALUE); /* rb_block_call_func */ int rb_block_given_p(void); void rb_need_block(void); VALUE rb_iterate(VALUE(*)(VALUE),VALUE,VALUE(*)(ANYARGS),VALUE); -VALUE rb_block_call(VALUE,ID,int,const VALUE*,rb_block_call_func_t,VALUE); +VALUE rb_block_call(VALUE,ID,int,VALUE*,VALUE(*)(ANYARGS),VALUE); VALUE rb_rescue(VALUE(*)(ANYARGS),VALUE,VALUE(*)(ANYARGS),VALUE); VALUE rb_rescue2(VALUE(*)(ANYARGS),VALUE,VALUE(*)(ANYARGS),VALUE,...); VALUE rb_ensure(VALUE(*)(ANYARGS),VALUE,VALUE(*)(ANYARGS),VALUE); @@ -1566,6 +1177,20 @@ NORETURN(void rb_throw_obj(VALUE,VALUE)); VALUE rb_require(const char*); +#ifdef __ia64 +void ruby_init_stack(volatile VALUE*, void*); +#define ruby_init_stack(addr) ruby_init_stack(addr, rb_ia64_bsp()) +#else +void ruby_init_stack(volatile VALUE*); +#endif +#define RUBY_INIT_STACK \ + VALUE variable_in_this_stack_frame; \ + ruby_init_stack(&variable_in_this_stack_frame); +void ruby_init(void); +void *ruby_options(int, char**); +int ruby_run_node(void *); +int ruby_exec_node(void *); + RUBY_EXTERN VALUE rb_mKernel; RUBY_EXTERN VALUE rb_mComparable; RUBY_EXTERN VALUE rb_mEnumerable; @@ -1659,9 +1284,8 @@ rb_class_of(VALUE obj) { if (IMMEDIATE_P(obj)) { if (FIXNUM_P(obj)) return rb_cFixnum; - if (FLONUM_P(obj)) return rb_cFloat; if (obj == Qtrue) return rb_cTrueClass; - if (STATIC_SYM_P(obj)) return rb_cSymbol; + if (SYMBOL_P(obj)) return rb_cSymbol; } else if (!RTEST(obj)) { if (obj == Qnil) return rb_cNilClass; @@ -1675,21 +1299,29 @@ rb_type(VALUE obj) { if (IMMEDIATE_P(obj)) { if (FIXNUM_P(obj)) return T_FIXNUM; - if (FLONUM_P(obj)) return T_FLOAT; - if (obj == Qtrue) return T_TRUE; - if (STATIC_SYM_P(obj)) return T_SYMBOL; + if (obj == Qtrue) return T_TRUE; + if (SYMBOL_P(obj)) return T_SYMBOL; if (obj == Qundef) return T_UNDEF; } else if (!RTEST(obj)) { - if (obj == Qnil) return T_NIL; + if (obj == Qnil) return T_NIL; if (obj == Qfalse) return T_FALSE; } return BUILTIN_TYPE(obj); } +#define RB_TYPE_P(obj, type) ( \ + ((type) == T_FIXNUM) ? FIXNUM_P(obj) : \ + ((type) == T_TRUE) ? ((obj) == Qtrue) : \ + ((type) == T_FALSE) ? ((obj) == Qfalse) : \ + ((type) == T_NIL) ? ((obj) == Qnil) : \ + ((type) == T_UNDEF) ? ((obj) == Qundef) : \ + ((type) == T_SYMBOL) ? SYMBOL_P(obj) : \ + (!SPECIAL_CONST_P(obj) && BUILTIN_TYPE(obj) == (type))) + #ifdef __GNUC__ #define rb_type_p(obj, type) \ - __extension__ (__builtin_constant_p(type) ? RB_TYPE_P((obj), (type)) : \ + __extension__ (__builtin_constant_p(type) ? RB_TYPE_P(obj, type) : \ rb_type(obj) == (type)) #else #define rb_type_p(obj, type) (rb_type(obj) == (type)) @@ -1707,6 +1339,7 @@ rb_special_const_p(VALUE obj) } #endif +#include "ruby/missing.h" #include "ruby/intern.h" #if defined(EXTLIB) && defined(USE_DLN_A_OUT) @@ -1714,11 +1347,18 @@ rb_special_const_p(VALUE obj) static char *dln_libs_to_be_linked[] = { EXTLIB, 0 }; #endif +#if (defined(__APPLE__) || defined(__NeXT__)) && defined(__MACH__) +#define RUBY_GLOBAL_SETUP /* use linker option to link startup code with ObjC support */ +#else +#define RUBY_GLOBAL_SETUP +#endif + +void ruby_sysinit(int *, char ***); + #define RUBY_VM 1 /* YARV */ #define HAVE_NATIVETHREAD int ruby_native_thread_p(void); -/* traditional set_trace_func events */ #define RUBY_EVENT_NONE 0x0000 #define RUBY_EVENT_LINE 0x0001 #define RUBY_EVENT_CLASS 0x0002 @@ -1728,38 +1368,24 @@ int ruby_native_thread_p(void); #define RUBY_EVENT_C_CALL 0x0020 #define RUBY_EVENT_C_RETURN 0x0040 #define RUBY_EVENT_RAISE 0x0080 -#define RUBY_EVENT_ALL 0x00ff - -/* for TracePoint extended events */ -#define RUBY_EVENT_B_CALL 0x0100 -#define RUBY_EVENT_B_RETURN 0x0200 -#define RUBY_EVENT_THREAD_BEGIN 0x0400 -#define RUBY_EVENT_THREAD_END 0x0800 -#define RUBY_EVENT_TRACEPOINT_ALL 0xffff - -/* special events */ -#define RUBY_EVENT_SPECIFIED_LINE 0x010000 -#define RUBY_EVENT_COVERAGE 0x020000 - -/* internal events */ -#define RUBY_INTERNAL_EVENT_SWITCH 0x040000 -#define RUBY_EVENT_SWITCH 0x040000 /* obsolete name. this macro is for compatibility */ - /* 0x080000 */ -#define RUBY_INTERNAL_EVENT_NEWOBJ 0x100000 -#define RUBY_INTERNAL_EVENT_FREEOBJ 0x200000 -#define RUBY_INTERNAL_EVENT_GC_START 0x400000 -#define RUBY_INTERNAL_EVENT_GC_END_MARK 0x800000 -#define RUBY_INTERNAL_EVENT_GC_END_SWEEP 0x1000000 -#define RUBY_INTERNAL_EVENT_GC_ENTER 0x2000000 -#define RUBY_INTERNAL_EVENT_GC_EXIT 0x4000000 -#define RUBY_INTERNAL_EVENT_OBJSPACE_MASK 0x7f00000 -#define RUBY_INTERNAL_EVENT_MASK 0xfffe0000 - -typedef uint32_t rb_event_flag_t; -typedef void (*rb_event_hook_func_t)(rb_event_flag_t evflag, VALUE data, VALUE self, ID mid, VALUE klass); +#define RUBY_EVENT_ALL 0xffff +#define RUBY_EVENT_VM 0x10000 +#define RUBY_EVENT_SWITCH 0x20000 +#define RUBY_EVENT_COVERAGE 0x40000 + +typedef unsigned int rb_event_flag_t; +typedef void (*rb_event_hook_func_t)(rb_event_flag_t, VALUE data, VALUE, ID, VALUE klass); + +typedef struct rb_event_hook_struct { + rb_event_flag_t flag; + rb_event_hook_func_t func; + VALUE data; + struct rb_event_hook_struct *next; +} rb_event_hook_t; #define RB_EVENT_HOOKS_HAVE_CALLBACK_DATA 1 -void rb_add_event_hook(rb_event_hook_func_t func, rb_event_flag_t events, VALUE data); +void rb_add_event_hook(rb_event_hook_func_t func, rb_event_flag_t events, + VALUE data); int rb_remove_event_hook(rb_event_hook_func_t func); /* locale insensitive functions */ @@ -1784,7 +1410,6 @@ int rb_toupper(int c); #define ISASCII(c) rb_isascii((unsigned char)(c)) #undef ISPRINT #define ISPRINT(c) rb_isprint((unsigned char)(c)) -#define ISGRAPH(c) rb_isgraph((unsigned char)(c)) #define ISSPACE(c) rb_isspace((unsigned char)(c)) #define ISUPPER(c) rb_isupper((unsigned char)(c)) #define ISLOWER(c) rb_islower((unsigned char)(c)) @@ -1796,90 +1421,33 @@ int rb_toupper(int c); #define TOUPPER(c) rb_toupper((unsigned char)(c)) #define TOLOWER(c) rb_tolower((unsigned char)(c)) -int st_locale_insensitive_strcasecmp(const char *s1, const char *s2); -int st_locale_insensitive_strncasecmp(const char *s1, const char *s2, size_t n); -#define STRCASECMP(s1, s2) (st_locale_insensitive_strcasecmp((s1), (s2))) -#define STRNCASECMP(s1, s2, n) (st_locale_insensitive_strncasecmp((s1), (s2), (n))) +int st_strcasecmp(const char *s1, const char *s2); +int st_strncasecmp(const char *s1, const char *s2, size_t n); +#define STRCASECMP(s1, s2) (st_strcasecmp(s1, s2)) +#define STRNCASECMP(s1, s2, n) (st_strncasecmp(s1, s2, n)) unsigned long ruby_strtoul(const char *str, char **endptr, int base); -#define STRTOUL(str, endptr, base) (ruby_strtoul((str), (endptr), (base))) +#define STRTOUL(str, endptr, base) (ruby_strtoul(str, endptr, base)) #define InitVM(ext) {void InitVM_##ext(void);InitVM_##ext();} -PRINTF_ARGS(int ruby_snprintf(char *str, size_t n, char const *fmt, ...), 3, 4); +int ruby_snprintf(char *str, size_t n, char const *fmt, ...); int ruby_vsnprintf(char *str, size_t n, char const *fmt, va_list ap); - -#ifndef RUBY_DONT_SUBST -#include "ruby/subst.h" -#endif - -/** - * @defgroup embed CRuby Embedding APIs - * CRuby interpreter APIs. These are APIs to embed MRI interpreter into your - * program. - * These functions are not a part of Ruby extension library API. - * Extension libraries of Ruby should not depend on these functions. - * @{ - */ - -/** @defgroup ruby1 ruby(1) implementation - * A part of the implementation of ruby(1) command. - * Other programs that embed Ruby interpreter do not always need to use these - * functions. - * @{ - */ - -void ruby_sysinit(int *argc, char ***argv); -void ruby_init(void); -void* ruby_options(int argc, char** argv); -int ruby_executable_node(void *n, int *status); -int ruby_run_node(void *n); - -/* version.c */ -void ruby_show_version(void); -void ruby_show_copyright(void); - - -/*! A convenience macro to call ruby_init_stack(). Must be placed just after - * variable declarations */ -#define RUBY_INIT_STACK \ - VALUE variable_in_this_stack_frame; \ - ruby_init_stack(&variable_in_this_stack_frame); -/*! @} */ - -#ifdef __ia64 -void ruby_init_stack(volatile VALUE*, void*); -#define ruby_init_stack(addr) ruby_init_stack((addr), rb_ia64_bsp()) -#else -void ruby_init_stack(volatile VALUE*); +#undef snprintf +#undef vsnprintf +#define snprintf ruby_snprintf +#define vsnprintf ruby_vsnprintf + +#ifdef BROKEN_CLOSE +#undef getpeername +#define getpeername ruby_getpeername +#undef getsockname +#define getsockname ruby_getsockname +#undef shutdown +#define shutdown ruby_shutdown +#undef close +#define close ruby_close #endif -#define Init_stack(addr) ruby_init_stack(addr) - -int ruby_setup(void); -int ruby_cleanup(volatile int); - -void ruby_finalize(void); -NORETURN(void ruby_stop(int)); - -void ruby_set_stack_size(size_t); -int ruby_stack_check(void); -size_t ruby_stack_length(VALUE**); - -int ruby_exec_node(void *n); - -void ruby_script(const char* name); -void ruby_set_script_name(VALUE name); - -void ruby_prog_init(void); -void ruby_set_argv(int, char**); -void *ruby_process_options(int, char**); -void ruby_init_loadpath(void); -void ruby_incpush(const char*); -void ruby_sig_finalize(void); - -/*! @} */ - -RUBY_SYMBOL_EXPORT_END #if defined(__cplusplus) #if 0 diff --git a/include/ruby/st.h b/include/ruby/st.h index 0ef499944a..27e47b816c 100644 --- a/include/ruby/st.h +++ b/include/ruby/st.h @@ -12,16 +12,33 @@ extern "C" { #endif #endif +#ifndef RUBY_LIB_PREFIX +#include "ruby/config.h" #include "ruby/defines.h" +#ifdef RUBY_EXTCONF_H +#include RUBY_EXTCONF_H +#endif +#endif -RUBY_SYMBOL_EXPORT_BEGIN +#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 SIZEOF_LONG == SIZEOF_VOIDP typedef unsigned long st_data_t; #elif SIZEOF_LONG_LONG == SIZEOF_VOIDP typedef unsigned LONG_LONG st_data_t; #else -# error ---->> st.c requires sizeof(void*) == sizeof(long) or sizeof(LONG_LONG) to be compiled. <<---- +# error ---->> st.c requires sizeof(void*) == sizeof(long) to be compiled. <<---- #endif #define ST_DATA_T_DEFINED @@ -59,43 +76,19 @@ 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; unsigned int entries_packed : 1; #ifdef __GNUC__ - /* - * C spec says, - * A bit-field shall have a type that is a qualified or unqualified - * version of _Bool, signed int, unsigned int, or some other - * 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. - */ __extension__ #endif st_index_t num_entries : ST_INDEX_BITS - 1; - union { - struct { - struct st_table_entry **bins; - struct st_table_entry *head, *tail; - } big; - struct { - struct st_packed_entry *entries; - st_index_t real_entries; - } packed; - } as; + struct st_table_entry **bins; + struct st_table_entry *head, *tail; }; -#define st_is_member(table,key) st_lookup((table),(key),(st_data_t *)0) +#define st_is_member(table,key) st_lookup(table,key,(st_data_t *)0) enum st_retval {ST_CONTINUE, ST_STOP, ST_DELETE, ST_CHECK}; @@ -109,23 +102,12 @@ 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,10 +115,8 @@ 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_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 +int st_strcasecmp(const char *s1, const char *s2); +int st_strncasecmp(const char *s1, const char *s2, size_t n); 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); @@ -145,8 +125,6 @@ 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)) -RUBY_SYMBOL_EXPORT_END - #if defined(__cplusplus) #if 0 { /* satisfy cc-mode */ diff --git a/include/ruby/subst.h b/include/ruby/subst.h deleted file mode 100644 index 1f0e6db5a4..0000000000 --- a/include/ruby/subst.h +++ /dev/null @@ -1,19 +0,0 @@ -#ifndef RUBY_SUBST_H -#define RUBY_SUBST_H 1 - -#undef snprintf -#undef vsnprintf -#define snprintf ruby_snprintf -#define vsnprintf ruby_vsnprintf - -#ifdef BROKEN_CLOSE -#undef getpeername -#define getpeername ruby_getpeername -#undef getsockname -#define getsockname ruby_getsockname -#undef shutdown -#define shutdown ruby_shutdown -#undef close -#define close ruby_close -#endif -#endif diff --git a/include/ruby/thread.h b/include/ruby/thread.h deleted file mode 100644 index 550f678e54..0000000000 --- a/include/ruby/thread.h +++ /dev/null @@ -1,45 +0,0 @@ -/********************************************************************** - - thread.h - - - $Author: matz $ - created at: Tue Jul 10 17:35:43 JST 2012 - - Copyright (C) 2007 Yukihiro Matsumoto - -**********************************************************************/ - -#ifndef RUBY_THREAD_H -#define RUBY_THREAD_H 1 - -#if defined(__cplusplus) -extern "C" { -#if 0 -} /* satisfy cc-mode */ -#endif -#endif - -#include "ruby/intern.h" - -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 *), 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_ - -RUBY_SYMBOL_EXPORT_END - -#if defined(__cplusplus) -#if 0 -{ /* satisfy cc-mode */ -#endif -} /* extern "C" { */ -#endif - -#endif /* RUBY_THREAD_H */ diff --git a/include/ruby/thread_native.h b/include/ruby/thread_native.h deleted file mode 100644 index 8e500c5a13..0000000000 --- a/include/ruby/thread_native.h +++ /dev/null @@ -1,56 +0,0 @@ -/********************************************************************** - - 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 74cdd0ffd1..0c1e1c4ebc 100644 --- a/include/ruby/util.h +++ b/include/ruby/util.h @@ -19,11 +19,6 @@ extern "C" { #endif #endif -#include "ruby/defines.h" -#ifdef RUBY_EXTCONF_H -#include RUBY_EXTCONF_H -#endif - #ifndef _ #ifdef __cplusplus # ifndef HAVE_PROTOTYPES @@ -45,29 +40,24 @@ extern "C" { #endif #endif -RUBY_SYMBOL_EXPORT_BEGIN - -#define DECIMAL_SIZE_OF_BITS(n) (((n) * 3010 + 9998) / 9999) -/* an approximation of ceil(n * log10(2)), upto 65536 at least */ - -#define scan_oct(s,l,e) ((int)ruby_scan_oct((s),(l),(e))) +#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))) +#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 +#if defined(__CYGWIN32__) || defined(_WIN32) +void ruby_add_suffix(VALUE str, const char *suffix); +#endif + 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 setenv(name,val) ruby_setenv(name,val) +#define unsetenv(name,val) ruby_unsetenv(name); char *ruby_strdup(const char *); #undef strdup @@ -78,7 +68,7 @@ char *ruby_getcwd(void); double ruby_strtod(const char *, char **); #undef strtod -#define strtod(s,e) ruby_strtod((s),(e)) +#define strtod(s,e) ruby_strtod(s,e) #if defined _MSC_VER && _MSC_VER >= 1300 #pragma warning(push) @@ -90,8 +80,6 @@ double ruby_strtod(const char *, char **); void ruby_each_words(const char *, void (*)(const char*, int, void*), void *); -RUBY_SYMBOL_EXPORT_END - #if defined(__cplusplus) #if 0 { /* satisfy cc-mode */ diff --git a/include/ruby/version.h b/include/ruby/version.h index 1e3ff2e6a3..32b09b3f52 100644 --- a/include/ruby/version.h +++ b/include/ruby/version.h @@ -29,12 +29,6 @@ #define RUBY_BIRTH_MONTH 2 #define RUBY_BIRTH_DAY 24 -/* API version */ -#define RUBY_API_VERSION_MAJOR 2 -#define RUBY_API_VERSION_MINOR 2 -#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) - #ifdef RUBY_EXTERN #if defined(__cplusplus) extern "C" { @@ -42,9 +36,6 @@ extern "C" { } /* satisfy cc-mode */ #endif #endif - -RUBY_SYMBOL_EXPORT_BEGIN - /* * Interfaces from extension libraries. * @@ -52,7 +43,6 @@ RUBY_SYMBOL_EXPORT_BEGIN * necessary or not, and if the answer was yes, think twice a week * later again. */ -RUBY_EXTERN const int ruby_api_version[3]; RUBY_EXTERN const char ruby_version[]; RUBY_EXTERN const char ruby_release_date[]; RUBY_EXTERN const char ruby_platform[]; @@ -60,9 +50,6 @@ RUBY_EXTERN const int ruby_patchlevel; RUBY_EXTERN const char ruby_description[]; RUBY_EXTERN const char ruby_copyright[]; RUBY_EXTERN const char ruby_engine[]; - -RUBY_SYMBOL_EXPORT_END - #if defined(__cplusplus) #if 0 { /* satisfy cc-mode */ diff --git a/include/ruby/vm.h b/include/ruby/vm.h index 73345264bd..ac8e599e90 100644 --- a/include/ruby/vm.h +++ b/include/ruby/vm.h @@ -19,8 +19,6 @@ extern "C" { #endif #endif -RUBY_SYMBOL_EXPORT_BEGIN - /* Place holder. * * We will prepare VM creation/control APIs on 1.9.2 or later. @@ -34,26 +32,6 @@ typedef struct rb_vm_struct ruby_vm_t; /* core API */ int ruby_vm_destruct(ruby_vm_t *vm); -/** - * ruby_vm_at_exit registers a function _func_ to be invoked when a VM - * passed away. Functions registered this way runs in reverse order - * of registration, just like END {} block does. The difference is - * its timing to be triggered. ruby_vm_at_exit functions runs when a - * VM _passed_ _away_, while END {} blocks runs just _before_ a VM - * _is_ _passing_ _away_. - * - * You cannot register a function to another VM than where you are in. - * So where to register is intuitive, omitted. OTOH the argument - * _func_ cannot know which VM it is in because at the time of - * invocation, the VM has already died and there is no execution - * context. The VM itself is passed as the first argument to it. - * - * @param[in] func the function to register. - */ -void ruby_vm_at_exit(void(*func)(ruby_vm_t *)); - -RUBY_SYMBOL_EXPORT_END - #if defined(__cplusplus) #if 0 { /* satisfy cc-mode */ diff --git a/include/ruby/win32.h b/include/ruby/win32.h index 4b938626af..79eb6a19df 100644 --- a/include/ruby/win32.h +++ b/include/ruby/win32.h @@ -8,8 +8,6 @@ extern "C" { #endif #endif -RUBY_SYMBOL_EXPORT_BEGIN - /* * Copyright (c) 1993, Intergraph Corporation * @@ -18,37 +16,33 @@ RUBY_SYMBOL_EXPORT_BEGIN * */ -/* - * Definitions for NT port of Perl - */ +// +// Definitions for NT port of Perl +// -/* - * Ok now we can include the normal include files. - */ +// +// Ok now we can include the normal include files. +// -/* #include <stdarg.h> conflict with varargs.h? */ +// #include <stdarg.h> conflict with varargs.h? #if !defined(WSAAPI) #if defined(__cplusplus) && defined(_MSC_VER) extern "C++" { /* template without extern "C++" */ #endif -#if !defined(_WIN64) && !defined(WIN32) -#define WIN32 -#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 #endif -/* - * We're not using Microsoft's "extensions" to C for - * Structured Exception Handling (SEH) so we can nuke these - */ +#define NT 1 /* deprecated */ + +// +// We're not using Microsoft's "extensions" to C for +// Structured Exception Handling (SEH) so we can nuke these +// #undef try #undef except #undef finally @@ -88,14 +82,6 @@ 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; @@ -104,13 +90,6 @@ 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 @@ -119,15 +98,17 @@ typedef unsigned int uintptr_t; # include <unistd.h> #endif +#ifdef WIN95 +extern DWORD rb_w32_osid(void); +#define rb_w32_iswinnt() (rb_w32_osid() == VER_PLATFORM_WIN32_NT) +#define rb_w32_iswin95() (rb_w32_osid() == VER_PLATFORM_WIN32_WINDOWS) +#else #define rb_w32_iswinnt() TRUE #define rb_w32_iswin95() FALSE +#endif #define WNOHANG -1 -typedef int clockid_t; -#define CLOCK_REALTIME 0 -#define CLOCK_MONOTONIC 1 - #undef getc #undef putc #undef fgetc @@ -138,7 +119,6 @@ typedef int clockid_t; #undef fputchar #undef utime #undef lseek -#undef stat #undef fstat #define getc(_stream) rb_w32_getc(_stream) #define getchar() rb_w32_getc(stdin) @@ -162,7 +142,6 @@ typedef int clockid_t; #define getppid() rb_w32_getppid() #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() @@ -171,6 +150,7 @@ typedef int clockid_t; #define tell(h) _tell(h) #define _open _sopen #define sopen _sopen +#define _fstati64(fd,st) rb_w32_fstati64(fd,st) #undef fopen #define fopen(p, m) rb_w32_fopen(p, m) #undef fdopen @@ -197,17 +177,16 @@ typedef int clockid_t; #if SIZEOF_OFF_T == 8 #define off_t __int64 #define stat stati64 -#define fstat(fd,st) fstati64(fd,st) +#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 stati64 _stati64 -#ifndef _stati64 #define _stati64(path, st) rb_w32_stati64(path, st) -#endif #else #define stati64 _stat64 #define _stat64(path, st) rb_w32_stati64(path, st) +#define _fstati64 _fstat64 #endif #else #define stat(path,st) rb_w32_stat(path,st) @@ -242,30 +221,11 @@ 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); +#define NtInitialize ruby_sysinit +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); +extern int rb_w32_has_cancel_io(void); extern int rb_w32_is_socket(int); extern int WSAAPI rb_w32_accept(int, struct sockaddr *, int *); extern int WSAAPI rb_w32_bind(int, const struct sockaddr *, int); @@ -296,38 +256,25 @@ 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 socketpair(int, int, int, int *); -extern int getifaddrs(struct ifaddrs **); -extern void freeifaddrs(struct ifaddrs *); +extern int rb_w32_socketpair(int, int, int, int *); extern char * rb_w32_getcwd(char *, int); -extern char * rb_w32_ugetenv(const char *); extern char * rb_w32_getenv(const char *); extern int rb_w32_rename(const char *, const char *); extern int rb_w32_urename(const char *, const char *); 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 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__) @@ -345,11 +292,9 @@ extern int rb_w32_stati64(const char *, struct stati64 *); extern int rb_w32_ustati64(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); #ifdef __BORLANDC__ +extern int rb_w32_fstati64(int, struct stati64 *); 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 *); @@ -357,20 +302,6 @@ extern FILE *rb_w32_fsopen(const char *, const char *, int); #endif #include <float.h> - -#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 - #if !defined __MINGW32__ || defined __NO_ISOCEXT #ifndef isnan #define isnan(x) _isnan(x) @@ -388,8 +319,6 @@ scalb(double a, long b) { return _scalb(a, b); } -#else -__declspec(dllimport) extern int finite(double); #endif #if !defined S_IFIFO && defined _S_IFIFO @@ -439,14 +368,16 @@ __declspec(dllimport) extern int finite(double); #define S_IXOTH 0001 #endif -/* - * define this so we can do inplace editing - */ +// +// 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); #undef HAVE_FTRUNCATE #define HAVE_FTRUNCATE 1 @@ -464,14 +395,25 @@ extern int rb_w32_truncate(const char *path, off_t length); #define truncate rb_w32_truncate #endif -#if defined(_MSC_VER) && _MSC_VER >= 1400 && _MSC_VER < 1800 -#define strtoll _strtoi64 -#define strtoull _strtoui64 +#undef HAVE_FSEEKO +#define HAVE_FSEEKO 1 +#if defined HAVE_FSEEKO64 +#define fseeko fseeko64 +#else +#define fseeko rb_w32_fseeko #endif -/* - * stubs - */ +#undef HAVE_FTELLO +#define HAVE_FTELLO 1 +#if defined HAVE_FTELLO64 +#define ftello ftello64 +#else +#define ftello rb_w32_ftello +#endif + +// +// stubs +// extern int ioctl (int, int, ...); extern rb_uid_t getuid (void); extern rb_uid_t geteuid (void); @@ -480,8 +422,6 @@ 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 @@ -618,35 +558,11 @@ extern char *rb_w32_strerror(int); # define EREMOTE WSAEREMOTE #endif -#define F_DUPFD 0 -#if 0 -#define F_GETFD 1 -#define F_SETFD 2 -#define F_GETFL 3 -#endif -#define F_SETFL 4 -#if 0 -#define FD_CLOEXEC 1 /* F_GETFD, F_SETFD */ -#endif +#define F_SETFL 1 #define O_NONBLOCK 1 #undef FD_SET -#define FD_SET(fd, set) do {\ - unsigned int i;\ - SOCKET s = _get_osfhandle(fd);\ -\ - for (i = 0; i < (set)->fd_count; i++) {\ - if ((set)->fd_array[i] == s) {\ - break;\ - }\ - }\ - if (i == (set)->fd_count) {\ - if ((set)->fd_count < FD_SETSIZE) {\ - (set)->fd_array[i] = s;\ - (set)->fd_count++;\ - }\ - }\ -} while(0) +#define FD_SET(f, s) rb_w32_fdset(f, s) #undef FD_CLR #define FD_CLR(f, s) rb_w32_fdclr(f, s) @@ -655,12 +571,6 @@ extern char *rb_w32_strerror(int); #define FD_ISSET(f, s) rb_w32_fdisset(f, s) #ifdef RUBY_EXPORT -#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) @@ -730,6 +640,9 @@ 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) @@ -744,9 +657,6 @@ 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 { @@ -758,10 +668,8 @@ struct tms { int rb_w32_times(struct tms *); -struct tm *gmtime_r(const time_t *, struct tm *); -struct tm *localtime_r(const time_t *, struct tm *); - /* thread stuff */ +HANDLE GetCurrentThreadHandle(void); int rb_w32_sleep(unsigned long msec); int rb_w32_putc(int, FILE*); int rb_w32_getc(FILE*); @@ -771,46 +679,35 @@ int rb_w32_wopen(const WCHAR *, int, ...); int rb_w32_close(int); int rb_w32_fclose(FILE*); int rb_w32_pipe(int[2]); -ssize_t rb_w32_read(int, void *, size_t); -ssize_t rb_w32_write(int, const void *, size_t); +size_t rb_w32_read(int, void *, size_t); +size_t rb_w32_write(int, const void *, size_t); int rb_w32_utime(const char *, const struct utimbuf *); int rb_w32_uutime(const char *, const struct utimbuf *); -long rb_w32_write_console(uintptr_t, int); /* use uintptr_t instead of VALUE because it's not defined yet here */ +long rb_w32_write_console(unsigned long, int); int WINAPI rb_w32_Sleep(unsigned long msec); 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 rb_thread_call_without_gvl, +* use anything like TRAP_BEG...TRAP_END block structure, 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); -RUBY_SYMBOL_EXPORT_END - #ifdef __MINGW_ATTRIB_PURE -/* License: Ruby's */ /* get rid of bugs in math.h of mingw */ #define frexp(_X, _Y) __extension__ ({\ - int intpart_frexp_bug = intpart_frexp_bug;\ - double result_frexp_bug = frexp((_X), &intpart_frexp_bug);\ - *(_Y) = intpart_frexp_bug;\ - result_frexp_bug;\ + int *intptr_frexp_bug = (_Y);\ + *intptr_frexp_bug = *intptr_frexp_bug;\ + frexp((_X), intptr_frexp_bug);\ }) -/* License: Ruby's */ #define modf(_X, _Y) __extension__ ({\ - double intpart_modf_bug = intpart_modf_bug;\ - double result_modf_bug = modf((_X), &intpart_modf_bug);\ - *(_Y) = intpart_modf_bug;\ - result_modf_bug;\ + double *intptr_modf_bug = (_Y);\ + *intptr_modf_bug = *intptr_modf_bug;\ + modf((_X), intptr_modf_bug);\ }) #endif @@ -821,22 +718,4 @@ RUBY_SYMBOL_EXPORT_END } /* extern "C" { */ #endif -#if defined(__MINGW64__) -/* - * Use powl() instead of broken pow() of x86_64-w64-mingw32. - * This workaround will fix test failures in test_bignum.rb, - * test_fixnum.rb and test_float.rb etc. - */ -static inline double -rb_w32_pow(double x, double y) -{ - return powl(x, y); -} -#elif defined(__MINGW64_VERSION_MAJOR) -double rb_w32_pow(double x, double y); -#endif -#if defined(__MINGW64_VERSION_MAJOR) || defined(__MINGW64__) -#define pow rb_w32_pow -#endif - #endif /* RUBY_WIN32_H */ |