kreuzberg 4.0.0.pre.rc.13 → 4.0.0.pre.rc.15

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

@@ -1,53 +1,53 @@
-/// Prevents premature destruction of local objects.
-///
-/// Ruby's garbage collector is conservative; it scans the C level machine stack as well.
-/// Possible in-use Ruby objects must remain visible on stack, to be properly marked as such.
-/// However, Rust's compiler optimizations might remove the references to these objects from
-/// the stack when they are not being used directly.
-///
-/// Consider the following example:
-///
-/// ```ignore
-/// use rb_sys::{rb_str_new_cstr, rb_str_cat_cstr, RSTRING_PTR, rb_gc_guard};
-///
-/// unsafe {
-///     let s = rb_str_new_cstr(" world\0".as_ptr() as _);
-///     let sptr = RSTRING_PTR(s);
-///     let t = rb_str_new_cstr("hello,\0".as_ptr() as _); // Possible GC invocation
-///     let u = rb_str_cat_cstr(t, sptr);
-///     rb_gc_guard!(s); // ensure `s` (and thus `sptr`) do not get GC-ed
-/// }
-/// ```
-///
-/// In this example, without the `rb_gc_guard!`, the last use of `s` is before the last use
-/// of `sptr`. Compilers could think `s` and `t` are allowed to overlap. That would
-/// eliminate `s` from the stack, while `sptr` is still in use. If our GC runs at that
-/// very moment, `s` gets swept out, which also destroys `sptr`.
-///
-/// In order to prevent this scenario, `rb_gc_guard!` must be placed after the last use
-/// of `sptr`. Placing `rb_gc_guard!` before dereferencing `sptr` would be of no use.
-///
-/// Using the `rb_gc_guard!` macro has the following advantages:
-///
-/// - the intent of the macro use is clear.
-///
-/// - `rb_gc_guard!` only affects its call site, without negatively affecting other systems.
-///
-/// # Example
-/// ```no_run
-/// use rb_sys::{rb_utf8_str_new_cstr, rb_gc_guard};
-///
-/// let my_string = unsafe { rb_utf8_str_new_cstr("hello world\0".as_ptr() as _) };
-/// let _ = rb_gc_guard!(my_string);
-/// ```
-#[macro_export]
-macro_rules! rb_gc_guard {
-    ($v:expr) => {{
-        unsafe {
-            let val: $crate::VALUE = $v;
-            let rb_gc_guarded_ptr = std::ptr::read_volatile(&&val);
-            std::arch::asm!("/* {0} */", in(reg) rb_gc_guarded_ptr);
-            *rb_gc_guarded_ptr
-        }
-    }};
-}
+/// Prevents premature destruction of local objects.
+///
+/// Ruby's garbage collector is conservative; it scans the C level machine stack as well.
+/// Possible in-use Ruby objects must remain visible on stack, to be properly marked as such.
+/// However, Rust's compiler optimizations might remove the references to these objects from
+/// the stack when they are not being used directly.
+///
+/// Consider the following example:
+///
+/// ```ignore
+/// use rb_sys::{rb_str_new_cstr, rb_str_cat_cstr, RSTRING_PTR, rb_gc_guard};
+///
+/// unsafe {
+///     let s = rb_str_new_cstr(" world\0".as_ptr() as _);
+///     let sptr = RSTRING_PTR(s);
+///     let t = rb_str_new_cstr("hello,\0".as_ptr() as _); // Possible GC invocation
+///     let u = rb_str_cat_cstr(t, sptr);
+///     rb_gc_guard!(s); // ensure `s` (and thus `sptr`) do not get GC-ed
+/// }
+/// ```
+///
+/// In this example, without the `rb_gc_guard!`, the last use of `s` is before the last use
+/// of `sptr`. Compilers could think `s` and `t` are allowed to overlap. That would
+/// eliminate `s` from the stack, while `sptr` is still in use. If our GC runs at that
+/// very moment, `s` gets swept out, which also destroys `sptr`.
+///
+/// In order to prevent this scenario, `rb_gc_guard!` must be placed after the last use
+/// of `sptr`. Placing `rb_gc_guard!` before dereferencing `sptr` would be of no use.
+///
+/// Using the `rb_gc_guard!` macro has the following advantages:
+///
+/// - the intent of the macro use is clear.
+///
+/// - `rb_gc_guard!` only affects its call site, without negatively affecting other systems.
+///
+/// # Example
+/// ```no_run
+/// use rb_sys::{rb_utf8_str_new_cstr, rb_gc_guard};
+///
+/// let my_string = unsafe { rb_utf8_str_new_cstr("hello world\0".as_ptr() as _) };
+/// let _ = rb_gc_guard!(my_string);
+/// ```
+#[macro_export]
+macro_rules! rb_gc_guard {
+    ($v:expr) => {{
+        unsafe {
+            let val: $crate::VALUE = $v;
+            let rb_gc_guarded_ptr = std::ptr::read_volatile(&&val);
+            std::arch::asm!("/* {0} */", in(reg) rb_gc_guarded_ptr);
+            *rb_gc_guarded_ptr
+        }
+    }};
+}

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

