debase-ruby_core_source 4.0.1 → 4.1.0.preview1

data/lib/debase/ruby_core_source/ruby-4.1.0-preview1/internal/numeric.h

@@ -0,0 +1,326 @@
+#ifndef INTERNAL_NUMERIC_H                               /*-*-C-*-vi:se ft=c:*/
+#define INTERNAL_NUMERIC_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 Numeric.
+ */
+#include "internal/bignum.h"    /* for BIGNUM_POSITIVE_P */
+#include "internal/bits.h"      /* for RUBY_BIT_ROTL */
+#include "internal/compar.h"    /* for rb_cmperr_reason */
+#include "internal/fixnum.h"    /* for FIXNUM_POSITIVE_P */
+#include "internal/vm.h"        /* for rb_method_basic_definition_p */
+#include "ruby/ruby.h"          /* for USE_FLONUM */
+
+#define ROUND_TO(mode, even, up, down) \
+    ((mode) == RUBY_NUM_ROUND_HALF_EVEN ? even : \
+     (mode) == RUBY_NUM_ROUND_HALF_UP ? up : down)
+#define ROUND_FUNC(mode, name) \
+    ROUND_TO(mode, name##_half_even, name##_half_up, name##_half_down)
+#define ROUND_CALL(mode, name, args) \
+    ROUND_TO(mode, name##_half_even args, \
+             name##_half_up args, name##_half_down args)
+
+#ifndef ROUND_DEFAULT
+# define ROUND_DEFAULT RUBY_NUM_ROUND_HALF_UP
+#endif
+
+enum ruby_num_rounding_mode {
+    RUBY_NUM_ROUND_HALF_UP,
+    RUBY_NUM_ROUND_HALF_EVEN,
+    RUBY_NUM_ROUND_HALF_DOWN,
+    RUBY_NUM_ROUND_DEFAULT = ROUND_DEFAULT,
+};
+
+/* same as internal.h */
+#define numberof(array) ((int)(sizeof(array) / sizeof((array)[0])))
+#define roomof(x, y) (((x) + (y) - 1) / (y))
+#define type_roomof(x, y) roomof(sizeof(x), sizeof(y))
+
+#if SIZEOF_DOUBLE <= SIZEOF_VALUE
+typedef double rb_float_value_type;
+#else
+typedef struct {
+    VALUE values[roomof(SIZEOF_DOUBLE, SIZEOF_VALUE)];
+} rb_float_value_type;
+#endif
+
+struct RFloat {
+    struct RBasic basic;
+    rb_float_value_type float_value;
+};
+
+#define RFLOAT(obj)  ((struct RFloat *)(obj))
+
+/* numeric.c */
+int rb_num_to_uint(VALUE val, unsigned int *ret);
+VALUE ruby_num_interval_step_size(VALUE from, VALUE to, VALUE step, int excl);
+double ruby_float_step_size(double beg, double end, double unit, int excl);
+int ruby_float_step(VALUE from, VALUE to, VALUE step, int excl, int allow_endless);
+int rb_num_negative_p(VALUE);
+VALUE rb_int_succ(VALUE num);
+VALUE rb_float_uminus(VALUE num);
+VALUE rb_int_plus(VALUE x, VALUE y);
+VALUE rb_float_plus(VALUE x, VALUE y);
+VALUE rb_int_minus(VALUE x, VALUE y);
+VALUE rb_float_minus(VALUE x, VALUE y);
+VALUE rb_int_mul(VALUE x, VALUE y);
+VALUE rb_float_mul(VALUE x, VALUE y);
+VALUE rb_float_div(VALUE x, VALUE y);
+VALUE rb_flo_to_i(VALUE num);
+VALUE rb_int_idiv(VALUE x, VALUE y);
+VALUE rb_int_modulo(VALUE x, VALUE y);
+VALUE rb_int2str(VALUE num, int base);
+VALUE rb_fix_plus(VALUE x, VALUE y);
+VALUE rb_int_gt(VALUE x, VALUE y);
+VALUE rb_float_gt(VALUE x, VALUE y);
+VALUE rb_int_ge(VALUE x, VALUE y);
+enum ruby_num_rounding_mode rb_num_get_rounding_option(VALUE opts);
+VALUE rb_int_fdiv(VALUE x, VALUE y);
+double rb_int_fdiv_double(VALUE x, VALUE y);
+VALUE rb_int_pow(VALUE x, VALUE y);
+VALUE rb_float_pow(VALUE x, VALUE y);
+VALUE rb_int_cmp(VALUE x, VALUE y);
+VALUE rb_int_equal(VALUE x, VALUE y);
+VALUE rb_int_divmod(VALUE x, VALUE y);
+VALUE rb_int_and(VALUE x, VALUE y);
+VALUE rb_int_xor(VALUE x, VALUE y);
+VALUE rb_int_lshift(VALUE x, VALUE y);
+VALUE rb_int_rshift(VALUE x, VALUE y);
+VALUE rb_int_div(VALUE x, VALUE y);
+int rb_int_positive_p(VALUE num);
+int rb_int_negative_p(VALUE num);
+VALUE rb_check_integer_type(VALUE);
+VALUE rb_num_pow(VALUE x, VALUE y);
+VALUE rb_float_ceil(VALUE num, int ndigits);
+VALUE rb_float_floor(VALUE x, int ndigits);
+VALUE rb_float_abs(VALUE flt);
+static inline VALUE rb_num_compare_with_zero(VALUE num, ID mid);
+static inline int rb_num_positive_int_p(VALUE num);
+static inline int rb_num_negative_int_p(VALUE num);
+static inline double rb_float_flonum_value(VALUE v);
+static inline double rb_float_noflonum_value(VALUE v);
+static inline double rb_float_value_inline(VALUE v);
+static inline VALUE rb_float_new_inline(double d);
+static inline bool INT_POSITIVE_P(VALUE num);
+static inline bool INT_NEGATIVE_P(VALUE num);
+static inline bool FLOAT_ZERO_P(VALUE num);
+#define rb_float_value rb_float_value_inline
+#define rb_float_new   rb_float_new_inline
+
+RUBY_SYMBOL_EXPORT_BEGIN
+/* numeric.c (export) */
+RUBY_SYMBOL_EXPORT_END
+
+VALUE rb_flo_div_flo(VALUE x, VALUE y);
+double ruby_float_mod(double x, double y);
+VALUE rb_float_equal(VALUE x, VALUE y);
+int rb_float_cmp(VALUE x, VALUE y);
+VALUE rb_float_eql(VALUE x, VALUE y);
+VALUE rb_fix_aref(VALUE fix, VALUE idx);
+VALUE rb_int_zero_p(VALUE num);
+VALUE rb_int_even_p(VALUE num);
+VALUE rb_int_odd_p(VALUE num);
+VALUE rb_int_abs(VALUE num);
+VALUE rb_int_bit_length(VALUE num);
+VALUE rb_int_bit_count(VALUE num);
+VALUE rb_int_uminus(VALUE num);
+VALUE rb_int_comp(VALUE num);
+
+// Unified 128-bit integer structures that work with or without native support:
+union rb_uint128 {
+#ifdef WORDS_BIGENDIAN
+    struct {
+        uint64_t high;
+        uint64_t low;
+    } parts;
+#else
+    struct {
+        uint64_t low;
+        uint64_t high;
+    } parts;
+#endif
+#ifdef HAVE_UINT128_T
+    uint128_t value;
+#endif
+};
+typedef union rb_uint128 rb_uint128_t;
+
+union rb_int128 {
+#ifdef WORDS_BIGENDIAN
+    struct {
+        uint64_t high;
+        uint64_t low;
+    } parts;
+#else
+    struct {
+        uint64_t low;
+        uint64_t high;
+    } parts;
+#endif
+#ifdef HAVE_UINT128_T
+    int128_t value;
+#endif
+};
+typedef union rb_int128 rb_int128_t;
+
+union uint128_int128_conversion {
+    rb_uint128_t uint128;
+    rb_int128_t int128;
+};
+
+// Conversion functions for 128-bit integers:
+rb_uint128_t rb_numeric_to_uint128(VALUE x);
+rb_int128_t rb_numeric_to_int128(VALUE x);
+VALUE rb_uint128_to_numeric(rb_uint128_t n);
+VALUE rb_int128_to_numeric(rb_int128_t n);
+
+static inline bool
+INT_POSITIVE_P(VALUE num)
+{
+    if (FIXNUM_P(num)) {
+        return FIXNUM_POSITIVE_P(num);
+    }
+    else {
+        return BIGNUM_POSITIVE_P(num);
+    }
+}
+
+static inline bool
+INT_NEGATIVE_P(VALUE num)
+{
+    if (FIXNUM_P(num)) {
+        return FIXNUM_NEGATIVE_P(num);
+    }
+    else {
+        return BIGNUM_NEGATIVE_P(num);
+    }
+}
+
+static inline bool
+FLOAT_ZERO_P(VALUE num)
+{
+    return RFLOAT_VALUE(num) == 0.0;
+}
+
+static inline VALUE
+rb_num_compare_with_zero(VALUE num, ID mid)
+{
+    VALUE zero = INT2FIX(0);
+    VALUE r = rb_check_funcall(num, mid, 1, &zero);
+    if (RB_UNDEF_P(r)) {
+        rb_cmperr_reason(num, zero, "unable to compare with zero");
+    }
+    return r;
+}
+
+static inline int
+rb_num_positive_int_p(VALUE num)
+{
+    const ID mid = '>';
+
+    if (FIXNUM_P(num)) {
+        if (rb_method_basic_definition_p(rb_cInteger, mid))
+            return FIXNUM_POSITIVE_P(num);
+    }
+    else if (RB_TYPE_P(num, T_BIGNUM)) {
+        if (rb_method_basic_definition_p(rb_cInteger, mid))
+            return BIGNUM_POSITIVE_P(num);
+    }
+    return RTEST(rb_num_compare_with_zero(num, mid));
+}
+
+static inline int
+rb_num_negative_int_p(VALUE num)
+{
+    const ID mid = '<';
+
+    if (FIXNUM_P(num)) {
+        if (rb_method_basic_definition_p(rb_cInteger, mid))
+            return FIXNUM_NEGATIVE_P(num);
+    }
+    else if (RB_TYPE_P(num, T_BIGNUM)) {
+        if (rb_method_basic_definition_p(rb_cInteger, mid))
+            return BIGNUM_NEGATIVE_P(num);
+    }
+    return RTEST(rb_num_compare_with_zero(num, mid));
+}
+
+static inline double
+rb_float_flonum_value(VALUE v)
+{
+#if USE_FLONUM
+    if (v != (VALUE)0x8000000000000002) { /* LIKELY */
+        union {
+            double d;
+            VALUE v;
+        } t;
+
+        VALUE b63 = (v >> 63);
+        /* e: xx1... -> 011... */
+        /*    xx0... -> 100... */
+        /*      ^b63           */
+        t.v = RUBY_BIT_ROTR((2 - b63) | (v & ~(VALUE)0x03), 3);
+        return t.d;
+    }
+#endif
+    return 0.0;
+}
+
+static inline double
+rb_float_noflonum_value(VALUE v)
+{
+#if SIZEOF_DOUBLE <= SIZEOF_VALUE
+    return RFLOAT(v)->float_value;
+#else
+    union {
+        rb_float_value_type v;
+        double d;
+    } u = {RFLOAT(v)->float_value};
+    return u.d;
+#endif
+}
+
+static inline double
+rb_float_value_inline(VALUE v)
+{
+    if (FLONUM_P(v)) {
+        return rb_float_flonum_value(v);
+    }
+    return rb_float_noflonum_value(v);
+}
+
+static inline VALUE
+rb_float_new_inline(double d)
+{
+#if USE_FLONUM
+    union {
+        double d;
+        VALUE v;
+    } t;
+    int bits;
+
+    t.d = d;
+    bits = (int)((VALUE)(t.v >> 60) & 0x7);
+    /* bits contains 3 bits of b62..b60. */
+    /* bits - 3 = */
+    /*   b011 -> b000 */
+    /*   b100 -> b001 */
+
+    if (t.v != 0x3000000000000000 /* 1.72723e-77 */ &&
+        !((bits-3) & ~0x01)) {
+        return (RUBY_BIT_ROTL(t.v, 3) & ~(VALUE)0x01) | 0x02;
+    }
+    else if (t.v == (VALUE)0) {
+        /* +0.0 */
+        return 0x8000000000000002;
+    }
+    /* out of range */
+#endif
+    return rb_float_new_in_heap(d);
+}
+
+#endif /* INTERNAL_NUMERIC_H */

data/lib/debase/ruby_core_source/ruby-4.1.0-preview1/internal/object.h

@@ -0,0 +1,88 @@
+#ifndef INTERNAL_OBJECT_H                                /*-*-C-*-vi:se ft=c:*/
+#define INTERNAL_OBJECT_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 Object.
+ */
+#include "ruby/ruby.h"          /* for VALUE */
+
+/* object.c */
+
+VALUE rb_class_allocate_instance(VALUE klass);
+VALUE rb_class_allocate_instance_capa(VALUE klass, uint8_t /* attr_index_t */ max_iv_count);
+VALUE rb_class_search_ancestor(VALUE klass, VALUE super);
+NORETURN(void rb_undefined_alloc(VALUE klass));
+double rb_num_to_dbl(VALUE val);
+VALUE rb_obj_dig(int argc, VALUE *argv, VALUE self, VALUE notfound);
+VALUE rb_obj_clone_setup(VALUE obj, VALUE clone, VALUE kwfreeze);
+VALUE rb_obj_dup_setup(VALUE obj, VALUE dup);
+VALUE rb_immutable_obj_clone(int, VALUE *, VALUE);
+VALUE rb_check_convert_type_with_id_slow(VALUE,int,const char*,ID);
+int rb_bool_expected(VALUE, const char *, int raise);
+
+static inline VALUE
+rb_check_convert_type_with_id(VALUE val, int type, const char *tname, ID method)
+{
+    if (RB_TYPE_P(val, type) && type != T_DATA) return val;
+    return rb_check_convert_type_with_id_slow(val, type, tname, method);
+}
+static inline void RBASIC_CLEAR_CLASS(VALUE obj);
+static inline void RBASIC_SET_CLASS_RAW(VALUE obj, VALUE klass);
+static inline void RBASIC_SET_CLASS(VALUE obj, VALUE klass);
+
+RUBY_SYMBOL_EXPORT_BEGIN
+/* object.c (export) */
+int rb_opts_exception_p(VALUE opts, int default_value);
+RUBY_SYMBOL_EXPORT_END
+
+CONSTFUNC(VALUE rb_obj_equal(VALUE obj1, VALUE obj2));
+CONSTFUNC(VALUE rb_obj_not(VALUE obj));
+VALUE rb_obj_not_equal(VALUE obj1, VALUE obj2);
+void rb_obj_copy_ivar(VALUE dest, VALUE obj);
+VALUE rb_false(VALUE obj);
+VALUE rb_convert_type_with_id(VALUE v, int t, const char* nam, ID mid);
+VALUE rb_obj_size(VALUE self, VALUE args, VALUE obj);
+VALUE rb_get_freeze_opt(int argc, VALUE *argv);
+
+static inline void
+RBASIC_SET_CLASS_RAW(VALUE obj, VALUE klass)
+{
+    const VALUE *ptr = &RBASIC(obj)->klass;
+    *(VALUE *)ptr = klass;
+}
+
+static inline void
+RBASIC_CLEAR_CLASS(VALUE obj)
+{
+    RBASIC_SET_CLASS_RAW(obj, 0);
+}
+
+static inline void
+RBASIC_SET_CLASS(VALUE obj, VALUE klass)
+{
+    VALUE oldv = RBASIC_CLASS(obj);
+    RBASIC_SET_CLASS_RAW(obj, klass);
+    RB_OBJ_WRITTEN(obj, oldv, klass);
+}
+
+static inline void
+ROBJECT_SET_EXTENDED(VALUE obj, VALUE fields_obj)
+{
+    RUBY_ASSERT(RB_TYPE_P(obj, T_OBJECT));
+    RUBY_ASSERT(RB_TYPE_P(fields_obj, T_IMEMO));
+    RB_OBJ_WRITE(obj, &ROBJECT(obj)->as.extended, fields_obj);
+}
+
+static inline size_t
+rb_obj_embedded_size(uint32_t fields_count)
+{
+    size_t size = offsetof(struct RObject, as.ary) + (sizeof(VALUE) * fields_count);
+    // Ensure enough room for the heap pointer if this expands
+    if (size < sizeof(struct RObject)) size = sizeof(struct RObject);
+    return size;
+}
+#endif /* INTERNAL_OBJECT_H */

data/lib/debase/ruby_core_source/ruby-4.1.0-preview1/internal/objspace.h

@@ -0,0 +1,24 @@
+#ifndef INTERNAL_OBJSPACE_H                         /*-*-C-*-vi:se ft=c:*/
+#define INTERNAL_OBJSPACE_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 Objspace.
+ */
+
+RUBY_SYMBOL_EXPORT_BEGIN
+
+/* from intern/class.h */
+RUBY_EXTERN VALUE rb_class_super_of(VALUE klass);
+RUBY_EXTERN VALUE rb_class_singleton_p(VALUE klass);
+RUBY_EXTERN unsigned char rb_class_variation_count(VALUE klass);
+
+/* from vm_sync.h */
+RUBY_EXTERN VALUE rb_vm_lock_with_barrier(VALUE (*func)(void *args), void *args);
+
+RUBY_SYMBOL_EXPORT_END
+
+#endif /* INTERNAL_OBJSPACE_H */

data/lib/debase/ruby_core_source/ruby-4.1.0-preview1/internal/parse.h

@@ -0,0 +1,131 @@
+#ifndef INTERNAL_PARSE_H                                 /*-*-C-*-vi:se ft=c:*/
+#define INTERNAL_PARSE_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 the parser.
+ */
+#include <limits.h>
+#include "rubyparser.h"
+#include "internal/static_assert.h"
+
+// The default parser to use for Ruby code.
+typedef enum {
+    RB_DEFAULT_PARSER_PARSE_Y,
+    RB_DEFAULT_PARSER_PRISM,
+} ruby_default_parser_enum;
+
+ruby_default_parser_enum rb_ruby_default_parser(void);
+void rb_ruby_default_parser_set(ruby_default_parser_enum parser);
+
+#define rb_ruby_prism_p() (rb_ruby_default_parser() == RB_DEFAULT_PARSER_PRISM)
+
+#ifdef UNIVERSAL_PARSER
+#define rb_encoding const void
+#endif
+
+struct rb_iseq_struct;          /* in vm_core.h */
+
+/* structs for managing terminator of string literal and heredocment */
+typedef struct rb_strterm_literal_struct {
+    long nest;
+    int func;	    /* STR_FUNC_* (e.g., STR_FUNC_ESCAPE and STR_FUNC_EXPAND) */
+    int paren;	    /* '(' of `%q(...)` */
+    int term;	    /* ')' of `%q(...)` */
+} rb_strterm_literal_t;
+
+typedef struct rb_strterm_heredoc_struct {
+    rb_parser_string_t *lastline;	/* the string of line that contains `<<"END"` */
+    long offset;	/* the column of END in `<<"END"` */
+    int sourceline;	/* lineno of the line that contains `<<"END"` */
+    unsigned length;	/* the length of END in `<<"END"` */
+    uint8_t quote;
+    uint8_t func;
+} rb_strterm_heredoc_t;
+
+#define HERETERM_LENGTH_MAX UINT_MAX
+
+typedef struct rb_strterm_struct {
+    bool heredoc;
+    union {
+        rb_strterm_literal_t literal;
+        rb_strterm_heredoc_t heredoc;
+    } u;
+} rb_strterm_t;
+
+/* parse.y */
+void rb_ruby_parser_mark(void *ptr);
+size_t rb_ruby_parser_memsize(const void *ptr);
+
+void rb_ruby_parser_set_options(rb_parser_t *p, int print, int loop, int chomp, int split);
+rb_parser_t *rb_ruby_parser_set_context(rb_parser_t *p, const struct rb_iseq_struct *base, int main);
+void rb_ruby_parser_set_script_lines(rb_parser_t *p);
+void rb_ruby_parser_error_tolerant(rb_parser_t *p);
+void rb_ruby_parser_keep_tokens(rb_parser_t *p);
+typedef rb_parser_string_t*(rb_parser_lex_gets_func)(struct parser_params*, rb_parser_input_data, int);
+rb_ast_t *rb_parser_compile(rb_parser_t *p, rb_parser_lex_gets_func *gets, VALUE fname, rb_parser_input_data input, int line);
+
+RUBY_SYMBOL_EXPORT_BEGIN
+
+rb_encoding *rb_ruby_parser_encoding(rb_parser_t *p);
+int rb_ruby_parser_end_seen_p(rb_parser_t *p);
+int rb_ruby_parser_set_yydebug(rb_parser_t *p, int flag);
+rb_parser_string_t *rb_str_to_parser_string(rb_parser_t *p, VALUE str);
+void rb_parser_string_free(rb_parser_t *p, rb_parser_string_t *str);
+
+int rb_parser_dvar_defined_ref(struct parser_params*, ID, ID**);
+ID rb_parser_internal_id(struct parser_params*);
+typedef void (*rb_parser_reg_fragment_error_func)(struct parser_params *, VALUE);
+int rb_parser_reg_fragment_check(struct parser_params*, rb_parser_string_t*, int, rb_parser_reg_fragment_error_func);
+int rb_reg_named_capture_assign_iter_impl(struct parser_params *p, const char *s, long len, rb_encoding *enc, NODE **succ_block, const rb_code_location_t *loc, rb_parser_assignable_func assignable);
+int rb_parser_local_defined(struct parser_params *p, ID id, const struct rb_iseq_struct *iseq);
+NODE *rb_parser_assignable(struct parser_params *p, ID id, NODE *val, const YYLTYPE *loc);
+
+RUBY_SYMBOL_EXPORT_END
+
+#ifndef UNIVERSAL_PARSER
+rb_parser_t *rb_ruby_parser_allocate(void);
+rb_parser_t *rb_ruby_parser_new(void);
+#endif
+
+#ifdef RIPPER
+void ripper_parser_mark(void *ptr);
+void ripper_parser_free(void *ptr);
+size_t ripper_parser_memsize(const void *ptr);
+void ripper_error(struct parser_params *p);
+VALUE ripper_value(struct parser_params *p);
+int rb_ruby_parser_get_yydebug(rb_parser_t *p);
+void rb_ruby_parser_set_value(rb_parser_t *p, VALUE value);
+int rb_ruby_parser_error_p(rb_parser_t *p);
+VALUE rb_ruby_parser_debug_output(rb_parser_t *p);
+void rb_ruby_parser_set_debug_output(rb_parser_t *p, VALUE output);
+VALUE rb_ruby_parser_parsing_thread(rb_parser_t *p);
+void rb_ruby_parser_set_parsing_thread(rb_parser_t *p, VALUE parsing_thread);
+void rb_ruby_parser_ripper_initialize(rb_parser_t *p, rb_parser_lex_gets_func *gets, rb_parser_input_data input, VALUE sourcefile_string, const char *sourcefile, int sourceline);
+VALUE rb_ruby_parser_result(rb_parser_t *p);
+rb_encoding *rb_ruby_parser_enc(rb_parser_t *p);
+VALUE rb_ruby_parser_ruby_sourcefile_string(rb_parser_t *p);
+int rb_ruby_parser_ruby_sourceline(rb_parser_t *p);
+int rb_ruby_parser_lex_state(rb_parser_t *p);
+void rb_ruby_ripper_parse0(rb_parser_t *p);
+int rb_ruby_ripper_dedent_string(rb_parser_t *p, rb_parser_string_t *string, int width);
+int rb_ruby_ripper_initialized_p(rb_parser_t *p);
+void rb_ruby_ripper_parser_initialize(rb_parser_t *p);
+long rb_ruby_ripper_column(rb_parser_t *p);
+long rb_ruby_ripper_token_len(rb_parser_t *p);
+rb_parser_string_t *rb_ruby_ripper_lex_lastline(rb_parser_t *p);
+VALUE rb_ruby_ripper_lex_state_name(struct parser_params *p, int state);
+#ifdef UNIVERSAL_PARSER
+rb_parser_t *rb_ripper_parser_params_allocate(const rb_parser_config_t *config);
+#endif
+struct parser_params *rb_ruby_ripper_parser_allocate(void);
+#endif
+
+#ifdef UNIVERSAL_PARSER
+#undef rb_encoding
+#endif
+
+#endif /* INTERNAL_PARSE_H */

data/lib/debase/ruby_core_source/ruby-4.1.0-preview1/internal/proc.h

@@ -0,0 +1,34 @@
+#ifndef INTERNAL_PROC_H                                  /*-*-C-*-vi:se ft=c:*/
+#define INTERNAL_PROC_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 Proc.
+ */
+#include "ruby/ruby.h"          /* for rb_block_call_func_t */
+#include "ruby/st.h"            /* for st_index_t */
+struct rb_block;                /* in vm_core.h */
+struct rb_code_location_struct; /* in rubyparser.h */
+struct rb_iseq_struct;          /* in vm_core.h */
+
+/* proc.c */
+VALUE rb_proc_location(VALUE self);
+st_index_t rb_hash_proc(st_index_t hash, VALUE proc);
+VALUE rb_proc_eq(VALUE self, VALUE other);
+int rb_block_pair_yield_optimizable(void);
+int rb_block_arity(void);
+int rb_block_min_max_arity(int *max);
+VALUE rb_block_to_s(VALUE self, const struct rb_block *block, const char *additional_info);
+VALUE rb_callable_receiver(VALUE);
+VALUE rb_source_range_new(VALUE path, VALUE absolute_path,
+                          const struct rb_code_location_struct *location);
+
+VALUE rb_func_proc_dup(VALUE src_obj);
+VALUE rb_func_lambda_new(rb_block_call_func_t func, VALUE val, int min_argc, int max_argc);
+VALUE rb_iseq_location(const struct rb_iseq_struct *iseq);
+VALUE rb_sym_to_proc(VALUE sym);
+
+#endif /* INTERNAL_PROC_H */