@shd101wyy/yo 0.1.25 → 0.1.27

package/std/regex/index.yo

@@ -1,33 +1,33 @@
 //! Regular expression engine with an NFA-based virtual machine.
-
-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";
-
+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");
 /// Compiled regular expression backed by an NFA program.
 Regex :: object(
-  _program     : NfaProgram,
-  _flags       : RegexFlags,
-  _pattern     : String,
-  _n_groups    : usize,
+  _program : NfaProgram,
+  _flags : RegexFlags,
+  _pattern : String,
+  _n_groups : usize,
   _group_names : ArrayList(GroupNameEntry)
 );
-
 // Block 1: Constructor and leaf methods
-impl(Regex,
+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),
+    match(
+      flags_result,
+      .Err(e) =>.Err(e),
       .Ok(flags) => {
         parser := RegexParser.new(pattern);
         ast_result := parser.parse();
-        match(ast_result,
-          .Err(e) => .Err(e),
+        match(
+          ast_result,
+          .Err(e) =>.Err(e),
           .Ok(ast) => {
             n_groups := parser.group_count();
             gnames := parser.group_names();
@@ -35,39 +35,40 @@ impl(Regex,
             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(); },
+              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
-            ))
+            .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));
+    result_bytes := ArrayList(u8).with_capacity(end_pos - start);
     i := start;
-    while (i < end_pos), (i = (i + usize(1))), {
+    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), {
+    while(i < byte_pos, {
       b := bytes.get(i).unwrap();
       char_len := cond(
         (b < u8(0x80)) => usize(1),
@@ -77,17 +78,15 @@ impl(Regex,
       );
       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)),
@@ -95,30 +94,34 @@ impl(Regex,
         first_byte := prefix.get(usize(0)).unwrap();
         (pos : usize) = from_byte;
         (found : bool) = false;
-
-        while ((pos <= (input_len - prefix_len)) && (!(found))), {
+        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))), {
+              while((pi < prefix_len) && match_ok, pi = (pi + usize(1)), {
                 cond(
-                  (input_bytes.get((pos + pi)).unwrap() != prefix.get(pi).unwrap()) => {
+                  (input_bytes.get(pos + pi).unwrap() != prefix.get(pi).unwrap()) => {
                     match_ok = false;
                   },
                   true => ()
                 );
-              };
+              });
               cond(
-                match_ok => { found = true; },
-                true => { pos = (pos + usize(1)); }
+                match_ok => {
+                  found = true;
+                },
+                true => {
+                  pos = (pos + usize(1));
+                }
               );
             },
-            true => { pos = (pos + usize(1)); }
+            true => {
+              pos = (pos + usize(1));
+            }
           );
-        };
-
+        });
         cond(
           found => pos,
           true => (input_len + usize(1))
@@ -127,25 +130,21 @@ impl(Regex,
     )
   })
 );
-
 // Block 2: _build_match (depends on Block 1)