@@ -1,38 +1,38 @@
-//! Helper to define the `ruby_abi_version` function needed for extensions.
-//!
-//! Since Ruby 3.2, gems are required to define a `ruby_abi_version` function.
-//! For C extensions, this is done transparently by including `ruby.h`, but for
-//! Rust we have to define it ourselves. This is enabled automatically by when
-//! compiling a gem.
-
-#[doc(hidden)]
-#[cfg(not(has_ruby_abi_version))]
-pub const __RB_SYS_RUBY_ABI_VERSION: std::os::raw::c_ulonglong = 0;
-
-#[doc(hidden)]
-#[cfg(has_ruby_abi_version)]
-pub const __RB_SYS_RUBY_ABI_VERSION: std::os::raw::c_ulonglong = crate::RUBY_ABI_VERSION as _;
-
-#[doc(hidden)]
-#[no_mangle]
-#[allow(unused)]
-pub extern "C" fn ruby_abi_version() -> std::os::raw::c_ulonglong {
-    __RB_SYS_RUBY_ABI_VERSION
-}
-
-#[doc(hidden)]
-#[no_mangle]
-#[allow(unused)]
-#[cfg(ruby_engine = "truffleruby")]
-pub extern "C" fn rb_tr_abi_version() -> *const std::os::raw::c_char {
-    crate::TRUFFLERUBY_ABI_VERSION.as_ptr() as *const _
-}
-
-#[deprecated(
-    since = "0.9.102",
-    note = "You no longer need to invoke this macro, the `ruby_abi_version` function is defined automatically."
-)]
-#[macro_export]
-macro_rules! ruby_abi_version {
-    () => {};
-}
+//! Helper to define the `ruby_abi_version` function needed for extensions.
+//!
+//! Since Ruby 3.2, gems are required to define a `ruby_abi_version` function.
+//! For C extensions, this is done transparently by including `ruby.h`, but for
+//! Rust we have to define it ourselves. This is enabled automatically by when
+//! compiling a gem.
+
+#[doc(hidden)]
+#[cfg(not(has_ruby_abi_version))]
+pub const __RB_SYS_RUBY_ABI_VERSION: std::os::raw::c_ulonglong = 0;
+
+#[doc(hidden)]
+#[cfg(has_ruby_abi_version)]
+pub const __RB_SYS_RUBY_ABI_VERSION: std::os::raw::c_ulonglong = crate::RUBY_ABI_VERSION as _;
+
+#[doc(hidden)]
+#[no_mangle]
+#[allow(unused)]
+pub extern "C" fn ruby_abi_version() -> std::os::raw::c_ulonglong {
+    __RB_SYS_RUBY_ABI_VERSION
+}
+
+#[doc(hidden)]
+#[no_mangle]
+#[allow(unused)]
+#[cfg(ruby_engine = "truffleruby")]
+pub extern "C" fn rb_tr_abi_version() -> *const std::os::raw::c_char {
+    crate::TRUFFLERUBY_ABI_VERSION.as_ptr() as *const _
+}
+
+#[deprecated(
+    since = "0.9.102",
+    note = "You no longer need to invoke this macro, the `ruby_abi_version` function is defined automatically."
+)]
+#[macro_export]
+macro_rules! ruby_abi_version {
+    () => {};
+}

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

