From 9059912ba900950b93a8ad82d109626ec98fc441 Mon Sep 17 00:00:00 2001 From: Maix0 Date: Sun, 18 Aug 2024 22:34:41 +0200 Subject: [PATCH] Removed tree pool --- Makefile | 4 +- parser/include/parser/subtree.h | 20 ++--- parser/src/parser.c | 68 +++++++++-------- parser/src/stack.c | 65 ++++++++-------- parser/src/subtree.c | 128 +++++++++++++++----------------- parser/src/tree.c | 11 ++- 6 files changed, 143 insertions(+), 153 deletions(-) diff --git a/Makefile b/Makefile index 7ecc59e5..b68bdf10 100644 --- a/Makefile +++ b/Makefile @@ -6,7 +6,7 @@ # By: rparodi +#+ +:+ +#+ # # +#+#+#+#+#+ +#+ # # Created: 2023/11/12 11:05:05 by rparodi #+# #+# # -# Updated: 2024/08/17 23:40:03 by maiboyer ### ########.fr # +# Updated: 2024/08/18 22:01:52 by maiboyer ### ########.fr # # # # **************************************************************************** # @@ -45,7 +45,7 @@ endif # TODO: ADD THIS WHEN FINISHING THIS: # CFLAGS_ADDITIONAL += -DNVALGRIND -CFLAGS_ADDITIONAL += -O0 -Wno-cpp +CFLAGS_ADDITIONAL += -O0 -Wno-cpp -Wno-type-limits # TODO: REMOVE THIS WHEN FINISHING THIS: CFLAGS_ADDITIONAL += -gcolumn-info -g3 diff --git a/parser/include/parser/subtree.h b/parser/include/parser/subtree.h index 231af778..5beb9e21 100644 --- a/parser/include/parser/subtree.h +++ b/parser/include/parser/subtree.h @@ -145,28 +145,28 @@ bool ts_external_scanner_state_eq(const ExternalScannerState *self, const t_u8 void ts_external_scanner_state_delete(ExternalScannerState *self); void ts_subtree_array_copy(SubtreeArray, SubtreeArray *); -void ts_subtree_array_clear(SubtreePool *, SubtreeArray *); -void ts_subtree_array_delete(SubtreePool *, SubtreeArray *); +void ts_subtree_array_clear(/*SubtreePool *,*/ SubtreeArray *); +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 *); -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_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 *); MutableSubtree ts_subtree_new_node(TSSymbol, SubtreeArray *, t_u32, const TSLanguage *); Subtree ts_subtree_new_error_node(SubtreeArray *, bool, const TSLanguage *); -Subtree ts_subtree_new_missing_leaf(SubtreePool *, TSSymbol, Length, t_u32, const TSLanguage *); -MutableSubtree ts_subtree_make_mut(SubtreePool *, Subtree); +Subtree ts_subtree_new_missing_leaf(/*SubtreePool *,*/ TSSymbol, Length, t_u32, const TSLanguage *); +MutableSubtree ts_subtree_make_mut(/*SubtreePool *,*/ Subtree); void ts_subtree_retain(Subtree); -void ts_subtree_release(SubtreePool *, Subtree); -int ts_subtree_compare(Subtree, Subtree, SubtreePool *); +void ts_subtree_release(/*SubtreePool *,*/ Subtree); +int ts_subtree_compare(Subtree, Subtree/*, SubtreePool **/); void ts_subtree_set_symbol(MutableSubtree *, TSSymbol, const TSLanguage *); void ts_subtree_summarize(MutableSubtree, const Subtree *, t_u32, const TSLanguage *); void ts_subtree_summarize_children(MutableSubtree, const TSLanguage *); -void ts_subtree_balance(Subtree, SubtreePool *, const TSLanguage *); -Subtree ts_subtree_edit(Subtree, const TSInputEdit *edit, SubtreePool *); +void ts_subtree_balance(Subtree, /*SubtreePool *,*/ const TSLanguage *); +Subtree ts_subtree_edit(Subtree, const TSInputEdit *edit/*, SubtreePool **/); char *ts_subtree_string(Subtree, TSSymbol, bool, const TSLanguage *, bool include_all); void ts_subtree_print_dot_graph(Subtree, const TSLanguage *, FILE *); Subtree ts_subtree_last_external_token(Subtree); diff --git a/parser/src/parser.c b/parser/src/parser.c index 3745e5e9..b03bcb2a 100644 --- a/parser/src/parser.c +++ b/parser/src/parser.c @@ -1,5 +1,7 @@ #define _POSIX_C_SOURCE 200112L +#include "me/mem/mem.h" +#include "me/types.h" #include "parser/api.h" #include "parser/array.h" #include "parser/language.h" @@ -9,8 +11,6 @@ #include "parser/stack.h" #include "parser/subtree.h" #include "parser/tree.h" -#include "me/mem/mem.h" -#include "me/types.h" #include #include @@ -163,7 +163,7 @@ static bool ts_parser__breakdown_top_of_stack(TSParser *self, StackVersion versi ts_stack_push(self->stack, slice.version, tree, false, state); } - ts_subtree_release(&self->tree_pool, parent); + ts_subtree_release(/*&self->tree_pool,*/ parent); array_delete(&slice.subtrees); LOG("breakdown_top_of_stack tree:%s", TREE_NAME(parent)); @@ -487,7 +487,8 @@ static Subtree ts_parser__lex(TSParser *self, StackVersion version, TSStateId pa Length padding = length_sub(error_start_position, start_position); Length size = length_sub(error_end_position, error_start_position); t_u32 lookahead_bytes = lookahead_end_byte - error_end_position.bytes; - result = ts_subtree_new_error(&self->tree_pool, first_error_character, padding, size, lookahead_bytes, parse_state, self->language); + result = + ts_subtree_new_error(/*&self->tree_pool, */ first_error_character, padding, size, lookahead_bytes, parse_state, self->language); } else { @@ -516,7 +517,7 @@ static Subtree ts_parser__lex(TSParser *self, StackVersion version, TSStateId pa } } - result = ts_subtree_new_leaf(&self->tree_pool, symbol, padding, size, lookahead_bytes, parse_state, found_external_token, + result = ts_subtree_new_leaf(/*&self->tree_pool,*/ symbol, padding, size, lookahead_bytes, parse_state, found_external_token, called_get_column, is_keyword, self->language); if (found_external_token) @@ -556,9 +557,9 @@ static void ts_parser__set_cached_token(TSParser *self, t_u32 byte_index, Subtre if (last_external_token.ptr) ts_subtree_retain(last_external_token); if (cache->token.ptr) - ts_subtree_release(&self->tree_pool, cache->token); + ts_subtree_release(/*&self->tree_pool, */ cache->token); if (cache->last_external_token.ptr) - ts_subtree_release(&self->tree_pool, cache->last_external_token); + ts_subtree_release(/*&self->tree_pool, */ cache->last_external_token); cache->token = token; cache->byte_index = byte_index; cache->last_external_token = last_external_token; @@ -570,6 +571,7 @@ static void ts_parser__set_cached_token(TSParser *self, t_u32 byte_index, Subtre // and finally, as a default, by a recursive comparison of the trees' symbols. static bool ts_parser__select_tree(TSParser *self, Subtree left, Subtree right) { + (void)(self); if (!left.ptr) return true; if (!right.ptr) @@ -604,7 +606,7 @@ static bool ts_parser__select_tree(TSParser *self, Subtree left, Subtree right) if (ts_subtree_error_cost(left) > 0) return true; - int comparison = ts_subtree_compare(left, right, &self->tree_pool); + int comparison = ts_subtree_compare(left, right /* , &self->tree_pool*/); switch (comparison) { case -1: @@ -641,7 +643,7 @@ static void ts_parser__shift(TSParser *self, StackVersion version, TSStateId sta Subtree subtree_to_push = lookahead; if (extra != ts_subtree_extra(lookahead) && is_leaf) { - MutableSubtree result = ts_subtree_make_mut(&self->tree_pool, lookahead); + MutableSubtree result = ts_subtree_make_mut(/*&self->tree_pool,*/ lookahead); ts_subtree_set_extra(&result, extra); subtree_to_push = ts_subtree_from_mut(result); } @@ -677,14 +679,14 @@ static StackVersion ts_parser__reduce(TSParser *self, StackVersion version, TSSy if (slice_version > MAX_VERSION_COUNT + MAX_VERSION_COUNT_OVERFLOW) { ts_stack_remove_version(self->stack, slice_version); - ts_subtree_array_delete(&self->tree_pool, &slice.subtrees); + ts_subtree_array_delete(/*&self->tree_pool,*/ &slice.subtrees); removed_version_count++; while (i + 1 < pop.size) { StackSlice next_slice = pop.contents[i + 1]; if (next_slice.version != slice.version) break; - ts_subtree_array_delete(&self->tree_pool, &next_slice.subtrees); + ts_subtree_array_delete(/*&self->tree_pool,*/ &next_slice.subtrees); i++; } continue; @@ -714,15 +716,15 @@ static StackVersion ts_parser__reduce(TSParser *self, StackVersion version, TSSy if (ts_parser__select_children(self, ts_subtree_from_mut(parent), &next_slice_children)) { - ts_subtree_array_clear(&self->tree_pool, &self->trailing_extras); - ts_subtree_release(&self->tree_pool, ts_subtree_from_mut(parent)); + ts_subtree_array_clear(/*&self->tree_pool,*/ &self->trailing_extras); + ts_subtree_release(/*&self->tree_pool,*/ ts_subtree_from_mut(parent)); array_swap(&self->trailing_extras, &self->trailing_extras2); parent = ts_subtree_new_node(symbol, &next_slice_children, production_id, self->language); } else { array_clear(&self->trailing_extras2); - ts_subtree_array_delete(&self->tree_pool, &next_slice.subtrees); + ts_subtree_array_delete(/*&self->tree_pool,*/ &next_slice.subtrees); } } @@ -792,7 +794,7 @@ static void ts_parser__accept(TSParser *self, StackVersion version, Subtree look } array_splice(&trees, j, 1, child_count, children); root = ts_subtree_from_mut(ts_subtree_new_node(ts_subtree_symbol(tree), &trees, tree.ptr->production_id, self->language)); - ts_subtree_release(&self->tree_pool, tree); + ts_subtree_release(/*&self->tree_pool, */ tree); break; } } @@ -804,12 +806,12 @@ static void ts_parser__accept(TSParser *self, StackVersion version, Subtree look { if (ts_parser__select_tree(self, self->finished_tree, root)) { - ts_subtree_release(&self->tree_pool, self->finished_tree); + ts_subtree_release(/*&self->tree_pool,*/ self->finished_tree); self->finished_tree = root; } else { - ts_subtree_release(&self->tree_pool, root); + ts_subtree_release(/*&self->tree_pool,*/ root); } } else @@ -938,7 +940,7 @@ static bool ts_parser__recover_to_state(TSParser *self, StackVersion version, t_ if (slice.version == previous_version) { - ts_subtree_array_delete(&self->tree_pool, &slice.subtrees); + ts_subtree_array_delete(/*&self->tree_pool,*/ &slice.subtrees); array_erase(&pop, i--); continue; } @@ -946,7 +948,7 @@ static bool ts_parser__recover_to_state(TSParser *self, StackVersion version, t_ if (ts_stack_state(self->stack, slice.version) != goal_state) { ts_stack_halt(self->stack, slice.version); - ts_subtree_array_delete(&self->tree_pool, &slice.subtrees); + ts_subtree_array_delete(/*&self->tree_pool,*/ &slice.subtrees); array_erase(&pop, i--); continue; } @@ -965,7 +967,7 @@ static bool ts_parser__recover_to_state(TSParser *self, StackVersion version, t_ ts_subtree_retain(slice.subtrees.contents[j]); } } - ts_subtree_array_delete(&self->tree_pool, &error_trees); + ts_subtree_array_delete(/*&self->tree_pool,*/ &error_trees); } ts_subtree_array_remove_trailing_extras(&slice.subtrees, &self->trailing_extras); @@ -1080,14 +1082,14 @@ static void ts_parser__recover(TSParser *self, StackVersion version, Subtree loo if (did_recover && ts_stack_version_count(self->stack) > MAX_VERSION_COUNT) { ts_stack_halt(self->stack, version); - ts_subtree_release(&self->tree_pool, lookahead); + ts_subtree_release(/*&self->tree_pool,*/ lookahead); return; } if (did_recover && ts_subtree_has_external_scanner_state_change(lookahead)) { ts_stack_halt(self->stack, version); - ts_subtree_release(&self->tree_pool, lookahead); + ts_subtree_release(/*&self->tree_pool,*/ lookahead); return; } @@ -1109,7 +1111,7 @@ static void ts_parser__recover(TSParser *self, StackVersion version, Subtree loo if (ts_parser__better_version_exists(self, version, false, new_cost)) { ts_stack_halt(self->stack, version); - ts_subtree_release(&self->tree_pool, lookahead); + ts_subtree_release(/*&self->tree_pool,*/ lookahead); return; } @@ -1119,7 +1121,7 @@ static void ts_parser__recover(TSParser *self, StackVersion version, Subtree loo const TSParseAction *actions = ts_language_actions(self->language, 1, ts_subtree_symbol(lookahead), &n); if (n > 0 && actions[n - 1].type == TSParseActionTypeShift && actions[n - 1].shift.extra) { - MutableSubtree mutable_lookahead = ts_subtree_make_mut(&self->tree_pool, lookahead); + MutableSubtree mutable_lookahead = ts_subtree_make_mut(/*&self->tree_pool,*/ lookahead); ts_subtree_set_extra(&mutable_lookahead, true); lookahead = ts_subtree_from_mut(mutable_lookahead); } @@ -1146,7 +1148,7 @@ static void ts_parser__recover(TSParser *self, StackVersion version, Subtree loo { for (t_u32 i = 1; i < pop.size; i++) { - ts_subtree_array_delete(&self->tree_pool, &pop.contents[i].subtrees); + ts_subtree_array_delete(/*&self->tree_pool,*/ &pop.contents[i].subtrees); } while (ts_stack_version_count(self->stack) > pop.contents[0].version + 1) { @@ -1206,7 +1208,7 @@ static void ts_parser__handle_error(TSParser *self, StackVersion version, Subtre StackVersion version_with_missing_tree = ts_stack_copy_version(self->stack, v); Subtree missing_tree = - ts_subtree_new_missing_leaf(&self->tree_pool, missing_symbol, padding, lookahead_bytes, self->language); + ts_subtree_new_missing_leaf(/*&self->tree_pool,*/ missing_symbol, padding, lookahead_bytes, self->language); ts_stack_push(self->stack, version_with_missing_tree, missing_tree, false, state_after_missing_symbol); if (ts_parser__do_all_potential_reductions(self, version_with_missing_tree, ts_subtree_leaf_symbol(lookahead))) @@ -1296,7 +1298,7 @@ static bool ts_parser__advance(TSParser *self, StackVersion version, bool allow_ { if (lookahead.ptr) { - ts_subtree_release(&self->tree_pool, lookahead); + ts_subtree_release(/*&self->tree_pool,*/ lookahead); } return false; } @@ -1412,7 +1414,7 @@ static bool ts_parser__advance(TSParser *self, StackVersion version, bool allow_ { LOG("switch from_keyword:%s, to_word_token:%s", TREE_NAME(lookahead), SYM_NAME(self->language->keyword_capture_token)); - MutableSubtree mutable_lookahead = ts_subtree_make_mut(&self->tree_pool, lookahead); + MutableSubtree mutable_lookahead = ts_subtree_make_mut(/*&self->tree_pool,*/ lookahead); ts_subtree_set_symbol(&mutable_lookahead, self->language->keyword_capture_token, self->language); lookahead = ts_subtree_from_mut(mutable_lookahead); continue; @@ -1436,7 +1438,7 @@ static bool ts_parser__advance(TSParser *self, StackVersion version, bool allow_ if (ts_parser__breakdown_top_of_stack(self, version)) { state = ts_stack_state(self->stack, version); - ts_subtree_release(&self->tree_pool, lookahead); + ts_subtree_release(/*&self->tree_pool,*/ lookahead); needs_lex = true; continue; } @@ -1612,7 +1614,7 @@ void ts_parser_delete(TSParser *self) } if (self->old_tree.ptr) { - ts_subtree_release(&self->tree_pool, self->old_tree); + ts_subtree_release(/*&self->tree_pool,*/ self->old_tree); self->old_tree = NULL_SUBTREE; } ts_lexer_delete(&self->lexer); @@ -1650,7 +1652,7 @@ void ts_parser_reset(TSParser *self) ts_parser__external_scanner_destroy(self); if (self->old_tree.ptr) { - ts_subtree_release(&self->tree_pool, self->old_tree); + ts_subtree_release(/*&self->tree_pool,*/ self->old_tree); self->old_tree = NULL_SUBTREE; } @@ -1659,7 +1661,7 @@ void ts_parser_reset(TSParser *self) ts_parser__set_cached_token(self, 0, NULL_SUBTREE, NULL_SUBTREE); if (self->finished_tree.ptr) { - ts_subtree_release(&self->tree_pool, self->finished_tree); + ts_subtree_release(/*&self->tree_pool,*/ self->finished_tree); self->finished_tree = NULL_SUBTREE; } self->accept_count = 0; @@ -1738,7 +1740,7 @@ TSTree *ts_parser_parse(TSParser *self, const TSTree *old_tree, TSInput input) } while (version_count != 0); assert(self->finished_tree.ptr); - ts_subtree_balance(self->finished_tree, &self->tree_pool, self->language); + ts_subtree_balance(self->finished_tree, /*&self->tree_pool,*/ self->language); LOG("done"); LOG_TREE(self->finished_tree); diff --git a/parser/src/stack.c b/parser/src/stack.c index b64fd055..f2670bc4 100644 --- a/parser/src/stack.c +++ b/parser/src/stack.c @@ -1,17 +1,17 @@ #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 #include -#define MAX_LINK_COUNT 8 -#define MAX_NODE_POOL_SIZE 50 -#define MAX_ITERATOR_COUNT 64 +#define MAX_LINK_COUNT 1 +#define MAX_NODE_POOL_SIZE 0 +#define MAX_ITERATOR_COUNT 0 typedef struct StackNode StackNode; @@ -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; @@ -105,23 +105,16 @@ recur: { StackLink link = self->links[i]; 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); } StackLink link = self->links[0]; if (link.subtree.ptr) - ts_subtree_release(subtree_pool, link.subtree); + ts_subtree_release(/*subtree_pool, */ link.subtree); first_predecessor = self->links[0].node; } - if (pool->size < MAX_NODE_POOL_SIZE) - { - array_push(pool, self); - } - else - { - mem_free(self); - } + mem_free(self); if (first_predecessor) { @@ -222,7 +215,7 @@ static void stack_node_add_link(StackNode *self, StackLink link, SubtreePool *su if (ts_subtree_dynamic_precedence(link.subtree) > ts_subtree_dynamic_precedence(existing_link->subtree)) { ts_subtree_retain(link.subtree); - ts_subtree_release(subtree_pool, 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); } @@ -256,7 +249,7 @@ static void stack_node_add_link(StackNode *self, StackLink link, SubtreePool *su 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) @@ -278,11 +271,11 @@ static void stack_head_delete(StackHead *self, StackNodeArray *pool, SubtreePool { if (self->last_external_token.ptr) { - ts_subtree_release(subtree_pool, self->last_external_token); + ts_subtree_release(/*subtree_pool, */ self->last_external_token); } if (self->lookahead_when_paused.ptr) { - ts_subtree_release(subtree_pool, self->lookahead_when_paused); + ts_subtree_release(/*subtree_pool, */ self->lookahead_when_paused); } if (self->summary) { @@ -375,7 +368,7 @@ static StackSliceArray stack__iter(Stack *self, StackVersion version, StackCallb { if (!should_pop) { - ts_subtree_array_delete(self->subtree_pool, &iterator->subtrees); + ts_subtree_array_delete(/*self->subtree_pool, */&iterator->subtrees); } array_erase(&self->iterators, i); i--, size--; @@ -434,7 +427,9 @@ static StackSliceArray stack__iter(Stack *self, StackVersion version, StackCallb Stack *ts_stack_new(SubtreePool *subtree_pool) { - Stack *self = mem_alloc_array(1, sizeof(Stack)); + Stack *self; + + self = mem_alloc(sizeof(*self)); array_init(&self->heads); array_init(&self->slices); @@ -443,7 +438,7 @@ Stack *ts_stack_new(SubtreePool *subtree_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->node_pool = (StackNodeArray)array_new(); self->subtree_pool = subtree_pool; self->base_node = stack_node_new(NULL, NULL_SUBTREE, false, 1, &self->node_pool); @@ -500,14 +495,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(self->subtree_pool, 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; @@ -639,14 +634,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--) diff --git a/parser/src/subtree.c b/parser/src/subtree.c index fe17ce84..9e897246 100644 --- a/parser/src/subtree.c +++ b/parser/src/subtree.c @@ -18,8 +18,8 @@ typedef struct Length new_end; } Edit; -#define TS_MAX_INLINE_TREE_LENGTH UINT8_MAX -#define TS_MAX_TREE_POOL_SIZE 32 +#define TS_MAX_INLINE_TREE_LENGTH 0 +#define TS_MAX_TREE_POOL_SIZE 0 // ExternalScannerState @@ -91,18 +91,18 @@ void ts_subtree_array_copy(SubtreeArray self, SubtreeArray *dest) } } -void ts_subtree_array_clear(SubtreePool *pool, SubtreeArray *self) +void ts_subtree_array_clear(/*SubtreePool *pool, */ SubtreeArray *self) { for (t_u32 i = 0; i < self->size; i++) { - ts_subtree_release(pool, self->contents[i]); + ts_subtree_release(/*pool,*/ self->contents[i]); } array_clear(self); } -void ts_subtree_array_delete(SubtreePool *pool, SubtreeArray *self) +void ts_subtree_array_delete(/*SubtreePool *pool,*/ SubtreeArray *self) { - ts_subtree_array_clear(pool, self); + ts_subtree_array_clear(/*pool, */ self); array_delete(self); } @@ -150,39 +150,13 @@ 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); } -static SubtreeHeapData *ts_subtree_pool_allocate(SubtreePool *self) -{ - if (self->free_trees.size > 0) - { - return array_pop(&self->free_trees).ptr; - } - else - { - return mem_alloc(sizeof(SubtreeHeapData)); - } -} - -static void ts_subtree_pool_free(SubtreePool *self, SubtreeHeapData *tree) -{ - if (self->free_trees.capacity > 0 && self->free_trees.size + 1 <= TS_MAX_TREE_POOL_SIZE) - { - array_push(&self->free_trees, (MutableSubtree){.ptr = tree}); - } - else - { - mem_free(tree); - } -} - // Subtree static inline bool ts_subtree_can_inline(Length padding, Length size, t_u32 lookahead_bytes) @@ -191,14 +165,17 @@ static inline bool ts_subtree_can_inline(Length padding, Length size, t_u32 look size.extent.row == 0 && size.extent.column < TS_MAX_INLINE_TREE_LENGTH && lookahead_bytes < 16; } -Subtree ts_subtree_new_leaf(SubtreePool *pool, TSSymbol symbol, Length padding, Length size, t_u32 lookahead_bytes, TSStateId parse_state, +Subtree ts_subtree_new_leaf(TSSymbol symbol, Length padding, Length size, t_u32 lookahead_bytes, TSStateId parse_state, bool has_external_tokens, bool depends_on_column, bool is_keyword, const TSLanguage *language) +// Subtree ts_subtree_new_leaf(SubtreePool *pool, TSSymbol symbol, Length padding, Length size, t_u32 lookahead_bytes, TSStateId +// parse_state, bool has_external_tokens, bool depends_on_column, bool is_keyword, const TSLanguage *language) { TSSymbolMetadata metadata = ts_language_symbol_metadata(language, symbol); bool extra = symbol == ts_builtin_sym_end; { - SubtreeHeapData *data = ts_subtree_pool_allocate(pool); + //--REMOVE-- (void)pool; + SubtreeHeapData *data = mem_alloc(sizeof(*data)); *data = (SubtreeHeapData){.ref_count = 1, .padding = padding, .size = size, @@ -233,11 +210,11 @@ void ts_subtree_set_symbol(MutableSubtree *self, TSSymbol symbol, const TSLangua } } -Subtree ts_subtree_new_error(SubtreePool *pool, t_i32 lookahead_char, Length padding, Length size, t_u32 bytes_scanned, +Subtree ts_subtree_new_error(/*SubtreePool *pool,*/ t_i32 lookahead_char, Length padding, Length size, t_u32 bytes_scanned, TSStateId parse_state, const TSLanguage *language) { Subtree result = - ts_subtree_new_leaf(pool, ts_builtin_sym_error, padding, size, bytes_scanned, parse_state, false, false, false, language); + ts_subtree_new_leaf(/*pool,*/ ts_builtin_sym_error, padding, size, bytes_scanned, parse_state, false, false, false, language); SubtreeHeapData *data = (SubtreeHeapData *)result.ptr; data->fragile_left = true; data->fragile_right = true; @@ -273,12 +250,12 @@ MutableSubtree ts_subtree_clone(Subtree self) // This takes ownership of the subtree. If the subtree has only one owner, // this will directly convert it into a mutable version. Otherwise, it will // perform a copy. -MutableSubtree ts_subtree_make_mut(SubtreePool *pool, Subtree self) +MutableSubtree ts_subtree_make_mut(/*SubtreePool *pool,*/ Subtree self) { if (self.ptr->ref_count == 1) return ts_subtree_to_mut_unsafe(self); MutableSubtree result = ts_subtree_clone(self); - ts_subtree_release(pool, self); + ts_subtree_release(/*pool, */ self); return result; } @@ -319,18 +296,22 @@ static void ts_subtree__compress(MutableSubtree self, t_u32 count, const TSLangu } } -void ts_subtree_balance(Subtree self, SubtreePool *pool, const TSLanguage *language) +void ts_subtree_balance(Subtree self, const TSLanguage *language) +// void ts_subtree_balance(Subtree self, SubtreePool *pool, const TSLanguage *language) { - array_clear(&pool->tree_stack); + //--REMOVE-- (void)pool; + + MutableSubtreeArray balance_stack = array_new(); + array_clear(&balance_stack); if (ts_subtree_child_count(self) > 0 && self.ptr->ref_count == 1) { - array_push(&pool->tree_stack, ts_subtree_to_mut_unsafe(self)); + array_push(&balance_stack, ts_subtree_to_mut_unsafe(self)); } - while (pool->tree_stack.size > 0) + while (balance_stack.size > 0) { - MutableSubtree tree = array_pop(&pool->tree_stack); + MutableSubtree tree = array_pop(&balance_stack); if (tree.ptr->repeat_depth > 0) { @@ -342,7 +323,7 @@ void ts_subtree_balance(Subtree self, SubtreePool *pool, const TSLanguage *langu t_u32 n = (t_u32)repeat_delta; for (t_u32 i = n / 2; i > 0; i /= 2) { - ts_subtree__compress(tree, i, language, &pool->tree_stack); + ts_subtree__compress(tree, i, language, &balance_stack); n -= i; } } @@ -353,10 +334,11 @@ void ts_subtree_balance(Subtree self, SubtreePool *pool, const TSLanguage *langu Subtree child = ts_subtree_children(tree)[i]; if (ts_subtree_child_count(child) > 0 && child.ptr->ref_count == 1) { - array_push(&pool->tree_stack, ts_subtree_to_mut_unsafe(child)); + array_push(&balance_stack, ts_subtree_to_mut_unsafe(child)); } } } + array_delete(&balance_stack); } // Assign all of the node's properties that depend on its children. @@ -553,9 +535,10 @@ Subtree ts_subtree_new_error_node(SubtreeArray *children, bool extra, const TSLa // // This node is treated as 'extra'. Its children are prevented from having // having any effect on the parse state. -Subtree ts_subtree_new_missing_leaf(SubtreePool *pool, TSSymbol symbol, Length padding, t_u32 lookahead_bytes, const TSLanguage *language) +Subtree ts_subtree_new_missing_leaf(/*SubtreePool *pool,*/ TSSymbol symbol, Length padding, t_u32 lookahead_bytes, + const TSLanguage *language) { - Subtree result = ts_subtree_new_leaf(pool, symbol, padding, length_zero(), lookahead_bytes, 0, false, false, false, language); + Subtree result = ts_subtree_new_leaf(/*pool, */ symbol, padding, length_zero(), lookahead_bytes, 0, false, false, false, language); ((SubtreeHeapData *)result.ptr)->is_missing = true; return result; } @@ -567,19 +550,25 @@ void ts_subtree_retain(Subtree self) assert(self.ptr->ref_count != 0); } -void ts_subtree_release(SubtreePool *pool, Subtree self) +void ts_subtree_release(Subtree self) +// void ts_subtree_release(SubtreePool *pool, Subtree self) { - array_clear(&pool->tree_stack); + //--REMOVE-- (void)(pool); + MutableSubtreeArray to_free; + + to_free = (MutableSubtreeArray)array_new(); + + array_clear(&to_free); assert(self.ptr->ref_count > 0); if (--(*(t_u32 *)(&self.ptr->ref_count)) == 0) { - array_push(&pool->tree_stack, ts_subtree_to_mut_unsafe(self)); + array_push(&to_free, ts_subtree_to_mut_unsafe(self)); } - while (pool->tree_stack.size > 0) + while (to_free.size > 0) { - MutableSubtree tree = array_pop(&pool->tree_stack); + MutableSubtree tree = array_pop(&to_free); if (tree.ptr->child_count > 0) { Subtree *children = ts_subtree_children(tree); @@ -589,7 +578,7 @@ void ts_subtree_release(SubtreePool *pool, Subtree self) assert(child.ptr->ref_count > 0); if (--(*(t_u32 *)(&child.ptr->ref_count)) == 0) { - array_push(&pool->tree_stack, ts_subtree_to_mut_unsafe(child)); + array_push(&to_free, ts_subtree_to_mut_unsafe(child)); } } mem_free(children); @@ -597,23 +586,26 @@ void ts_subtree_release(SubtreePool *pool, Subtree self) else { if (tree.ptr->has_external_tokens) - { ts_external_scanner_state_delete(&tree.ptr->external_scanner_state); - } - ts_subtree_pool_free(pool, tree.ptr); + mem_free(tree.ptr); } } + array_delete(&to_free); } -int ts_subtree_compare(Subtree left, Subtree right, SubtreePool *pool) +int ts_subtree_compare(Subtree left, Subtree right) +// int ts_subtree_compare(Subtree left, Subtree right, SubtreePool *pool) { - array_push(&pool->tree_stack, ts_subtree_to_mut_unsafe(left)); - array_push(&pool->tree_stack, ts_subtree_to_mut_unsafe(right)); + MutableSubtreeArray compare_stack = array_new(); - while (pool->tree_stack.size > 0) + //--REMOVE-- (void)(pool); + array_push(&compare_stack, ts_subtree_to_mut_unsafe(left)); + array_push(&compare_stack, ts_subtree_to_mut_unsafe(right)); + + while (compare_stack.size > 0) { - right = ts_subtree_from_mut(array_pop(&pool->tree_stack)); - left = ts_subtree_from_mut(array_pop(&pool->tree_stack)); + right = ts_subtree_from_mut(array_pop(&compare_stack)); + left = ts_subtree_from_mut(array_pop(&compare_stack)); int result = 0; if (ts_subtree_symbol(left) < ts_subtree_symbol(right)) @@ -626,7 +618,8 @@ int ts_subtree_compare(Subtree left, Subtree right, SubtreePool *pool) result = 1; if (result != 0) { - array_clear(&pool->tree_stack); + array_clear(&compare_stack); + array_delete(&compare_stack); return result; } @@ -634,11 +627,12 @@ int ts_subtree_compare(Subtree left, Subtree right, SubtreePool *pool) { Subtree left_child = ts_subtree_children(left)[i - 1]; Subtree right_child = ts_subtree_children(right)[i - 1]; - array_push(&pool->tree_stack, ts_subtree_to_mut_unsafe(left_child)); - array_push(&pool->tree_stack, ts_subtree_to_mut_unsafe(right_child)); + array_push(&compare_stack, ts_subtree_to_mut_unsafe(left_child)); + array_push(&compare_stack, ts_subtree_to_mut_unsafe(right_child)); } } + array_delete(&compare_stack); return 0; } @@ -647,7 +641,7 @@ static inline void ts_subtree_set_has_changes(MutableSubtree *self) self->ptr->has_changes = true; } -Subtree ts_subtree_edit(Subtree self, const TSInputEdit *input_edit, SubtreePool *pool) +Subtree ts_subtree_edit(Subtree self, const TSInputEdit *input_edit /*, SubtreePool *pool*/) { typedef struct { @@ -710,7 +704,7 @@ Subtree ts_subtree_edit(Subtree self, const TSInputEdit *input_edit, SubtreePool size = length_add(length_sub(edit.new_end, padding), length_saturating_sub(total_size, edit.old_end)); } - MutableSubtree result = ts_subtree_make_mut(pool, *entry.tree); + MutableSubtree result = ts_subtree_make_mut(/* pool, */ *entry.tree); { result.ptr->padding = padding; diff --git a/parser/src/tree.c b/parser/src/tree.c index da90fa43..b8604316 100644 --- a/parser/src/tree.c +++ b/parser/src/tree.c @@ -1,13 +1,12 @@ #define _POSIX_C_SOURCE 200112L - -#include "me/types.h" #include "parser/tree.h" +#include "me/types.h" +#include "parser/api.h" #include "parser/array.h" #include "parser/length.h" -#include "parser/subtree.h" -#include "parser/api.h" #include "parser/point.h" +#include "parser/subtree.h" TSTree *ts_tree_new(Subtree root, const TSLanguage *language, const TSRange *included_ranges, t_u32 included_range_count) { @@ -32,7 +31,7 @@ void ts_tree_delete(TSTree *self) return; 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_language_delete(self->language); mem_free(self->included_ranges); @@ -96,7 +95,7 @@ void ts_tree_edit(TSTree *self, const TSInputEdit *edit) } 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); }