@shd101wyy/yo 0.1.5 → 0.1.7

package/std/process.yo

@@ -66,7 +66,7 @@ extern "Yo",
 // The first element is the program name
 // Example: ["./program", "arg1", "arg2"]
 raw_args :: (fn() -> [*(u8)]) {
-  return __yo_args(:);
+  return __yo_args;
 };
 export raw_args;
 

package/std/regex/compiler.yo

@@ -183,14 +183,14 @@ impl(NfaCompiler,
         right := node.children.get(usize(1)).unwrap();
         split_pc := self._emit(Instr.split_instr(usize(0), usize(0)));
         left_start := self._current_pc();
-        self._program.instructions.set(split_pc, Instr.split_instr(left_start, usize(0)));
+        &(self._program.instructions(split_pc)).* = Instr.split_instr(left_start, usize(0));
         recur(self, left);
         jump_pc := self._emit(Instr.jump_instr(usize(0)));
         right_start := self._current_pc();
-        self._program.instructions.set(split_pc, Instr.split_instr(left_start, right_start));
+        &(self._program.instructions(split_pc)).* = Instr.split_instr(left_start, right_start);
         recur(self, right);
         end_pc := self._current_pc();
-        self._program.instructions.set(jump_pc, Instr.jump_instr(end_pc));
+        &(self._program.instructions(jump_pc)).* = Instr.jump_instr(end_pc);
       },
       .Quantifier => {
         child := node.children.get(usize(0)).unwrap();
@@ -217,10 +217,10 @@ impl(NfaCompiler,
             l3 := self._current_pc();
             cond(
               greedy => {
-                self._program.instructions.set(split_pc, Instr.split_instr(l2, l3));
+                &(self._program.instructions(split_pc)).* = Instr.split_instr(l2, l3);
               },
               true => {
-                self._program.instructions.set(split_pc, Instr.split_instr(l3, l2));
+                &(self._program.instructions(split_pc)).* = Instr.split_instr(l3, l2);
               }
             );
           },
@@ -230,10 +230,10 @@ impl(NfaCompiler,
             l2 := self._current_pc();
             cond(
               greedy => {
-                self._program.instructions.set(split_pc, Instr.split_instr(last_body_start, l2));
+                &(self._program.instructions(split_pc)).* = Instr.split_instr(last_body_start, l2);
               },
               true => {
-                self._program.instructions.set(split_pc, Instr.split_instr(l2, last_body_start));
+                &(self._program.instructions(split_pc)).* = Instr.split_instr(l2, last_body_start);
               }
             );
           },
@@ -248,10 +248,10 @@ impl(NfaCompiler,
               after := self._current_pc();
               cond(
                 greedy => {
-                  self._program.instructions.set(split_pc, Instr.split_instr(body_start, after));
+                  &(self._program.instructions(split_pc)).* = Instr.split_instr(body_start, after);
                 },
                 true => {
-                  self._program.instructions.set(split_pc, Instr.split_instr(after, body_start));
+                  &(self._program.instructions(split_pc)).* = Instr.split_instr(after, body_start);
                 }
               );
             };
@@ -282,7 +282,7 @@ impl(NfaCompiler,
         recur(self, child);
         self._emit(Instr.match_instr());
         sub_end := self._current_pc();
-        self._program.instructions.set(la_pc, Instr.lookahead_instr(sub_start, sub_end, positive));
+        &(self._program.instructions(la_pc)).* = Instr.lookahead_instr(sub_start, sub_end, positive);
       },
       .Lookbehind => {
         child := node.children.get(usize(0)).unwrap();
@@ -292,7 +292,7 @@ impl(NfaCompiler,
         recur(self, child);
         self._emit(Instr.match_instr());
         sub_end := self._current_pc();
-        self._program.instructions.set(lb_pc, Instr.lookbehind_instr(sub_start, sub_end, positive));
+        &(self._program.instructions(lb_pc)).* = Instr.lookbehind_instr(sub_start, sub_end, positive);
       }
     );
   })

package/std/regex/index.yo

