kreuzberg 4.0.0.rc2 → 4.0.1

data/vendor/rb-sys/build/stable_api_config.rs

@@ -1,153 +0,0 @@
-use rb_sys_build::{RbConfig, RubyEngine};
-
-use crate::{
-    features::is_env_variable_defined,
-    version::{MIN_SUPPORTED_STABLE_VERSION, Version},
-};
-use std::{convert::TryFrom, error::Error, path::Path};
-
-pub fn setup(rb_config: &RbConfig) -> Result<(), Box<dyn Error>> {
-    let ruby_version = Version::current(rb_config);
-    let ruby_engine = rb_config.ruby_engine();
-    let strategy = Strategy::try_from((ruby_engine, ruby_version))?;
-
-    strategy.apply()?;
-
-    Ok(())
-}
-
-#[derive(Debug)]
-enum Strategy {
-    RustOnly(Version),
-    CompiledOnly,
-    RustThenCompiled(Version),
-    Testing(Version),
-}
-
-impl TryFrom<(RubyEngine, Version)> for Strategy {
-    type Error = Box<dyn Error>;
-
-    fn try_from((engine, current_ruby_version): (RubyEngine, Version)) -> Result<Self, Self::Error> {
-        let mut strategy = None;
-
-        match engine {
-            RubyEngine::TruffleRuby => {
-                return Ok(Strategy::CompiledOnly);
-            }
-            RubyEngine::JRuby => {
-                return Err("JRuby is not supported".into());
-            }
-            RubyEngine::Mri => {}
-        }
-
-        if current_ruby_version.is_stable() {
-            strategy = Some(Strategy::RustOnly(current_ruby_version));
-        } else {
-            maybe_warn_old_ruby_version(current_ruby_version);
-        }
-
-        if is_fallback_enabled() {
-            strategy = Some(Strategy::RustThenCompiled(current_ruby_version));
-        }
-
-        if is_testing() {
-            strategy = Some(Strategy::Testing(current_ruby_version));
-        }
-
-        if is_force_enabled() {
-            strategy = Some(Strategy::CompiledOnly);
-        }
-
-        if let Some(strategy) = strategy {
-            return Ok(strategy);
-        }
-
-        Err("Stable API is needed but could not find a candidate. Try enabling the `stable-api-compiled-fallback` feature in rb-sys.".into())
-    }
-}
-
-impl Strategy {
-    fn apply(self) -> Result<(), Box<dyn Error>> {
-        println!("cargo:rustc-check-cfg=cfg(stable_api_include_rust_impl)");
-        println!("cargo:rustc-check-cfg=cfg(stable_api_enable_compiled_mod)");
-        println!("cargo:rustc-check-cfg=cfg(stable_api_export_compiled_as_api)");
-        println!("cargo:rustc-check-cfg=cfg(stable_api_has_rust_impl)");
-        match self {
-            Strategy::RustOnly(current_ruby_version) => {
-                if current_ruby_version.is_stable() {
-                    println!("cargo:rustc-cfg=stable_api_include_rust_impl");
-                } else {
-                    return Err(format!("A stable Ruby API is needed but could not find a candidate. If you are using a stable version of Ruby, try upgrading rb-sys. Otherwise if you are testing against ruby-head or Ruby < {}, enable the `stable-api-compiled-fallback` feature in rb-sys.", MIN_SUPPORTED_STABLE_VERSION).into());
-                }
-            }
-            Strategy::CompiledOnly => {
-                compile()?;
-                println!("cargo:rustc-cfg=stable_api_enable_compiled_mod");
-                println!("cargo:rustc-cfg=stable_api_export_compiled_as_api");
-            }
-            Strategy::RustThenCompiled(current_ruby_version) => {
-                if current_ruby_version.is_stable() {
-                    println!("cargo:rustc-cfg=stable_api_has_rust_impl");
-                    println!("cargo:rustc-cfg=stable_api_include_rust_impl");
-                } else {
-                    compile()?;
-                    println!("cargo:rustc-cfg=stable_api_enable_compiled_mod");
-                    println!("cargo:rustc-cfg=stable_api_export_compiled_as_api");
-                }
-            }
-            Strategy::Testing(current_ruby_version) => {
-                compile()?;
-
-                println!("cargo:rustc-cfg=stable_api_enable_compiled_mod");
-
-                if current_ruby_version.is_stable() {
-                    println!("cargo:rustc-cfg=stable_api_include_rust_impl");
-                } else {
-                    println!("cargo:rustc-cfg=stable_api_export_compiled_as_api");
-                }
-            }
-        };
-
-        Ok(())
-    }
-}
-
-fn is_fallback_enabled() -> bool {
-    println!("cargo:rerun-if-env-changed=RB_SYS_STABLE_API_COMPILED_FALLBACK");
-
-    is_env_variable_defined("CARGO_FEATURE_STABLE_API_COMPILED_FALLBACK")
-        || cfg!(rb_sys_use_stable_api_compiled_fallback)
-        || is_env_variable_defined("RB_SYS_STABLE_API_COMPILED_FALLBACK")
-}
-
-fn is_force_enabled() -> bool {
-    println!("cargo:rerun-if-env-changed=RB_SYS_STABLE_API_COMPILED_FORCE");
-
-    is_env_variable_defined("CARGO_FEATURE_STABLE_API_COMPILED_FORCE")
-        || cfg!(rb_sys_force_stable_api_compiled)
-        || is_env_variable_defined("RB_SYS_STABLE_API_COMPILED_FORCE")
-}
-
-fn is_testing() -> bool {
-    is_env_variable_defined("CARGO_FEATURE_STABLE_API_COMPILED_TESTING")
-}
-
-fn maybe_warn_old_ruby_version(current_ruby_version: Version) {
-    if current_ruby_version < MIN_SUPPORTED_STABLE_VERSION {
-        println!(
-            "cargo:warning=Support for Ruby {} will be removed in a future release.",
-            current_ruby_version
-        );
-    }
-}
-
-fn compile() -> Result<(), Box<dyn Error>> {
-    eprintln!("INFO: Compiling the stable API compiled module");
-    let mut build = rb_sys_build::cc::Build::new();
-    let crate_dir = Path::new(env!("CARGO_MANIFEST_DIR"));
-    let path = crate_dir.join("src").join("stable_api").join("compiled.c");
-    eprintln!("cargo:rerun-if-changed={}", path.display());
-
-    build.file(path);
-    build.try_compile("compiled")
-}

