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

Removed tree pool: Electric boogaloo

Browse source
This commit is contained in:
Maix0 2024-08-18 22:40:16 +02:00
parent 9059912ba9
commit 713a80a228
6 changed files with 46 additions and 46 deletions
Download patch file Download diff file Expand all files Collapse all files

2
parser/include/parser/stack.h
View file

@ -29,7 +29,7 @@ typedef Array(StackSummaryEntry) StackSummary;
typedef void (*StackIterateCallback)(void *, TSStateId, t_u32); typedef void (*StackIterateCallback)(void *, TSStateId, t_u32);
// Create a stack. // Create a stack.
Stack *ts_stack_new(SubtreePool *); Stack *ts_stack_new(/*SubtreePool **/);
// Release the memory reserved for a given stack. // Release the memory reserved for a given stack.
void ts_stack_delete(Stack *); void ts_stack_delete(Stack *);

6
parser/include/parser/subtree.h
View file

@ -137,7 +137,7 @@ typedef struct SubtreePool
{ {
MutableSubtreeArray free_trees; MutableSubtreeArray free_trees;
MutableSubtreeArray tree_stack; MutableSubtreeArray tree_stack;
} SubtreePool; } SubtreePool_;
void ts_external_scanner_state_init(ExternalScannerState *, const t_u8 *, t_u32); void ts_external_scanner_state_init(ExternalScannerState *, const t_u8 *, t_u32);
const t_u8 *ts_external_scanner_state_data(const ExternalScannerState *); const t_u8 *ts_external_scanner_state_data(const ExternalScannerState *);
@ -150,8 +150,8 @@ void ts_subtree_array_delete(/*SubtreePool *,*/ SubtreeArray *);
void ts_subtree_array_remove_trailing_extras(SubtreeArray *, SubtreeArray *); void ts_subtree_array_remove_trailing_extras(SubtreeArray *, SubtreeArray *);
void ts_subtree_array_reverse(SubtreeArray *); void ts_subtree_array_reverse(SubtreeArray *);
SubtreePool ts_subtree_pool_new(t_u32 capacity); // SubtreePool ts_subtree_pool_new(t_u32 capacity);
void ts_subtree_pool_delete(SubtreePool *); // void ts_subtree_pool_delete(SubtreePool *);
Subtree ts_subtree_new_leaf(/*SubtreePool *,*/ TSSymbol, Length, Length, t_u32, TSStateId, bool, bool, bool, const TSLanguage *); Subtree ts_subtree_new_leaf(/*SubtreePool *,*/ TSSymbol, Length, Length, t_u32, TSStateId, bool, bool, bool, const TSLanguage *);
Subtree ts_subtree_new_error(/*SubtreePool *,*/ t_i32, Length, Length, t_u32, TSStateId, const TSLanguage *); Subtree ts_subtree_new_error(/*SubtreePool *,*/ t_i32, Length, Length, t_u32, TSStateId, const TSLanguage *);

8
parser/src/parser.c
View file

