farce 0.4.1-aarch64-linux-gnu → 0.6.0-aarch64-linux-gnu

data/ext/farce/queue.c

@@ -33,6 +33,8 @@ typedef struct {
 #endif
 } readiness_signal_t;
 
+typedef struct queue_wait_context queue_wait_context_t;
+
 typedef struct {
     pthread_mutex_t lock;
     VALUE *values;
@@ -44,8 +46,14 @@ typedef struct {
     size_t tail;
     size_t pop_waiters;
     size_t push_waiters;
+    VALUE interrupt_token;
+    uint64_t interrupt_generation;
+    size_t interrupt_pending;
+    queue_wait_context_t *interrupt_waiters;
     readiness_signal_t can_pop;
     readiness_signal_t can_push;
+    readiness_signal_t interrupts_drained;
+    size_t interrupt_drain_waiters;
     farce_unshared_wait_list_t unshared_pop_waiters;
     farce_unshared_wait_list_t unshared_push_waiters;
     bool bounded;
@@ -160,20 +168,25 @@ queue_update_readiness(queue_t *queue)
     }
     readiness_set(
         &queue->can_pop,
-        queue->pop_waiters > 0 && (queue->closed || queue->size > 0)
+        queue->pop_waiters > 0 && (queue->closed || queue->size > 0 || queue->interrupt_pending > 0)
     );
     readiness_set(
         &queue->can_push,
         queue->push_waiters > 0 &&
             (queue->sealed || !queue->bounded || queue->size < queue->limit)
     );
+    readiness_set(
+        &queue->interrupts_drained,
+        queue->interrupt_drain_waiters > 0 && (queue->closed || queue->interrupt_pending == 0)
+    );
     if (!queue->shared) {
         /* Keep the slow path until both waiter mechanisms and every pending
          * readiness byte have drained. Interrupted direct waits may leave the
          * flag set, which is harmless and corrected by the next mutation. */
         queue->unshared_notifications_needed = queue->pop_waiters || queue->push_waiters ||
             queue->unshared_pop_waiters.count || queue->unshared_push_waiters.count ||
-            queue->can_pop.set || queue->can_push.set;
+            queue->can_pop.set || queue->can_push.set ||
+            queue->interrupt_drain_waiters || queue->interrupts_drained.set;
     }
 }
 
