// Port of tree-sitter lib/src/reusable_node.h and lib/src/reduce_action.h.
///|
priv struct ReusableStackEntry {
tree : Subtree
child_index : Int32
byte_offset : UInt32
}
///|
priv struct ReusableNode {
stack : Array[ReusableStackEntry]
mut last_external_token : Subtree
}
///|
fn ReusableNode::new() -> ReusableNode {
{ stack: [], last_external_token: Null, }
}
///|
fn ReusableNode::clear(self : ReusableNode) -> Unit {
self.stack.clear()
self.last_external_token = Null
}
///|
fn ReusableNode::tree(self : ReusableNode) -> Subtree {
if self.stack.length() > 0 {
self.stack[self.stack.length() - 1].tree
} else {
Null
}
}
///|
fn ReusableNode::byte_offset(self : ReusableNode) -> UInt32 {
if self.stack.length() > 0 {
self.stack[self.stack.length() - 1].byte_offset
} else {
0xFFFFFFFFU
}
}
///|
fn ReusableNode::advance(self : ReusableNode) -> Unit {
let last_entry = self.stack[self.stack.length() - 1]
let byte_offset = last_entry.byte_offset + last_entry.tree.total_bytes()
if last_entry.tree.has_external_tokens() {
self.last_external_token = last_entry.tree.last_external_token()
}
let mut tree = Subtree::Null
let mut next_index = 0
for ;; {
let popped_entry = self.stack.pop().unwrap()
next_index = popped_entry.child_index + 1
if self.stack.length() == 0 {
return
}
tree = self.stack[self.stack.length() - 1].tree
if !(tree.child_count() <= next_index) {
break
}
}
self.stack.push({
tree: tree.children()[next_index],
child_index: next_index,
byte_offset,
})
}
///|
fn ReusableNode::descend(self : ReusableNode) -> Bool {
let last_entry = self.stack[self.stack.length() - 1]
if last_entry.tree.child_count() > 0 {
self.stack.push({
tree: last_entry.tree.children()[0],
child_index: 0,
byte_offset: last_entry.byte_offset,
})
true
} else {
false
}
}
///|
fn ReusableNode::advance_past_leaf(self : ReusableNode) -> Unit {
while self.descend() {
}
self.advance()
}
///|
fn ReusableNode::reset(self : ReusableNode, tree : Subtree) -> Unit {
self.clear()
self.stack.push({ tree, child_index: 0, byte_offset: 0, })
// Never reuse the root node, because it has a non-standard internal
// structure due to transformations that are applied when it is accepted:
// adding the EOF child and any extra children.
if !self.descend() {
self.clear()
}
}
///|
priv struct ReduceAction {
count : Int32
symbol : Int32
dynamic_precedence : Int32
production_id : Int32
}
///|
fn reduce_action_set_add(
set : Array[ReduceAction],
new_action : ReduceAction,
) -> Unit {
for action in set {
if action.symbol == new_action.symbol && action.count == new_action.count {
return
}
}
set.push(new_action)
}