@ -40,7 +40,7 @@ struct TSParser
{ {
Lexer lexer; Lexer lexer;
Stack *stack; Stack *stack;
SubtreePool tree_pool; /* SubtreePool tree_pool; */
const TSLanguage *language; const TSLanguage *language;
ReduceActionSet reduce_actions; ReduceActionSet reduce_actions;
Subtree finished_tree; Subtree finished_tree;
@ -1587,8 +1587,8 @@ TSParser *ts_parser_new(void)
ts_lexer_init(&self->lexer); ts_lexer_init(&self->lexer);
array_init(&self->reduce_actions); array_init(&self->reduce_actions);
array_reserve(&self->reduce_actions, 4); array_reserve(&self->reduce_actions, 4);
self->tree_pool = ts_subtree_pool_new(32); /* self->tree_pool = ts_subtree_pool_new(32); */
self->stack = ts_stack_new(&self->tree_pool); self->stack = ts_stack_new(/*&self->tree_pool*/);
self->finished_tree = NULL_SUBTREE; self->finished_tree = NULL_SUBTREE;
self->cancellation_flag = NULL; self->cancellation_flag = NULL;
self->language = NULL; self->language = NULL;
@ -1619,7 +1619,7 @@ void ts_parser_delete(TSParser *self)
} }
ts_lexer_delete(&self->lexer); ts_lexer_delete(&self->lexer);
ts_parser__set_cached_token(self, 0, NULL_SUBTREE, NULL_SUBTREE); ts_parser__set_cached_token(self, 0, NULL_SUBTREE, NULL_SUBTREE);
ts_subtree_pool_delete(&self->tree_pool); /* ts_subtree_pool_delete(&self->tree_pool); */
array_delete(&self->trailing_extras); array_delete(&self->trailing_extras);
array_delete(&self->trailing_extras2); array_delete(&self->trailing_extras2);
array_delete(&self->scratch_trees); array_delete(&self->scratch_trees);

30
parser/src/stack.c
View file

