@shd101wyy/yo 0.1.25 → 0.1.27

package/std/regex/vm.yo

@@ -3,72 +3,65 @@
 //! Executes a compiled NFA program against an input string.
 //! Uses Thompson's NFA simulation with parallel state tracking
 //! for O(n×m) worst-case time complexity.
-
-open import "std/collections/array_list";
-open import "std/string";
-{ NfaProgram, Instr, InstrKind, ClassEntry, GroupNameEntry } :: import "./compiler.yo";
-{ CharRange } :: import "./node.yo";
-{ RegexFlags } :: import "./flags.yo";
-
+open(import("std/collections/array_list"));
+open(import("std/string"));
+{ NfaProgram, Instr, InstrKind, ClassEntry, GroupNameEntry } :: import("./compiler.yo");
+{ CharRange } :: import("./node.yo");
+{ RegexFlags } :: import("./flags.yo");
 // Max number of capture slots (group 0 + up to 99 groups = 200 slots)
 MAX_SLOTS :: 200;
-
 // A single NFA thread: an instruction pointer + capture slots
 NfaThread :: object(
-  pc    : usize,
+  pc : usize,
   slots : ArrayList(usize)
 );
-
-impl(NfaThread,
+impl(
+  NfaThread,
   new : (fn(pc : usize, n_slots : usize) -> Self)({
     s := ArrayList(usize).with_capacity(n_slots);
     // usize.MAX = 0xFF..FF, so memset with 0xFF fills each byte
     s.resize_with_byte(n_slots, int(255));
-    Self(pc: pc, slots: s)
+    Self(pc : pc, slots : s)
   }),
-
   // Clone a thread with a new PC
   fork : (fn(self : Self, new_pc : usize) -> Self)({
     new_slots := ArrayList(usize).with_capacity(self.slots.len());
-    match(self.slots.ptr(),
+    match(
+      self.slots.ptr(),
       .Some(src) => new_slots.extend_from_ptr(src, self.slots.len()),
       .None => ()
     );
-    Self(pc: new_pc, slots: new_slots)
+    Self(pc : new_pc, slots : new_slots)
   })
 );
-
 // VM execution result
 VmMatch :: struct(
   matched : bool,
-  slots   : ArrayList(usize)
+  slots : ArrayList(usize)
 );
-
 // Helper struct for decoded characters
 DecodedChar :: struct(
   codepoint : u32,
-  byte_len  : usize
+  byte_len : usize
 );
-
 // A thread deferred to a future byte position (for multi-byte backrefs)
 DeferredThread :: struct(
   target_byte_pos : usize,
   thread : NfaThread
 );
-
 // The NFA virtual machine
 NfaVm :: object(
-  _program   : NfaProgram,
-  _flags     : RegexFlags,
-  _input     : String,
-  _bytes     : ArrayList(u8),
-  _n_slots   : usize,
-  _seen      : ArrayList(bool),
+  _program : NfaProgram,
+  _flags : RegexFlags,
+  _input : String,
+  _bytes : ArrayList(u8),
+  _n_slots : usize,
+  _seen : ArrayList(bool),
   _next_seen : ArrayList(bool)
 );
-
 // Block 1: Constructor and leaf helpers (no method dependencies)
-impl(NfaVm,
+impl(
+  NfaVm,
   new : (fn(program : NfaProgram, flags : RegexFlags, input : String) -> Self)({
     n_slots := ((program.n_groups + usize(1)) * usize(2));
     n_instr := program.instructions.len();
@@ -77,88 +70,84 @@ impl(NfaVm,
     next_seen := ArrayList(bool).with_capacity(n_instr);
     next_seen.resize_with_byte(n_instr, int(0));
     Self(
-      _program: program,
-      _flags: flags,
-      _input: input,
-      _bytes: input.as_bytes(),
-      _n_slots: n_slots,
-      _seen: seen,
-      _next_seen: next_seen
+      _program : program,
+      _flags : flags,
+      _input : input,
+      _bytes : input.as_bytes(),
+      _n_slots : n_slots,
+      _seen : seen,
+      _next_seen : next_seen
     )
   }),
-
   _decode_codepoint : (fn(self : Self, pos : usize) -> DecodedChar)({
     first := self._bytes.get(pos).unwrap();
     cond(
       (first < u8(0x80)) =>
-        DecodedChar(codepoint: u32(first), byte_len: usize(1)),
+        DecodedChar(codepoint : u32(first), byte_len : usize(1)),
       ((first >= u8(0xC0)) && (first < u8(0xE0))) => {
-        second := self._bytes.get((pos + usize(1))).unwrap();
+        second := self._bytes.get(pos + usize(1)).unwrap();
         cp := (((u32(first) & u32(0x1F)) << u32(6)) | (u32(second) & u32(0x3F)));
-        DecodedChar(codepoint: cp, byte_len: usize(2))
+        DecodedChar(codepoint : cp, byte_len : usize(2))
       },
       ((first >= u8(0xE0)) && (first < u8(0xF0))) => {
-        second := self._bytes.get((pos + usize(1))).unwrap();
-        third := self._bytes.get((pos + usize(2))).unwrap();
+        second := self._bytes.get(pos + usize(1)).unwrap();
+        third := self._bytes.get(pos + usize(2)).unwrap();
         cp := ((((u32(first) & u32(0x0F)) << u32(12)) | ((u32(second) & u32(0x3F)) << u32(6))) | (u32(third) & u32(0x3F)));
-        DecodedChar(codepoint: cp, byte_len: usize(3))
+        DecodedChar(codepoint : cp, byte_len : usize(3))
       },
       true => {
-        second := self._bytes.get((pos + usize(1))).unwrap();
-        third := self._bytes.get((pos + usize(2))).unwrap();
-        fourth := self._bytes.get((pos + usize(3))).unwrap();
+        second := self._bytes.get(pos + usize(1)).unwrap();
+        third := self._bytes.get(pos + usize(2)).unwrap();
+        fourth := self._bytes.get(pos + usize(3)).unwrap();
         cp := (((((u32(first) & u32(0x07)) << u32(18)) | ((u32(second) & u32(0x3F)) << u32(12))) | ((u32(third) & u32(0x3F)) << u32(6))) | (u32(fourth) & u32(0x3F)));
-        DecodedChar(codepoint: cp, byte_len: usize(4))
+        DecodedChar(codepoint : cp, byte_len : usize(4))
       }
     )
   }),
-
   _to_lower : (fn(self : Self, cp : u32) -> u32)(
     cond(
       ((cp >= u32(65)) && (cp <= u32(90))) => (cp + u32(32)),
       true => cp
     )
   ),
-
   _is_word_char : (fn(self : Self, cp : u32) -> bool)(
-    ((((cp >= u32(48)) && (cp <= u32(57))) || ((cp >= u32(65)) && (cp <= u32(90)))) || (((cp >= u32(97)) && (cp <= u32(122))) || (cp == u32(95))))
+    (((cp >= u32(48)) && (cp <= u32(57))) || ((cp >= u32(65)) && (cp <= u32(90)))) || (((cp >= u32(97)) && (cp <= u32(122))) || (cp == u32(95)))
   ),
-
   _find_prev_char_start : (fn(self : Self, pos : usize) -> usize)({
     p := (pos - usize(1));
-    while (p > usize(0)), (p = (p - usize(1))), {
+    while(p > usize(0), p = (p - usize(1)), {
       b := self._bytes.get(p).unwrap();
       cond(
-        ((b < u8(0x80)) || (b >= u8(0xC0))) => { return p; },
+        ((b < u8(0x80)) || (b >= u8(0xC0))) => {
+          return(p);
+        },
         true => ()
       );
-    };
+    });
     p
   }),
-
   _prev_byte_is_newline : (fn(self : Self, pos : usize) -> bool)(
     cond(
       (pos == usize(0)) => false,
       true => {
-        b := self._bytes.get((pos - usize(1))).unwrap();
-        (b == u8(10))
+        b := self._bytes.get(pos - usize(1)).unwrap();
+        b == u8(10)
       }
     )
   ),
-
   _cur_byte_is_newline : (fn(self : Self, pos : usize) -> bool)(
     cond(
       (pos >= self._bytes.len()) => false,
       true => {
         b := self._bytes.get(pos).unwrap();
-        (b == u8(10))
+        b == u8(10)
       }
     )
   )
 );
-
 // Block 2: Methods that depend on Block 1
-impl(NfaVm,
+impl(
+  NfaVm,
   _char_matches : (fn(self : Self, expected : u32, actual : u32) -> bool)(
     cond(
       (expected == actual) => true,
@@ -166,16 +155,14 @@ impl(NfaVm,
       true => false
     )
   ),
-
   _codepoint_in_class : (fn(self : Self, cp : u32, cls : ClassEntry) -> bool)({
     check_cp := cond(
       self._flags.ignore_case => self._to_lower(cp),
       true => cp
     );
-
     (found : bool) = false;
     i := usize(0);
-    while ((i < cls.ranges.len()) && (!(found))), (i = (i + usize(1))), {
+    while((i < cls.ranges.len()) && (!(found)), i = (i + usize(1)), {
       r := cls.ranges.get(i).unwrap();
       (low : u32) = cond(
         self._flags.ignore_case => self._to_lower(r.low),
@@ -186,31 +173,32 @@ impl(NfaVm,
         true => r.high
       );
       cond(
-        ((check_cp >= low) && (check_cp <= high)) => { found = true; },
+        ((check_cp >= low) && (check_cp <= high)) => {
+          found = true;
+        },
         true => ()
       );
-    };
-
+    });
     cond(
       ((!(found)) && self._flags.ignore_case) => {
         i2 := usize(0);
-        while ((i2 < cls.ranges.len()) && (!(found))), (i2 = (i2 + usize(1))), {
+        while((i2 < cls.ranges.len()) && (!(found)), i2 = (i2 + usize(1)), {
           r := cls.ranges.get(i2).unwrap();
           cond(
-            ((cp >= r.low) && (cp <= r.high)) => { found = true; },
+            ((cp >= r.low) && (cp <= r.high)) => {
+              found = true;
+            },
             true => ()
           );
-        };
+        });
       },
       true => ()
     );
-
     cond(
       cls.negated => (!(found)),
       true => found
     )
   }),
-
   _is_word_boundary : (fn(self : Self, pos : usize) -> bool)({
     left_is_word := cond(
       (pos == usize(0)) => false,
@@ -227,29 +215,31 @@ impl(NfaVm,
         self._is_word_char(cur.codepoint)
       }
     );
-    (left_is_word != right_is_word)
+    left_is_word != right_is_word
   })
 );
-
 // Block 3: _add_thread (recursive, depends on Block 1+2)
-impl(NfaVm,
+impl(
+  NfaVm,
   _add_thread : (fn(self : Self, list : *(ArrayList(NfaThread)), thread : NfaThread, byte_pos : usize, seen : *(ArrayList(bool))) -> unit)({
     cond(
-      (thread.pc >= self._program.instructions.len()) => { return (); },
+      (thread.pc >= self._program.instructions.len()) => {
+        return(());
+      },
       true => ()
     );
-
     // Already checked bounds above: thread.pc < instructions.len()
     is_seen := (seen.*)(thread.pc);
     cond(
-      is_seen => { return (); },
+      is_seen => {
+        return(());
+      },
       true => ()
     );
     &((seen.*)(thread.pc)).* = true;
-
     instr := self._program.instructions(thread.pc);
-
-    match(instr.kind,
+    match(
+      instr.kind,
       .Split => {
         t1 := thread.fork(instr.target_a);
         t2 := thread.fork(instr.target_b);
@@ -267,7 +257,7 @@ impl(NfaVm,
           },
           true => ()
         );
-        new_t := NfaThread(pc: (thread.pc + usize(1)), slots: thread.slots);
+        new_t := NfaThread(pc : (thread.pc + usize(1)), slots : thread.slots);
         recur(self, list, new_t, byte_pos, seen);
       },
       .AssertStart => {
@@ -278,7 +268,7 @@ impl(NfaVm,
         );
         cond(
           passes => {
-            new_t := thread.fork((thread.pc + usize(1)));
+            new_t := thread.fork(thread.pc + usize(1));
             recur(self, list, new_t, byte_pos, seen);
           },
           true => ()
@@ -292,7 +282,7 @@ impl(NfaVm,
         );
         cond(
           passes => {
-            new_t := thread.fork((thread.pc + usize(1)));
+            new_t := thread.fork(thread.pc + usize(1));
             recur(self, list, new_t, byte_pos, seen);
           },
           true => ()
@@ -301,7 +291,7 @@ impl(NfaVm,
       .AssertWordBoundary => {
         cond(
           self._is_word_boundary(byte_pos) => {
-            new_t := thread.fork((thread.pc + usize(1)));
+            new_t := thread.fork(thread.pc + usize(1));
             recur(self, list, new_t, byte_pos, seen);
           },
           true => ()
@@ -310,7 +300,7 @@ impl(NfaVm,
       .AssertNonWordBoundary => {
         cond(
           (!(self._is_word_boundary(byte_pos))) => {
-            new_t := thread.fork((thread.pc + usize(1)));
+            new_t := thread.fork(thread.pc + usize(1));
             recur(self, list, new_t, byte_pos, seen);
           },
           true => ()
@@ -322,77 +312,79 @@ impl(NfaVm,
     );
   })
 );
-
 // Block 4: Sub-VM for lookahead/lookbehind (depends on Block 1+2+3)
-impl(NfaVm,
+impl(
+  NfaVm,
   // Run a sub-VM starting at sub_start_pc from start_byte.
   // If required_end is not UNSET, only succeed when Match is found at exactly required_end.
   _run_sub_vm : (fn(self : Self, sub_start_pc : usize, start_byte : usize, required_end : usize) -> bool)({
     unset := usize.MAX;
     sub_current := ArrayList(NfaThread).new();
     sub_next := ArrayList(NfaThread).new();
-
     sub_seen := ArrayList(bool).with_capacity(self._program.instructions.len());
     sub_seen.resize_with_byte(self._program.instructions.len(), int(0));
-
     initial := NfaThread.new(sub_start_pc, self._n_slots);
     self._add_thread(&(sub_current), initial, start_byte, &(sub_seen));
-
     sub_pos := start_byte;
     input_len := self._bytes.len();
-
-    while (sub_pos <= input_len), {
+    while(sub_pos <= input_len, {
       cond(
-        (sub_current.len() == usize(0)) => { break; },
+        (sub_current.len() == usize(0)) => {
+          break;
+        },
         true => ()
       );
-
       // Check for Match in current threads
       st := usize(0);
-      while (st < sub_current.len()), (st = (st + usize(1))), {
+      while(st < sub_current.len(), st = (st + usize(1)), {
         st_thread := sub_current.get(st).unwrap();
         st_instr := self._program.instructions.get(st_thread.pc).unwrap();
-        match(st_instr.kind,
+        match(
+          st_instr.kind,
           .Match => {
             cond(
-              (required_end == unset) => { return true; },
-              (sub_pos == required_end) => { return true; },
+              (required_end == unset) => {
+                return(true);
+              },
+              (sub_pos == required_end) => {
+                return(true);
+              },
               true => ()
             );
           },
           _ => ()
         );
-      };
-
+      });
       cond(
-        (sub_pos >= input_len) => { break; },
+        (sub_pos >= input_len) => {
+          break;
+        },
         true => ()
       );
-
       // Stop if we've passed the required end position
       cond(
-        ((required_end != unset) && (sub_pos > required_end)) => { break; },
+        ((required_end != unset) && (sub_pos > required_end)) => {
+          break;
+        },
         true => ()
       );
-
       decoded := self._decode_codepoint(sub_pos);
       sub_cp := decoded.codepoint;
       sub_blen := decoded.byte_len;
-
       // Clear seen
       sub_seen.fill_with_byte(int(0));
-
       // Process consuming instructions
       st2 := usize(0);
-      while (st2 < sub_current.len()), (st2 = (st2 + usize(1))), {
+      while(st2 < sub_current.len(), st2 = (st2 + usize(1)), {
         st_thread := sub_current.get(st2).unwrap();
         st_instr := self._program.instructions.get(st_thread.pc).unwrap();
-        match(st_instr.kind,
+        match(
+          st_instr.kind,
           .Char => {
             cond(
               self._char_matches(st_instr.codepoint, sub_cp) => {
-                new_t := st_thread.fork((st_thread.pc + usize(1)));
-                self._add_thread(&(sub_next), new_t, (sub_pos + sub_blen), &(sub_seen));
+                new_t := st_thread.fork(st_thread.pc + usize(1));
+                self._add_thread(&(sub_next), new_t, sub_pos + sub_blen, &(sub_seen));
               },
               true => ()
             );
@@ -404,20 +396,21 @@ impl(NfaVm,
             );
             cond(
               should_match => {
-                new_t := st_thread.fork((st_thread.pc + usize(1)));
-                self._add_thread(&(sub_next), new_t, (sub_pos + sub_blen), &(sub_seen));
+                new_t := st_thread.fork(st_thread.pc + usize(1));
+                self._add_thread(&(sub_next), new_t, sub_pos + sub_blen, &(sub_seen));
               },
               true => ()
             );
           },
           .CharClass => {
             class_opt := self._program.classes.get(st_instr.class_idx);
-            match(class_opt,
+            match(
+              class_opt,
               .Some(cls) => {
                 cond(
                   self._codepoint_in_class(sub_cp, cls) => {
-                    new_t := st_thread.fork((st_thread.pc + usize(1)));
-                    self._add_thread(&(sub_next), new_t, (sub_pos + sub_blen), &(sub_seen));
+                    new_t := st_thread.fork(st_thread.pc + usize(1));
+                    self._add_thread(&(sub_next), new_t, sub_pos + sub_blen, &(sub_seen));
                   },
                   true => ()
                 );
@@ -427,22 +420,20 @@ impl(NfaVm,
           },
           _ => ()
         );
-      };
-
+      });
       // Swap sub_current/sub_next and clear for reuse
       tmp_sub := sub_current;
       sub_current = sub_next;
       sub_next = tmp_sub;
       sub_next.clear();
       sub_pos = (sub_pos + sub_blen);
-    };
-
+    });
     false
   })
 );
-
 // Block 5: exec_at (depends on Block 1+2+3+4)
-impl(NfaVm,
+impl(
+  NfaVm,
   exec_at : (fn(self : Self, start_byte : usize) -> VmMatch)({
     // Reuse pre-allocated seen buffers from the VM
     current := ArrayList(NfaThread).new();
@@ -450,24 +441,19 @@ impl(NfaVm,
     seen := self._seen;
     next_seen := self._next_seen;
     deferred := ArrayList(DeferredThread).new();
-
     // Clear for this execution
     seen.fill_with_byte(int(0));
     next_seen.fill_with_byte(int(0));
-
     initial := NfaThread.new(usize(0), self._n_slots);
     self._add_thread(&(current), initial, start_byte, &(seen));
-
-    best_match := VmMatch(matched: false, slots: ArrayList(usize).new());
+    best_match := VmMatch(matched : false, slots : ArrayList(usize).new());
     byte_pos := start_byte;
     input_len := self._bytes.len();
     unset := usize.MAX;
-
-    while (byte_pos <= input_len), {
+    while(byte_pos <= input_len, {
       (cur_cp : u32) = u32(0);
       (char_byte_len : usize) = usize(0);
       (at_end : bool) = (byte_pos >= input_len);
-
       cond(
         (!(at_end)) => {
           decoded := self._decode_codepoint(byte_pos);
@@ -476,15 +462,13 @@ impl(NfaVm,
         },
         true => ()
       );
-
       // Clear seen flags for this generation using memset
       seen.fill_with_byte(int(0));
       next_seen.fill_with_byte(int(0));
-
       // Process deferred threads targeting this byte_pos
       new_deferred := ArrayList(DeferredThread).new();
       di := usize(0);
-      while (di < deferred.len()), (di = (di + usize(1))), {
+      while(di < deferred.len(), di = (di + usize(1)), {
         d := deferred.get(di).unwrap();
         cond(
           (d.target_byte_pos == byte_pos) => {
@@ -494,28 +478,28 @@ impl(NfaVm,
             new_deferred.push(d);
           }
         );
-      };
+      });
       deferred = new_deferred;
-
       // Break if no threads and no deferred
       cond(
-        ((current.len() == usize(0)) && (deferred.len() == usize(0))) => { break; },
+        ((current.len() == usize(0)) && (deferred.len() == usize(0))) => {
+          break;
+        },
         true => ()
       );
-
       // Process each thread (priority order — first match wins in gen)
       (found_match_in_gen : bool) = false;
       t := usize(0);
-      while ((t < current.len()) && (!(found_match_in_gen))), (t = (t + usize(1))), {
+      while((t < current.len()) && (!(found_match_in_gen)), t = (t + usize(1)), {
         thread := current.get(t).unwrap();
         instr := self._program.instructions.get(thread.pc).unwrap();
-
-        match(instr.kind,
+        match(
+          instr.kind,
           .Char => {
             cond(
               ((!(at_end)) && (self._char_matches(instr.codepoint, cur_cp))) => {
-                new_thread := thread.fork((thread.pc + usize(1)));
-                self._add_thread(&(next), new_thread, (byte_pos + char_byte_len), &(next_seen));
+                new_thread := thread.fork(thread.pc + usize(1));
+                self._add_thread(&(next), new_thread, byte_pos + char_byte_len, &(next_seen));
               },
               true => ()
             );
@@ -529,8 +513,8 @@ impl(NfaVm,
                 );
                 cond(
                   should_match => {
-                    new_thread := thread.fork((thread.pc + usize(1)));
-                    self._add_thread(&(next), new_thread, (byte_pos + char_byte_len), &(next_seen));
+                    new_thread := thread.fork(thread.pc + usize(1));
+                    self._add_thread(&(next), new_thread, byte_pos + char_byte_len, &(next_seen));
                   },
                   true => ()
                 );
@@ -542,12 +526,13 @@ impl(NfaVm,
             cond(
               (!(at_end)) => {
                 class_opt := self._program.classes.get(instr.class_idx);
-                match(class_opt,
+                match(
+                  class_opt,
                   .Some(cls) => {
                     cond(
                       self._codepoint_in_class(cur_cp, cls) => {
-                        new_thread := thread.fork((thread.pc + usize(1)));
-                        self._add_thread(&(next), new_thread, (byte_pos + char_byte_len), &(next_seen));
+                        new_thread := thread.fork(thread.pc + usize(1));
+                        self._add_thread(&(next), new_thread, byte_pos + char_byte_len, &(next_seen));
                       },
                       true => ()
                     );
@@ -573,9 +558,9 @@ impl(NfaVm,
                         // Compare captured bytes against input at current position
                         (bytes_match : bool) = true;
                         bi := usize(0);
-                        while (bi < captured_len), (bi = (bi + usize(1))), {
-                          expected := self._bytes.get((gs + bi)).unwrap();
-                          actual := self._bytes.get((byte_pos + bi)).unwrap();
+                        while(bi < captured_len, bi = (bi + usize(1)), {
+                          expected := self._bytes.get(gs + bi).unwrap();
+                          actual := self._bytes.get(byte_pos + bi).unwrap();
                           cond(
                             self._flags.ignore_case => {
                               el := cond(
@@ -587,22 +572,26 @@ impl(NfaVm,
                                 true => actual
                               );
                               cond(
-                                (el != al) => { bytes_match = false; },
+                                (el != al) => {
+                                  bytes_match = false;
+                                },
                                 true => ()
                               );
                             },
                             true => {
                               cond(
-                                (expected != actual) => { bytes_match = false; },
+                                (expected != actual) => {
+                                  bytes_match = false;
+                                },
                                 true => ()
                               );
                             }
                           );
-                        };
+                        });
                         cond(
                           bytes_match => {
                             new_pos := (byte_pos + captured_len);
-                            new_thread := thread.fork((thread.pc + usize(1)));
+                            new_thread := thread.fork(thread.pc + usize(1));
                             cond(
                               (captured_len == usize(0)) => {
                                 // Empty capture — epsilon-like, process in current gen
@@ -610,7 +599,7 @@ impl(NfaVm,
                               },
                               true => {
                                 // Defer to the target byte position
-                                deferred.push(DeferredThread(target_byte_pos: new_pos, thread: new_thread));
+                                deferred.push(DeferredThread(target_byte_pos : new_pos, thread : new_thread));
                               }
                             );
                           },
@@ -645,7 +634,6 @@ impl(NfaVm,
             sub_start := instr.target_a;
             positive := (instr.slot == usize(1));
             (lb_matched : bool) = false;
-
             // Try each byte position backwards from byte_pos
             cond(
               (byte_pos == usize(0)) => {
@@ -660,7 +648,7 @@ impl(NfaVm,
               true => {
                 // Try from byte_pos backwards to 0
                 (try_pos : usize) = byte_pos;
-                while (!(lb_matched)), {
+                while(!(lb_matched), {
                   cond(
                     (try_pos == usize(0)) => {
                       cond(
@@ -677,10 +665,10 @@ impl(NfaVm,
                       cond(
                         (try_pos > usize(0)) => {
                           tb := self._bytes.get(try_pos).unwrap();
-                          while (((tb >= u8(0x80)) && (tb < u8(0xC0))) && (try_pos > usize(0))), {
+                          while(((tb >= u8(0x80)) && (tb < u8(0xC0))) && (try_pos > usize(0)), {
                             try_pos = (try_pos - usize(1));
                             tb = self._bytes.get(try_pos).unwrap();
-                          };
+                          });
                         },
                         true => ()
                       );
@@ -692,10 +680,9 @@ impl(NfaVm,
                       );
                     }
                   );
-                };
+                });
               }
             );
-
             cond(
               (lb_matched == positive) => {
                 sub_end := instr.target_b;
@@ -707,38 +694,35 @@ impl(NfaVm,
           },
           .Match => {
             // Record match and kill lower-priority threads
-            best_match = VmMatch(matched: true, slots: thread.slots);
+            best_match = VmMatch(matched : true, slots : thread.slots);
             found_match_in_gen = true;
           },
           _ => ()
         );
-      };
-
+      });
       // Swap current/next and clear for reuse
       tmp_c := current;
       current = next;
       next = tmp_c;
       next.clear();
-
       cond(
-        at_end => { break; },
+        at_end => {
+          break;
+        },
         true => {
           byte_pos = (byte_pos + char_byte_len);
         }
       );
-    };
-
+    });
     // Store seen buffers back for reuse in next exec_at call
     self._seen = seen;
     self._next_seen = next_seen;
-
     best_match
   })
 );
-
-export
+export(
   NfaVm,
   NfaThread,
   VmMatch,
   DecodedChar
-;
+);