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

Removed more stuff

Browse source
This commit is contained in:
Maieul BOYER 2024-08-23 19:58:11 +02:00
parent db0903c3a8
commit 9f37123e46
No known key found for this signature in database
5 changed files with 19 additions and 260 deletions
Download patch file Download diff file Expand all files Collapse all files

10
parser/src/language.c
View file

@ -5,16 +5,6 @@
#include <assert.h> #include <assert.h>
#include <string.h> #include <string.h>
const TSLanguage *ts_language_copy(const TSLanguage *self)
{
return (self);
}
void ts_language_delete(const TSLanguage *self)
{
(void)(self);
}
t_u32 ts_language_symbol_count(const TSLanguage *self) t_u32 ts_language_symbol_count(const TSLanguage *self)
{ {
return (self->symbol_count + self->alias_count); return (self->symbol_count + self->alias_count);

13
parser/src/parser.c
View file

@ -1528,16 +1528,7 @@ const TSLanguage *ts_parser_language(const TSParser *self)
bool ts_parser_set_language(TSParser *self, const TSLanguage *language) bool ts_parser_set_language(TSParser *self, const TSLanguage *language)
{ {
ts_parser_reset(self); ts_parser_reset(self);
ts_language_delete(self->language); self->language = language;
self->language = NULL;
if (language)
{
if (language->version > TREE_SITTER_LANGUAGE_VERSION || language->version < TREE_SITTER_MIN_COMPATIBLE_LANGUAGE_VERSION)
return false;
}
self->language = ts_language_copy(language);
return true; return true;
} }
@ -1548,7 +1539,7 @@ void ts_parser_reset(TSParser *self)
ts_stack_clear(self->stack); ts_stack_clear(self->stack);
if (self->finished_tree) if (self->finished_tree)
{ {
ts_subtree_release(/*&self->tree_pool,*/ self->finished_tree); ts_subtree_release(self->finished_tree);
self->finished_tree = NULL_SUBTREE; self->finished_tree = NULL_SUBTREE;
} }
self->accept_count = 0; self->accept_count = 0;

184
parser/src/subtree.c
View file

@ -71,18 +71,18 @@ void ts_subtree_array_copy(SubtreeArray self, SubtreeArray *dest)
} }
} }
void ts_subtree_array_clear(/*SubtreePool *pool, */ SubtreeArray *self) void ts_subtree_array_clear( 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( self->contents[i]);
} }
array_clear(self); array_clear(self);
} }
void ts_subtree_array_delete(/*SubtreePool *pool,*/ SubtreeArray *self) void ts_subtree_array_delete( SubtreeArray *self)
{ {
ts_subtree_array_clear(/*pool, */ self); ts_subtree_array_clear( self);
array_delete(self); array_delete(self);
} }
@ -116,39 +116,14 @@ void ts_subtree_array_reverse(SubtreeArray *self)
} }
} }
// SubtreePool
/* SubtreePool ts_subtree_pool_new(t_u32 capacity) */
/* { */
/* SubtreePool self = {array_new(), array_new()}; */
/* array_reserve(&self.free_trees, capacity); */
/* return self; */
/* } */
/**/
/* void ts_subtree_pool_delete(SubtreePool *self) */
/* { */
/* if (self->free_trees.contents) */
/* { */
/* for (t_u32 i = 0; i < self->free_trees.size; i++) */
/* mem_free(self->free_trees.contents[i]); */
/* array_delete(&self->free_trees); */
/* } */
/* if (self->tree_stack.contents) */
/* array_delete(&self->tree_stack); */
/* } */
/**/
// Subtree
Subtree ts_subtree_new_leaf(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;
{ {
//--REMOVE-- (void)pool;
SubtreeHeapData *data = mem_alloc(sizeof(*data)); SubtreeHeapData *data = mem_alloc(sizeof(*data));
*data = (SubtreeHeapData){.ref_count = 1, *data = (SubtreeHeapData){.ref_count = 1,
.padding = padding, .padding = padding,
@ -184,11 +159,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(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(ts_builtin_sym_error, padding, size, bytes_scanned, parse_state, false, false, false, language);
SubtreeHeapData *data = (SubtreeHeapData *)result; SubtreeHeapData *data = (SubtreeHeapData *)result;
data->fragile_left = true; data->fragile_left = true;
data->fragile_right = true; data->fragile_right = true;
@ -224,12 +199,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( Subtree self)
{ {
if (self->ref_count == 1) if (self->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( self);
return result; return result;
} }
@ -271,9 +246,7 @@ static void ts_subtree__compress(MutableSubtree self, t_u32 count, const TSLangu
} }
void ts_subtree_balance(Subtree self, const TSLanguage *language) void ts_subtree_balance(Subtree self, const TSLanguage *language)
// void ts_subtree_balance(Subtree self, SubtreePool *pool, const TSLanguage *language)
{ {
//--REMOVE-- (void)pool;
MutableSubtreeArray balance_stack = array_new(); MutableSubtreeArray balance_stack = array_new();
array_clear(&balance_stack); array_clear(&balance_stack);
@ -509,10 +482,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, Subtree ts_subtree_new_missing_leaf( TSSymbol symbol, Length padding, t_u32 lookahead_bytes,
const TSLanguage *language) 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(symbol, padding, length_zero(), lookahead_bytes, 0, false, false, false, language);
((SubtreeHeapData *)result)->is_missing = true; ((SubtreeHeapData *)result)->is_missing = true;
return result; return result;
} }
@ -525,9 +498,7 @@ void ts_subtree_retain(Subtree self)
} }
void ts_subtree_release(Subtree self) void ts_subtree_release(Subtree self)
// void ts_subtree_release(SubtreePool *pool, Subtree self)
{ {
//--REMOVE-- (void)(pool);
MutableSubtreeArray to_free; MutableSubtreeArray to_free;
to_free = (MutableSubtreeArray)array_new(); to_free = (MutableSubtreeArray)array_new();
@ -568,11 +539,9 @@ void ts_subtree_release(Subtree self)
} }
int ts_subtree_compare(Subtree left, Subtree right) int ts_subtree_compare(Subtree left, Subtree right)
// int ts_subtree_compare(Subtree left, Subtree right, SubtreePool *pool)
{ {
MutableSubtreeArray compare_stack = array_new(); MutableSubtreeArray compare_stack = array_new();
//--REMOVE-- (void)(pool);
array_push(&compare_stack, ts_subtree_to_mut_unsafe(left)); array_push(&compare_stack, ts_subtree_to_mut_unsafe(left));
array_push(&compare_stack, ts_subtree_to_mut_unsafe(right)); array_push(&compare_stack, ts_subtree_to_mut_unsafe(right));
@ -610,139 +579,6 @@ int ts_subtree_compare(Subtree left, Subtree right)
return 0; return 0;
} }
static inline void ts_subtree_set_has_changes(MutableSubtree *self)
{
(*self)->has_changes = true;
}
Subtree ts_subtree_edit(Subtree self, const TSInputEdit *input_edit /*, SubtreePool *pool*/)
{
typedef struct
{
Subtree *tree;
Edit edit;
} EditEntry;
Array(EditEntry) stack = array_new();
array_push(&stack, ((EditEntry){
.tree = &self,
.edit =
(Edit){
.start = {input_edit->start_byte, input_edit->start_point},
.old_end = {input_edit->old_end_byte, input_edit->old_end_point},
.new_end = {input_edit->new_end_byte, input_edit->new_end_point},
},
}));
while (stack.size)
{
EditEntry entry = array_pop(&stack);
Edit edit = entry.edit;
bool is_noop = edit.old_end.bytes == edit.start.bytes && edit.new_end.bytes == edit.start.bytes;
bool is_pure_insertion = edit.old_end.bytes == edit.start.bytes;
bool invalidate_first_row = ts_subtree_depends_on_column(*entry.tree);
Length size = ts_subtree_size(*entry.tree);
Length padding = ts_subtree_padding(*entry.tree);
Length total_size = length_add(padding, size);
t_u32 lookahead_bytes = ts_subtree_lookahead_bytes(*entry.tree);
t_u32 end_byte = total_size.bytes + lookahead_bytes;
if (edit.start.bytes > end_byte || (is_noop && edit.start.bytes == end_byte))
continue;
// If the edit is entirely within the space before this subtree, then shift this
// subtree over according to the edit without changing its size.
if (edit.old_end.bytes <= padding.bytes)
{
padding = length_add(edit.new_end, length_sub(padding, edit.old_end));
}
// If the edit starts in the space before this subtree and extends into this subtree,
// shrink the subtree's content to compensate for the change in the space before it.
else if (edit.start.bytes < padding.bytes)
{
size = length_saturating_sub(size, length_sub(edit.old_end, padding));
padding = edit.new_end;
}
// If the edit is a pure insertion right at the start of the subtree,
// shift the subtree over according to the insertion.
else if (edit.start.bytes == padding.bytes && is_pure_insertion)
{
padding = edit.new_end;
}
// If the edit is within this subtree, resize the subtree to reflect the edit.
else if (edit.start.bytes < total_size.bytes || (edit.start.bytes == total_size.bytes && is_pure_insertion))
{
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);
{
result->padding = padding;
result->size = size;
}
ts_subtree_set_has_changes(&result);
*entry.tree = ts_subtree_from_mut(result);
Length child_left, child_right = length_zero();
for (t_u32 i = 0, n = ts_subtree_child_count(*entry.tree); i < n; i++)
{
Subtree *child = &ts_subtree_children(*entry.tree)[i];
Length child_size = ts_subtree_total_size(*child);
child_left = child_right;
child_right = length_add(child_left, child_size);
// If this child ends before the edit, it is not affected.
if (child_right.bytes + ts_subtree_lookahead_bytes(*child) < edit.start.bytes)
continue;
// Keep editing child nodes until a node is reached that starts after the edit.
// Also, if this node's validity depends on its column position, then continue
// invaliditing child nodes until reaching a line break.
if (((child_left.bytes > edit.old_end.bytes) || (child_left.bytes == edit.old_end.bytes && child_size.bytes > 0 && i > 0)) &&
(!invalidate_first_row || child_left.extent.row > (*entry.tree)->padding.extent.row))
{
break;
}
// Transform edit into the child's coordinate space.
Edit child_edit = {
.start = length_saturating_sub(edit.start, child_left),
.old_end = length_saturating_sub(edit.old_end, child_left),
.new_end = length_saturating_sub(edit.new_end, child_left),
};
// Interpret all inserted text as applying to the *first* child that touches the edit.
// Subsequent children are only never have any text inserted into them; they are only
// shrunk to compensate for the edit.
if (child_right.bytes > edit.start.bytes || (child_right.bytes == edit.start.bytes && is_pure_insertion))
{
edit.new_end = edit.start;
}
// Children that occur before the edit are not reshaped by the edit.
else
{
child_edit.old_end = child_edit.start;
child_edit.new_end = child_edit.start;
}
// Queue processing of this child's subtree.
array_push(&stack, ((EditEntry){
.tree = child,
.edit = child_edit,
}));
}
}
array_delete(&stack);
return self;
}
Subtree ts_subtree_last_external_token(Subtree tree) Subtree ts_subtree_last_external_token(Subtree tree)
{ {
if (!ts_subtree_has_external_tokens(tree)) if (!ts_subtree_has_external_tokens(tree))

70
parser/src/tree.c
View file

@ -10,12 +10,12 @@
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)
{ {
(void)(included_ranges);
(void)(included_range_count);
TSTree *result = mem_alloc(sizeof(TSTree)); TSTree *result = mem_alloc(sizeof(TSTree));
result->root = root; result->root = root;
result->language = ts_language_copy(language); result->included_ranges = NULL;
result->included_ranges = mem_alloc_array(included_range_count, sizeof(TSRange)); result->language = language;
mem_copy(result->included_ranges, included_ranges, included_range_count * sizeof(TSRange));
result->included_range_count = included_range_count;
return result; return result;
} }
@ -27,14 +27,9 @@ TSTree *ts_tree_copy(const TSTree *self)
void ts_tree_delete(TSTree *self) void ts_tree_delete(TSTree *self)
{ {
if (!self) if (self == NULL)
return; return;
ts_subtree_release(self->root);
/* SubtreePool pool = ts_subtree_pool_new(0); */
ts_subtree_release(/*&pool,*/ self->root);
/* ts_subtree_pool_delete(&pool); */
ts_language_delete(self->language);
mem_free(self->included_ranges);
mem_free(self); mem_free(self);
} }
@ -53,56 +48,3 @@ const TSLanguage *ts_tree_language(const TSTree *self)
{ {
return self->language; return self->language;
} }
void ts_tree_edit(TSTree *self, const TSInputEdit *edit)
{
for (t_u32 i = 0; i < self->included_range_count; i++)
{
TSRange *range = &self->included_ranges[i];
if (range->end_byte >= edit->old_end_byte)
{
if (range->end_byte != UINT32_MAX)
{
range->end_byte = edit->new_end_byte + (range->end_byte - edit->old_end_byte);
range->end_point = point_add(edit->new_end_point, point_sub(range->end_point, edit->old_end_point));
if (range->end_byte < edit->new_end_byte)
{
range->end_byte = UINT32_MAX;
range->end_point = POINT_MAX;
}
}
}
else if (range->end_byte > edit->start_byte)
{
range->end_byte = edit->start_byte;
range->end_point = edit->start_point;
}
if (range->start_byte >= edit->old_end_byte)
{
range->start_byte = edit->new_end_byte + (range->start_byte - edit->old_end_byte);
range->start_point = point_add(edit->new_end_point, point_sub(range->start_point, edit->old_end_point));
if (range->start_byte < edit->new_end_byte)
{
range->start_byte = UINT32_MAX;
range->start_point = POINT_MAX;
}
}
else if (range->start_byte > edit->start_byte)
{
range->start_byte = edit->start_byte;
range->start_point = edit->start_point;
}
}
// SubtreePool pool = ts_subtree_pool_new(0);
self->root = ts_subtree_edit(self->root, edit /*, &pool*/);
// ts_subtree_pool_delete(&pool);
}
TSRange *ts_tree_included_ranges(const TSTree *self, t_u32 *length)
{
*length = self->included_range_count;
TSRange *ranges = mem_alloc_array(self->included_range_count, sizeof(TSRange));
mem_copy(ranges, self->included_ranges, self->included_range_count * sizeof(TSRange));
return ranges;
}

2
symdif.py
View file

@ -48,7 +48,7 @@ for line in dump_binary.stdout.split('\n'):
if (len (words) >= 8 and words[3] == 'FUNC'): if (len (words) >= 8 and words[3] == 'FUNC'):
symbols_binary.add(words[7]) symbols_binary.add(words[7])
diff = list(symbols_archive - symbols_binary) diff = list(symbols_binary - symbols_archive)
diff.sort() diff.sort()
for sym in diff: for sym in diff:
print(f"{sym}") print(f"{sym}")