@ -68,7 +68,7 @@ struct Stack
Array(StackIterator) iterators; Array(StackIterator) iterators;
StackNodeArray node_pool; StackNodeArray node_pool;
StackNode *base_node; StackNode *base_node;
SubtreePool *subtree_pool; /* SubtreePool *subtree_pool; */
}; };
typedef t_u32 StackAction; typedef t_u32 StackAction;
@ -90,7 +90,7 @@ static void stack_node_retain(StackNode *self)
assert(self->ref_count != 0); assert(self->ref_count != 0);
} }
static void stack_node_release(StackNode *self, StackNodeArray *pool, SubtreePool *subtree_pool) static void stack_node_release(StackNode *self, StackNodeArray *pool/* , SubtreePool *subtree_pool */)
{ {
recur: recur:
assert(self->ref_count != 0); assert(self->ref_count != 0);
@ -106,7 +106,7 @@ recur:
StackLink link = self->links[i]; StackLink link = self->links[i];
if (link.subtree.ptr) if (link.subtree.ptr)
ts_subtree_release(/*subtree_pool, */ link.subtree); ts_subtree_release(/*subtree_pool, */ link.subtree);
stack_node_release(link.node, pool, subtree_pool); stack_node_release(link.node, pool/* , subtree_pool */);
} }
StackLink link = self->links[0]; StackLink link = self->links[0];
if (link.subtree.ptr) if (link.subtree.ptr)
@ -196,7 +196,7 @@ static bool stack__subtree_is_equivalent(Subtree left, Subtree right)
ts_subtree_extra(left) == ts_subtree_extra(right) && ts_subtree_external_scanner_state_eq(left, right)); ts_subtree_extra(left) == ts_subtree_extra(right) && ts_subtree_external_scanner_state_eq(left, right));
} }
static void stack_node_add_link(StackNode *self, StackLink link, SubtreePool *subtree_pool) static void stack_node_add_link(StackNode *self, StackLink link/* , SubtreePool *subtree_pool */)
{ {
if (link.node == self) if (link.node == self)
return; return;
@ -228,7 +228,7 @@ static void stack_node_add_link(StackNode *self, StackLink link, SubtreePool *su
{ {
for (int j = 0; j < link.node->link_count; j++) for (int j = 0; j < link.node->link_count; j++)
{ {
stack_node_add_link(existing_link->node, link.node->links[j], subtree_pool); stack_node_add_link(existing_link->node, link.node->links[j]/* , subtree_pool */);
} }
t_i32 dynamic_precedence = link.node->dynamic_precedence; t_i32 dynamic_precedence = link.node->dynamic_precedence;
if (link.subtree.ptr) if (link.subtree.ptr)
@ -265,7 +265,7 @@ static void stack_node_add_link(StackNode *self, StackLink link, SubtreePool *su
self->dynamic_precedence = dynamic_precedence; self->dynamic_precedence = dynamic_precedence;
} }
static void stack_head_delete(StackHead *self, StackNodeArray *pool, SubtreePool *subtree_pool) static void stack_head_delete(StackHead *self, StackNodeArray *pool/* , SubtreePool *subtree_pool */)
{ {
if (self->node) if (self->node)
{ {
@ -282,7 +282,7 @@ static void stack_head_delete(StackHead *self, StackNodeArray *pool, SubtreePool
array_delete(self->summary); array_delete(self->summary);
mem_free(self->summary); mem_free(self->summary);
} }
stack_node_release(self->node, pool, subtree_pool); stack_node_release(self->node, pool/* , subtree_pool */);
} }
} }
@ -425,7 +425,7 @@ static StackSliceArray stack__iter(Stack *self, StackVersion version, StackCallb
return self->slices; return self->slices;
} }
Stack *ts_stack_new(SubtreePool *subtree_pool) Stack *ts_stack_new(/* SubtreePool *subtree_pool */)
{ {
Stack *self; Stack *self;
@ -440,7 +440,7 @@ Stack *ts_stack_new(SubtreePool *subtree_pool)
array_reserve(&self->iterators, 4); array_reserve(&self->iterators, 4);
self->node_pool = (StackNodeArray)array_new(); self->node_pool = (StackNodeArray)array_new();
self->subtree_pool = subtree_pool; /* self->subtree_pool = subtree_pool; */
self->base_node = stack_node_new(NULL, NULL_SUBTREE, false, 1, &self->node_pool); self->base_node = stack_node_new(NULL, NULL_SUBTREE, false, 1, &self->node_pool);
ts_stack_clear(self); ts_stack_clear(self);
@ -453,10 +453,10 @@ void ts_stack_delete(Stack *self)
array_delete(&self->slices); array_delete(&self->slices);
if (self->iterators.contents) if (self->iterators.contents)
array_delete(&self->iterators); array_delete(&self->iterators);
stack_node_release(self->base_node, &self->node_pool, self->subtree_pool); stack_node_release(self->base_node, &self->node_pool/* , self->subtree_pool */);
for (t_u32 i = 0; i < self->heads.size; i++) for (t_u32 i = 0; i < self->heads.size; i++)
{ {
stack_head_delete(&self->heads.contents[i], &self->node_pool, self->subtree_pool); stack_head_delete(&self->heads.contents[i], &self->node_pool/* , self->subtree_pool */);
} }
array_clear(&self->heads); array_clear(&self->heads);
if (self->node_pool.contents) if (self->node_pool.contents)
@ -715,7 +715,7 @@ bool ts_stack_has_advanced_since_error(const Stack *self, StackVersion version)
void ts_stack_remove_version(Stack *self, StackVersion version) void ts_stack_remove_version(Stack *self, StackVersion version)
{ {
stack_head_delete(array_get(&self->heads, version), &self->node_pool, self->subtree_pool); stack_head_delete(array_get(&self->heads, version), &self->node_pool/* , self->subtree_pool */);
array_erase(&self->heads, version); array_erase(&self->heads, version);
} }
@ -732,7 +732,7 @@ void ts_stack_renumber_version(Stack *self, StackVersion v1, StackVersion v2)
source_head->summary = target_head->summary; source_head->summary = target_head->summary;
target_head->summary = NULL; target_head->summary = NULL;
} }
stack_head_delete(target_head, &self->node_pool, self->subtree_pool); stack_head_delete(target_head, &self->node_pool/* , self->subtree_pool */);
*target_head = *source_head; *target_head = *source_head;
array_erase(&self->heads, v1); array_erase(&self->heads, v1);
} }
@ -764,7 +764,7 @@ bool ts_stack_merge(Stack *self, StackVersion version1, StackVersion version2)
StackHead *head2 = &self->heads.contents[version2]; StackHead *head2 = &self->heads.contents[version2];
for (t_u32 i = 0; i < head2->node->link_count; i++) for (t_u32 i = 0; i < head2->node->link_count; i++)
{ {
stack_node_add_link(head1->node, head2->node->links[i], self->subtree_pool); stack_node_add_link(head1->node, head2->node->links[i]/* , self->subtree_pool */);
} }
if (head1->node->state == ERROR_STATE) if (head1->node->state == ERROR_STATE)
{ {
@ -826,7 +826,7 @@ void ts_stack_clear(Stack *self)
stack_node_retain(self->base_node); stack_node_retain(self->base_node);
for (t_u32 i = 0; i < self->heads.size; i++) for (t_u32 i = 0; i < self->heads.size; i++)
{ {
stack_head_delete(&self->heads.contents[i], &self->node_pool, self->subtree_pool); stack_head_delete(&self->heads.contents[i], &self->node_pool/* , self->subtree_pool */);
} }
array_clear(&self->heads); array_clear(&self->heads);
array_push(&self->heads, ((StackHead){ array_push(&self->heads, ((StackHead){

38
parser/src/subtree.c
View file

@ -138,25 +138,25 @@ void ts_subtree_array_reverse(SubtreeArray *self)
// SubtreePool // SubtreePool
SubtreePool ts_subtree_pool_new(t_u32 capacity) /* SubtreePool ts_subtree_pool_new(t_u32 capacity) */
{ /* { */
SubtreePool self = {array_new(), array_new()}; /* SubtreePool self = {array_new(), array_new()}; */
array_reserve(&self.free_trees, capacity); /* array_reserve(&self.free_trees, capacity); */
return self; /* return self; */
} /* } */
/**/
void ts_subtree_pool_delete(SubtreePool *self) /* void ts_subtree_pool_delete(SubtreePool *self) */
{ /* { */
if (self->free_trees.contents) /* if (self->free_trees.contents) */
{ /* { */
for (t_u32 i = 0; i < self->free_trees.size; i++) /* for (t_u32 i = 0; i < self->free_trees.size; i++) */
mem_free(self->free_trees.contents[i].ptr); /* mem_free(self->free_trees.contents[i].ptr); */
array_delete(&self->free_trees); /* array_delete(&self->free_trees); */
} /* } */
if (self->tree_stack.contents) /* if (self->tree_stack.contents) */
array_delete(&self->tree_stack); /* array_delete(&self->tree_stack); */
} /* } */
/**/
// Subtree // Subtree
static inline bool ts_subtree_can_inline(Length padding, Length size, t_u32 lookahead_bytes) static inline bool ts_subtree_can_inline(Length padding, Length size, t_u32 lookahead_bytes)

8
parser/src/tree.c
View file

@ -30,9 +30,9 @@ void ts_tree_delete(TSTree *self)
if (!self) if (!self)
return; return;
SubtreePool pool = ts_subtree_pool_new(0); /* SubtreePool pool = ts_subtree_pool_new(0); */
ts_subtree_release(/*&pool,*/ self->root); ts_subtree_release(/*&pool,*/ self->root);
ts_subtree_pool_delete(&pool); /* ts_subtree_pool_delete(&pool); */
ts_language_delete(self->language); ts_language_delete(self->language);
mem_free(self->included_ranges); mem_free(self->included_ranges);
mem_free(self); mem_free(self);
@ -94,9 +94,9 @@ void ts_tree_edit(TSTree *self, const TSInputEdit *edit)
} }
} }
SubtreePool pool = ts_subtree_pool_new(0); // SubtreePool pool = ts_subtree_pool_new(0);
self->root = ts_subtree_edit(self->root, edit /*, &pool*/); self->root = ts_subtree_edit(self->root, edit /*, &pool*/);
ts_subtree_pool_delete(&pool); // ts_subtree_pool_delete(&pool);
} }
TSRange *ts_tree_included_ranges(const TSTree *self, t_u32 *length) TSRange *ts_tree_included_ranges(const TSTree *self, t_u32 *length)