@@ -1,31 +1,31 @@
-#![allow(rustdoc::broken_intra_doc_links)]
-#![allow(non_upper_case_globals)]
-#![allow(non_snake_case)]
-
-//! Definitions for Ruby's special constants.
-//!
-//! Makes it easier to reference important Ruby constants, without having to dig
-//! around in bindgen's output.
-
-use std::ffi::c_long;
-
-use crate::{ruby_special_consts, VALUE};
-
-pub const Qfalse: ruby_special_consts = ruby_special_consts::RUBY_Qfalse;
-pub const Qtrue: ruby_special_consts = ruby_special_consts::RUBY_Qtrue;
-pub const Qnil: ruby_special_consts = ruby_special_consts::RUBY_Qnil;
-pub const Qundef: ruby_special_consts = ruby_special_consts::RUBY_Qundef;
-pub const IMMEDIATE_MASK: ruby_special_consts = ruby_special_consts::RUBY_IMMEDIATE_MASK;
-pub const FIXNUM_FLAG: ruby_special_consts = ruby_special_consts::RUBY_FIXNUM_FLAG;
-pub const FIXNUM_MIN: c_long = c_long::MIN / 2;
-pub const FIXNUM_MAX: c_long = c_long::MAX / 2;
-pub const FLONUM_MASK: ruby_special_consts = ruby_special_consts::RUBY_FLONUM_MASK;
-pub const FLONUM_FLAG: ruby_special_consts = ruby_special_consts::RUBY_FLONUM_FLAG;
-pub const SYMBOL_FLAG: ruby_special_consts = ruby_special_consts::RUBY_SYMBOL_FLAG;
-
-#[allow(clippy::from_over_into)]
-impl Into<VALUE> for ruby_special_consts {
-    fn into(self) -> VALUE {
-        self as VALUE
-    }
-}
+#![allow(rustdoc::broken_intra_doc_links)]
+#![allow(non_upper_case_globals)]
+#![allow(non_snake_case)]
+
+//! Definitions for Ruby's special constants.
+//!
+//! Makes it easier to reference important Ruby constants, without having to dig
+//! around in bindgen's output.
+
+use std::ffi::c_long;
+
+use crate::{ruby_special_consts, VALUE};
+
+pub const Qfalse: ruby_special_consts = ruby_special_consts::RUBY_Qfalse;
+pub const Qtrue: ruby_special_consts = ruby_special_consts::RUBY_Qtrue;
+pub const Qnil: ruby_special_consts = ruby_special_consts::RUBY_Qnil;
+pub const Qundef: ruby_special_consts = ruby_special_consts::RUBY_Qundef;
+pub const IMMEDIATE_MASK: ruby_special_consts = ruby_special_consts::RUBY_IMMEDIATE_MASK;
+pub const FIXNUM_FLAG: ruby_special_consts = ruby_special_consts::RUBY_FIXNUM_FLAG;
+pub const FIXNUM_MIN: c_long = c_long::MIN / 2;
+pub const FIXNUM_MAX: c_long = c_long::MAX / 2;
+pub const FLONUM_MASK: ruby_special_consts = ruby_special_consts::RUBY_FLONUM_MASK;
+pub const FLONUM_FLAG: ruby_special_consts = ruby_special_consts::RUBY_FLONUM_FLAG;
+pub const SYMBOL_FLAG: ruby_special_consts = ruby_special_consts::RUBY_SYMBOL_FLAG;
+
+#[allow(clippy::from_over_into)]
+impl Into<VALUE> for ruby_special_consts {
+    fn into(self) -> VALUE {
+        self as VALUE
+    }
+}

data/vendor/rb-sys/src/stable_api/compiled.c

