From 713a80a228f45800f1f999f393cc3861a18119fa Mon Sep 17 00:00:00 2001 From: Maix0 Date: Sun, 18 Aug 2024 22:40:16 +0200 Subject: [PATCH] Removed tree pool: Electric boogaloo --- parser/include/parser/stack.h | 2 +- parser/include/parser/subtree.h | 6 +++--- parser/src/parser.c | 8 +++---- parser/src/stack.c | 30 +++++++++++++------------- parser/src/subtree.c | 38 ++++++++++++++++----------------- parser/src/tree.c | 8 +++---- 6 files changed, 46 insertions(+), 46 deletions(-) diff --git a/parser/include/parser/stack.h b/parser/include/parser/stack.h index 8b7dbd81..43381978 100644 --- a/parser/include/parser/stack.h +++ b/parser/include/parser/stack.h @@ -29,7 +29,7 @@ typedef Array(StackSummaryEntry) StackSummary; typedef void (*StackIterateCallback)(void *, TSStateId, t_u32); // Create a stack. -Stack *ts_stack_new(SubtreePool *); +Stack *ts_stack_new(/*SubtreePool **/); // Release the memory reserved for a given stack. void ts_stack_delete(Stack *); diff --git a/parser/include/parser/subtree.h b/parser/include/parser/subtree.h index 5beb9e21..dff1643f 100644 --- a/parser/include/parser/subtree.h +++ b/parser/include/parser/subtree.h @@ -137,7 +137,7 @@ typedef struct SubtreePool { MutableSubtreeArray free_trees; MutableSubtreeArray tree_stack; -} SubtreePool; +} SubtreePool_; void ts_external_scanner_state_init(ExternalScannerState *, const t_u8 *, t_u32); 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_reverse(SubtreeArray *); -SubtreePool ts_subtree_pool_new(t_u32 capacity); -void ts_subtree_pool_delete(SubtreePool *); +// SubtreePool ts_subtree_pool_new(t_u32 capacity); +// 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_error(/*SubtreePool *,*/ t_i32, Length, Length, t_u32, TSStateId, const TSLanguage *); diff --git a/parser/src/parser.c b/parser/src/parser.c index b03bcb2a..122fe8e6 100644 --- a/parser/src/parser.c +++ b/parser/src/parser.c @@ -40,7 +40,7 @@ struct TSParser { Lexer lexer; Stack *stack; - SubtreePool tree_pool; + /* SubtreePool tree_pool; */ const TSLanguage *language; ReduceActionSet reduce_actions; Subtree finished_tree; @@ -1587,8 +1587,8 @@ TSParser *ts_parser_new(void) ts_lexer_init(&self->lexer); array_init(&self->reduce_actions); array_reserve(&self->reduce_actions, 4); - self->tree_pool = ts_subtree_pool_new(32); - self->stack = ts_stack_new(&self->tree_pool); + /* self->tree_pool = ts_subtree_pool_new(32); */ + self->stack = ts_stack_new(/*&self->tree_pool*/); self->finished_tree = NULL_SUBTREE; self->cancellation_flag = NULL; self->language = NULL; @@ -1619,7 +1619,7 @@ void ts_parser_delete(TSParser *self) } ts_lexer_delete(&self->lexer); 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_extras2); array_delete(&self->scratch_trees); diff --git a/parser/src/stack.c b/parser/src/stack.c index f2670bc4..b4495e00 100644 --- a/parser/src/stack.c +++ b/parser/src/stack.c @@ -68,7 +68,7 @@ struct Stack Array(StackIterator) iterators; StackNodeArray node_pool; StackNode *base_node; - SubtreePool *subtree_pool; + /* SubtreePool *subtree_pool; */ }; typedef t_u32 StackAction; @@ -90,7 +90,7 @@ static void stack_node_retain(StackNode *self) 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: assert(self->ref_count != 0); @@ -106,7 +106,7 @@ recur: StackLink link = self->links[i]; if (link.subtree.ptr) 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]; 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)); } -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) 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++) { - 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; 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; } -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) { @@ -282,7 +282,7 @@ static void stack_head_delete(StackHead *self, StackNodeArray *pool, SubtreePool array_delete(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; } -Stack *ts_stack_new(SubtreePool *subtree_pool) +Stack *ts_stack_new(/* SubtreePool *subtree_pool */) { Stack *self; @@ -440,7 +440,7 @@ Stack *ts_stack_new(SubtreePool *subtree_pool) array_reserve(&self->iterators, 4); 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); ts_stack_clear(self); @@ -453,10 +453,10 @@ void ts_stack_delete(Stack *self) array_delete(&self->slices); if (self->iterators.contents) 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++) { - 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); 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) { - 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); } @@ -732,7 +732,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, &self->node_pool, self->subtree_pool); + stack_head_delete(target_head, &self->node_pool/* , self->subtree_pool */); *target_head = *source_head; 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]; 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) { @@ -826,7 +826,7 @@ 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], &self->node_pool, self->subtree_pool); + stack_head_delete(&self->heads.contents[i], &self->node_pool/* , self->subtree_pool */); } array_clear(&self->heads); array_push(&self->heads, ((StackHead){ diff --git a/parser/src/subtree.c b/parser/src/subtree.c index 9e897246..3186fb18 100644 --- a/parser/src/subtree.c +++ b/parser/src/subtree.c @@ -138,25 +138,25 @@ void ts_subtree_array_reverse(SubtreeArray *self) // SubtreePool -SubtreePool ts_subtree_pool_new(t_u32 capacity) -{ - SubtreePool self = {array_new(), array_new()}; - array_reserve(&self.free_trees, capacity); - return self; -} - -void ts_subtree_pool_delete(SubtreePool *self) -{ - if (self->free_trees.contents) - { - for (t_u32 i = 0; i < self->free_trees.size; i++) - mem_free(self->free_trees.contents[i].ptr); - array_delete(&self->free_trees); - } - if (self->tree_stack.contents) - array_delete(&self->tree_stack); -} - +/* SubtreePool ts_subtree_pool_new(t_u32 capacity) */ +/* { */ +/* SubtreePool self = {array_new(), array_new()}; */ +/* array_reserve(&self.free_trees, capacity); */ +/* return self; */ +/* } */ +/**/ +/* void ts_subtree_pool_delete(SubtreePool *self) */ +/* { */ +/* if (self->free_trees.contents) */ +/* { */ +/* for (t_u32 i = 0; i < self->free_trees.size; i++) */ +/* mem_free(self->free_trees.contents[i].ptr); */ +/* array_delete(&self->free_trees); */ +/* } */ +/* if (self->tree_stack.contents) */ +/* array_delete(&self->tree_stack); */ +/* } */ +/**/ // Subtree static inline bool ts_subtree_can_inline(Length padding, Length size, t_u32 lookahead_bytes) diff --git a/parser/src/tree.c b/parser/src/tree.c index b8604316..0c12cf41 100644 --- a/parser/src/tree.c +++ b/parser/src/tree.c @@ -30,9 +30,9 @@ void ts_tree_delete(TSTree *self) if (!self) return; - SubtreePool pool = ts_subtree_pool_new(0); + /* SubtreePool pool = ts_subtree_pool_new(0); */ ts_subtree_release(/*&pool,*/ self->root); - ts_subtree_pool_delete(&pool); + /* ts_subtree_pool_delete(&pool); */ ts_language_delete(self->language); mem_free(self->included_ranges); 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*/); - ts_subtree_pool_delete(&pool); + // ts_subtree_pool_delete(&pool); } TSRange *ts_tree_included_ranges(const TSTree *self, t_u32 *length)