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

Restored to old state that doesn't leak

Browse source
This commit is contained in:
Maix0 2024-08-18 21:46:29 +02:00
parent 1a74bb38d3
commit 7329c95ba0
11 changed files with 1028 additions and 328 deletions
Download patch file Download diff file Expand all files Collapse all files

120
parser/src/stack.c
View file

@ -1,11 +1,11 @@
#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/subtree.h"
#include "me/mem/mem.h"
#include "me/types.h"
#include <assert.h>
#include <stdio.h>
@ -24,14 +24,14 @@ typedef struct StackLink
struct StackNode
{
TSStateId state;
Length position;
StackLink 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;
StackLink links[MAX_LINK_COUNT];
t_u16 link_count;
t_u32 ref_count;
t_u32 error_cost;
t_u32 node_count;
int dynamic_precedence;
};
typedef struct StackIterator
@ -55,7 +55,7 @@ typedef struct StackHead
{
StackNode *node;
StackSummary *summary;
t_u32 node_count_at_last_error;
t_u32 node_count_at_last_error;
Subtree last_external_token;
Subtree lookahead_when_paused;
StackStatus status;
@ -66,7 +66,9 @@ struct Stack
Array(StackHead) heads;
StackSliceArray slices;
Array(StackIterator) iterators;
StackNode *base_node;
StackNodeArray node_pool;
StackNode *base_node;
SubtreePool *subtree_pool;
};
typedef t_u32 StackAction;
@ -79,7 +81,7 @@ enum StackAction
typedef StackAction (*StackCallback)(void *, const StackIterator *);
/*R static R*/ void stack_node_retain(StackNode *self)
static void stack_node_retain(StackNode *self)
{
if (!self)
return;
@ -88,7 +90,7 @@ typedef StackAction (*StackCallback)(void *, const StackIterator *);
assert(self->ref_count != 0);
}
/*R static R*/ void stack_node_release(StackNode *self)
static void stack_node_release(StackNode *self, StackNodeArray *pool, SubtreePool *subtree_pool)
{
recur:
assert(self->ref_count != 0);
@ -103,15 +105,24 @@ recur:
{
StackLink link = self->links[i];
if (link.subtree.ptr)
ts_subtree_release(link.subtree);
stack_node_release(link.node);
ts_subtree_release(subtree_pool, link.subtree);
stack_node_release(link.node, pool, subtree_pool);
}
StackLink link = self->links[0];
if (link.subtree.ptr)
ts_subtree_release(link.subtree);
ts_subtree_release(subtree_pool, link.subtree);
first_predecessor = self->links[0].node;
}
mem_free(self);
if (pool->size < MAX_NODE_POOL_SIZE)
{
array_push(pool, self);
}
else
{
mem_free(self);
}
if (first_predecessor)
{
self = first_predecessor;
@ -121,7 +132,7 @@ 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.
/*R static R*/ 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);
if (ts_subtree_visible(subtree))
@ -136,9 +147,9 @@ recur:
return count;
}
/*R static R*/ StackNode *stack_node_new(StackNode *previous_node, Subtree subtree, bool is_pending, TSStateId state)
static StackNode *stack_node_new(StackNode *previous_node, Subtree subtree, bool is_pending, TSStateId state, StackNodeArray *pool)
{
StackNode *node = mem_alloc(sizeof(*node));
StackNode *node = pool->size > 0 ? array_pop(pool) : mem_alloc(sizeof(StackNode));
*node = (StackNode){.ref_count = 1, .link_count = 0, .state = state};
if (previous_node)
@ -172,7 +183,7 @@ recur:
return node;
}
/*R static R*/ bool stack__subtree_is_equivalent(Subtree left, Subtree right)
static bool stack__subtree_is_equivalent(Subtree left, Subtree right)
{
if (left.ptr == right.ptr)
return true;
@ -192,7 +203,7 @@ recur:
ts_subtree_extra(left) == ts_subtree_extra(right) && ts_subtree_external_scanner_state_eq(left, right));
}
/*R static R*/ void stack_node_add_link(StackNode *self, StackLink link)
static void stack_node_add_link(StackNode *self, StackLink link, SubtreePool *subtree_pool)
{
if (link.node == self)
return;
@ -211,7 +222,7 @@ recur:
if (ts_subtree_dynamic_precedence(link.subtree) > ts_subtree_dynamic_precedence(existing_link->subtree))
{
ts_subtree_retain(link.subtree);
ts_subtree_release(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);
}
@ -224,7 +235,7 @@ recur:
{
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], subtree_pool);
}
t_i32 dynamic_precedence = link.node->dynamic_precedence;
if (link.subtree.ptr)
@ -245,7 +256,7 @@ recur:
stack_node_retain(link.node);
t_u32 node_count = link.node->node_count;
int dynamic_precedence = link.node->dynamic_precedence;
int dynamic_precedence = link.node->dynamic_precedence;
self->links[self->link_count++] = link;
if (link.subtree.ptr)
@ -261,28 +272,28 @@ recur:
self->dynamic_precedence = dynamic_precedence;
}
/*R static R*/ void stack_head_delete(StackHead *self)
static void stack_head_delete(StackHead *self, StackNodeArray *pool, SubtreePool *subtree_pool)
{
if (self->node)
{
if (self->last_external_token.ptr)
{
ts_subtree_release(self->last_external_token);
ts_subtree_release(subtree_pool, self->last_external_token);
}
if (self->lookahead_when_paused.ptr)
{
ts_subtree_release(self->lookahead_when_paused);
ts_subtree_release(subtree_pool, self->lookahead_when_paused);
}
if (self->summary)
{
array_delete(self->summary);
mem_free(self->summary);
}
stack_node_release(self->node);
stack_node_release(self->node, pool, subtree_pool);
}
}
/*R static R*/ StackVersion ts_stack__add_version(Stack *self, StackVersion original_version, StackNode *node)
static StackVersion ts_stack__add_version(Stack *self, StackVersion original_version, StackNode *node)
{
StackHead head = {
.node = node,
@ -298,7 +309,7 @@ recur:
return (StackVersion)(self->heads.size - 1);
}
/*R static R*/ void ts_stack__add_slice(Stack *self, StackVersion original_version, StackNode *node, SubtreeArray *subtrees)
static void ts_stack__add_slice(Stack *self, StackVersion original_version, StackNode *node, SubtreeArray *subtrees)
{
for (t_u32 i = self->slices.size - 1; i + 1 > 0; i--)
{
@ -316,7 +327,7 @@ recur:
array_push(&self->slices, slice);
}
/*R static R*/ StackSliceArray stack__iter(Stack *self, StackVersion version, StackCallback callback, void *payload, int goal_subtree_count)
static StackSliceArray stack__iter(Stack *self, StackVersion version, StackCallback callback, void *payload, int goal_subtree_count)
{
array_clear(&self->slices);
array_clear(&self->iterators);
@ -364,7 +375,7 @@ recur:
{
if (!should_pop)
{
ts_subtree_array_delete(&iterator->subtrees);
ts_subtree_array_delete(self->subtree_pool, &iterator->subtrees);
}
array_erase(&self->iterators, i);
i--, size--;
@ -421,18 +432,21 @@ recur:
return self->slices;
}
Stack *ts_stack_new(void)
Stack *ts_stack_new(SubtreePool *subtree_pool)
{
Stack *self = mem_alloc(sizeof(*self));
Stack *self = mem_alloc_array(1, sizeof(Stack));
array_init(&self->heads);
array_init(&self->slices);
array_init(&self->iterators);
array_init(&self->node_pool);
array_reserve(&self->heads, 4);
array_reserve(&self->slices, 4);
array_reserve(&self->iterators, 4);
array_reserve(&self->node_pool, MAX_NODE_POOL_SIZE);
self->base_node = stack_node_new(NULL, NULL_SUBTREE, false, 1);
self->subtree_pool = subtree_pool;
self->base_node = stack_node_new(NULL, NULL_SUBTREE, false, 1, &self->node_pool);
ts_stack_clear(self);
return self;
@ -444,12 +458,18 @@ void ts_stack_delete(Stack *self)
array_delete(&self->slices);
if (self->iterators.contents)
array_delete(&self->iterators);
stack_node_release(self->base_node);
stack_node_release(self->base_node, &self->node_pool, self->subtree_pool);
for (t_u32 i = 0; i < self->heads.size; i++)
{
stack_head_delete(&self->heads.contents[i]);
stack_head_delete(&self->heads.contents[i], &self->node_pool, self->subtree_pool);
}
array_clear(&self->heads);
if (self->node_pool.contents)
{
for (t_u32 i = 0; i < self->node_pool.size; i++)
mem_free(self->node_pool.contents[i]);
array_delete(&self->node_pool);
}
array_delete(&self->heads);
mem_free(self);
}
@ -480,14 +500,14 @@ void ts_stack_set_last_external_token(Stack *self, StackVersion version, Subtree
if (token.ptr)
ts_subtree_retain(token);
if (head->last_external_token.ptr)
ts_subtree_release(head->last_external_token);
ts_subtree_release(self->subtree_pool, head->last_external_token);
head->last_external_token = token;
}
t_u32 ts_stack_error_cost(const Stack *self, StackVersion version)
{
StackHead *head = array_get(&self->heads, version);
t_u32 result = head->node->error_cost;
t_u32 result = head->node->error_cost;
if (head->status == StackStatusPaused || (head->node->state == ERROR_STATE && !head->node->links[0].subtree.ptr))
{
result += ERROR_COST_PER_RECOVERY;
@ -508,7 +528,7 @@ t_u32 ts_stack_node_count_since_error(const Stack *self, StackVersion version)
void ts_stack_push(Stack *self, StackVersion version, Subtree subtree, bool pending, TSStateId state)
{
StackHead *head = array_get(&self->heads, version);
StackNode *new_node = stack_node_new(head->node, subtree, pending, state);
StackNode *new_node = stack_node_new(head->node, subtree, pending, state, &self->node_pool);
if (!subtree.ptr)
head->node_count_at_last_error = new_node->node_count;
head->node = new_node;
@ -619,14 +639,14 @@ StackSliceArray ts_stack_pop_all(Stack *self, StackVersion version)
typedef struct SummarizeStackSession
{
StackSummary *summary;
t_u32 max_depth;
t_u32 max_depth;
} SummarizeStackSession;
StackAction summarize_stack_callback(void *payload, const StackIterator *iterator)
{
SummarizeStackSession *session = payload;
TSStateId state = iterator->node->state;
t_u32 depth = iterator->subtree_count;
t_u32 depth = iterator->subtree_count;
if (depth > session->max_depth)
return StackActionStop;
for (t_u32 i = session->summary->size - 1; i + 1 > 0; i--)
@ -700,7 +720,7 @@ bool ts_stack_has_advanced_since_error(const Stack *self, StackVersion version)
void ts_stack_remove_version(Stack *self, StackVersion version)
{
stack_head_delete(array_get(&self->heads, version));
stack_head_delete(array_get(&self->heads, version), &self->node_pool, self->subtree_pool);
array_erase(&self->heads, version);
}
@ -717,7 +737,7 @@ void ts_stack_renumber_version(Stack *self, StackVersion v1, StackVersion v2)
source_head->summary = target_head->summary;
target_head->summary = NULL;
}
stack_head_delete(target_head);
stack_head_delete(target_head, &self->node_pool, self->subtree_pool);
*target_head = *source_head;
array_erase(&self->heads, v1);
}
@ -749,7 +769,7 @@ bool ts_stack_merge(Stack *self, StackVersion version1, StackVersion version2)
StackHead *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]);
stack_node_add_link(head1->node, head2->node->links[i], self->subtree_pool);
}
if (head1->node->state == ERROR_STATE)
{
@ -810,7 +830,9 @@ void ts_stack_clear(Stack *self)
{
stack_node_retain(self->base_node);
for (t_u32 i = 0; i < self->heads.size; i++)
stack_head_delete(&self->heads.contents[i]);
{
stack_head_delete(&self->heads.contents[i], &self->node_pool, self->subtree_pool);
}
array_clear(&self->heads);
array_push(&self->heads, ((StackHead){
.node = self->base_node,
@ -819,3 +841,5 @@ void ts_stack_clear(Stack *self)
.lookahead_when_paused = NULL_SUBTREE,
}));
}
#undef forceinline