farce 0.5.0-aarch64-linux-gnu → 0.6.0-aarch64-linux-gnu

data/ext/farce/trie.c

@@ -111,6 +111,7 @@ typedef struct {
     size_t static_index_count;
     size_t static_index_bytes;
     size_t regexp_edge_count;
+    VALUE (*search_body)(VALUE);
     bool initialized;
 } trie_t;
 
@@ -131,6 +132,7 @@ typedef struct {
     size_t static_index;
     size_t regexp_index;
     unsigned phase;
+    unsigned lowercase_offset;
 } trie_frame_t;
 
 /* A suspended Enumerator or user Fiber can be collected without unwinding the
@@ -191,8 +193,12 @@ static VALUE cTrie;
 static ID id_captures;
 static ID id_named_captures;
 static ID id_timeout;
+static ID id_downcase;
 static bool regexp_timeout_supported;
 
+static VALUE trie_search_body(VALUE opaque);
+static VALUE trie_search_body_ignore_case(VALUE opaque);
+
 #ifdef FARCE_TRIE_FAILURE_INJECTION
 static _Thread_local long trie_failure_countdown = -1;
 static VALUE trie_interrupt_queue = Qnil;
@@ -1356,6 +1362,14 @@ trie_insert_entry(VALUE self, trie_t *trie, VALUE parts, uint32_t token)
             if (rb_enc_str_coderange(stable_part) == ENC_CODERANGE_BROKEN) {
                 rb_raise(rb_eArgError, "trie literal has invalid encoding");
             }
+            if (trie->search_body == trie_search_body_ignore_case) {
+                VALUE lowercase = rb_funcall(stable_part, id_downcase, 0);
+                Check_Type(lowercase, T_STRING);
+                stable_part = rb_str_new_frozen(lowercase);
+                if (rb_enc_str_coderange(stable_part) == ENC_CODERANGE_BROKEN) {
+                    rb_raise(rb_eArgError, "trie literal has invalid encoding");
+                }
+            }
             node = trie_insert_string(self, trie, node, stable_part);
             RB_GC_GUARD(stable_part);
         }
@@ -1407,16 +1421,25 @@ trie_validate_references(VALUE self)
 }
 
 static VALUE
-trie_initialize(VALUE self, VALUE entries, VALUE tokens)
+trie_initialize(int argc, VALUE *argv, VALUE self)
 {
     trie_t *trie;
+    VALUE entries, tokens, options;
+    VALUE ignore_case = Qfalse;
     VALUE token_copy;
     VALUE token_identities;
     long index;
+    rb_scan_args(argc, argv, "2:", &entries, &tokens, &options);
+    if (!NIL_P(options)) {
+        ID keyword = rb_intern("ignore_case");
+        rb_get_kwargs(options, &keyword, 0, 1, &ignore_case);
+        if (ignore_case == Qundef) ignore_case = Qfalse;
+    }
     TypedData_Get_Struct(self, trie_t, &trie_type, trie);
     if (trie->initialized || trie->node_count || !NIL_P(trie->tokens)) {
         rb_raise(rb_eRuntimeError, "trie initialization already attempted");
     }
+    trie->search_body = RTEST(ignore_case) ? trie_search_body_ignore_case : trie_search_body;
     Check_Type(entries, T_ARRAY);
     Check_Type(tokens, T_ARRAY);
     if ((unsigned long)RARRAY_LEN(tokens) > UINT32_MAX) rb_raise(rb_eArgError, "too many trie tokens");
@@ -1616,6 +1639,107 @@ trie_static_match(VALUE input, long cursor, const trie_static_edge_t *edge,
     return true;
 }
 
+typedef struct {
+    rb_encoding *encoding;
+    bool ascii_compatible;
+} trie_case_mapping_t;
+
+static unsigned char
+trie_lowercase_ascii(unsigned char byte)
+{
+    return byte >= 'A' && byte <= 'Z' ? byte + ('a' - 'A') : byte;
+}
+
+static int
+trie_lowercase_character(const trie_case_mapping_t *mapping, const unsigned char **cursor,
+                         const unsigned char *end, unsigned char *output)
+{
+    int bytes = rb_enc_mbclen((const char *)*cursor, (const char *)end, mapping->encoding);
+    OnigCaseFoldType flags = ONIGENC_CASE_DOWNCASE;
+    int length = mapping->encoding->case_map(&flags, cursor, *cursor + bytes,
+                                             output, output + ONIGENC_MBC_CASE_FOLD_MAXLEN,
+                                             mapping->encoding);
+    if (length <= 0) rb_raise(rb_eArgError, "cannot lowercase trie input character");
+    return length;
+}
+
+static void
+trie_search_push_frame_ignore_case(trie_search_t *search, trie_node_t *node, long cursor,
+                                   size_t restore_events, unsigned lowercase_offset,
+                                   const trie_case_mapping_t *mapping)
+{
+    trie_search_ensure_frames(search, search->frame_count + 1);
+    trie_frame_t *frame = &search->frames[search->frame_count++];
+    memset(frame, 0, sizeof(*frame));
+    frame->node = node;
+    frame->cursor = cursor;
+    frame->restore_events = restore_events;
+    frame->lowercase_offset = lowercase_offset;
+    if (node->static_index && cursor < search->input_length) {
+        const unsigned char *bytes = (const unsigned char *)RSTRING_PTR(search->input) + cursor;
+        unsigned char first;
+        if (*bytes < 128 && mapping->ascii_compatible) first = trie_lowercase_ascii(*bytes);
+        else {
+            unsigned char lowercase[ONIGENC_MBC_CASE_FOLD_MAXLEN];
+            const unsigned char *end = (const unsigned char *)RSTRING_END(search->input);
+            trie_lowercase_character(mapping, &bytes, end, lowercase);
+            first = lowercase[lowercase_offset];
+        }
+        const uint32_t *slot = trie_static_index_slot_const(node->static_index, first);
+        frame->static_index = slot ? *slot : 0;
+    }
+}
+
+static bool
+trie_static_match_ignore_case(trie_search_t *search, const trie_frame_t *frame,
+                              const trie_static_edge_t *edge, const trie_case_mapping_t *mapping,
+                              long *end_cursor, unsigned *end_offset)
+{
+    VALUE input = search->input;
+    VALUE label = edge->label;
+    if (edge->encoding != search->input_encoding && !rb_enc_compatible(label, input)) return false;
+    long cursor = frame->cursor;
+    unsigned offset = frame->lowercase_offset;
+    long index = 0;
+    long length = RSTRING_LEN(label);
+    long checkpoint = 16384;
+    while (index < length) {
+        if (cursor >= search->input_length) return false;
+        const unsigned char *bytes = (const unsigned char *)RSTRING_PTR(input) + cursor;
+        const unsigned char *literal = (const unsigned char *)RSTRING_PTR(label);
+        if (*bytes < 128 && mapping->ascii_compatible) {
+            if (trie_lowercase_ascii(*bytes) != literal[index]) return false;
+            cursor++;
+            index++;
+        }
+        else {
+            unsigned char lowercase[ONIGENC_MBC_CASE_FOLD_MAXLEN];
+            const unsigned char *begin = bytes;
+            const unsigned char *end = (const unsigned char *)RSTRING_END(input);
+            int count = trie_lowercase_character(mapping, &bytes, end, lowercase);
+            while (offset < (unsigned)count && index < length) {
+                if (lowercase[offset++] != literal[index++]) return false;
+            }
+            /* A radix split can fall inside one character's lowercase expansion.
+             * Retain its original cursor until every lowercase byte is consumed. */
+            if (offset == (unsigned)count) {
+                cursor += bytes - begin;
+                offset = 0;
+            }
+        }
+        if (index >= checkpoint) {
+            trie_check_interrupts();
+            checkpoint = index + 16384;
+        }
+    }
+    *end_cursor = cursor;
+    *end_offset = offset;
+    return true;
+}
+
+/* Keep the original traversal's inlining when compiling both search modes. */
+ALWAYS_INLINE(static bool trie_regexp_match(const trie_regexp_edge_t *edge, trie_search_t *search,
+                                           long cursor, long *end_cursor));
 static bool
 trie_regexp_match(const trie_regexp_edge_t *edge, trie_search_t *search,
                   long cursor, long *end_cursor)
