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

Removed tree pool

Browse source
This commit is contained in:
Maix0 2024-08-18 22:34:41 +02:00
parent 881a43bd47
commit 9059912ba9
6 changed files with 143 additions and 153 deletions
Download patch file Download diff file Expand all files Collapse all files

4
Makefile
View file

@ -6,7 +6,7 @@
# By: rparodi <rparodi@student.42.fr> +#+ +:+ +#+ # # By: rparodi <rparodi@student.42.fr> +#+ +:+ +#+ #
# +#+#+#+#+#+ +#+ # # +#+#+#+#+#+ +#+ #
# Created: 2023/11/12 11:05:05 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: # TODO: ADD THIS WHEN FINISHING THIS:
# CFLAGS_ADDITIONAL += -DNVALGRIND # CFLAGS_ADDITIONAL += -DNVALGRIND
CFLAGS_ADDITIONAL += -O0 -Wno-cpp CFLAGS_ADDITIONAL += -O0 -Wno-cpp -Wno-type-limits
# TODO: REMOVE THIS WHEN FINISHING THIS: # TODO: REMOVE THIS WHEN FINISHING THIS:
CFLAGS_ADDITIONAL += -gcolumn-info -g3 CFLAGS_ADDITIONAL += -gcolumn-info -g3

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

