nomen-lang 0.0.7 → 0.0.8

package/core/System/Text/Regex.nm

@@ -0,0 +1,655 @@
+// Regular expression support implemented in pure Nomen.
+//
+// `test` reports whether a pattern matches anywhere in the input; `match`
+// returns the first matched substring (or "" when there is no match).
+// Patterns use POSIX Extended Regular Expression syntax.
+
+/**
+ * Regular-expression helpers (`test`/`match`/`count`/`replace_all`) using POSIX ERE syntax
+ **/
+pub struct Regex {
+	// Test whether pattern matches anywhere in input.
+	pub func test = (string pattern, string input, 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 i = 0
+		while i <= len; i += 1 {
+			if clen > 0 && i < len {
+				i = find_next_byte(input, i, len, charset)
+				if i > len {
+					break
+				}
+			}
+			if match_here(pattern, 0, pat_len, input, i, len) >= 0 {
+				return true
+			}
+		}
+		return false
+	}
+
+	// Return the first substring of input matching pattern, or "" if none.
+	pub func match = (string pattern, string input, out string) {
+		var match_result = ""
+		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 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 int end = match_here(pattern, 0, pat_len, input, i, len)
+			if end >= 0 {
+				var int j = i
+				while j < end; j += 1 {
+					match_result = match_result + "\{input.at(j)}"
+				}
+				break
+			}
+		}
+		return match_result
+	}
+
+	// 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
+		var int len = input.length
+		var string charset = first_byte_set(pattern, pat_len)
+		var int clen = charset.length
+		var total = 0
+		var pos = 0
+		while pos < len {
+			if clen > 0 {
+				pos = find_next_byte(input, pos, len, charset)
+				if pos >= len {
+					break
+				}
+			}
+			var int end = match_here(pattern, 0, pat_len, input, pos, len)
+			if end >= 0 {
+				total += 1
+				if end == pos {
+					pos += 1
+				} else {
+					pos = end
+				}
+			} else {
+				pos += 1
+			}
+		}
+		return total
+	}
+
+	// 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()
+		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 pos = 0
+		while pos < len {
+			if clen > 0 {
+				var int next = find_next_byte(input, pos, len, charset)
+				// Copy the bytes we're skipping over.
+				while pos < next {
+					sb.append_char(input.at(pos))
+					pos += 1
+				}
+				if pos >= len {
+					break
+				}
+			}
+			var int end = match_here(pattern, 0, pat_len, input, pos, len)
+			if end >= 0 {
+				sb.append_string(replacement)
+				if end == pos {
+					sb.append_char(input.at(pos))
+					pos += 1
+				} else {
+					pos = end
+				}
+			} else {
+				sb.append_char(input.at(pos))
+				pos += 1
+			}
+		}
+		return sb.to_string()
+	}
+}
+
+// Scan input[pos..len) for the next byte that appears in charset (null-terminated).
+// Returns the index of the match, or len if none found / charset is empty.
+func find_next_byte = (string input, int pos, int len, string charset, out int) {
+	```
+	#arch: c
+	if (pos >= len || charset[0] == 0) return len;
+	char* found = strpbrk(input + pos, charset);
+	if (found == NULL) return len;
+	return (int)(found - input);
+	```
+	```
+	#arch: aarch64
+	// Free function: x0 = input, x1 = pos, x2 = len, x3 = charset
+	sub sp, sp, #32
+	str x0, [sp, #0]            // input
+	str x2, [sp, #8]            // len (default return)
+	cmp x1, x2
+	b.ge .Lfnb_default
+	ldrb w9, [x3]
+	cbz w9, .Lfnb_default
+	add x0, x0, x1              // x0 = input + pos
+	mov x1, x3                  // x1 = charset
+	bl _strpbrk
+	cbz x0, .Lfnb_default
+	ldr x9, [sp, #0]            // input
+	sub x0, x0, x9              // result = found - input
+	b .Lfnb_end
+	.Lfnb_default:
+	ldr x0, [sp, #8]            // return len
+	.Lfnb_end:
+	add sp, sp, #32
+	```
+}
+
+// Extract the set of possible first bytes from a pattern into a charset string.
+// Returns "" if every byte is possible (e.g. pattern starts with '.', '^', '(').
+func first_byte_set = (string pattern, int pat_len, out string) {
+	if pat_len == 0 {
+		return ""
+	}
+	var sb = StringBuilder()
+	collect_first_bytes(pattern, 0, pat_len, ref sb)
+	return sb.to_string()
+}
+
+// Walk top-level alternatives of pattern[pat_pos..pat_end), appending the first
+// byte(s) of each alternative to sb. Alternations at depth 0 are split on '|'.
+func collect_first_bytes = (string pattern, int pat_pos, int pat_end, ref StringBuilder sb) {
+	var depth = 0
+	var int i = pat_pos
+	var int alt_start = pat_pos
+	while i < pat_end {
+		var char c = pattern.at(i)
+		switch {
+			case (c as int) == 92 {
+				// escaped literal: '\x' → first byte is x
+				if i == alt_start {
+					if i + 1 < pat_end {
+						sb.append_char(pattern.at(i + 1))
+					}
+				}
+				i += 2
+			}
+			case c == '[' {
+				if i == alt_start {
+					var int a_end = atom_end_pos(pattern, i, pat_end)
+					add_class_chars(pattern, i + 1, a_end - 1, ref sb)
+				}
+				i = atom_end_pos(pattern, i, pat_end)
+			}
+			case c == '(' {
+				depth = depth + 1
+				i += 1
+			}
+			case c == ')' {
+				if depth > 0 {
+					depth -= 1
+				}
+				i += 1
+			}
+			case (c as int) == 124 {
+				if depth == 0 {
+					alt_start = i + 1
+				}
+				i += 1
+			}
+			case i == alt_start && depth == 0 && c != '^' && c != '$' && c != '.' {
+				sb.append_char(c)
+				i += 1
+			}
+			else {
+				i += 1
+			}
+		}
+	}
+}
+
+// Append the members of character class [start..end) to sb. Ranges (a-z) are
+// expanded; negation (^) is ignored (we want all candidates).
+func add_class_chars = (string pattern, int start, int end, ref StringBuilder sb) {
+	var int cs = start
+	if cs < end {
+		if pattern.at(cs) == '^' {
+			cs += 1
+		}
+	}
+	var int i = cs
+	while i < end {
+		if i + 2 < end {
+			if pattern.at(i + 1) == '-' {
+				var int lo = pattern.at(i) as int
+				var int hi = pattern.at(i + 2) as int
+				while lo <= hi {
+					sb.append_char(lo as char)
+					lo += 1
+				}
+				i += 3
+			} else {
+				sb.append_char(pattern.at(i))
+				i += 1
+			}
+		} else {
+			sb.append_char(pattern.at(i))
+				i += 1
+		}
+	}
+}
+
+// Match pattern[pat_pos..pat_end) against input starting at in_pos.
+// Returns the end position in input after a successful match, or -1.
+func match_here = (
+	string pattern,
+	int pat_pos,
+	int pat_end,
+	string input,
+	int in_pos,
+	int in_len,
+	out int
+) {
+	// Handle top-level alternation: a '|' at bracket/paren depth 0 splits the
+	// range into alternatives. Char classes and escapes are skipped so a '|' or
+	// '\|' inside them is not mistaken for an alternation operator.
+	var depth = 0
+	var int i = pat_pos
+	while i < pat_end {
+		var char c = pattern.at(i)
+		if (c as int) == 92 {
+			i += 2
+		} else {
+			if c == '[' {
+				i = atom_end_pos(pattern, i, pat_end)
+			} else {
+				if c == '(' {
+					depth += 1
+				}
+				if c == ')' {
+					if depth > 0 {
+						depth -= 1
+					}
+				}
+				if (c as int) == 124 {
+					if depth == 0 {
+						var int left = match_here(pattern, pat_pos, i, input, in_pos, in_len)
+						if left >= 0 {
+							return left
+						}
+						return match_here(pattern, i + 1, pat_end, input, in_pos, in_len)
+					}
+				}
+				i += 1
+			}
+		}
+	}
+
+	// Pattern exhausted: match succeeds at the current position.
+	if pat_pos >= pat_end {
+		return in_pos
+	}
+
+	var char pc = pattern.at(pat_pos)
+
+	// Anchors (zero-width assertions).
+	if pc == '^' {
+		if in_pos != 0 {
+			return -1
+		}
+		return match_here(pattern, pat_pos + 1, pat_end, input, in_pos, in_len)
+	}
+	if pc == '$' {
+		if in_pos != in_len {
+			return -1
+		}
+		return match_here(pattern, pat_pos + 1, pat_end, input, in_pos, in_len)
+	}
+
+	// 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.
+	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)
+		}
+	}
+
+	// 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)
+	if next < 0 {
+		return -1
+	}
+	return match_here(pattern, a_end, pat_end, input, next, in_len)
+}
+
+// Return the position just past the atom that starts at pat_pos. Handles
+// character classes [...], groups (...), and escaped characters (\x).
+func atom_end_pos = (string pattern, int pat_pos, int pat_end, out int) {
+	var char pc = pattern.at(pat_pos)
+	if pc == '[' {
+		var int cs = pat_pos + 1
+		if cs < pat_end {
+			if pattern.at(cs) == '^' {
+				cs += 1
+			}
+		}
+		while cs < pat_end; cs += 1 {
+			if pattern.at(cs) == ']' {
+				return cs + 1
+			}
+		}
+		return pat_end
+	}
+	if pc == '(' {
+		var d = 1
+		var int j = pat_pos + 1
+		while j < pat_end; j += 1 {
+			var char c = pattern.at(j)
+			if c == '(' {
+				d += 1
+			}
+			if c == ')' {
+				d -= 1
+				if d == 0 {
+					return j + 1
+				}
+			}
+		}
+		return pat_end
+	}
+	if (pc as int) == 92 {
+		if pat_pos + 1 < pat_end {
+			return pat_pos + 2
+		}
+		return pat_pos + 1
+	}
+	return pat_pos + 1
+}
+
+// Match the atom [atom_start..atom_end) exactly once at in_pos.
+// Returns the new input position after consuming the atom, or -1.
+func match_single_atom = (
+	string pattern,
+	int atom_start,
+	int atom_end,
+	string input,
+	int in_pos,
+	int in_len,
+	out int
+) {
+	var char pc = pattern.at(atom_start)
+
+	if pc == '.' {
+		if in_pos < in_len {
+			if (input.at(in_pos) as int) != 10 {
+				return in_pos + 1
+			}
+		}
+		return -1
+	}
+	if pc == '[' {
+		if in_pos < in_len {
+			if char_in_class(pattern, atom_start, atom_end, input, in_pos, in_len) {
+				return in_pos + 1
+			}
+		}
+		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)
+	}
+	if (pc as int) == 92 {
+		if atom_start + 1 < atom_end {
+			var char ec = pattern.at(atom_start + 1)
+			if in_pos < in_len {
+				if input.at(in_pos) == ec {
+					return in_pos + 1
+				}
+			}
+		}
+		return -1
+	}
+	if in_pos < in_len {
+		if input.at(in_pos) == pc {
+			return in_pos + 1
+		}
+	}
+	return -1
+}
+
+// Report whether input.at(pos) matches the single-character atom at
+// [atom_start..atom_end). Used by the greedy star matcher.
+func char_matches_atom = (
+	string pattern,
+	int atom_start,
+	int atom_end,
+	string input,
+	int pos,
+	int in_len,
+	out bool
+) {
+	var char pc = pattern.at(atom_start)
+	var char ic = input.at(pos)
+	if pc == '.' {
+		if (ic as int) == 10 {
+			return false
+		}
+		return true
+	}
+	if pc == '[' {
+		return char_in_class(pattern, atom_start, atom_end, input, pos, in_len)
+	}
+	if (pc as int) == 92 {
+		if atom_start + 1 < atom_end {
+			return ic == pattern.at(atom_start + 1)
+		}
+		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.
+func match_star = (
+	string pattern,
+	int atom_start,
+	int atom_end,
+	int pat_end,
+	string input,
+	int in_pos,
+	int min_count,
+	int in_len,
+	out int
+) {
+	var char pc = pattern.at(atom_start)
+	if pc == '(' {
+		return match_star_group(
+			pattern,
+			atom_start,
+			atom_end,
+			pat_end,
+			input,
+			in_pos,
+			min_count,
+			in_len,
+		)
+	}
+
+	// Greedily consume the longest run of matching characters.
+	var int max_pos = in_pos
+	while max_pos < in_len {
+		if char_matches_atom(pattern, atom_start, atom_end, input, max_pos, in_len) {
+			max_pos += 1
+		} else {
+			break
+		}
+	}
+	// 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)
+		if r >= 0 {
+			return r
+		}
+	}
+	return -1
+}
+
+// Recursive greedy backtracking for group atoms quantified with '*' or '+'.
+func match_star_group = (
+	string pattern,
+	int atom_start,
+	int atom_end,
+	int pat_end,
+	string input,
+	int in_pos,
+	int min_count,
+	int in_len,
+	out int
+) {
+	// Try matching the group one more time (greedy).
+	var int next = match_single_atom(pattern, atom_start, atom_end, input, in_pos, in_len)
+	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_group(
+				pattern,
+				atom_start,
+				atom_end,
+				pat_end,
+				input,
+				next,
+				new_min,
+				in_len,
+			)
+			if r >= 0 {
+				return r
+			}
+		}
+	}
+	// 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 -1
+}
+
+// Match the atom optionally ('?'), preferring to include it.
+func match_optional = (
+	string pattern,
+	int atom_start,
+	int atom_end,
+	int pat_end,
+	string input,
+	int in_pos,
+	int in_len,
+	out int
+) {
+	var int next = match_single_atom(pattern, atom_start, atom_end, input, in_pos, in_len)
+	if next >= 0 {
+		var int r = match_here(pattern, atom_end + 1, pat_end, input, next, in_len)
+		if r >= 0 {
+			return r
+		}
+	}
+	return match_here(pattern, atom_end + 1, pat_end, input, in_pos, in_len)
+}
+
+// Report whether input.at(in_pos) belongs to the character class whose '[' is
+// at open_pos and whose ']' is at atom_end - 1 (atom_end is just after ']').
+func char_in_class = (
+	string pattern,
+	int open_pos,
+	int atom_end,
+	string input,
+	int in_pos,
+	int in_len,
+	out bool
+) {
+	if in_pos >= in_len {
+		return false
+	}
+	var char ic = input.at(in_pos)
+
+	var int content_start = open_pos + 1
+	var negated = false
+	if content_start < atom_end {
+		if pattern.at(content_start) == '^' {
+			negated = true
+			content_start += 1
+		}
+	}
+	var int content_end = atom_end - 1
+
+	var found = false
+	var int i = content_start
+	while i < content_end {
+		var char c = pattern.at(i)
+		if (c as int) == 92 {
+			if i + 1 < content_end {
+				if ic == pattern.at(i + 1) {
+					found = true
+				}
+			}
+			i = i + 2
+		} else {
+			if i + 2 < content_end {
+				if pattern.at(i + 1) == '-' {
+					var char lo = c
+					var char hi = pattern.at(i + 2)
+					if (ic as int) >= (lo as int) {
+						if (ic as int) <= (hi as int) {
+							found = true
+						}
+					}
+					i += 3
+				} else {
+					if ic == c {
+						found = true
+					}
+					i += 1
+				}
+			} else {
+				if ic == c {
+					found = true
+				}
+				i += 1
+			}
+		}
+	}
+
+	if negated {
+		if found {
+			return false
+		}
+		return true
+	}
+	return found
+}