@@ -1765,6 +1889,7 @@ trie_seen(trie_search_t *search, uint32_t token)
     return false;
 }
 
+ALWAYS_INLINE(static bool trie_emit_terminal(trie_search_t *search, trie_frame_t *frame));
 static bool
 trie_emit_terminal(trie_search_t *search, trie_frame_t *frame)
 {
@@ -1796,75 +1921,17 @@ trie_emit_terminal(trie_search_t *search, trie_frame_t *frame)
     return false;
 }
 
-static VALUE
-trie_search_body(VALUE opaque)
-{
-    trie_search_t *search = (trie_search_t *)(uintptr_t)opaque;
-    trie_search_push_frame(search, search->trie->root, 0, 0);
-    while (search->frame_count) {
-        trie_frame_t *frame = &search->frames[search->frame_count - 1];
-        trie_search_work_checkpoint(search);
-        if (frame->phase == 0) {
-            bool descended = false;
-            if (frame->node->static_index) {
-                while (frame->static_index) {
-                    trie_static_edge_t *edge = &frame->node->static_edges[frame->static_index - 1];
-                    long label_length = RSTRING_LEN(edge->label);
-                    frame->static_index = edge->next_same_byte;
-                    if (!trie_static_match(search->input, frame->cursor, edge,
-                                           label_length, search->input_encoding)) continue;
-                    trie_search_push_frame(search, edge->child, frame->cursor + label_length,
-                                           search->event_count);
-                    descended = true;
-                    break;
-                }
-            }
-            else {
-                while (frame->static_index < frame->node->static_count) {
-                    trie_static_edge_t *edge = &frame->node->static_edges[frame->static_index++];
-                    long label_length = RSTRING_LEN(edge->label);
-                    if (!trie_static_match(search->input, frame->cursor, edge,
-                                           label_length, search->input_encoding)) continue;
-                    trie_search_push_frame(search, edge->child, frame->cursor + label_length,
-                                           search->event_count);
-                    descended = true;
-                    break;
-                }
-            }
-            if (descended) continue;
-            frame->phase = 1;
-        }
-        if (frame->phase == 1) {
-            bool descended = false;
-            while (frame->regexp_index < frame->node->regexp_count) {
-                trie_regexp_edge_t *edge = &frame->node->regexp_edges[frame->regexp_index++];
-                size_t restore = search->event_count;
-                long end_cursor;
-                if (!trie_regexp_match(edge, search, frame->cursor, &end_cursor)) {
-                    search->event_count = restore;
-                    continue;
-                }
-                trie_search_push_frame(search, edge->child, end_cursor, restore);
-                descended = true;
-                break;
-            }
-            if (descended) continue;
-            frame->phase = 2;
-        }
-        if (frame->phase == 2) {
-            frame->phase = 3;
-            if ((search->peek || frame->cursor == search->input_length) &&
-                trie_emit_terminal(search, frame)) break;
-        }
-        if (frame->phase == 3) {
-            size_t restore = frame->restore_events;
-            search->frame_count--;
-            search->event_count = restore;
-        }
-    }
-    if (search->stream) return search->self;
-    return search->first_only ? search->first : search->results;
-}
+#define TRIE_IGNORE_CASE 0
+#define TRIE_SEARCH_BODY trie_search_body
+#include "trie_search.h"
+#undef TRIE_SEARCH_BODY
+#undef TRIE_IGNORE_CASE
+
+#define TRIE_IGNORE_CASE 1
+#define TRIE_SEARCH_BODY trie_search_body_ignore_case
+#include "trie_search.h"
+#undef TRIE_SEARCH_BODY
+#undef TRIE_IGNORE_CASE
 
 static VALUE
 trie_search_cleanup(VALUE opaque)
