nomen-lang 0.2.3 → 0.3.0

package/core/System/Text/Regex.nm

@@ -22,7 +22,8 @@ pub struct Regex {
 					break
 				}
 			}
-			if match_here(pattern, 0, pat_len, input, i, len) >= 0 {
+			var caps = List<int>()
+			if match_here(pattern, 0, pat_len, input, i, len, ref caps) >= 0 {
 				return true
 			}
 		}
@@ -46,7 +47,8 @@ pub struct Regex {
 					break
 				}
 			}
-			var int end = match_here(pattern, 0, pat_len, input, i, len)
+			var caps = List<int>()
+			var int end = match_here(pattern, 0, pat_len, input, i, len, ref caps)
 			if end >= 0 {
 				var int j = i
 				while j < end; j += 1 {
@@ -58,6 +60,80 @@ pub struct Regex {
 		return match_result
 	}
 
+	// Try to match pattern anywhere in input. On a match, append the whole
+	// match as group 0 followed by capture groups 1..N to `out` ("" for a
+	// group that did not participate in the match) and return true. Return
+	// false with `out` untouched when nothing matches. A group that repeats
+	// (`(a)+`) reports its LAST iteration.
+	pub func captures = (string pattern, string input, ref List<string> dst, out bool) {		var int pat_len = pattern.length
+		var int len = input.length
+		var string charset = first_byte_set(pattern, pat_len)
+		var int clen = charset.length
+		var int groups = capture_count(pattern)
+		var i = 0
+		while i <= len; i += 1 {
+			if clen > 0 && i < len {
+				i = find_next_byte(input, i, len, charset)
+				if i > len {
+					break
+				}
+			}
+			var caps = List<int>()
+			var int end = match_here(pattern, 0, pat_len, input, i, len, ref caps)
+			if end >= 0 {
+				var string whole = input.substring(i, end)
+				dst.push(whole)
+				var int g = 1
+				while g <= groups; g += 1 {
+					var int at = last_capture_index(caps, g)
+					if at >= 0 {
+						var int s = caps.at(at + 1)
+						if s >= 0 {
+							var string cap = input.substring(s, caps.at(at + 2))
+							dst.push(cap)
+						} else {
+							dst.push("")
+						}
+					} else {
+						dst.push("")
+					}
+				}
+				return true
+			}
+		}
+		return false
+	}
+
+	// Find the first match of pattern in input and fill `dst` with where it
+	// sits: .found with byte offsets .start/.end, the matched .text, and
+	// .length (all zero/empty when .found is false — mvzr-style positions
+	// for callers doing their own index bookkeeping). `dst` is fully reset
+	// first, so a reused RegexMatch carries nothing over. Scans every
+	// position: the first-byte prefilter would skip nullable patterns'
+	// empty matches at skipped positions, reporting a wrong .start.
+	pub func find = (string pattern, string input, ref RegexMatch dst) {
+		dst.found = false
+		dst.start = 0
+		dst.end = 0
+		dst.length = 0
+		dst.text = ""
+		var int pat_len = pattern.length
+		var int len = input.length
+		var i = 0
+		while i <= len; i += 1 {
+			var caps = List<int>()
+			var int end = match_here(pattern, 0, pat_len, input, i, len, ref caps)
+			if end >= 0 {
+				dst.found = true
+				dst.start = i
+				dst.end = end
+				dst.length = end - i
+				dst.text = input.substring(i, end)
+				return
+			}
+		}
+	}
+
 	// Count the number of non-overlapping occurrences of pattern in input.
 	pub func count = (string pattern, string input, out int) {
 		var int pat_len = pattern.length
@@ -73,7 +149,8 @@ pub struct Regex {
 					break
 				}
 			}
-			var int end = match_here(pattern, 0, pat_len, input, pos, len)
+			var caps = List<int>()
+			var int end = match_here(pattern, 0, pat_len, input, pos, len, ref caps)
 			if end >= 0 {
 				total += 1
 				if end == pos {
@@ -89,8 +166,7 @@ pub struct Regex {
 	}
 
 	// Replace all non-overlapping occurrences of pattern in input with replacement.
-	pub func replace_all = (string pattern, string input, string replacement, out string) {
-		var sb = StringBuilder()
+	pub func replace_all = (string pattern, string input, string replacement, out string) {		var sb = StringBuilder()
 		var int pat_len = pattern.length
 		var int len = input.length
 		var string charset = first_byte_set(pattern, pat_len)
@@ -108,7 +184,8 @@ pub struct Regex {
 					break
 				}
 			}
-			var int end = match_here(pattern, 0, pat_len, input, pos, len)
+			var caps = List<int>()
+			var int end = match_here(pattern, 0, pat_len, input, pos, len, ref caps)
 			if end >= 0 {
 				sb.append_string(replacement)
 				if end == pos {
@@ -124,6 +201,172 @@ pub struct Regex {
 		}
 		return sb.to_string()
 	}
+
+	// Whether pattern matches anywhere in input, ignoring ASCII case.
+	pub func test_ci = (string pattern, string input, out bool) {
+		var string folded = fold_pattern(pattern)
+		return Regex.test(folded, input)
+	}
+
+	// First match of pattern in input, ignoring ASCII case ("" if none).
+	pub func match_ci = (string pattern, string input, move out string) {
+		var string folded = fold_pattern(pattern)
+		return Regex.match(folded, input)
+	}
+
+	// find, ignoring ASCII case.
+	pub func find_ci = (string pattern, string input, ref RegexMatch dst) {
+		var string folded = fold_pattern(pattern)
+		Regex.find(folded, input, ref dst)
+	}
+
+	// captures, ignoring ASCII case.
+	pub func captures_ci = (string pattern, string input, ref List<string> dst, out bool) {
+		var string folded = fold_pattern(pattern)
+		return Regex.captures(folded, input, ref dst)
+	}
+
+	// replace_all, ignoring ASCII case.
+	pub func replace_all_ci = (string pattern, string input, string replacement, out string) {
+		var string folded = fold_pattern(pattern)
+		return Regex.replace_all(folded, input, replacement)
+	}
+}
+
+// Rewrite pattern so the case-sensitive engine matches case-insensitively:
+// literals become both-case classes ([kK]), class members and ranges gain
+// their case counterparts ([a-z] -> [a-zA-Z]). Structural syntax — groups,
+// alternation, quantifiers, anchors, escaped punctuation — is copied
+// through unchanged.
+func fold_pattern = (string pattern, move out string) {
+	var int n = pattern.length
+	var sb = StringBuilder()
+	var int i = 0
+	while i < n; i += 1 {
+		var char c = pattern.at(i)
+		if (c as int) == 92 {
+			// Escaped char: shorthands and backrefs keep their backslash;
+			// other escaped letters become both-case classes; escaped
+			// punctuation is copied literally.
+			if i + 1 < n {
+				var char e = pattern.at(i + 1)
+				if is_shorthand(e) || is_backref_digit(e) {
+					sb.append_char(c)
+					sb.append_char(e)
+				} else {
+					if is_alpha_byte(e) {
+						sb.append_char('[')
+						sb.append_char(e)
+						sb.append_char(swap_case_byte(e))
+						sb.append_char(']')
+					} else {
+						sb.append_char(c)
+						sb.append_char(e)
+					}
+				}
+				i += 1
+			} else {
+				sb.append_char(c)
+			}
+		} else {
+			if c == '[' {
+				var int ce = atom_end_pos(pattern, i, n)
+				fold_class(pattern, i, ce, ref sb)
+				i = ce - 1
+			} else {
+				if is_alpha_byte(c) {
+					sb.append_char('[')
+					sb.append_char(c)
+					sb.append_char(swap_case_byte(c))
+					sb.append_char(']')
+				} else {
+					sb.append_char(c)
+				}
+			}
+		}
+	}
+	return sb.to_string()
+}
+
+// fold a character class [cs..ce): copy its contents, adding the case
+// counterpart of every letter member and mirroring letter ranges.
+func fold_class = (string pattern, int cs, int ce, ref StringBuilder dst) {
+	dst.append_char('[')
+	var int i = cs + 1
+	if i < ce - 1 {
+		if pattern.at(i) == '^' {
+			dst.append_char('^')
+			i += 1
+		}
+	}
+	var int content_end = ce - 1
+	while i < content_end; i += 1 {
+		var char c = pattern.at(i)
+		if (c as int) == 92 {
+			dst.append_char(c)
+			if i + 1 < content_end {
+				var char e = pattern.at(i + 1)
+				dst.append_char(e)
+				// A shorthand keeps its backslash; other escaped letters
+				// gain their case counterpart.
+				if is_alpha_byte(e) && !is_shorthand(e) {
+					dst.append_char(swap_case_byte(e))
+				}
+				i += 1
+			}
+		} else {
+			if i + 2 < content_end {
+				if pattern.at(i + 1) == '-' {
+					var char lo = c
+					var char hi = pattern.at(i + 2)
+					dst.append_char(lo)
+					dst.append_char('-')
+					dst.append_char(hi)
+					if is_alpha_byte(lo) {
+						if is_alpha_byte(hi) {
+							dst.append_char(swap_case_byte(lo))
+							dst.append_char('-')
+							dst.append_char(swap_case_byte(hi))
+						}
+					}
+					i += 2
+				} else {
+					if is_alpha_byte(c) {
+						dst.append_char(c)
+						dst.append_char(swap_case_byte(c))
+					} else {
+						dst.append_char(c)
+					}
+				}
+			} else {
+				if is_alpha_byte(c) {
+					dst.append_char(c)
+					dst.append_char(swap_case_byte(c))
+				} else {
+					dst.append_char(c)
+				}
+			}
+		}
+	}
+	dst.append_char(']')
+}
+
+// ASCII letter test for pattern characters.
+func is_alpha_byte = (char c, out bool) {
+	var int code = c as int
+	return (code > 64 && code < 91) || (code > 96 && code < 123)
+}
+
+// The ASCII letter with the opposite case (unchanged for non-letters).
+func swap_case_byte = (char c, out char) {
+	var int code = c as int
+	if code > 64 && code < 91 {
+		return (code + 32) as char
+	}
+	if code > 96 && code < 123 {
+		return (code - 32) as char
+	}
+	return c
 }
 
 // Scan input[pos..len) for the next byte that appears in charset.
@@ -219,9 +462,21 @@ func alt_first_bytes = (string pattern, int start, int end, ref StringBuilder sb
 	while i < end {
 		var char c = pattern.at(i)
 		if (c as int) == 92 {
-			// escaped literal: first byte is the escaped char
+			// escaped literal: first byte is the escaped char — unless it's
+			// a backreference (depends on a capture) or a complement
+			// shorthand (not an inclusion set), which disable the prefilter.
 			if i + 1 < end {
-				sb.append_char(pattern.at(i + 1))
+				var char e = pattern.at(i + 1)
+				if is_backref_digit(e) {
+					return -1
+				}
+				if is_shorthand(e) {
+					if shorthand_members(e, ref sb) < 0 {
+						return -1
+					}
+					return 0
+				}
+				sb.append_char(e)
 			}
 			return 0
 		}
@@ -248,7 +503,8 @@ func alt_first_bytes = (string pattern, int start, int end, ref StringBuilder sb
 				return -1
 			}
 			// A '?'/'*' quantifier makes the group nullable — the first byte
-			// can also come from whatever follows it.
+			// can also come from whatever follows it. A second '?' marks the
+			// quantifier lazy and is skipped either way.
 			var int after = a_end
 			var int nullable = 0
 			if after < end {
@@ -256,6 +512,11 @@ func alt_first_bytes = (string pattern, int start, int end, ref StringBuilder sb
 				if q == '?' || q == '*' {
 					nullable = 1
 					after += 1
+					if after < end {
+						if pattern.at(after) == '?' {
+							after += 1
+						}
+					}
 				}
 			}
 			if nullable == 0 {
@@ -317,6 +578,8 @@ func add_class_chars = (string pattern, int start, int end, ref StringBuilder sb
 // Return contract: a successful match never reads past in_len, so the result
 // is always <= in_len (and -1 on failure). This lets callers prove an index
 // bounded by the result is also bounded by the input length.
+// `caps` collects capture spans as (group_index, start, end) triples in
+// match order; a later entry for the same group supersedes an earlier one.
 func match_here = (
 	string pattern,
 	int pat_pos,
@@ -324,6 +587,7 @@ func match_here = (
 	string input,
 	int in_pos,
 	int in_len,
+	ref List<int> caps,
 	out int: out <= in_len
 ) {
 	// Handle top-level alternation: a '|' at bracket/paren depth 0 splits the
@@ -349,11 +613,11 @@ func match_here = (
 				}
 				if (c as int) == 124 {
 					if depth == 0 {
-						var int left = match_here(pattern, pat_pos, i, input, in_pos, in_len)
+						var int left = match_here(pattern, pat_pos, i, input, in_pos, in_len, ref caps)
 						if left >= 0 {
 							return left
 						}
-						return match_here(pattern, i + 1, pat_end, input, in_pos, in_len)
+						return match_here(pattern, i + 1, pat_end, input, in_pos, in_len, ref caps)
 					}
 				}
 				i += 1
@@ -373,38 +637,48 @@ func match_here = (
 		if in_pos != 0 {
 			return -1
 		}
-		return match_here(pattern, pat_pos + 1, pat_end, input, in_pos, in_len)
+		return match_here(pattern, pat_pos + 1, pat_end, input, in_pos, in_len, ref caps)
 	}
 	if pc == '$' {
 		if in_pos != in_len {
 			return -1
 		}
-		return match_here(pattern, pat_pos + 1, pat_end, input, in_pos, in_len)
+		return match_here(pattern, pat_pos + 1, pat_end, input, in_pos, in_len, ref caps)
 	}
 
 	// Determine the bounds of the current atom.
 	var int a_end = atom_end_pos(pattern, pat_pos, pat_end)
 
-	// Check for a quantifier following the atom.
+	// Check for a quantifier following the atom. A trailing '?' marks the
+	// quantifier LAZY (shortest match first) — the rest of the pattern then
+	// starts after both symbols.
 	if a_end < pat_end {
 		var char q = pattern.at(a_end)
-		if q == '*' {
-			return match_star(pattern, pat_pos, a_end, pat_end, input, in_pos, 0, in_len)
-		}
-		if q == '+' {
-			return match_star(pattern, pat_pos, a_end, pat_end, input, in_pos, 1, in_len)
-		}
-		if q == '?' {
-			return match_optional(pattern, pat_pos, a_end, pat_end, input, in_pos, in_len)
+		if q == '*' || q == '+' || q == '?' {
+			var int lazy = 0
+			var int rest = a_end + 1
+			if rest < pat_end {
+				if pattern.at(rest) == '?' {
+					lazy = 1
+					rest += 1
+				}
+			}
+			if q == '*' {
+				return match_star(pattern, pat_pos, a_end, rest, pat_end, input, in_pos, 0, lazy, in_len, ref caps)
+			}
+			if q == '+' {
+				return match_star(pattern, pat_pos, a_end, rest, pat_end, input, in_pos, 1, lazy, in_len, ref caps)
+			}
+			return match_optional(pattern, pat_pos, a_end, rest, pat_end, input, in_pos, lazy, in_len, ref caps)
 		}
 	}
 
 	// No quantifier: match the atom once, then the rest of the pattern.
-	var int next = match_single_atom(pattern, pat_pos, a_end, input, in_pos, in_len)
+	var int next = match_single_atom(pattern, pat_pos, a_end, input, in_pos, in_len, ref caps)
 	if next < 0 {
 		return -1
 	}
-	return match_here(pattern, a_end, pat_end, input, next, in_len)
+	return match_here(pattern, a_end, pat_end, input, next, in_len, ref caps)
 }
 
 // Return the position just past the atom that starts at pat_pos. Handles
@@ -460,6 +734,7 @@ func match_single_atom = (
 	string input,
 	int in_pos,
 	int in_len,
+	ref List<int> caps,
 	out int
 ) {
 	var char pc = pattern.at(atom_start)
@@ -481,12 +756,42 @@ func match_single_atom = (
 		return -1
 	}
 	if pc == '(' {
-		// Match the group's inner content.
-		return match_here(pattern, atom_start + 1, atom_end - 1, input, in_pos, in_len)
+		// Match the group's inner content, recording the group's span on
+		// success. On failure, restore the span this path started with (a
+		// repeated group's earlier iterations survive a failed extra trial)
+		// — or mark the group unset when it had no earlier span here.
+		var int g = group_index_at(pattern, atom_start)
+		var int at = last_capture_index(caps, g)
+		var int old_start = -1
+		var int old_end = -1
+		if at >= 0 {
+			old_start = caps.at(at + 1)
+			old_end = caps.at(at + 2)
+		}
+		var int next = match_here(pattern, atom_start + 1, atom_end - 1, input, in_pos, in_len, ref caps)
+		if next >= 0 {
+			record_capture(ref caps, g, in_pos, next)
+			return next
+		}
+		record_capture(ref caps, g, old_start, old_end)
+		return -1
 	}
 	if (pc as int) == 92 {
 		if atom_start + 1 < atom_end {
 			var char ec = pattern.at(atom_start + 1)
+			if is_backref_digit(ec) {
+				// \1..\9: match the same text capture group N matched.
+				return match_backref(input, backref_group(ec), in_pos, in_len, ref caps)
+			}
+			if is_shorthand(ec) {
+				// \d \s \w and complements: class membership by name.
+				if in_pos < in_len {
+					if matches_shorthand(ec, input.at(in_pos)) {
+						return in_pos + 1
+					}
+				}
+				return -1
+			}
 			if in_pos < in_len {
 				if input.at(in_pos) == ec {
 					return in_pos + 1
@@ -527,25 +832,38 @@ func char_matches_atom = (
 	}
 	if (pc as int) == 92 {
 		if atom_start + 1 < atom_end {
-			return ic == pattern.at(atom_start + 1)
+			var char ec = pattern.at(atom_start + 1)
+			if is_backref_digit(ec) {
+				// A backreference is a multi-byte atom; the greedy
+				// single-character loop never consults this for it.
+				return false
+			}
+			if is_shorthand(ec) {
+				return matches_shorthand(ec, ic)
+			}
+			return ic == ec
 		}
 		return false
 	}
 	return pc == ic
 }
 
-// Greedily match the atom [atom_start..atom_end) followed by the rest of the
-// pattern pattern[atom_end+1..pat_end). min_count is 0 for '*' and 1 for '+'.
-// Single-character atoms are handled iteratively; groups recurse.
+// Match the atom [atom_start..atom_end) followed by the rest of the pattern
+// pattern[rest..pat_end). min_count is 0 for '*' and 1 for '+'; lazy picks
+// the shortest repetition first instead of the longest. Single-character
+// atoms are handled iteratively; groups recurse.
 func match_star = (
 	string pattern,
 	int atom_start,
 	int atom_end,
+	int rest,
 	int pat_end,
 	string input,
 	int in_pos,
 	int min_count,
+	int lazy,
 	int in_len,
+	ref List<int> caps,
 	out int
 ) {
 	var char pc = pattern.at(atom_start)
@@ -554,13 +872,36 @@ func match_star = (
 			pattern,
 			atom_start,
 			atom_end,
+			rest,
 			pat_end,
 			input,
 			in_pos,
 			min_count,
+			lazy,
 			in_len,
+			ref caps,
 		)
 	}
+	if (pc as int) == 92 {
+		if atom_start + 1 < atom_end {
+			if is_backref_digit(pattern.at(atom_start + 1)) {
+				// A backreference matches a whole span per iteration — the
+				// single-character greedy loop below can't apply.
+				return match_star_backref(
+					pattern,
+					atom_start,
+					rest,
+					pat_end,
+					input,
+					in_pos,
+					min_count,
+					lazy,
+					in_len,
+					ref caps,
+				)
+			}
+		}
+	}
 
 	// Greedily consume the longest run of matching characters.
 	var int max_pos = in_pos
@@ -571,10 +912,21 @@ func match_star = (
 			break
 		}
 	}
+	if lazy > 0 {
+		// Lazy: extend from the minimum until the rest matches.
+		var int try_pos = in_pos + min_count
+		while try_pos <= max_pos; try_pos += 1 {
+			var int r = match_here(pattern, rest, pat_end, input, try_pos, in_len, ref caps)
+			if r >= 0 {
+				return r
+			}
+		}
+		return -1
+	}
 	// Backtrack from the longest match down to the minimum, trying the rest.
 	var int try_pos = max_pos
 	while try_pos >= in_pos + min_count; try_pos -= 1 {
-		var int r = match_here(pattern, atom_end + 1, pat_end, input, try_pos, in_len)
+		var int r = match_here(pattern, rest, pat_end, input, try_pos, in_len, ref caps)
 		if r >= 0 {
 			return r
 		}
@@ -582,20 +934,56 @@ func match_star = (
 	return -1
 }
 
-// Recursive greedy backtracking for group atoms quantified with '*' or '+'.
+// Recursive backtracking for group atoms quantified with '*' or '+'.
 func match_star_group = (
 	string pattern,
 	int atom_start,
 	int atom_end,
+	int rest,
 	int pat_end,
 	string input,
 	int in_pos,
 	int min_count,
+	int lazy,
 	int in_len,
+	ref List<int> caps,
 	out int
 ) {
+	if lazy > 0 {
+		// Lazy: stop repeating first (minimum met), then try one more
+		// iteration before giving up.
+		if min_count <= 0 {
+			var int stop = match_here(pattern, rest, pat_end, input, in_pos, in_len, ref caps)
+			if stop >= 0 {
+				return stop
+			}
+		}
+		var int next = match_single_atom(pattern, atom_start, atom_end, input, in_pos, in_len, ref caps)
+		if next >= 0 {
+			if next != in_pos {
+				var new_min = 0
+				if min_count > 0 {
+					new_min = min_count - 1
+				}
+				return match_star_group(
+					pattern,
+					atom_start,
+					atom_end,
+					rest,
+					pat_end,
+					input,
+					next,
+					new_min,
+					lazy,
+					in_len,
+					ref caps,
+				)
+			}
+		}
+		return -1
+	}
 	// Try matching the group one more time (greedy).
-	var int next = match_single_atom(pattern, atom_start, atom_end, input, in_pos, in_len)
+	var int next = match_single_atom(pattern, atom_start, atom_end, input, in_pos, in_len, ref caps)
 	if next >= 0 {
 		if next != in_pos {
 			var new_min = 0
@@ -606,11 +994,14 @@ func match_star_group = (
 				pattern,
 				atom_start,
 				atom_end,
+				rest,
 				pat_end,
 				input,
 				next,
 				new_min,
+				lazy,
 				in_len,
+				ref caps,
 			)
 			if r >= 0 {
 				return r
@@ -619,30 +1010,45 @@ func match_star_group = (
 	}
 	// Stop repeating and try the rest of the pattern, if the minimum is met.
 	if min_count <= 0 {
-		return match_here(pattern, atom_end + 1, pat_end, input, in_pos, in_len)
+		return match_here(pattern, rest, pat_end, input, in_pos, in_len, ref caps)
 	}
 	return -1
 }
 
-// Match the atom optionally ('?'), preferring to include it.
+// Match the atom optionally ('?'), preferring to include it unless lazy.
 func match_optional = (
 	string pattern,
 	int atom_start,
 	int atom_end,
+	int rest,
 	int pat_end,
 	string input,
 	int in_pos,
+	int lazy,
 	int in_len,
+	ref List<int> caps,
 	out int
 ) {
-	var int next = match_single_atom(pattern, atom_start, atom_end, input, in_pos, in_len)
+	if lazy > 0 {
+		// Lazy: try without the atom first.
+		var int skip = match_here(pattern, rest, pat_end, input, in_pos, in_len, ref caps)
+		if skip >= 0 {
+			return skip
+		}
+		var int next = match_single_atom(pattern, atom_start, atom_end, input, in_pos, in_len, ref caps)
+		if next >= 0 {
+			return match_here(pattern, rest, pat_end, input, next, in_len, ref caps)
+		}
+		return -1
+	}
+	var int next = match_single_atom(pattern, atom_start, atom_end, input, in_pos, in_len, ref caps)
 	if next >= 0 {
-		var int r = match_here(pattern, atom_end + 1, pat_end, input, next, in_len)
+		var int r = match_here(pattern, rest, pat_end, input, next, in_len, ref caps)
 		if r >= 0 {
 			return r
 		}
 	}
-	return match_here(pattern, atom_end + 1, pat_end, input, in_pos, in_len)
+	return match_here(pattern, rest, pat_end, input, in_pos, in_len, ref caps)
 }
 
 // Report whether input.at(in_pos) belongs to the character class whose '[' is
@@ -677,8 +1083,16 @@ func char_in_class = (
 		var char c = pattern.at(i)
 		if (c as int) == 92 {
 			if i + 1 < content_end {
-				if ic == pattern.at(i + 1) {
-					found = true
+				var char e = pattern.at(i + 1)
+				if is_shorthand(e) {
+					// \d \s \w (and complements) inside a class.
+					if matches_shorthand(e, ic) {
+						found = true
+					}
+				} else {
+					if ic == e {
+						found = true
+					}
 				}
 			}
 			i = i + 2
@@ -716,3 +1130,275 @@ func char_in_class = (
 	}
 	return found
 }
+
+// The number of capture groups in the whole pattern: every '(' that is not
+// escaped and not inside a character class (POSIX ERE has no non-capturing
+// groups).
+func capture_count = (string pattern, out int) {
+	var int n = pattern.length
+	var int count = 0
+	var int i = 0
+	while i < n; i += 1 {
+		var char c = pattern.at(i)
+		if (c as int) == 92 {
+			i += 1
+		} else {
+			if c == '[' {
+				i = atom_end_pos(pattern, i, n) - 1
+			} else {
+				if c == '(' {
+					count += 1
+				}
+			}
+		}
+	}
+	return count
+}
+
+// The capture-group index (1-based) of the group whose '(' opens at
+// open_pos: one more than the number of capture opens before it in the
+// pattern (the whole match is group 0).
+func group_index_at = (string pattern, int open_pos, out int) {
+	var int count = 0
+	var int i = 0
+	while i < open_pos; i += 1 {
+		var char c = pattern.at(i)
+		if (c as int) == 92 {
+			i += 1
+		} else {
+			if c == '[' {
+				i = atom_end_pos(pattern, i, open_pos) - 1
+			} else {
+				if c == '(' {
+					count += 1
+				}
+			}
+		}
+	}
+	return count + 1
+}
+
+// Record a capture span (start, end) for the group whose '(' opens at
+// group_pos. A later span for the same group supersedes the earlier one, so
+// a repeated group reports its last iteration; a failed group records
+// (-1, -1) so stale spans from an abandoned attempt never surface.
+func record_capture = (ref List<int> caps, int group, int start, int end) {
+	var int at = last_capture_index(caps, group)
+	if at >= 0 {
+		caps.set(at + 1, start)
+		caps.set(at + 2, end)
+	} else {
+		caps.push(group)
+		caps.push(start)
+		caps.push(end)
+	}
+}
+
+// The log index of the LAST entry for `group` in caps, or -1 when the group
+// has no entry. Entries are (group, start, end) triples.
+func last_capture_index = (List<int> caps, int group, out int) {
+	var int best = -1
+	var int i = 0
+	while i < caps.length; i += 3 {
+		if caps.at(i) == group {
+			best = i
+		}
+	}
+	return best
+}
+
+/**
+ * A Regex.find result: whether the pattern matched, where, and what
+ **/
+pub struct RegexMatch {
+	var bool found = false
+	var int start = 0
+	var int end = 0
+	var int length = 0
+	var string text = ""
+}
+
+// Whether the escaped character c (the byte after a backslash) is a
+// backreference (\1..\9; \0 is the whole-match escape, not supported here).
+func is_backref_digit = (char c, out bool) {
+	var int code = c as int
+	return code >= 49 && code <= 57
+}
+
+// The capture group a backreference refers to: '1' -> 1 .. '9' -> 9.
+func backref_group = (char c, out int) {
+	return (c as int) - 48
+}
+
+// Match the text capture group `group` last matched, at in_pos. Returns the
+// position after the span, or -1 when the group has no span here (it did not
+// participate) or the text differs.
+func match_backref = (string input, int group, int in_pos, int in_len, ref List<int> caps, out int) {
+	var int at = last_capture_index(caps, group)
+	if at < 0 {
+		return -1
+	}
+	var int s = caps.at(at + 1)
+	if s < 0 {
+		return -1
+	}
+	var int len = caps.at(at + 2) - s
+	if in_pos + len > in_len {
+		return -1
+	}
+	var int i = 0
+	while i < len; i += 1 {
+		if input.at(in_pos + i) != input.at(s + i) {
+			return -1
+		}
+	}
+	return in_pos + len
+}
+
+// Greedy/lazy backtracking for a backreference atom quantified with '*' or
+// '+' (each iteration consumes the referenced span).
+func match_star_backref = (
+	string pattern,
+	int atom_start,
+	int rest,
+	int pat_end,
+	string input,
+	int in_pos,
+	int min_count,
+	int lazy,
+	int in_len,
+	ref List<int> caps,
+	out int
+) {
+	var int group = backref_group(pattern.at(atom_start + 1))
+	if lazy > 0 {
+		if min_count <= 0 {
+			var int stop = match_here(pattern, rest, pat_end, input, in_pos, in_len, ref caps)
+			if stop >= 0 {
+				return stop
+			}
+		}
+		var int next = match_backref(input, group, in_pos, in_len, ref caps)
+		if next >= 0 {
+			if next != in_pos {
+				var new_min = 0
+				if min_count > 0 {
+					new_min = min_count - 1
+				}
+				return match_star_backref(
+					pattern,
+					atom_start,
+					rest,
+					pat_end,
+					input,
+					next,
+					new_min,
+					lazy,
+					in_len,
+					ref caps,
+				)
+			}
+		}
+		return -1
+	}
+	var int next = match_backref(input, group, in_pos, in_len, ref caps)
+	if next >= 0 {
+		if next != in_pos {
+			var new_min = 0
+			if min_count > 0 {
+				new_min = min_count - 1
+			}
+			var int r = match_star_backref(
+				pattern,
+				atom_start,
+				rest,
+				pat_end,
+				input,
+				next,
+				new_min,
+				lazy,
+				in_len,
+				ref caps,
+			)
+			if r >= 0 {
+				return r
+			}
+		}
+	}
+	if min_count <= 0 {
+		return match_here(pattern, rest, pat_end, input, in_pos, in_len, ref caps)
+	}
+	return -1
+}
+
+// Whether the escaped character c names an ASCII shorthand class:
+// \d \D (digits), \w \W (word characters), \s \S (whitespace).
+func is_shorthand = (char c, out bool) {
+	var int code = c as int
+	return code == 100 || code == 68 || code == 119 || code == 87 || code == 115 || code == 83
+}
+
+// Whether byte b belongs to the shorthand class named by c. Uppercase names
+// are the complements (S/D/W match anything the lowercase set excludes).
+func matches_shorthand = (char c, char b, out bool) {
+	var int kind = c as int
+	var int code = b as int
+	var found = false
+	if kind == 100 || kind == 68 {
+		// \d \D
+		found = code >= 48 && code <= 57
+	} else {
+		if kind == 119 || kind == 87 {
+			// \w \W
+			found = (code >= 97 && code <= 122) || (code >= 65 && code <= 90) || (code >= 48 && code <= 57) || code == 95
+		} else {
+			// \s \S
+			found = (code >= 9 && code <= 13) || code == 32
+		}
+	}
+	if kind >= 65 && kind <= 90 {
+		return !found
+	}
+	return found
+}
+
+// Append the member bytes of the lowercase shorthand class named by c to the
+// first-byte charset. Complement shorthands (S/D/W) match "anything else" —
+// not expressible as an inclusion set — so they return -1, which disables
+// the caller's prefilter.
+func shorthand_members = (char c, ref StringBuilder sb, out int) {
+	var int kind = c as int
+	if kind == 83 || kind == 68 || kind == 87 {
+		return -1
+	}
+	if kind == 100 {
+		var int code = 48
+		while code <= 57; code += 1 {
+			sb.append_char(code as char)
+		}
+		return 0
+	}
+	if kind == 119 {
+		var int code = 48
+		while code <= 57; code += 1 {
+			sb.append_char(code as char)
+		}
+		var int upper = 65
+		while upper <= 90; upper += 1 {
+			sb.append_char(upper as char)
+		}
+		var int lower = 97
+		while lower <= 122; lower += 1 {
+			sb.append_char(lower as char)
+		}
+		sb.append_char('_')
+		return 0
+	}
+	// \s: tab, LF, VT, FF, CR, space
+	var int w = 9
+	while w <= 13; w += 1 {
+		sb.append_char(w as char)
+	}
+	sb.append_char(32 as char)
+	return 0
+}