diff options
Diffstat (limited to 'include/ruby')
| -rw-r--r-- | include/ruby/assert.h | 54 | ||||
| -rw-r--r-- | include/ruby/backward.h | 21 | ||||
| -rw-r--r-- | include/ruby/backward/cxxanyargs.hpp | 439 | ||||
| -rw-r--r-- | include/ruby/debug.h | 6 | ||||
| -rw-r--r-- | include/ruby/defines.h | 183 | ||||
| -rw-r--r-- | include/ruby/encoding.h | 6 | ||||
| -rw-r--r-- | include/ruby/intern.h | 328 | ||||
| -rw-r--r-- | include/ruby/io.h | 10 | ||||
| -rw-r--r-- | include/ruby/missing.h | 12 | ||||
| -rw-r--r-- | include/ruby/onigmo.h | 8 | ||||
| -rw-r--r-- | include/ruby/re.h | 3 | ||||
| -rw-r--r-- | include/ruby/ruby.h | 610 | ||||
| -rw-r--r-- | include/ruby/st.h | 128 | ||||
| -rw-r--r-- | include/ruby/thread.h | 12 | ||||
| -rw-r--r-- | include/ruby/version.h | 2 | ||||
| -rw-r--r-- | include/ruby/vm.h | 3 | ||||
| -rw-r--r-- | include/ruby/win32.h | 3 |
17 files changed, 254 insertions, 1574 deletions
diff --git a/include/ruby/assert.h b/include/ruby/assert.h deleted file mode 100644 index d19d8e4e32..0000000000 --- a/include/ruby/assert.h +++ /dev/null @@ -1,54 +0,0 @@ -#ifndef RUBY_ASSERT_H -#define RUBY_ASSERT_H - -#if defined(__cplusplus) -extern "C" { -#if 0 -} /* satisfy cc-mode */ -#endif -#endif - -NORETURN(void rb_assert_failure(const char *, int, const char *, const char *)); -#ifdef RUBY_FUNCTION_NAME_STRING -# define RUBY_ASSERT_FAIL(expr) \ - rb_assert_failure(__FILE__, __LINE__, RUBY_FUNCTION_NAME_STRING, expr) -#else -# define RUBY_ASSERT_FAIL(expr) \ - rb_assert_failure(__FILE__, __LINE__, NULL, expr) -#endif -#define RUBY_ASSERT_MESG(expr, mesg) \ - ((expr) ? (void)0 : RUBY_ASSERT_FAIL(mesg)) -#ifdef HAVE_BUILTIN___BUILTIN_CHOOSE_EXPR_CONSTANT_P -# define RUBY_ASSERT_MESG_WHEN(cond, expr, mesg) \ - ((RUBY_DEBUG+0) ? RUBY_ASSERT_MESG((expr), mesg) : \ - __builtin_choose_expr( \ - __builtin_constant_p(cond), \ - __builtin_choose_expr(cond, RUBY_ASSERT_MESG(expr, mesg), (void)0), \ - RUBY_ASSERT_MESG(!(cond) || (expr), mesg))) -#else -# define RUBY_ASSERT_MESG_WHEN(cond, expr, mesg) \ - RUBY_ASSERT_MESG(!((RUBY_DEBUG+0) || (cond)) || (expr), mesg) -#endif -#define RUBY_ASSERT(expr) RUBY_ASSERT_MESG_WHEN((!RUBY_NDEBUG+0), expr, #expr) -#define RUBY_ASSERT_WHEN(cond, expr) RUBY_ASSERT_MESG_WHEN(cond, expr, #expr) -#define RUBY_ASSERT_ALWAYS(expr) RUBY_ASSERT_MESG_WHEN(TRUE, expr, #expr) - -#ifndef RUBY_DEBUG -# define RUBY_DEBUG 0 -#endif -#ifndef RUBY_NDEBUG -# ifdef NDEBUG -# define RUBY_NDEBUG 1 -# else -# define RUBY_NDEBUG 0 -# endif -#endif - -#if defined(__cplusplus) -#if 0 -{ /* satisfy cc-mode */ -#endif -} /* extern "C" { */ -#endif - -#endif diff --git a/include/ruby/backward.h b/include/ruby/backward.h index 863edf0ed5..76bd162cb2 100644 --- a/include/ruby/backward.h +++ b/include/ruby/backward.h @@ -12,6 +12,10 @@ struct RClass { #define DECLARE_DEPRECATED_FEATURE(ver, func) \ NORETURN(ERRORFUNC(("deprecated since "#ver), DEPRECATED(void func(void)))) +/* complex.c */ +DECLARE_DEPRECATED_FEATURE(2.2, rb_complex_set_real); +DECLARE_DEPRECATED_FEATURE(2.2, rb_complex_set_imag); + /* eval.c */ DECLARE_DEPRECATED_FEATURE(2.2, rb_disable_super); DECLARE_DEPRECATED_FEATURE(2.2, rb_enable_super); @@ -34,30 +38,19 @@ DECLARE_DEPRECATED_FEATURE(2.2, rb_frame_pop); #define DECLARE_DEPRECATED_INTERNAL_FEATURE(func) \ NORETURN(ERRORFUNC(("deprecated internal function"), DEPRECATED(void func(void)))) -/* eval.c */ -NORETURN(ERRORFUNC(("internal function"), void rb_frozen_class_p(VALUE))); -DECLARE_DEPRECATED_INTERNAL_FEATURE(rb_exec_end_proc); - /* error.c */ DECLARE_DEPRECATED_INTERNAL_FEATURE(rb_compile_error); DECLARE_DEPRECATED_INTERNAL_FEATURE(rb_compile_error_with_enc); DECLARE_DEPRECATED_INTERNAL_FEATURE(rb_compile_error_append); -/* gc.c */ -DECLARE_DEPRECATED_INTERNAL_FEATURE(rb_gc_call_finalizer_at_exit); - -/* signal.c */ -DECLARE_DEPRECATED_INTERNAL_FEATURE(rb_trap_exit); - /* struct.c */ DECLARE_DEPRECATED_INTERNAL_FEATURE(rb_struct_ptr); -/* thread.c */ -DECLARE_DEPRECATED_INTERNAL_FEATURE(rb_clear_trace_func); - /* variable.c */ DECLARE_DEPRECATED_INTERNAL_FEATURE(rb_generic_ivar_table); -NORETURN(ERRORFUNC(("internal function"), VALUE rb_mod_const_missing(VALUE, VALUE))); + +/* vm.c */ +DEPRECATED(int rb_frame_method_id_and_class(ID *idp, VALUE *klassp)); /* from version.c */ #ifndef RUBY_SHOW_COPYRIGHT_TO_DIE diff --git a/include/ruby/backward/cxxanyargs.hpp b/include/ruby/backward/cxxanyargs.hpp deleted file mode 100644 index 3585f678b8..0000000000 --- a/include/ruby/backward/cxxanyargs.hpp +++ /dev/null @@ -1,439 +0,0 @@ -#ifndef RUBY_BACKWARD_CXXANYARGS_HPP // -*- C++ -*- -#define RUBY_BACKWARD_CXXANYARGS_HPP -/// @file -/// @brief Provides old prototypes for C++ programs. -/// @author \@shyouhei -/// @copyright This file is a part of the programming language Ruby. -/// Permission is hereby granted, to either redistribute and/or -/// modify this file, provided that the conditions mentioned in the -/// file COPYING are met. Consult the file for details. -/// @note DO NOT MODERNIZE THIS FILE! As the file name implies it is -/// meant to be a backwards compatibility shim. Please stick to -/// C++ 98 and never use newer features, like `constexpr`. - -/// @brief The main namespace. -/// @note The name "ruby" might already be taken, but that must not be a -/// problem because namespaces are allowed to reopen. -namespace ruby { - -/// @brief Backwards compatibility layer. -namespace backward { - -/// @brief Provides ANYARGS deprecation warnings. -/// -/// In C, ANYARGS means there is no function prototype. Literally anything, -/// even including nothing, can be a valid ANYARGS. So passing a correctly -/// prototyped function pointer to an ANYARGS-ed function parameter is valid, -/// at the same time passing an ANYARGS-ed function pointer to a granular typed -/// function parameter is also valid. However on the other hand in C++, -/// ANYARGS doesn't actually mean any number of arguments. C++'s ANYARGS means -/// _variadic_ number of arguments. This is incompatible with ordinal, correct -/// function prototypes. -/// -/// Luckily, function prototypes being distinct each other means they can be -/// overloaded. We can provide a compatibility layer for older Ruby APIs which -/// used to have ANYARGS. This namespace includes such attempts. -namespace cxxanyargs { - -/// @brief ANYARGS-ed function type. -typedef VALUE type(ANYARGS); - -/// @brief ANYARGS-ed function type, void variant. -typedef void void_type(ANYARGS); - -/// @brief ANYARGS-ed function type, int variant. -typedef int int_type(ANYARGS); - -/// @name Hooking global variables -/// @{ - -RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated") -/// @brief Define a function-backended global variable. -/// @param[in] q Name of the variable. -/// @param[in] w Getter function. -/// @param[in] e Setter function. -/// @note Both functions can be nullptr. -/// @see rb_define_hooked_variable() -/// @deprecated Use glanular typed overload instead. -inline void -rb_define_virtual_variable(const char *q, type *w, void_type *e) -{ - rb_gvar_getter_t *r = reinterpret_cast<rb_gvar_getter_t*>(w); - rb_gvar_setter_t *t = reinterpret_cast<rb_gvar_setter_t*>(e); - ::rb_define_virtual_variable(q, r, t); -} - -RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated") -/// @brief Define a function-backended global variable. -/// @param[in] q Name of the variable. -/// @param[in] w Getter function. -/// @param[in] e Setter function. -/// @note Both functions can be nullptr. -/// @see rb_define_hooked_variable() -/// @deprecated Use glanular typed overload instead. -inline void -rb_define_virtual_variable(const char *q, rb_gvar_getter_t *w, void_type *e) -{ - rb_gvar_setter_t *t = reinterpret_cast<rb_gvar_setter_t*>(e); - ::rb_define_virtual_variable(q, w, t); -} - -RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated") -/// @brief Define a function-backended global variable. -/// @param[in] q Name of the variable. -/// @param[in] w Getter function. -/// @param[in] e Setter function. -/// @note Both functions can be nullptr. -/// @see rb_define_hooked_variable() -/// @deprecated Use glanular typed overload instead. -inline void -rb_define_virtual_variable(const char *q, type *w, rb_gvar_setter_t *e) -{ - rb_gvar_getter_t *r = reinterpret_cast<rb_gvar_getter_t*>(w); - ::rb_define_virtual_variable(q, r, e); -} - -RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated") -/// @brief Define a function-backended global variable. -/// @param[in] q Name of the variable. -/// @param[in] w Variable storage. -/// @param[in] e Getter function. -/// @param[in] r Setter function. -/// @note Both functions can be nullptr. -/// @see rb_define_virtual_variable() -/// @deprecated Use glanular typed overload instead. -inline void -rb_define_hooked_variable(const char *q, VALUE *w, type *e, void_type *r) -{ - rb_gvar_getter_t *t = reinterpret_cast<rb_gvar_getter_t*>(e); - rb_gvar_setter_t *y = reinterpret_cast<rb_gvar_setter_t*>(r); - ::rb_define_hooked_variable(q, w, t, y); -} - -RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated") -/// @brief Define a function-backended global variable. -/// @param[in] q Name of the variable. -/// @param[in] w Variable storage. -/// @param[in] e Getter function. -/// @param[in] r Setter function. -/// @note Both functions can be nullptr. -/// @see rb_define_virtual_variable() -/// @deprecated Use glanular typed overload instead. -inline void -rb_define_hooked_variable(const char *q, VALUE *w, rb_gvar_getter_t *e, void_type *r) -{ - rb_gvar_setter_t *y = reinterpret_cast<rb_gvar_setter_t*>(r); - ::rb_define_hooked_variable(q, w, e, y); -} - -RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated") -/// @brief Define a function-backended global variable. -/// @param[in] q Name of the variable. -/// @param[in] w Variable storage. -/// @param[in] e Getter function. -/// @param[in] r Setter function. -/// @note Both functions can be nullptr. -/// @see rb_define_virtual_variable() -/// @deprecated Use glanular typed overload instead. -inline void -rb_define_hooked_variable(const char *q, VALUE *w, type *e, rb_gvar_setter_t *r) -{ - rb_gvar_getter_t *t = reinterpret_cast<rb_gvar_getter_t*>(e); - ::rb_define_hooked_variable(q, w, t, r); -} - -/// @} -/// @name Exceptions and tag jumps -/// @{ - -RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated") -/// @brief Old way to implement iterators. -/// @param[in] q A function that can yield. -/// @param[in] w Passed to `q`. -/// @param[in] e What is to be yielded. -/// @param[in] r Passed to `e`. -/// @return The return value of `q`. -/// @note `e` can be nullptr. -/// @deprecated This function is obsolated since long before 2.x era. Do not -/// use it any longer. rb_block_call() is provided instead. -inline VALUE -rb_iterate(VALUE(*q)(VALUE), VALUE w, type *e, VALUE r) -{ - rb_block_call_func_t t = reinterpret_cast<rb_block_call_func_t>(e); - return ::rb_iterate(q, w, t, r); -} - -RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated") -/// @brief Call a method with a block. -/// @param[in] q The self. -/// @param[in] w The method. -/// @param[in] e The # of elems of `r` -/// @param[in] r The arguments. -/// @param[in] t What is to be yielded. -/// @param[in] y Passed to `t` -/// @return Return value of `q#w(*r,&t)` -/// @note 't' can be nullptr. -/// @deprecated Use glanular typed overload instead. -inline VALUE -rb_block_call(VALUE q, ID w, int e, const VALUE *r, type *t, VALUE y) -{ - rb_block_call_func_t u = reinterpret_cast<rb_block_call_func_t>(t); - return ::rb_block_call(q, w, e, r, u, y); -} - -RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated") -/// @brief An equivalent of `rescue` clause. -/// @param[in] q A function that can raise. -/// @param[in] w Passed to `q`. -/// @param[in] e A function that cleans-up. -/// @param[in] r Passed to `e`. -/// @return The return value of `q` if no exception occurs, or the return -/// value of `e` if otherwise. -/// @note `e` can be nullptr. -/// @see rb_ensure() -/// @see rb_rescue2() -/// @see rb_protect() -/// @deprecated Use glanular typed overload instead. -inline VALUE -rb_rescue(type *q, VALUE w, type *e, VALUE r) -{ - typedef VALUE func1_t(VALUE); - typedef VALUE func2_t(VALUE, VALUE); - func1_t *t = reinterpret_cast<func1_t*>(q); - func2_t *y = reinterpret_cast<func2_t*>(e); - return ::rb_rescue(t, w, y, r); -} - -RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated") -/// @brief An equivalent of `rescue` clause. -/// @param[in] q A function that can raise. -/// @param[in] w Passed to `q`. -/// @param[in] e A function that cleans-up. -/// @param[in] r Passed to `e`. -/// @param[in] ... 0-terminated list of subclass of @ref rb_eException. -/// @return The return value of `q` if no exception occurs, or the return -/// value of `e` if otherwise. -/// @note `e` can be nullptr. -/// @see rb_ensure() -/// @see rb_rescue() -/// @see rb_protect() -/// @deprecated Use glanular typed overload instead. -inline VALUE -rb_rescue2(type *q, VALUE w, type *e, VALUE r, ...) -{ - typedef VALUE func1_t(VALUE); - typedef VALUE func2_t(VALUE, VALUE); - func1_t *t = reinterpret_cast<func1_t*>(q); - func2_t *y = reinterpret_cast<func2_t*>(e); - va_list ap; - va_start(ap, r); - VALUE ret = ::rb_vrescue2(t, w, y, r, ap); - va_end(ap); - return ret; -} - -RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated") -/// @brief An equivalent of `ensure` clause. -/// @param[in] q A function that can raise. -/// @param[in] w Passed to `q`. -/// @param[in] e A function that ensures. -/// @param[in] r Passed to `e`. -/// @return The return value of `q`. -/// @note It makes no sense to pass nullptr to `e`. -/// @see rb_rescue() -/// @see rb_rescue2() -/// @see rb_protect() -/// @deprecated Use glanular typed overload instead. -inline VALUE -rb_ensure(type *q, VALUE w, type *e, VALUE r) -{ - typedef VALUE func1_t(VALUE); - func1_t *t = reinterpret_cast<func1_t*>(q); - func1_t *y = reinterpret_cast<func1_t*>(e); - return ::rb_ensure(t, w, y, r); -} - -RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated") -/// @brief An equivalent of `Kernel#catch`. -/// @param[in] q The "tag" string. -/// @param[in] w A function that can throw. -/// @param[in] e Passed to `w`. -/// @return What was thrown. -/// @note `q` can be a nullptr but makes no sense to pass nullptr to`w`. -/// @see rb_block_call() -/// @see rb_protect() -/// @see rb_rb_catch_obj() -/// @see rb_rescue() -/// @deprecated Use glanular typed overload instead. -inline VALUE -rb_catch(const char *q, type *w, VALUE e) -{ - rb_block_call_func_t r = reinterpret_cast<rb_block_call_func_t>(w); - return ::rb_catch(q, r, e); -} - -RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated") -/// @brief An equivalent of `Kernel#catch`. -/// @param[in] q The "tag" object. -/// @param[in] w A function that can throw. -/// @param[in] e Passed to `w`. -/// @return What was thrown. -/// @note It makes no sense to pass nullptr to`w`. -/// @see rb_block_call() -/// @see rb_protect() -/// @see rb_rb_catch_obj() -/// @see rb_rescue() -/// @deprecated Use glanular typed overload instead. -inline VALUE -rb_catch_obj(VALUE q, type *w, VALUE e) -{ - rb_block_call_func_t r = reinterpret_cast<rb_block_call_func_t>(w); - return ::rb_catch_obj(q, r, e); -} - -/// @} -/// @name Procs, Fibers and Threads -/// @{ - -RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated") -/// @brief Creates a @ref rb_cFiber instance. -/// @param[in] q The fiber body. -/// @param[in] w Passed to `q`. -/// @return What was allocated. -/// @note It makes no sense to pass nullptr to`q`. -/// @see rb_proc_new() -/// @see rb_thread_creatr() -/// @deprecated Use glanular typed overload instead. -inline VALUE -rb_fiber_new(type *q, VALUE w) -{ - rb_block_call_func_t e = reinterpret_cast<rb_block_call_func_t>(q); - return ::rb_fiber_new(e, w); -} - -RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated") -/// @brief Creates a @ref rb_cProc instance. -/// @param[in] q The proc body. -/// @param[in] w Passed to `q`. -/// @return What was allocated. -/// @note It makes no sense to pass nullptr to`q`. -/// @see rb_fiber_new() -/// @see rb_thread_creatr() -/// @deprecated Use glanular typed overload instead. -inline VALUE -rb_proc_new(type *q, VALUE w) -{ - rb_block_call_func_t e = reinterpret_cast<rb_block_call_func_t>(q); - return ::rb_proc_new(e, w); -} - -RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated") -/// @brief Creates a @ref rb_cThread instance. -/// @param[in] q The thread body. -/// @param[in] w Passed to `q`. -/// @return What was allocated. -/// @note It makes no sense to pass nullptr to`q`. -/// @see rb_proc_new() -/// @see rb_fiber_new() -/// @deprecated Use glanular typed overload instead. -inline VALUE -rb_thread_create(type *q, void *w) -{ - typedef VALUE ptr_t(void*); - ptr_t *e = reinterpret_cast<ptr_t*>(q); - return ::rb_thread_create(e, w); -} - -/// @} -/// @name Hash and st_table -/// @{ - -RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated") -/// @brief Iteration over the given table. -/// @param[in] q A table to scan. -/// @param[in] w A function to iterate. -/// @param[in] e Passed to `w`. -/// @retval 0 Always returns 0. -/// @note It makes no sense to pass nullptr to`w`. -/// @see st_foreach_check() -/// @see rb_hash_foreach() -/// @deprecated Use glanular typed overload instead. -inline int -st_foreach(st_table *q, int_type *w, st_data_t e) -{ - st_foreach_callback_func *r = - reinterpret_cast<st_foreach_callback_func*>(w); - return ::st_foreach(q, r, e); -} - -RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated") -/// @brief Iteration over the given table. -/// @param[in] q A table to scan. -/// @param[in] w A function to iterate. -/// @param[in] e Passed to `w`. -/// @retval 0 Successful end of iteration. -/// @retval 1 Element removed during traversing. -/// @note It makes no sense to pass nullptr to`w`. -/// @see st_foreach() -/// @deprecated Use glanular typed overload instead. -inline int -st_foreach_check(st_table *q, int_type *w, st_data_t e, st_data_t) -{ - st_foreach_check_callback_func *t = - reinterpret_cast<st_foreach_check_callback_func*>(w); - return ::st_foreach_check(q, t, e, 0); -} - -RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated") -/// @brief Iteration over the given table. -/// @param[in] q A table to scan. -/// @param[in] w A function to iterate. -/// @param[in] e Passed to `w`. -/// @note It makes no sense to pass nullptr to`w`. -/// @see st_foreach_check() -/// @deprecated Use glanular typed overload instead. -inline void -st_foreach_safe(st_table *q, int_type *w, st_data_t e) -{ - st_foreach_callback_func *r = - reinterpret_cast<st_foreach_callback_func*>(w); - ::st_foreach_safe(q, r, e); -} - -RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated") -/// @brief Iteration over the given hash. -/// @param[in] q A hash to scan. -/// @param[in] w A function to iterate. -/// @param[in] e Passed to `w`. -/// @note It makes no sense to pass nullptr to`w`. -/// @see st_foreach() -/// @deprecated Use glanular typed overload instead. -inline void -rb_hash_foreach(VALUE q, int_type *w, VALUE e) -{ - st_foreach_callback_func *r = - reinterpret_cast<st_foreach_callback_func*>(w); - ::rb_hash_foreach(q, r, e); -} - -RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated") -/// @brief Iteration over each instance variable of the object. -/// @param[in] q An object. -/// @param[in] w A function to iterate. -/// @param[in] e Passed to `w`. -/// @note It makes no sense to pass nullptr to`w`. -/// @see st_foreach() -/// @deprecated Use glanular typed overload instead. -inline void -rb_ivar_foreach(VALUE q, int_type *w, VALUE e) -{ - st_foreach_callback_func *r = - reinterpret_cast<st_foreach_callback_func*>(w); - ::rb_ivar_foreach(q, r, e); -} - -/// @} -}}} - -using namespace ruby::backward::cxxanyargs; -#endif // RUBY_BACKWARD_CXXANYARGS_HPP diff --git a/include/ruby/debug.h b/include/ruby/debug.h index 8a831e61ab..0456c73b9c 100644 --- a/include/ruby/debug.h +++ b/include/ruby/debug.h @@ -83,11 +83,7 @@ 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 - * rb_postponed_job_register and rb_postponed_job_register_one are - * async-signal-safe and used via SIGPROF by the "stackprof" RubyGem - */ +/* 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); diff --git a/include/ruby/defines.h b/include/ruby/defines.h index dc71d65100..2c72a7cb8a 100644 --- a/include/ruby/defines.h +++ b/include/ruby/defines.h @@ -29,6 +29,10 @@ extern "C" { #ifndef PUREFUNC # define PUREFUNC(x) x #endif +#define NORETURN_STYLE_NEW 1 +#ifndef NORETURN +# define NORETURN(x) x +#endif #ifndef DEPRECATED # define DEPRECATED(x) x #endif @@ -38,9 +42,6 @@ extern "C" { #ifndef DEPRECATED_TYPE # define DEPRECATED_TYPE(mesg, decl) decl #endif -#ifndef RUBY_CXX_DEPRECATED -# define RUBY_CXX_DEPRECATED(mesg) /* nothing */ -#endif #ifndef NOINLINE # define NOINLINE(x) x #endif @@ -92,24 +93,9 @@ extern "C" { #define RB_UNLIKELY(x) (x) #endif /* __GNUC__ >= 3 */ -/* - cold attribute for code layout improvements - RUBY_FUNC_ATTRIBUTE not used because MSVC does not like nested func macros - */ -#if defined(__clang__) || GCC_VERSION_SINCE(4, 3, 0) -#define COLDFUNC __attribute__((cold)) -#else -#define COLDFUNC -#endif - #ifdef __GNUC__ -#if defined __MINGW_PRINTF_FORMAT -#define PRINTF_ARGS(decl, string_index, first_to_check) \ - decl __attribute__((format(__MINGW_PRINTF_FORMAT, string_index, first_to_check))) -#else #define PRINTF_ARGS(decl, string_index, first_to_check) \ decl __attribute__((format(printf, string_index, first_to_check))) -#endif #else #define PRINTF_ARGS(decl, string_index, first_to_check) decl #endif @@ -153,9 +139,6 @@ extern "C" { #ifdef HAVE_STDINT_H # include <stdint.h> #endif -#ifdef HAVE_STDALIGN_H -# include <stdalign.h> -#endif #ifdef HAVE_UNISTD_H # include <unistd.h> #endif @@ -217,116 +200,16 @@ RUBY_SYMBOL_EXPORT_BEGIN #if GCC_VERSION_SINCE(4,3,0) # define RUBY_ATTR_ALLOC_SIZE(params) __attribute__ ((alloc_size params)) -#elif defined(__has_attribute) -# if __has_attribute(alloc_size) -# define RUBY_ATTR_ALLOC_SIZE(params) __attribute__((__alloc_size__ params)) -# endif -#endif -#ifndef RUBY_ATTR_ALLOC_SIZE +#else # define RUBY_ATTR_ALLOC_SIZE(params) #endif -#ifdef __has_attribute -# if __has_attribute(malloc) -# define RUBY_ATTR_MALLOC __attribute__((__malloc__)) -# endif -#endif -#ifndef RUBY_ATTR_MALLOC -# define RUBY_ATTR_MALLOC -#endif - -#ifdef __has_attribute -# if __has_attribute(returns_nonnull) -# define RUBY_ATTR_RETURNS_NONNULL __attribute__((__returns_nonnull__)) -# endif -#endif -#ifndef RUBY_ATTR_RETURNS_NONNULL -# define RUBY_ATTR_RETURNS_NONNULL -#endif - -void *ruby_xmalloc(size_t) RUBY_ATTR_MALLOC RUBY_ATTR_RETURNS_NONNULL RUBY_ATTR_ALLOC_SIZE((1)); -void *ruby_xmalloc2(size_t,size_t) RUBY_ATTR_MALLOC RUBY_ATTR_RETURNS_NONNULL RUBY_ATTR_ALLOC_SIZE((1,2)); -void *ruby_xcalloc(size_t,size_t) RUBY_ATTR_MALLOC RUBY_ATTR_RETURNS_NONNULL RUBY_ATTR_ALLOC_SIZE((1,2)); -void *ruby_xrealloc(void*,size_t) RUBY_ATTR_RETURNS_NONNULL RUBY_ATTR_ALLOC_SIZE((2)); -void *ruby_xrealloc2(void*,size_t,size_t) RUBY_ATTR_RETURNS_NONNULL RUBY_ATTR_ALLOC_SIZE((2,3)); -void ruby_xfree(void*); - -#ifndef USE_GC_MALLOC_OBJ_INFO_DETAILS -#define USE_GC_MALLOC_OBJ_INFO_DETAILS 0 -#endif - -#if USE_GC_MALLOC_OBJ_INFO_DETAILS - -void *ruby_xmalloc_body(size_t) RUBY_ATTR_MALLOC RUBY_ATTR_RETURNS_NONNULL RUBY_ATTR_ALLOC_SIZE((1)); -void *ruby_xmalloc2_body(size_t,size_t) RUBY_ATTR_MALLOC RUBY_ATTR_RETURNS_NONNULL RUBY_ATTR_ALLOC_SIZE((1,2)); -void *ruby_xcalloc_body(size_t,size_t) RUBY_ATTR_MALLOC RUBY_ATTR_RETURNS_NONNULL RUBY_ATTR_ALLOC_SIZE((1,2)); -void *ruby_xrealloc_body(void*,size_t) RUBY_ATTR_RETURNS_NONNULL RUBY_ATTR_ALLOC_SIZE((2)); -void *ruby_xrealloc2_body(void*,size_t,size_t) RUBY_ATTR_RETURNS_NONNULL RUBY_ATTR_ALLOC_SIZE((2,3)); - -#define ruby_xmalloc(s1) ruby_xmalloc_with_location(s1, __FILE__, __LINE__) -#define ruby_xmalloc2(s1, s2) ruby_xmalloc2_with_location(s1, s2, __FILE__, __LINE__) -#define ruby_xcalloc(s1, s2) ruby_xcalloc_with_location(s1, s2, __FILE__, __LINE__) -#define ruby_xrealloc(ptr, s1) ruby_xrealloc_with_location(ptr, s1, __FILE__, __LINE__) -#define ruby_xrealloc2(ptr, s1, s2) ruby_xrealloc2_with_location(ptr, s1, s2, __FILE__, __LINE__) - -extern const char *ruby_malloc_info_file; -extern int ruby_malloc_info_line; - -static inline void * -ruby_xmalloc_with_location(size_t s, const char *file, int line) -{ - void *ptr; - ruby_malloc_info_file = file; - ruby_malloc_info_line = line; - ptr = ruby_xmalloc_body(s); - ruby_malloc_info_file = NULL; - return ptr; -} - -static inline void * -ruby_xmalloc2_with_location(size_t s1, size_t s2, const char *file, int line) -{ - void *ptr; - ruby_malloc_info_file = file; - ruby_malloc_info_line = line; - ptr = ruby_xmalloc2_body(s1, s2); - ruby_malloc_info_file = NULL; - return ptr; -} - -static inline void * -ruby_xcalloc_with_location(size_t s1, size_t s2, const char *file, int line) -{ - void *ptr; - ruby_malloc_info_file = file; - ruby_malloc_info_line = line; - ptr = ruby_xcalloc_body(s1, s2); - ruby_malloc_info_file = NULL; - return ptr; -} - -static inline void * -ruby_xrealloc_with_location(void *ptr, size_t s, const char *file, int line) -{ - void *rptr; - ruby_malloc_info_file = file; - ruby_malloc_info_line = line; - rptr = ruby_xrealloc_body(ptr, s); - ruby_malloc_info_file = NULL; - return rptr; -} - -static inline void * -ruby_xrealloc2_with_location(void *ptr, size_t s1, size_t s2, const char *file, int line) -{ - void *rptr; - ruby_malloc_info_file = file; - ruby_malloc_info_line = line; - rptr = ruby_xrealloc2_body(ptr, s1, s2); - ruby_malloc_info_file = NULL; - return rptr; -} -#endif +void *xmalloc(size_t) RUBY_ATTR_ALLOC_SIZE((1)); +void *xmalloc2(size_t,size_t) RUBY_ATTR_ALLOC_SIZE((1,2)); +void *xcalloc(size_t,size_t) RUBY_ATTR_ALLOC_SIZE((1,2)); +void *xrealloc(void*,size_t) RUBY_ATTR_ALLOC_SIZE((2)); +void *xrealloc2(void*,size_t,size_t) RUBY_ATTR_ALLOC_SIZE((2,3)); +void xfree(void*); #define STRINGIZE(expr) STRINGIZE0(expr) #ifndef STRINGIZE0 @@ -391,17 +274,6 @@ ruby_xrealloc2_with_location(void *ptr, size_t s1, size_t s2, const char *file, #define RUBY_FUNC_EXPORTED #endif -/* These macros are used for functions which are exported only for MJIT - and NOT ensured to be exported in future versions. */ -#define MJIT_FUNC_EXPORTED RUBY_FUNC_EXPORTED -#define MJIT_SYMBOL_EXPORT_BEGIN RUBY_SYMBOL_EXPORT_BEGIN -#define MJIT_SYMBOL_EXPORT_END RUBY_SYMBOL_EXPORT_END - -#if defined(MJIT_HEADER) && defined(_MSC_VER) -# undef MJIT_FUNC_EXPORTED -# define MJIT_FUNC_EXPORTED static -#endif - #ifndef RUBY_EXTERN #define RUBY_EXTERN extern #endif @@ -427,6 +299,10 @@ ruby_xrealloc2_with_location(void *ptr, size_t s1, size_t s2, const char *file, #if defined(__sparc) void rb_sparc_flush_register_windows(void); # define FLUSH_REGISTER_WINDOWS rb_sparc_flush_register_windows() +#elif defined(__ia64) +void *rb_ia64_bsp(void); +void rb_ia64_flushrs(void); +# define FLUSH_REGISTER_WINDOWS rb_ia64_flushrs() #else # define FLUSH_REGISTER_WINDOWS ((void)0) #endif @@ -478,15 +354,11 @@ void rb_sparc_flush_register_windows(void); #define RUBY_ALIAS_FUNCTION(prot, name, args) \ RUBY_ALIAS_FUNCTION_TYPE(VALUE, prot, name, args) #endif -#ifndef RUBY_FUNC_NONNULL -#define RUBY_FUNC_NONNULL(n, x) x -#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(__aarch64__) || \ defined(__mc68020__) # define UNALIGNED_WORD_ACCESS 1 # else @@ -504,31 +376,6 @@ void rb_sparc_flush_register_windows(void); # endif #endif -#ifndef RUBY_ALIGNAS -#define RUBY_ALIGNAS(x) /* x */ -#endif - -#ifdef RUBY_ALIGNOF -/* OK, take that definition */ -#elif defined(__cplusplus) && (__cplusplus >= 201103L) -#define RUBY_ALIGNOF alignof -#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) -#define RUBY_ALIGNOF _Alignof -#else -#define RUBY_ALIGNOF(type) ((size_t)offsetof(struct { char f1; type f2; }, f2)) -#endif - -#define NORETURN_STYLE_NEW 1 -#ifdef NORETURN -/* OK, take that definition */ -#elif defined(__cplusplus) && (__cplusplus >= 201103L) -#define NORETURN(x) [[ noreturn ]] x -#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) -#define NORETURN(x) _Noreturn x -#else -#define NORETURN(x) x -#endif - RUBY_SYMBOL_EXPORT_END #if defined(__cplusplus) diff --git a/include/ruby/encoding.h b/include/ruby/encoding.h index 93939ee7db..e6ceb19cdf 100644 --- a/include/ruby/encoding.h +++ b/include/ruby/encoding.h @@ -12,10 +12,6 @@ #ifndef RUBY_ENCODING_H #define RUBY_ENCODING_H 1 -#ifdef RUBY_INTERNAL_H -#error "Include this file before internal.h" -#endif - #if defined(__cplusplus) extern "C" { #if 0 @@ -122,9 +118,7 @@ PUREFUNC(int rb_enc_dummy_p(rb_encoding *enc)); PUREFUNC(int rb_enc_to_index(rb_encoding *enc)); int rb_enc_get_index(VALUE obj); void rb_enc_set_index(VALUE obj, int encindex); -int rb_enc_capable(VALUE obj); int rb_enc_find_index(const char *name); -int rb_enc_alias(const char *alias, const char *orig); int rb_to_encoding_index(VALUE); rb_encoding *rb_to_encoding(VALUE); rb_encoding *rb_find_encoding(VALUE); diff --git a/include/ruby/intern.h b/include/ruby/intern.h index 2f60fb569e..a711b86115 100644 --- a/include/ruby/intern.h +++ b/include/ruby/intern.h @@ -21,10 +21,6 @@ extern "C" { #endif #endif -#if !defined(__has_attribute) -#define __has_attribute(x) 0 -#endif - #include "ruby/defines.h" #ifdef RUBY_EXTCONF_H #include RUBY_EXTCONF_H @@ -38,15 +34,6 @@ extern "C" { #include "ruby/st.h" -/* On mswin, MJIT header transformation can't be used since cl.exe can't output - preprocessed output preserving macros. So this `MJIT_STATIC` is needed - to force non-static function to static on MJIT header to avoid symbol conflict. */ -#ifdef MJIT_HEADER -# define MJIT_STATIC static -#else -# define MJIT_STATIC -#endif - RUBY_SYMBOL_EXPORT_BEGIN /* @@ -57,7 +44,7 @@ RUBY_SYMBOL_EXPORT_BEGIN #define UNLIMITED_ARGUMENTS (-1) /* array.c */ -void rb_mem_clear(VALUE*, long); +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); @@ -192,24 +179,7 @@ VALUE rb_complex_raw(VALUE, VALUE); 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)) -VALUE rb_complex_new_polar(VALUE abs, VALUE arg); -DEPRECATED_BY(rb_complex_new_polar, VALUE rb_complex_polar(VALUE abs, VALUE arg)); -VALUE rb_complex_real(VALUE z); -VALUE rb_complex_imag(VALUE z); -VALUE rb_complex_plus(VALUE x, VALUE y); -VALUE rb_complex_minus(VALUE x, VALUE y); -VALUE rb_complex_mul(VALUE x, VALUE y); -VALUE rb_complex_div(VALUE x, VALUE y); -VALUE rb_complex_uminus(VALUE z); -VALUE rb_complex_conjugate(VALUE z); -VALUE rb_complex_abs(VALUE z); -VALUE rb_complex_arg(VALUE z); -VALUE rb_complex_pow(VALUE base, VALUE exp); -VALUE rb_dbl_complex_new(double real, double imag); -#define rb_complex_add rb_complex_plus -#define rb_complex_sub rb_complex_minus -#define rb_complex_nagate rb_complex_uminus - +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)) @@ -233,6 +203,7 @@ VALUE rb_class_protected_instance_methods(int, const VALUE*, VALUE); VALUE rb_class_private_instance_methods(int, const VALUE*, VALUE); VALUE rb_obj_singleton_methods(int, const VALUE*, VALUE); void rb_define_method_id(VALUE, ID, VALUE (*)(ANYARGS), int); +void rb_frozen_class_p(VALUE); void rb_undef(VALUE, ID); void rb_define_protected_method(VALUE, const char*, VALUE (*)(ANYARGS), int); void rb_define_private_method(VALUE, const char*, VALUE (*)(ANYARGS), int); @@ -242,11 +213,9 @@ VALUE rb_singleton_class(VALUE); int rb_cmpint(VALUE, VALUE, VALUE); NORETURN(void rb_cmperr(VALUE, VALUE)); /* cont.c */ -VALUE rb_fiber_new(rb_block_call_func_t, VALUE); +VALUE rb_fiber_new(VALUE (*)(ANYARGS), VALUE); VALUE rb_fiber_resume(VALUE fib, int argc, const VALUE *argv); -VALUE rb_fiber_resume_kw(VALUE fib, int argc, const VALUE *argv, int kw_splat); VALUE rb_fiber_yield(int argc, const VALUE *argv); -VALUE rb_fiber_yield_kw(int argc, const VALUE *argv, int kw_splat); VALUE rb_fiber_current(void); VALUE rb_fiber_alive_p(VALUE); /* enum.c */ @@ -255,36 +224,18 @@ VALUE rb_enum_values_pack(int, const VALUE*); 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 *); -VALUE rb_enumeratorize_with_size_kw(VALUE, VALUE, int, const VALUE *, rb_enumerator_size_func *, int); #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)) -#define rb_enumeratorize_with_size_kw(obj, id, argc, argv, size_fn, kw_splat) \ - rb_enumeratorize_with_size_kw(obj, id, argc, argv, (rb_enumerator_size_func *)(size_fn), kw_splat) #endif #define SIZED_ENUMERATOR(obj, argc, argv, size_fn) \ rb_enumeratorize_with_size((obj), ID2SYM(rb_frame_this_func()), \ (argc), (argv), (size_fn)) -#define SIZED_ENUMERATOR_KW(obj, argc, argv, size_fn, kw_splat) \ - rb_enumeratorize_with_size_kw((obj), ID2SYM(rb_frame_this_func()), \ - (argc), (argv), (size_fn), (kw_splat)) #define RETURN_SIZED_ENUMERATOR(obj, argc, argv, size_fn) do { \ if (!rb_block_given_p()) \ return SIZED_ENUMERATOR(obj, argc, argv, size_fn); \ } while (0) -#define RETURN_SIZED_ENUMERATOR_KW(obj, argc, argv, size_fn, kw_splat) do { \ - if (!rb_block_given_p()) \ - return SIZED_ENUMERATOR_KW(obj, argc, argv, size_fn, kw_splat); \ - } while (0) #define RETURN_ENUMERATOR(obj, argc, argv) RETURN_SIZED_ENUMERATOR(obj, argc, argv, 0) -#define RETURN_ENUMERATOR_KW(obj, argc, argv, kw_splat) RETURN_SIZED_ENUMERATOR_KW(obj, argc, argv, 0, kw_splat) -typedef struct { - VALUE begin; - VALUE end; - VALUE step; - int exclude_end; -} rb_arithmetic_sequence_components_t; -int rb_arithmetic_sequence_extract(VALUE, rb_arithmetic_sequence_components_t *); /* error.c */ VALUE rb_exc_new(VALUE, const char*, long); VALUE rb_exc_new_cstr(VALUE, const char*); @@ -295,7 +246,6 @@ 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); -PRINTF_ARGS(NORETURN(void rb_frozen_error_raise(VALUE, const char*, ...)), 2, 3); NORETURN(void rb_invalid_str(const char*, const char*)); NORETURN(void rb_error_frozen(const char*)); NORETURN(void rb_error_frozen_object(VALUE)); @@ -304,12 +254,14 @@ void rb_check_frozen(VALUE); void rb_check_trusted(VALUE); #define rb_check_frozen_internal(obj) do { \ VALUE frozen_obj = (obj); \ - if (RB_UNLIKELY(RB_OBJ_FROZEN(frozen_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) @@ -320,7 +272,7 @@ rb_check_frozen_inline(VALUE obj) static inline void rb_check_trusted_inline(VALUE obj) { - rb_check_trusted(obj); + rb_check_trusted_internal(obj); } #define rb_check_trusted(obj) rb_check_trusted_inline(obj) #endif @@ -334,9 +286,8 @@ void rb_check_copyable(VALUE obj, VALUE orig); int rb_sourceline(void); const char *rb_sourcefile(void); VALUE rb_check_funcall(VALUE, ID, int, const VALUE*); -VALUE rb_check_funcall_kw(VALUE, ID, int, const VALUE*, int); -NORETURN(MJIT_STATIC void rb_error_arity(int, int, int)); +NORETURN(void rb_error_arity(int, int, int)); static inline int rb_check_arity(int argc, int min, int max) { @@ -384,15 +335,7 @@ void rb_fd_set(int, rb_fdset_t *); 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); -static inline int -rb_fd_select(int n, rb_fdset_t *rfds, rb_fdset_t *wfds, rb_fdset_t *efds, struct timeval *timeout) -{ - return rb_w32_select(n, - rfds ? rfds->fdset : NULL, - wfds ? wfds->fdset : NULL, - efds ? efds->fdset : NULL, - timeout); -} +#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) @@ -435,12 +378,11 @@ void rb_attr(VALUE,ID,int,int,int); int rb_method_boundp(VALUE, ID, int); int rb_method_basic_definition_p(VALUE, ID); VALUE rb_eval_cmd(VALUE, VALUE, int); -VALUE rb_eval_cmd_kw(VALUE, VALUE, int); int rb_obj_respond_to(VALUE, ID, int); int rb_respond_to(VALUE, ID); -NORETURN(VALUE rb_f_notimplement(int argc, const VALUE *argv, VALUE obj, VALUE marker)); +NORETURN(VALUE rb_f_notimplement(int argc, const VALUE *argv, VALUE obj)); #if !defined(RUBY_EXPORT) && defined(_WIN32) -RUBY_EXTERN VALUE (*const rb_f_notimplement_)(int, const VALUE *, VALUE, VALUE marker); +RUBY_EXTERN VALUE (*const rb_f_notimplement_)(int, const VALUE *, VALUE); #define rb_f_notimplement (*rb_f_notimplement_) #endif NORETURN(void rb_interrupt(void)); @@ -458,33 +400,27 @@ int rb_provided(const char*); 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); /* Remove in 3.0 */ -VALUE rb_require_string(VALUE); +VALUE rb_require_safe(VALUE, int); void rb_obj_call_init(VALUE, int, const VALUE*); -void rb_obj_call_init_kw(VALUE, int, const VALUE*, int); VALUE rb_class_new_instance(int, const VALUE*, VALUE); -VALUE rb_class_new_instance_kw(int, const VALUE*, VALUE, int); VALUE rb_block_proc(void); VALUE rb_block_lambda(void); -VALUE rb_proc_new(rb_block_call_func_t, VALUE); +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_kw(VALUE, VALUE, int); VALUE rb_proc_call_with_block(VALUE, int argc, const VALUE *argv, VALUE); -VALUE rb_proc_call_with_block_kw(VALUE, int argc, const VALUE *argv, VALUE, int); 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_kw(int, const VALUE*, VALUE, int); VALUE rb_method_call_with_block(int, const VALUE *, VALUE, VALUE); -VALUE rb_method_call_with_block_kw(int, const VALUE *, VALUE, VALUE, int); 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_exec_end_proc(void); void rb_thread_schedule(void); void rb_thread_wait_fd(int); int rb_thread_fd_writable(int); @@ -498,7 +434,7 @@ 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 (*)(void *), void*); +VALUE rb_thread_create(VALUE (*)(ANYARGS), void*); 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); @@ -519,29 +455,27 @@ VALUE rb_file_expand_path(VALUE, VALUE); VALUE rb_file_s_absolute_path(int, const VALUE *); VALUE rb_file_absolute_path(VALUE, VALUE); VALUE rb_file_dirname(VALUE fname); -int rb_find_file_ext_safe(VALUE*, const char* const*, int); /* Remove in 3.0 */ -VALUE rb_find_file_safe(VALUE, int); /* Remove in 3.0 */ +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); VALUE rb_file_directory_p(VALUE,VALUE); VALUE rb_str_encode_ospath(VALUE); int rb_is_absolute_path(const char *); /* gc.c */ -COLDFUNC NORETURN(void rb_memerror(void)); +NORETURN(void rb_memerror(void)); PUREFUNC(int rb_during_gc(void)); void rb_gc_mark_locations(const VALUE*, const VALUE*); void rb_mark_tbl(struct st_table*); -void rb_mark_tbl_no_pin(struct st_table*); void rb_mark_set(struct st_table*); void rb_mark_hash(struct st_table*); -void rb_gc_update_tbl_refs(st_table *ptr); void rb_gc_mark_maybe(VALUE); void rb_gc_mark(VALUE); -void rb_gc_mark_movable(VALUE); -VALUE rb_gc_location(VALUE); void rb_gc_force_recycle(VALUE); void rb_gc(void); void rb_gc_copy_finalizer(VALUE,VALUE); +void rb_gc_finalize_deferred(void); +void rb_gc_call_finalizer_at_exit(void); VALUE rb_gc_enable(void); VALUE rb_gc_disable(void); VALUE rb_gc_start(void); @@ -552,10 +486,9 @@ size_t rb_gc_stat(VALUE); VALUE rb_gc_latest_gc_info(VALUE); void rb_gc_adjust_memory_usage(ssize_t); /* hash.c */ -void rb_st_foreach_safe(struct st_table *, int (*)(st_data_t, st_data_t, st_data_t), st_data_t); -#define st_foreach_safe rb_st_foreach_safe +void st_foreach_safe(struct st_table *, int (*)(ANYARGS), st_data_t); VALUE rb_check_hash_type(VALUE); -void rb_hash_foreach(VALUE, int (*)(VALUE, VALUE, VALUE), VALUE); +void rb_hash_foreach(VALUE, int (*)(ANYARGS), VALUE); VALUE rb_hash(VALUE); VALUE rb_hash_new(void); VALUE rb_hash_dup(VALUE); @@ -569,15 +502,13 @@ 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); -void rb_hash_bulk_insert(long, const VALUE *, VALUE); 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, const char *file, int line); +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); -void rb_hash_free(VALUE); /* io.c */ #define rb_defout rb_stdout RUBY_EXTERN VALUE rb_fs; @@ -650,7 +581,6 @@ VALUE rb_obj_trust(VALUE); VALUE rb_obj_freeze(VALUE); PUREFUNC(VALUE rb_obj_frozen_p(VALUE)); VALUE rb_obj_id(VALUE); -VALUE rb_memory_id(VALUE); VALUE rb_obj_class(VALUE); PUREFUNC(VALUE rb_class_real(VALUE)); PUREFUNC(VALUE rb_class_inherited_p(VALUE, VALUE)); @@ -741,6 +671,8 @@ VALUE rb_f_kill(int, const VALUE*); #define posix_signal ruby_posix_signal RETSIGTYPE (*posix_signal(int, RETSIGTYPE (*)(int)))(int); #endif +void rb_trap_exit(void); +void rb_trap_exec(void); const char *ruby_signal_name(int); void ruby_default_signal(int); /* sprintf.c */ @@ -825,7 +757,7 @@ VALUE rb_str_replace(VALUE, VALUE); VALUE rb_str_inspect(VALUE); VALUE rb_str_dump(VALUE); VALUE rb_str_split(VALUE, const char*); -rb_gvar_setter_t rb_str_setter; +void rb_str_setter(VALUE, ID, VALUE*); VALUE rb_str_intern(VALUE); VALUE rb_sym_to_s(VALUE); long rb_str_strlen(VALUE); @@ -952,7 +884,6 @@ VALUE rb_mutex_unlock(VALUE mutex); VALUE rb_mutex_sleep(VALUE self, VALUE timeout); VALUE rb_mutex_synchronize(VALUE mutex, VALUE (*func)(VALUE arg), VALUE arg); /* time.c */ -struct timespec; void rb_timespec_now(struct timespec *); VALUE rb_time_new(time_t, long); VALUE rb_time_nano_new(time_t, long); @@ -961,7 +892,6 @@ 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); -struct timespec rb_time_timespec_interval(VALUE num); VALUE rb_time_utc_offset(VALUE time); /* variable.c */ VALUE rb_mod_name(VALUE); @@ -971,6 +901,7 @@ void rb_set_class_path(VALUE, VALUE, const char*); void rb_set_class_path_string(VALUE, VALUE, VALUE); VALUE rb_path_to_class(VALUE); VALUE rb_path2class(const char*); +void rb_name_class(VALUE, ID); VALUE rb_class_name(VALUE); VALUE rb_autoload_load(VALUE, ID); VALUE rb_autoload_p(VALUE, ID); @@ -983,7 +914,7 @@ 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 (*)(ID, VALUE, st_data_t), st_data_t); +void rb_ivar_foreach(VALUE, int (*)(ANYARGS), st_data_t); st_index_t rb_ivar_count(VALUE); VALUE rb_attr_get(VALUE, ID); VALUE rb_obj_instance_variables(VALUE); @@ -1001,9 +932,7 @@ VALUE rb_const_get_at(VALUE, ID); VALUE rb_const_get_from(VALUE, ID); void rb_const_set(VALUE, ID, VALUE); VALUE rb_const_remove(VALUE, ID); -#if 0 /* EXPERIMENTAL: remove if no problem */ NORETURN(VALUE rb_mod_const_missing(VALUE,VALUE)); -#endif VALUE rb_cvar_defined(VALUE, ID); void rb_cvar_set(VALUE, ID, VALUE); VALUE rb_cvar_get(VALUE, ID); @@ -1014,7 +943,6 @@ VALUE rb_mod_class_variables(int, const VALUE*, VALUE); VALUE rb_mod_remove_cvar(VALUE, VALUE); ID rb_frame_callee(void); -int rb_frame_method_id_and_class(ID *idp, VALUE *klassp); VALUE rb_str_succ(VALUE); VALUE rb_time_succ(VALUE); VALUE rb_make_backtrace(void); @@ -1027,204 +955,6 @@ RUBY_SYMBOL_EXPORT_END { /* satisfy cc-mode */ #endif } /* extern "C" { */ -extern "C++" { -#endif - -#if defined(HAVE_BUILTIN___BUILTIN_TYPES_COMPATIBLE_P) -# define rb_f_notimplement_p(f) __builtin_types_compatible_p(__typeof__(f),__typeof__(rb_f_notimplement)) -#else -# define rb_f_notimplement_p(f) 0 -#endif - -#if defined(HAVE_BUILTIN___BUILTIN_CHOOSE_EXPR_CONSTANT_P) && !defined(_WIN32) && !defined(__CYGWIN__) -#if defined(__has_attribute) && __has_attribute(transparent_union) && __has_attribute(unused) && __has_attribute(weakref) && __has_attribute(nonnull) -#define RB_METHOD_DEFINITION_DECL_C(def,nonnull,defname,decl,vars,funcargs) \ - __attribute__((__unused__,__weakref__(#def),__nonnull__ nonnull))static void defname(RB_UNWRAP_MACRO decl,VALUE(*func)funcargs,int arity); -#endif -#endif - -#if defined(RB_METHOD_DEFINITION_DECL_C) || defined(__cplusplus) -#ifndef RB_METHOD_DEFINITION_DECL_C -#define RB_METHOD_DEFINITION_DECL_C(def,nonnull,defname,decl,vars,funcargs) \ - static inline void defname(RB_UNWRAP_MACRO decl,VALUE(*func)funcargs,int arity) \ - { \ - def(RB_UNWRAP_MACRO vars,(VALUE(*)(ANYARGS))(func),arity); \ - } -#endif - -#define RB_UNWRAP_MACRO(...) __VA_ARGS__ - -#ifdef __cplusplus -#define RB_METHOD_DEFINITION_DECL_CXX_BEGIN(def) template <int Arity> struct def##_tmpl {}; -#define RB_METHOD_DEFINITION_DECL_CXX(def,defname,decl,vars,funcargs,arity) \ - template <> struct def##_tmpl<arity> { \ - static void define(RB_UNWRAP_MACRO decl, VALUE (*func)funcargs) {::defname(RB_UNWRAP_MACRO vars, func, arity);} \ - static void define(RB_UNWRAP_MACRO decl, VALUE (*func)(...)) {::defname(RB_UNWRAP_MACRO vars, reinterpret_cast<VALUE(*)funcargs>(func), arity);} \ - }; -#else -#define RB_METHOD_DEFINITION_DECL_CXX_BEGIN(def) /* nothing */ -#define RB_METHOD_DEFINITION_DECL_CXX(def,defname,decl,vars,funcargs,arity) /* nothing */ -#endif -#define RB_METHOD_DEFINITION_DECL_1(def,nonnull,defname,arity,decl,vars,funcargs) \ - RB_METHOD_DEFINITION_DECL_C(def,nonnull,defname,decl,vars,funcargs) \ - RB_METHOD_DEFINITION_DECL_CXX(def,defname,decl,vars,funcargs,arity) - -#define RB_METHOD_DEFINITION_DECL(def,nonnull,decl,vars) \ -RB_METHOD_DEFINITION_DECL_CXX_BEGIN(def) \ -RB_METHOD_DEFINITION_DECL_1(def,nonnull,def##0 ,0 ,decl,vars,(VALUE)) \ -RB_METHOD_DEFINITION_DECL_1(def,nonnull,def##1 ,1 ,decl,vars,(VALUE,VALUE)) \ -RB_METHOD_DEFINITION_DECL_1(def,nonnull,def##2 ,2 ,decl,vars,(VALUE,VALUE,VALUE)) \ -RB_METHOD_DEFINITION_DECL_1(def,nonnull,def##3 ,3 ,decl,vars,(VALUE,VALUE,VALUE,VALUE)) \ -RB_METHOD_DEFINITION_DECL_1(def,nonnull,def##4 ,4 ,decl,vars,(VALUE,VALUE,VALUE,VALUE,VALUE)) \ -RB_METHOD_DEFINITION_DECL_1(def,nonnull,def##5 ,5 ,decl,vars,(VALUE,VALUE,VALUE,VALUE,VALUE,VALUE)) \ -RB_METHOD_DEFINITION_DECL_1(def,nonnull,def##6 ,6 ,decl,vars,(VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE)) \ -RB_METHOD_DEFINITION_DECL_1(def,nonnull,def##7 ,7 ,decl,vars,(VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE)) \ -RB_METHOD_DEFINITION_DECL_1(def,nonnull,def##8 ,8 ,decl,vars,(VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE)) \ -RB_METHOD_DEFINITION_DECL_1(def,nonnull,def##9 ,9 ,decl,vars,(VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE)) \ -RB_METHOD_DEFINITION_DECL_1(def,nonnull,def##10,10,decl,vars,(VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE)) \ -RB_METHOD_DEFINITION_DECL_1(def,nonnull,def##11,11,decl,vars,(VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE)) \ -RB_METHOD_DEFINITION_DECL_1(def,nonnull,def##12,12,decl,vars,(VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE)) \ -RB_METHOD_DEFINITION_DECL_1(def,nonnull,def##13,13,decl,vars,(VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE)) \ -RB_METHOD_DEFINITION_DECL_1(def,nonnull,def##14,14,decl,vars,(VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE)) \ -RB_METHOD_DEFINITION_DECL_1(def,nonnull,def##15,15,decl,vars,(VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE)) \ -RB_METHOD_DEFINITION_DECL_M3(def,nonnull,def##m3,decl,vars) \ -RB_METHOD_DEFINITION_DECL_1(def,nonnull,def##m2,-2,decl,vars,(VALUE,VALUE)) \ -RB_METHOD_DEFINITION_DECL_M1(def,nonnull,def##m1,decl,vars) /* END */ -#ifdef __cplusplus -#define RB_METHOD_DEFINITION_DECL_M1(def,nonnull,defname,decl,vars) \ - RB_METHOD_DEFINITION_DECL_C(def,nonnull,defname,decl,vars,(int,VALUE*,VALUE)) \ - RB_METHOD_DEFINITION_DECL_C(def,nonnull,defname,decl,vars,(int,const VALUE*,VALUE)) \ - RB_METHOD_DEFINITION_DECL_C(def,nonnull,defname,decl,vars,(int,const VALUE*,VALUE,VALUE)) \ - RB_METHOD_DEFINITION_DECL_C(def,nonnull,defname,decl,vars,(...)) \ - template <> struct def##_tmpl<-1> { \ - static void define(RB_UNWRAP_MACRO decl, VALUE (*func)(int,VALUE*,VALUE)) {::defname(RB_UNWRAP_MACRO vars, func, -1);} \ - static void define(RB_UNWRAP_MACRO decl, VALUE (*func)(int,const VALUE*,VALUE)) {::defname(RB_UNWRAP_MACRO vars, func, -1);} \ - static void define(RB_UNWRAP_MACRO decl, VALUE (*func)(int,const VALUE*,VALUE,VALUE)) {::defname(RB_UNWRAP_MACRO vars, func, -1);} \ - static void define(RB_UNWRAP_MACRO decl, VALUE (*func)(...)) {::defname(RB_UNWRAP_MACRO vars, func, -1);} \ - }; -#define RB_METHOD_DEFINITION_DECL_M3(def,nonnull,defname,decl,vars) /* nothing */ -#else -#define RB_METHOD_DEFINITION_DECL_M1(def,nonnull,defname,decl,vars) \ - RB_METHOD_DEFINITION_DECL_C(def,nonnull,defname,decl,vars,(int,union{VALUE*x;const VALUE*y;}__attribute__((__transparent_union__)),VALUE)) -#define RB_METHOD_DEFINITION_DECL_M3(def,nonnull,defname,decl,vars) \ - RB_METHOD_DEFINITION_DECL_C(def,nonnull,defname,decl,vars,()) -#endif - -#endif - -#ifdef RB_METHOD_DEFINITION_DECL - -RB_METHOD_DEFINITION_DECL(rb_define_method_id, (3), (VALUE klass, ID name), (klass, name)) -#ifdef __cplusplus -#define rb_define_method_id(m, n, f, a) rb_define_method_id_tmpl<a>::define(m, n, f) -#else -#define rb_define_method_id_choose_prototype15(n) rb_define_method_if_constexpr((n)==15,rb_define_method_id15,rb_define_method_idm3) -#define rb_define_method_id_choose_prototype14(n) rb_define_method_if_constexpr((n)==14,rb_define_method_id14,rb_define_method_id_choose_prototype15(n)) -#define rb_define_method_id_choose_prototype13(n) rb_define_method_if_constexpr((n)==13,rb_define_method_id13,rb_define_method_id_choose_prototype14(n)) -#define rb_define_method_id_choose_prototype12(n) rb_define_method_if_constexpr((n)==12,rb_define_method_id12,rb_define_method_id_choose_prototype13(n)) -#define rb_define_method_id_choose_prototype11(n) rb_define_method_if_constexpr((n)==11,rb_define_method_id11,rb_define_method_id_choose_prototype12(n)) -#define rb_define_method_id_choose_prototype10(n) rb_define_method_if_constexpr((n)==10,rb_define_method_id10,rb_define_method_id_choose_prototype11(n)) -#define rb_define_method_id_choose_prototype9(n) rb_define_method_if_constexpr((n)== 9,rb_define_method_id9, rb_define_method_id_choose_prototype10(n)) -#define rb_define_method_id_choose_prototype8(n) rb_define_method_if_constexpr((n)== 8,rb_define_method_id8, rb_define_method_id_choose_prototype9(n)) -#define rb_define_method_id_choose_prototype7(n) rb_define_method_if_constexpr((n)== 7,rb_define_method_id7, rb_define_method_id_choose_prototype8(n)) -#define rb_define_method_id_choose_prototype6(n) rb_define_method_if_constexpr((n)== 6,rb_define_method_id6, rb_define_method_id_choose_prototype7(n)) -#define rb_define_method_id_choose_prototype5(n) rb_define_method_if_constexpr((n)== 5,rb_define_method_id5, rb_define_method_id_choose_prototype6(n)) -#define rb_define_method_id_choose_prototype4(n) rb_define_method_if_constexpr((n)== 4,rb_define_method_id4, rb_define_method_id_choose_prototype5(n)) -#define rb_define_method_id_choose_prototype3(n) rb_define_method_if_constexpr((n)== 3,rb_define_method_id3, rb_define_method_id_choose_prototype4(n)) -#define rb_define_method_id_choose_prototype2(n) rb_define_method_if_constexpr((n)== 2,rb_define_method_id2, rb_define_method_id_choose_prototype3(n)) -#define rb_define_method_id_choose_prototype1(n) rb_define_method_if_constexpr((n)== 1,rb_define_method_id1, rb_define_method_id_choose_prototype2(n)) -#define rb_define_method_id_choose_prototype0(n) rb_define_method_if_constexpr((n)== 0,rb_define_method_id0, rb_define_method_id_choose_prototype1(n)) -#define rb_define_method_id_choose_prototypem1(n) rb_define_method_if_constexpr((n)==-1,rb_define_method_idm1,rb_define_method_id_choose_prototype0(n)) -#define rb_define_method_id_choose_prototypem2(n) rb_define_method_if_constexpr((n)==-2,rb_define_method_idm2,rb_define_method_id_choose_prototypem1(n)) -#define rb_define_method_id_choose_prototypem3(n, f) rb_define_method_if_constexpr(rb_f_notimplement_p(f),rb_define_method_idm3,rb_define_method_id_choose_prototypem2(n)) -#define rb_define_method_id(klass, mid, func, arity) rb_define_method_id_choose_prototypem3((arity),(func))((klass),(mid),(func),(arity)); -#endif - -RB_METHOD_DEFINITION_DECL(rb_define_protected_method, (2,3), (VALUE klass, const char *name), (klass, name)) -#ifdef __cplusplus -#define rb_define_protected_method(m, n, f, a) rb_define_protected_method_tmpl<a>::define(m, n, f) -#else -#define rb_define_protected_method_choose_prototype15(n) rb_define_method_if_constexpr((n)==15,rb_define_protected_method15,rb_define_protected_methodm3) -#define rb_define_protected_method_choose_prototype14(n) rb_define_method_if_constexpr((n)==14,rb_define_protected_method14,rb_define_protected_method_choose_prototype15(n)) -#define rb_define_protected_method_choose_prototype13(n) rb_define_method_if_constexpr((n)==13,rb_define_protected_method13,rb_define_protected_method_choose_prototype14(n)) -#define rb_define_protected_method_choose_prototype12(n) rb_define_method_if_constexpr((n)==12,rb_define_protected_method12,rb_define_protected_method_choose_prototype13(n)) -#define rb_define_protected_method_choose_prototype11(n) rb_define_method_if_constexpr((n)==11,rb_define_protected_method11,rb_define_protected_method_choose_prototype12(n)) -#define rb_define_protected_method_choose_prototype10(n) rb_define_method_if_constexpr((n)==10,rb_define_protected_method10,rb_define_protected_method_choose_prototype11(n)) -#define rb_define_protected_method_choose_prototype9(n) rb_define_method_if_constexpr((n)== 9,rb_define_protected_method9, rb_define_protected_method_choose_prototype10(n)) -#define rb_define_protected_method_choose_prototype8(n) rb_define_method_if_constexpr((n)== 8,rb_define_protected_method8, rb_define_protected_method_choose_prototype9(n)) -#define rb_define_protected_method_choose_prototype7(n) rb_define_method_if_constexpr((n)== 7,rb_define_protected_method7, rb_define_protected_method_choose_prototype8(n)) -#define rb_define_protected_method_choose_prototype6(n) rb_define_method_if_constexpr((n)== 6,rb_define_protected_method6, rb_define_protected_method_choose_prototype7(n)) -#define rb_define_protected_method_choose_prototype5(n) rb_define_method_if_constexpr((n)== 5,rb_define_protected_method5, rb_define_protected_method_choose_prototype6(n)) -#define rb_define_protected_method_choose_prototype4(n) rb_define_method_if_constexpr((n)== 4,rb_define_protected_method4, rb_define_protected_method_choose_prototype5(n)) -#define rb_define_protected_method_choose_prototype3(n) rb_define_method_if_constexpr((n)== 3,rb_define_protected_method3, rb_define_protected_method_choose_prototype4(n)) -#define rb_define_protected_method_choose_prototype2(n) rb_define_method_if_constexpr((n)== 2,rb_define_protected_method2, rb_define_protected_method_choose_prototype3(n)) -#define rb_define_protected_method_choose_prototype1(n) rb_define_method_if_constexpr((n)== 1,rb_define_protected_method1, rb_define_protected_method_choose_prototype2(n)) -#define rb_define_protected_method_choose_prototype0(n) rb_define_method_if_constexpr((n)== 0,rb_define_protected_method0, rb_define_protected_method_choose_prototype1(n)) -#define rb_define_protected_method_choose_prototypem1(n) rb_define_method_if_constexpr((n)==-1,rb_define_protected_methodm1,rb_define_protected_method_choose_prototype0(n)) -#define rb_define_protected_method_choose_prototypem2(n) rb_define_method_if_constexpr((n)==-2,rb_define_protected_methodm2,rb_define_protected_method_choose_prototypem1(n)) -#define rb_define_protected_method_choose_prototypem3(n, f) rb_define_method_if_constexpr(rb_f_notimplement_p(f),rb_define_protected_methodm3,rb_define_protected_method_choose_prototypem2(n)) -#define rb_define_protected_method(klass, mid, func, arity) rb_define_protected_method_choose_prototypem3((arity),(func))((klass),(mid),(func),(arity)); -#endif - -RB_METHOD_DEFINITION_DECL(rb_define_private_method, (2,3), (VALUE klass, const char *name), (klass, name)) -#ifdef __cplusplus -#define rb_define_private_method(m, n, f, a) rb_define_private_method_tmpl<a>::define(m, n, f) -#else -#define rb_define_private_method_choose_prototype15(n) rb_define_method_if_constexpr((n)==15,rb_define_private_method15,rb_define_private_methodm3) -#define rb_define_private_method_choose_prototype14(n) rb_define_method_if_constexpr((n)==14,rb_define_private_method14,rb_define_private_method_choose_prototype15(n)) -#define rb_define_private_method_choose_prototype13(n) rb_define_method_if_constexpr((n)==13,rb_define_private_method13,rb_define_private_method_choose_prototype14(n)) -#define rb_define_private_method_choose_prototype12(n) rb_define_method_if_constexpr((n)==12,rb_define_private_method12,rb_define_private_method_choose_prototype13(n)) -#define rb_define_private_method_choose_prototype11(n) rb_define_method_if_constexpr((n)==11,rb_define_private_method11,rb_define_private_method_choose_prototype12(n)) -#define rb_define_private_method_choose_prototype10(n) rb_define_method_if_constexpr((n)==10,rb_define_private_method10,rb_define_private_method_choose_prototype11(n)) -#define rb_define_private_method_choose_prototype9(n) rb_define_method_if_constexpr((n)== 9,rb_define_private_method9, rb_define_private_method_choose_prototype10(n)) -#define rb_define_private_method_choose_prototype8(n) rb_define_method_if_constexpr((n)== 8,rb_define_private_method8, rb_define_private_method_choose_prototype9(n)) -#define rb_define_private_method_choose_prototype7(n) rb_define_method_if_constexpr((n)== 7,rb_define_private_method7, rb_define_private_method_choose_prototype8(n)) -#define rb_define_private_method_choose_prototype6(n) rb_define_method_if_constexpr((n)== 6,rb_define_private_method6, rb_define_private_method_choose_prototype7(n)) -#define rb_define_private_method_choose_prototype5(n) rb_define_method_if_constexpr((n)== 5,rb_define_private_method5, rb_define_private_method_choose_prototype6(n)) -#define rb_define_private_method_choose_prototype4(n) rb_define_method_if_constexpr((n)== 4,rb_define_private_method4, rb_define_private_method_choose_prototype5(n)) -#define rb_define_private_method_choose_prototype3(n) rb_define_method_if_constexpr((n)== 3,rb_define_private_method3, rb_define_private_method_choose_prototype4(n)) -#define rb_define_private_method_choose_prototype2(n) rb_define_method_if_constexpr((n)== 2,rb_define_private_method2, rb_define_private_method_choose_prototype3(n)) -#define rb_define_private_method_choose_prototype1(n) rb_define_method_if_constexpr((n)== 1,rb_define_private_method1, rb_define_private_method_choose_prototype2(n)) -#define rb_define_private_method_choose_prototype0(n) rb_define_method_if_constexpr((n)== 0,rb_define_private_method0, rb_define_private_method_choose_prototype1(n)) -#define rb_define_private_method_choose_prototypem1(n) rb_define_method_if_constexpr((n)==-1,rb_define_private_methodm1,rb_define_private_method_choose_prototype0(n)) -#define rb_define_private_method_choose_prototypem2(n) rb_define_method_if_constexpr((n)==-2,rb_define_private_methodm2,rb_define_private_method_choose_prototypem1(n)) -#define rb_define_private_method_choose_prototypem3(n, f) rb_define_method_if_constexpr(rb_f_notimplement_p(f),rb_define_private_methodm3,rb_define_private_method_choose_prototypem2(n)) -#define rb_define_private_method(klass, mid, func, arity) rb_define_private_method_choose_prototypem3((arity),(func))((klass),(mid),(func),(arity)); -#endif - -RB_METHOD_DEFINITION_DECL(rb_define_singleton_method, (2,3), (VALUE klass, const char *name), (klass, name)) -#ifdef __cplusplus -#define rb_define_singleton_method(m, n, f, a) rb_define_singleton_method_tmpl<a>::define(m, n, f) -#else -#define rb_define_singleton_method_choose_prototype15(n) rb_define_method_if_constexpr((n)==15,rb_define_singleton_method15,rb_define_singleton_methodm3) -#define rb_define_singleton_method_choose_prototype14(n) rb_define_method_if_constexpr((n)==14,rb_define_singleton_method14,rb_define_singleton_method_choose_prototype15(n)) -#define rb_define_singleton_method_choose_prototype13(n) rb_define_method_if_constexpr((n)==13,rb_define_singleton_method13,rb_define_singleton_method_choose_prototype14(n)) -#define rb_define_singleton_method_choose_prototype12(n) rb_define_method_if_constexpr((n)==12,rb_define_singleton_method12,rb_define_singleton_method_choose_prototype13(n)) -#define rb_define_singleton_method_choose_prototype11(n) rb_define_method_if_constexpr((n)==11,rb_define_singleton_method11,rb_define_singleton_method_choose_prototype12(n)) -#define rb_define_singleton_method_choose_prototype10(n) rb_define_method_if_constexpr((n)==10,rb_define_singleton_method10,rb_define_singleton_method_choose_prototype11(n)) -#define rb_define_singleton_method_choose_prototype9(n) rb_define_method_if_constexpr((n)== 9,rb_define_singleton_method9, rb_define_singleton_method_choose_prototype10(n)) -#define rb_define_singleton_method_choose_prototype8(n) rb_define_method_if_constexpr((n)== 8,rb_define_singleton_method8, rb_define_singleton_method_choose_prototype9(n)) -#define rb_define_singleton_method_choose_prototype7(n) rb_define_method_if_constexpr((n)== 7,rb_define_singleton_method7, rb_define_singleton_method_choose_prototype8(n)) -#define rb_define_singleton_method_choose_prototype6(n) rb_define_method_if_constexpr((n)== 6,rb_define_singleton_method6, rb_define_singleton_method_choose_prototype7(n)) -#define rb_define_singleton_method_choose_prototype5(n) rb_define_method_if_constexpr((n)== 5,rb_define_singleton_method5, rb_define_singleton_method_choose_prototype6(n)) -#define rb_define_singleton_method_choose_prototype4(n) rb_define_method_if_constexpr((n)== 4,rb_define_singleton_method4, rb_define_singleton_method_choose_prototype5(n)) -#define rb_define_singleton_method_choose_prototype3(n) rb_define_method_if_constexpr((n)== 3,rb_define_singleton_method3, rb_define_singleton_method_choose_prototype4(n)) -#define rb_define_singleton_method_choose_prototype2(n) rb_define_method_if_constexpr((n)== 2,rb_define_singleton_method2, rb_define_singleton_method_choose_prototype3(n)) -#define rb_define_singleton_method_choose_prototype1(n) rb_define_method_if_constexpr((n)== 1,rb_define_singleton_method1, rb_define_singleton_method_choose_prototype2(n)) -#define rb_define_singleton_method_choose_prototype0(n) rb_define_method_if_constexpr((n)== 0,rb_define_singleton_method0, rb_define_singleton_method_choose_prototype1(n)) -#define rb_define_singleton_method_choose_prototypem1(n) rb_define_method_if_constexpr((n)==-1,rb_define_singleton_methodm1,rb_define_singleton_method_choose_prototype0(n)) -#define rb_define_singleton_method_choose_prototypem2(n) rb_define_method_if_constexpr((n)==-2,rb_define_singleton_methodm2,rb_define_singleton_method_choose_prototypem1(n)) -#define rb_define_singleton_method_choose_prototypem3(n, f) rb_define_method_if_constexpr(rb_f_notimplement_p(f),rb_define_singleton_methodm3,rb_define_singleton_method_choose_prototypem2(n)) -#define rb_define_singleton_method(klass, mid, func, arity) rb_define_singleton_method_choose_prototypem3((arity),(func))((klass),(mid),(func),(arity)); -#endif - -#endif - -#if defined(__cplusplus) -#if 0 -{ /* satisfy cc-mode */ -#endif -} /* extern "C++" { */ #endif #endif /* RUBY_INTERN_H */ diff --git a/include/ruby/io.h b/include/ruby/io.h index 152f4ef763..60d6f6d32e 100644 --- a/include/ruby/io.h +++ b/include/ruby/io.h @@ -12,10 +12,6 @@ #ifndef RUBY_IO_H #define RUBY_IO_H 1 -#ifdef RUBY_INTERNAL_H -#error "Include this file before internal.h" -#endif - #if defined(__cplusplus) extern "C" { #if 0 @@ -24,6 +20,7 @@ extern "C" { #endif #include <stdio.h> +#include <errno.h> #include "ruby/encoding.h" #if defined(HAVE_STDIO_EXT_H) @@ -31,7 +28,6 @@ extern "C" { #endif #include "ruby/config.h" -#include <errno.h> #if defined(HAVE_POLL) # ifdef _AIX # define reqevents events @@ -101,8 +97,6 @@ typedef struct rb_io_t { VALUE write_lock; } rb_io_t; -typedef struct rb_io_enc_t rb_io_enc_t; - #define HAVE_RB_IO_T 1 #define FMODE_READABLE 0x00000001 @@ -115,7 +109,6 @@ typedef struct rb_io_enc_t rb_io_enc_t; #define FMODE_APPEND 0x00000040 #define FMODE_CREATE 0x00000080 /* #define FMODE_NOREVLOOKUP 0x00000100 */ -#define FMODE_EXCL 0x00000400 #define FMODE_TRUNC 0x00000800 #define FMODE_TEXTMODE 0x00001000 /* #define FMODE_PREP 0x00010000 */ @@ -155,7 +148,6 @@ 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); -void rb_io_extract_modeenc(VALUE *vmode_p, VALUE *vperm_p, VALUE opthash, int *oflags_p, int *fmode_p, rb_io_enc_t *convconfig_p); ssize_t rb_io_bufwrite(VALUE io, const void *buf, size_t size); /* compatibility for ruby 1.8 and older */ diff --git a/include/ruby/missing.h b/include/ruby/missing.h index 03657042ce..4b88c9ea07 100644 --- a/include/ruby/missing.h +++ b/include/ruby/missing.h @@ -136,7 +136,7 @@ RUBY_EXTERN double lgamma_r(double, int *); RUBY_EXTERN double cbrt(double); #endif -#if !defined(INFINITY) || !defined(NAN) +#if !defined(HAVE_INFINITY) || !defined(HAVE_NAN) union bytesequence4_or_float { unsigned char bytesequence[4]; float float_value; @@ -147,18 +147,12 @@ union bytesequence4_or_float { /** @internal */ RUBY_EXTERN const union bytesequence4_or_float rb_infinity; # define INFINITY (rb_infinity.float_value) -# define USE_RB_INFINITY 1 #endif #ifndef NAN /** @internal */ RUBY_EXTERN const union bytesequence4_or_float rb_nan; # define NAN (rb_nan.float_value) -# define USE_RB_NAN 1 -#endif - -#ifndef HUGE_VAL -# define HUGE_VAL ((double)INFINITY) #endif #ifndef isinf @@ -193,10 +187,6 @@ RUBY_EXTERN int isnan(double); # endif #endif -#ifndef HAVE_NAN -RUBY_EXTERN double nan(const char *); -#endif - #ifndef HAVE_NEXTAFTER RUBY_EXTERN double nextafter(double x, double y); #endif diff --git a/include/ruby/onigmo.h b/include/ruby/onigmo.h index 6187b37dc3..385f2d6a8b 100644 --- a/include/ruby/onigmo.h +++ b/include/ruby/onigmo.h @@ -434,7 +434,7 @@ int onigenc_str_bytelen_null(OnigEncoding enc, const OnigUChar* p); /* PART: regular expression */ /* config parameters */ -#define ONIG_NREGION 4 +#define ONIG_NREGION 10 #define ONIG_MAX_CAPTURE_GROUP_NUM 32767 #define ONIG_MAX_BACKREF_NUM 1000 #define ONIG_MAX_REPEAT_NUM 100000 @@ -701,7 +701,6 @@ ONIG_EXTERN const OnigSyntaxType* OnigDefaultSyntax; #define ONIG_IS_CAPTURE_HISTORY_GROUP(r, i) \ ((i) <= ONIG_MAX_CAPTURE_HISTORY_GROUP && (r)->list && (r)->list[i]) -#ifdef USE_CAPTURE_HISTORY typedef struct OnigCaptureTreeNodeStruct { int group; /* group number */ OnigPosition beg; @@ -710,7 +709,6 @@ typedef struct OnigCaptureTreeNodeStruct { int num_childs; struct OnigCaptureTreeNodeStruct** childs; } OnigCaptureTreeNode; -#endif /* match result region type */ struct re_registers { @@ -718,10 +716,8 @@ struct re_registers { int num_regs; OnigPosition* beg; OnigPosition* end; -#ifdef USE_CAPTURE_HISTORY /* extended */ OnigCaptureTreeNode* history_root; /* capture history tree root */ -#endif }; /* capture tree traverse */ @@ -870,10 +866,8 @@ ONIG_EXTERN int onig_number_of_captures(const OnigRegexType *reg); ONIG_EXTERN int onig_number_of_capture_histories(const OnigRegexType *reg); -#ifdef USE_CAPTURE_HISTORY ONIG_EXTERN OnigCaptureTreeNode* onig_get_capture_tree(OnigRegion* region); -#endif ONIG_EXTERN int onig_capture_tree_traverse(OnigRegion* region, int at, int(*callback_func)(int,OnigPosition,OnigPosition,int,int,void*), void* arg); ONIG_EXTERN diff --git a/include/ruby/re.h b/include/ruby/re.h index 7102c7ace4..166f254aa5 100644 --- a/include/ruby/re.h +++ b/include/ruby/re.h @@ -36,8 +36,9 @@ struct rmatch_offset { struct rmatch { struct re_registers regs; - struct rmatch_offset *char_offset; + int char_offset_updated; int char_offset_num_allocated; + struct rmatch_offset *char_offset; }; struct RMatch { diff --git a/include/ruby/ruby.h b/include/ruby/ruby.h index 1ce73d5559..56b773b380 100644 --- a/include/ruby/ruby.h +++ b/include/ruby/ruby.h @@ -27,14 +27,6 @@ extern "C" { #endif #include "defines.h" -#include "ruby/assert.h" - -/* For MinGW, we need __declspec(dllimport) for RUBY_EXTERN on MJIT. - mswin's RUBY_EXTERN already has that. See also: win32/Makefile.sub */ -#if defined(MJIT_HEADER) && defined(_WIN32) && defined(__GNUC__) -# undef RUBY_EXTERN -# define RUBY_EXTERN extern __declspec(dllimport) -#endif #if defined(__cplusplus) /* __builtin_choose_expr and __builtin_types_compatible aren't available @@ -52,13 +44,6 @@ extern "C" { # define ASSUME(x) ((void)(x)) # endif #endif -#ifndef UNREACHABLE_RETURN -# ifdef UNREACHABLE -# define UNREACHABLE_RETURN(val) UNREACHABLE -# else -# define UNREACHABLE_RETURN(val) return (val) -# endif -#endif #ifndef UNREACHABLE # define UNREACHABLE ((void)0) /* unreachable */ #endif @@ -128,26 +113,12 @@ typedef char ruby_check_sizeof_voidp[SIZEOF_VOIDP == sizeof(void*) ? 1 : -1]; #ifndef PRI_LONG_PREFIX #define PRI_LONG_PREFIX "l" #endif -#ifndef PRI_SHORT_PREFIX -#define PRI_SHORT_PREFIX "h" -#endif -#ifndef PRI_64_PREFIX #if SIZEOF_LONG == 8 #define PRI_64_PREFIX PRI_LONG_PREFIX #elif SIZEOF_LONG_LONG == 8 #define PRI_64_PREFIX PRI_LL_PREFIX #endif -#endif - -#ifndef PRIdPTR -#define PRIdPTR PRI_PTR_PREFIX"d" -#define PRIiPTR PRI_PTR_PREFIX"i" -#define PRIoPTR PRI_PTR_PREFIX"o" -#define PRIuPTR PRI_PTR_PREFIX"u" -#define PRIxPTR PRI_PTR_PREFIX"x" -#define PRIXPTR PRI_PTR_PREFIX"X" -#endif #define RUBY_PRI_VALUE_MARK "\v" #if defined PRIdPTR && !defined PRI_VALUE_PREFIX @@ -264,10 +235,10 @@ typedef char ruby_check_sizeof_voidp[SIZEOF_VOIDP == sizeof(void*) ? 1 : -1]; #define RB_LONG2FIX(i) RB_INT2FIX(i) #define LONG2FIX(i) RB_INT2FIX(i) #define rb_fix_new(v) RB_INT2FIX(v) -VALUE rb_int2inum(intptr_t); +VALUE rb_int2inum(SIGNED_VALUE); #define rb_int_new(v) rb_int2inum(v) -VALUE rb_uint2inum(uintptr_t); +VALUE rb_uint2inum(VALUE); #define rb_uint_new(v) rb_uint2inum(v) @@ -513,7 +484,6 @@ enum ruby_value_type { RUBY_T_NODE = 0x1b, RUBY_T_ICLASS = 0x1c, RUBY_T_ZOMBIE = 0x1d, - RUBY_T_MOVED = 0x1e, RUBY_T_MASK = 0x1f }; @@ -544,7 +514,6 @@ enum ruby_value_type { #define T_UNDEF RUBY_T_UNDEF #define T_NODE RUBY_T_NODE #define T_ZOMBIE RUBY_T_ZOMBIE -#define T_MOVED RUBY_T_MOVED #define T_MASK RUBY_T_MASK #define RB_BUILTIN_TYPE(x) (int)(((struct RBasic*)(x))->flags & RUBY_T_MASK) @@ -604,18 +573,21 @@ char *rb_string_value_cstr(volatile VALUE*); #define StringValueCStr(v) rb_string_value_cstr(&(v)) void rb_check_safe_obj(VALUE); -#define SafeStringValue(v) StringValue(v) +#define SafeStringValue(v) do {\ + StringValue(v);\ + rb_check_safe_obj(v);\ +} while (0) #if GCC_VERSION_SINCE(4,4,0) -void rb_check_safe_str(VALUE) __attribute__((error("rb_check_safe_str() and Check_SafeStr() are obsolete; use StringValue() instead"))); +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 StringValue() instead">] -# define Check_SafeStr(v) [<"Check_SafeStr() is obsolete; use StringValue() instead">] +# define rb_check_safe_str(x) [<"rb_check_safe_str() is obsolete; use SafeStringValue() instead">] +# define Check_SafeStr(v) [<"Check_SafeStr() is obsolete; use SafeStringValue() instead">] #endif VALUE rb_str_export(VALUE); #define ExportStringValue(v) do {\ - StringValue(v);\ + SafeStringValue(v);\ (v) = rb_str_export(v);\ } while (0) VALUE rb_str_export_locale(VALUE); @@ -624,9 +596,8 @@ VALUE rb_get_path(VALUE); #define FilePathValue(v) (RB_GC_GUARD(v) = rb_get_path(v)) VALUE rb_get_path_no_checksafe(VALUE); -#define FilePathStringValue(v) ((v) = rb_get_path(v)) +#define FilePathStringValue(v) ((v) = rb_get_path_no_checksafe(v)) -/* Remove in 3.0 */ #define RUBY_SAFE_LEVEL_MAX 1 void rb_secure(int); int rb_safe_level(void); @@ -773,8 +744,8 @@ rb_num2ll_inline(VALUE x) double rb_num2dbl(VALUE); #define NUM2DBL(x) rb_num2dbl((VALUE)(x)) -VALUE rb_uint2big(uintptr_t); -VALUE rb_int2big(intptr_t); +VALUE rb_uint2big(VALUE); +VALUE rb_int2big(SIGNED_VALUE); VALUE rb_newobj(void); VALUE rb_newobj_of(VALUE, VALUE); @@ -846,7 +817,6 @@ enum ruby_fl_type { RUBY_FL_FINALIZE = (1<<7), RUBY_FL_TAINT = (1<<8), RUBY_FL_UNTRUSTED = RUBY_FL_TAINT, - RUBY_FL_SEEN_OBJ_ID = (1<<9), RUBY_FL_EXIVAR = (1<<10), RUBY_FL_FREEZE = (1<<11), @@ -883,10 +853,14 @@ enum ruby_fl_type { RUBY_FL_SINGLETON = RUBY_FL_USER0 }; -struct RUBY_ALIGNAS(SIZEOF_VALUE) RBasic { +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 */ @@ -905,15 +879,10 @@ VALUE rb_obj_reveal(VALUE obj, VALUE klass); /* do not use this API to change kl #define RBASIC_CLASS(obj) (RBASIC(obj)->klass) -#define RVALUE_EMBED_LEN_MAX RVALUE_EMBED_LEN_MAX -enum ruby_rvalue_flags { - RVALUE_EMBED_LEN_MAX = 3, -}; - #define ROBJECT_EMBED_LEN_MAX ROBJECT_EMBED_LEN_MAX #define ROBJECT_EMBED ROBJECT_EMBED enum ruby_robject_flags { - ROBJECT_EMBED_LEN_MAX = RVALUE_EMBED_LEN_MAX, + ROBJECT_EMBED_LEN_MAX = 3, ROBJECT_EMBED = RUBY_FL_USER1, ROBJECT_ENUM_END @@ -979,12 +948,11 @@ enum ruby_rstring_flags { RSTRING_EMBED_LEN_MASK = (RUBY_FL_USER2|RUBY_FL_USER3|RUBY_FL_USER4| RUBY_FL_USER5|RUBY_FL_USER6), RSTRING_EMBED_LEN_SHIFT = (RUBY_FL_USHIFT+2), - RSTRING_EMBED_LEN_MAX = (int)((sizeof(VALUE)*RVALUE_EMBED_LEN_MAX)/sizeof(char)-1), + RSTRING_EMBED_LEN_MAX = (int)((sizeof(VALUE)*3)/sizeof(char)-1), RSTRING_FSTR = RUBY_FL_USER17, RSTRING_ENUM_END }; - struct RString { struct RBasic basic; union { @@ -1020,31 +988,19 @@ struct RString { ((ptrvar) = RSTRING(str)->as.ary, (lenvar) = RSTRING_EMBED_LEN(str)) : \ ((ptrvar) = RSTRING(str)->as.heap.ptr, (lenvar) = RSTRING(str)->as.heap.len)) -#ifndef USE_TRANSIENT_HEAP -#define USE_TRANSIENT_HEAP 1 -#endif - enum ruby_rarray_flags { - RARRAY_EMBED_LEN_MAX = RVALUE_EMBED_LEN_MAX, + RARRAY_EMBED_LEN_MAX = 3, RARRAY_EMBED_FLAG = RUBY_FL_USER1, /* RUBY_FL_USER2 is for ELTS_SHARED */ RARRAY_EMBED_LEN_MASK = (RUBY_FL_USER4|RUBY_FL_USER3), RARRAY_EMBED_LEN_SHIFT = (RUBY_FL_USHIFT+3), -#if USE_TRANSIENT_HEAP - RARRAY_TRANSIENT_FLAG = RUBY_FL_USER13, -#define RARRAY_TRANSIENT_FLAG RARRAY_TRANSIENT_FLAG -#else -#define RARRAY_TRANSIENT_FLAG 0 -#endif - RARRAY_ENUM_END }; #define RARRAY_EMBED_FLAG (VALUE)RARRAY_EMBED_FLAG #define RARRAY_EMBED_LEN_MASK (VALUE)RARRAY_EMBED_LEN_MASK #define RARRAY_EMBED_LEN_MAX RARRAY_EMBED_LEN_MAX #define RARRAY_EMBED_LEN_SHIFT RARRAY_EMBED_LEN_SHIFT - struct RArray { struct RBasic basic; union { @@ -1052,12 +1008,7 @@ struct RArray { long len; union { long capa; -#if defined(__clang__) /* <- clang++ is sane */ || \ - !defined(__cplusplus) /* <- C99 is sane */ || \ - (__cplusplus > 199711L) /* <- C++11 is sane */ - const -#endif - VALUE shared_root; + VALUE shared; } aux; const VALUE *ptr; } heap; @@ -1070,26 +1021,9 @@ struct RArray { #define RARRAY_LEN(a) rb_array_len(a) #define RARRAY_LENINT(ary) rb_long2int(RARRAY_LEN(ary)) #define RARRAY_CONST_PTR(a) rb_array_const_ptr(a) -#define RARRAY_CONST_PTR_TRANSIENT(a) rb_array_const_ptr_transient(a) -#if USE_TRANSIENT_HEAP -#define RARRAY_TRANSIENT_P(ary) FL_TEST_RAW((ary), RARRAY_TRANSIENT_FLAG) -#else -#define RARRAY_TRANSIENT_P(ary) 0 -#endif - -#define RARRAY_PTR_USE_START_TRANSIENT(a) rb_array_ptr_use_start(a, 1) -#define RARRAY_PTR_USE_END_TRANSIENT(a) rb_array_ptr_use_end(a, 1) - -#define RARRAY_PTR_USE_TRANSIENT(ary, ptr_name, expr) do { \ - const VALUE _ary = (ary); \ - VALUE *ptr_name = (VALUE *)RARRAY_PTR_USE_START_TRANSIENT(_ary); \ - expr; \ - RARRAY_PTR_USE_END_TRANSIENT(_ary); \ -} while (0) - -#define RARRAY_PTR_USE_START(a) rb_array_ptr_use_start(a, 0) -#define RARRAY_PTR_USE_END(a) rb_array_ptr_use_end(a, 0) +#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); \ @@ -1098,13 +1032,12 @@ struct RArray { RARRAY_PTR_USE_END(_ary); \ } while (0) -#define RARRAY_AREF(a, i) (RARRAY_CONST_PTR_TRANSIENT(a)[i]) +#define RARRAY_AREF(a, i) (RARRAY_CONST_PTR(a)[i]) #define RARRAY_ASET(a, i, v) do { \ const VALUE _ary = (a); \ - const VALUE _v = (v); \ - VALUE *ptr = (VALUE *)RARRAY_PTR_USE_START_TRANSIENT(_ary); \ - RB_OBJ_WRITE(_ary, &ptr[i], _v); \ - RARRAY_PTR_USE_END_TRANSIENT(_ary); \ + VALUE *ptr = (VALUE *)RARRAY_PTR_USE_START(_ary); \ + RB_OBJ_WRITE(_ary, &ptr[i], (v)); \ + RARRAY_PTR_USE_END(_ary); \ } while (0) #define RARRAY_PTR(a) ((VALUE *)RARRAY_CONST_PTR(RB_OBJ_WB_UNPROTECT_FOR(ARRAY, a))) @@ -1121,13 +1054,11 @@ struct RRegexp { #define RREGEXP_SRC_LEN(r) RSTRING_LEN(RREGEXP(r)->src) #define RREGEXP_SRC_END(r) RSTRING_END(RREGEXP(r)->src) -/* RHash is defined at internal.h */ -size_t rb_hash_size_num(VALUE hash); - -#define RHASH_TBL(h) rb_hash_tbl(h, __FILE__, __LINE__) +/* 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) rb_hash_size_num(h) +#define RHASH_SIZE(h) NUM2SIZET(rb_hash_size(h)) #define RHASH_EMPTY_P(h) (RHASH_SIZE(h) == 0) #define RHASH_SET_IFNONE(h, ifnone) rb_hash_set_ifnone((VALUE)h, ifnone) @@ -1136,6 +1067,9 @@ struct RFile { 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 RData { struct RBasic basic; void (*dmark)(void*); @@ -1151,8 +1085,7 @@ struct rb_data_type_struct { void (*dmark)(void*); void (*dfree)(void*); size_t (*dsize)(const void *); - void (*dcompact)(void*); - void *reserved[1]; /* For future extension. + void *reserved[2]; /* For future extension. This array *must* be filled with ZERO. */ } function; const rb_data_type_t *parent; @@ -1263,7 +1196,6 @@ int rb_big_sign(VALUE); #define RBIGNUM_NEGATIVE_P(b) (RBIGNUM_SIGN(b)==0) #define R_CAST(st) (struct st*) -#define RMOVED(obj) (R_CAST(RMoved)(obj)) #define RBASIC(obj) (R_CAST(RBasic)(obj)) #define ROBJECT(obj) (R_CAST(RObject)(obj)) #define RCLASS(obj) (R_CAST(RClass)(obj)) @@ -1282,7 +1214,6 @@ int rb_big_sign(VALUE); #define FL_FINALIZE ((VALUE)RUBY_FL_FINALIZE) #define FL_TAINT ((VALUE)RUBY_FL_TAINT) #define FL_UNTRUSTED ((VALUE)RUBY_FL_UNTRUSTED) -#define FL_SEEN_OBJ_ID ((VALUE)RUBY_FL_SEEN_OBJ_ID) #define FL_EXIVAR ((VALUE)RUBY_FL_EXIVAR) #define FL_FREEZE ((VALUE)RUBY_FL_FREEZE) @@ -1307,7 +1238,7 @@ int rb_big_sign(VALUE); #define FL_USER16 ((VALUE)RUBY_FL_USER16) #define FL_USER17 ((VALUE)RUBY_FL_USER17) #define FL_USER18 ((VALUE)RUBY_FL_USER18) -#define FL_USER19 ((VALUE)(unsigned int)RUBY_FL_USER19) +#define FL_USER19 ((VALUE)RUBY_FL_USER19) #define RB_SPECIAL_CONST_P(x) (RB_IMMEDIATE_P(x) || !RB_TEST(x)) #define SPECIAL_CONST_P(x) RB_SPECIAL_CONST_P(x) @@ -1643,7 +1574,6 @@ rb_num2char_inline(VALUE x) #define LONG2NUM(x) RB_LONG2NUM(x) #define ULONG2NUM(x) RB_ULONG2NUM(x) -#define USHORT2NUM(x) RB_INT2FIX(x) #define NUM2CHR(x) RB_NUM2CHR(x) #define CHR2FIX(x) RB_CHR2FIX(x) @@ -1666,23 +1596,7 @@ rb_num2char_inline(VALUE x) #define ZALLOC(type) RB_ZALLOC(type) #define REALLOC_N(var,type,n) RB_REALLOC_N(var,type,n) -#if GCC_VERSION_BEFORE(4,9,5) -/* GCC 4.9.2 reportedly has this feature and is broken. - * The function is not officially documented below. - * Seems we should not use it. - * https://gcc.gnu.org/onlinedocs/gcc-4.9.4/gcc/Other-Builtins.html#Other-Builtins */ -# undef HAVE_BUILTIN___BUILTIN_ALLOCA_WITH_ALIGN -#endif - -#if defined(HAVE_BUILTIN___BUILTIN_ALLOCA_WITH_ALIGN) && defined(RUBY_ALIGNOF) -/* I don't know why but __builtin_alloca_with_align's second argument - takes bits rather than bytes. */ -#define ALLOCA_N(type, n) \ - (type*)__builtin_alloca_with_align((sizeof(type)*(n)), \ - RUBY_ALIGNOF(type) * CHAR_BIT) -#else #define ALLOCA_N(type,n) ((type*)alloca(sizeof(type)*(n))) -#endif void *rb_alloc_tmp_buffer(volatile VALUE *store, long len) RUBY_ATTR_ALLOC_SIZE((2)); void *rb_alloc_tmp_buffer_with_count(volatile VALUE *store, size_t len,size_t count) RUBY_ATTR_ALLOC_SIZE((2,3)); @@ -1736,11 +1650,11 @@ rb_alloc_tmp_buffer2(volatile VALUE *store, long count, size_t elsize) #else # define RUBY_ALLOCV_LIMIT 1024 # define RB_ALLOCV(v, n) ((n) < RUBY_ALLOCV_LIMIT ? \ - ((v) = 0, alloca(n)) : \ + (RB_GC_GUARD(v) = 0, alloca(n)) : \ rb_alloc_tmp_buffer(&(v), (n))) # define RB_ALLOCV_N(type, v, n) \ ((type*)(((size_t)(n) < RUBY_ALLOCV_LIMIT / sizeof(type)) ? \ - ((v) = 0, alloca((size_t)(n) * sizeof(type))) : \ + (RB_GC_GUARD(v) = 0, alloca((size_t)(n) * sizeof(type))) : \ rb_alloc_tmp_buffer2(&(v), (long)(n), sizeof(type)))) #endif #define RB_ALLOCV_END(v) rb_free_tmp_buffer(&(v)) @@ -1753,15 +1667,6 @@ rb_alloc_tmp_buffer2(volatile VALUE *store, long count, size_t elsize) #define MEMCPY(p1,p2,type,n) memcpy((p1), (p2), sizeof(type)*(size_t)(n)) #define MEMMOVE(p1,p2,type,n) memmove((p1), (p2), sizeof(type)*(size_t)(n)) #define MEMCMP(p1,p2,type,n) memcmp((p1), (p2), sizeof(type)*(size_t)(n)) -#ifdef __GLIBC__ -static inline void * -ruby_nonempty_memcpy(void *dest, const void *src, size_t n) -{ - /* if nothing to be copied, src may be NULL */ - return (n ? memcpy(dest, src, n) : dest); -} -#define memcpy(p1,p2,n) ruby_nonempty_memcpy(p1, p2, n) -#endif void rb_obj_infect(VALUE victim, VALUE carrier); @@ -1779,31 +1684,34 @@ void rb_include_module(VALUE,VALUE); void rb_extend_object(VALUE,VALUE); void rb_prepend_module(VALUE,VALUE); -typedef VALUE rb_gvar_getter_t(ID id, VALUE *data); -typedef void rb_gvar_setter_t(VALUE val, ID id, VALUE *data); +struct rb_global_variable; + +typedef VALUE rb_gvar_getter_t(ID id, void *data, struct rb_global_variable *gvar); +typedef void rb_gvar_setter_t(VALUE val, ID id, void *data, struct rb_global_variable *gvar); typedef void rb_gvar_marker_t(VALUE *var); -rb_gvar_getter_t rb_gvar_undef_getter; -rb_gvar_setter_t rb_gvar_undef_setter; -rb_gvar_marker_t rb_gvar_undef_marker; +VALUE rb_gvar_undef_getter(ID id, void *data, struct rb_global_variable *gvar); +void rb_gvar_undef_setter(VALUE val, ID id, void *data, struct rb_global_variable *gvar); +void rb_gvar_undef_marker(VALUE *var); -rb_gvar_getter_t rb_gvar_val_getter; -rb_gvar_setter_t rb_gvar_val_setter; -rb_gvar_marker_t rb_gvar_val_marker; +VALUE rb_gvar_val_getter(ID id, void *data, struct rb_global_variable *gvar); +void rb_gvar_val_setter(VALUE val, ID id, void *data, struct rb_global_variable *gvar); +void rb_gvar_val_marker(VALUE *var); -rb_gvar_getter_t rb_gvar_var_getter; -rb_gvar_setter_t rb_gvar_var_setter; -rb_gvar_marker_t rb_gvar_var_marker; +VALUE rb_gvar_var_getter(ID id, void *data, struct rb_global_variable *gvar); +void rb_gvar_var_setter(VALUE val, ID id, void *data, struct rb_global_variable *gvar); +void rb_gvar_var_marker(VALUE *var); -NORETURN(rb_gvar_setter_t rb_gvar_readonly_setter); +NORETURN(void rb_gvar_readonly_setter(VALUE val, ID id, void *data, struct rb_global_variable *gvar)); void rb_define_variable(const char*,VALUE*); -void rb_define_virtual_variable(const char*,rb_gvar_getter_t*,rb_gvar_setter_t*); -void rb_define_hooked_variable(const char*,VALUE*,rb_gvar_getter_t*,rb_gvar_setter_t*); +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_const(VALUE,const char*,VALUE); void rb_define_global_const(const char*,VALUE); +#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); @@ -1839,7 +1747,7 @@ VALUE rb_check_symbol(volatile VALUE *namep); do RUBY_CONST_ID_CACHE((var) =, (str)) while (0) #define CONST_ID_CACHE(result, str) RUBY_CONST_ID_CACHE(result, str) #define CONST_ID(var, str) RUBY_CONST_ID(var, str) -#if defined(HAVE_BUILTIN___BUILTIN_CONSTANT_P) && defined(HAVE_STMT_AND_DECL_IN_EXPR) +#ifdef __GNUC__ /* __builtin_constant_p and statement expression is available * since gcc-2.7.2.3 at least. */ #define rb_intern(str) \ @@ -1889,23 +1797,13 @@ 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_kw(VALUE, ID, int, const VALUE*, int); VALUE rb_funcallv_public(VALUE, ID, int, const VALUE*); -VALUE rb_funcallv_public_kw(VALUE, ID, int, const VALUE*, int); #define rb_funcall2 rb_funcallv #define rb_funcall3 rb_funcallv_public VALUE rb_funcall_passing_block(VALUE, ID, int, const VALUE*); -VALUE rb_funcall_passing_block_kw(VALUE, ID, int, const VALUE*, int); VALUE rb_funcall_with_block(VALUE, ID, int, const VALUE*, VALUE); -VALUE rb_funcall_with_block_kw(VALUE, ID, int, const VALUE*, VALUE, int); int rb_scan_args(int, const VALUE*, const char*, ...); -#define RB_SCAN_ARGS_PASS_CALLED_KEYWORDS 0 -#define RB_SCAN_ARGS_KEYWORDS 1 -#define RB_SCAN_ARGS_EMPTY_KEYWORDS 2 /* Will be removed in 3.0 */ -#define RB_SCAN_ARGS_LAST_HASH_KEYWORDS 3 -int rb_scan_args_kw(int, int, const VALUE*, const char*, ...); VALUE rb_call_super(int, const VALUE*); -VALUE rb_call_super_kw(int, const VALUE*, int); 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); @@ -1932,7 +1830,7 @@ enum rb_io_wait_readwrite {RB_IO_WAIT_READABLE, RB_IO_WAIT_WRITABLE}; PRINTF_ARGS(NORETURN(void rb_raise(VALUE, const char*, ...)), 2, 3); PRINTF_ARGS(NORETURN(void rb_fatal(const char*, ...)), 1, 2); -COLDFUNC PRINTF_ARGS(NORETURN(void rb_bug(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)); @@ -1956,40 +1854,35 @@ PRINTF_ARGS(void rb_warning(const char*, ...), 1, 2); PRINTF_ARGS(void rb_compile_warning(const char *, int, const char*, ...), 3, 4); PRINTF_ARGS(void rb_sys_warning(const char*, ...), 1, 2); /* reports always */ -COLDFUNC PRINTF_ARGS(void rb_warn(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); -#define RB_BLOCK_CALL_FUNC_STRICT 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 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_values_kw(int n, const VALUE *argv, int kw_splat); VALUE rb_yield_splat(VALUE); -VALUE rb_yield_splat_kw(VALUE, int); -VALUE rb_yield_block(RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, callback_arg)); /* rb_block_call_func */ -#define RB_NO_KEYWORDS 0 -#define RB_PASS_KEYWORDS 1 -#define RB_PASS_EMPTY_KEYWORDS 2 /* Will be removed in 3.0 */ -#define RB_PASS_CALLED_KEYWORDS 3 -int rb_keyword_given_p(void); +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,rb_block_call_func_t,VALUE); +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_kw(VALUE,ID,int,const VALUE*,rb_block_call_func_t,VALUE,int); -VALUE rb_rescue(VALUE(*)(VALUE),VALUE,VALUE(*)(VALUE,VALUE),VALUE); -VALUE rb_rescue2(VALUE(*)(VALUE),VALUE,VALUE(*)(VALUE,VALUE),VALUE,...); -VALUE rb_vrescue2(VALUE(*)(VALUE),VALUE,VALUE(*)(VALUE,VALUE),VALUE,va_list); -VALUE rb_ensure(VALUE(*)(VALUE),VALUE,VALUE(*)(VALUE),VALUE); -VALUE rb_catch(const char*,rb_block_call_func_t,VALUE); -VALUE rb_catch_obj(VALUE,rb_block_call_func_t,VALUE); +VALUE rb_rescue(VALUE(*)(ANYARGS),VALUE,VALUE(*)(ANYARGS),VALUE); +VALUE rb_rescue2(VALUE(*)(ANYARGS),VALUE,VALUE(*)(ANYARGS),VALUE,...); +VALUE rb_ensure(VALUE(*)(ANYARGS),VALUE,VALUE(*)(ANYARGS),VALUE); +VALUE rb_catch(const char*,VALUE(*)(ANYARGS),VALUE); +VALUE rb_catch_obj(VALUE,VALUE(*)(ANYARGS),VALUE); NORETURN(void rb_throw(const char*,VALUE)); NORETURN(void rb_throw_obj(VALUE,VALUE)); @@ -2015,20 +1908,19 @@ RUBY_EXTERN VALUE rb_cBignum; RUBY_EXTERN VALUE rb_cBinding; RUBY_EXTERN VALUE rb_cClass; RUBY_EXTERN VALUE rb_cCont; -RUBY_EXTERN VALUE rb_cData; RUBY_EXTERN VALUE rb_cDir; +RUBY_EXTERN VALUE rb_cData; +RUBY_EXTERN VALUE rb_cFalseClass; RUBY_EXTERN VALUE rb_cEncoding; RUBY_EXTERN VALUE rb_cEnumerator; -RUBY_EXTERN VALUE rb_cFalseClass; RUBY_EXTERN VALUE rb_cFile; #ifndef RUBY_INTEGER_UNIFICATION RUBY_EXTERN VALUE rb_cFixnum; #endif -RUBY_EXTERN VALUE rb_cComplex; RUBY_EXTERN VALUE rb_cFloat; RUBY_EXTERN VALUE rb_cHash; -RUBY_EXTERN VALUE rb_cIO; RUBY_EXTERN VALUE rb_cInteger; +RUBY_EXTERN VALUE rb_cIO; RUBY_EXTERN VALUE rb_cMatch; RUBY_EXTERN VALUE rb_cMethod; RUBY_EXTERN VALUE rb_cModule; @@ -2039,6 +1931,7 @@ RUBY_EXTERN VALUE rb_cProc; RUBY_EXTERN VALUE rb_cRandom; RUBY_EXTERN VALUE rb_cRange; RUBY_EXTERN VALUE rb_cRational; +RUBY_EXTERN VALUE rb_cComplex; RUBY_EXTERN VALUE rb_cRegexp; RUBY_EXTERN VALUE rb_cStat; RUBY_EXTERN VALUE rb_cString; @@ -2078,7 +1971,6 @@ RUBY_EXTERN VALUE rb_eSysStackError; RUBY_EXTERN VALUE rb_eRegexpError; RUBY_EXTERN VALUE rb_eEncodingError; RUBY_EXTERN VALUE rb_eEncCompatError; -RUBY_EXTERN VALUE rb_eNoMatchingPatternError; RUBY_EXTERN VALUE rb_eScriptError; RUBY_EXTERN VALUE rb_eNameError; @@ -2178,56 +2070,13 @@ rb_array_len(VALUE a) # define FIX_CONST_VALUE_PTR(x) (x) #endif -/* internal function. do not use this function */ static inline const VALUE * -rb_array_const_ptr_transient(VALUE a) +rb_array_const_ptr(VALUE a) { return FIX_CONST_VALUE_PTR((RBASIC(a)->flags & RARRAY_EMBED_FLAG) ? RARRAY(a)->as.ary : RARRAY(a)->as.heap.ptr); } -/* internal function. do not use this function */ -static inline const VALUE * -rb_array_const_ptr(VALUE a) -{ -#if USE_TRANSIENT_HEAP - void rb_ary_detransient(VALUE a); - - if (RARRAY_TRANSIENT_P(a)) { - rb_ary_detransient(a); - } -#endif - return rb_array_const_ptr_transient(a); -} - -/* internal function. do not use this function */ -static inline VALUE * -rb_array_ptr_use_start(VALUE a, int allow_transient) -{ - VALUE *rb_ary_ptr_use_start(VALUE ary); - -#if USE_TRANSIENT_HEAP - if (!allow_transient) { - if (RARRAY_TRANSIENT_P(a)) { - void rb_ary_detransient(VALUE a); - rb_ary_detransient(a); - } - } -#endif - (void)allow_transient; - - return rb_ary_ptr_use_start(a); -} - -/* internal function. do not use this function */ -static inline void -rb_array_ptr_use_end(VALUE a, int allow_transient) -{ - void rb_ary_ptr_use_end(VALUE a); - rb_ary_ptr_use_end(a); - (void)allow_transient; -} - #if defined(EXTLIB) && defined(USE_DLN_A_OUT) /* hook for external modules */ static char *dln_libs_to_be_linked[] = { EXTLIB, 0 }; @@ -2255,7 +2104,6 @@ int ruby_native_thread_p(void); #define RUBY_EVENT_THREAD_BEGIN 0x0400 #define RUBY_EVENT_THREAD_END 0x0800 #define RUBY_EVENT_FIBER_SWITCH 0x1000 -#define RUBY_EVENT_SCRIPT_COMPILED 0x2000 #define RUBY_EVENT_TRACEPOINT_ALL 0xffff /* special events */ @@ -2311,9 +2159,6 @@ static inline int rb_toupper(int c) { return rb_islower(c) ? (c&0x5f) : c; } #define ISALPHA(c) rb_isalpha(c) #define ISDIGIT(c) rb_isdigit(c) #define ISXDIGIT(c) rb_isxdigit(c) -#define ISBLANK(c) rb_isblank(c) -#define ISCNTRL(c) rb_iscntrl(c) -#define ISPUNCT(c) rb_ispunct(c) #endif #define TOUPPER(c) rb_toupper(c) #define TOLOWER(c) rb_tolower(c) @@ -2331,70 +2176,74 @@ unsigned long ruby_strtoul(const char *str, char **endptr, int base); PRINTF_ARGS(int ruby_snprintf(char *str, size_t n, char const *fmt, ...), 3, 4); int ruby_vsnprintf(char *str, size_t n, char const *fmt, va_list ap); -/* -- Remove In 3.0, Only public for rb_scan_args optimized version -- */ -int rb_empty_keyword_given_p(void); - -#if defined(HAVE_BUILTIN___BUILTIN_CHOOSE_EXPR_CONSTANT_P) && defined(HAVE_VA_ARGS_MACRO) && defined(__OPTIMIZE__) +#if defined(HAVE_BUILTIN___BUILTIN_CHOOSE_EXPR_CONSTANT_P) && defined(__OPTIMIZE__) # define rb_scan_args(argc,argvp,fmt,...) \ __builtin_choose_expr(__builtin_constant_p(fmt), \ rb_scan_args0(argc,argvp,fmt,\ (sizeof((VALUE*[]){__VA_ARGS__})/sizeof(VALUE*)), \ ((VALUE*[]){__VA_ARGS__})), \ - rb_scan_args(argc,argvp,fmt,##__VA_ARGS__)) + rb_scan_args(argc,argvp,fmt,__VA_ARGS__)) # if HAVE_ATTRIBUTE_ERRORFUNC -ERRORFUNC(("bad scan arg format"), void rb_scan_args_bad_format(const char*)); -ERRORFUNC(("variable argument length doesn't match"), void rb_scan_args_length_mismatch(const char*,int)); +ERRORFUNC(("bad scan arg format"), int rb_scan_args_bad_format(const char*)); +ERRORFUNC(("variable argument length doesn't match"), int rb_scan_args_length_mismatch(const char*,int)); # else -# define rb_scan_args_bad_format(fmt) ((void)0) -# define rb_scan_args_length_mismatch(fmt, varc) ((void)0) +# define rb_scan_args_bad_format(fmt) 0 +# define rb_scan_args_length_mismatch(fmt, varc) 0 # endif # define rb_scan_args_isdigit(c) ((unsigned char)((c)-'0')<10) -# define rb_scan_args_count_end(fmt, ofs, vari) \ - (fmt[ofs] ? -1 : (vari)) +# define rb_scan_args_count_end(fmt, ofs, varc, vari) \ + ((vari)/(!fmt[ofs] || rb_scan_args_bad_format(fmt))) -# define rb_scan_args_count_block(fmt, ofs, vari) \ +# define rb_scan_args_count_block(fmt, ofs, varc, vari) \ (fmt[ofs]!='&' ? \ - rb_scan_args_count_end(fmt, ofs, vari) : \ - rb_scan_args_count_end(fmt, ofs+1, vari+1)) + rb_scan_args_count_end(fmt, ofs, varc, vari) : \ + rb_scan_args_count_end(fmt, ofs+1, varc, vari+1)) -# define rb_scan_args_count_hash(fmt, ofs, vari) \ +# define rb_scan_args_count_hash(fmt, ofs, varc, vari) \ (fmt[ofs]!=':' ? \ - rb_scan_args_count_block(fmt, ofs, vari) : \ - rb_scan_args_count_block(fmt, ofs+1, vari+1)) + rb_scan_args_count_block(fmt, ofs, varc, vari) : \ + rb_scan_args_count_block(fmt, ofs+1, varc, vari+1)) -# define rb_scan_args_count_trail(fmt, ofs, vari) \ +# define rb_scan_args_count_trail(fmt, ofs, varc, vari) \ (!rb_scan_args_isdigit(fmt[ofs]) ? \ - rb_scan_args_count_hash(fmt, ofs, vari) : \ - rb_scan_args_count_hash(fmt, ofs+1, vari+(fmt[ofs]-'0'))) + rb_scan_args_count_hash(fmt, ofs, varc, vari) : \ + rb_scan_args_count_hash(fmt, ofs+1, varc, vari+(fmt[ofs]-'0'))) -# define rb_scan_args_count_var(fmt, ofs, vari) \ +# define rb_scan_args_count_var(fmt, ofs, varc, vari) \ (fmt[ofs]!='*' ? \ - rb_scan_args_count_trail(fmt, ofs, vari) : \ - rb_scan_args_count_trail(fmt, ofs+1, vari+1)) + rb_scan_args_count_trail(fmt, ofs, varc, vari) : \ + rb_scan_args_count_trail(fmt, ofs+1, varc, vari+1)) -# define rb_scan_args_count_opt(fmt, ofs, vari) \ - (!rb_scan_args_isdigit(fmt[ofs]) ? \ - rb_scan_args_count_var(fmt, ofs, vari) : \ - rb_scan_args_count_var(fmt, ofs+1, vari+fmt[ofs]-'0')) +# define rb_scan_args_count_opt(fmt, ofs, varc, vari) \ + (!rb_scan_args_isdigit(fmt[1]) ? \ + rb_scan_args_count_var(fmt, ofs, varc, vari) : \ + rb_scan_args_count_var(fmt, ofs+1, varc, vari+fmt[ofs]-'0')) -# define rb_scan_args_count_lead(fmt, ofs, vari) \ - (!rb_scan_args_isdigit(fmt[ofs]) ? \ - rb_scan_args_count_var(fmt, ofs, vari) : \ - rb_scan_args_count_opt(fmt, ofs+1, vari+fmt[ofs]-'0')) +# define rb_scan_args_count(fmt, varc) \ + ((!rb_scan_args_isdigit(fmt[0]) ? \ + rb_scan_args_count_var(fmt, 0, varc, 0) : \ + rb_scan_args_count_opt(fmt, 1, varc, fmt[0]-'0')) \ + == (varc) || \ + rb_scan_args_length_mismatch(fmt, varc)) -# define rb_scan_args_count(fmt) rb_scan_args_count_lead(fmt, 0, 0) +# define rb_scan_args_verify_count(fmt, varc) \ + ((varc)/(rb_scan_args_count(fmt, varc))) -# if defined(__has_attribute) && __has_attribute(diagnose_if) -# define rb_scan_args_verify(fmt, varc) (void)0 +# ifdef __GNUC__ +# define rb_scan_args_verify(fmt, varc) \ + ({ \ + int verify; \ + _Pragma("GCC diagnostic push"); \ + _Pragma("GCC diagnostic ignored \"-Warray-bounds\""); \ + verify = rb_scan_args_verify_count(fmt, varc); \ + _Pragma("GCC diagnostic pop"); \ + verify; \ + }) # else # define rb_scan_args_verify(fmt, varc) \ - (sizeof(char[1-2*(rb_scan_args_count(fmt)<0)])!=1 ? \ - rb_scan_args_bad_format(fmt) : \ - sizeof(char[1-2*(rb_scan_args_count(fmt)!=(varc))])!=1 ? \ - rb_scan_args_length_mismatch(fmt, varc) : \ - (void)0) + rb_scan_args_verify_count(fmt, varc) # endif ALWAYS_INLINE(static int rb_scan_args_lead_p(const char *fmt)); @@ -2495,8 +2344,6 @@ rb_scan_args_end_idx(const char *fmt) } # endif -/* NOTE: Use `char *fmt` instead of `const char *fmt` because of clang's bug*/ -/* https://bugs.llvm.org/show_bug.cgi?id=38095 */ # define rb_scan_args0(argc, argv, fmt, varc, vars) \ rb_scan_args_set(argc, argv, \ rb_scan_args_n_lead(fmt), \ @@ -2505,101 +2352,45 @@ rb_scan_args_end_idx(const char *fmt) rb_scan_args_f_var(fmt), \ rb_scan_args_f_hash(fmt), \ rb_scan_args_f_block(fmt), \ - (rb_scan_args_verify(fmt, varc), vars), (char *)fmt, varc) + (rb_scan_args_verify(fmt, varc), vars)) ALWAYS_INLINE(static int rb_scan_args_set(int argc, const VALUE *argv, int n_lead, int n_opt, int n_trail, int f_var, int f_hash, int f_block, - VALUE *vars[], char *fmt, int varc)); - + VALUE *vars[])); inline int rb_scan_args_set(int argc, const VALUE *argv, int n_lead, int n_opt, int n_trail, int f_var, int f_hash, int f_block, - VALUE *vars[], RB_UNUSED_VAR(char *fmt), RB_UNUSED_VAR(int varc)) -# if defined(__has_attribute) && __has_attribute(diagnose_if) - __attribute__((diagnose_if(rb_scan_args_count(fmt)<0,"bad scan arg format","error"))) - __attribute__((diagnose_if(rb_scan_args_count(fmt)!=varc,"variable argument length doesn't match","error"))) -# endif + VALUE *vars[]) { int i, argi = 0, vari = 0, last_idx = -1; VALUE *var, hash = Qnil, last_hash = 0; const int n_mand = n_lead + n_trail; - int keyword_given = rb_keyword_given_p(); - int empty_keyword_given = 0; - VALUE tmp_buffer = 0; - - if (!keyword_given) { - empty_keyword_given = rb_empty_keyword_given_p(); - } /* capture an option hash - phase 1: pop */ - /* Ignore final positional hash if empty keywords given */ - if (argc > 0 && !(f_hash && empty_keyword_given)) { - VALUE last = argv[argc - 1]; - - if (f_hash && n_mand < argc) { - if (keyword_given) { - if (!RB_TYPE_P(last, T_HASH)) { - rb_warn("Keyword flag set when calling rb_scan_args, but last entry is not a hash"); - } - else { - hash = last; - } - } - else if (NIL_P(last)) { - /* For backwards compatibility, nil is taken as an empty - option hash only if it is not ambiguous; i.e. '*' is - not specified and arguments are given more than sufficient. - This will be removed in Ruby 3. */ - if (!f_var && n_mand + n_opt < argc) { - rb_warn("The last argument is nil, treating as empty keywords"); - argc--; - } - } - else { - hash = rb_check_hash_type(last); - } - - /* Ruby 3: Remove if branch, as it will not attempt to split hashes */ - if (!NIL_P(hash)) { - VALUE opts = rb_extract_keywords(&hash); - - if (!(last_hash = hash)) { - if (!keyword_given) { - /* Warn if treating positional as keyword, as in Ruby 3, - this will be an error */ - rb_warn("Using the last argument as keyword parameters is deprecated"); - } - argc--; - } - else { - /* Warn if splitting either positional hash to keywords or keywords - to positional hash, as in Ruby 3, no splitting will be done */ - rb_warn("The last argument is split into positional and keyword parameters"); - last_idx = argc - 1; - } - hash = opts ? opts : Qnil; - } - } - else if (f_hash && keyword_given && n_mand == argc) { - /* Warn if treating keywords as positional, as in Ruby 3, this will be an error */ - rb_warn("Passing the keyword argument as the last hash parameter is deprecated"); - } - } - if (f_hash && n_mand > 0 && n_mand == argc+1 && empty_keyword_given) { - VALUE *ptr = (VALUE *)rb_alloc_tmp_buffer2(&tmp_buffer, argc+1, sizeof(VALUE)); - memcpy(ptr, argv, sizeof(VALUE)*argc); - ptr[argc] = rb_hash_new(); - argc++; - *(&argv) = ptr; - rb_warn("Passing the keyword argument as the last hash parameter is deprecated"); + if (f_hash && n_mand < argc) { + VALUE last = argv[argc - 1]; + + if (RB_NIL_P(last)) { + /* nil is taken as an empty option hash only if it is not + ambiguous; i.e. '*' is not specified and arguments are + given more than sufficient */ + if (!f_var && n_mand + n_opt < argc) + argc--; + } + else { + hash = rb_check_hash_type(last); + if (!RB_NIL_P(hash)) { + VALUE opts = rb_extract_keywords(&hash); + if (!(last_hash = hash)) argc--; + else last_idx = argc - 1; + hash = opts ? opts : Qnil; + } + } } - - if (argc < n_mand) { - goto argc_error; - } + rb_check_arity(argc, n_mand, f_var ? UNLIMITED_ARGUMENTS : n_mand + n_opt); /* capture leading mandatory arguments */ for (i = n_lead; i-- > 0; ) { @@ -2657,18 +2448,11 @@ rb_scan_args_set(int argc, const VALUE *argv, } } - if (argi < argc) { - argc_error: - if (tmp_buffer) rb_free_tmp_buffer(&tmp_buffer); - rb_error_arity(argc, n_mand, f_var ? UNLIMITED_ARGUMENTS : n_mand + n_opt); - } - - if (tmp_buffer) rb_free_tmp_buffer(&tmp_buffer); return argc; } #endif -#if defined(__GNUC__) && defined(HAVE_VA_ARGS_MACRO) && defined(__OPTIMIZE__) +#if defined(__GNUC__) && defined(__OPTIMIZE__) # define rb_yield_values(argc, ...) \ __extension__({ \ const int rb_yield_values_argc = (argc); \ @@ -2686,7 +2470,7 @@ __extension__({ \ const VALUE rb_funcall_args[] = {__VA_ARGS__}; \ const int rb_funcall_nargs = \ (int)(sizeof(rb_funcall_args) / sizeof(VALUE)); \ - rb_funcallv(recv, mid, \ + rb_funcallv(recv, mid, \ rb_varargs_argc_check(rb_funcall_argc, rb_funcall_nargs), \ rb_funcall_nargs ? rb_funcall_args : NULL); \ }) @@ -2730,7 +2514,13 @@ void ruby_show_copyright(void); ruby_init_stack(&variable_in_this_stack_frame); /*! @} */ +#ifdef __ia64 +void ruby_init_stack(volatile VALUE*, void*); +#define ruby_init_stack(addr) ruby_init_stack((addr), rb_ia64_bsp()) +#else void ruby_init_stack(volatile VALUE*); +#endif +#define Init_stack(addr) ruby_init_stack(addr) int ruby_setup(void); int ruby_cleanup(volatile int); @@ -2767,105 +2557,5 @@ RUBY_SYMBOL_EXPORT_END { /* satisfy cc-mode */ #endif } /* extern "C" { */ -extern "C++" { #endif - -#ifdef RB_METHOD_DEFINITION_DECL - -RB_METHOD_DEFINITION_DECL(rb_define_method, (2,3), (VALUE klass, const char *name), (klass, name)) -#ifdef __cplusplus -#define rb_define_method(m, n, f, a) rb_define_method_tmpl<a>::define(m, n, f) -#else -#define rb_define_method_if_constexpr(x, t, f) __builtin_choose_expr(__builtin_choose_expr(__builtin_constant_p(x),(x),0),(t),(f)) -#define rb_define_method_choose_prototype15(n) rb_define_method_if_constexpr((n)==15,rb_define_method15,rb_define_methodm3) -#define rb_define_method_choose_prototype14(n) rb_define_method_if_constexpr((n)==14,rb_define_method14,rb_define_method_choose_prototype15(n)) -#define rb_define_method_choose_prototype13(n) rb_define_method_if_constexpr((n)==13,rb_define_method13,rb_define_method_choose_prototype14(n)) -#define rb_define_method_choose_prototype12(n) rb_define_method_if_constexpr((n)==12,rb_define_method12,rb_define_method_choose_prototype13(n)) -#define rb_define_method_choose_prototype11(n) rb_define_method_if_constexpr((n)==11,rb_define_method11,rb_define_method_choose_prototype12(n)) -#define rb_define_method_choose_prototype10(n) rb_define_method_if_constexpr((n)==10,rb_define_method10,rb_define_method_choose_prototype11(n)) -#define rb_define_method_choose_prototype9(n) rb_define_method_if_constexpr((n)== 9,rb_define_method9, rb_define_method_choose_prototype10(n)) -#define rb_define_method_choose_prototype8(n) rb_define_method_if_constexpr((n)== 8,rb_define_method8, rb_define_method_choose_prototype9(n)) -#define rb_define_method_choose_prototype7(n) rb_define_method_if_constexpr((n)== 7,rb_define_method7, rb_define_method_choose_prototype8(n)) -#define rb_define_method_choose_prototype6(n) rb_define_method_if_constexpr((n)== 6,rb_define_method6, rb_define_method_choose_prototype7(n)) -#define rb_define_method_choose_prototype5(n) rb_define_method_if_constexpr((n)== 5,rb_define_method5, rb_define_method_choose_prototype6(n)) -#define rb_define_method_choose_prototype4(n) rb_define_method_if_constexpr((n)== 4,rb_define_method4, rb_define_method_choose_prototype5(n)) -#define rb_define_method_choose_prototype3(n) rb_define_method_if_constexpr((n)== 3,rb_define_method3, rb_define_method_choose_prototype4(n)) -#define rb_define_method_choose_prototype2(n) rb_define_method_if_constexpr((n)== 2,rb_define_method2, rb_define_method_choose_prototype3(n)) -#define rb_define_method_choose_prototype1(n) rb_define_method_if_constexpr((n)== 1,rb_define_method1, rb_define_method_choose_prototype2(n)) -#define rb_define_method_choose_prototype0(n) rb_define_method_if_constexpr((n)== 0,rb_define_method0, rb_define_method_choose_prototype1(n)) -#define rb_define_method_choose_prototypem1(n) rb_define_method_if_constexpr((n)==-1,rb_define_methodm1,rb_define_method_choose_prototype0(n)) -#define rb_define_method_choose_prototypem2(n) rb_define_method_if_constexpr((n)==-2,rb_define_methodm2,rb_define_method_choose_prototypem1(n)) -#define rb_define_method_choose_prototypem3(n, f) rb_define_method_if_constexpr(rb_f_notimplement_p(f),rb_define_methodm3,rb_define_method_choose_prototypem2(n)) -#define rb_define_method(klass, mid, func, arity) rb_define_method_choose_prototypem3((arity),(func))((klass),(mid),(func),(arity)); -#endif - -RB_METHOD_DEFINITION_DECL(rb_define_module_function, (2,3), (VALUE klass, const char *name), (klass, name)) -#ifdef __cplusplus -#define rb_define_module_function(m, n, f, a) rb_define_module_function_tmpl<a>::define(m, n, f) -#else -#define rb_define_module_function_choose_prototype15(n) rb_define_method_if_constexpr((n)==15,rb_define_module_function15,rb_define_module_functionm3) -#define rb_define_module_function_choose_prototype14(n) rb_define_method_if_constexpr((n)==14,rb_define_module_function14,rb_define_module_function_choose_prototype15(n)) -#define rb_define_module_function_choose_prototype13(n) rb_define_method_if_constexpr((n)==13,rb_define_module_function13,rb_define_module_function_choose_prototype14(n)) -#define rb_define_module_function_choose_prototype12(n) rb_define_method_if_constexpr((n)==12,rb_define_module_function12,rb_define_module_function_choose_prototype13(n)) -#define rb_define_module_function_choose_prototype11(n) rb_define_method_if_constexpr((n)==11,rb_define_module_function11,rb_define_module_function_choose_prototype12(n)) -#define rb_define_module_function_choose_prototype10(n) rb_define_method_if_constexpr((n)==10,rb_define_module_function10,rb_define_module_function_choose_prototype11(n)) -#define rb_define_module_function_choose_prototype9(n) rb_define_method_if_constexpr((n)== 9,rb_define_module_function9, rb_define_module_function_choose_prototype10(n)) -#define rb_define_module_function_choose_prototype8(n) rb_define_method_if_constexpr((n)== 8,rb_define_module_function8, rb_define_module_function_choose_prototype9(n)) -#define rb_define_module_function_choose_prototype7(n) rb_define_method_if_constexpr((n)== 7,rb_define_module_function7, rb_define_module_function_choose_prototype8(n)) -#define rb_define_module_function_choose_prototype6(n) rb_define_method_if_constexpr((n)== 6,rb_define_module_function6, rb_define_module_function_choose_prototype7(n)) -#define rb_define_module_function_choose_prototype5(n) rb_define_method_if_constexpr((n)== 5,rb_define_module_function5, rb_define_module_function_choose_prototype6(n)) -#define rb_define_module_function_choose_prototype4(n) rb_define_method_if_constexpr((n)== 4,rb_define_module_function4, rb_define_module_function_choose_prototype5(n)) -#define rb_define_module_function_choose_prototype3(n) rb_define_method_if_constexpr((n)== 3,rb_define_module_function3, rb_define_module_function_choose_prototype4(n)) -#define rb_define_module_function_choose_prototype2(n) rb_define_method_if_constexpr((n)== 2,rb_define_module_function2, rb_define_module_function_choose_prototype3(n)) -#define rb_define_module_function_choose_prototype1(n) rb_define_method_if_constexpr((n)== 1,rb_define_module_function1, rb_define_module_function_choose_prototype2(n)) -#define rb_define_module_function_choose_prototype0(n) rb_define_method_if_constexpr((n)== 0,rb_define_module_function0, rb_define_module_function_choose_prototype1(n)) -#define rb_define_module_function_choose_prototypem1(n) rb_define_method_if_constexpr((n)==-1,rb_define_module_functionm1,rb_define_module_function_choose_prototype0(n)) -#define rb_define_module_function_choose_prototypem2(n) rb_define_method_if_constexpr((n)==-2,rb_define_module_functionm2,rb_define_module_function_choose_prototypem1(n)) -#define rb_define_module_function_choose_prototypem3(n, f) rb_define_method_if_constexpr(rb_f_notimplement_p(f),rb_define_module_functionm3,rb_define_module_function_choose_prototypem2(n)) -#define rb_define_module_function(klass, mid, func, arity) rb_define_module_function_choose_prototypem3((arity),(func))((klass),(mid),(func),(arity)); -#endif - -RB_METHOD_DEFINITION_DECL(rb_define_global_function, (1,2), (const char *name), (name)) -#ifdef __cplusplus -#define rb_define_global_function(n, f, a) rb_define_global_function_tmpl<a>::define(n, f) -#else -#define rb_define_global_function_choose_prototype15(n) rb_define_method_if_constexpr((n)==15,rb_define_global_function15,rb_define_global_functionm3) -#define rb_define_global_function_choose_prototype14(n) rb_define_method_if_constexpr((n)==14,rb_define_global_function14,rb_define_global_function_choose_prototype15(n)) -#define rb_define_global_function_choose_prototype13(n) rb_define_method_if_constexpr((n)==13,rb_define_global_function13,rb_define_global_function_choose_prototype14(n)) -#define rb_define_global_function_choose_prototype12(n) rb_define_method_if_constexpr((n)==12,rb_define_global_function12,rb_define_global_function_choose_prototype13(n)) -#define rb_define_global_function_choose_prototype11(n) rb_define_method_if_constexpr((n)==11,rb_define_global_function11,rb_define_global_function_choose_prototype12(n)) -#define rb_define_global_function_choose_prototype10(n) rb_define_method_if_constexpr((n)==10,rb_define_global_function10,rb_define_global_function_choose_prototype11(n)) -#define rb_define_global_function_choose_prototype9(n) rb_define_method_if_constexpr((n)== 9,rb_define_global_function9, rb_define_global_function_choose_prototype10(n)) -#define rb_define_global_function_choose_prototype8(n) rb_define_method_if_constexpr((n)== 8,rb_define_global_function8, rb_define_global_function_choose_prototype9(n)) -#define rb_define_global_function_choose_prototype7(n) rb_define_method_if_constexpr((n)== 7,rb_define_global_function7, rb_define_global_function_choose_prototype8(n)) -#define rb_define_global_function_choose_prototype6(n) rb_define_method_if_constexpr((n)== 6,rb_define_global_function6, rb_define_global_function_choose_prototype7(n)) -#define rb_define_global_function_choose_prototype5(n) rb_define_method_if_constexpr((n)== 5,rb_define_global_function5, rb_define_global_function_choose_prototype6(n)) -#define rb_define_global_function_choose_prototype4(n) rb_define_method_if_constexpr((n)== 4,rb_define_global_function4, rb_define_global_function_choose_prototype5(n)) -#define rb_define_global_function_choose_prototype3(n) rb_define_method_if_constexpr((n)== 3,rb_define_global_function3, rb_define_global_function_choose_prototype4(n)) -#define rb_define_global_function_choose_prototype2(n) rb_define_method_if_constexpr((n)== 2,rb_define_global_function2, rb_define_global_function_choose_prototype3(n)) -#define rb_define_global_function_choose_prototype1(n) rb_define_method_if_constexpr((n)== 1,rb_define_global_function1, rb_define_global_function_choose_prototype2(n)) -#define rb_define_global_function_choose_prototype0(n) rb_define_method_if_constexpr((n)== 0,rb_define_global_function0, rb_define_global_function_choose_prototype1(n)) -#define rb_define_global_function_choose_prototypem1(n) rb_define_method_if_constexpr((n)==-1,rb_define_global_functionm1,rb_define_global_function_choose_prototype0(n)) -#define rb_define_global_function_choose_prototypem2(n) rb_define_method_if_constexpr((n)==-2,rb_define_global_functionm2,rb_define_global_function_choose_prototypem1(n)) -#define rb_define_global_function_choose_prototypem3(n, f) rb_define_method_if_constexpr(rb_f_notimplement_p(f),rb_define_global_functionm3,rb_define_global_function_choose_prototypem2(n)) -#define rb_define_global_function(mid, func, arity) rb_define_global_function_choose_prototypem3((arity),(func))((mid),(func),(arity)); -#endif - -#endif - -#if defined(RUBY_DEVEL) && RUBY_DEVEL && (!defined(__cplusplus) || defined(RB_METHOD_DEFINITION_DECL)) -# define RUBY_METHOD_FUNC(func) (func) -#else -# define RUBY_METHOD_FUNC(func) ((VALUE (*)(ANYARGS))(func)) -#endif - -#ifdef __cplusplus -#include "backward/cxxanyargs.hpp" - -#if 0 -{ /* satisfy cc-mode */ -#endif -} /* extern "C++" { */ -#endif - #endif /* RUBY_RUBY_H */ diff --git a/include/ruby/st.h b/include/ruby/st.h index ea1637bd9f..47e14a3e2c 100644 --- a/include/ruby/st.h +++ b/include/ruby/st.h @@ -59,8 +59,8 @@ typedef char st_check_for_sizeof_st_index_t[SIZEOF_VOIDP == (int)sizeof(st_index #define SIZEOF_ST_INDEX_T SIZEOF_VOIDP struct st_hash_type { - int (*compare)(st_data_t, st_data_t); /* st_compare_func* */ - st_index_t (*hash)(st_data_t); /* st_hash_func* */ + int (*compare)(ANYARGS /*st_data_t, st_data_t*/); /* st_compare_func* */ + st_index_t (*hash)(ANYARGS /*st_data_t*/); /* st_hash_func* */ }; #define ST_INDEX_BITS (SIZEOF_ST_INDEX_T * CHAR_BIT) @@ -96,95 +96,53 @@ struct st_table { #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, ST_REPLACE}; - -st_table *rb_st_init_table(const struct st_hash_type *); -#define st_init_table rb_st_init_table -st_table *rb_st_init_table_with_size(const struct st_hash_type *, st_index_t); -#define st_init_table_with_size rb_st_init_table_with_size -st_table *rb_st_init_numtable(void); -#define st_init_numtable rb_st_init_numtable -st_table *rb_st_init_numtable_with_size(st_index_t); -#define st_init_numtable_with_size rb_st_init_numtable_with_size -st_table *rb_st_init_strtable(void); -#define st_init_strtable rb_st_init_strtable -st_table *rb_st_init_strtable_with_size(st_index_t); -#define st_init_strtable_with_size rb_st_init_strtable_with_size -st_table *rb_st_init_strcasetable(void); -#define st_init_strcasetable rb_st_init_strcasetable -st_table *rb_st_init_strcasetable_with_size(st_index_t); -#define st_init_strcasetable_with_size rb_st_init_strcasetable_with_size -int rb_st_delete(st_table *, st_data_t *, st_data_t *); /* returns 0:notfound 1:deleted */ -#define st_delete rb_st_delete -int rb_st_delete_safe(st_table *, st_data_t *, st_data_t *, st_data_t); -#define st_delete_safe rb_st_delete_safe -int rb_st_shift(st_table *, st_data_t *, st_data_t *); /* returns 0:notfound 1:deleted */ -#define st_shift rb_st_shift -int rb_st_insert(st_table *, st_data_t, st_data_t); -#define st_insert rb_st_insert -int rb_st_insert2(st_table *, st_data_t, st_data_t, st_data_t (*)(st_data_t)); -#define st_insert2 rb_st_insert2 -int rb_st_lookup(st_table *, st_data_t, st_data_t *); -#define st_lookup rb_st_lookup -int rb_st_get_key(st_table *, st_data_t, st_data_t *); -#define st_get_key rb_st_get_key +enum st_retval {ST_CONTINUE, ST_STOP, ST_DELETE, ST_CHECK}; + +st_table *st_init_table(const struct st_hash_type *); +st_table *st_init_table_with_size(const struct st_hash_type *, st_index_t); +st_table *st_init_numtable(void); +st_table *st_init_numtable_with_size(st_index_t); +st_table *st_init_strtable(void); +st_table *st_init_strtable_with_size(st_index_t); +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 rb_st_update(st_table *table, st_data_t key, st_update_callback_func *func, st_data_t arg); -#define st_update rb_st_update -typedef int st_foreach_callback_func(st_data_t, st_data_t, st_data_t); -typedef int st_foreach_check_callback_func(st_data_t, st_data_t, st_data_t, int); -int rb_st_foreach_with_replace(st_table *tab, st_foreach_check_callback_func *func, st_update_callback_func *replace, st_data_t arg); -#define st_foreach_with_replace rb_st_foreach_with_replace -int rb_st_foreach(st_table *, st_foreach_callback_func *, st_data_t); -#define st_foreach rb_st_foreach -int rb_st_foreach_check(st_table *, st_foreach_check_callback_func *, st_data_t, st_data_t); -#define st_foreach_check rb_st_foreach_check -st_index_t rb_st_keys(st_table *table, st_data_t *keys, st_index_t size); -#define st_keys rb_st_keys -st_index_t rb_st_keys_check(st_table *table, st_data_t *keys, st_index_t size, st_data_t never); -#define st_keys_check rb_st_keys_check -st_index_t rb_st_values(st_table *table, st_data_t *values, st_index_t size); -#define st_values rb_st_values -st_index_t rb_st_values_check(st_table *table, st_data_t *values, st_index_t size, st_data_t never); -#define st_values_check rb_st_values_check -void rb_st_add_direct(st_table *, st_data_t, st_data_t); -#define st_add_direct rb_st_add_direct -void rb_st_free_table(st_table *); -#define st_free_table rb_st_free_table -void rb_st_cleanup_safe(st_table *, st_data_t); -#define st_cleanup_safe rb_st_cleanup_safe -void rb_st_clear(st_table *); -#define st_clear rb_st_clear -st_table *rb_st_copy(st_table *); -#define st_copy rb_st_copy -CONSTFUNC(int rb_st_numcmp(st_data_t, st_data_t)); -#define st_numcmp rb_st_numcmp -CONSTFUNC(st_index_t rb_st_numhash(st_data_t)); -#define st_numhash rb_st_numhash -PUREFUNC(int rb_st_locale_insensitive_strcasecmp(const char *s1, const char *s2)); -#define st_locale_insensitive_strcasecmp rb_st_locale_insensitive_strcasecmp -PUREFUNC(int rb_st_locale_insensitive_strncasecmp(const char *s1, const char *s2, size_t n)); -#define st_locale_insensitive_strncasecmp rb_st_locale_insensitive_strncasecmp -#define st_strcasecmp rb_st_locale_insensitive_strcasecmp -#define st_strncasecmp rb_st_locale_insensitive_strncasecmp -PUREFUNC(size_t rb_st_memsize(const st_table *)); -#define st_memsize rb_st_memsize -PUREFUNC(st_index_t rb_st_hash(const void *ptr, size_t len, st_index_t h)); -#define st_hash rb_st_hash -CONSTFUNC(st_index_t rb_st_hash_uint32(st_index_t h, uint32_t i)); -#define st_hash_uint32 rb_st_hash_uint32 -CONSTFUNC(st_index_t rb_st_hash_uint(st_index_t h, st_index_t i)); -#define st_hash_uint rb_st_hash_uint -CONSTFUNC(st_index_t rb_st_hash_end(st_index_t h)); -#define st_hash_end rb_st_hash_end -CONSTFUNC(st_index_t rb_st_hash_start(st_index_t h)); +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); +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); +void st_clear(st_table *); +st_table *st_copy(st_table *); +CONSTFUNC(int st_numcmp(st_data_t, st_data_t)); +CONSTFUNC(st_index_t st_numhash(st_data_t)); +PUREFUNC(int st_locale_insensitive_strcasecmp(const char *s1, const char *s2)); +PUREFUNC(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 +PUREFUNC(size_t st_memsize(const st_table *)); +PUREFUNC(st_index_t st_hash(const void *ptr, size_t len, st_index_t h)); +CONSTFUNC(st_index_t st_hash_uint32(st_index_t h, uint32_t i)); +CONSTFUNC(st_index_t st_hash_uint(st_index_t h, st_index_t i)); +CONSTFUNC(st_index_t st_hash_end(st_index_t h)); +CONSTFUNC(st_index_t st_hash_start(st_index_t h)); #define st_hash_start(h) ((st_index_t)(h)) -void rb_hash_bulk_insert_into_st_table(long, const VALUE *, VALUE); - RUBY_SYMBOL_EXPORT_END #if defined(__cplusplus) diff --git a/include/ruby/thread.h b/include/ruby/thread.h index d398cc127e..550f678e54 100644 --- a/include/ruby/thread.h +++ b/include/ruby/thread.h @@ -21,10 +21,6 @@ extern "C" { #include "ruby/intern.h" -/* flags for rb_nogvl */ -#define RB_NOGVL_INTR_FAIL (0x1) -#define RB_NOGVL_UBF_ASYNC_SAFE (0x2) - RUBY_SYMBOL_EXPORT_BEGIN void *rb_thread_call_with_gvl(void *(*func)(void *), void *data1); @@ -34,14 +30,6 @@ void *rb_thread_call_without_gvl(void *(*func)(void *), void *data1, void *rb_thread_call_without_gvl2(void *(*func)(void *), void *data1, rb_unblock_function_t *ubf, void *data2); -/* - * XXX: unstable/unapproved - out-of-tree code should NOT not depend - * on this until it hits Ruby 2.6.1 - */ -void *rb_nogvl(void *(*func)(void *), void *data1, - rb_unblock_function_t *ubf, void *data2, - int flags); - #define RUBY_CALL_WO_GVL_FLAG_SKIP_CHECK_INTS_AFTER 0x01 #define RUBY_CALL_WO_GVL_FLAG_SKIP_CHECK_INTS_ diff --git a/include/ruby/version.h b/include/ruby/version.h index 64c5c614e0..10b1b05436 100644 --- a/include/ruby/version.h +++ b/include/ruby/version.h @@ -31,7 +31,7 @@ /* API version */ #define RUBY_API_VERSION_MAJOR 2 -#define RUBY_API_VERSION_MINOR 7 +#define RUBY_API_VERSION_MINOR 5 #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) diff --git a/include/ruby/vm.h b/include/ruby/vm.h index b137a280c9..73345264bd 100644 --- a/include/ruby/vm.h +++ b/include/ruby/vm.h @@ -24,7 +24,8 @@ RUBY_SYMBOL_EXPORT_BEGIN /* Place holder. * * We will prepare VM creation/control APIs on 1.9.2 or later. - * + * If you have an interest about it, please see mvm branch. + * http://svn.ruby-lang.org/cgi-bin/viewvc.cgi/branches/mvm/ */ /* VM type declaration */ diff --git a/include/ruby/win32.h b/include/ruby/win32.h index b29470b0c4..fe1978fdde 100644 --- a/include/ruby/win32.h +++ b/include/ruby/win32.h @@ -146,7 +146,7 @@ typedef int clockid_t; #define HAVE_UTIMENSAT 1 #define AT_FDCWD -100 #define utimensat(_d, _p, _t, _f) rb_w32_utimensat(_d, _p, _t, _f) -#define lseek(_f, _o, _w) rb_w32_lseek(_f, _o, _w) +#define lseek(_f, _o, _w) _lseeki64(_f, _o, _w) #define pipe(p) rb_w32_pipe(p) #define open rb_w32_open @@ -751,7 +751,6 @@ 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); -off_t rb_w32_lseek(int, off_t, int); int rb_w32_utime(const char *, const struct utimbuf *); int rb_w32_uutime(const char *, const struct utimbuf *); int rb_w32_utimes(const char *, const struct timeval *); |