debase-ruby_core_source 3.3.6 → 4.0.0.preview2

data/lib/debase/ruby_core_source/{ruby-3.4.0-preview1 → ruby-4.0.0-preview2}/prism/util/pm_newline_list.h

@@ -80,6 +80,17 @@ pm_newline_list_clear(pm_newline_list_t *list);
  */
 bool pm_newline_list_append(pm_newline_list_t *list, const uint8_t *cursor);
 
+/**
+ * Returns the line of the given offset. If the offset is not in the list, the
+ * line of the closest offset less than the given offset is returned.
+ *
+ * @param list The list to search.
+ * @param cursor A pointer to the offset to search for.
+ * @param start_line The line to start counting from.
+ * @return The line of the given offset.
+ */
+int32_t pm_newline_list_line(const pm_newline_list_t *list, const uint8_t *cursor, int32_t start_line);
+
 /**
  * Returns the line and column of the given offset. If the offset is not in the
  * list, the line and column of the closest offset less than the given offset

data/lib/debase/ruby_core_source/{ruby-3.4.0-preview1 → ruby-4.0.0-preview2}/prism/util/pm_string.h

@@ -9,6 +9,7 @@
 #include "prism/defines.h"
 
 #include <assert.h>
+#include <errno.h>
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdlib.h>
@@ -21,6 +22,9 @@
 #include <fcntl.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
+#elif defined(PRISM_HAS_FILESYSTEM)
+#include <fcntl.h>
+#include <sys/stat.h>
 #endif
 
 /**
@@ -41,11 +45,11 @@ typedef struct {
         /** This is a slice of another string, and should not be freed. */
         PM_STRING_SHARED,
 
-        /** This string owns its memory, and should be freed using `pm_string_free`. */
+        /** This string owns its memory, and should be freed using `pm_string_free()`. */
         PM_STRING_OWNED,
 
 #ifdef PRISM_HAS_MMAP
-        /** This string is a memory-mapped file, and should be freed using `pm_string_free`. */
+        /** This string is a memory-mapped file, and should be freed using `pm_string_free()`. */
         PM_STRING_MAPPED
 #endif
     } type;
@@ -92,6 +96,26 @@ void pm_string_owned_init(pm_string_t *string, uint8_t *source, size_t length);
  */
 void pm_string_constant_init(pm_string_t *string, const char *source, size_t length);
 
+/**
+ * Represents the result of calling pm_string_mapped_init or
+ * pm_string_file_init. We need this additional information because there is
+ * not a platform-agnostic way to indicate that the file that was attempted to
+ * be opened was a directory.
+ */
+typedef enum {
+    /** Indicates that the string was successfully initialized. */
+    PM_STRING_INIT_SUCCESS = 0,
+    /**
+     * Indicates a generic error from a string_*_init function, where the type
+     * of error should be read from `errno` or `GetLastError()`.
+     */
+    PM_STRING_INIT_ERROR_GENERIC = 1,
+    /**
+     * Indicates that the file that was attempted to be opened was a directory.
+     */
+    PM_STRING_INIT_ERROR_DIRECTORY = 2
+} pm_string_init_result_t;
+
 /**
  * Read the file indicated by the filepath parameter into source and load its
  * contents and size into the given `pm_string_t`. The given `pm_string_t`
@@ -105,9 +129,11 @@ void pm_string_constant_init(pm_string_t *string, const char *source, size_t len
  *
  * @param string The string to initialize.
  * @param filepath The filepath to read.
- * @return Whether or not the file was successfully mapped.
+ * @return The success of the read, indicated by the value of the enum.
+ *
+ * \public \memberof pm_string_t
  */
