From 749fdf627fbb83f9be6f77a1b2b76beca7c2f46e Mon Sep 17 00:00:00 2001 From: Maieul BOYER Date: Sat, 31 Aug 2024 15:52:24 +0000 Subject: [PATCH] WIP --- parser/src/stack.c | 668 +++++++++++++++++++++++++-------------------- 1 file changed, 375 insertions(+), 293 deletions(-) diff --git a/parser/src/stack.c b/parser/src/stack.c index 7272a6b0..20d674cb 100644 --- a/parser/src/stack.c +++ b/parser/src/stack.c @@ -6,16 +6,16 @@ /* By: maiboyer +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2024/08/31 15:22:58 by maiboyer #+# #+# */ -/* Updated: 2024/08/31 15:35:03 by maiboyer ### ########.fr */ +/* Updated: 2024/08/31 15:51:15 by maiboyer ### ########.fr */ /* */ /* ************************************************************************** */ -#include "parser/stack.h" #include "me/mem/mem.h" #include "me/types.h" #include "parser/array.h" #include "parser/language.h" #include "parser/length.h" +#include "parser/stack.h" #include "parser/subtree.h" #include #include @@ -24,116 +24,117 @@ #define MAX_NODE_POOL_SIZE 0 #define MAX_ITERATOR_COUNT 0 -typedef enum e_stack_status t_stack_status; -typedef struct s_stack_head t_stack_head; -typedef struct s_stack_iterator t_stack_iterator; -typedef struct s_stack_link t_stack_link; -typedef struct s_stack_node t_stack_node; -typedef struct s_summarize_stack_session t_summarize_stack_session; -typedef t_u32 t_stack_action; +typedef enum e_stack_status t_stack_status; +typedef struct s_stack_head t_stack_head; +typedef struct s_stack_iterator t_stack_iterator; +typedef struct s_stack_link t_stack_link; +typedef struct s_stack_node t_stack_node; +typedef struct s_summarize_stack_session t_summarize_stack_session; +typedef t_u32 t_stack_action; -typedef t_stack_action (*t_stack_callback)(void *, const t_stack_iterator *); +typedef t_stack_action (*t_stack_callback)(void *, + const t_stack_iterator *); -struct s_stack_link +struct s_stack_link { - t_stack_node *node; - Subtree subtree; - bool is_pending; + t_stack_node *node; + Subtree subtree; + bool is_pending; }; -struct s_stack_node +struct s_stack_node { - TSStateId state; - Length position; - t_stack_link links[MAX_LINK_COUNT]; - t_u16 link_count; - t_u32 ref_count; - t_u32 error_cost; - t_u32 node_count; - int dynamic_precedence; + TSStateId state; + Length position; + t_stack_link links[MAX_LINK_COUNT]; + t_u16 link_count; + t_u32 ref_count; + t_u32 error_cost; + t_u32 node_count; + int dynamic_precedence; }; -struct s_stack_iterator +struct s_stack_iterator { - t_stack_node *node; - SubtreeArray subtrees; - t_u32 subtree_count; - bool is_pending; + t_stack_node *node; + SubtreeArray subtrees; + t_u32 subtree_count; + bool is_pending; }; -enum e_stack_status +enum e_stack_status { SStatusActive, SStatusPaused, SStatusHalted, }; -struct s_stack_head +struct s_stack_head { - t_stack_node *node; - t_stack_summary *summary; - t_u32 node_count_at_last_error; - Subtree last_external_token; - Subtree lookahead_when_paused; - t_stack_status status; + t_stack_node *node; + t_stack_summary *summary; + t_u32 node_count_at_last_error; + Subtree last_external_token; + Subtree lookahead_when_paused; + t_stack_status status; }; -struct s_stack +struct s_stack { Array(t_stack_head) heads; - t_stack_slice_array slices; + t_stack_slice_array slices; Array(t_stack_iterator) iterators; - t_stack_node *base_node; + t_stack_node *base_node; }; -enum e_stack_action +enum e_stack_action { SActionNone, SActionStop = 1, SActionPop = 2, }; -struct s_summarize_stack_session +struct s_summarize_stack_session { - t_stack_summary *summary; - t_u32 max_depth; + t_stack_summary *summary; + t_u32 max_depth; }; -static void stack_node_retain(t_stack_node *self) +static void stack_node_retain(t_stack_node *self) { if (!self) - return; + return ; assert(self->ref_count > 0); self->ref_count++; assert(self->ref_count != 0); } -static void stack_node_release(t_stack_node *self) +static void stack_node_release(t_stack_node *self) { + t_stack_node *first_predecessor; + t_stack_link link; + recur: assert(self->ref_count != 0); self->ref_count--; if (self->ref_count > 0) - return; - - t_stack_node *first_predecessor = NULL; + return ; + first_predecessor = NULL; if (self->link_count > 0) { for (t_u32 i = self->link_count - 1; i > 0; i--) { - t_stack_link link = self->links[i]; + link = self->links[i]; if (link.subtree) ts_subtree_release(link.subtree); stack_node_release(link.node); } - t_stack_link link = self->links[0]; + link = self->links[0]; if (link.subtree) ts_subtree_release(link.subtree); first_predecessor = self->links[0].node; } - mem_free(self); - if (first_predecessor) { self = first_predecessor; @@ -143,26 +144,28 @@ recur: /// Get the number of nodes in the subtree, for the purpose of measuring /// how much progress has been made by a given version of the stack. -static t_u32 stack__subtree_node_count(Subtree subtree) +static t_u32 stack__subtree_node_count(Subtree subtree) { - t_u32 count = ts_subtree_visible_descendant_count(subtree); + t_u32 count; + + count = ts_subtree_visible_descendant_count(subtree); if (ts_subtree_visible(subtree)) count++; - // Count intermediate error nodes even though they are not visible, // because a stack version's node count is used to check whether it // has made any progress since the last time it encountered an error. if (ts_subtree_symbol(subtree) == ts_builtin_sym_error_repeat) count++; - - return count; + return (count); } -static t_stack_node *stack_node_new(t_stack_node *previous_node, Subtree subtree, bool is_pending, TSStateId state) +static t_stack_node *stack_node_new(t_stack_node *previous_node, + Subtree subtree, bool is_pending, TSStateId state) { - t_stack_node *node = mem_alloc(sizeof(t_stack_node)); - *node = (t_stack_node){.ref_count = 1, .link_count = 0, .state = state}; + t_stack_node *node; + node = mem_alloc(sizeof(t_stack_node)); + *node = (t_stack_node){.ref_count = 1, .link_count = 0, .state = state}; if (previous_node != NULL) { node->link_count = 1; @@ -171,16 +174,15 @@ static t_stack_node *stack_node_new(t_stack_node *previous_node, Subtree subtree .subtree = subtree, .is_pending = is_pending, }; - node->position = previous_node->position; node->error_cost = previous_node->error_cost; node->dynamic_precedence = previous_node->dynamic_precedence; node->node_count = previous_node->node_count; - if (subtree) { node->error_cost += ts_subtree_error_cost(subtree); - node->position = length_add(node->position, ts_subtree_total_size(subtree)); + node->position = length_add(node->position, + ts_subtree_total_size(subtree)); node->node_count += stack__subtree_node_count(subtree); node->dynamic_precedence += ts_subtree_dynamic_precedence(subtree); } @@ -190,41 +192,43 @@ static t_stack_node *stack_node_new(t_stack_node *previous_node, Subtree subtree node->position = length_zero(); node->error_cost = 0; } - - return node; + return (node); } -static bool stack__subtree_is_equivalent(Subtree left, Subtree right) +static bool stack__subtree_is_equivalent(Subtree left, Subtree right) { if (left == right) - return true; + return (true); if (!left || !right) - return false; - + return (false); // Symbols must match if (ts_subtree_symbol(left) != ts_subtree_symbol(right)) - return false; - + return (false); // If both have errors, don't bother keeping both. if (ts_subtree_error_cost(left) > 0 && ts_subtree_error_cost(right) > 0) - return true; - - return (ts_subtree_padding(left).bytes == ts_subtree_padding(right).bytes && - ts_subtree_size(left).bytes == ts_subtree_size(right).bytes && ts_subtree_child_count(left) == ts_subtree_child_count(right) && - ts_subtree_extra(left) == ts_subtree_extra(right) && ts_subtree_external_scanner_state_eq(left, right)); + return (true); + return (ts_subtree_padding(left).bytes == ts_subtree_padding(right).bytes + && ts_subtree_size(left).bytes == ts_subtree_size(right).bytes + && ts_subtree_child_count(left) == ts_subtree_child_count(right) + && ts_subtree_extra(left) == ts_subtree_extra(right) + && ts_subtree_external_scanner_state_eq(left, right)); } -static void stack_node_add_link(t_stack_node *self, t_stack_link link) +static void stack_node_add_link(t_stack_node *self, t_stack_link link) { - if (link.node == self) - return; + t_stack_link *existing_link; + t_i32 dynamic_precedence; + t_u32 node_count; + if (link.node == self) + return ; for (int i = 0; i < self->link_count; i++) { - t_stack_link *existing_link = &self->links[i]; + existing_link = &self->links[i]; if (stack__subtree_is_equivalent(existing_link->subtree, link.subtree)) { - // In general, we preserve ambiguities until they are removed from the stack + // In general, + // we preserve ambiguities until they are removed from the stack // during a pop operation where multiple paths lead to the same node. But in // the special case where two links directly connect the same pair of nodes, // we can safely remove the ambiguity ahead of time without changing behavior. @@ -233,57 +237,57 @@ static void stack_node_add_link(t_stack_node *self, t_stack_link link) if (ts_subtree_dynamic_precedence(link.subtree) > ts_subtree_dynamic_precedence(existing_link->subtree)) { ts_subtree_retain(link.subtree); - ts_subtree_release(/*subtree_pool, */ existing_link->subtree); + ts_subtree_release(/*subtree_pool, + */ existing_link->subtree); existing_link->subtree = link.subtree; - self->dynamic_precedence = link.node->dynamic_precedence + ts_subtree_dynamic_precedence(link.subtree); + self->dynamic_precedence = link.node->dynamic_precedence + + ts_subtree_dynamic_precedence(link.subtree); } - return; + return ; } - // If the previous nodes are mergeable, merge them recursively. - if (existing_link->node->state == link.node->state && existing_link->node->position.bytes == link.node->position.bytes && - existing_link->node->error_cost == link.node->error_cost) + if (existing_link->node->state == link.node->state + && existing_link->node->position.bytes == link.node->position.bytes + && existing_link->node->error_cost == link.node->error_cost) { for (int j = 0; j < link.node->link_count; j++) { - stack_node_add_link(existing_link->node, link.node->links[j]); + stack_node_add_link(existing_link->node, + link.node->links[j]); } - t_i32 dynamic_precedence = link.node->dynamic_precedence; + dynamic_precedence = link.node->dynamic_precedence; if (link.subtree) { - dynamic_precedence += ts_subtree_dynamic_precedence(link.subtree); + dynamic_precedence + += ts_subtree_dynamic_precedence(link.subtree); } if (dynamic_precedence > self->dynamic_precedence) { self->dynamic_precedence = dynamic_precedence; } - return; + return ; } } } - if (self->link_count == MAX_LINK_COUNT) - return; - + return ; stack_node_retain(link.node); - t_u32 node_count = link.node->node_count; - int dynamic_precedence = link.node->dynamic_precedence; + node_count = link.node->node_count; + dynamic_precedence = link.node->dynamic_precedence; self->links[self->link_count++] = link; - if (link.subtree) { ts_subtree_retain(link.subtree); node_count += stack__subtree_node_count(link.subtree); dynamic_precedence += ts_subtree_dynamic_precedence(link.subtree); } - if (node_count > self->node_count) self->node_count = node_count; if (dynamic_precedence > self->dynamic_precedence) self->dynamic_precedence = dynamic_precedence; } -static void stack_head_delete(t_stack_head *self) +static void stack_head_delete(t_stack_head *self) { if (self->node) { @@ -304,9 +308,12 @@ static void stack_head_delete(t_stack_head *self) } } -static t_stack_version ts_stack__add_version(t_stack *self, t_stack_version original_version, t_stack_node *node) +static t_stack_version ts_stack__add_version(t_stack *self, + t_stack_version original_version, t_stack_node *node) { - t_stack_head head = { + t_stack_head head; + + head = (t_stack_head){ .node = node, .node_count_at_last_error = self->heads.contents[original_version].node_count_at_last_error, .last_external_token = self->heads.contents[original_version].last_external_token, @@ -317,64 +324,75 @@ static t_stack_version ts_stack__add_version(t_stack *self, t_stack_version orig stack_node_retain(node); if (head.last_external_token) ts_subtree_retain(head.last_external_token); - return (t_stack_version)(self->heads.size - 1); + return ((t_stack_version)(self->heads.size - 1)); } -static void ts_stack__add_slice(t_stack *self, t_stack_version original_version, t_stack_node *node, SubtreeArray *subtrees) +static void ts_stack__add_slice(t_stack *self, t_stack_version original_version, + t_stack_node *node, SubtreeArray *subtrees) { + t_stack_version version; + t_stack_slice slice; + for (t_u32 i = self->slices.size - 1; i + 1 > 0; i--) { - t_stack_version version = self->slices.contents[i].version; + version = self->slices.contents[i].version; if (self->heads.contents[version].node == node) { - t_stack_slice slice = {*subtrees, version}; + slice = (t_stack_slice){*subtrees, version}; array_insert(&self->slices, i + 1, slice); - return; + return ; } } - - t_stack_version version = ts_stack__add_version(self, original_version, node); - t_stack_slice slice = {*subtrees, version}; + version = ts_stack__add_version(self, original_version, node); + slice = (t_stack_slice){*subtrees, version}; array_push(&self->slices, slice); } -static t_stack_slice_array stack__iter(t_stack *self, t_stack_version version, t_stack_callback callback, void *payload, - int goal_subtree_count) +static t_stack_slice_array stack__iter(t_stack *self, t_stack_version version, + t_stack_callback callback, void *payload, int goal_subtree_count) { + t_stack_head *head; + bool include_subtrees; + t_stack_iterator *iterator; + t_stack_node *node; + t_stack_action action; + bool should_pop; + bool should_stop; + SubtreeArray subtrees; + t_stack_iterator *next_iterator; + t_stack_link link; + t_stack_iterator current_iterator; + t_stack_iterator new_iterator; + array_clear(&self->slices); array_clear(&self->iterators); - - t_stack_head *head = array_get(&self->heads, version); - t_stack_iterator new_iterator = { + head = array_get(&self->heads, version); + new_iterator = (t_stack_iterator){ .node = head->node, .subtrees = array_new(), .subtree_count = 0, .is_pending = true, }; - - bool include_subtrees = false; + include_subtrees = false; if (goal_subtree_count >= 0) { include_subtrees = true; - array_reserve(&new_iterator.subtrees, (t_u32)ts_subtree_alloc_size(goal_subtree_count) / sizeof(Subtree)); + array_reserve(&new_iterator.subtrees, + (t_u32)ts_subtree_alloc_size(goal_subtree_count) / sizeof(Subtree)); } - array_push(&self->iterators, new_iterator); - while (self->iterators.size > 0) { for (t_u32 i = 0, size = self->iterators.size; i < size; i++) { - t_stack_iterator *iterator = &self->iterators.contents[i]; - t_stack_node *node = iterator->node; - - t_stack_action action = callback(payload, iterator); - bool should_pop = action & SActionPop; - bool should_stop = action & SActionStop || node->link_count == 0; - + iterator = &self->iterators.contents[i]; + node = iterator->node; + action = callback(payload, iterator); + should_pop = action & SActionPop; + should_stop = action & SActionStop || node->link_count == 0; if (should_pop) { - SubtreeArray subtrees = iterator->subtrees; + subtrees = iterator->subtrees; if (!should_stop) { ts_subtree_array_copy(subtrees, &subtrees); @@ -382,7 +400,6 @@ static t_stack_slice_array stack__iter(t_stack *self, t_stack_version version, t ts_subtree_array_reverse(&subtrees); ts_stack__add_slice(self, version, node, &subtrees); } - if (should_stop) { if (!should_pop) @@ -391,13 +408,10 @@ static t_stack_slice_array stack__iter(t_stack *self, t_stack_version version, t } array_erase(&self->iterators, i); i--, size--; - continue; + continue ; } - for (t_u32 j = 1; j <= node->link_count; j++) { - t_stack_iterator *next_iterator; - t_stack_link link; if (j == node->link_count) { link = node->links[0]; @@ -406,14 +420,14 @@ static t_stack_slice_array stack__iter(t_stack *self, t_stack_version version, t else { if (self->iterators.size >= MAX_ITERATOR_COUNT) - continue; + continue ; link = node->links[j]; - t_stack_iterator current_iterator = self->iterators.contents[i]; + current_iterator = self->iterators.contents[i]; array_push(&self->iterators, current_iterator); next_iterator = array_back(&self->iterators); - ts_subtree_array_copy(next_iterator->subtrees, &next_iterator->subtrees); + ts_subtree_array_copy(next_iterator->subtrees, + &next_iterator->subtrees); } - next_iterator->node = link.node; if (link.subtree) { @@ -422,7 +436,6 @@ static t_stack_slice_array stack__iter(t_stack *self, t_stack_version version, t array_push(&next_iterator->subtrees, link.subtree); ts_subtree_retain(link.subtree); } - if (!ts_subtree_extra(link.subtree)) { next_iterator->subtree_count++; @@ -440,30 +453,26 @@ static t_stack_slice_array stack__iter(t_stack *self, t_stack_version version, t } } } - - return self->slices; + return (self->slices); } -t_stack *ts_stack_new(void) +t_stack *ts_stack_new(void) { - t_stack *self; + t_stack *self; self = mem_alloc(sizeof(*self)); - array_init(&self->heads); array_init(&self->slices); array_init(&self->iterators); array_reserve(&self->heads, 4); array_reserve(&self->slices, 4); array_reserve(&self->iterators, 4); - self->base_node = stack_node_new(NULL, NULL, false, 1); ts_stack_clear(self); - return (self); } -void ts_stack_delete(t_stack *self) +void ts_stack_delete(t_stack *self) { if (self->slices.contents) array_delete(&self->slices); @@ -479,29 +488,33 @@ void ts_stack_delete(t_stack *self) mem_free(self); } -t_u32 ts_stack_version_count(const t_stack *self) +t_u32 ts_stack_version_count(const t_stack *self) { - return self->heads.size; + return (self->heads.size); } -TSStateId ts_stack_state(const t_stack *self, t_stack_version version) +TSStateId ts_stack_state(const t_stack *self, t_stack_version version) { - return array_get(&self->heads, version)->node->state; + return (array_get(&self->heads, version)->node->state); } -Length ts_stack_position(const t_stack *self, t_stack_version version) +Length ts_stack_position(const t_stack *self, t_stack_version version) { - return array_get(&self->heads, version)->node->position; + return (array_get(&self->heads, version)->node->position); } -Subtree ts_stack_last_external_token(const t_stack *self, t_stack_version version) +Subtree ts_stack_last_external_token(const t_stack *self, + t_stack_version version) { - return array_get(&self->heads, version)->last_external_token; + return (array_get(&self->heads, version)->last_external_token); } -void ts_stack_set_last_external_token(t_stack *self, t_stack_version version, Subtree token) +void ts_stack_set_last_external_token(t_stack *self, t_stack_version version, + Subtree token) { - t_stack_head *head = array_get(&self->heads, version); + t_stack_head *head; + + head = array_get(&self->heads, version); if (token) ts_subtree_retain(token); if (head->last_external_token) @@ -509,167 +522,206 @@ void ts_stack_set_last_external_token(t_stack *self, t_stack_version version, Su head->last_external_token = token; } -t_u32 ts_stack_error_cost(const t_stack *self, t_stack_version version) +t_u32 ts_stack_error_cost(const t_stack *self, t_stack_version version) { - t_stack_head *head = array_get(&self->heads, version); - t_u32 result = head->node->error_cost; - if (head->status == SStatusPaused || (head->node->state == ERROR_STATE && !head->node->links[0].subtree)) + t_stack_head *head; + t_u32 result; + + head = array_get(&self->heads, version); + result = head->node->error_cost; + if (head->status == SStatusPaused || (head->node->state == ERROR_STATE + && !head->node->links[0].subtree)) { result += ERROR_COST_PER_RECOVERY; } - return result; + return (result); } -t_u32 ts_stack_node_count_since_error(const t_stack *self, t_stack_version version) +t_u32 ts_stack_node_count_since_error(const t_stack *self, + t_stack_version version) { - t_stack_head *head = array_get(&self->heads, version); + t_stack_head *head; + + head = array_get(&self->heads, version); if (head->node->node_count < head->node_count_at_last_error) { head->node_count_at_last_error = head->node->node_count; } - return head->node->node_count - head->node_count_at_last_error; + return (head->node->node_count - head->node_count_at_last_error); } -void ts_stack_push(t_stack *self, t_stack_version version, Subtree subtree, bool pending, TSStateId state) +void ts_stack_push(t_stack *self, t_stack_version version, Subtree subtree, + bool pending, TSStateId state) { - t_stack_head *head = array_get(&self->heads, version); - t_stack_node *new_node = stack_node_new(head->node, subtree, pending, state); + t_stack_head *head; + t_stack_node *new_node; + + head = array_get(&self->heads, version); + new_node = stack_node_new(head->node, subtree, pending, state); if (!subtree) head->node_count_at_last_error = new_node->node_count; head->node = new_node; } -t_stack_action pop_count_callback(void *payload, const t_stack_iterator *iterator) +t_stack_action pop_count_callback(void *payload, + const t_stack_iterator *iterator) { - t_u32 *goal_subtree_count = payload; + t_u32 *goal_subtree_count; + + goal_subtree_count = payload; if (iterator->subtree_count == *goal_subtree_count) { - return SActionPop | SActionStop; + return (SActionPop | SActionStop); } else { - return SActionNone; + return (SActionNone); } } -t_stack_slice_array ts_stack_pop_count(t_stack *self, t_stack_version version, t_u32 count) +t_stack_slice_array ts_stack_pop_count(t_stack *self, t_stack_version version, + t_u32 count) { - return stack__iter(self, version, pop_count_callback, &count, (int)count); + return (stack__iter(self, version, pop_count_callback, &count, (int)count)); } -t_stack_action pop_pending_callback(void *payload, const t_stack_iterator *iterator) +t_stack_action pop_pending_callback(void *payload, + const t_stack_iterator *iterator) { (void)payload; if (iterator->subtree_count >= 1) { if (iterator->is_pending) - { - return SActionPop | SActionStop; - } + return (SActionPop | SActionStop); else - { - return SActionStop; - } + return (SActionStop); } else - { - return SActionNone; - } + return (SActionNone); } -t_stack_slice_array ts_stack_pop_pending(t_stack *self, t_stack_version version) +t_stack_slice_array ts_stack_pop_pending(t_stack *self, t_stack_version version) { - t_stack_slice_array pop = stack__iter(self, version, pop_pending_callback, NULL, 0); + t_stack_slice_array pop; + + pop = stack__iter(self, version, pop_pending_callback, NULL, 0); if (pop.size > 0) { ts_stack_renumber_version(self, pop.contents[0].version, version); pop.contents[0].version = version; } - return pop; + return (pop); } -t_stack_action pop_error_callback(void *payload, const t_stack_iterator *iterator) +t_stack_action pop_error_callback(void *payload, + const t_stack_iterator *iterator) { + bool *found_error; + if (iterator->subtrees.size > 0) { - bool *found_error = payload; - if (!*found_error && ts_subtree_is_error(iterator->subtrees.contents[0])) + found_error = payload; + if (!*found_error + && ts_subtree_is_error(iterator->subtrees.contents[0])) { *found_error = true; - return SActionPop | SActionStop; + return (SActionPop | SActionStop); } else - { - return SActionStop; - } + return (SActionStop); } else - { - return SActionNone; - } + return (SActionNone); } -SubtreeArray ts_stack_pop_error(t_stack *self, t_stack_version version) +SubtreeArray ts_stack_pop_error(t_stack *self, t_stack_version version) { - t_stack_node *node = array_get(&self->heads, version)->node; - for (t_u32 i = 0; i < node->link_count; i++) + t_stack_node *node; + bool found_error; + t_stack_slice_array pop; + t_usize i; + + node = array_get(&self->heads, version)->node; + i = 0; + while (i < node->link_count) { - if (node->links[i].subtree && ts_subtree_is_error(node->links[i].subtree)) + if (node->links[i].subtree + && ts_subtree_is_error(node->links[i].subtree)) { - bool found_error = false; - t_stack_slice_array pop = stack__iter(self, version, pop_error_callback, &found_error, 1); + found_error = false; + pop = stack__iter(self, version, pop_error_callback, &found_error, + 1); if (pop.size > 0) { assert(pop.size == 1); - ts_stack_renumber_version(self, pop.contents[0].version, version); - return pop.contents[0].subtrees; + ts_stack_renumber_version(self, pop.contents[0].version, + version); + return (pop.contents[0].subtrees); } - break; + break ; } + i++; } - return (SubtreeArray){.size = 0}; + return ((SubtreeArray){.size = 0}); } -t_stack_action pop_all_callback(void *payload, const t_stack_iterator *iterator) +t_stack_action pop_all_callback(void *payload, + const t_stack_iterator *iterator) { (void)payload; - return iterator->node->link_count == 0 ? SActionPop : SActionNone; + if (iterator->node->link_count == 0) + return (SActionPop); + else + return (SActionNone); } -t_stack_slice_array ts_stack_pop_all(t_stack *self, t_stack_version version) +t_stack_slice_array ts_stack_pop_all(t_stack *self, t_stack_version version) { - return stack__iter(self, version, pop_all_callback, NULL, 0); + return (stack__iter(self, version, pop_all_callback, NULL, 0)); } -t_stack_action summarize_stack_callback(void *payload, const t_stack_iterator *iterator) +t_stack_action summarize_stack_callback(void *payload, + const t_stack_iterator *iterator) { - t_summarize_stack_session *session = payload; - TSStateId state = iterator->node->state; - t_u32 depth = iterator->subtree_count; + t_summarize_stack_session *session; + TSStateId state; + t_u32 depth; + t_stack_summary_entry entry; + t_usize i; + + session = payload; + state = iterator->node->state; + depth = iterator->subtree_count; if (depth > session->max_depth) - return SActionStop; - for (t_u32 i = session->summary->size - 1; i + 1 > 0; i--) + return (SActionStop); + i = session->summary->size - 1; + while (i + 1 > 0) { - t_stack_summary_entry entry = session->summary->contents[i]; + entry = session->summary->contents[i--]; if (entry.depth < depth) - break; + break ; if (entry.depth == depth && entry.state == state) - return SActionNone; + return (SActionNone); } - array_push(session->summary, ((t_stack_summary_entry){ - .position = iterator->node->position, - .depth = depth, - .state = state, - })); - return SActionNone; + array_push(session->summary, + ((t_stack_summary_entry){ + .position = iterator->node->position, + .depth = depth, + .state = state, + })); + return (SActionNone); } -void ts_stack_record_summary(t_stack *self, t_stack_version version, t_u32 max_depth) +void ts_stack_record_summary(t_stack *self, t_stack_version version, + t_u32 max_depth) { - t_summarize_stack_session session = {.summary = mem_alloc(sizeof(t_stack_summary)), .max_depth = max_depth}; + t_summarize_stack_session session; + t_stack_head *head; + + session = (t_summarize_stack_session){.summary = mem_alloc(sizeof(t_stack_summary)), .max_depth = max_depth}; array_init(session.summary); stack__iter(self, version, summarize_stack_callback, &session, -1); - t_stack_head *head = &self->heads.contents[version]; + head = &self->heads.contents[version]; if (head->summary) { array_delete(head->summary); @@ -678,59 +730,67 @@ void ts_stack_record_summary(t_stack *self, t_stack_version version, t_u32 max_d head->summary = session.summary; } -t_stack_summary *ts_stack_get_summary(t_stack *self, t_stack_version version) +t_stack_summary *ts_stack_get_summary(t_stack *self, t_stack_version version) { - return array_get(&self->heads, version)->summary; + return (array_get(&self->heads, version)->summary); } -int ts_stack_dynamic_precedence(t_stack *self, t_stack_version version) +int ts_stack_dynamic_precedence(t_stack *self, t_stack_version version) { - return array_get(&self->heads, version)->node->dynamic_precedence; + return (array_get(&self->heads, version)->node->dynamic_precedence); } -bool ts_stack_has_advanced_since_error(const t_stack *self, t_stack_version version) +bool ts_stack_has_advanced_since_error(const t_stack *self, + t_stack_version version) { - const t_stack_head *head = array_get(&self->heads, version); - const t_stack_node *node = head->node; + const t_stack_head *head = array_get(&self->heads, version); + const t_stack_node *node = head->node; + Subtree subtree; + if (node->error_cost == 0) - return true; + return (true); while (node) { if (node->link_count > 0) { - Subtree subtree = node->links[0].subtree; + subtree = node->links[0].subtree; if (subtree) { if (ts_subtree_total_bytes(subtree) > 0) { - return true; + return (true); } - else if (node->node_count > head->node_count_at_last_error && ts_subtree_error_cost(subtree) == 0) + else if (node->node_count > head->node_count_at_last_error + && ts_subtree_error_cost(subtree) == 0) { node = node->links[0].node; - continue; + continue ; } } } - break; + break ; } - return false; + return (false); } -void ts_stack_remove_version(t_stack *self, t_stack_version version) +void ts_stack_remove_version(t_stack *self, t_stack_version version) { stack_head_delete(array_get(&self->heads, version)); array_erase(&self->heads, version); } -void ts_stack_renumber_version(t_stack *self, t_stack_version v1, t_stack_version v2) +void ts_stack_renumber_version(t_stack *self, t_stack_version v1, + t_stack_version v2) { + t_stack_head *source_head; + t_stack_head *target_head; + if (v1 == v2) - return; + return ; assert(v2 < v1); assert((t_u32)v1 < self->heads.size); - t_stack_head *source_head = &self->heads.contents[v1]; - t_stack_head *target_head = &self->heads.contents[v2]; + source_head = &self->heads.contents[v1]; + target_head = &self->heads.contents[v2]; if (target_head->summary && !source_head->summary) { source_head->summary = target_head->summary; @@ -741,104 +801,126 @@ void ts_stack_renumber_version(t_stack *self, t_stack_version v1, t_stack_versio array_erase(&self->heads, v1); } -void ts_stack_swap_versions(t_stack *self, t_stack_version v1, t_stack_version v2) +void ts_stack_swap_versions(t_stack *self, t_stack_version v1, + t_stack_version v2) { - t_stack_head temporary_head = self->heads.contents[v1]; + t_stack_head temporary_head; + + temporary_head = self->heads.contents[v1]; self->heads.contents[v1] = self->heads.contents[v2]; self->heads.contents[v2] = temporary_head; } -t_stack_version ts_stack_copy_version(t_stack *self, t_stack_version version) +t_stack_version ts_stack_copy_version(t_stack *self, t_stack_version version) { + t_stack_head *head; + assert(version < self->heads.size); array_push(&self->heads, self->heads.contents[version]); - t_stack_head *head = array_back(&self->heads); + head = array_back(&self->heads); stack_node_retain(head->node); if (head->last_external_token) ts_subtree_retain(head->last_external_token); head->summary = NULL; - return self->heads.size - 1; + return (self->heads.size - 1); } -bool ts_stack_merge(t_stack *self, t_stack_version version1, t_stack_version version2) +bool ts_stack_merge(t_stack *self, t_stack_version version1, + t_stack_version version2) { + t_stack_head *head1; + t_stack_head *head2; + t_usize i; + if (!ts_stack_can_merge(self, version1, version2)) - return false; - t_stack_head *head1 = &self->heads.contents[version1]; - t_stack_head *head2 = &self->heads.contents[version2]; - for (t_u32 i = 0; i < head2->node->link_count; i++) - { - stack_node_add_link(head1->node, head2->node->links[i]); - } + return (false); + head1 = &self->heads.contents[version1]; + head2 = &self->heads.contents[version2]; + i = 0; + while (i < head2->node->link_count) + stack_node_add_link(head1->node, head2->node->links[i++]); if (head1->node->state == ERROR_STATE) - { head1->node_count_at_last_error = head1->node->node_count; - } ts_stack_remove_version(self, version2); - return true; + return (true); } -bool ts_stack_can_merge(t_stack *self, t_stack_version version1, t_stack_version version2) +bool ts_stack_can_merge(t_stack *self, t_stack_version version1, + t_stack_version version2) { - t_stack_head *head1 = &self->heads.contents[version1]; - t_stack_head *head2 = &self->heads.contents[version2]; - return head1->status == SStatusActive && head2->status == SStatusActive && head1->node->state == head2->node->state && - head1->node->position.bytes == head2->node->position.bytes && head1->node->error_cost == head2->node->error_cost && - ts_subtree_external_scanner_state_eq(head1->last_external_token, head2->last_external_token); + t_stack_head *head1; + t_stack_head *head2; + + head1 = &self->heads.contents[version1]; + head2 = &self->heads.contents[version2]; + return (head1->status == SStatusActive && head2->status == SStatusActive + && head1->node->state == head2->node->state + && head1->node->position.bytes == head2->node->position.bytes + && head1->node->error_cost == head2->node->error_cost + && ts_subtree_external_scanner_state_eq(head1->last_external_token, + head2->last_external_token)); } -void ts_stack_halt(t_stack *self, t_stack_version version) +void ts_stack_halt(t_stack *self, t_stack_version version) { array_get(&self->heads, version)->status = SStatusHalted; } -void ts_stack_pause(t_stack *self, t_stack_version version, Subtree lookahead) +void ts_stack_pause(t_stack *self, t_stack_version version, + Subtree lookahead) { - t_stack_head *head = array_get(&self->heads, version); + t_stack_head *head; + + head = array_get(&self->heads, version); head->status = SStatusPaused; head->lookahead_when_paused = lookahead; head->node_count_at_last_error = head->node->node_count; } -bool ts_stack_is_active(const t_stack *self, t_stack_version version) +bool ts_stack_is_active(const t_stack *self, t_stack_version version) { - return array_get(&self->heads, version)->status == SStatusActive; + return (array_get(&self->heads, version)->status == SStatusActive); } -bool ts_stack_is_halted(const t_stack *self, t_stack_version version) +bool ts_stack_is_halted(const t_stack *self, t_stack_version version) { - return array_get(&self->heads, version)->status == SStatusHalted; + return (array_get(&self->heads, version)->status == SStatusHalted); } -bool ts_stack_is_paused(const t_stack *self, t_stack_version version) +bool ts_stack_is_paused(const t_stack *self, t_stack_version version) { - return array_get(&self->heads, version)->status == SStatusPaused; + return (array_get(&self->heads, version)->status == SStatusPaused); } -Subtree ts_stack_resume(t_stack *self, t_stack_version version) +Subtree ts_stack_resume(t_stack *self, t_stack_version version) { - t_stack_head *head = array_get(&self->heads, version); + t_stack_head *head; + Subtree result; + + head = array_get(&self->heads, version); assert(head->status == SStatusPaused); - Subtree result = head->lookahead_when_paused; + result = head->lookahead_when_paused; head->status = SStatusActive; head->lookahead_when_paused = NULL; - return result; + return (result); } -void ts_stack_clear(t_stack *self) +void ts_stack_clear(t_stack *self) { + t_usize i; + stack_node_retain(self->base_node); - for (t_u32 i = 0; i < self->heads.size; i++) - { - stack_head_delete(&self->heads.contents[i]); - } + i = 0; + while (i < self->heads.size) + stack_head_delete(&self->heads.contents[i++]); array_clear(&self->heads); - array_push(&self->heads, ((t_stack_head){ - .node = self->base_node, - .status = SStatusActive, - .last_external_token = NULL, - .lookahead_when_paused = NULL, - })); + array_push(&self->heads, + ((t_stack_head){ + .node = self->base_node, + .status = SStatusActive, + .last_external_token = NULL, + .lookahead_when_paused = NULL, + })); } #undef forceinline