raphael/minishell
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

update: almost fully normed parser/src/stack !

Browse source
This commit is contained in:
maix0 2024-09-19 18:58:51 +02:00
parent bec1320c5f
commit cff5618664
9 changed files with 316 additions and 253 deletions
Download patch file Download diff file Expand all files Collapse all files

20
parser/include/parser/inner/stack_inner.h
View file

@ -6,7 +6,7 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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);

125
parser/src/stack/stack_add_link.c
View file

@ -6,66 +6,18 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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;
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);
}

10
parser/src/stack/stack_funcs2.c
View file

@ -6,7 +6,7 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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,15 +57,13 @@ 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)
{
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)
{
@ -74,7 +72,5 @@ bool ts_stack_has_advanced_since_error(const t_stack *self,
}
}
}
break ;
}
return (false);
}

21
parser/src/stack/stack_funcs4.c
View file

@ -6,12 +6,13 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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);
}

176
parser/src/stack/stack_iter.c
View file

@ -6,7 +6,7 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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);
while (self->iterators.size > 0)
{
i = 0;
size = self->iterators.size;
while (i < 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)
}
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 (!should_stop)
if (action & SActionStop || (*node)->link_count == 0)
ts_subtree_array_copy(subtrees, &subtrees);
vec_subtree_reverse(&subtrees);
ts_stack__add_slice(self, version, node, &subtrees);
ts_stack__add_slice(self, args->version, *node, &subtrees);
}
if (should_stop)
if (action & SActionStop || (*node)->link_count == 0)
{
if (!should_pop)
if (!(action & SActionPop))
ts_subtree_array_delete(&iterator->subtrees);
array_erase(&self->iterators, i);
i--;
i++;
size--;
continue ;
(array_erase(&self->iterators, idx->i), idx->size--);
return (true);
}
j = 1;
while (j <= node->link_count)
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 (j == node->link_count)
if (args->goal_subtree_count >= 0)
{
link = node->links[0];
next_iterator = &self->iterators.contents[i];
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)
{
j++;
continue ;
idx->j++;
return ;
}
link = node->links[j];
current_iterator = self->iterators.contents[i];
*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);
*next_iterator = array_back(&self->iterators);
ts_subtree_array_copy((*next_iterator)->subtrees,
&(*next_iterator)->subtrees);
}
next_iterator->node = link.node;
if (link.subtree)
_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)
{
if (include_subtrees)
idx.i = 0;
idx.size = self->iterators.size;
while (idx.i < idx.size)
{
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++;
if (_handle_pop_stop(self, &args, &idx, &node))
continue ;
idx.j = 1;
while (idx.j <= node->link_count)
_func(self, &link, &next_iterator, &args, &node, &idx);
idx.i++;
}
}
return (self->slices);

12
parser/src/stack/stack_manipulate.c
View file

@ -6,7 +6,7 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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);

23
parser/src/stack/stack_manipulate3.c
View file

@ -6,7 +6,7 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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}));
}

117
parser/src/stack/stack_node.c
View file

@ -6,7 +6,7 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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();

13
parser/src/stack/stack_summary.c
View file

@ -6,7 +6,7 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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)