-PRISM_EXPORTED_FUNCTION bool pm_string_mapped_init(pm_string_t *string, const char *filepath);
+PRISM_EXPORTED_FUNCTION pm_string_init_result_t pm_string_mapped_init(pm_string_t *string, const char *filepath);
 
 /**
  * Read the file indicated by the filepath parameter into source and load its
@@ -116,17 +142,11 @@ PRISM_EXPORTED_FUNCTION bool pm_string_mapped_init(pm_string_t *string, const ch
  *
  * @param string The string to initialize.
  * @param filepath The filepath to read.
- * @return Whether or not the file was successfully read.
- */
-PRISM_EXPORTED_FUNCTION bool pm_string_file_init(pm_string_t *string, const char *filepath);
-
-/**
- * Returns the memory size associated with the string.
+ * @return The success of the read, indicated by the value of the enum.
  *
- * @param string The string to get the memory size of.
- * @return The size of the memory associated with the string.
+ * \public \memberof pm_string_t
  */
-size_t pm_string_memsize(const pm_string_t *string);
+PRISM_EXPORTED_FUNCTION pm_string_init_result_t pm_string_file_init(pm_string_t *string, const char *filepath);
 
 /**
  * Ensure the string is owned. If it is not, then reinitialize it as owned and
@@ -153,6 +173,8 @@ int pm_string_compare(const pm_string_t *left, const pm_string_t *right);
  *
  * @param string The string to get the length of.
  * @return The length of the string.
+ *
+ * \public \memberof pm_string_t
  */
 PRISM_EXPORTED_FUNCTION size_t pm_string_length(const pm_string_t *string);
 
@@ -161,6 +183,8 @@ PRISM_EXPORTED_FUNCTION size_t pm_string_length(const pm_string_t *string);
  *
  * @param string The string to get the start pointer of.
  * @return The start pointer of the string.
+ *
+ * \public \memberof pm_string_t
  */
 PRISM_EXPORTED_FUNCTION const uint8_t * pm_string_source(const pm_string_t *string);
 
