kotovalexarian-likes-github/ruby--ruby
1
0
Fork 0
mirror of https://github.com/ruby/ruby.git synced 2022-11-09 12:17:21 -05:00
Code Releases Activity
ruby--ruby/include/ruby/backward/cxxanyargs.hpp

701 lines
30 KiB
C++
Raw Normal View History

add #include guard hack According to MSVC manual (*1), cl.exe can skip including a header file when that: - contains #pragma once, or - starts with #ifndef, or - starts with #if ! defined. GCC has a similar trick (*2), but it acts more stricter (e. g. there must be _no tokens_ outside of #ifndef...#endif). Sun C lacked #pragma once for a looong time. Oracle Developer Studio 12.5 finally implemented it, but we cannot assume such recent version. This changeset modifies header files so that each of them include strictly one #ifndef...#endif. I believe this is the most portable way to trigger compiler optimizations. [Bug #16770] *1: https://docs.microsoft.com/en-us/cpp/preprocessor/once *2: https://gcc.gnu.org/onlinedocs/cppinternals/Guard-Macros.html
2020-04-10 01:11:40 -04:00
#ifndef RUBY_BACKWARD_CXXANYARGS_HPP //-*-C++-*-vi:ft=cpp
#define RUBY_BACKWARD_CXXANYARGS_HPP
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
/// @file
template/Doxyfile.tmpl: add alias This enables me to write `@shyouhei` in C comments without complained by doxygen that @shyouhei is an unknown special command. [ci skip]
2020-12-23 00:51:41 -05:00
/// @author @shyouhei
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
/// @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.
include/ruby/backward/cxxanyargs.hpp: addo doxygen Must not be a bad idea to improve documents. [ci skip]
2021-06-06 22:56:52 -04:00
/// @note DO NOT MODERNISE THIS FILE! As the file name implies it is
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
/// meant to be a backwards compatibility shim. Please stick to
/// C++ 98 and never use newer features, like `constexpr`.
Merge pull request #2991 from shyouhei/ruby.h Split ruby.h
2020-04-08 00:28:13 -04:00
/// @brief Provides old prototypes for C++ programs.
sed -i 's|ruby/impl|ruby/internal|' To fix build failures.
2020-05-08 05:31:09 -04:00
#include "ruby/internal/config.h"
#include "ruby/internal/intern/class.h"
#include "ruby/internal/intern/cont.h"
#include "ruby/internal/intern/hash.h"
#include "ruby/internal/intern/proc.h"
#include "ruby/internal/intern/thread.h"
#include "ruby/internal/intern/variable.h"
#include "ruby/internal/intern/vm.h"
#include "ruby/internal/iterator.h"
#include "ruby/internal/method.h"
#include "ruby/internal/value.h"
#include "ruby/internal/variable.h"
Merge pull request #2991 from shyouhei/ruby.h Split ruby.h
2020-04-08 00:28:13 -04:00
#include "ruby/backward/2/stdarg.h"
#include "ruby/st.h"
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
template metaprogramming instead of macros C++ (and myself) hates macros. If we could do the same thing in both preprocessor and template, we shall choose template. This particular part of the ruby header is one of such situations.
2020-01-27 21:43:33 -05:00
extern "C++" {
support C++ std::nullptr_t C++ keyword `nullptr` represents a null pointer (note also that NULL is an integer in C++ due to its design flaw). Its type is `std::nullptr_t`, defined in <cstddef> standard header. Why not support it when the backend implementation can take a null pointer as an argument.
2020-01-30 22:01:39 -05:00
#ifdef HAVE_NULLPTR
#include <cstddef>
#endif
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
/// @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 {
a bit terse Doxygen comments [ci skip] Creative use of `@copydoc` Doxygen command and abusing its half-broken C parser let us delete some lines of documentations, while preserving document coverages.
2020-01-30 23:10:55 -05:00
/// Backwards compatibility layer.
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
namespace backward {
include/ruby/backward/cxxanyargs.hpp: addo doxygen Must not be a bad idea to improve documents. [ci skip]
2021-06-06 22:56:52 -04:00
/// Provides ANYARGS deprecation warnings. In C, ANYARGS means there is no
a bit terse Doxygen comments [ci skip] Creative use of `@copydoc` Doxygen command and abusing its half-broken C parser let us delete some lines of documentations, while preserving document coverages.
2020-01-30 23:10:55 -05:00
/// 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.
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
///
/// 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 {
a bit terse Doxygen comments [ci skip] Creative use of `@copydoc` Doxygen command and abusing its half-broken C parser let us delete some lines of documentations, while preserving document coverages.
2020-01-30 23:10:55 -05:00
typedef VALUE type(ANYARGS); ///< ANYARGS-ed function type.
typedef void void_type(ANYARGS); ///< ANYARGS-ed function type, void variant.
typedef int int_type(ANYARGS); ///< ANYARGS-ed function type, int variant.
typedef VALUE onearg_type(VALUE); ///< Single-argumented function type.
support C++ std::nullptr_t C++ keyword `nullptr` represents a null pointer (note also that NULL is an integer in C++ due to its design flaw). Its type is `std::nullptr_t`, defined in <cstddef> standard header. Why not support it when the backend implementation can take a null pointer as an argument.
2020-01-30 22:01:39 -05:00
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
/// @name Hooking global variables
/// @{
Fixed misspellings Fixed misspellings reported at [Bug #16437], only in ruby and rubyspec.
2019-12-19 19:19:39 -05:00
RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated")
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
/// @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()
include/ruby/backward/cxxanyargs.hpp: addo doxygen Must not be a bad idea to improve documents. [ci skip]
2021-06-06 22:56:52 -04:00
/// @deprecated Use granular typed overload instead.
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
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);
}
Fixed misspellings Fixed misspellings reported at [Bug #16437], only in ruby and rubyspec.
2019-12-19 19:19:39 -05:00
RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated")
Overload variable definition functions Define overloading functions of rb_define_virtual_variable and rb_define_hooked_variable, for combinations with and without ANYARGS casts.
2019-09-18 09:52:41 -04:00
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);
}
Fixed misspellings Fixed misspellings reported at [Bug #16437], only in ruby and rubyspec.
2019-12-19 19:19:39 -05:00
RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated")
Overload variable definition functions Define overloading functions of rb_define_virtual_variable and rb_define_hooked_variable, for combinations with and without ANYARGS casts.
2019-09-18 09:52:41 -04:00
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);
}
support C++ std::nullptr_t C++ keyword `nullptr` represents a null pointer (note also that NULL is an integer in C++ due to its design flaw). Its type is `std::nullptr_t`, defined in <cstddef> standard header. Why not support it when the backend implementation can take a null pointer as an argument.
2020-01-30 22:01:39 -05:00
#ifdef HAVE_NULLPTR
inline void
rb_define_virtual_variable(const char *q, rb_gvar_getter_t *w, std::nullptr_t e)
{
::rb_define_virtual_variable(q, w, e);
}
RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated")
inline void
rb_define_virtual_variable(const char *q, type *w, std::nullptr_t e)
{
rb_gvar_getter_t *r = reinterpret_cast<rb_gvar_getter_t *>(w);
::rb_define_virtual_variable(q, r, e);
}
inline void
rb_define_virtual_variable(const char *q, std::nullptr_t w, rb_gvar_setter_t *e)
{
::rb_define_virtual_variable(q, w, e);
}
RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated")
inline void
rb_define_virtual_variable(const char *q, std::nullptr_t w, void_type *e)
{
rb_gvar_setter_t *r = reinterpret_cast<rb_gvar_setter_t *>(e);
::rb_define_virtual_variable(q, w, r);
}
#endif
Fixed misspellings Fixed misspellings reported at [Bug #16437], only in ruby and rubyspec.
2019-12-19 19:19:39 -05:00
RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated")
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
/// @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()
include/ruby/backward/cxxanyargs.hpp: addo doxygen Must not be a bad idea to improve documents. [ci skip]
2021-06-06 22:56:52 -04:00
/// @deprecated Use granular typed overload instead.
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
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);
}
Fixed misspellings Fixed misspellings reported at [Bug #16437], only in ruby and rubyspec.
2019-12-19 19:19:39 -05:00
RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated")
Overload variable definition functions Define overloading functions of rb_define_virtual_variable and rb_define_hooked_variable, for combinations with and without ANYARGS casts.
2019-09-18 09:52:41 -04:00
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);
}
Fixed misspellings Fixed misspellings reported at [Bug #16437], only in ruby and rubyspec.
2019-12-19 19:19:39 -05:00
RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated")
Overload variable definition functions Define overloading functions of rb_define_virtual_variable and rb_define_hooked_variable, for combinations with and without ANYARGS casts.
2019-09-18 09:52:41 -04:00
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);
}
support C++ std::nullptr_t C++ keyword `nullptr` represents a null pointer (note also that NULL is an integer in C++ due to its design flaw). Its type is `std::nullptr_t`, defined in <cstddef> standard header. Why not support it when the backend implementation can take a null pointer as an argument.
2020-01-30 22:01:39 -05:00
#ifdef HAVE_NULLPTR
inline void
rb_define_hooked_variable(const char *q, VALUE *w, rb_gvar_getter_t *e, std::nullptr_t r)
{
::rb_define_hooked_variable(q, w, e, r);
}
RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated")
inline void
rb_define_hooked_variable(const char *q, VALUE *w, type *e, std::nullptr_t r)
{
rb_gvar_getter_t *y = reinterpret_cast<rb_gvar_getter_t *>(e);
::rb_define_hooked_variable(q, w, y, r);
}
inline void
rb_define_hooked_variable(const char *q, VALUE *w, std::nullptr_t e, rb_gvar_setter_t *r)
{
::rb_define_hooked_variable(q, w, e, r);
}
RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated")
inline void
rb_define_hooked_variable(const char *q, VALUE *w, std::nullptr_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);
}
#endif
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
/// @}
/// @name Exceptions and tag jumps
/// @{
VC warns the same attribute used more than once
2021-08-09 05:16:24 -04:00
// RUBY_CXX_DEPRECATED("by rb_block_call since 1.9")
Fixed misspellings Fixed misspellings reported at [Bug #16437], only in ruby and rubyspec.
2019-12-19 19:19:39 -05:00
RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated")
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
/// @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.
include/ruby/backward/cxxanyargs.hpp: addo doxygen Must not be a bad idea to improve documents. [ci skip]
2021-06-06 22:56:52 -04:00
/// @deprecated This function is obsoleted since long before 2.x era. Do not
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
/// use it any longer. rb_block_call() is provided instead.
inline VALUE
support C++ std::nullptr_t C++ keyword `nullptr` represents a null pointer (note also that NULL is an integer in C++ due to its design flaw). Its type is `std::nullptr_t`, defined in <cstddef> standard header. Why not support it when the backend implementation can take a null pointer as an argument.
2020-01-30 22:01:39 -05:00
rb_iterate(onearg_type *q, VALUE w, type *e, VALUE r)
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
{
rb_block_call_func_t t = reinterpret_cast<rb_block_call_func_t>(e);
Rename rb_iterate to get rid of name clash on Sun C
2021-08-09 04:36:00 -04:00
return backward::rb_iterate_deprecated(q, w, t, r);
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
}
support C++ std::nullptr_t C++ keyword `nullptr` represents a null pointer (note also that NULL is an integer in C++ due to its design flaw). Its type is `std::nullptr_t`, defined in <cstddef> standard header. Why not support it when the backend implementation can take a null pointer as an argument.
2020-01-30 22:01:39 -05:00
#ifdef HAVE_NULLPTR
Deprecate rb_iterate in C++
2021-08-08 05:24:03 -04:00
RUBY_CXX_DEPRECATED("by rb_block_call since 1.9")
support C++ std::nullptr_t C++ keyword `nullptr` represents a null pointer (note also that NULL is an integer in C++ due to its design flaw). Its type is `std::nullptr_t`, defined in <cstddef> standard header. Why not support it when the backend implementation can take a null pointer as an argument.
2020-01-30 22:01:39 -05:00
inline VALUE
rb_iterate(onearg_type *q, VALUE w, std::nullptr_t e, VALUE r)
{
Rename rb_iterate to get rid of name clash on Sun C
2021-08-09 04:36:00 -04:00
return backward::rb_iterate_deprecated(q, w, e, r);
support C++ std::nullptr_t C++ keyword `nullptr` represents a null pointer (note also that NULL is an integer in C++ due to its design flaw). Its type is `std::nullptr_t`, defined in <cstddef> standard header. Why not support it when the backend implementation can take a null pointer as an argument.
2020-01-30 22:01:39 -05:00
}
#endif
Fixed misspellings Fixed misspellings reported at [Bug #16437], only in ruby and rubyspec.
2019-12-19 19:19:39 -05:00
RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated")
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
/// @brief Call a method with a block.
/// @param[in] q The self.
/// @param[in] w The method.
oops [ci skip] Fixing typo. It seems I failed to press the shift key.
2019-09-15 10:19:01 -04:00
/// @param[in] e The # of elems of `r`
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
/// @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.
include/ruby/backward/cxxanyargs.hpp: addo doxygen Must not be a bad idea to improve documents. [ci skip]
2021-06-06 22:56:52 -04:00
/// @deprecated Use granular typed overload instead.
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
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);
}
support C++ std::nullptr_t C++ keyword `nullptr` represents a null pointer (note also that NULL is an integer in C++ due to its design flaw). Its type is `std::nullptr_t`, defined in <cstddef> standard header. Why not support it when the backend implementation can take a null pointer as an argument.
2020-01-30 22:01:39 -05:00
#ifdef HAVE_NULLPTR
inline VALUE
rb_block_call(VALUE q, ID w, int e, const VALUE *r, std::nullptr_t t, VALUE y)
{
return ::rb_block_call(q, w, e, r, t, y);
}
#endif
Fixed misspellings Fixed misspellings reported at [Bug #16437], only in ruby and rubyspec.
2019-12-19 19:19:39 -05:00
RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated")
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
/// @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()
include/ruby/backward/cxxanyargs.hpp: addo doxygen Must not be a bad idea to improve documents. [ci skip]
2021-06-06 22:56:52 -04:00
/// @deprecated Use granular typed overload instead.
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
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);
}
Fixed misspellings Fixed misspellings reported at [Bug #16437], only in ruby and rubyspec.
2019-12-19 19:19:39 -05:00
RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated")
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
/// @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()
include/ruby/backward/cxxanyargs.hpp: addo doxygen Must not be a bad idea to improve documents. [ci skip]
2021-06-06 22:56:52 -04:00
/// @deprecated Use granular typed overload instead.
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
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);
include/ruby/backward/cxxanyargs.hpp: call `va_end` before return Coverity Scan complains it.
2019-10-23 19:30:33 -04:00
VALUE ret = ::rb_vrescue2(t, w, y, r, ap);
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
va_end(ap);
include/ruby/backward/cxxanyargs.hpp: call `va_end` before return Coverity Scan complains it.
2019-10-23 19:30:33 -04:00
return ret;
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
}
Fixed misspellings Fixed misspellings reported at [Bug #16437], only in ruby and rubyspec.
2019-12-19 19:19:39 -05:00
RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated")
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
/// @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()
include/ruby/backward/cxxanyargs.hpp: addo doxygen Must not be a bad idea to improve documents. [ci skip]
2021-06-06 22:56:52 -04:00
/// @deprecated Use granular typed overload instead.
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
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);
}
Fixed misspellings Fixed misspellings reported at [Bug #16437], only in ruby and rubyspec.
2019-12-19 19:19:39 -05:00
RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated")
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
/// @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()
include/ruby/backward/cxxanyargs.hpp: addo doxygen Must not be a bad idea to improve documents. [ci skip]
2021-06-06 22:56:52 -04:00
/// @deprecated Use granular typed overload instead.
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
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);
}
support C++ std::nullptr_t C++ keyword `nullptr` represents a null pointer (note also that NULL is an integer in C++ due to its design flaw). Its type is `std::nullptr_t`, defined in <cstddef> standard header. Why not support it when the backend implementation can take a null pointer as an argument.
2020-01-30 22:01:39 -05:00
#ifdef HAVE_NULLPTR
inline VALUE
rb_catch(const char *q, std::nullptr_t w, VALUE e)
{
return ::rb_catch(q, w, e);
}
#endif
Fixed misspellings Fixed misspellings reported at [Bug #16437], only in ruby and rubyspec.
2019-12-19 19:19:39 -05:00
RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated")
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
/// @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()
include/ruby/backward/cxxanyargs.hpp: addo doxygen Must not be a bad idea to improve documents. [ci skip]
2021-06-06 22:56:52 -04:00
/// @deprecated Use granular typed overload instead.
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
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
/// @{
Fixed misspellings Fixed misspellings reported at [Bug #16437], only in ruby and rubyspec.
2019-12-19 19:19:39 -05:00
RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated")
include/ruby/backward/cxxanyargs.hpp: suppress doxygen warning rb_cFiber is not visible from extension libraries, hence intentionally not documented. [ci skip]
2020-12-21 02:30:10 -05:00
/// @brief Creates a rb_cFiber instance.
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
/// @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()
include/ruby/backward/cxxanyargs.hpp: addo doxygen Must not be a bad idea to improve documents. [ci skip]
2021-06-06 22:56:52 -04:00
/// @see rb_thread_create()
/// @deprecated Use granular typed overload instead.
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
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);
}
Fixed misspellings Fixed misspellings reported at [Bug #16437], only in ruby and rubyspec.
2019-12-19 19:19:39 -05:00
RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated")
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
/// @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()
include/ruby/backward/cxxanyargs.hpp: addo doxygen Must not be a bad idea to improve documents. [ci skip]
2021-06-06 22:56:52 -04:00
/// @see rb_thread_create()
/// @deprecated Use granular typed overload instead.
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
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);
}
Fixed misspellings Fixed misspellings reported at [Bug #16437], only in ruby and rubyspec.
2019-12-19 19:19:39 -05:00
RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated")
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
/// @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()
include/ruby/backward/cxxanyargs.hpp: addo doxygen Must not be a bad idea to improve documents. [ci skip]
2021-06-06 22:56:52 -04:00
/// @deprecated Use granular typed overload instead.
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
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
/// @{
Fixed misspellings Fixed misspellings reported at [Bug #16437], only in ruby and rubyspec.
2019-12-19 19:19:39 -05:00
RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated")
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
/// @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()
include/ruby/backward/cxxanyargs.hpp: addo doxygen Must not be a bad idea to improve documents. [ci skip]
2021-06-06 22:56:52 -04:00
/// @deprecated Use granular typed overload instead.
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
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);
}
Fixed misspellings Fixed misspellings reported at [Bug #16437], only in ruby and rubyspec.
2019-12-19 19:19:39 -05:00
RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated")
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
/// @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()
include/ruby/backward/cxxanyargs.hpp: addo doxygen Must not be a bad idea to improve documents. [ci skip]
2021-06-06 22:56:52 -04:00
/// @deprecated Use granular typed overload instead.
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
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);
}
Fixed misspellings Fixed misspellings reported at [Bug #16437], only in ruby and rubyspec.
2019-12-19 19:19:39 -05:00
RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated")
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
/// @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()
include/ruby/backward/cxxanyargs.hpp: addo doxygen Must not be a bad idea to improve documents. [ci skip]
2021-06-06 22:56:52 -04:00
/// @deprecated Use granular typed overload instead.
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
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);
}
Fixed misspellings Fixed misspellings reported at [Bug #16437], only in ruby and rubyspec.
2019-12-19 19:19:39 -05:00
RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated")
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
/// @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()
include/ruby/backward/cxxanyargs.hpp: addo doxygen Must not be a bad idea to improve documents. [ci skip]
2021-06-06 22:56:52 -04:00
/// @deprecated Use granular typed overload instead.
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
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);
}
Fixed misspellings Fixed misspellings reported at [Bug #16437], only in ruby and rubyspec.
2019-12-19 19:19:39 -05:00
RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated")
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
/// @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()
include/ruby/backward/cxxanyargs.hpp: addo doxygen Must not be a bad idea to improve documents. [ci skip]
2021-06-06 22:56:52 -04:00
/// @deprecated Use granular typed overload instead.
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
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);
}
/// @}
template metaprogramming instead of macros C++ (and myself) hates macros. If we could do the same thing in both preprocessor and template, we shall choose template. This particular part of the ruby header is one of such situations.
2020-01-27 21:43:33 -05:00
a bit terse Doxygen comments [ci skip] Creative use of `@copydoc` Doxygen command and abusing its half-broken C parser let us delete some lines of documentations, while preserving document coverages.
2020-01-30 23:10:55 -05:00
/// Driver for *_define_method. ::rb_define_method function for instance takes
/// a pointer to ANYARGS-ed functions, which in fact varies 18 different
/// prototypes. We still need to preserve ANYARGS for storages but why not
/// check the consistencies if possible. In C++ a function has its own
/// prototype, which is a compile-time constant (static type) by nature. We
/// can list up all the possible input types and provide warnings for other
/// cases. This is such attempt.
template metaprogramming instead of macros C++ (and myself) hates macros. If we could do the same thing in both preprocessor and template, we shall choose template. This particular part of the ruby header is one of such situations.
2020-01-27 21:43:33 -05:00
namespace define_method {
a bit terse Doxygen comments [ci skip] Creative use of `@copydoc` Doxygen command and abusing its half-broken C parser let us delete some lines of documentations, while preserving document coverages.
2020-01-30 23:10:55 -05:00
/// Type of ::rb_f_notimplement().
improved support for rb_f_notimplement rb_f_notimplement should be accepted for all possible arities. Test provided for that.
2020-01-28 03:02:30 -05:00
typedef VALUE notimpl_type(int, const VALUE *, VALUE, VALUE);
template metaprogramming instead of macros C++ (and myself) hates macros. If we could do the same thing in both preprocessor and template, we shall choose template. This particular part of the ruby header is one of such situations.
2020-01-27 21:43:33 -05:00
/// @brief Template metaprogramming to generate function prototypes.
/// @tparam T Type of method id (`ID` or `const char*` in practice).
/// @tparam F Definition driver e.g. ::rb_define_method.
template<typename T, void (*F)(VALUE klass, T mid, type *func, int arity)>
struct driver {
/// @brief Defines a method
/// @tparam N Arity of the function.
/// @tparam U The function in question
template<int N, typename U>
struct engine {
/* :TODO: Following deprecation attribute renders tons of warnings (one
* per every method definitions), which is annoying. Of course
* annoyance is the core feature of deprecation warnings... But that
* could be too much, especially when the warnings happen inside of
* machine-generated programs. And SWIG is known to do such thing.
* The new (granular) API was introduced in API version 2.7. As of
* this writing the version is 2.8. Let's warn this later, some time
* during 3.x. Hopefully codes in old (ANYARGS-ed) format should be
* less than now. */
#if (RUBY_API_VERSION_MAJOR * 100 + RUBY_API_VERSION_MINOR) >= 301
RUBY_CXX_DEPRECATED("use of ANYARGS is deprecated")
#endif
a bit terse Doxygen comments [ci skip] Creative use of `@copydoc` Doxygen command and abusing its half-broken C parser let us delete some lines of documentations, while preserving document coverages.
2020-01-30 23:10:55 -05:00
/// @copydoc define(VALUE klass, T mid, U func)
include/ruby/backward/cxxanyargs.hpp: addo doxygen Must not be a bad idea to improve documents. [ci skip]
2021-06-06 22:56:52 -04:00
/// @deprecated Pass correctly typed function instead.
template metaprogramming instead of macros C++ (and myself) hates macros. If we could do the same thing in both preprocessor and template, we shall choose template. This particular part of the ruby header is one of such situations.
2020-01-27 21:43:33 -05:00
static inline void
define(VALUE klass, T mid, type func)
{
F(klass, mid, func, N);
}
/// @brief Defines klass#mid as func, whose arity is N.
/// @param[in] klass Where the method lives.
/// @param[in] mid Name of the method to define.
/// @param[in] func Function that implements klass#mid.
static inline void
define(VALUE klass, T mid, U func)
{
F(klass, mid, reinterpret_cast<type *>(func), N);
}
improved support for rb_f_notimplement rb_f_notimplement should be accepted for all possible arities. Test provided for that.
2020-01-28 03:02:30 -05:00
a bit terse Doxygen comments [ci skip] Creative use of `@copydoc` Doxygen command and abusing its half-broken C parser let us delete some lines of documentations, while preserving document coverages.
2020-01-30 23:10:55 -05:00
/// @copydoc define(VALUE klass, T mid, U func)
improved support for rb_f_notimplement rb_f_notimplement should be accepted for all possible arities. Test provided for that.
2020-01-28 03:02:30 -05:00
static inline void
define(VALUE klass, T mid, notimpl_type func)
{
F(klass, mid, reinterpret_cast<type *>(func), N);
}
template metaprogramming instead of macros C++ (and myself) hates macros. If we could do the same thing in both preprocessor and template, we shall choose template. This particular part of the ruby header is one of such situations.
2020-01-27 21:43:33 -05:00
};
/// @cond INTERNAL_MACRO
template<int N, bool = false> struct specific : public engine<N, type *> {};
template<bool b> struct specific<15, b> : public engine<15, VALUE(*)(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE)> {};
template<bool b> struct specific<14, b> : public engine<14, VALUE(*)(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE)> {};
template<bool b> struct specific<13, b> : public engine<13, VALUE(*)(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE)> {};
template<bool b> struct specific<12, b> : public engine<12, VALUE(*)(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE)> {};
template<bool b> struct specific<11, b> : public engine<11, VALUE(*)(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE)> {};
template<bool b> struct specific<10, b> : public engine<10, VALUE(*)(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE)> {};
template<bool b> struct specific< 9, b> : public engine< 9, VALUE(*)(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE)> {};
template<bool b> struct specific< 8, b> : public engine< 8, VALUE(*)(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE)> {};
template<bool b> struct specific< 7, b> : public engine< 7, VALUE(*)(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE)> {};
template<bool b> struct specific< 6, b> : public engine< 6, VALUE(*)(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE)> {};
template<bool b> struct specific< 5, b> : public engine< 5, VALUE(*)(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE)> {};
template<bool b> struct specific< 4, b> : public engine< 4, VALUE(*)(VALUE, VALUE, VALUE, VALUE, VALUE)> {};
template<bool b> struct specific< 3, b> : public engine< 3, VALUE(*)(VALUE, VALUE, VALUE, VALUE)> {};
template<bool b> struct specific< 2, b> : public engine< 2, VALUE(*)(VALUE, VALUE, VALUE)> {};
template<bool b> struct specific< 1, b> : public engine< 1, VALUE(*)(VALUE, VALUE)> {};
template<bool b> struct specific< 0, b> : public engine< 0, VALUE(*)(VALUE)> {};
fix typo Add missing `*`.
2020-01-28 02:49:00 -05:00
template<bool b> struct specific<-1, b> : public engine<-1, VALUE(*)(int argc, VALUE *argv, VALUE self)> {
using engine<-1, VALUE(*)(int argc, VALUE *argv, VALUE self)>::define;
template metaprogramming instead of macros C++ (and myself) hates macros. If we could do the same thing in both preprocessor and template, we shall choose template. This particular part of the ruby header is one of such situations.
2020-01-27 21:43:33 -05:00
static inline void define(VALUE c, T m, VALUE(*f)(int argc, const VALUE *argv, VALUE self)) { F(c, m, reinterpret_cast<type *>(f), -1); }
};
template<bool b> struct specific<-2, b> : public engine<-2, VALUE(*)(VALUE, VALUE)> {};
/// @endcond
};
/* We could perhaps merge this struct into the one above using variadic
* template parameters if we could assume C++11, but sadly we cannot. */
include/ruby/backward/cxxanyargs.hpp: addo doxygen Must not be a bad idea to improve documents. [ci skip]
2021-06-06 22:56:52 -04:00
/// @copydoc ruby::backward::cxxanyargs::define_method::driver
template metaprogramming instead of macros C++ (and myself) hates macros. If we could do the same thing in both preprocessor and template, we shall choose template. This particular part of the ruby header is one of such situations.
2020-01-27 21:43:33 -05:00
template<typename T, void (*F)(T mid, type func, int arity)>
struct driver0 {
include/ruby/backward/cxxanyargs.hpp: addo doxygen Must not be a bad idea to improve documents. [ci skip]
2021-06-06 22:56:52 -04:00
/// @brief Defines a method
/// @tparam N Arity of the function.
/// @tparam U The function in question
template metaprogramming instead of macros C++ (and myself) hates macros. If we could do the same thing in both preprocessor and template, we shall choose template. This particular part of the ruby header is one of such situations.
2020-01-27 21:43:33 -05:00
template<int N, typename U>
struct engine {
RUBY_CXX_DEPRECATED("use of ANYARGS is deprecated")
include/ruby/backward/cxxanyargs.hpp: addo doxygen Must not be a bad idea to improve documents. [ci skip]
2021-06-06 22:56:52 -04:00
/// @copydoc define(T mid, U func)
/// @deprecated Pass correctly typed function instead.
template metaprogramming instead of macros C++ (and myself) hates macros. If we could do the same thing in both preprocessor and template, we shall choose template. This particular part of the ruby header is one of such situations.
2020-01-27 21:43:33 -05:00
static inline void
define(T mid, type func)
{
F(mid, func, N);
}
include/ruby/backward/cxxanyargs.hpp: addo doxygen Must not be a bad idea to improve documents. [ci skip]
2021-06-06 22:56:52 -04:00
/// @brief Defines Kernel#mid as func, whose arity is N.
/// @param[in] mid Name of the method to define.
/// @param[in] func Function that implements klass#mid.
template metaprogramming instead of macros C++ (and myself) hates macros. If we could do the same thing in both preprocessor and template, we shall choose template. This particular part of the ruby header is one of such situations.
2020-01-27 21:43:33 -05:00
static inline void
define(T mid, U func)
{
F(mid, reinterpret_cast<type *>(func), N);
}
include/ruby/backward/cxxanyargs.hpp: addo doxygen Must not be a bad idea to improve documents. [ci skip]
2021-06-06 22:56:52 -04:00
/// @copydoc define(T mid, U func)
/// @deprecated Pass correctly typed function instead.
improved support for rb_f_notimplement rb_f_notimplement should be accepted for all possible arities. Test provided for that.
2020-01-28 03:02:30 -05:00
static inline void
define(T mid, notimpl_type func)
{
F(mid, reinterpret_cast<type *>(func), N);
}
template metaprogramming instead of macros C++ (and myself) hates macros. If we could do the same thing in both preprocessor and template, we shall choose template. This particular part of the ruby header is one of such situations.
2020-01-27 21:43:33 -05:00
};
include/ruby/backward/cxxanyargs.hpp: addo doxygen Must not be a bad idea to improve documents. [ci skip]
2021-06-06 22:56:52 -04:00
template metaprogramming instead of macros C++ (and myself) hates macros. If we could do the same thing in both preprocessor and template, we shall choose template. This particular part of the ruby header is one of such situations.
2020-01-27 21:43:33 -05:00
/// @cond INTERNAL_MACRO
template<int N, bool = false> struct specific : public engine<N, type *> {};
template<bool b> struct specific<15, b> : public engine<15, VALUE(*)(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE)> {};
template<bool b> struct specific<14, b> : public engine<14, VALUE(*)(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE)> {};
template<bool b> struct specific<13, b> : public engine<13, VALUE(*)(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE)> {};
template<bool b> struct specific<12, b> : public engine<12, VALUE(*)(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE)> {};
template<bool b> struct specific<11, b> : public engine<11, VALUE(*)(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE)> {};
template<bool b> struct specific<10, b> : public engine<10, VALUE(*)(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE)> {};
template<bool b> struct specific< 9, b> : public engine< 9, VALUE(*)(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE)> {};
template<bool b> struct specific< 8, b> : public engine< 8, VALUE(*)(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE)> {};
template<bool b> struct specific< 7, b> : public engine< 7, VALUE(*)(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE)> {};
template<bool b> struct specific< 6, b> : public engine< 6, VALUE(*)(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE)> {};
template<bool b> struct specific< 5, b> : public engine< 5, VALUE(*)(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE)> {};
template<bool b> struct specific< 4, b> : public engine< 4, VALUE(*)(VALUE, VALUE, VALUE, VALUE, VALUE)> {};
template<bool b> struct specific< 3, b> : public engine< 3, VALUE(*)(VALUE, VALUE, VALUE, VALUE)> {};
template<bool b> struct specific< 2, b> : public engine< 2, VALUE(*)(VALUE, VALUE, VALUE)> {};
template<bool b> struct specific< 1, b> : public engine< 1, VALUE(*)(VALUE, VALUE)> {};
template<bool b> struct specific< 0, b> : public engine< 0, VALUE(*)(VALUE)> {};
fix typo Add missing `*`.
2020-01-28 02:49:00 -05:00
template<bool b> struct specific<-1, b> : public engine<-1, VALUE(*)(int argc, VALUE *argv, VALUE self)> {
using engine<-1, VALUE(*)(int argc, VALUE *argv, VALUE self)>::define;
fix rb_define_global_function to take const VALUE* It was unable for rb_define_global_function to take VALUE(*)(int argc, const VLAUE *argv, VALUE self) -style function. Test added.
2020-01-28 03:20:16 -05:00
static inline void define(T m, VALUE(*f)(int argc, const VALUE *argv, VALUE self)) { F(m, reinterpret_cast<type *>(f), -1); }
template metaprogramming instead of macros C++ (and myself) hates macros. If we could do the same thing in both preprocessor and template, we shall choose template. This particular part of the ruby header is one of such situations.
2020-01-27 21:43:33 -05:00
};
template<bool b> struct specific<-2, b> : public engine<-2, VALUE(*)(VALUE, VALUE)> {};
/// @endcond
};
a bit terse Doxygen comments [ci skip] Creative use of `@copydoc` Doxygen command and abusing its half-broken C parser let us delete some lines of documentations, while preserving document coverages.
2020-01-30 23:10:55 -05:00
struct rb_define_method : public driver <const char *, ::rb_define_method> {}; ///< Dispatches appropriate driver for ::rb_define_method.
struct rb_define_method_id : public driver <ID, ::rb_define_method_id> {}; ///< Dispatches appropriate driver for ::rb_define_method_id.
struct rb_define_private_method : public driver <const char *, ::rb_define_private_method> {}; ///< Dispatches appropriate driver for ::rb_define_private_method.
struct rb_define_protected_method : public driver <const char *, ::rb_define_protected_method> {}; ///< Dispatches appropriate driver for ::rb_define_protected_method.
struct rb_define_singleton_method : public driver <const char *, ::rb_define_singleton_method> {}; ///< Dispatches appropriate driver for ::rb_define_singleton_method.
struct rb_define_module_function : public driver <const char *, ::rb_define_module_function> {}; ///< Dispatches appropriate driver for ::rb_define_module_function.
struct rb_define_global_function : public driver0<const char *, ::rb_define_global_function> {}; ///< Dispatches appropriate driver for ::rb_define_global_function.
template metaprogramming instead of macros C++ (and myself) hates macros. If we could do the same thing in both preprocessor and template, we shall choose template. This particular part of the ruby header is one of such situations.
2020-01-27 21:43:33 -05:00
/// @brief Defines klass\#mid.
/// @param klass Where the method lives.
a bit terse Doxygen comments [ci skip] Creative use of `@copydoc` Doxygen command and abusing its half-broken C parser let us delete some lines of documentations, while preserving document coverages.
2020-01-30 23:10:55 -05:00
/// @copydetails #rb_define_global_function(mid, func, arity)
Make global ruby namespace usage explicit If the use of the ruby namespace isn't prepended by `::` to make it explicit that the global ruby namespace is referenced here, it can clash with other non-global namespace named ruby, e.g. ``` // declaration namespace myproject { namespace ruby { // my ruby classes } } // implementation using namespace myproject; [...] rb_define_method(...); [...] ``` leads to the following error: ``` ../ruby/choice.cc: In function 'void {anonymous}::do_register_choice()': ../ruby/choice.cc:342:9: error: reference to 'ruby' is ambiguous 342 | rb_define_method(c_choices, "each", RUBY_FUNC_CAST(&choices_each), 0); | ^~~~~~~~~~~~~~~~ In file included from ../ruby/choice.cc:20: ../ruby/paludis_ruby.hh:53:15: note: candidates are: 'namespace paludis::ruby { }' 53 | namespace ruby | ^~~~ In file included from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby/backward/2/stdalign.h:23, from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby/defines.h:77, from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby/ruby.h:23, from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby.h:38, from ../ruby/paludis_ruby.hh:44, from ../ruby/choice.cc:20: /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby/internal/stdalign.h:92:11: note: 'namespace ruby { }' 92 | namespace ruby { | ^~~~ In file included from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby/internal/anyargs.h:83, from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby/ruby.h:24, from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby.h:38, from ../ruby/paludis_ruby.hh:44, from ../ruby/choice.cc:20: ../ruby/choice.cc:342:9: error: '::define' has not been declared 342 | rb_define_method(c_choices, "each", RUBY_FUNC_CAST(&choices_each), 0); | ^~~~~~~~~~~~~~~~ ../ruby/choice.cc:344:9: error: reference to 'ruby' is ambiguous 344 | rb_define_method(c_choices, "find_by_name_with_prefix", RUBY_FUNC_CAST(&choices_find_by_name_with_prefix), 1); | ^~~~~~~~~~~~~~~~ ```
2021-02-14 08:12:32 -05:00
#define rb_define_method(klass, mid, func, arity) ::ruby::backward::cxxanyargs::define_method::rb_define_method::specific<arity>::define(klass, mid, func)
template metaprogramming instead of macros C++ (and myself) hates macros. If we could do the same thing in both preprocessor and template, we shall choose template. This particular part of the ruby header is one of such situations.
2020-01-27 21:43:33 -05:00
a bit terse Doxygen comments [ci skip] Creative use of `@copydoc` Doxygen command and abusing its half-broken C parser let us delete some lines of documentations, while preserving document coverages.
2020-01-30 23:10:55 -05:00
/// @copydoc #rb_define_method(klass, mid, func, arity)
Make global ruby namespace usage explicit If the use of the ruby namespace isn't prepended by `::` to make it explicit that the global ruby namespace is referenced here, it can clash with other non-global namespace named ruby, e.g. ``` // declaration namespace myproject { namespace ruby { // my ruby classes } } // implementation using namespace myproject; [...] rb_define_method(...); [...] ``` leads to the following error: ``` ../ruby/choice.cc: In function 'void {anonymous}::do_register_choice()': ../ruby/choice.cc:342:9: error: reference to 'ruby' is ambiguous 342 | rb_define_method(c_choices, "each", RUBY_FUNC_CAST(&choices_each), 0); | ^~~~~~~~~~~~~~~~ In file included from ../ruby/choice.cc:20: ../ruby/paludis_ruby.hh:53:15: note: candidates are: 'namespace paludis::ruby { }' 53 | namespace ruby | ^~~~ In file included from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby/backward/2/stdalign.h:23, from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby/defines.h:77, from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby/ruby.h:23, from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby.h:38, from ../ruby/paludis_ruby.hh:44, from ../ruby/choice.cc:20: /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby/internal/stdalign.h:92:11: note: 'namespace ruby { }' 92 | namespace ruby { | ^~~~ In file included from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby/internal/anyargs.h:83, from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby/ruby.h:24, from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby.h:38, from ../ruby/paludis_ruby.hh:44, from ../ruby/choice.cc:20: ../ruby/choice.cc:342:9: error: '::define' has not been declared 342 | rb_define_method(c_choices, "each", RUBY_FUNC_CAST(&choices_each), 0); | ^~~~~~~~~~~~~~~~ ../ruby/choice.cc:344:9: error: reference to 'ruby' is ambiguous 344 | rb_define_method(c_choices, "find_by_name_with_prefix", RUBY_FUNC_CAST(&choices_find_by_name_with_prefix), 1); | ^~~~~~~~~~~~~~~~ ```
2021-02-14 08:12:32 -05:00
#define rb_define_method_id(klass, mid, func, arity) ::ruby::backward::cxxanyargs::define_method::rb_define_method_id::specific<arity>::define(klass, mid, func)
template metaprogramming instead of macros C++ (and myself) hates macros. If we could do the same thing in both preprocessor and template, we shall choose template. This particular part of the ruby header is one of such situations.
2020-01-27 21:43:33 -05:00
/// @brief Defines klass\#mid and makes it private.
a bit terse Doxygen comments [ci skip] Creative use of `@copydoc` Doxygen command and abusing its half-broken C parser let us delete some lines of documentations, while preserving document coverages.
2020-01-30 23:10:55 -05:00
/// @copydetails #rb_define_method(klass, mid, func, arity)
Make global ruby namespace usage explicit If the use of the ruby namespace isn't prepended by `::` to make it explicit that the global ruby namespace is referenced here, it can clash with other non-global namespace named ruby, e.g. ``` // declaration namespace myproject { namespace ruby { // my ruby classes } } // implementation using namespace myproject; [...] rb_define_method(...); [...] ``` leads to the following error: ``` ../ruby/choice.cc: In function 'void {anonymous}::do_register_choice()': ../ruby/choice.cc:342:9: error: reference to 'ruby' is ambiguous 342 | rb_define_method(c_choices, "each", RUBY_FUNC_CAST(&choices_each), 0); | ^~~~~~~~~~~~~~~~ In file included from ../ruby/choice.cc:20: ../ruby/paludis_ruby.hh:53:15: note: candidates are: 'namespace paludis::ruby { }' 53 | namespace ruby | ^~~~ In file included from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby/backward/2/stdalign.h:23, from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby/defines.h:77, from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby/ruby.h:23, from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby.h:38, from ../ruby/paludis_ruby.hh:44, from ../ruby/choice.cc:20: /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby/internal/stdalign.h:92:11: note: 'namespace ruby { }' 92 | namespace ruby { | ^~~~ In file included from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby/internal/anyargs.h:83, from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby/ruby.h:24, from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby.h:38, from ../ruby/paludis_ruby.hh:44, from ../ruby/choice.cc:20: ../ruby/choice.cc:342:9: error: '::define' has not been declared 342 | rb_define_method(c_choices, "each", RUBY_FUNC_CAST(&choices_each), 0); | ^~~~~~~~~~~~~~~~ ../ruby/choice.cc:344:9: error: reference to 'ruby' is ambiguous 344 | rb_define_method(c_choices, "find_by_name_with_prefix", RUBY_FUNC_CAST(&choices_find_by_name_with_prefix), 1); | ^~~~~~~~~~~~~~~~ ```
2021-02-14 08:12:32 -05:00
#define rb_define_private_method(klass, mid, func, arity) ::ruby::backward::cxxanyargs::define_method::rb_define_private_method::specific<arity>::define(klass, mid, func)
template metaprogramming instead of macros C++ (and myself) hates macros. If we could do the same thing in both preprocessor and template, we shall choose template. This particular part of the ruby header is one of such situations.
2020-01-27 21:43:33 -05:00
/// @brief Defines klass\#mid and makes it protected.
/// @copydetails #rb_define_method
Make global ruby namespace usage explicit If the use of the ruby namespace isn't prepended by `::` to make it explicit that the global ruby namespace is referenced here, it can clash with other non-global namespace named ruby, e.g. ``` // declaration namespace myproject { namespace ruby { // my ruby classes } } // implementation using namespace myproject; [...] rb_define_method(...); [...] ``` leads to the following error: ``` ../ruby/choice.cc: In function 'void {anonymous}::do_register_choice()': ../ruby/choice.cc:342:9: error: reference to 'ruby' is ambiguous 342 | rb_define_method(c_choices, "each", RUBY_FUNC_CAST(&choices_each), 0); | ^~~~~~~~~~~~~~~~ In file included from ../ruby/choice.cc:20: ../ruby/paludis_ruby.hh:53:15: note: candidates are: 'namespace paludis::ruby { }' 53 | namespace ruby | ^~~~ In file included from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby/backward/2/stdalign.h:23, from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby/defines.h:77, from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby/ruby.h:23, from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby.h:38, from ../ruby/paludis_ruby.hh:44, from ../ruby/choice.cc:20: /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby/internal/stdalign.h:92:11: note: 'namespace ruby { }' 92 | namespace ruby { | ^~~~ In file included from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby/internal/anyargs.h:83, from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby/ruby.h:24, from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby.h:38, from ../ruby/paludis_ruby.hh:44, from ../ruby/choice.cc:20: ../ruby/choice.cc:342:9: error: '::define' has not been declared 342 | rb_define_method(c_choices, "each", RUBY_FUNC_CAST(&choices_each), 0); | ^~~~~~~~~~~~~~~~ ../ruby/choice.cc:344:9: error: reference to 'ruby' is ambiguous 344 | rb_define_method(c_choices, "find_by_name_with_prefix", RUBY_FUNC_CAST(&choices_find_by_name_with_prefix), 1); | ^~~~~~~~~~~~~~~~ ```
2021-02-14 08:12:32 -05:00
#define rb_define_protected_method(klass, mid, func, arity) ::ruby::backward::cxxanyargs::define_method::rb_define_protected_method::specific<arity>::define(klass, mid, func)
template metaprogramming instead of macros C++ (and myself) hates macros. If we could do the same thing in both preprocessor and template, we shall choose template. This particular part of the ruby header is one of such situations.
2020-01-27 21:43:33 -05:00
a bit terse Doxygen comments [ci skip] Creative use of `@copydoc` Doxygen command and abusing its half-broken C parser let us delete some lines of documentations, while preserving document coverages.
2020-01-30 23:10:55 -05:00
/// @brief Defines klass.mid.(klass, mid, func, arity)
template metaprogramming instead of macros C++ (and myself) hates macros. If we could do the same thing in both preprocessor and template, we shall choose template. This particular part of the ruby header is one of such situations.
2020-01-27 21:43:33 -05:00
/// @copydetails #rb_define_method
Make global ruby namespace usage explicit If the use of the ruby namespace isn't prepended by `::` to make it explicit that the global ruby namespace is referenced here, it can clash with other non-global namespace named ruby, e.g. ``` // declaration namespace myproject { namespace ruby { // my ruby classes } } // implementation using namespace myproject; [...] rb_define_method(...); [...] ``` leads to the following error: ``` ../ruby/choice.cc: In function 'void {anonymous}::do_register_choice()': ../ruby/choice.cc:342:9: error: reference to 'ruby' is ambiguous 342 | rb_define_method(c_choices, "each", RUBY_FUNC_CAST(&choices_each), 0); | ^~~~~~~~~~~~~~~~ In file included from ../ruby/choice.cc:20: ../ruby/paludis_ruby.hh:53:15: note: candidates are: 'namespace paludis::ruby { }' 53 | namespace ruby | ^~~~ In file included from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby/backward/2/stdalign.h:23, from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby/defines.h:77, from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby/ruby.h:23, from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby.h:38, from ../ruby/paludis_ruby.hh:44, from ../ruby/choice.cc:20: /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby/internal/stdalign.h:92:11: note: 'namespace ruby { }' 92 | namespace ruby { | ^~~~ In file included from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby/internal/anyargs.h:83, from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby/ruby.h:24, from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby.h:38, from ../ruby/paludis_ruby.hh:44, from ../ruby/choice.cc:20: ../ruby/choice.cc:342:9: error: '::define' has not been declared 342 | rb_define_method(c_choices, "each", RUBY_FUNC_CAST(&choices_each), 0); | ^~~~~~~~~~~~~~~~ ../ruby/choice.cc:344:9: error: reference to 'ruby' is ambiguous 344 | rb_define_method(c_choices, "find_by_name_with_prefix", RUBY_FUNC_CAST(&choices_find_by_name_with_prefix), 1); | ^~~~~~~~~~~~~~~~ ```
2021-02-14 08:12:32 -05:00
#define rb_define_singleton_method(klass, mid, func, arity) ::ruby::backward::cxxanyargs::define_method::rb_define_singleton_method::specific<arity>::define(klass, mid, func)
template metaprogramming instead of macros C++ (and myself) hates macros. If we could do the same thing in both preprocessor and template, we shall choose template. This particular part of the ruby header is one of such situations.
2020-01-27 21:43:33 -05:00
/// @brief Defines klass\#mid and makes it a module function.
a bit terse Doxygen comments [ci skip] Creative use of `@copydoc` Doxygen command and abusing its half-broken C parser let us delete some lines of documentations, while preserving document coverages.
2020-01-30 23:10:55 -05:00
/// @copydetails #rb_define_method(klass, mid, func, arity)
Make global ruby namespace usage explicit If the use of the ruby namespace isn't prepended by `::` to make it explicit that the global ruby namespace is referenced here, it can clash with other non-global namespace named ruby, e.g. ``` // declaration namespace myproject { namespace ruby { // my ruby classes } } // implementation using namespace myproject; [...] rb_define_method(...); [...] ``` leads to the following error: ``` ../ruby/choice.cc: In function 'void {anonymous}::do_register_choice()': ../ruby/choice.cc:342:9: error: reference to 'ruby' is ambiguous 342 | rb_define_method(c_choices, "each", RUBY_FUNC_CAST(&choices_each), 0); | ^~~~~~~~~~~~~~~~ In file included from ../ruby/choice.cc:20: ../ruby/paludis_ruby.hh:53:15: note: candidates are: 'namespace paludis::ruby { }' 53 | namespace ruby | ^~~~ In file included from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby/backward/2/stdalign.h:23, from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby/defines.h:77, from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby/ruby.h:23, from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby.h:38, from ../ruby/paludis_ruby.hh:44, from ../ruby/choice.cc:20: /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby/internal/stdalign.h:92:11: note: 'namespace ruby { }' 92 | namespace ruby { | ^~~~ In file included from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby/internal/anyargs.h:83, from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby/ruby.h:24, from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby.h:38, from ../ruby/paludis_ruby.hh:44, from ../ruby/choice.cc:20: ../ruby/choice.cc:342:9: error: '::define' has not been declared 342 | rb_define_method(c_choices, "each", RUBY_FUNC_CAST(&choices_each), 0); | ^~~~~~~~~~~~~~~~ ../ruby/choice.cc:344:9: error: reference to 'ruby' is ambiguous 344 | rb_define_method(c_choices, "find_by_name_with_prefix", RUBY_FUNC_CAST(&choices_find_by_name_with_prefix), 1); | ^~~~~~~~~~~~~~~~ ```
2021-02-14 08:12:32 -05:00
#define rb_define_module_function(klass, mid, func, arity) ::ruby::backward::cxxanyargs::define_method::rb_define_module_function::specific<arity>::define(klass, mid, func)
template metaprogramming instead of macros C++ (and myself) hates macros. If we could do the same thing in both preprocessor and template, we shall choose template. This particular part of the ruby header is one of such situations.
2020-01-27 21:43:33 -05:00
Fix a typo [ci skip]
2020-01-28 18:30:39 -05:00
/// @brief Defines ::rb_mKernel \#mid.
template metaprogramming instead of macros C++ (and myself) hates macros. If we could do the same thing in both preprocessor and template, we shall choose template. This particular part of the ruby header is one of such situations.
2020-01-27 21:43:33 -05:00
/// @param mid Name of the defining method.
/// @param func Implementation of \#mid.
/// @param arity Arity of \#mid.
Make global ruby namespace usage explicit If the use of the ruby namespace isn't prepended by `::` to make it explicit that the global ruby namespace is referenced here, it can clash with other non-global namespace named ruby, e.g. ``` // declaration namespace myproject { namespace ruby { // my ruby classes } } // implementation using namespace myproject; [...] rb_define_method(...); [...] ``` leads to the following error: ``` ../ruby/choice.cc: In function 'void {anonymous}::do_register_choice()': ../ruby/choice.cc:342:9: error: reference to 'ruby' is ambiguous 342 | rb_define_method(c_choices, "each", RUBY_FUNC_CAST(&choices_each), 0); | ^~~~~~~~~~~~~~~~ In file included from ../ruby/choice.cc:20: ../ruby/paludis_ruby.hh:53:15: note: candidates are: 'namespace paludis::ruby { }' 53 | namespace ruby | ^~~~ In file included from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby/backward/2/stdalign.h:23, from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby/defines.h:77, from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby/ruby.h:23, from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby.h:38, from ../ruby/paludis_ruby.hh:44, from ../ruby/choice.cc:20: /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby/internal/stdalign.h:92:11: note: 'namespace ruby { }' 92 | namespace ruby { | ^~~~ In file included from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby/internal/anyargs.h:83, from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby/ruby.h:24, from /usr/x86_64-pc-linux-gnu/include/ruby-3.0/ruby.h:38, from ../ruby/paludis_ruby.hh:44, from ../ruby/choice.cc:20: ../ruby/choice.cc:342:9: error: '::define' has not been declared 342 | rb_define_method(c_choices, "each", RUBY_FUNC_CAST(&choices_each), 0); | ^~~~~~~~~~~~~~~~ ../ruby/choice.cc:344:9: error: reference to 'ruby' is ambiguous 344 | rb_define_method(c_choices, "find_by_name_with_prefix", RUBY_FUNC_CAST(&choices_find_by_name_with_prefix), 1); | ^~~~~~~~~~~~~~~~ ```
2021-02-14 08:12:32 -05:00
#define rb_define_global_function(mid, func, arity) ::ruby::backward::cxxanyargs::define_method::rb_define_global_function::specific<arity>::define(mid, func)
template metaprogramming instead of macros C++ (and myself) hates macros. If we could do the same thing in both preprocessor and template, we shall choose template. This particular part of the ruby header is one of such situations.
2020-01-27 21:43:33 -05:00
}}}}}
add include/ruby/backward/cxxanyargs.hpp Compilation of extension libraries written in C++ are reportedly broken due to https://github.com/ruby/ruby/pull/2404 The root cause of this issue was that the definition of ANYARGS differ between C and C++, and that of C++ is incompatible with the updated ones. We are using the incompatibility against itself. In C++ two distinct function prototypes can be overloaded. We provide the old, ANYARGSed prototypes in addition to the current granular ones; and let the older ones warn about types.
2019-09-05 10:50:45 -04:00
using namespace ruby::backward::cxxanyargs;
#endif // RUBY_BACKWARD_CXXANYARGS_HPP
Copy permalink