@@ -1916,7 +1983,7 @@ trie_search(VALUE self, VALUE input, bool peek, bool first_only, bool stream)
                                       encoding == rb_usascii_encindex() ||
                                       encoding == rb_ascii8bit_encindex();
     }
-    VALUE result = rb_ensure(trie_search_body, (VALUE)(uintptr_t)&search,
+    VALUE result = rb_ensure(search.trie->search_body, (VALUE)(uintptr_t)&search,
                              trie_search_cleanup, (VALUE)(uintptr_t)&search);
     RB_GC_GUARD(self);
     RB_GC_GUARD(input);
@@ -2035,7 +2102,7 @@ containers_init_trie(VALUE namespace)
     (void)namespace;
     cTrie = rb_define_class_under(strict, "Trie", rb_cObject);
     rb_define_alloc_func(cTrie, trie_allocate);
-    rb_define_private_method(cTrie, "initialize", trie_initialize, 2);
+    rb_define_private_method(cTrie, "initialize", trie_initialize, -1);
     rb_define_private_method(cTrie, "initialize_copy", trie_initialize_copy, 1);
     rb_define_method(cTrie, "match", trie_match, 1);
     rb_define_method(cTrie, "match_all", trie_match_all, 1);
@@ -2054,5 +2121,6 @@ containers_init_trie(VALUE namespace)
     id_captures = rb_intern("captures");
     id_named_captures = rb_intern("named_captures");
     id_timeout = rb_intern("timeout");
+    id_downcase = rb_intern("downcase");
     regexp_timeout_supported = rb_respond_to(rb_cRegexp, id_timeout);
 }

