fix(regex): accept annex b control escapes

Test262 flips through zig-js:
- test/annexB/built-ins/RegExp: 5 fail/57 pass -> 0 fail/62 pass (+5)
- test/annexB: 61 fail/1025 pass -> 56 fail/1030 pass (+5)

Verification:
- zig test --dep regex -Mroot=tests/parser_compiler_edge_cases.zig -Mregex=src/root.zig --test-filter "annex b character class escapes"
- zig test --dep regex -Mroot=tests/parser_compiler_edge_cases.zig -Mregex=src/root.zig
- zig run --dep regex -Mroot=/private/tmp/zig_regex_probe.zig -Mregex=/Users/chris/Code/Libraries/zig-regex/src/root.zig
- (zig-js) zig build test262-bin
- (zig-js) ./zig-out/bin/test262 --diag test/annexB/built-ins/RegExp
- (zig-js) ./zig-out/bin/test262 --diag test/language/literals/regexp
- (zig-js) ./zig-out/bin/test262 --diag test/annexB
- git diff --check
- git diff --cached --check

Notes:
- zig build test in zig-regex was interrupted after the benchmark shard stayed silent; the focused parser/compiler file passed with explicit module wiring.
- test/language/literals/regexp still has 3 existing braced-quantifier negative failures.

Author: chrisbbreuer

src/parser.zig

@@ -137,6 +137,16 @@ pub const Lexer = struct {
         };
     }
 
+    fn literalWithPending(self: *Lexer, first: u8, rest: []const u8) Token {
+        self.pending_len = 0;
+        self.pending_pos = 0;
+        for (rest) |b| {
+            self.pending[self.pending_len] = b;
+            self.pending_len += 1;
+        }
+        return self.makeToken(.literal, first);
+    }
+
     fn parseEscape(self: *Lexer) !Token {
         // We've already consumed the backslash
         const c = self.advance() orelse return RegexError.UnexpectedEndOfPattern;
@@ -215,7 +225,10 @@ pub const Lexer = struct {
             'x' => try self.parseHexEscape(), // \xHH → one byte
             'c' => blk: {
                 // \cX control escape: the control letter's code mod 32.
-                const x = self.peek() orelse break :blk RegexError.InvalidEscapeSequence;
+                const x = self.peek() orelse {
+                    if (self.unicode_strict) break :blk RegexError.InvalidEscapeSequence;
+                    break :blk self.literalWithPending('\\', "c");
+                };
                 if (std.ascii.isAlphabetic(x)) {
                     _ = self.advance();
                     break :blk self.makeToken(.escape_char, x % 32);
@@ -225,7 +238,7 @@ pub const Lexer = struct {
                     break :blk self.makeToken(.escape_char, x % 32);
                 }
                 if (self.unicode_strict) break :blk RegexError.InvalidEscapeSequence;
-                break :blk self.makeToken(.literal, 'c'); // not a control letter: literal 'c'
+                break :blk self.literalWithPending('\\', "c"); // Annex B: invalid \c is literal "\c"
             },
             'u' => try self.parseUnicodeEscape(), // \uHHHH or \u{...} → UTF-8 byte(s)
             'p' => self.parsePropertyEscape(false),
@@ -1533,10 +1546,17 @@ pub const Parser = struct {
             .lbrace => '{',
             .rbrace => '}',
             .dollar => '$',
+            .caret => '^',
             .lbracket => '[', // Allow [ as literal (for non-POSIX cases)
             .escape_b => 0x08, // Inside a class, \b is backspace, not a word boundary.
+            .backref => blk: {
+                if (self.unicode or self.unicode_sets) break :blk null;
+                var bytes: [8]u8 = undefined;
+                const fallback = self.decimalEscapeFallbackBytes(self.current_token, &bytes);
+                break :blk if (fallback.len == 0) null else fallback[0];
+            },
             // These should not appear here
-            .rbracket, .caret, .backslash, .escape_d, .escape_D, .escape_w, .escape_W, .escape_s, .escape_S, .escape_B, .escape_A, .escape_z, .escape_Z, .backref, .escape_p, .escape_P, .eof => null,
+            .rbracket, .backslash, .escape_d, .escape_D, .escape_w, .escape_W, .escape_s, .escape_S, .escape_B, .escape_A, .escape_z, .escape_Z, .escape_p, .escape_P, .eof => null,
         };
     }
 

tests/parser_compiler_edge_cases.zig

@@ -241,6 +241,12 @@ test "parser: annex b character class escapes and shorthand ranges" {
     var outside = try Regex.compile(allocator, "\\c0");
     defer outside.deinit();
     try std.testing.expect(!try outside.isMatch("\x10"));
+    try std.testing.expect(try outside.isMatch("\\c0"));
+
+    var invalid_control = try Regex.compile(allocator, "\\c\u{0410}");
+    defer invalid_control.deinit();
+    try std.testing.expect(!try invalid_control.isMatch("c\u{0410}"));
+    try std.testing.expect(try invalid_control.isMatch("\\c\u{0410}"));
 
     var control_digit = try Regex.compile(allocator, "[\\c0]");
     defer control_digit.deinit();
@@ -250,6 +256,25 @@ test "parser: annex b character class escapes and shorthand ranges" {
     defer control_underscore.deinit();
     try std.testing.expect(try control_underscore.isMatch("\x1f"));
 
+    var invalid_control_class = try Regex.compile(allocator, "[\\c!]");
+    defer invalid_control_class.deinit();
+    try std.testing.expect(try invalid_control_class.isMatch("\\"));
+    try std.testing.expect(try invalid_control_class.isMatch("c"));
+    try std.testing.expect(try invalid_control_class.isMatch("!"));
+    try std.testing.expect(!try invalid_control_class.isMatch("\x03"));
+
+    var caret_literal = try Regex.compile(allocator, "[0-9A-Za-z_\\$(|)\\[\\]\\/\\\\^]");
+    defer caret_literal.deinit();
+    try std.testing.expect(try caret_literal.isMatch("^"));
+
+    var decimal_range = try Regex.compile(allocator, "[\\d][\\12-\\14]{1,}[^\\d]");
+    defer decimal_range.deinit();
+    if (try decimal_range.find("line1\n\n\n\n\nline2")) |match| {
+        var owned = match;
+        defer owned.deinit(allocator);
+        try std.testing.expectEqualStrings("1\n\n\n\n\nl", match.slice);
+    } else return error.TestExpectedMatch;
+
     var range_left_shorthand = try Regex.compile(allocator, "[\\d-a]+");
     defer range_left_shorthand.deinit();
     if (try range_left_shorthand.find(":a0123456789-:")) |match| {