mruby · matz · Aug 20, 2026 · Aug 19, 2026 · Aug 19, 2026 · Aug 19, 2026
@@ -46,3 +46,8 @@ MRC_SYM_2(defined_gvar_q,   __defined_gvar?,   44)
 MRC_SYM_2(defined_cvar_q,   __defined_cvar?,   45)
 MRC_SYM_2(defined_super_q,  __defined_super?,  46)
 MRC_SYM_2(defined_const_path_q, __defined_const_path?, 47)
+MRC_SYM_2(last_match, $~, 48)
+MRC_SYM_1(__pre_match,  49)
+MRC_SYM_1(__post_match, 50)
+MRC_SYM_1(__last_group, 51)
+MRC_SYM_1(__group,      52)
@@ -3888,6 +3888,42 @@ gen_binary_operator(mrc_codegen_scope *s, mrc_sym binary_operator)
   }
 }
 
+/* `$&`, `` $` ``, `$'`, `$+` and `$1` onward are not globals of their own but
+   readings of `$~`, the way CRuby's `getspecial` derives each from the
+   backref when it is read, so they compile to a read of `$~` and, where it is
+   not nil, a send on it: `__group` with `n` for `$&` (0) and `$n`,
+   `__pre_match` for `` $` ``, `__post_match` for `$'` and `__last_group`
+   for `$+`. All five are private readings of the match rather than the
+   methods that read the same things in Ruby (`[]`, `pre_match` and
+   `post_match`), so that redefining those moves `$~[n]`, `$~.pre_match`
+   and `$~.post_match` and leaves these names alone, the way CRuby's
+   `rb_reg_nth_match` and the like are past reach. Where `$~` is nil,
+   which it is without mruby-regexp, the name reads as nil, as an unset
+   global does. A negative `n` is no argument. */
+static void
+gen_match_ref(mrc_codegen_scope *s, mrc_sym meth, mrc_int n)
+{
+  uint32_t skip;
+
+  genop_2(s, OP_GETGV, cursp(), new_sym(s, MRC_SYM_2(last_match)));
+  skip = genjmp2_0(s, OP_JMPNIL, cursp(), VAL);
+  push();                       /* $~ is the receiver */
+  if (n >= 0) {
+    gen_int(s, cursp(), n);
+    push();
+  }
+  push(); pop();                /* space for a block */
+  pop_n(n >= 0 ? 2 : 1);
+  if (n >= 0) {
+    genop_3(s, OP_SEND, cursp(), new_sym(s, meth), 1);
+  }
+  else {
+    genop_2(s, OP_SEND0, cursp(), new_sym(s, meth));
+  }
+  dispatch(s, skip);
+  push();
+}
+
 static void
 regex_set_flags(pm_node_flags_t flags, char *p2, char *p3)
 {
@@ -4905,25 +4941,31 @@ codegen(mrc_codegen_scope *s, mrc_node *tree, int val)
     {
       if (val) {
         CAST(back_reference_read);
-        int sym = new_sym(s, cast->name);
-        genop_2(s, OP_GETGV, cursp(), sym);
-        push();
+        pm_constant_t *c = pm_constant_pool_id_to_constant(&s->c->p->constant_pool, cast->name);
+        /* `$&`, `` $` ``, `$'` and `$+`; the parser admits no other name here */
+        switch (c->start[1]) {
+        case '&':  gen_match_ref(s, MRC_SYM_1(__group), 0); break;
+        case '`':  gen_match_ref(s, MRC_SYM_1(__pre_match), -1); break;
+        case '\'': gen_match_ref(s, MRC_SYM_1(__post_match), -1); break;
+        default:   gen_match_ref(s, MRC_SYM_1(__last_group), -1); break;
+        }
       }
       break;
     }
     case PM_NUMBERED_REFERENCE_READ_NODE:
     {
       if (val) {
         CAST(numbered_reference_read);
-        char buf[16];
-        buf[0] = '$';
-        int n = snprintf(buf + 1, sizeof(buf) - 1, "%u", (unsigned int)cast->number);
-        size_t len = (size_t)(1 + n);  // leading '$' + digits
-        uint8_t *name = (uint8_t *)mrc_malloc(s->c, len);
-        memcpy(name, buf, len);
-        int sym = new_sym(s, pm_constant_pool_insert_owned(&s->c->p->constant_pool, name, len));
-        genop_2(s, OP_GETGV, cursp(), sym);
-        push();
+        /* The parser hands a number too large for its field over as 0, and
+           no match has a group that large either way, so the name reads as
+           nil without asking; CRuby warns and answers nil. */
+        if (cast->number == 0 || cast->number > INT32_MAX) {
+          genop_1(s, OP_LOADNIL, cursp());
+          push();
+        }
+        else {
+          gen_match_ref(s, MRC_SYM_1(__group), (mrc_int)cast->number);
+        }
       }
       break;
     }

@@ -158,6 +158,8 @@ sym[re]                           # => matched substring or nil
 
 # Global variables
 $~                                # last MatchData
+$&, $`, $', $+, $1, $2, ...       # read from $~ at the moment they are read
+                                  #    (all nil while $~ is nil)
 ```
 
 ## Engine Architecture

@@ -41,6 +41,16 @@ MRuby::Gem::Specification.new('mruby-regexp') do |spec|
     spec.add_dependency 'mruby-symbol-ext', :core => 'mruby-symbol-ext'
   end
 
+  # Same deal for taking a method back off a class. The test that pins `$&`
+  # and `$1` reading the match rather than `MatchData#[]` redefines `[]` and
+  # parks the original under another name, and dropping that name afterwards
+  # is `remove_method`, which mruby-metaprog owns. Where the build has none
+  # the test leaves the parked name behind, which costs the tests after it
+  # nothing.
+  if build.gems.any? {|g| g.name == 'mruby-metaprog'}
+    spec.add_test_dependency 'mruby-metaprog', :core => 'mruby-metaprog'
+  end
+
   # The unicode_* and ascii_* test files assert opposite things about the
   # same patterns (one that /i folds them, the other that /i refuses to
   # compile them; one that [[:alpha:]] holds a letter above ASCII, the other

@@ -163,44 +163,26 @@ regexp_init(mrb_state *mrb, mrb_value self)
    word after the `$`, which `~` is not, so this one is looked up once here. */
 static mrb_sym match_sym;
 
-/* Pre-interned symbols for $1-$9 (cached on first use) */
-static mrb_sym nth_syms[9];
-
-/* Pre-interned symbols for $&, $`, $' and $+ (cached on first use) */
-enum { LAST_MATCH, PRE_MATCH, POST_MATCH, LAST_PAREN, LAST_SYM_COUNT };
-static mrb_sym last_match_syms[LAST_SYM_COUNT];
+static mrb_sym
+ensure_match_sym(mrb_state *mrb)
+{
+  if (!match_sym) match_sym = mrb_intern_lit(mrb, "$~");
+  return match_sym;
+}
 
+/* $~ is the one name a match publishes. `$&`, `` $` ``, `$'`, `$+` and `$1`
+   onward are readings of it that the compiler derives when they are read,
+   so publishing and clearing are each one write of `$~`. */
 static void
-ensure_match_syms(mrb_state *mrb)
-{
-  if (nth_syms[0]) return;
-  match_sym = mrb_intern_lit(mrb, "$~");
-  nth_syms[0] = mrb_intern_lit(mrb, "$1");
-  nth_syms[1] = mrb_intern_lit(mrb, "$2");
-  nth_syms[2] = mrb_intern_lit(mrb, "$3");
-  nth_syms[3] = mrb_intern_lit(mrb, "$4");
-  nth_syms[4] = mrb_intern_lit(mrb, "$5");
-  nth_syms[5] = mrb_intern_lit(mrb, "$6");
-  nth_syms[6] = mrb_intern_lit(mrb, "$7");
-  nth_syms[7] = mrb_intern_lit(mrb, "$8");
-  nth_syms[8] = mrb_intern_lit(mrb, "$9");
-  last_match_syms[LAST_MATCH] = mrb_intern_lit(mrb, "$&");
-  last_match_syms[PRE_MATCH] = mrb_intern_lit(mrb, "$`");
-  last_match_syms[POST_MATCH] = mrb_intern_lit(mrb, "$'");
-  last_match_syms[LAST_PAREN] = mrb_intern_lit(mrb, "$+");
+set_match_globals(mrb_state *mrb, mrb_value obj)
+{
+  mrb_gv_set(mrb, ensure_match_sym(mrb), obj);
 }
 
 static void
 clear_match_globals(mrb_state *mrb)
 {
-  ensure_match_syms(mrb);
-  mrb_gv_set(mrb, match_sym, mrb_nil_value());
-  for (int i = 0; i < 9; i++) {
-    mrb_gv_set(mrb, nth_syms[i], mrb_nil_value());
-  }
-  for (int i = 0; i < LAST_SYM_COUNT; i++) {
-    mrb_gv_set(mrb, last_match_syms[i], mrb_nil_value());
-  }
+  set_match_globals(mrb, mrb_nil_value());
 }
 
 /* Byte-based substring extraction. The regexp engine records all capture
@@ -349,46 +331,6 @@ regexp_check_byte_pos(mrb_state *mrb, mrb_value self)
   return mrb_nil_value();
 }
 
-/* Publish `obj` and the thirteen names derived from its offsets, the
-   counterpart of clear_match_globals(). Kept apart from create_matchdata() so
-   that an existing MatchData can be republished without rebuilding it. */
-static void
-set_match_globals(mrb_state *mrb, mrb_value obj, mrb_value str, int *captures, int num_captures)
-{
-  ensure_match_syms(mrb);
-
-  mrb_gv_set(mrb, match_sym, obj);
-
-  /* set $1-$9 from captures */
-  for (int i = 0; i < 9; i++) {
-    mrb_value val = mrb_nil_value();
-    int g = i + 1;
-    if (g < num_captures && captures[g*2] >= 0) {
-      val = re_byte_substr(mrb, str, captures[g*2], captures[g*2+1] - captures[g*2]);
-    }
-    mrb_gv_set(mrb, nth_syms[i], val);
-  }
-
-  /* set $&, $` and $' from the whole-match offsets */
-  mrb_gv_set(mrb, last_match_syms[LAST_MATCH],
-             re_byte_substr(mrb, str, captures[0], captures[1] - captures[0]));
-  mrb_gv_set(mrb, last_match_syms[PRE_MATCH],
-             re_byte_substr(mrb, str, 0, captures[0]));
-  mrb_gv_set(mrb, last_match_syms[POST_MATCH],
-             re_byte_substr(mrb, str, captures[1], RSTRING_LEN(str) - captures[1]));
-
-  /* set $+ from the last group that actually participated, which is not
-     necessarily the last group in the pattern */
-  mrb_value last_paren = mrb_nil_value();
-  for (int g = num_captures - 1; g >= 1; g--) {
-    if (captures[g*2] >= 0) {
-      last_paren = re_byte_substr(mrb, str, captures[g*2], captures[g*2+1] - captures[g*2]);
-      break;
-    }
-  }
-  mrb_gv_set(mrb, last_match_syms[LAST_PAREN], last_paren);
-}
-
 /* Create MatchData from captures, and make it the match the globals
    describe. */
 static mrb_value
@@ -413,7 +355,7 @@ create_matchdata(mrb_state *mrb, mrb_value regexp, mrb_value str, int *captures,
   mrb_iv_set(mrb, obj, MRB_SYM(source), str);
   mrb_iv_set(mrb, obj, MRB_SYM(regexp), regexp);
 
-  set_match_globals(mrb, obj, str, captures, md->num_captures);
+  set_match_globals(mrb, obj);
 
   return obj;
 }
@@ -429,7 +371,7 @@ match_operand(mrb_state *mrb, mrb_value obj)
 
 /* Internal: execute match and create MatchData.
    Returns MatchData on match, nil on no match.
-   Sets $~ and $1-$9 globals, and clears them on a miss. */
+   Publishes the match as $~, and clears it on a miss. */
 static mrb_value
 exec_match(mrb_state *mrb, mrb_value self, mrb_value str, mrb_int pos)
 {
@@ -1146,9 +1088,8 @@ re_subject_reads_as(mrb_state *mrb, mrb_value str, mrb_value mdv)
    a search from the offset its last match was found from, on the receiver as
    the block left it, the way `rb_str_scan` does; `re_subject_reads_as()`
    above is the test that spares that search, and this is it asked from
-   mrblib. The names other than $~ are not assignable from Ruby, so publishing
-   them again has to come from here. Returns false where `str` reads
-   differently, and the caller searches. */
+   mrblib, with the publish folded in so that the loop asks once. Returns
+   false where `str` reads differently, and the caller searches. */
 static mrb_value
 matchdata_republish(mrb_state *mrb, mrb_value self)
 {
@@ -1157,12 +1098,15 @@ matchdata_republish(mrb_state *mrb, mrb_value self)
   mrb_match_data *md = DATA_GET_PTR(mrb, self, &matchdata_type, mrb_match_data);
   if (!md) return mrb_false_value();
   if (!re_subject_reads_as(mrb, str, self)) return mrb_false_value();
-  set_match_globals(mrb, self, md->source, md->captures, md->num_captures);
+  set_match_globals(mrb, self);
   return mrb_true_value();
 }
 
 /*
- * MatchData#pre_match / #post_match
+ * MatchData#pre_match / #post_match, which `` $` `` and `$'` also read
+ * under the private names `__pre_match` and `__post_match`, so that a
+ * program redefining the public pair moves `$~.pre_match` and
+ * `$~.post_match` and leaves the two globals alone.
  */
 static mrb_value
 matchdata_pre(mrb_state *mrb, mrb_value self)
@@ -1181,6 +1125,41 @@ matchdata_post(mrb_state *mrb, mrb_value self)
   return re_byte_substr(mrb, md->source, pos, RSTRING_LEN(md->source) - pos);
 }
 
+/* Private: what `$&` and `$1` onward read, the group of that number, the
+   whole match at 0. The compiler derives them from `$~` with this and not
+   with `[]`, so that a program redefining `[]` moves `$~[n]` and leaves the
+   names alone, as it does in CRuby, where they come from the backref. `n`
+   arrives from the compiler and is never a name; a negative one, which only
+   a direct call can pass, reads as no group rather than counting back. */
+static mrb_value
+matchdata_group(mrb_state *mrb, mrb_value self)
+{
+  mrb_int n;
+  mrb_get_args(mrb, "i", &n);
+  mrb_match_data *md = DATA_GET_PTR(mrb, self, &matchdata_type, mrb_match_data);
+  if (!md || n < 0 || n >= md->num_captures) return mrb_nil_value();
+  int s = md->captures[n*2];
+  if (s < 0) return mrb_nil_value();
+  return re_byte_substr(mrb, md->source, s, md->captures[n*2+1] - s);
+}
+
+/* Private: what `$+` reads, the last group that took part in the match,
+   which is not necessarily the last group in the pattern. The compiler
+   derives `$+` from `$~` with this, as it derives `$1` with `__group`. */
+static mrb_value
+matchdata_last_group(mrb_state *mrb, mrb_value self)
+{
+  mrb_match_data *md = DATA_GET_PTR(mrb, self, &matchdata_type, mrb_match_data);
+  if (!md) return mrb_nil_value();
+  for (int g = md->num_captures - 1; g >= 1; g--) {
+    int s = md->captures[g*2];
+    if (s >= 0) {
+      return re_byte_substr(mrb, md->source, s, md->captures[g*2+1] - s);
+    }
+  }
+  return mrb_nil_value();
+}
+
 /*
  * MatchData#length / #size
  */
@@ -1894,8 +1873,7 @@ regexp_s_gsub_block(mrb_state *mrb, mrb_value klass)
     clear_match_globals(mrb);
   }
   else if (re_subject_reads_as(mrb, str, last_md)) {
-    mrb_match_data *md = DATA_GET_PTR(mrb, last_md, &matchdata_type, mrb_match_data);
-    set_match_globals(mrb, last_md, md->source, md->captures, md->num_captures);
+    set_match_globals(mrb, last_md);
   }
   else {
     /* The closing search of `str_gsub`, on the receiver as the block left it,
@@ -2241,6 +2219,10 @@ mrb_mruby_regexp_gem_init(mrb_state *mrb)
   mrb_define_method(mrb, md, "__republish", matchdata_republish, MRB_ARGS_REQ(1));
   mrb_define_method(mrb, md, "pre_match", matchdata_pre, MRB_ARGS_NONE());
   mrb_define_method(mrb, md, "post_match", matchdata_post, MRB_ARGS_NONE());
+  mrb_define_method(mrb, md, "__pre_match", matchdata_pre, MRB_ARGS_NONE());
+  mrb_define_method(mrb, md, "__post_match", matchdata_post, MRB_ARGS_NONE());
+  mrb_define_method(mrb, md, "__group", matchdata_group, MRB_ARGS_REQ(1));
+  mrb_define_method(mrb, md, "__last_group", matchdata_last_group, MRB_ARGS_NONE());
   mrb_define_method(mrb, md, "named_captures", matchdata_named_captures, MRB_ARGS_NONE());
   mrb_define_method(mrb, md, "string", matchdata_string, MRB_ARGS_NONE());
   mrb_define_method(mrb, md, "regexp", matchdata_regexp, MRB_ARGS_NONE());