data/vendor/rb-sys/build/version.rs

@@ -1,48 +0,0 @@
-use crate::RbConfig;
-
-#[allow(dead_code)]
-pub const LATEST_STABLE_VERSION: Version = Version::new(3, 4);
-#[allow(dead_code)]
-pub const MIN_SUPPORTED_STABLE_VERSION: Version = Version::new(2, 6);
-
-#[derive(Debug, PartialEq, Eq, PartialOrd, Clone, Copy)]
-pub struct Version(u32, u32);
-
-impl Version {
-    pub const fn new(major: u32, minor: u32) -> Self {
-        Self(major, minor)
-    }
-
-    pub fn major(&self) -> u32 {
-        self.0
-    }
-
-    pub fn minor(&self) -> u32 {
-        self.1
-    }
-
-    pub fn current(rbconfig: &RbConfig) -> Version {
-        match (rbconfig.get("MAJOR"), rbconfig.get("MINOR")) {
-            (Some(major), Some(minor)) => Version::new(major.parse::<u32>().unwrap(), minor.parse::<u32>().unwrap()),
-            _ => {
-                // Try to parse out the first 3 components of the version string (for truffleruby)
-                let version_string = rbconfig.get("ruby_version").expect("ruby_version");
-                let mut parts = version_string.split('.').map(|s| s.parse::<u32>());
-                let major = parts.next().expect("major").unwrap();
-                let minor = parts.next().expect("minor").unwrap();
-                Version::new(major, minor)
-            }
-        }
-    }
-
-    #[allow(dead_code)]
-    pub fn is_stable(&self) -> bool {
-        *self >= MIN_SUPPORTED_STABLE_VERSION && *self <= LATEST_STABLE_VERSION
-    }
-}
-
-impl std::fmt::Display for Version {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        write!(f, "{}.{}", self.0, self.1)
-    }
-}

data/vendor/rb-sys/readme.md

