From 034a64346c0a902bd0510e4e205dce3bdd61eead Mon Sep 17 00:00:00 2001
From: "Yukihiro \"Matz\" Matsumoto" <matz@ruby.or.jp>
Date: Mon, 23 Mar 2026 11:00:00 +0900
Subject: [PATCH] mruby-regexp: add literal pattern fast path bypassing NFA

Pure literal patterns (/hello/, /abc/) are detected at compile
time and matched using memchr+memcmp directly, completely
bypassing Pike VM setup (no malloc, no visited array, no thread
lists). Engine-only time drops from ~400ns to ~80ns.

Co-authored-by: Claude <noreply@anthropic.com>
---
 mrbgems/mruby-regexp/include/re_internal.h |  1 +
 mrbgems/mruby-regexp/src/re_compile.c      | 16 ++++++++++++
 mrbgems/mruby-regexp/src/re_exec.c         | 29 ++++++++++++++++++++++
 3 files changed, 46 insertions(+)

diff --git a/mrbgems/mruby-regexp/include/re_internal.h b/mrbgems/mruby-regexp/include/re_internal.h
index af81f108e..9a3f8b585 100644
--- a/mrbgems/mruby-regexp/include/re_internal.h
+++ b/mrbgems/mruby-regexp/include/re_internal.h
@@ -74,6 +74,7 @@ typedef struct mrb_regexp_pattern {
   uint8_t prefix_len;      /* length of prefix (0 = no prefix) */
   uint8_t first_bytes[16]; /* bitmap of possible first bytes (128-bit, ASCII) */
   mrb_bool has_first_bytes; /* true if first_bytes is usable for skipping */
+  mrb_bool is_literal;     /* true if pattern is pure literal (no metacharacters) */
 } mrb_regexp_pattern;
 
 /* Regexp flags */
diff --git a/mrbgems/mruby-regexp/src/re_compile.c b/mrbgems/mruby-regexp/src/re_compile.c
index 79d01aacb..b3ae2d3b6 100644
--- a/mrbgems/mruby-regexp/src/re_compile.c
+++ b/mrbgems/mruby-regexp/src/re_compile.c
@@ -875,6 +875,22 @@ re_compile(mrb_state *mrb, const char *pattern, mrb_int len, uint32_t flags)
     }
   }
 
+  /* Check if pattern is pure literal: SAVE CHAR* SAVE MATCH only.
+     prefix_len already holds the literal char count if so. */
+  pat->is_literal = FALSE;
+  if (pat->prefix_len > 0 && pat->num_captures == 1 &&
+      !pat->has_backref && !pat->needs_backtrack) {
+    /* bytecode should be: SAVE(0), CHAR*N, SAVE(1), MATCH
+       = 2 + prefix_len + 2 = prefix_len + 2 instructions
+       (SAVE(0) at 0, CHARs at 1..N, SAVE(1) at N+1, MATCH at N+2) */
+    if (pat->code_len == (uint32_t)(pat->prefix_len + 3) &&
+        pat->code[0].op == RE_SAVE &&
+        pat->code[pat->code_len - 2].op == RE_SAVE &&
+        pat->code[pat->code_len - 1].op == RE_MATCH) {
+      pat->is_literal = TRUE;
+    }
+  }
+
   /* Compute first-byte bitmap: set of bytes that could start a match.
      Used when prefix is empty (e.g. alternation, character class patterns). */
   {
diff --git a/mrbgems/mruby-regexp/src/re_exec.c b/mrbgems/mruby-regexp/src/re_exec.c
index 662ad67a1..f6448e69f 100644
--- a/mrbgems/mruby-regexp/src/re_exec.c
+++ b/mrbgems/mruby-regexp/src/re_exec.c
@@ -565,12 +565,41 @@ backtrack_exec(mrb_state *mrb, const mrb_regexp_pattern *pat,
   return 0;
 }
 
+/* Fast path for pure literal patterns: use memchr+memcmp, no NFA needed */
+static int
+literal_exec(const mrb_regexp_pattern *pat,
+             const char *str, mrb_int len, mrb_int start,
+             int *captures, int captures_size)
+{
+  const char *sp = str + start;
+  const char *str_end = str + len;
+  int plen = pat->prefix_len;
+
+  while (sp + plen <= str_end) {
+    const char *found = (const char*)memchr(sp, pat->prefix[0], str_end - sp);
+    if (!found || found + plen > str_end) return 0;
+    if (plen == 1 || memcmp(found + 1, pat->prefix + 1, plen - 1) == 0) {
+      /* match found */
+      if (captures && captures_size >= 2) {
+        captures[0] = (int)(found - str);
+        captures[1] = (int)(found - str) + plen;
+      }
+      return 2;  /* group 0 start/end */
+    }
+    sp = found + 1;
+  }
+  return 0;
+}
+
 /* Public entry point */
 int
 re_exec(mrb_state *mrb, const mrb_regexp_pattern *pat,
         const char *str, mrb_int len, mrb_int start,
         int *captures, int captures_size)
 {
+  if (pat->is_literal) {
+    return literal_exec(pat, str, len, start, captures, captures_size);
+  }
   if (pat->has_backref || pat->needs_backtrack) {
     return backtrack_exec(mrb, pat, str, len, start, captures, captures_size);
   }