@@ -181,6 +194,7 @@ static void
 queue_mark(void *pointer)
 {
     queue_t *queue = pointer;
+    rb_gc_mark_movable(queue->interrupt_token);
     farce_unshared_wait_mark(&queue->unshared_pop_waiters);
     farce_unshared_wait_mark(&queue->unshared_push_waiters);
     if (!queue->values) return;
@@ -195,6 +209,7 @@ static void
 queue_compact(void *pointer)
 {
     queue_t *queue = pointer;
+    containers_gc_update(&queue->interrupt_token);
     if (!queue->values) return;
     size_t index = queue->head;
     for (size_t remaining = queue->size; remaining > 0; remaining--) {
@@ -212,6 +227,7 @@ queue_free(void *pointer)
     free(queue->enqueued_at);
     readiness_close(&queue->can_pop);
     readiness_close(&queue->can_push);
+    readiness_close(&queue->interrupts_drained);
     ruby_xfree(queue);
 }
 
@@ -277,8 +293,14 @@ queue_allocate_type(VALUE klass, bool shared)
     queue->tail = 0;
     queue->pop_waiters = 0;
     queue->push_waiters = 0;
+    queue->interrupt_token = Qnil;
+    queue->interrupt_generation = 0;
+    queue->interrupt_pending = 0;
+    queue->interrupt_waiters = NULL;
     queue->can_pop = (readiness_signal_t){.read_fd = -1, .write_fd = -1, .set = false};
     queue->can_push = (readiness_signal_t){.read_fd = -1, .write_fd = -1, .set = false};
+    queue->interrupts_drained = (readiness_signal_t){.read_fd = -1, .write_fd = -1, .set = false};
+    queue->interrupt_drain_waiters = 0;
     queue->unshared_pop_waiters = (farce_unshared_wait_list_t){0};
     queue->unshared_push_waiters = (farce_unshared_wait_list_t){0};
     queue->bounded = true;
@@ -384,6 +406,8 @@ typedef struct {
     bool finite;
     bool collected;
     double deadline;
+    bool interruptible;
+    VALUE token;
 } queue_timeout_t;
 
 static double
@@ -449,13 +473,44 @@ queue_wait_for_descriptor(int fd, queue_timeout_t *timeout)
     return containers_wait_for_readable(fd, wait_timeout);
 }
 
-typedef struct {
+struct queue_wait_context {
     queue_t *queue;
     readiness_signal_t *signal;
     size_t *waiter_count;
     queue_timeout_t *timeout;
     int wait_fd;
-} queue_wait_context_t;
+    bool linked;
+    uint64_t generation;
+    queue_wait_context_t *previous;
+    queue_wait_context_t *next;
+};
+
+/* Keep a wakeup readable until every interrupted descriptor waiter has left.
+ * Registration and removal happen under the same queue lock as publication. */
+static void
+queue_register_interrupt_waiter(queue_wait_context_t *context)
+{
+    if (!context->timeout->interruptible || context->signal != &context->queue->can_pop) return;
+    queue_t *queue = context->queue;
+    context->generation = queue->interrupt_generation;
+    context->previous = NULL;
+    context->next = queue->interrupt_waiters;
+    if (context->next) context->next->previous = context;
+    queue->interrupt_waiters = context;
+    context->linked = true;
+}
+
+static void
+queue_remove_interrupt_waiter(queue_wait_context_t *context)
+{
+    if (!context->linked) return;
+    queue_t *queue = context->queue;
+    if (context->previous) context->previous->next = context->next;
+    else queue->interrupt_waiters = context->next;
+    if (context->next) context->next->previous = context->previous;
+    if (context->generation != queue->interrupt_generation) queue->interrupt_pending--;
+    context->linked = false;
+}
 
 static VALUE
 queue_wait_body(VALUE opaque)
@@ -527,6 +582,7 @@ queue_wait_cleanup(VALUE opaque)
     queue_wait_context_t *context = (queue_wait_context_t *)opaque;
     if (context->wait_fd >= 0) close(context->wait_fd);
     queue_lock(context->queue);
+    queue_remove_interrupt_waiter(context);
     (*context->waiter_count)--;
     queue_update_readiness(context->queue);
     if (context->queue->closed && *context->waiter_count == 0) {
@@ -588,8 +644,16 @@ queue_wait(VALUE self, queue_t *queue, readiness_signal_t *signal, size_t *waite
         queue_unlock(queue);
         return false;
     }
+    /* A fresh wait must not repeatedly consume readiness reserved for older
+     * interrupted fibers on the same scheduler. Wait for their acknowledgments
+     * on a separate signal, without joining the interrupted generation. */
+    if (signal == &queue->can_pop && queue->interrupt_pending > 0) {
+        signal = &queue->interrupts_drained;
+        waiter_count = &queue->interrupt_drain_waiters;
+    }
     if (!queue->shared) queue->unshared_notifications_needed = true;
-    if (!queue->shared && (!queue->unshared_fiber_io || NIL_P(rb_fiber_scheduler_current()))) {
+    if (signal != &queue->interrupts_drained && !queue->shared &&
+        (!queue->unshared_fiber_io || NIL_P(rb_fiber_scheduler_current()))) {
         farce_unshared_wait_list_t *list = signal == &queue->can_pop ?
             &queue->unshared_pop_waiters : &queue->unshared_push_waiters;
         return farce_unshared_wait(list, self, timeout->finite, timeout->deadline);
@@ -611,6 +675,7 @@ queue_wait(VALUE self, queue_t *queue, readiness_signal_t *signal, size_t *waite
             .timeout = timeout,
             .wait_fd = -1,
         };
+        queue_register_interrupt_waiter(&context);
         (*waiter_count)++;
         queue_update_readiness(queue);
         queue_unlock(queue);
@@ -632,6 +697,7 @@ queue_wait(VALUE self, queue_t *queue, readiness_signal_t *signal, size_t *waite
         .timeout = timeout,
         .wait_fd = wait_fd,
     };
+    queue_register_interrupt_waiter(&context);
     (*waiter_count)++;
     queue_update_readiness(queue);
     queue_unlock(queue);
@@ -664,7 +730,54 @@ static VALUE
 queue_capacity(VALUE self)
 {
     queue_t *queue = get_queue(self);
-    return queue->bounded ? SIZET2NUM(queue->limit) : Qnil;
+    queue_lock(queue);
+    bool bounded = queue->bounded;
+    size_t limit = queue->limit;
+    queue_unlock(queue);
+    return bounded ? SIZET2NUM(limit) : Qnil;
+}
+
+static VALUE
+queue_set_capacity(VALUE self, VALUE value)
+{
+    size_t limit = 0;
+    if (!NIL_P(value)) {
+        long long converted = NUM2LL(rb_to_int(value));
+        if (converted <= 0) rb_raise(rb_eArgError, "capacity must be positive or nil");
+        if ((unsigned long long)converted > SIZE_MAX / sizeof(VALUE)) rb_raise(rb_eArgError, "capacity is too large");
+        limit = (size_t)converted;
+    }
+    queue_t *queue = get_queue(self);
+    queue_lock(queue);
+    queue->bounded = !NIL_P(value);
+    queue->limit = limit;
+    queue_update_readiness(queue);
+    queue_unlock(queue);
+    return value;
+}
+
+static VALUE
+queue_interrupt(VALUE self, VALUE token, VALUE generation_value)
+{
+    queue_t *queue = get_queue(self);
+    if (queue->shared) containers_check_shareable(token);
+    uint64_t generation = NUM2ULL(generation_value);
+    queue_lock(queue);
+    /* Concurrent writers can finish their notifications out of order. */
+    if (!NIL_P(queue->interrupt_token) && generation <= queue->interrupt_generation) {
+        queue_unlock(queue);
+        return self;
+    }
+    RB_OBJ_WRITE(self, &queue->interrupt_token, token);
+    queue->interrupt_generation = generation;
+    queue->interrupt_pending = 0;
+    for (queue_wait_context_t *waiter = queue->interrupt_waiters; waiter; waiter = waiter->next) {
+        if (waiter->generation != generation) queue->interrupt_pending++;
+    }
+    if (!queue->shared) farce_unshared_wait_notify_all(&queue->unshared_pop_waiters);
+    queue_update_readiness(queue);
+    queue_unlock(queue);
+    return self;
 }
 
 /* Called with queue->lock held. The queue is unchanged if allocation fails.
@@ -719,7 +832,7 @@ queue_num_waiting(VALUE self)
     queue_t *queue = get_queue(self);
     size_t num_waiting;
     queue_lock(queue);
-    num_waiting = queue->pop_waiters + queue->push_waiters +
+    num_waiting = queue->pop_waiters + queue->push_waiters + queue->interrupt_drain_waiters +
         queue->unshared_pop_waiters.count + queue->unshared_push_waiters.count;
     queue_unlock(queue);
     return SIZET2NUM(num_waiting);
@@ -848,6 +961,7 @@ queue_close(VALUE self)
         queue_update_readiness(queue);
         if (queue->pop_waiters == 0) readiness_close(&queue->can_pop);
         if (queue->push_waiters == 0) readiness_close(&queue->can_push);
+        if (queue->interrupt_drain_waiters == 0) readiness_close(&queue->interrupts_drained);
     }
     queue_unlock(queue);
     return self;
@@ -862,6 +976,7 @@ queue_release_wait_descriptors(VALUE self)
     queue_lock(queue);
     if (queue->pop_waiters == 0) readiness_close(&queue->can_pop);
     if (queue->push_waiters == 0) readiness_close(&queue->can_push);
+    if (queue->interrupt_drain_waiters == 0) readiness_close(&queue->interrupts_drained);
     queue_unlock(queue);
     return self;
 }
@@ -871,6 +986,10 @@ queue_pop_with_timeout(VALUE self, queue_t *queue, queue_timeout_t timeout)
 {
     for (;;) {
         queue_lock(queue);
+        if (timeout.interruptible && timeout.token != queue->interrupt_token) {
+            queue_unlock(queue);
+            return Qfalse;
+        }
         if (queue->closed) {
             queue_unlock(queue);
             raise_queue_closed();
@@ -902,6 +1021,18 @@ queue_pop(int argc, VALUE *argv, VALUE self)
     return queue_pop_with_timeout(self, queue, timeout);
 }
 
+/* Pool dispatch uses positional arguments to avoid another keyword hash. */
+static VALUE
+queue_pop_interruptible(VALUE self, VALUE token, VALUE timeout_value)
+{
+    queue_timeout_t timeout = parse_timeout(timeout_value);
+    timeout.interruptible = true;
+    timeout.token = token;
+    VALUE result = queue_pop_with_timeout(self, get_queue(self), timeout);
+    RB_GC_GUARD(token);
+    return result;
+}
+
 static VALUE
 queue_try_pop(VALUE self)
 {
@@ -1042,6 +1173,9 @@ containers_init_queue(VALUE namespace)
     rb_define_method(unshared, "fiber_wait", unshared_queue_fiber_wait, 0);
     rb_define_method(cQueue, "initialize", queue_initialize, -1);
     rb_define_method(cQueue, "capacity", queue_capacity, 0);
+    rb_define_method(cQueue, "capacity=", queue_set_capacity, 1);
+    rb_define_method(cQueue, "interrupt", queue_interrupt, 2);
+    rb_define_method(cQueue, "pop_interruptible", queue_pop_interruptible, 2);
     rb_define_method(cQueue, "size", queue_size, 0);
     rb_define_method(cQueue, "num_waiting", queue_num_waiting, 0);
     rb_define_method(cQueue, "clear", queue_clear, 0);

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);
 }