@@ -186,11 +186,11 @@ 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 => {
-        vm := NfaVm.new(self._program, self._flags, input);
         result := vm.exec_at(usize(0));
         cond(
           result.matched => .Some(self._build_match(result.slots, input)),
@@ -205,7 +205,6 @@ impl(Regex,
         );
 
         while (byte_pos <= input_len), {
-          vm := NfaVm.new(self._program, self._flags, input);
           result := vm.exec_at(byte_pos);
 
           cond(
@@ -244,13 +243,13 @@ impl(Regex,
     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), {
-          vm := NfaVm.new(self._program, self._flags, input);
           result := vm.exec_at(byte_pos);
 
           cond(
@@ -293,7 +292,6 @@ impl(Regex,
         );
 
         while (byte_pos <= input_len), {
-          vm := NfaVm.new(self._program, self._flags, input);
           result := vm.exec_at(byte_pos);
 
           cond(

package/std/regex/parser.yo

@@ -189,6 +189,27 @@ impl(RegexParser,
     r
   }),
 
+  // Parse \xHH hex escape — reads exactly 2 hex digits and returns the codepoint.
+  _parse_hex_byte : (fn(self : Self) -> Option(u32))({
+    if(((self._pos + usize(2)) > self._bytes.len()), { return .None; });
+    (h1 : u8) = self._bytes.get(self._pos).unwrap();
+    (h2 : u8) = self._bytes.get((self._pos + usize(1))).unwrap();
+    (v1 : i32) = cond(
+      ((h1 >= u8(48)) && (h1 <= u8(57))) => (i32(h1) - i32(48)),
+      ((h1 >= u8(65)) && (h1 <= u8(70))) => ((i32(h1) - i32(65)) + i32(10)),
+      ((h1 >= u8(97)) && (h1 <= u8(102))) => ((i32(h1) - i32(97)) + i32(10)),
+      true => { return .None; }
+    );
+    (v2 : i32) = cond(
+      ((h2 >= u8(48)) && (h2 <= u8(57))) => (i32(h2) - i32(48)),
+      ((h2 >= u8(65)) && (h2 <= u8(70))) => ((i32(h2) - i32(65)) + i32(10)),
+      ((h2 >= u8(97)) && (h2 <= u8(102))) => ((i32(h2) - i32(97)) + i32(10)),
+      true => { return .None; }
+    );
+    self._pos = (self._pos + usize(2));
+    .Some(u32(((v1 << i32(4)) | v2)))
+  }),
+
   _parse_class_escape : (fn(self : Self) -> Result(ArrayList(CharRange), String))({
     b := self._advance();
     match(b,
@@ -219,6 +240,14 @@ impl(RegexParser,
             r.push(CharRange(low: u32(33), high: u32(0x10FFFF)));
             .Ok(r)
           },
+          (ch == u8(120)) => {
+            r := ArrayList(CharRange).new();
+            match(self._parse_hex_byte(),
+              .Some(v) => r.push(CharRange(low: v, high: v)),
+              .None => r.push(CharRange(low: u32(ch), high: u32(ch)))
+            );
+            .Ok(r)
+          },
           true => {
             r := ArrayList(CharRange).new();
             codepoint := self._escape_char_codepoint(ch);
@@ -246,6 +275,31 @@ impl(RegexParser,
               (end_first == u8(93)) => {
                 ranges.push(CharRange(low: low, high: low));
               },
+              (end_first == u8(92)) => {
+                // High end is an escape sequence (e.g. \x20, \0, \n)
+                self._pos = (self._pos + usize(1));
+                self._pos = (self._pos + usize(1));
+                esc := self._parse_class_escape();
+                match(esc,
+                  .Ok(esc_ranges) => {
+                    if(((esc_ranges.len() == usize(1)) && (esc_ranges.get(usize(0)).unwrap().low == esc_ranges.get(usize(0)).unwrap().high)), {
+                      (high : u32) = esc_ranges.get(usize(0)).unwrap().low;
+                      ranges.push(CharRange(low: low, high: high));
+                    }, {
+                      // Multi-range escape like \d can't be range endpoint; treat dash as literal
+                      ranges.push(CharRange(low: low, high: low));
+                      ranges.push(CharRange(low: u32(45), high: u32(45)));
+                      j := usize(0);
+                      while (j < esc_ranges.len()), (j = (j + usize(1))), {
+                        ranges.push(esc_ranges.get(j).unwrap());
+                      };
+                    });
+                  },
+                  .Err(_e) => {
+                    ranges.push(CharRange(low: low, high: low));
+                  }
+                );
+              },
               true => {
                 // Consume dash
                 self._pos = (self._pos + usize(1));
@@ -284,10 +338,16 @@ impl(RegexParser,
         esc := self._parse_class_escape();
         match(esc,
           .Ok(esc_ranges) => {
-            j := usize(0);
-            while (j < esc_ranges.len()), (j = (j + usize(1))), {
-              ranges.push(esc_ranges.get(j).unwrap());
-            };
+            // If escape produced a single codepoint, check for range (e.g. \0-\x20)
+            if(((esc_ranges.len() == usize(1)) && (esc_ranges.get(usize(0)).unwrap().low == esc_ranges.get(usize(0)).unwrap().high)), {
+              (low : u32) = esc_ranges.get(usize(0)).unwrap().low;
+              self._try_parse_char_range(ranges, low);
+            }, {
+              j := usize(0);
+              while (j < esc_ranges.len()), (j = (j + usize(1))), {
+                ranges.push(esc_ranges.get(j).unwrap());
+              };
+            });
           },
           .Err(e) => { return .Err(e); }
         );
@@ -452,6 +512,11 @@ impl(RegexParser,
           (ch == u8(112)) => self._parse_unicode_property(false),
           // Negated unicode property \P{Name}
           (ch == u8(80)) => self._parse_unicode_property(true),
+          // Hex escape \xHH
+          (ch == u8(120)) => match(self._parse_hex_byte(),
+            .Some(v) => .Ok(RegexNode.literal(v)),
+            .None => .Ok(RegexNode.literal(u32(ch)))
+          ),
           true => .Ok(RegexNode.literal(self._escape_char_codepoint(ch)))
         ),
       .None => .Err(`Unexpected end of pattern after backslash`)

package/std/regex/vm.yo

@@ -22,21 +22,18 @@ NfaThread :: object(
 impl(NfaThread,
   new : (fn(pc : usize, n_slots : usize) -> Self)({
     s := ArrayList(usize).with_capacity(n_slots);
-    i := usize(0);
-    while (i < n_slots), (i = (i + usize(1))), {
-      // usize.MAX signals "unset"
-      s.push(usize.MAX);
-    };
+    // usize.MAX = 0xFF..FF, so memset with 0xFF fills each byte
+    s.resize_with_byte(n_slots, int(255));
     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());
-    i := usize(0);
-    while (i < self.slots.len()), (i = (i + usize(1))), {
-      new_slots.push(self.slots.get(i).unwrap());
-    };
+    match(self.slots.ptr(),
+      .Some(src) => new_slots.extend_from_ptr(src, self.slots.len()),
+      .None => ()
+    );
     Self(pc: new_pc, slots: new_slots)
   })
 );
@@ -47,15 +44,6 @@ VmMatch :: struct(
   slots   : ArrayList(usize)
 );
 
-// The NFA virtual machine
-NfaVm :: object(
-  _program   : NfaProgram,
-  _flags     : RegexFlags,
-  _input     : String,
-  _bytes     : ArrayList(u8),
-  _n_slots   : usize
-);
-
 // Helper struct for decoded characters
 DecodedChar :: struct(
   codepoint : u32,
@@ -68,16 +56,34 @@ DeferredThread :: struct(
   thread : NfaThread
 );
 
+// The NFA virtual machine
+NfaVm :: object(
+  _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,
   new : (fn(program : NfaProgram, flags : RegexFlags, input : String) -> Self)({
     n_slots := ((program.n_groups + usize(1)) * usize(2));
+    n_instr := program.instructions.len();
+    seen := ArrayList(bool).with_capacity(n_instr);
+    seen.resize_with_byte(n_instr, int(0));
+    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
+      _n_slots: n_slots,
+      _seen: seen,
+      _next_seen: next_seen
     )
   }),
 
@@ -233,14 +239,15 @@ impl(NfaVm,
       true => ()
     );
 
-    is_seen := seen.*.get(thread.pc).unwrap();
+    // Already checked bounds above: thread.pc < instructions.len()
+    is_seen := (seen.*)(thread.pc);
     cond(
       is_seen => { return (); },
       true => ()
     );
-    seen.*.set(thread.pc, true);
+    &((seen.*)(thread.pc)).* = true;
 
-    instr := self._program.instructions.get(thread.pc).unwrap();
+    instr := self._program.instructions(thread.pc);
 
     match(instr.kind,
       .Split => {
@@ -256,7 +263,7 @@ impl(NfaVm,
       .Save => {
         cond(
           (instr.slot < thread.slots.len()) => {
-            thread.slots.set(instr.slot, byte_pos);
+            &(thread.slots(instr.slot)).* = byte_pos;
           },
           true => ()
         );
@@ -326,10 +333,7 @@ impl(NfaVm,
     sub_next := ArrayList(NfaThread).new();
 
     sub_seen := ArrayList(bool).with_capacity(self._program.instructions.len());
-    si := usize(0);
-    while (si < self._program.instructions.len()), (si = (si + usize(1))), {
-      sub_seen.push(false);
-    };
+    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));
@@ -376,10 +380,7 @@ impl(NfaVm,
       sub_blen := decoded.byte_len;
 
       // Clear seen
-      sj := usize(0);
-      while (sj < sub_seen.len()), (sj = (sj + usize(1))), {
-        sub_seen.set(sj, false);
-      };
+      sub_seen.fill_with_byte(int(0));
 
       // Process consuming instructions
       st2 := usize(0);
@@ -428,8 +429,11 @@ impl(NfaVm,
         );
       };
 
+      // Swap sub_current/sub_next and clear for reuse
+      tmp_sub := sub_current;
       sub_current = sub_next;
-      sub_next = ArrayList(NfaThread).new();
+      sub_next = tmp_sub;
+      sub_next.clear();
       sub_pos = (sub_pos + sub_blen);
     };
 
@@ -440,17 +444,16 @@ impl(NfaVm,
 // Block 5: exec_at (depends on Block 1+2+3+4)
 impl(NfaVm,
   exec_at : (fn(self : Self, start_byte : usize) -> VmMatch)({
+    // Reuse pre-allocated seen buffers from the VM
     current := ArrayList(NfaThread).new();
     next := ArrayList(NfaThread).new();
+    seen := self._seen;
+    next_seen := self._next_seen;
     deferred := ArrayList(DeferredThread).new();
 
-    seen := ArrayList(bool).with_capacity(self._program.instructions.len());
-    next_seen := ArrayList(bool).with_capacity(self._program.instructions.len());
-    i := usize(0);
-    while (i < self._program.instructions.len()), (i = (i + usize(1))), {
-      seen.push(false);
-      next_seen.push(false);
-    };
+    // 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));
@@ -474,12 +477,9 @@ impl(NfaVm,
         true => ()
       );
 
-      // Clear seen flags for this generation
-      j := usize(0);
-      while (j < seen.len()), (j = (j + usize(1))), {
-        seen.set(j, false);
-        next_seen.set(j, false);
-      };
+      // 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();
@@ -714,8 +714,11 @@ impl(NfaVm,
         );
       };
 
+      // Swap current/next and clear for reuse
+      tmp_c := current;
       current = next;
-      next = ArrayList(NfaThread).new();
+      next = tmp_c;
+      next.clear();
 
       cond(
         at_end => { break; },
@@ -725,6 +728,10 @@ impl(NfaVm,
       );
     };
 
+    // Store seen buffers back for reuse in next exec_at call
+    self._seen = seen;
+    self._next_seen = next_seen;
+
     best_match
   })
 );