datadog-ruby_core_source 3.5.3 → 3.5.5

data/lib/datadog/ruby_core_source/ruby-3.3.0-p0/internal/rational.h

@@ -1,71 +0,0 @@
-#ifndef INTERNAL_RATIONAL_H                              /*-*-C-*-vi:se ft=c:*/
-#define INTERNAL_RATIONAL_H
-/**
- * @author     Ruby developers <ruby-core@ruby-lang.org>
- * @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.
- * @brief      Internal header for Rational.
- */
-#include "ruby/internal/config.h"      /* for HAVE_LIBGMP */
-#include "ruby/ruby.h"          /* for struct RBasic */
-#include "internal/numeric.h"   /* for INT_POSITIVE_P */
-#include "ruby_assert.h"        /* for assert */
-
-struct RRational {
-    struct RBasic basic;
-    VALUE num;
-    VALUE den;
-};
-
-#define RRATIONAL(obj) ((struct RRational *)(obj))
-
-/* rational.c */
-VALUE rb_rational_canonicalize(VALUE x);
-VALUE rb_rational_uminus(VALUE self);
-VALUE rb_rational_plus(VALUE self, VALUE other);
-VALUE rb_rational_minus(VALUE self, VALUE other);
-VALUE rb_rational_mul(VALUE self, VALUE other);
-VALUE rb_rational_div(VALUE self, VALUE other);
-VALUE rb_lcm(VALUE x, VALUE y);
-VALUE rb_rational_reciprocal(VALUE x);
-VALUE rb_cstr_to_rat(const char *, int);
-VALUE rb_rational_hash(VALUE self);
-VALUE rb_rational_abs(VALUE self);
-VALUE rb_rational_cmp(VALUE self, VALUE other);
-VALUE rb_rational_pow(VALUE self, VALUE other);
-VALUE rb_rational_floor(VALUE self, int ndigits);
-VALUE rb_numeric_quo(VALUE x, VALUE y);
-VALUE rb_flo_round_by_rational(int argc, VALUE *argv, VALUE num);
-VALUE rb_float_numerator(VALUE x);
-VALUE rb_float_denominator(VALUE x);
-
-static inline void RATIONAL_SET_NUM(VALUE r, VALUE n);
-static inline void RATIONAL_SET_DEN(VALUE r, VALUE d);
-
-RUBY_SYMBOL_EXPORT_BEGIN
-/* rational.c (export) */
-VALUE rb_gcd(VALUE x, VALUE y);
-VALUE rb_gcd_normal(VALUE self, VALUE other);
-#if defined(HAVE_LIBGMP) && defined(HAVE_GMP_H)
-VALUE rb_gcd_gmp(VALUE x, VALUE y);
-#endif
-RUBY_SYMBOL_EXPORT_END
-
-static inline void
-RATIONAL_SET_NUM(VALUE r, VALUE n)
-{
-    assert(RB_INTEGER_TYPE_P(n));
-    RB_OBJ_WRITE(r, &RRATIONAL(r)->num, n);
-}
-
-static inline void
-RATIONAL_SET_DEN(VALUE r, VALUE d)
-{
-    assert(RB_INTEGER_TYPE_P(d));
-    assert(INT_POSITIVE_P(d));
-    RB_OBJ_WRITE(r, &RRATIONAL(r)->den, d);
-}
-
-#endif /* INTERNAL_RATIONAL_H */

data/lib/datadog/ruby_core_source/ruby-3.3.0-p0/internal/re.h

@@ -1,28 +0,0 @@
-#ifndef INTERNAL_RE_H                                    /*-*-C-*-vi:se ft=c:*/
-#define INTERNAL_RE_H
-/**
- * @author     Ruby developers <ruby-core@ruby-lang.org>
- * @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.
- * @brief      Internal header for Regexp.
- */
-#include "ruby/internal/stdbool.h"     /* for bool */
-#include "ruby/ruby.h"          /* for VALUE */
-
-/* re.c */
-VALUE rb_reg_compile(VALUE str, int options, const char *sourcefile, int sourceline);
-VALUE rb_reg_check_preprocess(VALUE);
-long rb_reg_search0(VALUE, VALUE, long, int, int);
-VALUE rb_reg_match_p(VALUE re, VALUE str, long pos);
-bool rb_reg_start_with_p(VALUE re, VALUE str);
-VALUE rb_reg_hash(VALUE re);
-VALUE rb_reg_equal(VALUE re1, VALUE re2);
-void rb_backref_set_string(VALUE string, long pos, long len);
-void rb_match_unbusy(VALUE);
-int rb_match_count(VALUE match);
-VALUE rb_reg_new_ary(VALUE ary, int options);
-VALUE rb_reg_last_defined(VALUE match);
-
-#endif /* INTERNAL_RE_H */

