@shd101wyy/yo 0.1.28 → 0.1.30

package/std/regex/parser.yo

@@ -57,20 +57,20 @@ impl(
     cond(
       (first < u8(0x80)) => u32(first),
       ((first >= u8(0xC0)) && (first < u8(0xE0))) => {
-        second := self._bytes.get(self._pos).unwrap();
+        second := self._bytes(self._pos);
         self._pos = (self._pos + usize(1));
         ((u32(first) & u32(0x1F)) << u32(6)) | (u32(second) & u32(0x3F))
       },
       ((first >= u8(0xE0)) && (first < u8(0xF0))) => {
-        second := self._bytes.get(self._pos).unwrap();
-        third := self._bytes.get(self._pos + usize(1)).unwrap();
+        second := self._bytes(self._pos);
+        third := self._bytes(self._pos + usize(1));
         self._pos = (self._pos + usize(2));
         (((u32(first) & u32(0x0F)) << u32(12)) | ((u32(second) & u32(0x3F)) << u32(6))) | (u32(third) & u32(0x3F))
       },
       true => {
-        second := self._bytes.get(self._pos).unwrap();
-        third := self._bytes.get(self._pos + usize(1)).unwrap();
-        fourth := self._bytes.get(self._pos + usize(2)).unwrap();
+        second := self._bytes(self._pos);
+        third := self._bytes(self._pos + usize(1));
+        fourth := self._bytes(self._pos + usize(2));
         self._pos = (self._pos + usize(3));
         ((((u32(first) & u32(0x07)) << u32(18)) | ((u32(second) & u32(0x3F)) << u32(12))) | ((u32(third) & u32(0x3F)) << u32(6))) | (u32(fourth) & u32(0x3F))
       }
@@ -88,7 +88,7 @@ impl(
   _lookup_group_name : (fn(self : Self, name : String) -> Option(usize))({
     i := usize(0);
     while(i < self._group_names.len(), i = (i + usize(1)), {
-      entry := self._group_names.get(i).unwrap();
+      entry := self._group_names(i);
       cond(
         (entry.name == name) => {
           return(.Some(entry.index));
@@ -136,7 +136,7 @@ impl(
     result := usize(0);
     i := start;
     while(i < self._pos, i = (i + usize(1)), {
-      d := self._bytes.get(i).unwrap();
+      d := self._bytes(i);
       result = ((result * usize(10)) + usize(d - u8(48)));
     });
     .Some(result)
@@ -176,13 +176,13 @@ impl(
     r.push(CharRange(low : u32(32), high : u32(32)));
     r
   }),
-  // Parse \xHH hex escape — reads exactly 2 hex digits and returns the codepoint.
+  // Parse \xHH hex unwind — 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();
+    (h1 : u8) = self._bytes(self._pos);
+    (h2 : u8) = self._bytes(self._pos + usize(1));
     (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)),
@@ -202,7 +202,7 @@ impl(
     self._pos = (self._pos + usize(2));
     .Some(u32((v1 << i32(4)) | v2))
   }),
-  _parse_class_escape : (fn(self : Self) -> Result(ArrayList(CharRange), String))({
+  _parse_class_unwind : (fn(self : Self) -> Result(ArrayList(CharRange), String))({
     b := self._advance();
     match(
       b,
@@ -264,7 +264,7 @@ impl(
         has_end := ((self._pos + usize(1)) < self._bytes.len());
         cond(
           has_end => {
-            end_first := self._bytes.get(self._pos + usize(1)).unwrap();
+            end_first := self._bytes(self._pos + usize(1));
             cond(
               (end_first == u8(93)) => {
                 ranges.push(CharRange(low : low, high : low));
@@ -273,20 +273,20 @@ impl(
                 // 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();
+                esc := self._parse_class_unwind();
                 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;
+                    if((esc_ranges.len() == usize(1)) && (esc_ranges(usize(0)).low == esc_ranges(usize(0)).high), {
+                      (high : u32) = esc_ranges(usize(0)).low;
                       ranges.push(CharRange(low : low, high : high));
                     }, {
-                      // Multi-range escape like \d can't be range endpoint; treat dash as literal
+                      // Multi-range unwind 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());
+                        ranges.push(esc_ranges(j));
                       });
                     });
                   },
@@ -331,18 +331,18 @@ impl(
       },
       (b == u8(92)) => {
         self._pos = (self._pos + usize(1));
-        esc := self._parse_class_escape();
+        esc := self._parse_class_unwind();
         match(
           esc,
           .Ok(esc_ranges) => {
-            // 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;
+            // If unwind produced a single codepoint, check for range (e.g. \0-\x20)
+            if((esc_ranges.len() == usize(1)) && (esc_ranges(usize(0)).low == esc_ranges(usize(0)).high), {
+              (low : u32) = esc_ranges(usize(0)).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());
+                ranges.push(esc_ranges(j));
               });
             });
           },
@@ -402,7 +402,7 @@ impl(
     });
     .Err(`Unterminated character class`)
   }),
-  // Parse \p{PropertyName} or \P{PropertyName} unicode property escape.
+  // Parse \p{PropertyName} or \P{PropertyName} unicode property unwind.
   // negated=true for \P (inverted match).
   _parse_unicode_property : (fn(self : Self, negated : bool) -> Result(RegexNode, String))({
     // Expect opening '{'
@@ -451,7 +451,7 @@ impl(
     });
     .Err(`Unterminated Unicode property \\p{...}`)
   }),
-  _parse_escape : (fn(self : Self) -> Result(RegexNode, String))({
+  _parse_unwind : (fn(self : Self) -> Result(RegexNode, String))({
     b := self._advance();
     match(
       b,
@@ -524,7 +524,7 @@ impl(
           (ch == u8(112)) => self._parse_unicode_property(false),
           // Negated unicode property \P{Name}
           (ch == u8(80)) => self._parse_unicode_property(true),
-          // Hex escape \xHH
+          // Hex unwind \xHH
           (ch == u8(120)) => match(
             self._parse_hex_byte(),
             .Some(v) =>.Ok(RegexNode.literal(v)),
@@ -627,7 +627,7 @@ impl(
           (ch == u8(94)) =>.Ok(RegexNode.anchor_node(.Start)),
           (ch == u8(36)) =>.Ok(RegexNode.anchor_node(.End)),
           (ch == u8(91)) => self._parse_char_class(),
-          (ch == u8(92)) => self._parse_escape(),
+          (ch == u8(92)) => self._parse_unwind(),
           true =>.Ok(RegexNode.literal(self._read_codepoint(ch)))
         ),
       .None =>.Err(`Unexpected end of pattern`)
@@ -677,7 +677,7 @@ impl(
   _make_sequence : (fn(self : Self, nodes : ArrayList(RegexNode)) -> RegexNode)(
     cond(
       (nodes.len() == usize(0)) => RegexNode.sequence(ArrayList(RegexNode).new()),
-      (nodes.len() == usize(1)) => nodes.get(usize(0)).unwrap(),
+      (nodes.len() == usize(1)) => nodes(usize(0)),
       true => RegexNode.sequence(nodes)
     )
   ),
@@ -689,10 +689,10 @@ impl(
       true => ()
     );
     alts.push(seq);
-    result := self._make_sequence(alts.get(usize(0)).unwrap());
+    result := self._make_sequence(alts(usize(0)));
     i := usize(1);
     while(i < alts.len(), i = (i + usize(1)), {
-      right := self._make_sequence(alts.get(i).unwrap());
+      right := self._make_sequence(alts(i));
       result = RegexNode.alternation(result, right);
     });
     result
@@ -873,7 +873,7 @@ impl(
             cur_non_cap => RegexNode.non_capturing_group(inner),
             true => RegexNode.group(inner, cur_group_idx)
           );
-          parent := stack.get(stack.len() - usize(1)).unwrap();
+          parent := stack(stack.len() - usize(1));
           stack.pop();
           cur_alts = parent.alternatives;
           cur_seq = parent.current;

package/std/regex/vm.yo

@@ -3,6 +3,7 @@
 //! 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.
+pragma(Pragma.AllowUnsafe);
 open(import("std/collections/array_list"));
 open(import("std/string"));
 { NfaProgram, Instr, InstrKind, ClassEntry, GroupNameEntry } :: import("./compiler.yo");
@@ -80,25 +81,25 @@ impl(
     )
   }),
   _decode_codepoint : (fn(self : Self, pos : usize) -> DecodedChar)({
-    first := self._bytes.get(pos).unwrap();
+    first := self._bytes(pos);
     cond(
       (first < u8(0x80)) =>
         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(pos + usize(1));
         cp := (((u32(first) & u32(0x1F)) << u32(6)) | (u32(second) & u32(0x3F)));
         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(pos + usize(1));
+        third := self._bytes(pos + usize(2));
         cp := ((((u32(first) & u32(0x0F)) << u32(12)) | ((u32(second) & u32(0x3F)) << u32(6))) | (u32(third) & u32(0x3F)));
         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(pos + usize(1));
+        third := self._bytes(pos + usize(2));
+        fourth := self._bytes(pos + usize(3));
         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))
       }
@@ -116,7 +117,7 @@ impl(
   _find_prev_char_start : (fn(self : Self, pos : usize) -> usize)({
     p := (pos - usize(1));
     while(p > usize(0), p = (p - usize(1)), {
-      b := self._bytes.get(p).unwrap();
+      b := self._bytes(p);
       cond(
         ((b < u8(0x80)) || (b >= u8(0xC0))) => {
           return(p);
@@ -130,7 +131,7 @@ impl(
     cond(
       (pos == usize(0)) => false,
       true => {
-        b := self._bytes.get(pos - usize(1)).unwrap();
+        b := self._bytes(pos - usize(1));
         b == u8(10)
       }
     )
@@ -139,7 +140,7 @@ impl(
     cond(
       (pos >= self._bytes.len()) => false,
       true => {
-        b := self._bytes.get(pos).unwrap();
+        b := self._bytes(pos);
         b == u8(10)
       }
     )
@@ -163,7 +164,7 @@ impl(
     (found : bool) = false;
     i := usize(0);
     while((i < cls.ranges.len()) && (!(found)), i = (i + usize(1)), {
-      r := cls.ranges.get(i).unwrap();
+      r := cls.ranges(i);
       (low : u32) = cond(
         self._flags.ignore_case => self._to_lower(r.low),
         true => r.low
@@ -183,7 +184,7 @@ impl(
       ((!(found)) && self._flags.ignore_case) => {
         i2 := usize(0);
         while((i2 < cls.ranges.len()) && (!(found)), i2 = (i2 + usize(1)), {
-          r := cls.ranges.get(i2).unwrap();
+          r := cls.ranges(i2);
           cond(
             ((cp >= r.low) && (cp <= r.high)) => {
               found = true;
@@ -221,7 +222,7 @@ impl(
 // Block 3: _add_thread (recursive, depends on Block 1+2)
 impl(
   NfaVm,
-  _add_thread : (fn(self : Self, list : *(ArrayList(NfaThread)), thread : NfaThread, byte_pos : usize, seen : *(ArrayList(bool))) -> unit)({
+  _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(());
@@ -229,14 +230,14 @@ impl(
       true => ()
     );
     // Already checked bounds above: thread.pc < instructions.len()
-    is_seen := (seen.*)(thread.pc);
+    is_seen := seen(thread.pc);
     cond(
       is_seen => {
         return(());
       },
       true => ()
     );
-    &((seen.*)(thread.pc)).* = true;
+    seen(thread.pc) = true;
     instr := self._program.instructions(thread.pc);
     match(
       instr.kind,
@@ -307,7 +308,7 @@ impl(
         );
       },
       _ => {
-        list.*.push(thread);
+        list.push(thread);
       }
     );
   })
@@ -324,7 +325,7 @@ impl(
     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));
+    self._add_thread(sub_current, initial, start_byte, sub_seen);
     sub_pos := start_byte;
     input_len := self._bytes.len();
     while(sub_pos <= input_len, {
@@ -337,8 +338,8 @@ impl(
       // Check for Match in current threads
       st := usize(0);
       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();
+        st_thread := sub_current(st);
+        st_instr := self._program.instructions(st_thread.pc);
         match(
           st_instr.kind,
           .Match => {
@@ -376,15 +377,15 @@ impl(
       // Process consuming instructions
       st2 := usize(0);
       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();
+        st_thread := sub_current(st2);
+        st_instr := self._program.instructions(st_thread.pc);
         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));
+                self._add_thread(sub_next, new_t, sub_pos + sub_blen, sub_seen);
               },
               true => ()
             );
@@ -397,7 +398,7 @@ impl(
             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));
+                self._add_thread(sub_next, new_t, sub_pos + sub_blen, sub_seen);
               },
               true => ()
             );
@@ -410,7 +411,7 @@ impl(
                 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));
+                    self._add_thread(sub_next, new_t, sub_pos + sub_blen, sub_seen);
                   },
                   true => ()
                 );
@@ -445,7 +446,7 @@ impl(
     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));
+    self._add_thread(current, initial, start_byte, seen);
     best_match := VmMatch(matched : false, slots : ArrayList(usize).new());
     byte_pos := start_byte;
     input_len := self._bytes.len();
@@ -469,10 +470,10 @@ impl(
       new_deferred := ArrayList(DeferredThread).new();
       di := usize(0);
       while(di < deferred.len(), di = (di + usize(1)), {
-        d := deferred.get(di).unwrap();
+        d := deferred(di);
         cond(
           (d.target_byte_pos == byte_pos) => {
-            self._add_thread(&(current), d.thread, byte_pos, &(seen));
+            self._add_thread(current, d.thread, byte_pos, seen);
           },
           true => {
             new_deferred.push(d);
@@ -491,15 +492,15 @@ impl(
       (found_match_in_gen : bool) = false;
       t := usize(0);
       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();
+        thread := current(t);
+        instr := self._program.instructions(thread.pc);
         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));
+                self._add_thread(next, new_thread, byte_pos + char_byte_len, next_seen);
               },
               true => ()
             );
@@ -514,7 +515,7 @@ impl(
                 cond(
                   should_match => {
                     new_thread := thread.fork(thread.pc + usize(1));
-                    self._add_thread(&(next), new_thread, byte_pos + char_byte_len, &(next_seen));
+                    self._add_thread(next, new_thread, byte_pos + char_byte_len, next_seen);
                   },
                   true => ()
                 );
@@ -532,7 +533,7 @@ impl(
                     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));
+                        self._add_thread(next, new_thread, byte_pos + char_byte_len, next_seen);
                       },
                       true => ()
                     );
@@ -548,8 +549,8 @@ impl(
             group_end_slot := ((instr.slot * usize(2)) + usize(1));
             cond(
               ((group_start_slot < thread.slots.len()) && (group_end_slot < thread.slots.len())) => {
-                gs := thread.slots.get(group_start_slot).unwrap();
-                ge := thread.slots.get(group_end_slot).unwrap();
+                gs := thread.slots(group_start_slot);
+                ge := thread.slots(group_end_slot);
                 cond(
                   ((gs != unset) && (ge != unset)) => {
                     captured_len := (ge - gs);
@@ -559,8 +560,8 @@ impl(
                         (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();
+                          expected := self._bytes(gs + bi);
+                          actual := self._bytes(byte_pos + bi);
                           cond(
                             self._flags.ignore_case => {
                               el := cond(
@@ -595,7 +596,7 @@ impl(
                             cond(
                               (captured_len == usize(0)) => {
                                 // Empty capture — epsilon-like, process in current gen
-                                self._add_thread(&(current), new_thread, byte_pos, &(seen));
+                                self._add_thread(current, new_thread, byte_pos, seen);
                               },
                               true => {
                                 // Defer to the target byte position
@@ -624,7 +625,7 @@ impl(
               (sub_matched == positive) => {
                 sub_end := instr.target_b;
                 new_thread := thread.fork(sub_end);
-                self._add_thread(&(current), new_thread, byte_pos, &(seen));
+                self._add_thread(current, new_thread, byte_pos, seen);
               },
               true => ()
             );
@@ -664,10 +665,10 @@ impl(
                       // Skip UTF-8 continuation bytes (10xxxxxx)
                       cond(
                         (try_pos > usize(0)) => {
-                          tb := self._bytes.get(try_pos).unwrap();
+                          tb := self._bytes(try_pos);
                           while(((tb >= u8(0x80)) && (tb < u8(0xC0))) && (try_pos > usize(0)), {
                             try_pos = (try_pos - usize(1));
-                            tb = self._bytes.get(try_pos).unwrap();
+                            tb = self._bytes(try_pos);
                           });
                         },
                         true => ()
@@ -687,7 +688,7 @@ impl(
               (lb_matched == positive) => {
                 sub_end := instr.target_b;
                 new_thread := thread.fork(sub_end);
-                self._add_thread(&(current), new_thread, byte_pos, &(seen));
+                self._add_thread(current, new_thread, byte_pos, seen);
               },
               true => ()
             );