@shd101wyy/yo 0.0.27 → 0.0.29

package/std/regex/regex.yo

@@ -0,0 +1,714 @@
+// std/regex/regex.yo - Main Regex type
+//
+// High-level regex API similar to JavaScript's RegExp.
+//
+// Example:
+//   { Regex } :: import "std/regex";
+//   re := Regex.new(`\\d+`).unwrap();
+//   m := re.exec(`abc123def`);
+//   match(m,
+//     .Some(result) => println(result.value()),
+//     .None => println(`no match`)
+//   );
+
+open import "std/collections/array_list";
+open import "std/string";
+{ RegexParser } :: import "./parser.yo";
+{ NfaCompiler, NfaProgram, Instr, InstrKind, ClassEntry, GroupNameEntry } :: import "./compiler.yo";
+{ NfaVm, VmMatch } :: import "./vm.yo";
+{ RegexFlags } :: import "./flags.yo";
+{ RegexMatch } :: import "./match.yo";
+
+// The Regex type: a compiled regular expression
+Regex :: object(
+  _program     : NfaProgram,
+  _flags       : RegexFlags,
+  _pattern     : String,
+  _n_groups    : usize,
+  _group_names : ArrayList(GroupNameEntry)
+);
+
+// Block 1: Constructor and leaf methods
+impl(Regex,
+  new : (fn(pattern : String, flags_str : String) -> Result(Self, String))({
+    flags_result := RegexFlags.parse(flags_str);
+    match(flags_result,
+      .Err(e) => .Err(e),
+      .Ok(flags) => {
+        parser := RegexParser.new(pattern);
+        ast_result := parser.parse();
+        match(ast_result,
+          .Err(e) => .Err(e),
+          .Ok(ast) => {
+            n_groups := parser.group_count();
+            gnames := parser.group_names();
+            compiler := NfaCompiler.new();
+            program := compiler.compile(ast, n_groups, gnames);
+            // Literal prefix scan is case-sensitive; disable when ignoreCase
+            cond(
+              flags.ignore_case => { program.literal_prefix = ArrayList(u8).new(); },
+              true => ()
+            );
+            .Ok(Self(
+              _program: program,
+              _flags: flags,
+              _pattern: pattern,
+              _n_groups: n_groups,
+              _group_names: gnames
+            ))
+          }
+        )
+      }
+    )
+  }),
+
+  source : (fn(self : Self) -> String)(
+    self._pattern
+  ),
+
+  _extract_substring : (fn(self : Self, bytes : ArrayList(u8), start : usize, end_pos : usize) -> String)({
+    result_bytes := ArrayList(u8).with_capacity((end_pos - start));
+    i := start;
+    while (i < end_pos), (i = (i + usize(1))), {
+      result_bytes.push(bytes.get(i).unwrap());
+    };
+    String.from_bytes(result_bytes)
+  }),
+
+  _byte_to_char_index : (fn(self : Self, bytes : ArrayList(u8), byte_pos : usize) -> usize)({
+    char_idx := usize(0);
+    i := usize(0);
+    while (i < byte_pos), {
+      b := bytes.get(i).unwrap();
+      char_len := cond(
+        (b < u8(0x80)) => usize(1),
+        ((b >= u8(0xC0)) && (b < u8(0xE0))) => usize(2),
+        ((b >= u8(0xE0)) && (b < u8(0xF0))) => usize(3),
+        true => usize(4)
+      );
+      i = (i + char_len);
+      char_idx = (char_idx + usize(1));
+    };
+    char_idx
+  }),
+
+  // Fast-scan: find the next byte position where the literal prefix matches.
+  // Returns the byte position or input_len if not found.
+  _find_prefix_pos : (fn(self : Self, input_bytes : ArrayList(u8), from_byte : usize) -> usize)({
+    prefix := self._program.literal_prefix;
+    prefix_len := prefix.len();
+    input_len := input_bytes.len();
+
+    cond(
+      (prefix_len == usize(0)) => from_byte,
+      (input_len < prefix_len) => (input_len + usize(1)),
+      true => {
+        first_byte := prefix.get(usize(0)).unwrap();
+        (pos : usize) = from_byte;
+        (found : bool) = false;
+
+        while ((pos <= (input_len - prefix_len)) && (!(found))), {
+          cond(
+            (input_bytes.get(pos).unwrap() == first_byte) => {
+              // Check remaining prefix bytes
+              (match_ok : bool) = true;
+              pi := usize(1);
+              while ((pi < prefix_len) && match_ok), (pi = (pi + usize(1))), {
+                cond(
+                  (input_bytes.get((pos + pi)).unwrap() != prefix.get(pi).unwrap()) => {
+                    match_ok = false;
+                  },
+                  true => ()
+                );
+              };
+              cond(
+                match_ok => { found = true; },
+                true => { pos = (pos + usize(1)); }
+              );
+            },
+            true => { pos = (pos + usize(1)); }
+          );
+        };
+
+        cond(
+          found => pos,
+          true => (input_len + usize(1))
+        )
+      }
+    )
+  })
+);
+
+// Block 2: _build_match (depends on Block 1)
+impl(Regex,
+  _build_match : (fn(self : Self, slots : ArrayList(usize), input : String) -> RegexMatch)({
+    bytes := input.as_bytes();
+    unset := usize(0xFFFFFFFFFFFFFFFF);
+
+    match_start_byte := slots.get(usize(0)).unwrap();
+    match_end_byte := slots.get(usize(1)).unwrap();
+
+    match_text := self._extract_substring(bytes, match_start_byte, match_end_byte);
+    match_char_index := self._byte_to_char_index(bytes, match_start_byte);
+
+    groups := ArrayList(Option(String)).new();
+    g := usize(1);
+    while (g <= self._n_groups), (g = (g + usize(1))), {
+      start_slot := (g * usize(2));
+      end_slot := ((g * usize(2)) + usize(1));
+
+      cond(
+        ((start_slot < slots.len()) && (end_slot < slots.len())) => {
+          gs := slots.get(start_slot).unwrap();
+          ge := slots.get(end_slot).unwrap();
+          cond(
+            ((gs != unset) && (ge != unset)) => {
+              group_text := self._extract_substring(bytes, gs, ge);
+              groups.push(.Some(group_text));
+            },
+            true => {
+              groups.push(.None);
+            }
+          );
+        },
+        true => {
+          groups.push(.None);
+        }
+      );
+    };
+
+    RegexMatch.new(match_text, match_char_index, input, groups, self._group_names)
+  })
+);
+
+// Block 3: exec, match_all (depend on Block 2)
+impl(Regex,
+  exec : (fn(self : Self, input : String) -> Option(RegexMatch))({
+    bytes := input.as_bytes();
+    input_len := bytes.len();
+
+    // Sticky flag: only try matching at position 0
+    cond(
+      self._flags.sticky => {
+        vm := NfaVm.new(self._program, self._flags, input);
+        result := vm.exec_at(usize(0));
+        cond(
+          result.matched => .Some(self._build_match(result.slots, input)),
+          true => .None
+        )
+      },
+      true => {
+        has_prefix := (self._program.literal_prefix.len() > usize(0));
+        byte_pos := cond(
+          has_prefix => self._find_prefix_pos(bytes, usize(0)),
+          true => usize(0)
+        );
+
+        while (byte_pos <= input_len), {
+          vm := NfaVm.new(self._program, self._flags, input);
+          result := vm.exec_at(byte_pos);
+
+          cond(
+            result.matched => {
+              m := self._build_match(result.slots, input);
+              return .Some(m);
+            },
+            true => ()
+          );
+
+          cond(
+            (byte_pos >= input_len) => { break; },
+            true => {
+              b := bytes.get(byte_pos).unwrap();
+              char_len := cond(
+                (b < u8(0x80)) => usize(1),
+                ((b >= u8(0xC0)) && (b < u8(0xE0))) => usize(2),
+                ((b >= u8(0xE0)) && (b < u8(0xF0))) => usize(3),
+                true => usize(4)
+              );
+              next_pos := (byte_pos + char_len);
+              byte_pos = cond(
+                has_prefix => self._find_prefix_pos(bytes, next_pos),
+                true => next_pos
+              );
+            }
+          );
+        };
+
+        .None
+      }
+    )
+  }),
+
+  match_all : (fn(self : Self, input : String) -> ArrayList(RegexMatch))({
+    matches := ArrayList(RegexMatch).new();
+    bytes := input.as_bytes();
+    input_len := bytes.len();
+
+    cond(
+      self._flags.sticky => {
+        // Sticky: only try at position 0, then at end of each match
+        (byte_pos : usize) = usize(0);
+        while (byte_pos <= input_len), {
+          vm := NfaVm.new(self._program, self._flags, input);
+          result := vm.exec_at(byte_pos);
+
+          cond(
+            result.matched => {
+              m := self._build_match(result.slots, input);
+              matches.push(m);
+              match_start := result.slots.get(usize(0)).unwrap();
+              match_end := result.slots.get(usize(1)).unwrap();
+              cond(
+                (match_end == match_start) => {
+                  // Empty match: advance one char to avoid infinite loop
+                  cond(
+                    (byte_pos >= input_len) => { break; },
+                    true => {
+                      b := bytes.get(byte_pos).unwrap();
+                      char_len := cond(
+                        (b < u8(0x80)) => usize(1),
+                        ((b >= u8(0xC0)) && (b < u8(0xE0))) => usize(2),
+                        ((b >= u8(0xE0)) && (b < u8(0xF0))) => usize(3),
+                        true => usize(4)
+                      );
+                      byte_pos = (byte_pos + char_len);
+                    }
+                  );
+                },
+                true => {
+                  byte_pos = match_end;
+                }
+              );
+            },
+            true => { break; }
+          );
+        };
+      },
+      true => {
+        has_prefix := (self._program.literal_prefix.len() > usize(0));
+        byte_pos := cond(
+          has_prefix => self._find_prefix_pos(bytes, usize(0)),
+          true => usize(0)
+        );
+
+        while (byte_pos <= input_len), {
+          vm := NfaVm.new(self._program, self._flags, input);
+          result := vm.exec_at(byte_pos);
+
+          cond(
+            result.matched => {
+              m := self._build_match(result.slots, input);
+              matches.push(m);
+
+              match_start := result.slots.get(usize(0)).unwrap();
+              match_end := result.slots.get(usize(1)).unwrap();
+
+              cond(
+                (match_end == match_start) => {
+                  cond(
+                    (byte_pos >= input_len) => { break; },
+                    true => {
+                      b := bytes.get(byte_pos).unwrap();
+                      char_len := cond(
+                        (b < u8(0x80)) => usize(1),
+                        ((b >= u8(0xC0)) && (b < u8(0xE0))) => usize(2),
+                        ((b >= u8(0xE0)) && (b < u8(0xF0))) => usize(3),
+                        true => usize(4)
+                      );
+                      next_pos := (byte_pos + char_len);
+                      byte_pos = cond(
+                        has_prefix => self._find_prefix_pos(bytes, next_pos),
+                        true => next_pos
+                      );
+                    }
+                  );
+                },
+                true => {
+                  byte_pos = cond(
+                    has_prefix => self._find_prefix_pos(bytes, match_end),
+                    true => match_end
+                  );
+                }
+              );
+            },
+            true => {
+              cond(
+                (byte_pos >= input_len) => { break; },
+                true => {
+                  b := bytes.get(byte_pos).unwrap();
+                  char_len := cond(
+                    (b < u8(0x80)) => usize(1),
+                    ((b >= u8(0xC0)) && (b < u8(0xE0))) => usize(2),
+                    ((b >= u8(0xE0)) && (b < u8(0xF0))) => usize(3),
+                    true => usize(4)
+                  );
+                  next_pos := (byte_pos + char_len);
+                  byte_pos = cond(
+                    has_prefix => self._find_prefix_pos(bytes, next_pos),
+                    true => next_pos
+                  );
+                }
+              );
+            }
+          );
+        };
+      }
+    );
+
+    matches
+  })
+);
+
+// Block 4: test, search (depends on Block 3)
+impl(Regex,
+  test : (fn(self : Self, input : String) -> bool)({
+    result := self.exec(input);
+    result.is_some()
+  }),
+
+  search : (fn(self : Self, input : String) -> Option(usize))({
+    result := self.exec(input);
+    match(result,
+      .Some(m) => .Some(m.index()),
+      .None => .None
+    )
+  })
+);
+
+// Block 5: _apply_replacement helper (depends on Block 2)
+impl(Regex,
+  // Process replacement patterns: $& (full match), $1-$9 (groups),
+  // ${name} (named groups), $` (pre-match), $' (post-match), $$ (literal $)
+  _apply_replacement : (fn(self : Self, replacement : String, m : RegexMatch) -> String)({
+    rep_bytes := replacement.as_bytes();
+    rep_len := rep_bytes.len();
+    result := ArrayList(u8).new();
+    i := usize(0);
+
+    while (i < rep_len), {
+      b := rep_bytes.get(i).unwrap();
+      cond(
+        ((b == u8(36)) && ((i + usize(1)) < rep_len)) => {
+          // '$' character — check next char
+          next_b := rep_bytes.get((i + usize(1))).unwrap();
+          cond(
+            (next_b == u8(36)) => {
+              // $$ → literal $
+              result.push(u8(36));
+              i = (i + usize(2));
+            },
+            (next_b == u8(38)) => {
+              // $& → full match
+              match_bytes := m.value().as_bytes();
+              mi := usize(0);
+              while (mi < match_bytes.len()), (mi = (mi + usize(1))), {
+                result.push(match_bytes.get(mi).unwrap());
+              };
+              i = (i + usize(2));
+            },
+            (next_b == u8(96)) => {
+              // $` → pre-match (text before match)
+              input_bytes := m.input().as_bytes();
+              // Convert char index to byte index
+              char_idx := m.index();
+              byte_idx := usize(0);
+              ci := usize(0);
+              while (ci < char_idx), {
+                cb := input_bytes.get(byte_idx).unwrap();
+                cbl := cond(
+                  (cb < u8(0x80)) => usize(1),
+                  ((cb >= u8(0xC0)) && (cb < u8(0xE0))) => usize(2),
+                  ((cb >= u8(0xE0)) && (cb < u8(0xF0))) => usize(3),
+                  true => usize(4)
+                );
+                byte_idx = (byte_idx + cbl);
+                ci = (ci + usize(1));
+              };
+              pi := usize(0);
+              while (pi < byte_idx), (pi = (pi + usize(1))), {
+                result.push(input_bytes.get(pi).unwrap());
+              };
+              i = (i + usize(2));
+            },
+            (next_b == u8(39)) => {
+              // $' → post-match (text after match)
+              input_bytes := m.input().as_bytes();
+              // Find byte position after match end
+              char_idx := m.index();
+              byte_idx := usize(0);
+              ci := usize(0);
+              while (ci < char_idx), {
+                cb := input_bytes.get(byte_idx).unwrap();
+                cbl := cond(
+                  (cb < u8(0x80)) => usize(1),
+                  ((cb >= u8(0xC0)) && (cb < u8(0xE0))) => usize(2),
+                  ((cb >= u8(0xE0)) && (cb < u8(0xF0))) => usize(3),
+                  true => usize(4)
+                );
+                byte_idx = (byte_idx + cbl);
+                ci = (ci + usize(1));
+              };
+              // Advance past the matched text
+              match_bytes := m.value().as_bytes();
+              byte_idx = (byte_idx + match_bytes.len());
+              pi := byte_idx;
+              while (pi < input_bytes.len()), (pi = (pi + usize(1))), {
+                result.push(input_bytes.get(pi).unwrap());
+              };
+              i = (i + usize(2));
+            },
+            ((next_b >= u8(48)) && (next_b <= u8(57))) => {
+              // $0-$9 → group reference
+              group_idx := usize((next_b - u8(48)));
+              grp := m.group(group_idx);
+              match(grp,
+                .Some(g) => {
+                  g_bytes := g.as_bytes();
+                  gi := usize(0);
+                  while (gi < g_bytes.len()), (gi = (gi + usize(1))), {
+                    result.push(g_bytes.get(gi).unwrap());
+                  };
+                },
+                .None => ()
+              );
+              i = (i + usize(2));
+            },
+            (next_b == u8(123)) => {
+              // ${ → named group reference ${name}
+              name_start := (i + usize(2));
+              (name_end : usize) = name_start;
+              (found_close : bool) = false;
+              while (name_end < rep_len), {
+                nb := rep_bytes.get(name_end).unwrap();
+                cond(
+                  (nb == u8(125)) => {
+                    found_close = true;
+                    break;
+                  },
+                  true => {
+                    name_end = (name_end + usize(1));
+                  }
+                );
+              };
+              cond(
+                found_close => {
+                  name_bytes := ArrayList(u8).with_capacity((name_end - name_start));
+                  ni := name_start;
+                  while (ni < name_end), (ni = (ni + usize(1))), {
+                    name_bytes.push(rep_bytes.get(ni).unwrap());
+                  };
+                  name := String.from_bytes(name_bytes);
+                  grp := m.named_group(name);
+                  match(grp,
+                    .Some(g) => {
+                      g_bytes := g.as_bytes();
+                      gi := usize(0);
+                      while (gi < g_bytes.len()), (gi = (gi + usize(1))), {
+                        result.push(g_bytes.get(gi).unwrap());
+                      };
+                    },
+                    .None => ()
+                  );
+                  i = (name_end + usize(1));
+                },
+                true => {
+                  // No closing } — emit literal ${
+                  result.push(u8(36));
+                  i = (i + usize(1));
+                }
+              );
+            },
+            true => {
+              // Unknown $ sequence — emit literal $
+              result.push(u8(36));
+              i = (i + usize(1));
+            }
+          );
+        },
+        true => {
+          result.push(b);
+          i = (i + usize(1));
+        }
+      );
+    };
+
+    String.from_bytes(result)
+  })
+);
+
+// Block 6: replace, replace_all, split (depends on Block 3+5)
+impl(Regex,
+  replace : (fn(self : Self, input : String, replacement : String) -> String)({
+    result := self.exec(input);
+    match(result,
+      .None => input,
+      .Some(m) => {
+        input_bytes := input.as_bytes();
+        // Convert char index to byte index for match start
+        char_idx := m.index();
+        (match_start_byte : usize) = usize(0);
+        ci := usize(0);
+        while (ci < char_idx), {
+          cb := input_bytes.get(match_start_byte).unwrap();
+          cbl := cond(
+            (cb < u8(0x80)) => usize(1),
+            ((cb >= u8(0xC0)) && (cb < u8(0xE0))) => usize(2),
+            ((cb >= u8(0xE0)) && (cb < u8(0xF0))) => usize(3),
+            true => usize(4)
+          );
+          match_start_byte = (match_start_byte + cbl);
+          ci = (ci + usize(1));
+        };
+        match_end_byte := (match_start_byte + m.value().as_bytes().len());
+
+        // Build result: pre-match + replacement + post-match
+        out := ArrayList(u8).new();
+        pi := usize(0);
+        while (pi < match_start_byte), (pi = (pi + usize(1))), {
+          out.push(input_bytes.get(pi).unwrap());
+        };
+        rep := self._apply_replacement(replacement, m);
+        rep_bytes := rep.as_bytes();
+        ri := usize(0);
+        while (ri < rep_bytes.len()), (ri = (ri + usize(1))), {
+          out.push(rep_bytes.get(ri).unwrap());
+        };
+        pi = match_end_byte;
+        while (pi < input_bytes.len()), (pi = (pi + usize(1))), {
+          out.push(input_bytes.get(pi).unwrap());
+        };
+        String.from_bytes(out)
+      }
+    )
+  }),
+
+  replace_all : (fn(self : Self, input : String, replacement : String) -> String)({
+    all_matches := self.match_all(input);
+    cond(
+      (all_matches.len() == usize(0)) => input,
+      true => {
+        input_bytes := input.as_bytes();
+        out := ArrayList(u8).new();
+        (last_end_byte : usize) = usize(0);
+
+        mi := usize(0);
+        while (mi < all_matches.len()), (mi = (mi + usize(1))), {
+          m := all_matches.get(mi).unwrap();
+          // Convert char index to byte index for match start
+          char_idx := m.index();
+          (match_start_byte : usize) = usize(0);
+          ci := usize(0);
+          while (ci < char_idx), {
+            cb := input_bytes.get(match_start_byte).unwrap();
+            cbl := cond(
+              (cb < u8(0x80)) => usize(1),
+              ((cb >= u8(0xC0)) && (cb < u8(0xE0))) => usize(2),
+              ((cb >= u8(0xE0)) && (cb < u8(0xF0))) => usize(3),
+              true => usize(4)
+            );
+            match_start_byte = (match_start_byte + cbl);
+            ci = (ci + usize(1));
+          };
+          match_end_byte := (match_start_byte + m.value().as_bytes().len());
+
+          // Copy text between last match end and this match start
+          pi := last_end_byte;
+          while (pi < match_start_byte), (pi = (pi + usize(1))), {
+            out.push(input_bytes.get(pi).unwrap());
+          };
+
+          // Apply replacement
+          rep := self._apply_replacement(replacement, m);
+          rep_bytes := rep.as_bytes();
+          ri := usize(0);
+          while (ri < rep_bytes.len()), (ri = (ri + usize(1))), {
+            out.push(rep_bytes.get(ri).unwrap());
+          };
+
+          last_end_byte = match_end_byte;
+        };
+
+        // Copy remaining text after last match
+        pi := last_end_byte;
+        while (pi < input_bytes.len()), (pi = (pi + usize(1))), {
+          out.push(input_bytes.get(pi).unwrap());
+        };
+
+        String.from_bytes(out)
+      }
+    )
+  }),
+
+  split : (fn(self : Self, input : String) -> ArrayList(String))({
+    parts := ArrayList(String).new();
+    all_matches := self.match_all(input);
+
+    cond(
+      (all_matches.len() == usize(0)) => {
+        parts.push(input);
+      },
+      true => {
+        input_bytes := input.as_bytes();
+        (last_end_byte : usize) = usize(0);
+
+        mi := usize(0);
+        while (mi < all_matches.len()), (mi = (mi + usize(1))), {
+          m := all_matches.get(mi).unwrap();
+          // Convert char index to byte index for match start
+          char_idx := m.index();
+          (match_start_byte : usize) = usize(0);
+          ci := usize(0);
+          while (ci < char_idx), {
+            cb := input_bytes.get(match_start_byte).unwrap();
+            cbl := cond(
+              (cb < u8(0x80)) => usize(1),
+              ((cb >= u8(0xC0)) && (cb < u8(0xE0))) => usize(2),
+              ((cb >= u8(0xE0)) && (cb < u8(0xF0))) => usize(3),
+              true => usize(4)
+            );
+            match_start_byte = (match_start_byte + cbl);
+            ci = (ci + usize(1));
+          };
+          match_end_byte := (match_start_byte + m.value().as_bytes().len());
+
+          // Extract text from last_end_byte to match_start_byte
+          part_bytes := ArrayList(u8).new();
+          pi := last_end_byte;
+          while (pi < match_start_byte), (pi = (pi + usize(1))), {
+            part_bytes.push(input_bytes.get(pi).unwrap());
+          };
+          parts.push(String.from_bytes(part_bytes));
+
+          // Include capture groups in split result (like JS)
+          gi := usize(1);
+          while (gi <= m.group_count()), (gi = (gi + usize(1))), {
+            grp := m.group(gi);
+            match(grp,
+              .Some(g) => { parts.push(g); },
+              .None => { parts.push(`undefined`); }
+            );
+          };
+
+          last_end_byte = match_end_byte;
+        };
+
+        // Add remaining text after last match
+        remaining := ArrayList(u8).new();
+        pi := last_end_byte;
+        while (pi < input_bytes.len()), (pi = (pi + usize(1))), {
+          remaining.push(input_bytes.get(pi).unwrap());
+        };
+        parts.push(String.from_bytes(remaining));
+      }
+    );
+
+    parts
+  })
+);
+
+export
+  Regex,
+  RegexMatch,
+  RegexFlags
+;