data/lib/datadog/ruby_core_source/ruby-3.3.0-p0/internal/ruby_parser.h

@@ -1,69 +0,0 @@
-#ifndef INTERNAL_RUBY_PARSE_H
-#define INTERNAL_RUBY_PARSE_H
-
-#include "internal.h"
-#include "internal/imemo.h"
-#include "rubyparser.h"
-#include "vm.h"
-
-RUBY_SYMBOL_EXPORT_BEGIN
-#ifdef UNIVERSAL_PARSER
-void rb_parser_config_initialize(rb_parser_config_t *config);
-#endif
-VALUE rb_parser_set_context(VALUE, const struct rb_iseq_struct *, int);
-VALUE rb_parser_new(void);
-rb_ast_t *rb_parser_compile_string_path(VALUE vparser, VALUE fname, VALUE src, int line);
-RUBY_SYMBOL_EXPORT_END
-
-VALUE rb_parser_end_seen_p(VALUE);
-VALUE rb_parser_encoding(VALUE);
-VALUE rb_parser_set_yydebug(VALUE, VALUE);
-void rb_parser_set_options(VALUE, int, int, int, int);
-void *rb_parser_load_file(VALUE parser, VALUE name);
-void rb_parser_set_script_lines(VALUE vparser, VALUE lines_array);
-void rb_parser_error_tolerant(VALUE vparser);
-void rb_parser_keep_tokens(VALUE vparser);
-
-rb_ast_t *rb_parser_compile_string(VALUE, const char*, VALUE, int);
-rb_ast_t *rb_parser_compile_file_path(VALUE vparser, VALUE fname, VALUE input, int line);
-rb_ast_t *rb_parser_compile_generic(VALUE vparser, VALUE (*lex_gets)(VALUE, int), VALUE fname, VALUE input, int line);
-
-enum lex_state_bits {
-    EXPR_BEG_bit,		/* ignore newline, +/- is a sign. */
-    EXPR_END_bit,		/* newline significant, +/- is an operator. */
-    EXPR_ENDARG_bit,		/* ditto, and unbound braces. */
-    EXPR_ENDFN_bit,		/* ditto, and unbound braces. */
-    EXPR_ARG_bit,		/* newline significant, +/- is an operator. */
-    EXPR_CMDARG_bit,		/* newline significant, +/- is an operator. */
-    EXPR_MID_bit,		/* newline significant, +/- is an operator. */
-    EXPR_FNAME_bit,		/* ignore newline, no reserved words. */
-    EXPR_DOT_bit,		/* right after `.', `&.' or `::', no reserved words. */
-    EXPR_CLASS_bit,		/* immediate after `class', no here document. */
-    EXPR_LABEL_bit,		/* flag bit, label is allowed. */
-    EXPR_LABELED_bit,		/* flag bit, just after a label. */
-    EXPR_FITEM_bit,		/* symbol literal as FNAME. */
-    EXPR_MAX_STATE
-};
-/* examine combinations */
-enum lex_state_e {
-#define DEF_EXPR(n) EXPR_##n = (1 << EXPR_##n##_bit)
-    DEF_EXPR(BEG),
-    DEF_EXPR(END),
-    DEF_EXPR(ENDARG),
-    DEF_EXPR(ENDFN),
-    DEF_EXPR(ARG),
-    DEF_EXPR(CMDARG),
-    DEF_EXPR(MID),
-    DEF_EXPR(FNAME),
-    DEF_EXPR(DOT),
-    DEF_EXPR(CLASS),
-    DEF_EXPR(LABEL),
-    DEF_EXPR(LABELED),
-    DEF_EXPR(FITEM),
-    EXPR_VALUE = EXPR_BEG,
-    EXPR_BEG_ANY  =  (EXPR_BEG | EXPR_MID | EXPR_CLASS),
-    EXPR_ARG_ANY  =  (EXPR_ARG | EXPR_CMDARG),
-    EXPR_END_ANY  =  (EXPR_END | EXPR_ENDARG | EXPR_ENDFN),
-    EXPR_NONE = 0
-};
-#endif /* INTERNAL_RUBY_PARSE_H */