@ -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_external_scanner_state_delete(ExternalScannerState *self);
void ts_subtree_array_copy(SubtreeArray, SubtreeArray *); void ts_subtree_array_copy(SubtreeArray, SubtreeArray *);
void ts_subtree_array_clear(SubtreePool *, SubtreeArray *); void ts_subtree_array_clear(/*SubtreePool *,*/ SubtreeArray *);
void ts_subtree_array_delete(SubtreePool *, SubtreeArray *); 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 *);
MutableSubtree ts_subtree_new_node(TSSymbol, SubtreeArray *, t_u32, 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_error_node(SubtreeArray *, bool, const TSLanguage *);
Subtree ts_subtree_new_missing_leaf(SubtreePool *, TSSymbol, Length, t_u32, const TSLanguage *); Subtree ts_subtree_new_missing_leaf(/*SubtreePool *,*/ TSSymbol, Length, t_u32, const TSLanguage *);
MutableSubtree ts_subtree_make_mut(SubtreePool *, Subtree); MutableSubtree ts_subtree_make_mut(/*SubtreePool *,*/ Subtree);
void ts_subtree_retain(Subtree); void ts_subtree_retain(Subtree);
void ts_subtree_release(SubtreePool *, Subtree); void ts_subtree_release(/*SubtreePool *,*/ Subtree);
int ts_subtree_compare(Subtree, Subtree, SubtreePool *); int ts_subtree_compare(Subtree, Subtree/*, SubtreePool **/);
void ts_subtree_set_symbol(MutableSubtree *, TSSymbol, const TSLanguage *); void ts_subtree_set_symbol(MutableSubtree *, TSSymbol, const TSLanguage *);
void ts_subtree_summarize(MutableSubtree, const Subtree *, t_u32, const TSLanguage *); void ts_subtree_summarize(MutableSubtree, const Subtree *, t_u32, const TSLanguage *);
void ts_subtree_summarize_children(MutableSubtree, const TSLanguage *); void ts_subtree_summarize_children(MutableSubtree, const TSLanguage *);
void ts_subtree_balance(Subtree, SubtreePool *, const TSLanguage *); void ts_subtree_balance(Subtree, /*SubtreePool *,*/ const TSLanguage *);
Subtree ts_subtree_edit(Subtree, const TSInputEdit *edit, SubtreePool *); Subtree ts_subtree_edit(Subtree, const TSInputEdit *edit/*, SubtreePool **/);
char *ts_subtree_string(Subtree, TSSymbol, bool, const TSLanguage *, bool include_all); char *ts_subtree_string(Subtree, TSSymbol, bool, const TSLanguage *, bool include_all);
void ts_subtree_print_dot_graph(Subtree, const TSLanguage *, FILE *); void ts_subtree_print_dot_graph(Subtree, const TSLanguage *, FILE *);
Subtree ts_subtree_last_external_token(Subtree); Subtree ts_subtree_last_external_token(Subtree);

68
parser/src/parser.c
View file

@ -1,5 +1,7 @@
#define _POSIX_C_SOURCE 200112L #define _POSIX_C_SOURCE 200112L
#include "me/mem/mem.h"
#include "me/types.h"
#include "parser/api.h" #include "parser/api.h"
#include "parser/array.h" #include "parser/array.h"
#include "parser/language.h" #include "parser/language.h"
@ -9,8 +11,6 @@
#include "parser/stack.h" #include "parser/stack.h"
#include "parser/subtree.h" #include "parser/subtree.h"
#include "parser/tree.h" #include "parser/tree.h"
#include "me/mem/mem.h"
#include "me/types.h"
#include <assert.h> #include <assert.h>
#include <stdio.h> #include <stdio.h>
@ -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_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); array_delete(&slice.subtrees);
LOG("breakdown_top_of_stack tree:%s", TREE_NAME(parent)); 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 padding = length_sub(error_start_position, start_position);
Length size = length_sub(error_end_position, error_start_position); Length size = length_sub(error_end_position, error_start_position);
t_u32 lookahead_bytes = lookahead_end_byte - error_end_position.bytes; 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 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); called_get_column, is_keyword, self->language);
if (found_external_token) 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) if (last_external_token.ptr)
ts_subtree_retain(last_external_token); ts_subtree_retain(last_external_token);
if (cache->token.ptr) 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) 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->token = token;
cache->byte_index = byte_index; cache->byte_index = byte_index;
cache->last_external_token = last_external_token; 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. // 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) static bool ts_parser__select_tree(TSParser *self, Subtree left, Subtree right)
{ {
(void)(self);
if (!left.ptr) if (!left.ptr)
return true; return true;
if (!right.ptr) 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) if (ts_subtree_error_cost(left) > 0)
return true; return true;
int comparison = ts_subtree_compare(left, right, &self->tree_pool); int comparison = ts_subtree_compare(left, right /* , &self->tree_pool*/);
switch (comparison) switch (comparison)
{ {
case -1: case -1:
@ -641,7 +643,7 @@ static void ts_parser__shift(TSParser *self, StackVersion version, TSStateId sta
Subtree subtree_to_push = lookahead; Subtree subtree_to_push = lookahead;
if (extra != ts_subtree_extra(lookahead) && is_leaf) 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); ts_subtree_set_extra(&result, extra);
subtree_to_push = ts_subtree_from_mut(result); 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) if (slice_version > MAX_VERSION_COUNT + MAX_VERSION_COUNT_OVERFLOW)
{ {
ts_stack_remove_version(self->stack, slice_version); 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++; removed_version_count++;
while (i + 1 < pop.size) while (i + 1 < pop.size)
{ {
StackSlice next_slice = pop.contents[i + 1]; StackSlice next_slice = pop.contents[i + 1];
if (next_slice.version != slice.version) if (next_slice.version != slice.version)
break; break;
ts_subtree_array_delete(&self->tree_pool, &next_slice.subtrees); ts_subtree_array_delete(/*&self->tree_pool,*/ &next_slice.subtrees);
i++; i++;
} }
continue; 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)) 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_array_clear(/*&self->tree_pool,*/ &self->trailing_extras);
ts_subtree_release(&self->tree_pool, ts_subtree_from_mut(parent)); ts_subtree_release(/*&self->tree_pool,*/ ts_subtree_from_mut(parent));
array_swap(&self->trailing_extras, &self->trailing_extras2); array_swap(&self->trailing_extras, &self->trailing_extras2);
parent = ts_subtree_new_node(symbol, &next_slice_children, production_id, self->language); parent = ts_subtree_new_node(symbol, &next_slice_children, production_id, self->language);
} }
else else
{ {
array_clear(&self->trailing_extras2); 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); 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)); 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; 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)) 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; self->finished_tree = root;
} }
else else
{ {
ts_subtree_release(&self->tree_pool, root); ts_subtree_release(/*&self->tree_pool,*/ root);
} }
} }
else else
@ -938,7 +940,7 @@ static bool ts_parser__recover_to_state(TSParser *self, StackVersion version, t_
if (slice.version == previous_version) 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--); array_erase(&pop, i--);
continue; 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) if (ts_stack_state(self->stack, slice.version) != goal_state)
{ {
ts_stack_halt(self->stack, slice.version); 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--); array_erase(&pop, i--);
continue; 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_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); 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) if (did_recover && ts_stack_version_count(self->stack) > MAX_VERSION_COUNT)
{ {
ts_stack_halt(self->stack, version); ts_stack_halt(self->stack, version);
ts_subtree_release(&self->tree_pool, lookahead); ts_subtree_release(/*&self->tree_pool,*/ lookahead);
return; return;
} }
if (did_recover && ts_subtree_has_external_scanner_state_change(lookahead)) if (did_recover && ts_subtree_has_external_scanner_state_change(lookahead))
{ {
ts_stack_halt(self->stack, version); ts_stack_halt(self->stack, version);
ts_subtree_release(&self->tree_pool, lookahead); ts_subtree_release(/*&self->tree_pool,*/ lookahead);
return; 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)) if (ts_parser__better_version_exists(self, version, false, new_cost))
{ {
ts_stack_halt(self->stack, version); ts_stack_halt(self->stack, version);
ts_subtree_release(&self->tree_pool, lookahead); ts_subtree_release(/*&self->tree_pool,*/ lookahead);
return; 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); 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) 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); ts_subtree_set_extra(&mutable_lookahead, true);
lookahead = ts_subtree_from_mut(mutable_lookahead); 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++) 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) 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); StackVersion version_with_missing_tree = ts_stack_copy_version(self->stack, v);
Subtree missing_tree = 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); 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))) 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) if (lookahead.ptr)
{ {
ts_subtree_release(&self->tree_pool, lookahead); ts_subtree_release(/*&self->tree_pool,*/ lookahead);
} }
return false; 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)); 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); ts_subtree_set_symbol(&mutable_lookahead, self->language->keyword_capture_token, self->language);
lookahead = ts_subtree_from_mut(mutable_lookahead); lookahead = ts_subtree_from_mut(mutable_lookahead);
continue; 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)) if (ts_parser__breakdown_top_of_stack(self, version))
{ {
state = ts_stack_state(self->stack, 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; needs_lex = true;
continue; continue;
} }
@ -1612,7 +1614,7 @@ void ts_parser_delete(TSParser *self)
} }
if (self->old_tree.ptr) 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; self->old_tree = NULL_SUBTREE;
} }
ts_lexer_delete(&self->lexer); ts_lexer_delete(&self->lexer);
@ -1650,7 +1652,7 @@ void ts_parser_reset(TSParser *self)
ts_parser__external_scanner_destroy(self); ts_parser__external_scanner_destroy(self);
if (self->old_tree.ptr) 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; 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); ts_parser__set_cached_token(self, 0, NULL_SUBTREE, NULL_SUBTREE);
if (self->finished_tree.ptr) 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->finished_tree = NULL_SUBTREE;
} }
self->accept_count = 0; self->accept_count = 0;
@ -1738,7 +1740,7 @@ TSTree *ts_parser_parse(TSParser *self, const TSTree *old_tree, TSInput input)
} while (version_count != 0); } while (version_count != 0);
assert(self->finished_tree.ptr); 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("done");
LOG_TREE(self->finished_tree); LOG_TREE(self->finished_tree);