data/ext/farce/trie_search.h

@@ -0,0 +1,114 @@
+/* Included twice to specialize static matching without a mode branch in the
+ * traversal loop. Keep both modes on the same capture and backtracking logic. */
+
+static VALUE
+TRIE_SEARCH_BODY(VALUE opaque)
+{
+    trie_search_t *search = (trie_search_t *)(uintptr_t)opaque;
+#if TRIE_IGNORE_CASE
+    trie_case_mapping_t mapping = { .encoding = rb_enc_from_index(search->input_encoding) };
+    mapping.ascii_compatible = rb_enc_asciicompat(mapping.encoding);
+    trie_search_push_frame_ignore_case(search, search->trie->root, 0, 0, 0, &mapping);
+#else
+    trie_search_push_frame(search, search->trie->root, 0, 0);
+#endif
+    while (search->frame_count) {
+        trie_frame_t *frame = &search->frames[search->frame_count - 1];
+        trie_search_work_checkpoint(search);
+        if (frame->phase == 0) {
+            bool descended = false;
+            if (frame->node->static_index) {
+                while (frame->static_index) {
+                    trie_static_edge_t *edge = &frame->node->static_edges[frame->static_index - 1];
+#if TRIE_IGNORE_CASE
+                    long end_cursor;
+                    unsigned end_offset;
+#else
+                    long label_length = RSTRING_LEN(edge->label);
+#endif
+                    frame->static_index = edge->next_same_byte;
+#if TRIE_IGNORE_CASE
+                    if (!trie_static_match_ignore_case(search, frame, edge, &mapping,
+                                                       &end_cursor, &end_offset)) continue;
+                    trie_search_push_frame_ignore_case(search, edge->child, end_cursor,
+                                                        search->event_count, end_offset, &mapping);
+#else
+                    if (!trie_static_match(search->input, frame->cursor, edge,
+                                           label_length, search->input_encoding)) continue;
+                    trie_search_push_frame(search, edge->child, frame->cursor + label_length,
+                                           search->event_count);
+#endif
+                    descended = true;
+                    break;
+                }
+            }
+            else {
+                while (frame->static_index < frame->node->static_count) {
+                    trie_static_edge_t *edge = &frame->node->static_edges[frame->static_index++];
+#if TRIE_IGNORE_CASE
+                    long end_cursor;
+                    unsigned end_offset;
+#else
+                    long label_length = RSTRING_LEN(edge->label);
+#endif
+#if TRIE_IGNORE_CASE
+                    if (!trie_static_match_ignore_case(search, frame, edge, &mapping,
+                                                       &end_cursor, &end_offset)) continue;
+                    trie_search_push_frame_ignore_case(search, edge->child, end_cursor,
+                                                        search->event_count, end_offset, &mapping);
+#else
+                    if (!trie_static_match(search->input, frame->cursor, edge,
+                                           label_length, search->input_encoding)) continue;
+                    trie_search_push_frame(search, edge->child, frame->cursor + label_length,
+                                           search->event_count);
+#endif
+                    descended = true;
+                    break;
+                }
+            }
+            if (descended) continue;
+            frame->phase = 1;
+        }
+        if (frame->phase == 1) {
+            bool descended = false;
+            while (frame->regexp_index < frame->node->regexp_count) {
+#if TRIE_IGNORE_CASE
+                if (frame->lowercase_offset) break;
+#endif
+                trie_regexp_edge_t *edge = &frame->node->regexp_edges[frame->regexp_index++];
+                size_t restore = search->event_count;
+                long end_cursor;
+                if (!trie_regexp_match(edge, search, frame->cursor, &end_cursor)) {
+                    search->event_count = restore;
+                    continue;
+                }
+#if TRIE_IGNORE_CASE
+                trie_search_push_frame_ignore_case(search, edge->child, end_cursor, restore, 0, &mapping);
+#else
+                trie_search_push_frame(search, edge->child, end_cursor, restore);
+#endif
+                descended = true;
+                break;
+            }
+            if (descended) continue;
+            frame->phase = 2;
+        }
+        if (frame->phase == 2) {
+            frame->phase = 3;
+            if (
+#if TRIE_IGNORE_CASE
+                !frame->lowercase_offset &&
+#endif
+                (search->peek || frame->cursor == search->input_length) &&
+                trie_emit_terminal(search, frame)) break;
+        }
+        if (frame->phase == 3) {
+            size_t restore = frame->restore_events;
+            search->frame_count--;
+            search->event_count = restore;
+        }
+    }
+    if (search->stream) return search->self;
+    return search->first_only ? search->first : search->results;
+}
+