data/lib/datadog/ruby_core_source/ruby-3.3.0-p0/internal/sanitizers.h

@@ -1,186 +0,0 @@
-#ifndef INTERNAL_SANITIZERS_H                            /*-*-C-*-vi:se ft=c:*/
-#define INTERNAL_SANITIZERS_H
-/**
- * @author     Ruby developers <ruby-core@ruby-lang.org>
- * @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.
- * @brief      Internal header for ASAN / MSAN / etc.
- */
-#include "ruby/internal/config.h"
-#include "internal/compilers.h" /* for __has_feature */
-
-#ifdef HAVE_VALGRIND_MEMCHECK_H
-# include <valgrind/memcheck.h>
-#endif
-
-#ifdef HAVE_SANITIZER_ASAN_INTERFACE_H
-# include <sanitizer/asan_interface.h>
-#endif
-
-#ifdef HAVE_SANITIZER_MSAN_INTERFACE_H
-# if __has_feature(memory_sanitizer)
-#  include <sanitizer/msan_interface.h>
-# endif
-#endif
-
-#include "ruby/internal/stdbool.h"     /* for bool */
-#include "ruby/ruby.h"          /* for VALUE */
-
-#if 0
-#elif __has_feature(memory_sanitizer) && __has_feature(address_sanitizer)
-# define ATTRIBUTE_NO_ADDRESS_SAFETY_ANALYSIS(x) \
-    __attribute__((__no_sanitize__("memory, address"), __noinline__)) x
-#elif __has_feature(address_sanitizer)
-# define ATTRIBUTE_NO_ADDRESS_SAFETY_ANALYSIS(x) \
-    __attribute__((__no_sanitize__("address"), __noinline__)) x
-#elif defined(NO_SANITIZE_ADDRESS)
-# define ATTRIBUTE_NO_ADDRESS_SAFETY_ANALYSIS(x) \
-    NO_SANITIZE_ADDRESS(NOINLINE(x))
-#elif defined(NO_ADDRESS_SAFETY_ANALYSIS)
-# define ATTRIBUTE_NO_ADDRESS_SAFETY_ANALYSIS(x) \
-    NO_ADDRESS_SAFETY_ANALYSIS(NOINLINE(x))
-#else
-# define ATTRIBUTE_NO_ADDRESS_SAFETY_ANALYSIS(x) x
-#endif
-
-#if defined(NO_SANITIZE) && RBIMPL_COMPILER_IS(GCC)
-/* GCC warns about unknown sanitizer, which is annoying. */
-# include "internal/warnings.h"
-# undef NO_SANITIZE
-# define NO_SANITIZE(x, y) \
-    COMPILER_WARNING_PUSH; \
-    COMPILER_WARNING_IGNORED(-Wattributes); \
-    __attribute__((__no_sanitize__(x))) y; \
-    COMPILER_WARNING_POP
-#endif
-
-#ifndef NO_SANITIZE
-# define NO_SANITIZE(x, y) y
-#endif
-
-#if !__has_feature(address_sanitizer)
-# define __asan_poison_memory_region(x, y)
-# define __asan_unpoison_memory_region(x, y)
-# define __asan_region_is_poisoned(x, y) 0
-#endif
-
-#if !__has_feature(memory_sanitizer)
-# define __msan_allocated_memory(x, y) ((void)(x), (void)(y))
-# define __msan_poison(x, y) ((void)(x), (void)(y))
-# define __msan_unpoison(x, y) ((void)(x), (void)(y))
-# define __msan_unpoison_string(x) ((void)(x))
-#endif
-
-#ifdef VALGRIND_MAKE_READABLE
-# define VALGRIND_MAKE_MEM_DEFINED(p, n) VALGRIND_MAKE_READABLE((p), (n))
-#endif
-
-#ifdef VALGRIND_MAKE_WRITABLE
-# define VALGRIND_MAKE_MEM_UNDEFINED(p, n) VALGRIND_MAKE_WRITABLE((p), (n))
-#endif
-
-#ifndef VALGRIND_MAKE_MEM_DEFINED
-# define VALGRIND_MAKE_MEM_DEFINED(p, n) 0
-#endif
-
-#ifndef VALGRIND_MAKE_MEM_UNDEFINED
-# define VALGRIND_MAKE_MEM_UNDEFINED(p, n) 0
-#endif
-
-/*!
- * This function asserts that a (continuous) memory region from ptr to size
- * being "poisoned".  Both read / write access to such memory region are
- * prohibited until properly unpoisoned.  The region must be previously
- * allocated (do not pass a freed pointer here), but not necessarily be an
- * entire object that the malloc returns.  You can punch hole a part of a
- * gigantic heap arena.  This is handy when you do not free an allocated memory
- * region to reuse later: poison when you keep it unused, and unpoison when you
- * reuse.
- *
- * \param[in]  ptr   pointer to the beginning of the memory region to poison.
- * \param[in]  size  the length of the memory region to poison.
- */
-static inline void
-asan_poison_memory_region(const volatile void *ptr, size_t size)
-{
-    __msan_poison(ptr, size);
-    __asan_poison_memory_region(ptr, size);
-}
-
-/*!
- * This is a variant of asan_poison_memory_region that takes a VALUE.
- *
- * \param[in]  obj   target object.
- */
-static inline void
-asan_poison_object(VALUE obj)
-{
-    MAYBE_UNUSED(struct RVALUE *) ptr = (void *)obj;
-    asan_poison_memory_region(ptr, SIZEOF_VALUE);
-}
-
-#if !__has_feature(address_sanitizer)
-#define asan_poison_object_if(ptr, obj) ((void)(ptr), (void)(obj))
-#else
-#define asan_poison_object_if(ptr, obj) do { \
-        if (ptr) asan_poison_object(obj); \
-    } while (0)
-#endif
-
-/*!
- * This function predicates if the given object is fully addressable or not.
- *
- * \param[in]  obj        target object.
- * \retval     0          the given object is fully addressable.
- * \retval     otherwise  pointer to first such byte who is poisoned.
- */
-static inline void *
-asan_poisoned_object_p(VALUE obj)
-{
-    MAYBE_UNUSED(struct RVALUE *) ptr = (void *)obj;
-    return __asan_region_is_poisoned(ptr, SIZEOF_VALUE);
-}
-
-/*!
- * This function asserts that a (formally poisoned) memory region from ptr to
- * size is now addressable.  Write access to such memory region gets allowed.
- * However read access might or might not be possible depending on situations,
- * because the region can have contents of previous usages.  That information
- * should be passed by the malloc_p flag.  If that is true, the contents of the
- * region is _not_ fully defined (like the return value of malloc behaves).
- * Reading from there is NG; write something first.  If malloc_p is false on
- * the other hand, that memory region is fully defined and can be read
- * immediately.
- *
- * \param[in]  ptr       pointer to the beginning of the memory region to unpoison.
- * \param[in]  size      the length of the memory region.
- * \param[in]  malloc_p  if the memory region is like a malloc's return value or not.
- */
-static inline void
-asan_unpoison_memory_region(const volatile void *ptr, size_t size, bool malloc_p)
-{
-    __asan_unpoison_memory_region(ptr, size);
-    if (malloc_p) {
-        __msan_allocated_memory(ptr, size);
-    }
-    else {
-        __msan_unpoison(ptr, size);
-    }
-}
-
-/*!
- * This is a variant of asan_unpoison_memory_region that takes a VALUE.
- *
- * \param[in]  obj       target object.
- * \param[in]  malloc_p  if the memory region is like a malloc's return value or not.
- */
-static inline void
-asan_unpoison_object(VALUE obj, bool newobj_p)
-{
-    MAYBE_UNUSED(struct RVALUE *) ptr = (void *)obj;
-    asan_unpoison_memory_region(ptr, SIZEOF_VALUE, newobj_p);
-}
-
-#endif /* INTERNAL_SANITIZERS_H */