65
parser/src/stack.c
View file

@ -1,17 +1,17 @@
#include "parser/stack.h" #include "parser/stack.h"
#include "me/mem/mem.h"
#include "me/types.h"
#include "parser/array.h" #include "parser/array.h"
#include "parser/language.h" #include "parser/language.h"
#include "parser/length.h" #include "parser/length.h"
#include "parser/subtree.h" #include "parser/subtree.h"
#include "me/mem/mem.h"
#include "me/types.h"
#include <assert.h> #include <assert.h>
#include <stdio.h> #include <stdio.h>
#define MAX_LINK_COUNT 8 #define MAX_LINK_COUNT 1
#define MAX_NODE_POOL_SIZE 50 #define MAX_NODE_POOL_SIZE 0
#define MAX_ITERATOR_COUNT 64 #define MAX_ITERATOR_COUNT 0
typedef struct StackNode StackNode; typedef struct StackNode StackNode;
@ -24,14 +24,14 @@ typedef struct StackLink
struct StackNode struct StackNode
{ {
TSStateId state; TSStateId state;
Length position; Length position;
StackLink links[MAX_LINK_COUNT]; StackLink links[MAX_LINK_COUNT];
t_u16 link_count; t_u16 link_count;
t_u32 ref_count; t_u32 ref_count;
t_u32 error_cost; t_u32 error_cost;
t_u32 node_count; t_u32 node_count;
int dynamic_precedence; int dynamic_precedence;
}; };
typedef struct StackIterator typedef struct StackIterator
@ -55,7 +55,7 @@ typedef struct StackHead
{ {
StackNode *node; StackNode *node;
StackSummary *summary; StackSummary *summary;
t_u32 node_count_at_last_error; t_u32 node_count_at_last_error;
Subtree last_external_token; Subtree last_external_token;
Subtree lookahead_when_paused; Subtree lookahead_when_paused;
StackStatus status; StackStatus status;
@ -105,23 +105,16 @@ 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)
ts_subtree_release(subtree_pool, link.subtree); ts_subtree_release(/*subtree_pool, */ link.subtree);
first_predecessor = self->links[0].node; first_predecessor = self->links[0].node;
} }
if (pool->size < MAX_NODE_POOL_SIZE) mem_free(self);
{
array_push(pool, self);
}
else
{
mem_free(self);
}
if (first_predecessor) 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)) if (ts_subtree_dynamic_precedence(link.subtree) > ts_subtree_dynamic_precedence(existing_link->subtree))
{ {
ts_subtree_retain(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; existing_link->subtree = link.subtree;
self->dynamic_precedence = link.node->dynamic_precedence + ts_subtree_dynamic_precedence(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); stack_node_retain(link.node);
t_u32 node_count = link.node->node_count; 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; self->links[self->link_count++] = link;
if (link.subtree.ptr) if (link.subtree.ptr)
@ -278,11 +271,11 @@ static void stack_head_delete(StackHead *self, StackNodeArray *pool, SubtreePool
{ {
if (self->last_external_token.ptr) 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) 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) if (self->summary)
{ {
@ -375,7 +368,7 @@ static StackSliceArray stack__iter(Stack *self, StackVersion version, StackCallb
{ {
if (!should_pop) 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); array_erase(&self->iterators, i);
i--, size--; i--, size--;
@ -434,7 +427,9 @@ static StackSliceArray stack__iter(Stack *self, StackVersion version, StackCallb
Stack *ts_stack_new(SubtreePool *subtree_pool) 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->heads);
array_init(&self->slices); array_init(&self->slices);
@ -443,7 +438,7 @@ Stack *ts_stack_new(SubtreePool *subtree_pool)
array_reserve(&self->heads, 4); array_reserve(&self->heads, 4);
array_reserve(&self->slices, 4); array_reserve(&self->slices, 4);
array_reserve(&self->iterators, 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->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);
@ -500,14 +495,14 @@ void ts_stack_set_last_external_token(Stack *self, StackVersion version, Subtree
if (token.ptr) if (token.ptr)
ts_subtree_retain(token); ts_subtree_retain(token);
if (head->last_external_token.ptr) 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; head->last_external_token = token;
} }
t_u32 ts_stack_error_cost(const Stack *self, StackVersion version) t_u32 ts_stack_error_cost(const Stack *self, StackVersion version)
{ {
StackHead *head = array_get(&self->heads, 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)) if (head->status == StackStatusPaused || (head->node->state == ERROR_STATE && !head->node->links[0].subtree.ptr))
{ {
result += ERROR_COST_PER_RECOVERY; result += ERROR_COST_PER_RECOVERY;
@ -639,14 +634,14 @@ StackSliceArray ts_stack_pop_all(Stack *self, StackVersion version)
typedef struct SummarizeStackSession typedef struct SummarizeStackSession
{ {
StackSummary *summary; StackSummary *summary;
t_u32 max_depth; t_u32 max_depth;
} SummarizeStackSession; } SummarizeStackSession;
StackAction summarize_stack_callback(void *payload, const StackIterator *iterator) StackAction summarize_stack_callback(void *payload, const StackIterator *iterator)
{ {
SummarizeStackSession *session = payload; SummarizeStackSession *session = payload;
TSStateId state = iterator->node->state; TSStateId state = iterator->node->state;
t_u32 depth = iterator->subtree_count; t_u32 depth = iterator->subtree_count;
if (depth > session->max_depth) if (depth > session->max_depth)
return StackActionStop; return StackActionStop;
for (t_u32 i = session->summary->size - 1; i + 1 > 0; i--) for (t_u32 i = session->summary->size - 1; i + 1 > 0; i--)

128
parser/src/subtree.c
View file

@ -18,8 +18,8 @@ typedef struct
Length new_end; Length new_end;
} Edit; } Edit;
#define TS_MAX_INLINE_TREE_LENGTH UINT8_MAX #define TS_MAX_INLINE_TREE_LENGTH 0
#define TS_MAX_TREE_POOL_SIZE 32 #define TS_MAX_TREE_POOL_SIZE 0
// ExternalScannerState // 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++) 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); 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); array_delete(self);
} }
@ -150,39 +150,13 @@ 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);
} }
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 // 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)
@ -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; 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) 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); TSSymbolMetadata metadata = ts_language_symbol_metadata(language, symbol);
bool extra = symbol == ts_builtin_sym_end; 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, *data = (SubtreeHeapData){.ref_count = 1,
.padding = padding, .padding = padding,
.size = size, .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) TSStateId parse_state, const TSLanguage *language)
{ {
Subtree result = 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; SubtreeHeapData *data = (SubtreeHeapData *)result.ptr;
data->fragile_left = true; data->fragile_left = true;
data->fragile_right = 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 takes ownership of the subtree. If the subtree has only one owner,
// this will directly convert it into a mutable version. Otherwise, it will // this will directly convert it into a mutable version. Otherwise, it will
// perform a copy. // 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) if (self.ptr->ref_count == 1)
return ts_subtree_to_mut_unsafe(self); return ts_subtree_to_mut_unsafe(self);
MutableSubtree result = ts_subtree_clone(self); MutableSubtree result = ts_subtree_clone(self);
ts_subtree_release(pool, self); ts_subtree_release(/*pool, */ self);
return result; 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) 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) 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; t_u32 n = (t_u32)repeat_delta;
for (t_u32 i = n / 2; i > 0; i /= 2) 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; n -= i;
} }
} }
@ -353,10 +334,11 @@ void ts_subtree_balance(Subtree self, SubtreePool *pool, const TSLanguage *langu
Subtree child = ts_subtree_children(tree)[i]; Subtree child = ts_subtree_children(tree)[i];
if (ts_subtree_child_count(child) > 0 && child.ptr->ref_count == 1) 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. // 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 // This node is treated as 'extra'. Its children are prevented from having
// having any effect on the parse state. // 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; ((SubtreeHeapData *)result.ptr)->is_missing = true;
return result; return result;
} }
@ -567,19 +550,25 @@ void ts_subtree_retain(Subtree self)
assert(self.ptr->ref_count != 0); 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); assert(self.ptr->ref_count > 0);
if (--(*(t_u32 *)(&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) if (tree.ptr->child_count > 0)
{ {
Subtree *children = ts_subtree_children(tree); Subtree *children = ts_subtree_children(tree);
@ -589,7 +578,7 @@ void ts_subtree_release(SubtreePool *pool, Subtree self)
assert(child.ptr->ref_count > 0); assert(child.ptr->ref_count > 0);
if (--(*(t_u32 *)(&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); mem_free(children);
@ -597,23 +586,26 @@ void ts_subtree_release(SubtreePool *pool, Subtree self)
else else
{ {
if (tree.ptr->has_external_tokens) if (tree.ptr->has_external_tokens)
{
ts_external_scanner_state_delete(&tree.ptr->external_scanner_state); ts_external_scanner_state_delete(&tree.ptr->external_scanner_state);
} mem_free(tree.ptr);
ts_subtree_pool_free(pool, 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)); MutableSubtreeArray compare_stack = array_new();
array_push(&pool->tree_stack, ts_subtree_to_mut_unsafe(right));
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)); right = ts_subtree_from_mut(array_pop(&compare_stack));
left = ts_subtree_from_mut(array_pop(&pool->tree_stack)); left = ts_subtree_from_mut(array_pop(&compare_stack));
int result = 0; int result = 0;
if (ts_subtree_symbol(left) < ts_subtree_symbol(right)) 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; result = 1;
if (result != 0) if (result != 0)
{ {
array_clear(&pool->tree_stack); array_clear(&compare_stack);
array_delete(&compare_stack);
return result; 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 left_child = ts_subtree_children(left)[i - 1];
Subtree right_child = ts_subtree_children(right)[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(&compare_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(right_child));
} }
} }
array_delete(&compare_stack);
return 0; return 0;
} }
@ -647,7 +641,7 @@ static inline void ts_subtree_set_has_changes(MutableSubtree *self)
self->ptr->has_changes = true; 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 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)); 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; result.ptr->padding = padding;

11
parser/src/tree.c
View file

@ -1,13 +1,12 @@
#define _POSIX_C_SOURCE 200112L #define _POSIX_C_SOURCE 200112L
#include "me/types.h"
#include "parser/tree.h" #include "parser/tree.h"
#include "me/types.h"
#include "parser/api.h"
#include "parser/array.h" #include "parser/array.h"
#include "parser/length.h" #include "parser/length.h"
#include "parser/subtree.h"
#include "parser/api.h"
#include "parser/point.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) 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; 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);
@ -96,7 +95,7 @@ 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);
} }