data/ext/farce/vector.c

@@ -4,6 +4,7 @@
 #include "ruby/fiber/scheduler.h"
 
 #include <errno.h>
+#include <limits.h>
 #include <math.h>
 #include <stdint.h>
 #include <stdlib.h>
@@ -380,22 +381,26 @@ vector_assignment_index(vector_t *vector, long long raw)
     return (size_t)raw;
 }
 
+static size_t
+vector_initial_size(VALUE source)
+{
+    long size = NUM2LONG(source);
+    if (size < 0) rb_raise(rb_eArgError, "negative array size");
+    if (size > LONG_MAX / (long)sizeof(VALUE)) rb_raise(rb_eArgError, "array size too big");
+    return (size_t)size;
+}
+
 static VALUE
-vector_initialize(int argc, VALUE *argv, VALUE self)
+vector_normalize_source(VALUE klass, VALUE source)
 {
-    VALUE source = Qnil;
-    VALUE keywords = Qnil;
-    VALUE identity = Qundef;
-    ID keyword_ids[] = {rb_intern("compare_by_identity")};
-    VALUE keyword_values[1];
-    vector_t *vector;
+    if (RB_INTEGER_TYPE_P(source)) vector_initial_size(source);
+    return source;
+}
 
-    rb_check_frozen(self);
-    rb_scan_args(argc, argv, "01:", &source, &keywords);
-    if (!NIL_P(keywords)) {
-        rb_get_kwargs(keywords, keyword_ids, 0, 1, keyword_values);
-        identity = keyword_values[0];
-    }
+static VALUE
+vector_initialize_with_identity(VALUE self, VALUE source, VALUE identity)
+{
+    vector_t *vector;
     TypedData_Get_Struct(self, vector_t, &vector_type, vector);
     if (vector->initialized) rb_raise(rb_eRuntimeError, "Vector is already initialized");
 
@@ -403,8 +408,12 @@ vector_initialize(int argc, VALUE *argv, VALUE self)
         ? false
         : containers_strict_bool(identity, "compare_by_identity");
 
+    bool sized = RB_INTEGER_TYPE_P(source);
     size_t size = 0;
-    if (!NIL_P(source)) {
+    if (sized) {
+        size = vector_initial_size(source);
+    }
+    else if (!NIL_P(source)) {
         Check_Type(source, T_ARRAY);
         size = (size_t)RARRAY_LEN(source);
     }
@@ -413,16 +422,37 @@ vector_initialize(int argc, VALUE *argv, VALUE self)
     if (!vector->values) rb_memerror();
     vector->capacity = capacity;
 
-    for (size_t index = 0; index < size; index++) {
-        VALUE value = rb_ary_entry(source, (long)index);
-        containers_check_shareable(value);
-        RB_OBJ_WRITE(self, &vector->values[index], value);
+    if (!sized) {
+        for (size_t index = 0; index < size; index++) {
+            VALUE value = rb_ary_entry(source, (long)index);
+            containers_check_shareable(value);
+            RB_OBJ_WRITE(self, &vector->values[index], value);
+        }
     }
     vector->size = size;
     vector->initialized = true;
+    if (sized) return containers_publish_native_reference_free(self);
     return containers_publish_native_with_references(self, vector_validate_references);
 }
 
+static VALUE
+vector_initialize(int argc, VALUE *argv, VALUE self)
+{
+    ID keyword_ids[] = {rb_intern("compare_by_identity")};
+    VALUE keyword_values[1];
+
+    rb_check_frozen(self);
+    VALUE source = containers_parse_constructor(argc, argv, keyword_ids, 1, keyword_values);
+    return vector_initialize_with_identity(self, source, keyword_values[0]);
+}
+
+static VALUE
+vector_new_for_modes(VALUE klass, VALUE source)
+{
+    VALUE self = rb_obj_alloc(klass);
+    return vector_initialize_with_identity(self, source, Qtrue);
+}
+
 static VALUE
 vector_snapshot_locked(VALUE self)
 {
@@ -1185,6 +1215,8 @@ containers_init_vector(VALUE namespace)
 
     cVector = rb_define_class_under(namespace, "Vector", rb_cObject);
     rb_define_alloc_func(cVector, vector_allocate);
+    rb_define_singleton_method(cVector, "normalize_source", vector_normalize_source, 1);
+    rb_define_singleton_method(cVector, "new_for_modes", vector_new_for_modes, 1);
     rb_define_method(cVector, "freeze", vector_freeze, 0);
     rb_define_method(cVector, "initialize", vector_initialize, -1);
     rb_define_method(cVector, "size", vector_size, 0);

data/ext/farce/weak_map.c

@@ -1,4 +1,5 @@
 #include "containers.h"
+#include "weak_references.h"
 
 #ifdef RC_HAVE_NATIVE_WEAK_REFERENCES
 
@@ -15,11 +16,6 @@
 
 #define WEAK_MAP_INITIAL_CAPACITY 16
 
-/* These functions are exported by Rubies with the probed typed-data weak
- * reference callback, but their declarations intentionally remain internal. */
-void rb_gc_declare_weak_references(VALUE object);
-bool rb_gc_handle_weak_references_alive_p(VALUE object);
-
 static VALUE cWeakKeyMap;
 static VALUE weak_map_keep;
 static VALUE weak_map_delete_token;
@@ -209,7 +205,7 @@ weak_map_compact(void *pointer)
  * mutex here could deadlock if GC stopped a mutator at a safepoint while it
  * owned the mutex, so cleanup deliberately runs lock-free. */
 static void
-weak_map_handle_weak_references(void *pointer)
+FARCE_WEAK_REFERENCES_CALLBACK(weak_map_handle_weak_references)
 {
     weak_map_t *map = pointer;
     if (!map->slots) return;
@@ -219,8 +215,8 @@ weak_map_handle_weak_references(void *pointer)
         weak_map_slot_t *slot = &map->slots[index];
         if (slot->state != WEAK_MAP_OCCUPIED) continue;
 
-        bool key_alive = !map->weak_keys || rb_gc_handle_weak_references_alive_p(slot->key);
-        bool value_alive = !map->weak_values || rb_gc_handle_weak_references_alive_p(slot->value);
+        bool key_alive = !map->weak_keys || FARCE_WEAK_REFERENCE_ALIVE_P(slot->key);
+        bool value_alive = !map->weak_values || FARCE_WEAK_REFERENCE_ALIVE_P(slot->value);
         if (key_alive && value_alive) continue;
 
         slot->key = Qnil;

data/ext/farce/weak_references.h

@@ -0,0 +1,23 @@
+#ifndef FARCE_WEAK_REFERENCES_H
+#define FARCE_WEAK_REFERENCES_H
+
+#include "ruby.h"
+#include <stdbool.h>
+
+#ifdef RC_HAVE_NATIVE_WEAK_REFERENCES
+/* These symbols are exported, but their declarations remain internal. The
+ * callback and liveness function gained the same opaque GC context together. */
+void rb_gc_declare_weak_references(VALUE object);
+
+#ifdef FARCE_WEAK_REFERENCES_HAVE_OBJSPACE
+bool rb_gc_handle_weak_references_alive_p(void *objspace, VALUE object);
+# define FARCE_WEAK_REFERENCES_CALLBACK(name) name(void *pointer, void *objspace)
+# define FARCE_WEAK_REFERENCE_ALIVE_P(object) rb_gc_handle_weak_references_alive_p(objspace, object)
+#else
+bool rb_gc_handle_weak_references_alive_p(VALUE object);
+# define FARCE_WEAK_REFERENCES_CALLBACK(name) name(void *pointer)
+# define FARCE_WEAK_REFERENCE_ALIVE_P(object) rb_gc_handle_weak_references_alive_p(object)
+#endif
+#endif
+
+#endif

data/ext/java/org/farce/FiberScheduler.java

@@ -17,6 +17,7 @@ import org.jruby.RubyModule;
 import org.jruby.RubyObject;
 import org.jruby.RubyThread;
 import org.jruby.anno.JRubyMethod;
+import org.jruby.api.Access;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 import org.jruby.util.io.SelectExecutor;
@@ -30,9 +31,10 @@ public final class FiberScheduler extends RubyObject {
     public FiberScheduler(Ruby runtime, RubyClass klass) { super(runtime, klass); }
 
     public static void load(Ruby runtime) {
-        RubyModule internal = (RubyModule) runtime.getModule("Farce").getConstantAt("Internal");
-        RubyClass klass = internal.defineClassUnder("FiberScheduler", runtime.getObject(), FiberScheduler::new);
-        klass.defineAnnotatedMethods(FiberScheduler.class);
+        ThreadContext context = runtime.getCurrentContext();
+        RubyModule internal = (RubyModule) Access.getModule(context, "Farce").getConstantAt(context, "Internal");
+        RubyClass klass = internal.defineClassUnder(context, "FiberScheduler", runtime.getObject(), FiberScheduler::new);
+        klass.defineMethods(context, FiberScheduler.class);
     }
 
     @JRubyMethod(name = "nio_initialize")
@@ -59,14 +61,14 @@ public final class FiberScheduler extends RubyObject {
         checkOwner(context);
         if (selector == null) throw context.runtime.newIOError("scheduler is closed");
         RubyArray groups = (RubyArray) groupValue;
-        Long milliseconds = timeout.isNil() ? null : Math.max(0, (long)Math.ceil(timeout.convertToFloat().getDoubleValue() * 1000));
+        Long milliseconds = timeout.isNil() ? null : Math.max(0, (long)Math.ceil(timeout.convertToFloat().asDouble(context) * 1000));
         IRubyObject immediate = snapshot(context, groups, 0L);
         if (!immediate.isNil() || (milliseconds != null && milliseconds == 0)) return immediate;
         HashMap<SelectableChannel, Integer> interests = new HashMap<>();
         boolean compatible = ((RubyArray)groups.entry(2)).isEmpty();
         for (int i = 0; i < 2; i++) {
             RubyArray list = (RubyArray)groups.entry(i);
-            for (Object object : list.toJavaArray()) {
+            for (Object object : list.toJavaArray(context)) {
                 RubyIO io = RubyIO.convertToIO(context, (IRubyObject)object);
                 SelectableChannel channel = io.getOpenFileChecked().fd().chSelect;
                 if (channel == null || channel.provider() != selector.provider()) { compatible = false; continue; }
@@ -123,7 +125,7 @@ public final class FiberScheduler extends RubyObject {
     public IRubyObject hookBuffer(ThreadContext context, IRubyObject value) {
         RubyIOBuffer buffer = (RubyIOBuffer)value;
         if (!buffer.locked_p(context).isTrue()) return value;
-        if (buffer.size(context).convertToInteger().getLongValue() != 0) return value;
+        if (buffer.size(context).convertToInteger().asLong(context) != 0) return value;
         try {
             Field field = RubyIOBuffer.class.getDeclaredField("base");
             if (!field.trySetAccessible()) throw context.runtime.newRuntimeError("Farce cannot access the JRuby hook buffer layout");

data/lib/farce/abstract/atom.rb

@@ -59,7 +59,11 @@ module Farce
       # @yield computes the value to store when the current value is nil
       # @yieldreturn [BasicObject, nil] the value to store
       # @return [BasicObject, nil] the current or newly stored value, or nil when the timeout expires
-      def store_if_absent(timeout: nil, &) = internal_atom.store_if_absent(timeout:, &)
+      def store_if_absent(timeout: nil, &)
+        return internal_atom.store_if_absent(&) if timeout.nil?
+
+        internal_atom.store_if_absent(timeout:, &)
+      end
 
       # Atomically replace the current value if it matches the expected value.
       # @param expected [BasicObject, nil] the value to compare with the current value

data/lib/farce/abstract/counter.rb

@@ -15,14 +15,15 @@ module Farce
     #   @return [Integer] The current value of the counter.
     #
     # @!method increment(by = 1)
-    #   Increment the counter by the given amount (default is 1).
+    #   Atomically increment the counter by the given amount (default is 1).
+    #   Use the returned integer to allocate a sequence number without a separate read.
     #   @param [Numeric, String, #to_int] by The amount, converted to an Integer.
-    #   @return [self] Returns self for chaining.
+    #   @return [Integer] The value produced by this atomic update.
     #
     # @!method decrement(by = 1)
-    #   Decrement the counter by the given amount (default is 1).
+    #   Atomically decrement the counter by the given amount (default is 1).
     #   @param [Numeric, String, #to_int] by The amount, converted to an Integer.
-    #   @return [self] Returns self for chaining.
+    #   @return [Integer] The value produced by this atomic update.
     module Counter
       include Internal::MarshalSupport::Counter
       include Internal::Copyable