data/lib/datadog/ruby_core_source/ruby-3.3.0-p0/internal/signal.h

@@ -1,25 +0,0 @@
-#ifndef INTERNAL_SIGNAL_H                                /*-*-C-*-vi:se ft=c:*/
-#define INTERNAL_SIGNAL_H
-/**
- * @author     Ruby developers <ruby-core@ruby-lang.org>
- * @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.
- * @brief      Internal header for SignalException.
- */
-
-/* signal.c */
-extern int ruby_enable_coredump;
-int rb_get_next_signal(void);
-
-#ifdef POSIX_SIGNAL
-void (*ruby_posix_signal(int, void (*)(int)))(int);
-#endif
-
-RUBY_SYMBOL_EXPORT_BEGIN
-/* signal.c (export) */
-int rb_grantpt(int fd);
-RUBY_SYMBOL_EXPORT_END
-
-#endif /* INTERNAL_SIGNAL_H */

data/lib/datadog/ruby_core_source/ruby-3.3.0-p0/internal/string.h

@@ -1,159 +0,0 @@
-#ifndef INTERNAL_STRING_H                                /*-*-C-*-vi:se ft=c:*/
-#define INTERNAL_STRING_H
-/**
- * @author     Ruby developers <ruby-core@ruby-lang.org>
- * @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.
- * @brief      Internal header for String.
- */
-#include "ruby/internal/config.h"
-#include <stddef.h>             /* for size_t */
-#include "internal/compilers.h" /* for __has_builtin */
-#include "ruby/internal/stdbool.h"     /* for bool */
-#include "ruby/encoding.h"      /* for rb_encoding */
-#include "ruby/ruby.h"          /* for VALUE */
-
-#define STR_NOEMBED      FL_USER1
-#define STR_SHARED       FL_USER2 /* = ELTS_SHARED */
-
-#ifdef rb_fstring_cstr
-# undef rb_fstring_cstr
-#endif
-
-/* string.c */
-VALUE rb_fstring(VALUE);
-VALUE rb_fstring_cstr(const char *str);
-VALUE rb_fstring_enc_new(const char *ptr, long len, rb_encoding *enc);
-int rb_str_buf_cat_escaped_char(VALUE result, unsigned int c, int unicode_p);
-int rb_str_symname_p(VALUE);
-VALUE rb_str_quote_unprintable(VALUE);
-char *rb_str_fill_terminator(VALUE str, const int termlen);
-void rb_str_change_terminator_length(VALUE str, const int oldtermlen, const int termlen);
-VALUE rb_str_locktmp_ensure(VALUE str, VALUE (*func)(VALUE), VALUE arg);
-VALUE rb_str_chomp_string(VALUE str, VALUE chomp);
-VALUE rb_external_str_with_enc(VALUE str, rb_encoding *eenc);
-VALUE rb_str_cat_conv_enc_opts(VALUE newstr, long ofs, const char *ptr, long len,
-                               rb_encoding *from, int ecflags, VALUE ecopts);
-VALUE rb_enc_str_scrub(rb_encoding *enc, VALUE str, VALUE repl);
-VALUE rb_str_escape(VALUE str);
-size_t rb_str_memsize(VALUE);
-char *rb_str_to_cstr(VALUE str);
-const char *ruby_escaped_char(int c);
-void rb_str_make_independent(VALUE str);
-int rb_enc_str_coderange_scan(VALUE str, rb_encoding *enc);
-int rb_ascii8bit_appendable_encoding_index(rb_encoding *enc, unsigned int code);
-VALUE rb_str_include(VALUE str, VALUE arg);
-
-static inline bool STR_EMBED_P(VALUE str);
-static inline bool STR_SHARED_P(VALUE str);
-static inline VALUE QUOTE(VALUE v);
-static inline VALUE QUOTE_ID(ID v);
-static inline bool is_ascii_string(VALUE str);
-static inline bool is_broken_string(VALUE str);
-static inline VALUE rb_str_eql_internal(const VALUE str1, const VALUE str2);
-
-RUBY_SYMBOL_EXPORT_BEGIN
-/* string.c (export) */
-VALUE rb_str_tmp_frozen_acquire(VALUE str);
-void rb_str_tmp_frozen_release(VALUE str, VALUE tmp);
-VALUE rb_setup_fake_str(struct RString *fake_str, const char *name, long len, rb_encoding *enc);
-VALUE rb_str_upto_each(VALUE, VALUE, int, int (*each)(VALUE, VALUE), VALUE);
-VALUE rb_str_upto_endless_each(VALUE, int (*each)(VALUE, VALUE), VALUE);
-void rb_str_make_embedded(VALUE);
-size_t rb_str_size_as_embedded(VALUE);
-bool rb_str_reembeddable_p(VALUE);
-RUBY_SYMBOL_EXPORT_END
-
-VALUE rb_fstring_new(const char *ptr, long len);
-VALUE rb_obj_as_string_result(VALUE str, VALUE obj);
-VALUE rb_str_opt_plus(VALUE x, VALUE y);
-VALUE rb_str_concat_literals(size_t num, const VALUE *strary);
-VALUE rb_str_eql(VALUE str1, VALUE str2);
-VALUE rb_id_quote_unprintable(ID);
-VALUE rb_sym_proc_call(ID mid, int argc, const VALUE *argv, int kw_splat, VALUE passed_proc);
-
-struct rb_execution_context_struct;
-VALUE rb_ec_str_resurrect(struct rb_execution_context_struct *ec, VALUE str);
-
-#define rb_fstring_lit(str) rb_fstring_new((str), rb_strlen_lit(str))
-#define rb_fstring_literal(str) rb_fstring_lit(str)
-#define rb_fstring_enc_lit(str, enc) rb_fstring_enc_new((str), rb_strlen_lit(str), (enc))
-#define rb_fstring_enc_literal(str, enc) rb_fstring_enc_lit(str, enc)
-
-static inline VALUE
-QUOTE(VALUE v)
-{
-    return rb_str_quote_unprintable(v);
-}
-
-static inline VALUE
-QUOTE_ID(ID i)
-{
-    return rb_id_quote_unprintable(i);
-}
-
-static inline bool
-STR_EMBED_P(VALUE str)
-{
-    return ! FL_TEST_RAW(str, STR_NOEMBED);
-}
-
-static inline bool
-STR_SHARED_P(VALUE str)
-{
-    return FL_ALL_RAW(str, STR_NOEMBED | STR_SHARED);
-}
-
-static inline bool
-is_ascii_string(VALUE str)
-{
-    return rb_enc_str_coderange(str) == ENC_CODERANGE_7BIT;
-}
-
-static inline bool
-is_broken_string(VALUE str)
-{
-    return rb_enc_str_coderange(str) == ENC_CODERANGE_BROKEN;
-}
-
-static inline bool
-at_char_boundary(const char *s, const char *p, const char *e, rb_encoding *enc)
-{
-    return rb_enc_left_char_head(s, p, e, enc) == p;
-}
-
-static inline bool
-at_char_right_boundary(const char *s, const char *p, const char *e, rb_encoding *enc)
-{
-    RUBY_ASSERT(s <= p);
-    RUBY_ASSERT(p <= e);
-
-    return rb_enc_right_char_head(s, p, e, enc) == p;
-}
-
-/* expect tail call optimization */
-// YJIT needs this function to never allocate and never raise
-static inline VALUE
-rb_str_eql_internal(const VALUE str1, const VALUE str2)
-{
-    const long len = RSTRING_LEN(str1);
-    const char *ptr1, *ptr2;
-
-    if (len != RSTRING_LEN(str2)) return Qfalse;
-    if (!rb_str_comparable(str1, str2)) return Qfalse;
-    if ((ptr1 = RSTRING_PTR(str1)) == (ptr2 = RSTRING_PTR(str2)))
-        return Qtrue;
-    if (memcmp(ptr1, ptr2, len) == 0)
-        return Qtrue;
-    return Qfalse;
-}
-
-#if __has_builtin(__builtin_constant_p)
-# define rb_fstring_cstr(str) \
-    (__builtin_constant_p(str) ? \
-        rb_fstring_new((str), (long)strlen(str)) : \
-        (rb_fstring_cstr)(str))
-#endif
-#endif /* INTERNAL_STRING_H */

