diff options
Diffstat (limited to 'include/ruby/backward')
| -rw-r--r-- | include/ruby/backward/classext.h | 18 | ||||
| -rw-r--r-- | include/ruby/backward/cxxanyargs.hpp | 439 | ||||
| -rw-r--r-- | include/ruby/backward/rubyio.h | 6 | ||||
| -rw-r--r-- | include/ruby/backward/rubysig.h | 47 | ||||
| -rw-r--r-- | include/ruby/backward/st.h | 6 | ||||
| -rw-r--r-- | include/ruby/backward/util.h | 6 |
6 files changed, 522 insertions, 0 deletions
diff --git a/include/ruby/backward/classext.h b/include/ruby/backward/classext.h new file mode 100644 index 0000000000..9d5747316a --- /dev/null +++ b/include/ruby/backward/classext.h @@ -0,0 +1,18 @@ +#if defined __GNUC__ +#warning use of RClass internals is deprecated +#elif defined _MSC_VER +#pragma message("warning: use of RClass internals is deprecated") +#endif + +#ifndef RUBY_BACKWARD_CLASSEXT_H +#define RUBY_BACKWARD_CLASSEXT_H 1 + +typedef struct rb_deprecated_classext_struct { + VALUE super; +} rb_deprecated_classext_t; + +#undef RCLASS_SUPER(c) +#define RCLASS_EXT(c) ((rb_deprecated_classext_t *)RCLASS(c)->ptr) +#define RCLASS_SUPER(c) (RCLASS(c)->super) + +#endif /* RUBY_BACKWARD_CLASSEXT_H */ diff --git a/include/ruby/backward/cxxanyargs.hpp b/include/ruby/backward/cxxanyargs.hpp new file mode 100644 index 0000000000..3585f678b8 --- /dev/null +++ b/include/ruby/backward/cxxanyargs.hpp @@ -0,0 +1,439 @@ +#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/backward/rubyio.h b/include/ruby/backward/rubyio.h new file mode 100644 index 0000000000..a6e3a7c78b --- /dev/null +++ b/include/ruby/backward/rubyio.h @@ -0,0 +1,6 @@ +#if defined __GNUC__ +#warning use "ruby/io.h" instead of "rubyio.h" +#elif defined _MSC_VER +#pragma message("warning: use \"ruby/io.h\" instead of \"rubyio.h\"") +#endif +#include "ruby/io.h" diff --git a/include/ruby/backward/rubysig.h b/include/ruby/backward/rubysig.h new file mode 100644 index 0000000000..58b13cab1c --- /dev/null +++ b/include/ruby/backward/rubysig.h @@ -0,0 +1,47 @@ +/********************************************************************** + + rubysig.h - + + $Author$ + $Date$ + created at: Wed Aug 16 01:15:38 JST 1995 + + Copyright (C) 1993-2008 Yukihiro Matsumoto + +**********************************************************************/ + +#if defined __GNUC__ +#warning rubysig.h is obsolete +#elif defined _MSC_VER +#pragma message("warning: rubysig.h is obsolete") +#endif + +#ifndef RUBYSIG_H +#define RUBYSIG_H +#include "ruby/ruby.h" + +#if defined(__cplusplus) +extern "C" { +#if 0 +} /* satisfy cc-mode */ +#endif +#endif + +RUBY_SYMBOL_EXPORT_BEGIN + +#define RUBY_CRITICAL(statements) do {statements;} while (0) +#define DEFER_INTS (0) +#define ENABLE_INTS (1) +#define ALLOW_INTS do {CHECK_INTS;} while (0) +#define CHECK_INTS rb_thread_check_ints() + +RUBY_SYMBOL_EXPORT_END + +#if defined(__cplusplus) +#if 0 +{ /* satisfy cc-mode */ +#endif +} /* extern "C" { */ +#endif + +#endif diff --git a/include/ruby/backward/st.h b/include/ruby/backward/st.h new file mode 100644 index 0000000000..3e36d44cf8 --- /dev/null +++ b/include/ruby/backward/st.h @@ -0,0 +1,6 @@ +#if defined __GNUC__ +#warning use "ruby/st.h" instead of bare "st.h" +#elif defined _MSC_VER +#pragma message("warning: use \"ruby/st.h\" instead of bare \"st.h\"") +#endif +#include "ruby/st.h" diff --git a/include/ruby/backward/util.h b/include/ruby/backward/util.h new file mode 100644 index 0000000000..11d32a2da8 --- /dev/null +++ b/include/ruby/backward/util.h @@ -0,0 +1,6 @@ +#if defined __GNUC__ +#warning use "ruby/util.h" instead of bare "util.h" +#elif defined _MSC_VER +#pragma message("warning: use \"ruby/util.h\" instead of bare \"util.h\"") +#endif +#include "ruby/util.h" |