@@ -168,6 +192,8 @@ PRISM_EXPORTED_FUNCTION const uint8_t * pm_string_source(const pm_string_t *stri
  * Free the associated memory of the given string.
  *
  * @param string The string to free.
+ *
+ * \public \memberof pm_string_t
  */
 PRISM_EXPORTED_FUNCTION void pm_string_free(pm_string_t *string);
 

data/lib/debase/ruby_core_source/{ruby-3.4.0-preview1 → ruby-4.0.0-preview2}/prism/version.h

@@ -9,12 +9,12 @@
 /**
  * The major version of the Prism library as an int.
  */
-#define PRISM_VERSION_MAJOR 0
+#define PRISM_VERSION_MAJOR 1
 
 /**
  * The minor version of the Prism library as an int.
  */
-#define PRISM_VERSION_MINOR 29
+#define PRISM_VERSION_MINOR 6
 
 /**
  * The patch version of the Prism library as an int.
@@ -24,6 +24,6 @@
 /**
  * The version of the Prism library as a constant string.
  */
-#define PRISM_VERSION "0.29.0"
+#define PRISM_VERSION "1.6.0"
 
 #endif

data/lib/debase/ruby_core_source/{ruby-3.4.0-preview1 → ruby-4.0.0-preview2}/prism_compile.h

@@ -29,6 +29,16 @@ typedef struct pm_scope_node {
     const pm_parser_t *parser;
     rb_encoding *encoding;
 
+    /**
+     * This is a pointer to the list of script lines for the ISEQs that will be
+     * associated with this scope node. It is only set if
+     * RubyVM.keep_script_lines is true. If it is set, it will be set to a
+     * pointer to an array that is always stack allocated (so no GC marking is
+     * needed by this struct). If it is not set, it will be NULL. It is
+     * inherited by all child scopes.
+     */
+    VALUE *script_lines;
+
     /**
      * This is the encoding of the actual filepath object that will be used when
      * a __FILE__ node is compiled or when the path has to be set on a syntax
@@ -36,14 +46,16 @@ typedef struct pm_scope_node {
      */
     rb_encoding *filepath_encoding;
 
-    // The size of the local table
-    // on the iseq which includes
-    // locals and hidden variables
+    // The size of the local table on the iseq which includes locals and hidden
+    // variables.
     int local_table_for_iseq_size;
 
     ID *constants;
     st_table *index_lookup_table;
 
+    // The current coverage setting, passed down through the various scopes.
+    int coverage_enabled;
+
     /**
      * This will only be set on the top-level scope node. It will contain all of
      * the instructions pertaining to BEGIN{} nodes.
@@ -53,7 +65,6 @@ typedef struct pm_scope_node {
 
 void pm_scope_node_init(const pm_node_t *node, pm_scope_node_t *scope, pm_scope_node_t *previous);
 void pm_scope_node_destroy(pm_scope_node_t *scope_node);
-bool *rb_ruby_prism_ptr(void);
 
 typedef struct {
     /** The parser that will do the actual parsing. */
@@ -72,17 +83,24 @@ typedef struct {
     bool parsed;
 } pm_parse_result_t;
 
+#define PM_SPECIAL_CONSTANT_FLAG ((pm_constant_id_t)(1 << 31))
+#define PM_CONSTANT_AND ((pm_constant_id_t)(idAnd | PM_SPECIAL_CONSTANT_FLAG))
+#define PM_CONSTANT_DOT3 ((pm_constant_id_t)(idDot3 | PM_SPECIAL_CONSTANT_FLAG))
+#define PM_CONSTANT_MULT ((pm_constant_id_t)(idMULT | PM_SPECIAL_CONSTANT_FLAG))
+#define PM_CONSTANT_POW ((pm_constant_id_t)(idPow | PM_SPECIAL_CONSTANT_FLAG))
+
 VALUE pm_load_file(pm_parse_result_t *result, VALUE filepath, bool load_error);
-VALUE pm_parse_file(pm_parse_result_t *result, VALUE filepath);
-VALUE pm_load_parse_file(pm_parse_result_t *result, VALUE filepath);
-VALUE pm_parse_string(pm_parse_result_t *result, VALUE source, VALUE filepath);
+VALUE pm_parse_file(pm_parse_result_t *result, VALUE filepath, VALUE *script_lines);
+VALUE pm_load_parse_file(pm_parse_result_t *result, VALUE filepath, VALUE *script_lines);
+VALUE pm_parse_string(pm_parse_result_t *result, VALUE source, VALUE filepath, VALUE *script_lines);
 VALUE pm_parse_stdin(pm_parse_result_t *result);
+void pm_options_version_for_current_ruby_set(pm_options_t *options);
 void pm_parse_result_free(pm_parse_result_t *result);
 
-rb_iseq_t *pm_iseq_new(pm_scope_node_t *node, VALUE name, VALUE path, VALUE realpath, const rb_iseq_t *parent, enum rb_iseq_type);
-rb_iseq_t *pm_iseq_new_top(pm_scope_node_t *node, VALUE name, VALUE path, VALUE realpath, const rb_iseq_t *parent);
-rb_iseq_t *pm_iseq_new_main(pm_scope_node_t *node, VALUE path, VALUE realpath, const rb_iseq_t *parent, int opt);
-rb_iseq_t *pm_iseq_new_eval(pm_scope_node_t *node, VALUE name, VALUE path, VALUE realpath, int first_lineno, const rb_iseq_t *parent, int isolated_depth);
-rb_iseq_t *pm_iseq_new_with_opt(pm_scope_node_t *node, VALUE name, VALUE path, VALUE realpath, int first_lineno, const rb_iseq_t *parent, int isolated_depth, enum rb_iseq_type, const rb_compile_option_t*);
+rb_iseq_t *pm_iseq_new(pm_scope_node_t *node, VALUE name, VALUE path, VALUE realpath, const rb_iseq_t *parent, enum rb_iseq_type, int *error_state);
+rb_iseq_t *pm_iseq_new_top(pm_scope_node_t *node, VALUE name, VALUE path, VALUE realpath, const rb_iseq_t *parent, int *error_state);
+rb_iseq_t *pm_iseq_new_main(pm_scope_node_t *node, VALUE path, VALUE realpath, const rb_iseq_t *parent, int opt, int *error_state);
+rb_iseq_t *pm_iseq_new_eval(pm_scope_node_t *node, VALUE name, VALUE path, VALUE realpath, int first_lineno, const rb_iseq_t *parent, int isolated_depth, int *error_state);
+rb_iseq_t *pm_iseq_new_with_opt(pm_scope_node_t *node, VALUE name, VALUE path, VALUE realpath, int first_lineno, const rb_iseq_t *parent, int isolated_depth, enum rb_iseq_type, const rb_compile_option_t *option, int *error_state);
 
 VALUE pm_iseq_compile_node(rb_iseq_t *iseq, pm_scope_node_t *node);

data/lib/debase/ruby_core_source/{ruby-3.4.0-preview1 → ruby-4.0.0-preview2}/ractor_core.h

@@ -9,122 +9,36 @@
 #define RACTOR_CHECK_MODE (VM_CHECK_MODE || RUBY_DEBUG) && (SIZEOF_UINT64_T == SIZEOF_VALUE)
 #endif
 
-enum rb_ractor_basket_type {
-    // basket is empty
-    basket_type_none,
-
-    // value is available
-    basket_type_ref,
-    basket_type_copy,
-    basket_type_move,
-    basket_type_will,
-
-    // basket should be deleted
-    basket_type_deleted,
-
-    // basket is reserved
-    basket_type_reserved,
-
-    // take_basket is available
-    basket_type_take_basket,
-
-    // basket is keeping by yielding ractor
-    basket_type_yielding,
-};
-
-// per ractor taking configuration
-struct rb_ractor_selector_take_config {
-    bool closed;
-    bool oneshot;
-};
-
-struct rb_ractor_basket {
-    union {
-        enum rb_ractor_basket_type e;
-        rb_atomic_t atomic;
-    } type;
-    VALUE sender;
-
-    union {
-        struct {
-            VALUE v;
-            bool exception;
-        } send;
-
-        struct {
-            struct rb_ractor_basket *basket;
-            struct rb_ractor_selector_take_config *config;
-        } take;
-    } p; // payload
-};
-
-static inline bool
-basket_type_p(struct rb_ractor_basket *b, enum rb_ractor_basket_type type)
-{
-    return b->type.e == type;
-}
-
-static inline bool
-basket_none_p(struct rb_ractor_basket *b)
-{
-    return basket_type_p(b, basket_type_none);
-}
-
-struct rb_ractor_queue {
-    struct rb_ractor_basket *baskets;
-    int start;
-    int cnt;
-    int size;
-    unsigned int serial;
-    unsigned int reserved_cnt;
-};
-
-enum rb_ractor_wait_status {
-    wait_none      = 0x00,
-    wait_receiving = 0x01,
-    wait_taking    = 0x02,
-    wait_yielding  = 0x04,
-    wait_moving    = 0x08,
-};
-
-enum rb_ractor_wakeup_status {
-    wakeup_none,
-    wakeup_by_send,
-    wakeup_by_yield,
-    wakeup_by_take,
-    wakeup_by_close,
-    wakeup_by_interrupt,
-    wakeup_by_retry,
-};
-
 struct rb_ractor_sync {
     // ractor lock
     rb_nativethread_lock_t lock;
+
 #if RACTOR_CHECK_MODE > 0
     VALUE locked_by;
 #endif
 
-    bool incoming_port_closed;
-    bool outgoing_port_closed;
+#ifndef RUBY_THREAD_PTHREAD_H
+    rb_nativethread_cond_t wakeup_cond;
+#endif
 
-    // All sent messages will be pushed into recv_queue
-    struct rb_ractor_queue recv_queue;
+    // incoming messages
+    struct ractor_queue *recv_queue;
 
-    // The following ractors waiting for the yielding by this ractor
-    struct rb_ractor_queue takers_queue;
+    // waiting threads for receiving
+    struct ccan_list_head waiters;
 
-    // Enabled if the ractor already terminated and not taken yet.
-    struct rb_ractor_basket will_basket;
+    // ports
+    VALUE default_port_value;
+    struct st_table *ports;
+    size_t next_port_id;
 
-    struct ractor_wait {
-        enum rb_ractor_wait_status status;
-        enum rb_ractor_wakeup_status wakeup_status;
-        rb_thread_t *waiting_thread;
-    } wait;
+    // monitors
+    struct ccan_list_head monitors;
 
-#ifndef RUBY_THREAD_PTHREAD_H
-    rb_nativethread_cond_t cond;
-#endif
+    // value
+    rb_ractor_t *successor;
+    VALUE legacy;
+    bool legacy_exc;
 };
 
 // created
@@ -150,12 +64,7 @@ enum ractor_status {
 
 struct rb_ractor_struct {
     struct rb_ractor_pub pub;
-
     struct rb_ractor_sync sync;
-    VALUE receiving_mutex;
-
-    // vm wide barrier synchronization
-    rb_nativethread_cond_t barrier_wait_cond;
 
     // thread management
     struct {
@@ -167,6 +76,7 @@ struct rb_ractor_struct {
         rb_execution_context_t *running_ec;
         rb_thread_t *main;
     } threads;
+
     VALUE thgroup_default;
 
     VALUE name;
@@ -180,6 +90,7 @@ struct rb_ractor_struct {
 
     st_table *local_storage;
     struct rb_id_table *idkey_local_storage;
+    VALUE local_storage_store_lock;
 
     VALUE r_stdin;
     VALUE r_stdout;
@@ -187,13 +98,8 @@ struct rb_ractor_struct {
     VALUE verbose;
     VALUE debug;
 
-    rb_ractor_newobj_cache_t newobj_cache;
-
-    // gc.c rb_objspace_reachable_objects_from
-    struct gc_mark_func_data_struct {
-        void *data;
-        void (*mark_func)(VALUE v, void *data);
-    } *mfd;
+    bool malloc_gc_disabled;
+    void *newobj_cache;
 }; // rb_ractor_t is defined in vm_core.h
 
 
@@ -227,12 +133,16 @@ void rb_ractor_vm_barrier_interrupt_running_thread(rb_ractor_t *r);
 void rb_ractor_terminate_interrupt_main_thread(rb_ractor_t *r);
 void rb_ractor_terminate_all(void);
 bool rb_ractor_main_p_(void);
-void rb_ractor_finish_marking(void);
 void rb_ractor_atfork(rb_vm_t *vm, rb_thread_t *th);
+void rb_ractor_terminate_atfork(rb_vm_t *vm, rb_ractor_t *th);
+VALUE rb_ractor_require(VALUE feature, bool silent);
+VALUE rb_ractor_autoload_load(VALUE space, ID id);
 
 VALUE rb_ractor_ensure_shareable(VALUE obj, VALUE name);
 
 RUBY_SYMBOL_EXPORT_BEGIN
+void rb_ractor_finish_marking(void);
+
 bool rb_ractor_shareable_p_continue(VALUE obj);
 
 // THIS FUNCTION SHOULD NOT CALL WHILE INCREMENTAL MARKING!!
@@ -283,12 +193,16 @@ rb_ractor_sleeper_thread_num(rb_ractor_t *r)
 }
 
 static inline void
-rb_ractor_thread_switch(rb_ractor_t *cr, rb_thread_t *th)
+rb_ractor_thread_switch(rb_ractor_t *cr, rb_thread_t *th, bool always_reset)
 {
     RUBY_DEBUG_LOG("th:%d->%u%s",
                    cr->threads.running_ec ? (int)rb_th_serial(cr->threads.running_ec->thread_ptr) : -1,
                    rb_th_serial(th), cr->threads.running_ec == th->ec ? " (same)" : "");
 
+    if (cr->threads.running_ec != th->ec || always_reset) {
+        th->running_time_us = 0;
+    }
+
     if (cr->threads.running_ec != th->ec) {
         if (0) {
             ruby_debug_printf("rb_ractor_thread_switch ec:%p->%p\n",
@@ -299,28 +213,21 @@ rb_ractor_thread_switch(rb_ractor_t *cr, rb_thread_t *th)
         return;
     }
 
-    if (cr->threads.running_ec != th->ec) {
-        th->running_time_us = 0;
-    }
-
     cr->threads.running_ec = th->ec;
 
     VM_ASSERT(cr == GET_RACTOR());
 }
 
 #define rb_ractor_set_current_ec(cr, ec) rb_ractor_set_current_ec_(cr, ec, __FILE__, __LINE__)
+#ifdef RB_THREAD_LOCAL_SPECIFIER
+void rb_current_ec_set(rb_execution_context_t *ec);
+#endif
 
 static inline void
 rb_ractor_set_current_ec_(rb_ractor_t *cr, rb_execution_context_t *ec, const char *file, int line)
 {
 #ifdef RB_THREAD_LOCAL_SPECIFIER
-
-# ifdef __APPLE__
     rb_current_ec_set(ec);
-# else
-    ruby_current_ec = ec;
-# endif
-
 #else
     native_tls_set(ruby_current_ec_key, ec);
 #endif
@@ -349,12 +256,6 @@ rb_ractor_setup_belonging_to(VALUE obj, uint32_t rid)
     RACTOR_BELONGING_ID(obj) = rid;
 }
 
-static inline void
-rb_ractor_setup_belonging(VALUE obj)
-{
-    rb_ractor_setup_belonging_to(obj, rb_ractor_current_id());
-}
-
 static inline uint32_t
 rb_ractor_belonging(VALUE obj)
 {
@@ -366,9 +267,13 @@ rb_ractor_belonging(VALUE obj)
     }
 }
 
+extern bool rb_ractor_ignore_belonging_flag;
+
 static inline VALUE
 rb_ractor_confirm_belonging(VALUE obj)
 {
+    if (rb_ractor_ignore_belonging_flag) return obj;
+
     uint32_t id = rb_ractor_belonging(obj);
 
     if (id == 0) {
@@ -388,6 +293,14 @@ rb_ractor_confirm_belonging(VALUE obj)
     }
     return obj;
 }
+
+static inline void
+rb_ractor_ignore_belonging(bool flag)
+{
+    rb_ractor_ignore_belonging_flag = flag;
+}
+
 #else
 #define rb_ractor_confirm_belonging(obj) obj
+#define rb_ractor_ignore_belonging(flag) (0)
 #endif

data/lib/debase/ruby_core_source/{ruby-3.4.0-preview2 → ruby-4.0.0-preview2}/regenc.h

@@ -118,6 +118,11 @@ typedef struct {
 
 typedef struct {
   short int len;
+#if defined(__has_attribute)
+# if __has_attribute(nonstring)
+  __attribute__((nonstring))
+# endif
+#endif
   const UChar name[6];
   int       ctype;
 } PosixBracketEntryType;
@@ -187,8 +192,8 @@ ONIG_EXTERN int onigenc_unicode_apply_all_case_fold(OnigCaseFoldType flag, OnigA
 #define UTF16_IS_SURROGATE_SECOND(c)   (((c) & 0xfc) == 0xdc)
 #define UTF16_IS_SURROGATE(c)          (((c) & 0xf8) == 0xd8)
 #define UNICODE_VALID_CODEPOINT_P(c) ( \
-	((c) <= 0x10ffff) && \
-	!((c) < 0x10000 && UTF16_IS_SURROGATE((c) >> 8)))
+        ((c) <= 0x10ffff) && \
+        !((c) < 0x10000 && UTF16_IS_SURROGATE((c) >> 8)))
 
 #define ONIGENC_ISO_8859_1_TO_LOWER_CASE(c) \
   OnigEncISO_8859_1_ToLowerCaseTable[c]
@@ -234,8 +239,8 @@ extern int ONIG_ENC_REGISTER(const char *, OnigEncoding);
 # define OnigEncodingDefine(f,n)			     \
     OnigEncodingDeclare(n);			     \
     void Init_##f(void) {			     \
-	ONIG_ENC_REGISTER(OnigEncodingName(n).name,  \
-			  &OnigEncodingName(n));     \
+        ONIG_ENC_REGISTER(OnigEncodingName(n).name,  \
+                          &OnigEncodingName(n));     \
     }						     \
     OnigEncodingDeclare(n)
 #else

data/lib/debase/ruby_core_source/{ruby-3.4.0-preview1 → ruby-4.0.0-preview2}/regint.h

@@ -86,7 +86,6 @@
 /* #define USE_OP_PUSH_OR_JUMP_EXACT */
 #define USE_QTFR_PEEK_NEXT
 #define USE_ST_LIBRARY
-#define USE_SUNDAY_QUICK_SEARCH
 
 #define INIT_MATCH_STACK_SIZE                     160
 #define DEFAULT_MATCH_STACK_LIMIT_SIZE              0 /* unlimited */
@@ -163,9 +162,6 @@
     rb_thread_check_ints(); \
   } \
 } while(0)
-# define HANDLE_REG_TIMEOUT_IN_MATCH_AT do { \
-  rb_reg_raise_timeout(); \
-} while (0)
 # define onig_st_init_table                  st_init_table
 # define onig_st_init_table_with_size        st_init_table_with_size
 # define onig_st_init_numtable               st_init_numtable
@@ -1002,7 +998,6 @@ extern int onig_st_insert_strend(hash_table_type* table, const UChar* str_key, c
 extern size_t onig_memsize(const regex_t *reg);
 extern size_t onig_region_memsize(const struct re_registers *regs);
 bool rb_reg_timeout_p(regex_t *reg, void *end_time);
-NORETURN(void rb_reg_raise_timeout(void));
 #endif
 
 RUBY_SYMBOL_EXPORT_END

data/lib/debase/ruby_core_source/{ruby-3.4.0-preview2 → ruby-4.0.0-preview2}/regparse.h

@@ -69,8 +69,8 @@ RUBY_SYMBOL_EXPORT_BEGIN
 #define NTYPE(node)             ((node)->u.base.type)
 #define SET_NTYPE(node, ntype) \
     do { \
-	int value = ntype; \
-	memcpy(&((node)->u.base.type), &value, sizeof(int)); \
+        int value = ntype; \
+        memcpy(&((node)->u.base.type), &value, sizeof(int)); \
     } while (0)
 
 #define NSTR(node)         (&((node)->u.str))

data/lib/debase/ruby_core_source/ruby-4.0.0-preview2/revision.h

@@ -0,0 +1,5 @@
+#define RUBY_REVISION "4fa6e9938c"
+#define RUBY_FULL_REVISION "4fa6e9938cfb9458abd876ad4219a6648bfe1c96"
+#define RUBY_RELEASE_YEAR 2025
+#define RUBY_RELEASE_MONTH 11
+#define RUBY_RELEASE_DAY 17

data/lib/debase/ruby_core_source/ruby-4.0.0-preview2/ruby_atomic.h

@@ -0,0 +1,66 @@
+#ifndef INTERNAL_ATOMIC_H
+#define INTERNAL_ATOMIC_H
+
+#include "ruby/atomic.h"
+
+#define RUBY_ATOMIC_VALUE_LOAD(x) rbimpl_atomic_value_load(&(x), RBIMPL_ATOMIC_SEQ_CST)
+
+/* shim macros only */
+#define ATOMIC_ADD(var, val) RUBY_ATOMIC_ADD(var, val)
+#define ATOMIC_CAS(var, oldval, newval) RUBY_ATOMIC_CAS(var, oldval, newval)
+#define ATOMIC_DEC(var) RUBY_ATOMIC_DEC(var)
+#define ATOMIC_EXCHANGE(var, val) RUBY_ATOMIC_EXCHANGE(var, val)
+#define ATOMIC_FETCH_ADD(var, val) RUBY_ATOMIC_FETCH_ADD(var, val)
+#define ATOMIC_FETCH_SUB(var, val) RUBY_ATOMIC_FETCH_SUB(var, val)
+#define ATOMIC_INC(var) RUBY_ATOMIC_INC(var)
+#define ATOMIC_OR(var, val) RUBY_ATOMIC_OR(var, val)
+#define ATOMIC_PTR_CAS(var, oldval, newval) RUBY_ATOMIC_PTR_CAS(var, oldval, newval)
+#define ATOMIC_PTR_EXCHANGE(var, val) RUBY_ATOMIC_PTR_EXCHANGE(var, val)
+#define ATOMIC_SET(var, val) RUBY_ATOMIC_SET(var, val)
+#define ATOMIC_SIZE_ADD(var, val) RUBY_ATOMIC_SIZE_ADD(var, val)
+#define ATOMIC_SIZE_CAS(var, oldval, newval) RUBY_ATOMIC_SIZE_CAS(var, oldval, newval)
+#define ATOMIC_SIZE_DEC(var) RUBY_ATOMIC_SIZE_DEC(var)
+#define ATOMIC_SIZE_EXCHANGE(var, val) RUBY_ATOMIC_SIZE_EXCHANGE(var, val)
+#define ATOMIC_SIZE_INC(var) RUBY_ATOMIC_SIZE_INC(var)
+#define ATOMIC_SIZE_SUB(var, val) RUBY_ATOMIC_SIZE_SUB(var, val)
+#define ATOMIC_SUB(var, val) RUBY_ATOMIC_SUB(var, val)
+#define ATOMIC_VALUE_CAS(var, oldval, val) RUBY_ATOMIC_VALUE_CAS(var, oldval, val)
+#define ATOMIC_VALUE_EXCHANGE(var, val) RUBY_ATOMIC_VALUE_EXCHANGE(var, val)
+
+#define ATOMIC_LOAD_RELAXED(var) rbimpl_atomic_load(&(var), RBIMPL_ATOMIC_RELAXED)
+
+typedef RBIMPL_ALIGNAS(8) uint64_t rbimpl_atomic_uint64_t;
+
+static inline uint64_t
+rbimpl_atomic_u64_load_relaxed(const volatile rbimpl_atomic_uint64_t *value)
+{
+#if defined(HAVE_GCC_ATOMIC_BUILTINS_64)
+    return __atomic_load_n(value, __ATOMIC_RELAXED);
+#elif defined(_WIN32)
+    uint64_t val = *value;
+    return InterlockedCompareExchange64(RBIMPL_CAST((uint64_t *)value), val, val);
+#elif defined(__sun) && defined(HAVE_ATOMIC_H) && (defined(_LP64) || defined(_I32LPx))
+    uint64_t val = *value;
+    return atomic_cas_64(value, val, val);
+#else
+    return *value;
+#endif
+}
+#define ATOMIC_U64_LOAD_RELAXED(var) rbimpl_atomic_u64_load_relaxed(&(var))
+
+static inline void
+rbimpl_atomic_u64_set_relaxed(volatile rbimpl_atomic_uint64_t *address, uint64_t value)
+{
+#if defined(HAVE_GCC_ATOMIC_BUILTINS_64)
+    __atomic_store_n(address, value, __ATOMIC_RELAXED);
+#elif defined(_WIN32)
+    InterlockedExchange64(address, value);
+#elif defined(__sun) && defined(HAVE_ATOMIC_H) && (defined(_LP64) || defined(_I32LPx))
+    atomic_swap_64(address, value);
+#else
+    *address = value;
+#endif
+}
+#define ATOMIC_U64_SET_RELAXED(var, val) rbimpl_atomic_u64_set_relaxed(&(var), val)
+
+#endif