traxys/tree-sitter
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Rename ts_subtree_make_* -> ts_subtree_new_*

Browse source
This commit is contained in:
Max Brunsfeld 2018-05-11 13:02:12 -07:00
parent bf1bb1604f
commit 20c183b7cd
5 changed files with 66 additions and 70 deletions
Download patch file Download diff file Expand all files Collapse all files

26
src/runtime/parser.c
View file

@ -358,7 +358,7 @@ static Subtree *ts_parser__lex(TSParser *self, StackVersion version, TSStateId p
if (skipped_error) {
Length padding = length_sub(error_start_position, start_position);
Length size = length_sub(error_end_position, error_start_position);
result = ts_subtree_make_error(&self->tree_pool, size, padding, first_error_character, self->language);
result = ts_subtree_new_error(&self->tree_pool, size, padding, first_error_character, self->language);
} else {
if (self->lexer.token_end_position.bytes < self->lexer.token_start_position.bytes) {
self->lexer.token_start_position = self->lexer.token_end_position;
@ -383,7 +383,7 @@ static Subtree *ts_parser__lex(TSParser *self, StackVersion version, TSStateId p
}
}
result = ts_subtree_make_leaf(&self->tree_pool, symbol, padding, size, self->language);
result = ts_subtree_new_leaf(&self->tree_pool, symbol, padding, size, self->language);
if (found_external_token) {
result->has_external_tokens = true;
@ -577,7 +577,7 @@ static void ts_parser__shift(TSParser *self, StackVersion version, TSStateId sta
Subtree *lookahead, bool extra) {
if (extra != lookahead->extra) {
if (ts_stack_version_count(self->stack) > 1) {
lookahead = ts_subtree_make_copy(&self->tree_pool, lookahead);
lookahead = ts_subtree_new_copy(&self->tree_pool, lookahead);
} else {
ts_subtree_retain(lookahead);
}
@ -625,7 +625,7 @@ static StackSliceArray ts_parser__reduce(TSParser *self, StackVersion version, T
children.size--;
}
Subtree *parent = ts_subtree_make_node(&self->tree_pool,
Subtree *parent = ts_subtree_new_node(&self->tree_pool,
symbol, &children, alias_sequence_id, self->language
);
@ -735,7 +735,7 @@ static void ts_parser__accept(TSParser *self, StackVersion version, Subtree *loo
ts_subtree_retain(child->children.contents[k]);
}
array_splice(&trees, j, 1, &child->children);
root = ts_subtree_make_node(
root = ts_subtree_new_node(
&self->tree_pool, child->symbol, &trees,
child->alias_sequence_id, self->language
);
@ -875,7 +875,7 @@ static void ts_parser__handle_error(TSParser *self, StackVersion version,
lookahead_symbol
)) {
StackVersion version_with_missing_tree = ts_stack_copy_version(self->stack, v);
Subtree *missing_tree = ts_subtree_make_missing_leaf(&self->tree_pool, missing_symbol, self->language);
Subtree *missing_tree = ts_subtree_new_missing_leaf(&self->tree_pool, missing_symbol, self->language);
ts_stack_push(
self->stack, version_with_missing_tree,
missing_tree, false,
@ -920,15 +920,15 @@ static void ts_parser__halt_parse(TSParser *self) {
ts_stack_position(self->stack, 0)
);
Subtree *filler_node = ts_subtree_make_error(&self->tree_pool, remaining_length, length_zero(), 0, self->language);
Subtree *filler_node = ts_subtree_new_error(&self->tree_pool, remaining_length, length_zero(), 0, self->language);
filler_node->visible = false;
ts_stack_push(self->stack, 0, filler_node, false, 0);
SubtreeArray children = array_new();
Subtree *root_error = ts_subtree_make_error_node(&self->tree_pool, &children, self->language);
Subtree *root_error = ts_subtree_new_error_node(&self->tree_pool, &children, self->language);
ts_stack_push(self->stack, 0, root_error, false, 0);
Subtree *eof = ts_subtree_make_leaf(&self->tree_pool, ts_builtin_sym_end, length_zero(), length_zero(), self->language);
Subtree *eof = ts_subtree_new_leaf(&self->tree_pool, ts_builtin_sym_end, length_zero(), length_zero(), self->language);
ts_parser__accept(self, 0, eof);
ts_subtree_release(&self->tree_pool, eof);
}
@ -967,7 +967,7 @@ static bool ts_parser__recover_to_state(TSParser *self, StackVersion version, un
SubtreeArray trailing_extras = ts_subtree_array_remove_trailing_extras(&slice.subtrees);
if (slice.subtrees.size > 0) {
Subtree *error = ts_subtree_make_error_node(&self->tree_pool, &slice.subtrees, self->language);
Subtree *error = ts_subtree_new_error_node(&self->tree_pool, &slice.subtrees, self->language);
error->extra = true;
ts_stack_push(self->stack, slice.version, error, false, goal_state);
} else {
@ -1048,7 +1048,7 @@ static void ts_parser__recover(TSParser *self, StackVersion version, Subtree *lo
if (lookahead->symbol == ts_builtin_sym_end) {
LOG("recover_eof");
SubtreeArray children = array_new();
Subtree *parent = ts_subtree_make_error_node(&self->tree_pool, &children, self->language);
Subtree *parent = ts_subtree_new_error_node(&self->tree_pool, &children, self->language);
ts_stack_push(self->stack, version, parent, false, 1);
ts_parser__accept(self, version, lookahead);
return;
@ -1075,7 +1075,7 @@ static void ts_parser__recover(TSParser *self, StackVersion version, Subtree *lo
SubtreeArray children = array_new();
array_reserve(&children, 1);
array_push(&children, lookahead);
Subtree *error_repeat = ts_subtree_make_node(
Subtree *error_repeat = ts_subtree_new_node(
&self->tree_pool,
ts_builtin_sym_error_repeat,
&children,
@ -1089,7 +1089,7 @@ static void ts_parser__recover(TSParser *self, StackVersion version, Subtree *lo
assert(pop.contents[0].subtrees.size == 1);
ts_stack_renumber_version(self->stack, pop.contents[0].version, version);
array_push(&pop.contents[0].subtrees, error_repeat);
error_repeat = ts_subtree_make_node(
error_repeat = ts_subtree_new_node(
&self->tree_pool,
ts_builtin_sym_error_repeat,
&pop.contents[0].subtrees,

28
src/runtime/subtree.c
View file

@ -141,7 +141,7 @@ void ts_subtree_pool_free(SubtreePool *self, Subtree *tree) {
// Subtree
Subtree *ts_subtree_make_leaf(SubtreePool *pool, TSSymbol symbol, Length padding, Length size,
Subtree *ts_subtree_new_leaf(SubtreePool *pool, TSSymbol symbol, Length padding, Length size,
const TSLanguage *language) {
TSSymbolMetadata metadata = ts_language_symbol_metadata(language, symbol);
Subtree *result = ts_subtree_pool_allocate(pool);
@ -166,16 +166,16 @@ Subtree *ts_subtree_make_leaf(SubtreePool *pool, TSSymbol symbol, Length padding
return result;
}
Subtree *ts_subtree_make_error(SubtreePool *pool, Length size, Length padding,
Subtree *ts_subtree_new_error(SubtreePool *pool, Length size, Length padding,
int32_t lookahead_char, const TSLanguage *language) {
Subtree *result = ts_subtree_make_leaf(pool, ts_builtin_sym_error, padding, size, language);
Subtree *result = ts_subtree_new_leaf(pool, ts_builtin_sym_error, padding, size, language);
result->fragile_left = true;
result->fragile_right = true;
result->lookahead_char = lookahead_char;
return result;
}
Subtree *ts_subtree_make_copy(SubtreePool *pool, Subtree *self) {
Subtree *ts_subtree_new_copy(SubtreePool *pool, Subtree *self) {
Subtree *result = ts_subtree_pool_allocate(pool);
*result = *self;
if (result->children.size > 0) {
@ -185,11 +185,11 @@ Subtree *ts_subtree_make_copy(SubtreePool *pool, Subtree *self) {
return result;
}
static Subtree *ts_subtree_make_mut(SubtreePool *pool, Subtree *self) {
static Subtree *ts_subtree_new_mut(SubtreePool *pool, Subtree *self) {
if (self->ref_count == 1) {
return self;
} else {
Subtree *result = ts_subtree_make_copy(pool, self);
Subtree *result = ts_subtree_new_copy(pool, self);
ts_subtree_release(pool, self);
return result;
}
@ -360,9 +360,9 @@ void ts_subtree_set_children(Subtree *self, SubtreeArray *children, const TSLang
}
}
Subtree *ts_subtree_make_node(SubtreePool *pool, TSSymbol symbol, SubtreeArray *children,
Subtree *ts_subtree_new_node(SubtreePool *pool, TSSymbol symbol, SubtreeArray *children,
unsigned alias_sequence_id, const TSLanguage *language) {
Subtree *result = ts_subtree_make_leaf(pool, symbol, length_zero(), length_zero(), language);
Subtree *result = ts_subtree_new_leaf(pool, symbol, length_zero(), length_zero(), language);
result->alias_sequence_id = alias_sequence_id;
if (symbol == ts_builtin_sym_error || symbol == ts_builtin_sym_error_repeat) {
result->fragile_left = true;
@ -372,14 +372,14 @@ Subtree *ts_subtree_make_node(SubtreePool *pool, TSSymbol symbol, SubtreeArray *
return result;
}
Subtree *ts_subtree_make_error_node(SubtreePool *pool, SubtreeArray *children,
Subtree *ts_subtree_new_error_node(SubtreePool *pool, SubtreeArray *children,
const TSLanguage *language) {
return ts_subtree_make_node(pool, ts_builtin_sym_error, children, 0, language);
return ts_subtree_new_node(pool, ts_builtin_sym_error, children, 0, language);
}
Subtree *ts_subtree_make_missing_leaf(SubtreePool *pool, TSSymbol symbol,
Subtree *ts_subtree_new_missing_leaf(SubtreePool *pool, TSSymbol symbol,
const TSLanguage *language) {
Subtree *result = ts_subtree_make_leaf(pool, symbol, length_zero(), length_zero(), language);
Subtree *result = ts_subtree_new_leaf(pool, symbol, length_zero(), length_zero(), language);
result->is_missing = true;
result->error_cost = ERROR_COST_PER_MISSING_TREE + ERROR_COST_PER_RECOVERY;
return result;
@ -464,7 +464,7 @@ Subtree *ts_subtree_invalidate_lookahead(Subtree *self, uint32_t edit_byte_offse
SubtreePool *pool) {
if (edit_byte_offset >= self->bytes_scanned) return self;
Subtree *result = ts_subtree_make_mut(pool, self);
Subtree *result = ts_subtree_new_mut(pool, self);
result->has_changes = true;
if (result->children.size > 0) {
@ -484,7 +484,7 @@ Subtree *ts_subtree__edit(Subtree *self, Edit edit, SubtreePool *pool) {
Length new_end = length_add(edit.start, edit.added);
Length old_end = length_add(edit.start, edit.removed);
Subtree *result = ts_subtree_make_mut(pool, self);
Subtree *result = ts_subtree_new_mut(pool, self);
result->has_changes = true;
if (old_end.bytes <= result->padding.bytes) {

16
src/runtime/subtree.h
View file

@ -88,12 +88,12 @@ void ts_subtree_pool_delete(SubtreePool *);
Subtree *ts_subtree_pool_allocate(SubtreePool *);
void ts_subtree_pool_free(SubtreePool *, Subtree *);
Subtree *ts_subtree_make_leaf(SubtreePool *, TSSymbol, Length, Length, const TSLanguage *);
Subtree *ts_subtree_make_node(SubtreePool *, TSSymbol, SubtreeArray *, unsigned, const TSLanguage *);
Subtree *ts_subtree_make_copy(SubtreePool *, Subtree *child);
Subtree *ts_subtree_make_error_node(SubtreePool *, SubtreeArray *, const TSLanguage *);
Subtree *ts_subtree_make_error(SubtreePool *, Length, Length, int32_t, const TSLanguage *);
Subtree *ts_subtree_make_missing_leaf(SubtreePool *, TSSymbol, const TSLanguage *);
Subtree *ts_subtree_new_leaf(SubtreePool *, TSSymbol, Length, Length, const TSLanguage *);
Subtree *ts_subtree_new_node(SubtreePool *, TSSymbol, SubtreeArray *, unsigned, const TSLanguage *);
Subtree *ts_subtree_new_copy(SubtreePool *, Subtree *child);
Subtree *ts_subtree_new_error_node(SubtreePool *, SubtreeArray *, const TSLanguage *);
Subtree *ts_subtree_new_error(SubtreePool *, Length, Length, int32_t, const TSLanguage *);
Subtree *ts_subtree_new_missing_leaf(SubtreePool *, TSSymbol, const TSLanguage *);
void ts_subtree_retain(Subtree *tree);
void ts_subtree_release(SubtreePool *, Subtree *tree);
bool ts_subtree_eq(const Subtree *tree1, const Subtree *tree2);
@ -110,10 +110,6 @@ static inline uint32_t ts_subtree_total_bytes(const Subtree *self) {
return self->padding.bytes + self->size.bytes;
}
static inline uint32_t ts_subtree_total_rows(const Subtree *self) {
return self->padding.extent.row + self->size.extent.row;
}
static inline Length ts_subtree_total_size(const Subtree *self) {
return length_add(self->padding, self->size);
}