-impl(Regex,
+impl(
+  Regex,
   _build_match : (fn(self : Self, slots : ArrayList(usize), input : String) -> RegexMatch)({
     bytes := input.as_bytes();
     unset := usize.MAX;
-
     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))), {
+    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();
@@ -164,26 +163,24 @@ impl(Regex,
           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,
+impl(
+  Regex,
   exec : (fn(self : Self, input : String) -> Option(RegexMatch))({
     bytes := input.as_bytes();
     input_len := bytes.len();
     vm := NfaVm.new(self._program, self._flags, input);
-
     // Sticky flag: only try matching at position 0
     cond(
       self._flags.sticky => {
         result := vm.exec_at(usize(0));
         cond(
-          result.matched => .Some(self._build_match(result.slots, input)),
-          true => .None
+          result.matched =>.Some(self._build_match(result.slots, input)),
+          true =>.None
         )
       },
       true => {
@@ -192,20 +189,19 @@ impl(Regex,
           has_prefix => self._find_prefix_pos(bytes, usize(0)),
           true => usize(0)
         );
-
-        while (byte_pos <= input_len), {
+        while(byte_pos <= input_len, {
           result := vm.exec_at(byte_pos);
-
           cond(
             result.matched => {
               m := self._build_match(result.slots, input);
-              return .Some(m);
+              return(.Some(m));
             },
             true => ()
           );
-
           cond(
-            (byte_pos >= input_len) => { break; },
+            (byte_pos >= input_len) => {
+              break;
+            },
             true => {
               b := bytes.get(byte_pos).unwrap();
               char_len := cond(
@@ -221,26 +217,22 @@ impl(Regex,
               );
             }
           );
-        };
-
+        });
         .None
       }
     )
   }),
-
   match_all : (fn(self : Self, input : String) -> ArrayList(RegexMatch))({
     matches := ArrayList(RegexMatch).new();
     bytes := input.as_bytes();
     input_len := bytes.len();
     vm := NfaVm.new(self._program, self._flags, input);
-
     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), {
+        while(byte_pos <= input_len, {
           result := vm.exec_at(byte_pos);
-
           cond(
             result.matched => {
               m := self._build_match(result.slots, input);
@@ -251,7 +243,9 @@ impl(Regex,
                 (match_end == match_start) => {
                   // Empty match: advance one char to avoid infinite loop
                   cond(
-                    (byte_pos >= input_len) => { break; },
+                    (byte_pos >= input_len) => {
+                      break;
+                    },
                     true => {
                       b := bytes.get(byte_pos).unwrap();
                       char_len := cond(
@@ -269,9 +263,11 @@ impl(Regex,
                 }
               );
             },
-            true => { break; }
+            true => {
+              break;
+            }
           );
-        };
+        });
       },
       true => {
         has_prefix := (self._program.literal_prefix.len() > usize(0));
@@ -279,22 +275,20 @@ impl(Regex,
           has_prefix => self._find_prefix_pos(bytes, usize(0)),
           true => usize(0)
         );
-
-        while (byte_pos <= input_len), {
+        while(byte_pos <= input_len, {
           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; },
+                    (byte_pos >= input_len) => {
+                      break;
+                    },
                     true => {
                       b := bytes.get(byte_pos).unwrap();
                       char_len := cond(
@@ -321,7 +315,9 @@ impl(Regex,
             },
             true => {
               cond(
-                (byte_pos >= input_len) => { break; },
+                (byte_pos >= input_len) => {
+                  break;
+                },
                 true => {
                   b := bytes.get(byte_pos).unwrap();
                   char_len := cond(
@@ -339,32 +335,31 @@ impl(Regex,
               );
             }
           );
-        };
+        });
       }
     );
-
     matches
   })
 );
-
 // Block 4: test, search (depends on Block 3)
-impl(Regex,
+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
+    match(
+      result,
+      .Some(m) =>.Some(m.index()),
+      .None =>.None
     )
   })
 );
-
 // Block 5: _apply_replacement helper (depends on Block 2)
-impl(Regex,
+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)({
@@ -372,13 +367,12 @@ impl(Regex,
     rep_len := rep_bytes.len();
     result := ArrayList(u8).new();
     i := usize(0);
-
-    while (i < rep_len), {
+    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();
+          next_b := rep_bytes.get(i + usize(1)).unwrap();
           cond(
             (next_b == u8(36)) => {
               // $$ → literal $
@@ -389,9 +383,9 @@ impl(Regex,
               // $& → full match
               match_bytes := m.value().as_bytes();
               mi := usize(0);
-              while (mi < match_bytes.len()), (mi = (mi + usize(1))), {
+              while(mi < match_bytes.len(), mi = (mi + usize(1)), {
                 result.push(match_bytes.get(mi).unwrap());
-              };
+              });
               i = (i + usize(2));
             },
             (next_b == u8(96)) => {
@@ -401,7 +395,7 @@ impl(Regex,
               char_idx := m.index();
               byte_idx := usize(0);
               ci := usize(0);
-              while (ci < char_idx), {
+              while(ci < char_idx, {
                 cb := input_bytes.get(byte_idx).unwrap();
                 cbl := cond(
                   (cb < u8(0x80)) => usize(1),
@@ -411,11 +405,11 @@ impl(Regex,
                 );
                 byte_idx = (byte_idx + cbl);
                 ci = (ci + usize(1));
-              };
+              });
               pi := usize(0);
-              while (pi < byte_idx), (pi = (pi + usize(1))), {
+              while(pi < byte_idx, pi = (pi + usize(1)), {
                 result.push(input_bytes.get(pi).unwrap());
-              };
+              });
               i = (i + usize(2));
             },
             (next_b == u8(39)) => {
@@ -425,7 +419,7 @@ impl(Regex,
               char_idx := m.index();
               byte_idx := usize(0);
               ci := usize(0);
-              while (ci < char_idx), {
+              while(ci < char_idx, {
                 cb := input_bytes.get(byte_idx).unwrap();
                 cbl := cond(
                   (cb < u8(0x80)) => usize(1),
@@ -435,27 +429,28 @@ impl(Regex,
                 );
                 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))), {
+              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)));
+              group_idx := usize(next_b - u8(48));
               grp := m.group(group_idx);
-              match(grp,
+              match(
+                grp,
                 .Some(g) => {
                   g_bytes := g.as_bytes();
                   gi := usize(0);
-                  while (gi < g_bytes.len()), (gi = (gi + usize(1))), {
+                  while(gi < g_bytes.len(), gi = (gi + usize(1)), {
                     result.push(g_bytes.get(gi).unwrap());
-                  };
+                  });
                 },
                 .None => ()
               );
@@ -466,7 +461,7 @@ impl(Regex,
               name_start := (i + usize(2));
               (name_end : usize) = name_start;
               (found_close : bool) = false;
-              while (name_end < rep_len), {
+              while(name_end < rep_len, {
                 nb := rep_bytes.get(name_end).unwrap();
                 cond(
                   (nb == u8(125)) => {
@@ -477,23 +472,24 @@ impl(Regex,
                     name_end = (name_end + usize(1));
                   }
                 );
-              };
+              });
               cond(
                 found_close => {
-                  name_bytes := ArrayList(u8).with_capacity((name_end - name_start));
+                  name_bytes := ArrayList(u8).with_capacity(name_end - name_start);
                   ni := name_start;
-                  while (ni < name_end), (ni = (ni + usize(1))), {
+                  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,
+                  match(
+                    grp,
                     .Some(g) => {
                       g_bytes := g.as_bytes();
                       gi := usize(0);
-                      while (gi < g_bytes.len()), (gi = (gi + usize(1))), {
+                      while(gi < g_bytes.len(), gi = (gi + usize(1)), {
                         result.push(g_bytes.get(gi).unwrap());
-                      };
+                      });
                     },
                     .None => ()
                   );
@@ -518,17 +514,17 @@ impl(Regex,
           i = (i + usize(1));
         }
       );
-    };
-
+    });
     String.from_bytes(result)
   })
 );
-
 // Block 6: replace, replace_all, split (depends on Block 3+5)
-impl(Regex,
+impl(
+  Regex,
   replace : (fn(self : Self, input : String, replacement : String) -> String)({
     result := self.exec(input);
-    match(result,
+    match(
+      result,
       .None => input,
       .Some(m) => {
         input_bytes := input.as_bytes();
@@ -536,7 +532,7 @@ impl(Regex,
         char_idx := m.index();
         (match_start_byte : usize) = usize(0);
         ci := usize(0);
-        while (ci < char_idx), {
+        while(ci < char_idx, {
           cb := input_bytes.get(match_start_byte).unwrap();
           cbl := cond(
             (cb < u8(0x80)) => usize(1),
@@ -546,30 +542,28 @@ impl(Regex,
           );
           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))), {
+        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))), {
+        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))), {
+        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(
@@ -578,15 +572,14 @@ impl(Regex,
         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))), {
+        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), {
+          while(ci < char_idx, {
             cb := input_bytes.get(match_start_byte).unwrap();
             cbl := cond(
               (cb < u8(0x80)) => usize(1),
@@ -596,41 +589,34 @@ impl(Regex,
             );
             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))), {
+          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))), {
+          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))), {
+        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);
@@ -638,15 +624,14 @@ impl(Regex,
       true => {
         input_bytes := input.as_bytes();
         (last_end_byte : usize) = usize(0);
-
         mi := usize(0);
-        while (mi < all_matches.len()), (mi = (mi + usize(1))), {
+        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), {
+          while(ci < char_idx, {
             cb := input_bytes.get(match_start_byte).unwrap();
             cbl := cond(
               (cb < u8(0x80)) => usize(1),
@@ -656,46 +641,45 @@ impl(Regex,
             );
             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))), {
+          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))), {
+          while(gi <= m.group_count(), gi = (gi + usize(1)), {
             grp := m.group(gi);
-            match(grp,
-              .Some(g) => { parts.push(g); },
-              .None => { parts.push(`undefined`); }
+            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))), {
+        while(pi < input_bytes.len(), pi = (pi + usize(1)), {
           remaining.push(input_bytes.get(pi).unwrap());
-        };
+        });
         parts.push(String.from_bytes(remaining));
       }
     );
-
     parts
   })
 );
-
-export
+export(
   Regex,
   RegexMatch,
   RegexFlags
-;
+);