@@ -1,36 +0,0 @@
-# rb-sys
-
-[![Join the discussion](https://img.shields.io/badge/slack-chat-blue.svg)](https://join.slack.com/t/oxidize-rb/shared_invite/zt-16zv5tqte-Vi7WfzxCesdo2TqF_RYBCw)
-
-Autogenerated Rust bindings for Ruby. Uses the [`rust-bindgen`](https://github.com/rust-lang/rust-bindgen) crate to
-generate bindings from the `ruby.h` header.
-
-## Notice
-
-This is a very low-level library. If you are looking to write a gem in Rust, you should probably use
-https://github.com/matsadler/magnus crate, with the `rb-sys-interop` feature.
-
-If you actually _need_ raw/unsafe bindings to libruby, then this crate is for you!
-
-## Documentation
-
-For comprehensive documentation, please refer to the [Ruby on Rust Book](https://oxidize-rb.github.io/rb-sys/), which
-includes:
-
-- [API Reference for rb-sys Features](https://oxidize-rb.github.io/rb-sys/api-reference/rb-sys-features.html)
-- [Usage examples and tutorials](https://oxidize-rb.github.io/rb-sys/introduction.html)
-- [Memory management guidance](https://oxidize-rb.github.io/rb-sys/memory-management.html)
-
-## License
-
-Licensed under either of
-
-- Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
-- MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
-
-at your option.
-
-### Contribution
-
-Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as
-defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.

data/vendor/rb-sys/src/bindings.rs

@@ -1,21 +0,0 @@
-//! Raw bindings to libruby, generated by bindgen.
-//!
-//! This module contains the raw bindings to libruby, generated by bindgen.
-
-#![allow(non_upper_case_globals)]
-#![allow(non_camel_case_types)]
-#![allow(non_snake_case)]
-#![allow(unknown_lints)]
-#![allow(deref_nullptr)]
-#![warn(unknown_lints)]
-#![allow(clippy::all)]
-#![allow(rustdoc::broken_intra_doc_links)]
-#![allow(rustdoc::invalid_rust_codeblocks)]
-#![allow(rustdoc::invalid_html_tags)]
-#![allow(deprecated)]
-#![allow(dead_code)]
-
-include!(env!("RB_SYS_BINDINGS_PATH"));
-
-pub use uncategorized::*;
-pub use unstable::*;

data/vendor/rb-sys/src/hidden.rs

@@ -1,11 +0,0 @@
-//! Hidden symbols from Ruby that we need to link to, not exposed to users.
-//!
-//! Note: Using these symbols is an absolute last resort. Try to use the
-//! official Ruby C API if at all possible.
-
-extern "C" {
-    /// A pointer to the current Ruby VM.
-    #[cfg(all(ruby_gt_2_4, ruby_lte_3_2))]
-    #[cfg(ruby_engine = "mri")]
-    pub(crate) static ruby_current_vm_ptr: *mut crate::ruby_vm_t;
-}

data/vendor/rb-sys/src/lib.rs

@@ -1,34 +0,0 @@
-#![allow(rustdoc::bare_urls)]
-#![doc = include_str!("../readme.md")]
-
-pub mod bindings;
-#[cfg(feature = "stable-api")]
-pub mod macros;
-pub mod memory;
-pub mod special_consts;
-#[cfg(feature = "stable-api")]
-pub mod stable_api;
-pub mod symbol;
-pub mod tracking_allocator;
-pub mod value_type;
-
-mod hidden;
-mod ruby_abi_version;
-mod utils;
-
-pub use bindings::*;
-#[cfg(feature = "stable-api")]
-pub use macros::*;
-pub use ruby_abi_version::*;
-pub use special_consts::*;
-#[cfg(feature = "stable-api")]
-pub use stable_api::StableApiDefinition;
-pub use value_type::*;
-
-#[deprecated(since = "0.9.79", note = "Use `VALUE` instead")]
-pub type Value = VALUE;
-#[deprecated(since = "0.9.79", note = "Use `VALUE` instead")]
-pub type RubyValue = VALUE;
-
-#[cfg(use_global_allocator)]
-set_global_tracking_allocator!();

data/vendor/rb-sys/src/macros.rs

@@ -1,371 +0,0 @@
-//! Implementation of Ruby macros.
-//!
-//! Since macros are rely on the C preprocessor, or defined as `inline` C
-//! functions, they are not available when linking libruby. In order to use the
-//! libruby macros from Rust, `rb-sys` implements them using the following
-//! strategies:
-//!
-//! 1. For stable versions of Ruby, the macros are implemented as Rust functions
-//! 2. For ruby-head, the macros are implemented as C functions that are linked
-//!    into the crate.
-
-#![allow(rustdoc::broken_intra_doc_links)]
-#![allow(non_upper_case_globals)]
-#![allow(non_snake_case)]
-
-use crate::StableApiDefinition;
-use crate::VALUE;
-use crate::rb_data_type_t;
-use crate::ruby_value_type;
-use crate::stable_api::get_default as api;
-use std::ffi::c_void;
-use std::os::raw::{c_char, c_long};
-
-/// Emulates Ruby's "if" statement.
-///
-/// - @param[in]  obj    An arbitrary ruby object.
-/// - @retval     false  `obj` is either ::RUBY_Qfalse or ::RUBY_Qnil.
-/// - @retval     true   Anything else.
-///
-/// ```
-/// use rb_sys::special_consts::*;
-///
-/// assert!(!TEST(Qfalse));
-/// assert!(!TEST(Qnil));
-/// assert!(TEST(Qtrue));
-/// ```
-#[inline]
-pub fn TEST<T: Into<VALUE>>(obj: T) -> bool {
-    api().rb_test(obj.into())
-}
-
-/// Checks if the given object is nil.
-///
-/// - @param[in]  obj    An arbitrary ruby object.
-/// - @retval     true   `obj` is ::RUBY_Qnil.
-/// - @retval     false  Anything else.
-///
-/// ### Example
-///
-/// ```
-/// use rb_sys::special_consts::*;
-///
-/// assert!(NIL_P(Qnil));
-/// assert!(!NIL_P(Qtrue));
-/// ```
-#[inline]
-pub fn NIL_P<T: Into<VALUE>>(obj: T) -> bool {
-    api().nil_p(obj.into())
-}
-
-/// Checks if the given object is a so-called Fixnum.
-///
-/// - @param[in]  obj    An arbitrary ruby object.
-/// - @retval     true   `obj` is a Fixnum.
-/// - @retval     false  Anything else.
-/// - @note       Fixnum was  a thing  in the  20th century, but  it is  rather an implementation detail today.
-#[inline]
-pub fn FIXNUM_P<T: Into<VALUE>>(obj: T) -> bool {
-    api().fixnum_p(obj.into())
-}
-
-/// Checks if the given object is a static symbol.
-///
-/// - @param[in]  obj    An arbitrary ruby object.
-/// - @retval     true   `obj` is a static symbol
-/// - @retval     false  Anything else.
-/// - @see        RB_DYNAMIC_SYM_P()
-/// - @see        RB_SYMBOL_P()
-/// - @note       These days  there are static  and dynamic symbols, just  like we once had Fixnum/Bignum back in the old days.
-#[inline]
-pub fn STATIC_SYM_P<T: Into<VALUE>>(obj: T) -> bool {
-    api().static_sym_p(obj.into())
-}
-
-/// Get the backend storage of a Ruby array.
-///
-/// ### Safety
-///
-/// This function is unsafe because it dereferences a raw pointer and returns
-/// raw pointers to Ruby memory. The caller must ensure that the pointer stays live
-/// for the duration of usage the the underlying array (by either GC marking or
-/// keeping the RArray on the stack).
-///
-/// - @param[in]  a  An object of ::RArray.
-/// - @return     Its backend storage.
-#[inline]
-pub unsafe fn RARRAY_CONST_PTR<T: Into<VALUE>>(obj: T) -> *const VALUE {
-    api().rarray_const_ptr(obj.into())
-}
-
-/// Get the length of a Ruby array.
-///
-/// ### Safety
-///
-/// This function is unsafe because it dereferences a raw pointer in order to
-/// access internal Ruby memory.
-///
-/// - @param[in]  a  An object of ::RArray.
-/// - @return     Its length.
-#[inline]
-pub unsafe fn RARRAY_LEN<T: Into<VALUE>>(obj: T) -> c_long {
-    api().rarray_len(obj.into())
-}
-
-/// Get the length of a Ruby string.
-///
-/// ### Safety
-///
-/// This function is unsafe because it dereferences a raw pointer in order to
-/// access internal Ruby memory.
-///
-/// - @param[in]  a  An object of ::RString.
-/// - @return     Its length.
-#[inline]
-pub unsafe fn RSTRING_LEN<T: Into<VALUE>>(obj: T) -> c_long {
-    api().rstring_len(obj.into())
-}
-
-/// Get the backend storage of a Ruby string.
-///
-/// ### Safety
-///
-/// This function is unsafe because it dereferences a raw pointer and returns
-/// raw pointers to Ruby memory.
-///
-/// - @param[in]  a  An object of ::RString.
-/// - @return     Its backend storage
-#[inline]
-pub unsafe fn RSTRING_PTR<T: Into<VALUE>>(obj: T) -> *const c_char {
-    api().rstring_ptr(obj.into())
-}
-
-/// Checks if the given object is a so-called Flonum.
-///
-/// @param[in]  obj    An arbitrary ruby object.
-/// @retval     true   `obj` is a Flonum.
-/// @retval     false  Anything else.
-/// @see        RB_FLOAT_TYPE_P()
-/// @note       These days there are Flonums and non-Flonum floats, just like we
-///             once had Fixnum/Bignum back in the old days.
-#[inline]
-pub fn FLONUM_P<T: Into<VALUE>>(#[allow(unused)] obj: T) -> bool {
-    api().flonum_p(obj.into())
-}
-
-/// Checks if  the given  object is  an immediate  i.e. an  object which  has no
-/// corresponding storage inside of the object space.
-///
-/// @param[in]  obj    An arbitrary ruby object.
-/// @retval     true   `obj` is a Flonum.
-/// @retval     false  Anything else.
-/// @see        RB_FLOAT_TYPE_P()
-/// @note       The concept of "immediate" is purely C specific.
-#[inline]
-pub fn IMMEDIATE_P<T: Into<VALUE>>(obj: T) -> bool {
-    api().immediate_p(obj.into())
-}
-
-/// Checks if the given object is of enum ::ruby_special_consts.
-///
-/// @param[in]  obj    An arbitrary ruby object.
-/// @retval     true   `obj` is a special constant.
-/// @retval     false  Anything else.
-///
-/// ### Example
-///
-/// ```
-/// use rb_sys::special_consts::*;
-///
-/// assert!(SPECIAL_CONST_P(Qnil));
-/// assert!(SPECIAL_CONST_P(Qtrue));
-/// assert!(SPECIAL_CONST_P(Qfalse));
-/// ```
-#[inline]
-pub fn SPECIAL_CONST_P<T: Into<VALUE>>(obj: T) -> bool {
-    api().special_const_p(obj.into())
-}
-
-/// Queries the type of the object.
-///
-/// @param[in]  obj  Object in question.
-/// @pre        `obj` must not be a special constant.
-/// @return     The type of `obj`.
-///
-/// # Safety
-/// This function is unsafe because it could dereference a raw pointer when
-/// attemping to access the underlying [`RBasic`] struct.
-#[inline]
-pub unsafe fn RB_BUILTIN_TYPE(obj: VALUE) -> ruby_value_type {
-    api().builtin_type(obj)
-}
-
-/// Queries if the object is an instance of ::rb_cInteger.
-///
-/// @param[in]  obj    Object in question.
-/// @retval     true   It is.
-/// @retval     false  It isn't.
-///
-/// # Safety
-/// This function is unsafe because it could dereference a raw pointer when
-/// attemping to access the underlying [`RBasic`] struct.
-#[inline]
-pub unsafe fn RB_INTEGER_TYPE_P(obj: VALUE) -> bool {
-    api().integer_type_p(obj)
-}
-
-/// Queries if the object is a dynamic symbol.
-///
-/// @param[in]  obj    Object in question.
-/// @retval     true   It is.
-/// @retval     false  It isn't.
-///
-/// # Safety
-/// This function is unsafe because it could dereference a raw pointer when
-/// attemping to access the underlying [`RBasic`] struct.
-#[inline]
-pub unsafe fn RB_DYNAMIC_SYM_P(obj: VALUE) -> bool {
-    api().dynamic_sym_p(obj)
-}
-
-/// Queries if the object is an instance of ::rb_cSymbol.
-///
-/// @param[in]  obj    Object in question.
-/// @retval     true   It is.
-/// @retval     false  It isn't.
-///
-/// # Safety
-/// This function is unsafe because it could dereference a raw pointer when
-/// attemping to access the underlying [`RBasic`] struct.
-#[inline]
-pub unsafe fn RB_SYMBOL_P(obj: VALUE) -> bool {
-    api().symbol_p(obj)
-}
-
-/// Identical to RB_BUILTIN_TYPE(), except it can also accept special constants.
-///
-/// @param[in]  obj  Object in question.
-/// @return     The type of `obj`.
-///
-/// # Safety
-/// This function is unsafe because it could dereference a raw pointer when
-/// attemping to access the underlying [`RBasic`] struct.
-#[inline]
-pub unsafe fn RB_TYPE(value: VALUE) -> ruby_value_type {
-    api().rb_type(value)
-}
-
-/// Queries if the given object is of given type.
-///
-/// @param[in]  obj    An object.
-/// @param[in]  t      A type.
-/// @retval     true   `obj` is of type `t`.
-/// @retval     false  Otherwise.
-///
-/// # Safety
-/// This function is unsafe because it could dereference a raw pointer when
-/// attemping to access the underlying [`RBasic`] struct.
-#[inline]
-#[cfg(ruby_engine = "mri")] // truffleruby provides its own implementation
-pub unsafe fn RB_TYPE_P(obj: VALUE, ty: ruby_value_type) -> bool {
-    api().type_p(obj, ty)
-}
-
-/// Queries if the object is an instance of ::rb_cFloat.
-///
-/// @param[in]  obj    Object in question.
-/// @retval     true   It is.
-/// @retval     false  It isn't.
-///
-/// # Safety
-/// This function is unsafe because it could dereference a raw pointer when
-/// attemping to access the underlying [`RBasic`] struct.
-#[inline]
-pub unsafe fn RB_FLOAT_TYPE_P(obj: VALUE) -> bool {
-    api().float_type_p(obj)
-}
-
-/// Checks if the given object is an RTypedData.
-///
-/// @param[in]  obj    Object in question.
-/// @retval     true   It is an RTypedData.
-/// @retval     false  It isn't an RTypedData.
-///
-/// # Safety
-/// This function is unsafe because it could dereference a raw pointer when
-/// accessing the underlying data structure.
-#[inline]
-pub unsafe fn RTYPEDDATA_P(obj: VALUE) -> bool {
-    api().rtypeddata_p(obj)
-}
-
-/// Checks if the given RTypedData is embedded.
-///
-/// @param[in]  obj    An RTypedData object.
-/// @retval     true   The data is embedded in the object itself.
-/// @retval     false  The data is stored separately.
-///
-/// # Safety
-/// This function is unsafe because it could dereference a raw pointer when
-/// accessing the underlying data structure. The caller must ensure the object
-/// is a valid RTypedData.
-#[inline]
-pub unsafe fn RTYPEDDATA_EMBEDDED_P(obj: VALUE) -> bool {
-    api().rtypeddata_embedded_p(obj)
-}
-
-/// Gets the data type information from an RTypedData object.
-///
-/// @param[in]  obj    An RTypedData object.
-/// @return     Pointer to the rb_data_type_t structure for this object.
-///
-/// # Safety
-/// This function is unsafe because it dereferences a raw pointer to get
-/// access to the underlying data type. The caller must ensure the object
-/// is a valid RTypedData.
-#[inline]
-pub unsafe fn RTYPEDDATA_TYPE(obj: VALUE) -> *const rb_data_type_t {
-    api().rtypeddata_type(obj)
-}
-
-/// Gets the data pointer from an RTypedData object.
-///
-/// @param[in]  obj    An RTypedData object.
-/// @return     Pointer to the wrapped C struct.
-///
-/// # Safety
-/// This function is unsafe because it dereferences a raw pointer to get
-/// access to the underlying data. The caller must ensure the object
-/// is a valid RTypedData.
-#[inline]
-pub unsafe fn RTYPEDDATA_GET_DATA(obj: VALUE) -> *mut c_void {
-    api().rtypeddata_get_data(obj)
-}
-
-/// Checks if the bignum is positive.
-///
-/// @param[in]  b      An object of RBignum.
-/// @retval     false  `b` is less than zero.
-/// @retval     true   Otherwise.
-///
-/// # Safety
-/// This function is unsafe because it could dereference a raw pointer when
-/// accessing the underlying bignum structure.
-#[inline]
-pub unsafe fn RBIGNUM_POSITIVE_P(b: VALUE) -> bool {
-    api().bignum_positive_p(b)
-}
-
-/// Checks if the bignum is negative.
-///
-/// @param[in]  b      An object of RBignum.
-/// @retval     true   `b` is less than zero.
-/// @retval     false  Otherwise.
-///
-/// # Safety
-/// This function is unsafe because it could dereference a raw pointer when
-/// accessing the underlying bignum structure.
-#[inline]
-pub unsafe fn RBIGNUM_NEGATIVE_P(b: VALUE) -> bool {
-    api().bignum_negative_p(b)
-}