From cff5618664e1dac2c5d4a8d2d540075dc9686147 Mon Sep 17 00:00:00 2001 From: maix0 Date: Thu, 19 Sep 2024 18:58:51 +0200 Subject: [PATCH] update: almost fully normed parser/src/stack ! --- parser/include/parser/inner/stack_inner.h | 20 ++- parser/src/stack/stack_add_link.c | 129 ++++++++------ parser/src/stack/stack_funcs2.c | 26 ++- parser/src/stack/stack_funcs4.c | 21 ++- parser/src/stack/stack_iter.c | 208 ++++++++++++---------- parser/src/stack/stack_manipulate.c | 12 +- parser/src/stack/stack_manipulate3.c | 23 ++- parser/src/stack/stack_node.c | 117 ++++++------ parser/src/stack/stack_summary.c | 13 +- 9 files changed, 316 insertions(+), 253 deletions(-) diff --git a/parser/include/parser/inner/stack_inner.h b/parser/include/parser/inner/stack_inner.h index f2a81891..911584e4 100644 --- a/parser/include/parser/inner/stack_inner.h +++ b/parser/include/parser/inner/stack_inner.h @@ -6,7 +6,7 @@ /* By: maiboyer +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2024/08/31 16:37:50 by maiboyer #+# #+# */ -/* Updated: 2024/09/19 16:42:26 by maiboyer ### ########.fr */ +/* Updated: 2024/09/19 18:23:03 by maiboyer ### ########.fr */ /* */ /* ************************************************************************** */ @@ -126,6 +126,22 @@ struct s_stack_push_arg t_state_id state; }; +struct s_stack_iter_args +{ + t_stack_version version; + t_stack_callback callback; + void *payload; + int goal_subtree_count; +}; + +struct s_stack_iter_indexes +{ + t_usize i; + t_usize j; + t_usize size; +}; + + t_length ts_stack_position(const t_stack *self, t_stack_version version); t_state_id ts_stack_state(const t_stack *self, t_stack_version version); bool stack__subtree_is_equivalent(t_subtree left, t_subtree right); @@ -143,7 +159,7 @@ t_stack_action pop_error_callback(void *payload, const t_stack_iterator *iterato t_stack_action pop_pending_callback(void *payload, const t_stack_iterator *iterator); t_stack_action summarize_stack_callback(void *payload, const t_stack_iterator *iterator); t_stack_node *stack_node_new(t_stack_node *previous_node, t_subtree subtree, bool is_pending, t_state_id state); -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_slice_array stack__iter(t_stack *self, struct s_stack_iter_args args); t_stack_slice_array ts_stack_pop_all(t_stack *self, t_stack_version version); 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_pending(t_stack *self, t_stack_version version); diff --git a/parser/src/stack/stack_add_link.c b/parser/src/stack/stack_add_link.c index 5856a6f2..ce28323f 100644 --- a/parser/src/stack/stack_add_link.c +++ b/parser/src/stack/stack_add_link.c @@ -6,66 +6,18 @@ /* By: maiboyer +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2024/08/31 16:52:46 by maiboyer #+# #+# */ -/* Updated: 2024/08/31 16:59:20 by maiboyer ### ########.fr */ +/* Updated: 2024/09/19 18:49:32 by maiboyer ### ########.fr */ /* */ /* ************************************************************************** */ #include "parser/inner/stack_inner.h" #include "parser/inner/stack_inner.h" -// 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. -void stack_node_add_link(t_stack_node *self, t_stack_link link) +void _add_link_tail(t_stack_node *self, t_stack_link link) { - t_stack_link *existing_link; - t_i32 dynamic_precedence; - t_u32 node_count; - t_usize i; - t_usize j; + t_i32 dynamic_precedence; + t_u32 node_count; - if (link.node == self) - return ; - i = 0; - while (i < self->link_count) - { - existing_link = &self->links[i]; - if (stack__subtree_is_equivalent(existing_link->subtree, link.subtree)) - { - if (existing_link->node == link.node) - { - if (ts_subtree_dynamic_precedence(\ - link.subtree) > ts_subtree_dynamic_precedence(existing_link->subtree)) - { - (link.subtree->ref_count++); - ts_subtree_release(existing_link->subtree); - existing_link->subtree = link.subtree; - self->dynamic_precedence = link.node->dynamic_precedence - + ts_subtree_dynamic_precedence(link.subtree); - } - return ; - } - 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) - { - j = 0; - while (j < link.node->link_count) - stack_node_add_link(existing_link->node, - link.node->links[j++]); - dynamic_precedence = link.node->dynamic_precedence; - if (link.subtree) - dynamic_precedence - += ts_subtree_dynamic_precedence(link.subtree); - if (dynamic_precedence > self->dynamic_precedence) - self->dynamic_precedence = dynamic_precedence; - return ; - } - } - i++; - } if (self->link_count == MAX_LINK_COUNT) return ; stack_node_retain(link.node); @@ -83,3 +35,76 @@ void stack_node_add_link(t_stack_node *self, t_stack_link link) if (dynamic_precedence > self->dynamic_precedence) self->dynamic_precedence = dynamic_precedence; } + +bool _is_link_node_similar(\ + t_stack_node *self, t_stack_link link, \ + t_stack_link *ext_link) +{ + t_usize j; + t_i32 dynamic_precedence; + + if (ext_link->node->state == link.node->state \ + && ext_link->node->position.bytes == link.node->position.bytes + && ext_link->node->error_cost == link.node->error_cost) + { + j = 0; + while (j < link.node->link_count) + stack_node_add_link(ext_link->node, + link.node->links[j++]); + dynamic_precedence = link.node->dynamic_precedence; + if (link.subtree) + dynamic_precedence + += ts_subtree_dynamic_precedence(link.subtree); + if (dynamic_precedence > self->dynamic_precedence) + self->dynamic_precedence = dynamic_precedence; + return (true); + } + return (false); +} + +bool _is_link_same_node(\ + t_stack_node *self, t_stack_link link, \ + t_stack_link *ext_link) +{ + if (ext_link->node == link.node) + { + if (ts_subtree_dynamic_precedence(\ + link.subtree) > ts_subtree_dynamic_precedence(ext_link->subtree)) + { + link.subtree->ref_count++; + ts_subtree_release(ext_link->subtree); + ext_link->subtree = link.subtree; + self->dynamic_precedence = link.node->dynamic_precedence + + ts_subtree_dynamic_precedence(link.subtree); + } + return (true); + } + return (false); +} + +// 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. +void stack_node_add_link(t_stack_node *self, t_stack_link link) +{ + t_stack_link *ext_link; + t_usize i; + + if (link.node == self) + return ; + i = 0; + while (i < self->link_count) + { + ext_link = &self->links[i]; + if (stack__subtree_is_equivalent(ext_link->subtree, link.subtree)) + { + if (_is_link_same_node(self, link, ext_link) \ + || _is_link_node_similar(self, link, ext_link)) + return ; + } + i++; + } + _add_link_tail(self, link); +} diff --git a/parser/src/stack/stack_funcs2.c b/parser/src/stack/stack_funcs2.c index 1b432911..7e7bc4e6 100644 --- a/parser/src/stack/stack_funcs2.c +++ b/parser/src/stack/stack_funcs2.c @@ -6,7 +6,7 @@ /* By: maiboyer +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2024/08/31 16:55:52 by maiboyer #+# #+# */ -/* Updated: 2024/09/02 18:06:38 by maiboyer ### ########.fr */ +/* Updated: 2024/09/19 18:38:38 by maiboyer ### ########.fr */ /* */ /* ************************************************************************** */ @@ -57,24 +57,20 @@ bool ts_stack_has_advanced_since_error(const t_stack *self, return (true); while (node) { - if (node->link_count > 0) + if (node->link_count == 0) + break ; + subtree = node->links[0].subtree; + if (subtree) { - subtree = node->links[0].subtree; - if (subtree) + if (ts_subtree_total_bytes(subtree) > 0) + return (true); + else if (node->node_count > head->node_count_at_last_error + && ts_subtree_error_cost(subtree) == 0) { - if (ts_subtree_total_bytes(subtree) > 0) - { - return (true); - } - else if (node->node_count > head->node_count_at_last_error - && ts_subtree_error_cost(subtree) == 0) - { - node = node->links[0].node; - continue ; - } + node = node->links[0].node; + continue ; } } - break ; } return (false); } diff --git a/parser/src/stack/stack_funcs4.c b/parser/src/stack/stack_funcs4.c index 556f7ae1..a19ae73d 100644 --- a/parser/src/stack/stack_funcs4.c +++ b/parser/src/stack/stack_funcs4.c @@ -6,12 +6,13 @@ /* By: maiboyer +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2024/08/31 16:58:39 by maiboyer #+# #+# */ -/* Updated: 2024/08/31 16:58:51 by maiboyer ### ########.fr */ +/* Updated: 2024/09/19 18:37:14 by maiboyer ### ########.fr */ /* */ /* ************************************************************************** */ #include "parser/inner/stack_inner.h" #include "parser/inner/stack_inner.h" +#include "parser/language.h" t_u32 ts_stack_version_count(const t_stack *self) { @@ -33,3 +34,21 @@ t_subtree ts_stack_last_external_token(const t_stack *self, { return (array_get(&self->heads, version)->last_external_token); } + +/// 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. +// +// 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. +t_u32 stack__subtree_node_count(t_subtree subtree) +{ + t_u32 count; + + count = ts_subtree_visible_descendant_count(subtree); + if (ts_subtree_visible(subtree)) + count++; + if (ts_subtree_symbol(subtree) == ts_builtin_sym_error_repeat) + count++; + return (count); +} diff --git a/parser/src/stack/stack_iter.c b/parser/src/stack/stack_iter.c index f55cd28f..3ee545f3 100644 --- a/parser/src/stack/stack_iter.c +++ b/parser/src/stack/stack_iter.c @@ -6,7 +6,7 @@ /* By: maiboyer +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2024/08/31 16:46:43 by maiboyer #+# #+# */ -/* Updated: 2024/09/02 21:22:19 by maiboyer ### ########.fr */ +/* Updated: 2024/09/19 18:57:31 by maiboyer ### ########.fr */ /* */ /* ************************************************************************** */ @@ -14,117 +14,133 @@ #include "parser/inner/stack_inner.h" #include "parser/inner/stack_inner.h" -t_stack_slice_array stack__iter(t_stack *self, t_stack_version version, - t_stack_callback callback, void *payload, int goal_subtree_count) +void _set_stack_iter_vars(\ + t_stack *self, struct s_stack_iter_args *args) { - 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; - t_vec_subtree subtrees; - t_stack_iterator *next_iterator; - t_stack_link link; - t_stack_iterator current_iterator; t_stack_iterator new_iterator; - t_usize i; - t_usize j; - t_usize size; + t_stack_head *head; array_clear(&self->slices); array_clear(&self->iterators); - head = array_get(&self->heads, version); + head = array_get(&self->heads, args->version); new_iterator = (t_stack_iterator){ .node = head->node, .subtrees = vec_subtree_new(16, NULL), .subtree_count = 0, .is_pending = true, }; - include_subtrees = false; - if (goal_subtree_count >= 0) - { - include_subtrees = true; - vec_subtree_reserve(&new_iterator.subtrees, - ts_subtree_alloc_size(goal_subtree_count) / sizeof(t_subtree)); - } + if (args->goal_subtree_count >= 0) + vec_subtree_reserve(&new_iterator.subtrees, \ + ts_subtree_alloc_size(args->goal_subtree_count) / sizeof(t_subtree)); array_push(&self->iterators, new_iterator); +} + +bool _handle_pop_stop(\ + t_stack *self, struct s_stack_iter_args *args, \ + struct s_stack_iter_indexes *idx, t_stack_node **node) +{ + t_stack_action action; + t_stack_iterator *iterator; + t_vec_subtree subtrees; + + iterator = &self->iterators.contents[idx->i]; + *node = iterator->node; + action = args->callback(args->payload, iterator); + if (action & SActionPop) + { + subtrees = iterator->subtrees; + if (action & SActionStop || (*node)->link_count == 0) + ts_subtree_array_copy(subtrees, &subtrees); + vec_subtree_reverse(&subtrees); + ts_stack__add_slice(self, args->version, *node, &subtrees); + } + if (action & SActionStop || (*node)->link_count == 0) + { + if (!(action & SActionPop)) + ts_subtree_array_delete(&iterator->subtrees); + (array_erase(&self->iterators, idx->i), idx->size--); + return (true); + } + return (false); +} + +void _stack_iter_misc(t_stack_link *link, t_stack_iterator **next_iterator, \ + struct s_stack_iter_args *args) +{ + (*next_iterator)->node = link->node; + if (link->subtree) + { + if (args->goal_subtree_count >= 0) + { + vec_subtree_push(&(*next_iterator)->subtrees, link->subtree); + link->subtree->ref_count++; + } + if (!ts_subtree_extra(link->subtree)) + { + (*next_iterator)->subtree_count++; + if (!link->is_pending) + (*next_iterator)->is_pending = false; + } + } + else + { + (*next_iterator)->subtree_count++; + (*next_iterator)->is_pending = false; + } +} + +void _func(t_stack *self, \ + t_stack_link *link, \ + t_stack_iterator **next_iterator, \ + struct s_stack_iter_args *args, \ + t_stack_node **node, \ + struct s_stack_iter_indexes *idx) +{ + t_stack_iterator current_iterator; + + if (idx->j == (*node)->link_count) + { + *link = (*node)->links[0]; + *next_iterator = &self->iterators.contents[idx->i]; + } + else + { + if (self->iterators.size >= MAX_ITERATOR_COUNT) + { + idx->j++; + return ; + } + *link = (*node)->links[idx->j]; + current_iterator = self->iterators.contents[idx->i]; + array_push(&self->iterators, current_iterator); + *next_iterator = array_back(&self->iterators); + ts_subtree_array_copy((*next_iterator)->subtrees, + &(*next_iterator)->subtrees); + } + _stack_iter_misc(link, next_iterator, args); + idx->j++; +} + +t_stack_slice_array stack__iter(t_stack *self, struct s_stack_iter_args args) +{ + t_stack_iterator *next_iterator; + t_stack_link link; + t_stack_node *node; + struct s_stack_iter_indexes idx; + + _set_stack_iter_vars(self, &args); while (self->iterators.size > 0) { - i = 0; - size = self->iterators.size; - while (i < size) + idx.i = 0; + idx.size = self->iterators.size; + while (idx.i < idx.size) { - 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) - { - subtrees = iterator->subtrees; - if (!should_stop) - ts_subtree_array_copy(subtrees, &subtrees); - vec_subtree_reverse(&subtrees); - ts_stack__add_slice(self, version, node, &subtrees); - } - if (should_stop) - { - if (!should_pop) - ts_subtree_array_delete(&iterator->subtrees); - array_erase(&self->iterators, i); - i--; - i++; - size--; + if (_handle_pop_stop(self, &args, &idx, &node)) continue ; - } - j = 1; - while (j <= node->link_count) - { - if (j == node->link_count) - { - link = node->links[0]; - next_iterator = &self->iterators.contents[i]; - } - else - { - if (self->iterators.size >= MAX_ITERATOR_COUNT) - { - j++; - continue ; - } - link = node->links[j]; - 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); - } - next_iterator->node = link.node; - if (link.subtree) - { - if (include_subtrees) - { - vec_subtree_push(&next_iterator->subtrees, - link.subtree); - link.subtree->ref_count++; - } - if (!ts_subtree_extra(link.subtree)) - { - next_iterator->subtree_count++; - if (!link.is_pending) - next_iterator->is_pending = false; - } - } - else - { - next_iterator->subtree_count++; - next_iterator->is_pending = false; - } - j++; - } - i++; + idx.j = 1; + while (idx.j <= node->link_count) + _func(self, &link, &next_iterator, &args, &node, &idx); + idx.i++; } } return (self->slices); diff --git a/parser/src/stack/stack_manipulate.c b/parser/src/stack/stack_manipulate.c index a175e5a8..d4300bf8 100644 --- a/parser/src/stack/stack_manipulate.c +++ b/parser/src/stack/stack_manipulate.c @@ -6,7 +6,7 @@ /* By: maiboyer +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2024/08/31 16:50:04 by maiboyer #+# #+# */ -/* Updated: 2024/09/19 14:44:37 by maiboyer ### ########.fr */ +/* Updated: 2024/09/19 17:57:27 by maiboyer ### ########.fr */ /* */ /* ************************************************************************** */ @@ -19,7 +19,8 @@ void ts_stack_push(t_stack *self, struct s_stack_push_arg args) t_stack_node *new_node; head = array_get(&self->heads, args.version); - new_node = stack_node_new(head->node, args.subtree, args.pending, args.state); + new_node = stack_node_new(\ + head->node, args.subtree, args.pending, args.state); if (!args.subtree) head->node_count_at_last_error = new_node->node_count; head->node = new_node; @@ -44,7 +45,9 @@ t_stack_action pop_count_callback(void *payload, 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, \ + (struct s_stack_iter_args){version, pop_count_callback, \ + &count, (int)count})); } t_stack_action pop_pending_callback(void *payload, @@ -66,7 +69,8 @@ t_stack_slice_array ts_stack_pop_pending(t_stack *self, t_stack_version version) { t_stack_slice_array pop; - pop = stack__iter(self, version, pop_pending_callback, NULL, 0); + pop = stack__iter(self, \ + (struct s_stack_iter_args){version, pop_pending_callback, NULL, 0}); if (pop.size > 0) { ts_stack_renumber_version(self, pop.contents[0].version, version); diff --git a/parser/src/stack/stack_manipulate3.c b/parser/src/stack/stack_manipulate3.c index 047aa832..44446640 100644 --- a/parser/src/stack/stack_manipulate3.c +++ b/parser/src/stack/stack_manipulate3.c @@ -6,7 +6,7 @@ /* By: maiboyer +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2024/08/31 17:00:07 by maiboyer #+# #+# */ -/* Updated: 2024/09/02 20:53:54 by maiboyer ### ########.fr */ +/* Updated: 2024/09/19 18:26:48 by maiboyer ### ########.fr */ /* */ /* ************************************************************************** */ @@ -36,26 +36,24 @@ t_stack_action pop_error_callback(void *payload, t_vec_subtree ts_stack_pop_error(t_stack *self, t_stack_version version) { - t_stack_node *node; + t_stack_node *n; bool found_error; t_stack_slice_array pop; t_usize i; - node = array_get(&self->heads, version)->node; + n = array_get(&self->heads, version)->node; i = 0; - while (i < node->link_count) + while (i < n->link_count) { - if (node->links[i].subtree - && ts_subtree_is_error(node->links[i].subtree)) + if (n->links[i].subtree && ts_subtree_is_error(n->links[i].subtree)) { found_error = false; - pop = stack__iter(self, version, pop_error_callback, &found_error, - 1); + pop = stack__iter(self, \ + (struct s_stack_iter_args){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); + ts_stack_renumber_version(\ + self, pop.contents[0].version, version); return (pop.contents[0].subtrees); } break ; @@ -77,5 +75,6 @@ t_stack_action pop_all_callback(void *payload, 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, \ + (struct s_stack_iter_args){version, pop_all_callback, NULL, 0})); } diff --git a/parser/src/stack/stack_node.c b/parser/src/stack/stack_node.c index ced71ee5..8255aec2 100644 --- a/parser/src/stack/stack_node.c +++ b/parser/src/stack/stack_node.c @@ -6,7 +6,7 @@ /* By: maiboyer +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2024/08/31 16:48:48 by maiboyer #+# #+# */ -/* Updated: 2024/08/31 16:49:38 by maiboyer ### ########.fr */ +/* Updated: 2024/09/19 18:37:07 by maiboyer ### ########.fr */ /* */ /* ************************************************************************** */ @@ -23,93 +23,80 @@ void stack_node_retain(t_stack_node *self) assert(self->ref_count != 0); } -void stack_node_release(t_stack_node *self) +void _stack_node_release_inner(\ + t_stack_node **self, bool *continue_, t_stack_link *link) { t_stack_node *first_predecessor; + t_usize i; + + first_predecessor = NULL; + if ((*self)->link_count > 0) + { + i = (*self)->link_count - 1; + while (i > 0) + { + *link = (*self)->links[i]; + if (link->subtree) + ts_subtree_release(link->subtree); + stack_node_release(link->node); + i--; + } + *link = (*self)->links[0]; + if (link->subtree) + ts_subtree_release(link->subtree); + first_predecessor = (*self)->links[0].node; + } + if (mem_free(*self), first_predecessor) + { + *self = first_predecessor; + *continue_ = true; + } +} + +void stack_node_release(t_stack_node *self) +{ t_stack_link link; bool continue_; - t_usize i; continue_ = true; while (continue_) { continue_ = false; - assert(self->ref_count != 0); self->ref_count--; if (self->ref_count > 0) return ; - first_predecessor = NULL; - if (self->link_count > 0) - { - i = self->link_count - 1; - while (i > 0) - { - link = self->links[i]; - if (link.subtree) - ts_subtree_release(link.subtree); - stack_node_release(link.node); - i--; - } - 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; - continue_ = true; - } + _stack_node_release_inner(&self, &continue_, &link); } } -/// 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. -// -// 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. -t_u32 stack__subtree_node_count(t_subtree subtree) +void _node_new_from_previous(t_stack_node *node, t_stack_node *prev, \ + t_subtree subtree, bool is_pending) { - t_u32 count; - - count = ts_subtree_visible_descendant_count(subtree); - if (ts_subtree_visible(subtree)) - count++; - if (ts_subtree_symbol(subtree) == ts_builtin_sym_error_repeat) - count++; - return (count); + node->link_count = prev != NULL; + node->links[0] = (t_stack_link){prev, subtree, is_pending}; + node->position = prev->position; + node->error_cost = prev->error_cost; + node->dynamic_precedence = prev->dynamic_precedence; + node->node_count = prev->node_count; + if (subtree) + { + node->error_cost += ts_subtree_error_cost(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); + } } -t_stack_node *stack_node_new(t_stack_node *previous_node, +t_stack_node *stack_node_new(t_stack_node *prev, t_subtree subtree, bool is_pending, t_state_id 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; - node->links[0] = (t_stack_link){ - .node = previous_node, - .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->node_count += stack__subtree_node_count(subtree); - node->dynamic_precedence += ts_subtree_dynamic_precedence(subtree); - } - } + *node = (typeof(*node)){.ref_count = 1, .link_count = 0, .state = state}; + if (prev != NULL) + _node_new_from_previous(node, prev, subtree, is_pending); else { node->position = length_zero(); diff --git a/parser/src/stack/stack_summary.c b/parser/src/stack/stack_summary.c index 8d874e19..8b9e8a56 100644 --- a/parser/src/stack/stack_summary.c +++ b/parser/src/stack/stack_summary.c @@ -6,7 +6,7 @@ /* By: maiboyer +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2024/08/31 16:50:56 by maiboyer #+# #+# */ -/* Updated: 2024/09/02 17:20:31 by maiboyer ### ########.fr */ +/* Updated: 2024/09/19 18:25:51 by maiboyer ### ########.fr */ /* */ /* ************************************************************************** */ @@ -46,20 +46,21 @@ t_stack_action summarize_stack_callback(void *payload, void ts_stack_record_summary(t_stack *self, t_stack_version version, t_u32 max_depth) { - t_summarize_stack_session session; + t_summarize_stack_session sess; t_stack_head *head; - session = (t_summarize_stack_session){.summary = \ + sess = (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); + array_init(sess.summary); + stack__iter(self, \ + (struct s_stack_iter_args){version, summarize_stack_callback, &sess, -1}); head = &self->heads.contents[version]; if (head->summary) { array_delete(head->summary); mem_free(head->summary); } - head->summary = session.summary; + head->summary = sess.summary; } t_stack_summary *ts_stack_get_summary(t_stack *self, t_stack_version version)