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

68
parser/src/parser.c
View file

@ -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 <assert.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_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);

65
parser/src/stack.c
View file

@ -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 <assert.h>
#include <stdio.h>
#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--)

128
parser/src/subtree.c
View file

@ -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;

11
parser/src/tree.c
View file

@ -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);
}