data/lib/datadog/ruby_core_source/ruby-3.3.0-p0/internal/struct.h

@@ -1,127 +0,0 @@
-#ifndef INTERNAL_STRUCT_H                                /*-*-C-*-vi:se ft=c:*/
-#define INTERNAL_STRUCT_H
-/**
- * @author     Ruby developers <ruby-core@ruby-lang.org>
- * @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.
- * @brief      Internal header for Struct.
- */
-#include "ruby/internal/stdbool.h"     /* for bool */
-#include "ruby/ruby.h"          /* for struct RBasic */
-
-enum {
-    RSTRUCT_EMBED_LEN_MASK = RUBY_FL_USER7 | RUBY_FL_USER6 | RUBY_FL_USER5 | RUBY_FL_USER4 |
-                                 RUBY_FL_USER3 | RUBY_FL_USER2 | RUBY_FL_USER1,
-    RSTRUCT_EMBED_LEN_SHIFT = (RUBY_FL_USHIFT+1),
-};
-
-struct RStruct {
-    struct RBasic basic;
-    union {
-        struct {
-            long len;
-            const VALUE *ptr;
-        } heap;
-        /* This is a length 1 array because:
-         *   1. GCC has a bug that does not optimize C flexible array members
-         *      (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=102452)
-         *   2. Zero length arrays are not supported by all compilers
-         */
-        const VALUE ary[1];
-    } as;
-};
-
-#define RSTRUCT(obj) ((struct RStruct *)(obj))
-
-#ifdef RSTRUCT_LEN
-# undef RSTRUCT_LEN
-#endif
-
-#ifdef RSTRUCT_PTR
-# undef RSTRUCT_PTR
-#endif
-
-#ifdef RSTRUCT_SET
-# undef RSTRUCT_SET
-#endif
-
-#ifdef RSTRUCT_GET
-# undef RSTRUCT_GET
-#endif
-
-#define RSTRUCT_LEN internal_RSTRUCT_LEN
-#define RSTRUCT_SET internal_RSTRUCT_SET
-#define RSTRUCT_GET internal_RSTRUCT_GET
-
-/* struct.c */
-VALUE rb_struct_init_copy(VALUE copy, VALUE s);
-VALUE rb_struct_lookup(VALUE s, VALUE idx);
-VALUE rb_struct_s_keyword_init(VALUE klass);
-static inline const VALUE *rb_struct_const_heap_ptr(VALUE st);
-static inline long RSTRUCT_EMBED_LEN(VALUE st);
-static inline long RSTRUCT_LEN(VALUE st);
-static inline int RSTRUCT_LENINT(VALUE st);
-static inline const VALUE *RSTRUCT_CONST_PTR(VALUE st);
-static inline void RSTRUCT_SET(VALUE st, long k, VALUE v);
-static inline VALUE RSTRUCT_GET(VALUE st, long k);
-
-static inline long
-RSTRUCT_EMBED_LEN(VALUE st)
-{
-    long ret = FL_TEST_RAW(st, RSTRUCT_EMBED_LEN_MASK);
-    ret >>= RSTRUCT_EMBED_LEN_SHIFT;
-    return ret;
-}
-
-static inline long
-RSTRUCT_LEN(VALUE st)
-{
-    if (FL_TEST_RAW(st, RSTRUCT_EMBED_LEN_MASK)) {
-        return RSTRUCT_EMBED_LEN(st);
-    }
-    else {
-        return RSTRUCT(st)->as.heap.len;
-    }
-}
-
-static inline int
-RSTRUCT_LENINT(VALUE st)
-{
-    return rb_long2int(RSTRUCT_LEN(st));
-}
-
-static inline const VALUE *
-RSTRUCT_CONST_PTR(VALUE st)
-{
-    const struct RStruct *p = RSTRUCT(st);
-
-    if (FL_TEST_RAW(st, RSTRUCT_EMBED_LEN_MASK)) {
-        return p->as.ary;
-    }
-    else {
-        return p->as.heap.ptr;
-    }
-}
-
-static inline void
-RSTRUCT_SET(VALUE st, long k,  VALUE v)
-{
-    RB_OBJ_WRITE(st, &RSTRUCT_CONST_PTR(st)[k], v);
-}
-
-static inline VALUE
-RSTRUCT_GET(VALUE st, long k)
-{
-    return RSTRUCT_CONST_PTR(st)[k];
-}
-
-static inline const VALUE *
-rb_struct_const_heap_ptr(VALUE st)
-{
-    assert(!FL_TEST_RAW(st, RSTRUCT_EMBED_LEN_MASK));
-    return RSTRUCT(st)->as.heap.ptr;
-}
-
-#endif /* INTERNAL_STRUCT_H */