@@ -1,179 +1,179 @@
-#include "ruby.h"
-#include "ruby/ruby.h"
-#include "ruby/intern.h"
-#include "ruby/version.h"
-
-// Check that we have Ruby API version macros
-#if !defined(RUBY_API_VERSION_MAJOR)
-#error "RUBY_API_VERSION_MAJOR is not defined, Ruby headers might not be configured correctly"
-#endif
-
-#if !defined(RUBY_API_VERSION_MINOR)
-#error "RUBY_API_VERSION_MINOR is not defined, Ruby headers might not be configured correctly"
-#endif
-
-// Define a macro to check for Ruby 3.3+
-#if RUBY_API_VERSION_MAJOR > 3 || (RUBY_API_VERSION_MAJOR == 3 && RUBY_API_VERSION_MINOR >= 3)
-#define RUBY_VERSION_AT_LEAST_3_3 1
-#else
-#define RUBY_VERSION_AT_LEAST_3_3 0
-#endif
-
-long impl_rstring_len(VALUE obj)
-{
-  return RSTRING_LEN(obj);
-}
-
-char *
-impl_rstring_ptr(VALUE obj)
-{
-  return RSTRING_PTR(obj);
-}
-
-long impl_rarray_len(VALUE obj)
-{
-  return RARRAY_LEN(obj);
-}
-
-const VALUE *
-impl_rarray_const_ptr(VALUE obj)
-{
-  return RARRAY_CONST_PTR(obj);
-}
-
-VALUE
-impl_rbasic_class(VALUE obj)
-{
-  return RBASIC_CLASS(obj);
-}
-
-int impl_frozen_p(VALUE obj)
-{
-  return RB_OBJ_FROZEN(obj);
-}
-
-int impl_special_const_p(VALUE obj)
-{
-  return SPECIAL_CONST_P(obj);
-}
-
-int impl_bignum_positive_p(VALUE obj)
-{
-  return RBIGNUM_POSITIVE_P(obj);
-}
-
-int impl_bignum_negative_p(VALUE obj)
-{
-  return RBIGNUM_NEGATIVE_P(obj);
-}
-
-enum ruby_value_type
-impl_builtin_type(VALUE obj)
-{
-  return RB_BUILTIN_TYPE(obj);
-}
-
-int impl_nil_p(VALUE obj)
-{
-  return NIL_P(obj);
-}
-
-int impl_fixnum_p(VALUE obj)
-{
-  return FIXNUM_P(obj);
-}
-
-int impl_static_sym_p(VALUE obj)
-{
-  return STATIC_SYM_P(obj);
-}
-
-int impl_flonum_p(VALUE obj)
-{
-  return FLONUM_P(obj);
-}
-
-int impl_immediate_p(VALUE obj)
-{
-  return IMMEDIATE_P(obj);
-}
-
-int impl_rb_test(VALUE obj)
-{
-  return RB_TEST(obj);
-}
-
-int impl_type_p(VALUE obj, enum ruby_value_type type)
-{
-  return RB_TYPE_P(obj, type);
-}
-
-int impl_dynamic_sym_p(VALUE obj)
-{
-  return RB_DYNAMIC_SYM_P(obj);
-}
-
-int impl_symbol_p(VALUE obj)
-{
-  return RB_SYMBOL_P(obj);
-}
-
-int impl_float_type_p(VALUE obj)
-{
-  return RB_FLOAT_TYPE_P(obj);
-}
-
-enum ruby_value_type
-impl_rb_type(VALUE obj)
-{
-  return rb_type(obj);
-}
-
-int impl_integer_type_p(VALUE obj)
-{
-  return RB_INTEGER_TYPE_P(obj);
-}
-
-int impl_rstring_interned_p(VALUE obj)
-{
-  Check_Type(obj, T_STRING);
-
-  return !(FL_TEST(obj, RSTRING_FSTR) == 0);
-}
-
-void impl_thread_sleep(struct timeval time)
-{
-  rb_thread_wait_for(time);
-}
-
-// RTypedData implementations
-int impl_rtypeddata_p(VALUE obj)
-{
-  return RTYPEDDATA_P(obj);
-}
-
-int impl_rtypeddata_embedded_p(VALUE obj)
-{
-#if RUBY_VERSION_AT_LEAST_3_3
-  return RTYPEDDATA_EMBEDDED_P(obj);
-#else
-  // On Ruby versions before 3.3, embedded typed data is not supported
-  return 0;
-#endif
-}
-
-const struct rb_data_type_struct *
-impl_rtypeddata_type(VALUE obj)
-{
-  return RTYPEDDATA_TYPE(obj);
-}
-
-void *
-impl_rtypeddata_get_data(VALUE obj)
-{
-#if RUBY_VERSION_AT_LEAST_3_3
-  return RTYPEDDATA_GET_DATA(obj);
-#else
-  return RTYPEDDATA(obj)->data;
-#endif
-}
+#include "ruby.h"
+#include "ruby/ruby.h"
+#include "ruby/intern.h"
+#include "ruby/version.h"
+
+// Check that we have Ruby API version macros
+#if !defined(RUBY_API_VERSION_MAJOR)
+#error "RUBY_API_VERSION_MAJOR is not defined, Ruby headers might not be configured correctly"
+#endif
+
+#if !defined(RUBY_API_VERSION_MINOR)
+#error "RUBY_API_VERSION_MINOR is not defined, Ruby headers might not be configured correctly"
+#endif
+
+// Define a macro to check for Ruby 3.3+
+#if RUBY_API_VERSION_MAJOR > 3 || (RUBY_API_VERSION_MAJOR == 3 && RUBY_API_VERSION_MINOR >= 3)
+#define RUBY_VERSION_AT_LEAST_3_3 1
+#else
+#define RUBY_VERSION_AT_LEAST_3_3 0
+#endif
+
+long impl_rstring_len(VALUE obj)
+{
+  return RSTRING_LEN(obj);
+}
+
+char *
+impl_rstring_ptr(VALUE obj)
+{
+  return RSTRING_PTR(obj);
+}
+
+long impl_rarray_len(VALUE obj)
+{
+  return RARRAY_LEN(obj);
+}
+
+const VALUE *
+impl_rarray_const_ptr(VALUE obj)
+{
+  return RARRAY_CONST_PTR(obj);
+}
+
+VALUE
+impl_rbasic_class(VALUE obj)
+{
+  return RBASIC_CLASS(obj);
+}
+
+int impl_frozen_p(VALUE obj)
+{
+  return RB_OBJ_FROZEN(obj);
+}
+
+int impl_special_const_p(VALUE obj)
+{
+  return SPECIAL_CONST_P(obj);
+}
+
+int impl_bignum_positive_p(VALUE obj)
+{
+  return RBIGNUM_POSITIVE_P(obj);
+}
+
+int impl_bignum_negative_p(VALUE obj)
+{
+  return RBIGNUM_NEGATIVE_P(obj);
+}
+
+enum ruby_value_type
+impl_builtin_type(VALUE obj)
+{
+  return RB_BUILTIN_TYPE(obj);
+}
+
+int impl_nil_p(VALUE obj)
+{
+  return NIL_P(obj);
+}
+
+int impl_fixnum_p(VALUE obj)
+{
+  return FIXNUM_P(obj);
+}
+
+int impl_static_sym_p(VALUE obj)
+{
+  return STATIC_SYM_P(obj);
+}
+
+int impl_flonum_p(VALUE obj)
+{
+  return FLONUM_P(obj);
+}
+
+int impl_immediate_p(VALUE obj)
+{
+  return IMMEDIATE_P(obj);
+}
+
+int impl_rb_test(VALUE obj)
+{
+  return RB_TEST(obj);
+}
+
+int impl_type_p(VALUE obj, enum ruby_value_type type)
+{
+  return RB_TYPE_P(obj, type);
+}
+
+int impl_dynamic_sym_p(VALUE obj)
+{
+  return RB_DYNAMIC_SYM_P(obj);
+}
+
+int impl_symbol_p(VALUE obj)
+{
+  return RB_SYMBOL_P(obj);
+}
+
+int impl_float_type_p(VALUE obj)
+{
+  return RB_FLOAT_TYPE_P(obj);
+}
+
+enum ruby_value_type
+impl_rb_type(VALUE obj)
+{
+  return rb_type(obj);
+}
+
+int impl_integer_type_p(VALUE obj)
+{
+  return RB_INTEGER_TYPE_P(obj);
+}
+
+int impl_rstring_interned_p(VALUE obj)
+{
+  Check_Type(obj, T_STRING);
+
+  return !(FL_TEST(obj, RSTRING_FSTR) == 0);
+}
+
+void impl_thread_sleep(struct timeval time)
+{
+  rb_thread_wait_for(time);
+}
+
+// RTypedData implementations
+int impl_rtypeddata_p(VALUE obj)
+{
+  return RTYPEDDATA_P(obj);
+}
+
+int impl_rtypeddata_embedded_p(VALUE obj)
+{
+#if RUBY_VERSION_AT_LEAST_3_3
+  return RTYPEDDATA_EMBEDDED_P(obj);
+#else
+  // On Ruby versions before 3.3, embedded typed data is not supported
+  return 0;
+#endif
+}
+
+const struct rb_data_type_struct *
+impl_rtypeddata_type(VALUE obj)
+{
+  return RTYPEDDATA_TYPE(obj);
+}
+
+void *
+impl_rtypeddata_get_data(VALUE obj)
+{
+#if RUBY_VERSION_AT_LEAST_3_3
+  return RTYPEDDATA_GET_DATA(obj);
+#else
+  return RTYPEDDATA(obj)->data;
+#endif
+}