kreuzberg 4.0.0.rc1 → 4.0.0.rc2

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

@@ -0,0 +1,153 @@
+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

@@ -0,0 +1,48 @@
+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

@@ -0,0 +1,36 @@
+# 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

@@ -0,0 +1,21 @@
+//! 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

@@ -0,0 +1,11 @@
+//! 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

@@ -0,0 +1,34 @@
+#![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

@@ -0,0 +1,371 @@
+//! 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)
+}