@shd101wyy/yo 0.0.28 → 0.0.29

package/std/regex/node.yo

@@ -0,0 +1,283 @@
+// std/regex/node.yo - Regex AST node types
+//
+// The parser produces a tree of RegexNode objects representing the
+// structure of a regex pattern. Nodes are reference-counted objects
+// since they form a recursive tree.
+
+open import "std/collections/array_list";
+open import "std/string";
+
+// A range of characters for character classes, e.g. 'a'-'z'
+CharRange :: struct(
+  low  : u32,
+  high : u32
+);
+
+// Anchor types for ^ $ \b \B
+AnchorKind :: enum(
+  Start,
+  End,
+  WordBoundary,
+  NonWordBoundary
+);
+
+// Node kind tag
+NodeKind :: enum(
+  Literal,
+  Dot,
+  CharClass,
+  Anchor,
+  Sequence,
+  Alternation,
+  Quantifier,
+  Group,
+  NonCapturingGroup,
+  Backreference,
+  Lookahead,
+  Lookbehind
+);
+
+// Entry mapping a named group to its index
+GroupNameEntry :: struct(
+  name  : String,
+  index : usize
+);
+
+// The regex AST node type.
+// Uses `object(...)` for reference counting since nodes are recursive.
+// Self-reference via `Self` (like LinkedList's Node).
+RegexNode :: object(
+  kind     : NodeKind,
+  children : ArrayList(Self),
+  // For Literal nodes: the codepoint
+  codepoint : u32,
+  // For CharClass nodes: ranges and negation flag
+  ranges   : ArrayList(CharRange),
+  negated  : bool,
+  // For Quantifier nodes: min, max, greedy
+  q_min    : usize,
+  q_max    : usize,
+  q_greedy : bool,
+  // For Group/Save nodes: group index
+  group_index : usize,
+  // For Anchor nodes
+  anchor   : AnchorKind
+);
+
+impl(RegexNode,
+  // Create a literal node matching a single codepoint
+  literal : (fn(cp : u32) -> Self)(
+    Self(
+      kind: .Literal,
+      children: ArrayList(RegexNode).new(),
+      codepoint: cp,
+      ranges: ArrayList(CharRange).new(),
+      negated: false,
+      q_min: usize(0),
+      q_max: usize(0),
+      q_greedy: true,
+      group_index: usize(0),
+      anchor: .Start
+    )
+  ),
+
+  // Create a dot (any char) node
+  dot : (fn() -> Self)(
+    Self(
+      kind: .Dot,
+      children: ArrayList(RegexNode).new(),
+      codepoint: u32(0),
+      ranges: ArrayList(CharRange).new(),
+      negated: false,
+      q_min: usize(0),
+      q_max: usize(0),
+      q_greedy: true,
+      group_index: usize(0),
+      anchor: .Start
+    )
+  ),
+
+  // Create a character class node
+  char_class : (fn(ranges : ArrayList(CharRange), negated : bool) -> Self)(
+    Self(
+      kind: .CharClass,
+      children: ArrayList(RegexNode).new(),
+      codepoint: u32(0),
+      ranges: ranges,
+      negated: negated,
+      q_min: usize(0),
+      q_max: usize(0),
+      q_greedy: true,
+      group_index: usize(0),
+      anchor: .Start
+    )
+  ),
+
+  // Create an anchor node (^, $, \b, \B)
+  anchor_node : (fn(kind : AnchorKind) -> Self)(
+    Self(
+      kind: .Anchor,
+      children: ArrayList(RegexNode).new(),
+      codepoint: u32(0),
+      ranges: ArrayList(CharRange).new(),
+      negated: false,
+      q_min: usize(0),
+      q_max: usize(0),
+      q_greedy: true,
+      group_index: usize(0),
+      anchor: kind
+    )
+  ),
+
+  // Create a sequence node (concatenation of children)
+  sequence : (fn(nodes : ArrayList(RegexNode)) -> Self)(
+    Self(
+      kind: .Sequence,
+      children: nodes,
+      codepoint: u32(0),
+      ranges: ArrayList(CharRange).new(),
+      negated: false,
+      q_min: usize(0),
+      q_max: usize(0),
+      q_greedy: true,
+      group_index: usize(0),
+      anchor: .Start
+    )
+  ),
+
+  // Create an alternation node (left | right)
+  alternation : (fn(left : RegexNode, right : RegexNode) -> Self)({
+    kids := ArrayList(RegexNode).new();
+    kids.push(left);
+    kids.push(right);
+    Self(
+      kind: .Alternation,
+      children: kids,
+      codepoint: u32(0),
+      ranges: ArrayList(CharRange).new(),
+      negated: false,
+      q_min: usize(0),
+      q_max: usize(0),
+      q_greedy: true,
+      group_index: usize(0),
+      anchor: .Start
+    )
+  }),
+
+  // Create a quantifier node (wrapping a child)
+  // max_val of 0 means unbounded (infinity)
+  quantifier : (fn(child : RegexNode, min_val : usize, max_val : usize, greedy : bool) -> Self)({
+    kids := ArrayList(RegexNode).new();
+    kids.push(child);
+    Self(
+      kind: .Quantifier,
+      children: kids,
+      codepoint: u32(0),
+      ranges: ArrayList(CharRange).new(),
+      negated: false,
+      q_min: min_val,
+      q_max: max_val,
+      q_greedy: greedy,
+      group_index: usize(0),
+      anchor: .Start
+    )
+  }),
+
+  // Create a capturing group node
+  group : (fn(child : RegexNode, index : usize) -> Self)({
+    kids := ArrayList(RegexNode).new();
+    kids.push(child);
+    Self(
+      kind: .Group,
+      children: kids,
+      codepoint: u32(0),
+      ranges: ArrayList(CharRange).new(),
+      negated: false,
+      q_min: usize(0),
+      q_max: usize(0),
+      q_greedy: true,
+      group_index: index,
+      anchor: .Start
+    )
+  }),
+
+  // Create a non-capturing group node
+  non_capturing_group : (fn(child : RegexNode) -> Self)({
+    kids := ArrayList(RegexNode).new();
+    kids.push(child);
+    Self(
+      kind: .NonCapturingGroup,
+      children: kids,
+      codepoint: u32(0),
+      ranges: ArrayList(CharRange).new(),
+      negated: false,
+      q_min: usize(0),
+      q_max: usize(0),
+      q_greedy: true,
+      group_index: usize(0),
+      anchor: .Start
+    )
+  }),
+
+  // Create a backreference node (\1, \k<name>)
+  backreference : (fn(group_idx : usize) -> Self)(
+    Self(
+      kind: .Backreference,
+      children: ArrayList(RegexNode).new(),
+      codepoint: u32(0),
+      ranges: ArrayList(CharRange).new(),
+      negated: false,
+      q_min: usize(0),
+      q_max: usize(0),
+      q_greedy: true,
+      group_index: group_idx,
+      anchor: .Start
+    )
+  ),
+
+  // Create a lookahead node (?=...) or (?!...)
+  // negated=false means positive, negated=true means negative
+  lookahead : (fn(child : RegexNode, positive : bool) -> Self)({
+    kids := ArrayList(RegexNode).new();
+    kids.push(child);
+    Self(
+      kind: .Lookahead,
+      children: kids,
+      codepoint: u32(0),
+      ranges: ArrayList(CharRange).new(),
+      negated: (!(positive)),
+      q_min: usize(0),
+      q_max: usize(0),
+      q_greedy: true,
+      group_index: usize(0),
+      anchor: .Start
+    )
+  }),
+
+  // Create a lookbehind node (?<=...) or (?<!...)
+  // negated=false means positive, negated=true means negative
+  lookbehind : (fn(child : RegexNode, positive : bool) -> Self)({
+    kids := ArrayList(RegexNode).new();
+    kids.push(child);
+    Self(
+      kind: .Lookbehind,
+      children: kids,
+      codepoint: u32(0),
+      ranges: ArrayList(CharRange).new(),
+      negated: (!(positive)),
+      q_min: usize(0),
+      q_max: usize(0),
+      q_greedy: true,
+      group_index: usize(0),
+      anchor: .Start
+    )
+  })
+);
+
+export
+  RegexNode,
+  NodeKind,
+  CharRange,
+  AnchorKind,
+  GroupNameEntry
+;