From 5f59de72a8d1271b5e6c83227fea9f4497ad70c9 Mon Sep 17 00:00:00 2001 From: Max Brunsfeld Date: Sat, 28 Jun 2014 18:45:22 -0700 Subject: [PATCH] Rename type ts_tree -> TSTree --- include/tree_sitter/parser.h | 6 +-- include/tree_sitter/parser/lexer.h | 4 +- include/tree_sitter/parser/lr_parser.h | 10 ++--- include/tree_sitter/parser/stack.h | 8 ++-- include/tree_sitter/runtime.h | 38 +++++++++--------- spec/runtime/helpers/tree_helpers.cc | 4 +- spec/runtime/helpers/tree_helpers.h | 2 +- spec/runtime/lr_parser_spec.cc | 6 +-- spec/runtime/node_position_spec.cc | 8 ++-- spec/runtime/stack_spec.cc | 30 +++++++------- spec/runtime/tree_spec.cc | 14 +++---- src/runtime/document.c | 6 +-- src/runtime/lr_parser.c | 22 +++++------ src/runtime/stack.c | 24 ++++++------ src/runtime/tree.c | 54 +++++++++++++------------- src/runtime/tree.h | 4 +- 16 files changed, 120 insertions(+), 120 deletions(-) diff --git a/include/tree_sitter/parser.h b/include/tree_sitter/parser.h index 126e00df..ff3f7b32 100644 --- a/include/tree_sitter/parser.h +++ b/include/tree_sitter/parser.h @@ -26,7 +26,7 @@ static ts_state_id ts_lex_states[STATE_COUNT] static const ts_parse_action ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] #define LEX_FN() \ -static ts_tree * ts_lex(ts_lexer *lexer, ts_state_id lex_state) +static TSTree * ts_lex(ts_lexer *lexer, ts_state_id lex_state) #ifdef TS_DEBUG_LEX #include @@ -72,11 +72,11 @@ ts_lexer_start_token(lexer); SYMBOL_NAMES; -static const ts_tree * ts_parse(void *data, ts_input input, ts_input_edit *edit) { +static const TSTree * ts_parse(void *data, ts_input input, ts_input_edit *edit) { ts_lr_parser *parser = (ts_lr_parser *)data; ts_lr_parser_initialize(parser, input, edit); for (;;) { - const ts_tree *tree = ts_lr_parser_parse(parser, ts_symbol_names); + const TSTree *tree = ts_lr_parser_parse(parser, ts_symbol_names); if (tree) return tree; } } diff --git a/include/tree_sitter/parser/lexer.h b/include/tree_sitter/parser/lexer.h index 3a99fef8..3cdea6d1 100644 --- a/include/tree_sitter/parser/lexer.h +++ b/include/tree_sitter/parser/lexer.h @@ -59,7 +59,7 @@ static inline void ts_lexer_start_token(ts_lexer *lexer) { lexer->token_start_position = ts_lexer_position(lexer); } -static inline ts_tree * ts_lexer_build_node(ts_lexer *lexer, ts_symbol symbol) { +static inline TSTree * ts_lexer_build_node(ts_lexer *lexer, ts_symbol symbol) { size_t current_position = ts_lexer_position(lexer); size_t size = current_position - lexer->token_start_position; size_t offset = lexer->token_start_position - lexer->token_end_position; @@ -67,4 +67,4 @@ static inline ts_tree * ts_lexer_build_node(ts_lexer *lexer, ts_symbol symbol) { return ts_tree_make_leaf(symbol, size, offset); } -#endif \ No newline at end of file +#endif diff --git a/include/tree_sitter/parser/lr_parser.h b/include/tree_sitter/parser/lr_parser.h index a9c46490..aac316c3 100644 --- a/include/tree_sitter/parser/lr_parser.h +++ b/include/tree_sitter/parser/lr_parser.h @@ -42,25 +42,25 @@ typedef struct { typedef struct { ts_lexer lexer; ts_stack stack; - ts_tree *lookahead; - ts_tree *next_lookahead; + TSTree *lookahead; + TSTree *next_lookahead; struct { size_t symbol_count; const int *hidden_symbol_flags; const ts_parse_action *parse_table; const ts_state_id *lex_states; - ts_tree * (* lex_fn)(ts_lexer *, ts_state_id); + TSTree * (* lex_fn)(ts_lexer *, ts_state_id); } config; } ts_lr_parser; ts_lr_parser * ts_lr_parser_make(size_t symbol_count, const ts_parse_action *parse_table, const ts_state_id *lex_states, - ts_tree * (* lex_fn)(ts_lexer *, ts_state_id), + TSTree * (* lex_fn)(ts_lexer *, ts_state_id), const int *hidden_symbol_flags); void ts_lr_parser_free(void *data); void ts_lr_parser_initialize(ts_lr_parser *parser, ts_input input, ts_input_edit *edit); -ts_tree * ts_lr_parser_parse(ts_lr_parser *parser, const char **symbol_names); +TSTree * ts_lr_parser_parse(ts_lr_parser *parser, const char **symbol_names); #ifdef __cplusplus } diff --git a/include/tree_sitter/parser/stack.h b/include/tree_sitter/parser/stack.h index 4199a601..cbc13452 100644 --- a/include/tree_sitter/parser/stack.h +++ b/include/tree_sitter/parser/stack.h @@ -12,7 +12,7 @@ typedef unsigned short ts_state_id; typedef struct { size_t size; struct { - ts_tree *node; + TSTree *node; ts_state_id state; int is_extra; } *entries; @@ -20,11 +20,11 @@ typedef struct { ts_stack ts_stack_make(); void ts_stack_delete(ts_stack *); -ts_tree * ts_stack_reduce(ts_stack *stack, ts_symbol symbol, size_t immediate_child_count, const int *hidden_symbol_flags, int gather_extras); +TSTree * ts_stack_reduce(ts_stack *stack, ts_symbol symbol, size_t immediate_child_count, const int *hidden_symbol_flags, int gather_extras); void ts_stack_shrink(ts_stack *stack, size_t new_size); -void ts_stack_push(ts_stack *stack, ts_state_id state, ts_tree *node); +void ts_stack_push(ts_stack *stack, ts_state_id state, TSTree *node); ts_state_id ts_stack_top_state(const ts_stack *stack); -ts_tree * ts_stack_top_node(const ts_stack *stack); +TSTree * ts_stack_top_node(const ts_stack *stack); size_t ts_stack_right_position(const ts_stack *stack); #ifdef __cplusplus diff --git a/include/tree_sitter/runtime.h b/include/tree_sitter/runtime.h index f0b72e26..dd077407 100644 --- a/include/tree_sitter/runtime.h +++ b/include/tree_sitter/runtime.h @@ -12,21 +12,21 @@ typedef unsigned short ts_symbol; #define ts_builtin_sym_end 1 #define ts_start_sym 2 -typedef struct ts_tree ts_tree; -ts_tree * ts_tree_make_leaf(ts_symbol symbol, size_t size, size_t offset); -ts_tree * ts_tree_make_node(ts_symbol symbol, size_t child_count, size_t immediate_child_count, ts_tree **children); -ts_tree * ts_tree_make_error(char lookahead_char, size_t expected_input_count, const ts_symbol *expected_inputs, size_t size, size_t offset); -void ts_tree_retain(ts_tree *tree); -void ts_tree_release(ts_tree *tree); -int ts_tree_equals(const ts_tree *tree1, const ts_tree *tree2); -char * ts_tree_string(const ts_tree *tree, const char **names); -char * ts_tree_error_string(const ts_tree *tree, const char **names); -ts_tree ** ts_tree_children(const ts_tree *tree, size_t *count); -ts_tree ** ts_tree_immediate_children(const ts_tree *tree, size_t *count); -size_t ts_tree_size(const ts_tree *tree); -size_t ts_tree_offset(const ts_tree *tree); -size_t ts_tree_total_size(const ts_tree *tree); -ts_symbol ts_tree_symbol(const ts_tree *tree); +typedef struct TSTree TSTree; +TSTree * ts_tree_make_leaf(ts_symbol symbol, size_t size, size_t offset); +TSTree * ts_tree_make_node(ts_symbol symbol, size_t child_count, size_t immediate_child_count, TSTree **children); +TSTree * ts_tree_make_error(char lookahead_char, size_t expected_input_count, const ts_symbol *expected_inputs, size_t size, size_t offset); +void ts_tree_retain(TSTree *tree); +void ts_tree_release(TSTree *tree); +int ts_tree_equals(const TSTree *tree1, const TSTree *tree2); +char * ts_tree_string(const TSTree *tree, const char **names); +char * ts_tree_error_string(const TSTree *tree, const char **names); +TSTree ** ts_tree_children(const TSTree *tree, size_t *count); +TSTree ** ts_tree_immediate_children(const TSTree *tree, size_t *count); +size_t ts_tree_size(const TSTree *tree); +size_t ts_tree_offset(const TSTree *tree); +size_t ts_tree_total_size(const TSTree *tree); +ts_symbol ts_tree_symbol(const TSTree *tree); typedef struct { void *data; @@ -42,13 +42,13 @@ typedef struct { } ts_input_edit; typedef struct { - const ts_tree * (* parse_fn)(void *data, ts_input input, ts_input_edit *edit); + const TSTree * (* parse_fn)(void *data, ts_input input, ts_input_edit *edit); void (* free_fn)(void *data); const char **symbol_names; void *data; } ts_parser; -const ts_tree * ts_parser_parse(ts_parser *, ts_input, ts_input_edit *edit); +const TSTree * ts_parser_parse(ts_parser *, ts_input, ts_input_edit *edit); void ts_parser_free(ts_parser *); typedef struct TSDocument TSDocument; @@ -58,9 +58,9 @@ void ts_document_set_parser(TSDocument *doc, ts_parser parser); void ts_document_set_input(TSDocument *doc, ts_input input); void ts_document_set_input_string(TSDocument *doc, const char *text); void ts_document_edit(TSDocument *doc, ts_input_edit edit); -const ts_tree * ts_document_tree(const TSDocument *doc); +const TSTree * ts_document_tree(const TSDocument *doc); const char * ts_document_string(const TSDocument *doc); -const char * ts_document_symbol_name(const TSDocument *document, const ts_tree *tree); +const char * ts_document_symbol_name(const TSDocument *document, const TSTree *tree); #ifdef __cplusplus } diff --git a/spec/runtime/helpers/tree_helpers.cc b/spec/runtime/helpers/tree_helpers.cc index 42506e50..5902f9a7 100644 --- a/spec/runtime/helpers/tree_helpers.cc +++ b/spec/runtime/helpers/tree_helpers.cc @@ -1,7 +1,7 @@ #include "runtime/helpers/tree_helpers.h" -ts_tree ** tree_array(std::vector trees) { - ts_tree ** result = (ts_tree **)calloc(trees.size(), sizeof(ts_tree *)); +TSTree ** tree_array(std::vector trees) { + TSTree ** result = (TSTree **)calloc(trees.size(), sizeof(TSTree *)); for (size_t i = 0; i < trees.size(); i++) result[i] = trees[i]; return result; diff --git a/spec/runtime/helpers/tree_helpers.h b/spec/runtime/helpers/tree_helpers.h index cc0bfa2f..0a9c036a 100644 --- a/spec/runtime/helpers/tree_helpers.h +++ b/spec/runtime/helpers/tree_helpers.h @@ -5,6 +5,6 @@ #include -ts_tree ** tree_array(std::vector trees); +TSTree ** tree_array(std::vector trees); #endif // HELPERS_TREE_HELPERS_H_ \ No newline at end of file diff --git a/spec/runtime/lr_parser_spec.cc b/spec/runtime/lr_parser_spec.cc index 335577fa..08adab49 100644 --- a/spec/runtime/lr_parser_spec.cc +++ b/spec/runtime/lr_parser_spec.cc @@ -3,11 +3,11 @@ #include "runtime/helpers/dummy_parser.h" #include "tree_sitter/parser/lr_parser.h" -ts_tree *lex_fn_node_to_return; +TSTree *lex_fn_node_to_return; ts_state_id lex_fn_state_received; ts_lexer *lex_fn_lexer_received; -ts_tree * fake_lex(ts_lexer *lexer, ts_state_id state_id) { +TSTree * fake_lex(ts_lexer *lexer, ts_state_id state_id) { lex_fn_lexer_received = lexer; lex_fn_state_received = state_id; return lex_fn_node_to_return; @@ -55,7 +55,7 @@ describe("LR Parsers", [&]() { it("continues parsing (returns NULL)", [&]() { auto result = ts_lr_parser_parse(parser, nullptr); - AssertThat(result, Equals((ts_tree *)nullptr)); + AssertThat(result, Equals((TSTree *)nullptr)); }); }); diff --git a/spec/runtime/node_position_spec.cc b/spec/runtime/node_position_spec.cc index f1ba30f1..3cf6d947 100644 --- a/spec/runtime/node_position_spec.cc +++ b/spec/runtime/node_position_spec.cc @@ -19,10 +19,10 @@ describe("tracking the positions of AST nodes", []() { it("records the widths and offsets of nodes", [&]() { ts_document_set_input_string(doc, " [12, 5]"); - const ts_tree *tree = ts_document_tree(doc); - const ts_tree *array = ts_tree_children(tree, NULL)[0]; - const ts_tree *number1 = ts_tree_children(array, NULL)[0]; - const ts_tree *number2 = ts_tree_children(array, NULL)[1]; + const TSTree *tree = ts_document_tree(doc); + const TSTree *array = ts_tree_children(tree, NULL)[0]; + const TSTree *number1 = ts_tree_children(array, NULL)[0]; + const TSTree *number2 = ts_tree_children(array, NULL)[1]; AssertThat(ts_document_symbol_name(doc, array), Equals("array")); AssertThat(ts_document_symbol_name(doc, number1), Equals("number")); diff --git a/spec/runtime/stack_spec.cc b/spec/runtime/stack_spec.cc index b36cee95..73d155a5 100644 --- a/spec/runtime/stack_spec.cc +++ b/spec/runtime/stack_spec.cc @@ -20,11 +20,11 @@ describe("stacks", [&]() { it("starts out empty", [&]() { AssertThat(stack.size, Equals(0)); AssertThat(ts_stack_top_state(&stack), Equals(0)); - AssertThat(ts_stack_top_node(&stack), Equals((ts_tree *)nullptr)); + AssertThat(ts_stack_top_node(&stack), Equals((TSTree *)nullptr)); }); describe("pushing a symbol", [&]() { - ts_tree *node1; + TSTree *node1; before_each([&]() { node1 = ts_tree_make_leaf(sym1, 5, 1); @@ -43,7 +43,7 @@ describe("stacks", [&]() { }); describe("reducing a symbol", [&]() { - ts_tree **nodes; + TSTree **nodes; before_each([&]() { nodes = tree_array({ @@ -70,20 +70,20 @@ describe("stacks", [&]() { }); it("returns a node with the given symbol", [&]() { - ts_tree *node = ts_stack_reduce(&stack, sym2, 3, hidden_symbols, 0); + TSTree *node = ts_stack_reduce(&stack, sym2, 3, hidden_symbols, 0); AssertThat(ts_tree_symbol(node), Equals(sym2)); }); it("makes all of the removed nodes immediate children of the new node", [&]() { - ts_tree *expected_children[3] = { + TSTree *expected_children[3] = { stack.entries[1].node, stack.entries[2].node, stack.entries[3].node, }; - ts_tree *node = ts_stack_reduce(&stack, sym2, 3, hidden_symbols, 0); + TSTree *node = ts_stack_reduce(&stack, sym2, 3, hidden_symbols, 0); size_t immediate_child_count; - ts_tree **immediate_children = ts_tree_immediate_children(node, &immediate_child_count); + TSTree **immediate_children = ts_tree_immediate_children(node, &immediate_child_count); AssertThat(immediate_child_count, Equals(3)); for (size_t i = 0; i < 3; i++) @@ -91,14 +91,14 @@ describe("stacks", [&]() { }); it("removes any hidden nodes from its regular list of children", [&]() { - ts_tree *expected_children[2] = { + TSTree *expected_children[2] = { stack.entries[1].node, stack.entries[3].node, }; - ts_tree *node = ts_stack_reduce(&stack, sym2, 3, hidden_symbols, 0); + TSTree *node = ts_stack_reduce(&stack, sym2, 3, hidden_symbols, 0); size_t child_count; - ts_tree **children = ts_tree_children(node, &child_count); + TSTree **children = ts_tree_children(node, &child_count); AssertThat(child_count, Equals(2)); for (size_t i = 0; i < 2; i++) @@ -106,8 +106,8 @@ describe("stacks", [&]() { }); describe("when there are hidden nodes with children of their own", [&]() { - ts_tree **grandchildren; - ts_tree *hidden_node; + TSTree **grandchildren; + TSTree *hidden_node; before_each([&]() { grandchildren = tree_array({ @@ -127,9 +127,9 @@ describe("stacks", [&]() { }); it("makes those child nodes children of the new node", [&]() { - ts_tree *node = ts_stack_reduce(&stack, sym2, 4, hidden_symbols, 0); + TSTree *node = ts_stack_reduce(&stack, sym2, 4, hidden_symbols, 0); - ts_tree *expected_children[4] = { + TSTree *expected_children[4] = { stack.entries[1].node, stack.entries[3].node, grandchildren[0], @@ -137,7 +137,7 @@ describe("stacks", [&]() { }; size_t child_count; - ts_tree **children = ts_tree_children(node, &child_count); + TSTree **children = ts_tree_children(node, &child_count); AssertThat(child_count, Equals(4)); for (size_t i = 0; i < 4; i++) diff --git a/spec/runtime/tree_spec.cc b/spec/runtime/tree_spec.cc index b7bcb3ee..857a8c59 100644 --- a/spec/runtime/tree_spec.cc +++ b/spec/runtime/tree_spec.cc @@ -11,7 +11,7 @@ enum { static const char *names[] = { "error", "end", "cat", "dog", "pig" }; describe("trees", []() { - ts_tree *tree1, *tree2, *parent1; + TSTree *tree1, *tree2, *parent1; before_each([&]() { tree1 = ts_tree_make_leaf(cat, 5, 2); @@ -40,12 +40,12 @@ describe("trees", []() { describe("equality", [&]() { it("returns true for identical trees", [&]() { - ts_tree *tree1_copy = ts_tree_make_leaf(cat, 5, 2); + TSTree *tree1_copy = ts_tree_make_leaf(cat, 5, 2); AssertThat(ts_tree_equals(tree1, tree1_copy), Equals(1)); - ts_tree *tree2_copy = ts_tree_make_leaf(cat, 3, 1); + TSTree *tree2_copy = ts_tree_make_leaf(cat, 3, 1); AssertThat(ts_tree_equals(tree2, tree2_copy), Equals(1)); - ts_tree *parent2 = ts_tree_make_node(dog, 2, 2, tree_array({ + TSTree *parent2 = ts_tree_make_node(dog, 2, 2, tree_array({ tree1_copy, tree2_copy, tree1_copy, tree2_copy, })); @@ -57,14 +57,14 @@ describe("trees", []() { }); it("returns false for trees with different symbols", [&]() { - ts_tree *different_tree = ts_tree_make_leaf(pig, 0, 0); + TSTree *different_tree = ts_tree_make_leaf(pig, 0, 0); AssertThat(ts_tree_equals(tree1, different_tree), Equals(0)); ts_tree_release(different_tree); }); it("returns false for trees with different children", [&]() { - ts_tree *different_tree = ts_tree_make_leaf(pig, 0, 0); - ts_tree *different_parent = ts_tree_make_node(dog, 2, 2, tree_array({ + TSTree *different_tree = ts_tree_make_leaf(pig, 0, 0); + TSTree *different_parent = ts_tree_make_node(dog, 2, 2, tree_array({ different_tree, different_tree, tree2, tree2, })); diff --git a/src/runtime/document.c b/src/runtime/document.c index 22648c10..c391dd99 100644 --- a/src/runtime/document.c +++ b/src/runtime/document.c @@ -3,7 +3,7 @@ struct TSDocument { ts_parser parser; - const ts_tree *tree; + const TSTree *tree; ts_input input; size_t error_count; }; @@ -24,7 +24,7 @@ void ts_document_set_parser(TSDocument *document, ts_parser parser) { document->parser = parser; } -const ts_tree * ts_document_tree(const TSDocument *document) { +const TSTree * ts_document_tree(const TSDocument *document) { return document->tree; } @@ -41,7 +41,7 @@ void ts_document_edit(TSDocument *document, ts_input_edit edit) { document->tree = document->parser.parse_fn(document->parser.data, document->input, &edit); } -const char * ts_document_symbol_name(const TSDocument *document, const ts_tree *tree) { +const char * ts_document_symbol_name(const TSDocument *document, const TSTree *tree) { return document->parser.symbol_names[ts_tree_symbol(tree)]; } diff --git a/src/runtime/lr_parser.c b/src/runtime/lr_parser.c index 45a3d653..6f8a3d8f 100644 --- a/src/runtime/lr_parser.c +++ b/src/runtime/lr_parser.c @@ -32,19 +32,19 @@ static size_t breakdown_stack(ts_lr_parser *parser, ts_input_edit *edit) { size_t position = 0; for (;;) { - ts_tree *node = ts_stack_top_node(stack); + TSTree *node = ts_stack_top_node(stack); if (!node) break; position = ts_stack_right_position(stack); size_t child_count; - ts_tree **children = ts_tree_immediate_children(node, &child_count); + TSTree **children = ts_tree_immediate_children(node, &child_count); if (position <= edit->position && !children) break; stack->size--; position -= ts_tree_total_size(node); for (size_t i = 0; i < child_count && position < edit->position; i++) { - ts_tree *child = children[i]; + TSTree *child = children[i]; ts_state_id state = ts_stack_top_state(stack); ts_state_id next_state = actions_for_state(parser, state)[ts_tree_symbol(child)].data.to_state; ts_stack_push(stack, next_state, child); @@ -77,7 +77,7 @@ ts_symbol * expected_symbols(ts_lr_parser *parser, size_t *count) { int handle_error(ts_lr_parser *parser) { size_t count = 0; const ts_symbol *inputs = expected_symbols(parser, &count); - ts_tree *error = ts_tree_make_error(ts_lexer_lookahead_char(&parser->lexer), + TSTree *error = ts_tree_make_error(ts_lexer_lookahead_char(&parser->lexer), count, inputs, 0, @@ -117,20 +117,20 @@ int handle_error(ts_lr_parser *parser) { } } -ts_tree * get_tree_root(ts_lr_parser *parser) { +TSTree * get_tree_root(ts_lr_parser *parser) { ts_stack *stack = &parser->stack; - ts_tree *top_node = ts_stack_top_node(stack); + TSTree *top_node = ts_stack_top_node(stack); if (stack->size <= 1) return top_node; if (ts_tree_symbol(top_node) == ts_builtin_sym_error) return top_node; size_t immediate_child_count; - ts_tree **immedate_children = ts_tree_immediate_children(top_node, &immediate_child_count); + TSTree **immedate_children = ts_tree_immediate_children(top_node, &immediate_child_count); stack->size--; for (size_t i = 0; i < immediate_child_count; i++) { - ts_tree *child = immedate_children[i]; + TSTree *child = immedate_children[i]; child->is_extra = 0; ts_tree_retain(child); ts_state_id state = ts_stack_top_state(stack); @@ -138,7 +138,7 @@ ts_tree * get_tree_root(ts_lr_parser *parser) { ts_stack_push(stack, next_state, child); } - ts_tree *new_node = ts_stack_reduce(stack, + TSTree *new_node = ts_stack_reduce(stack, top_node->symbol, stack->size, parser->config.hidden_symbol_flags, @@ -161,7 +161,7 @@ ts_parse_action get_next_action(ts_lr_parser *parser) { ts_lr_parser * ts_lr_parser_make(size_t symbol_count, const ts_parse_action *parse_table, const ts_state_id *lex_states, - ts_tree * (* lex_fn)(ts_lexer *, ts_state_id), + TSTree * (* lex_fn)(ts_lexer *, ts_state_id), const int *hidden_symbol_flags) { ts_lr_parser *result = malloc(sizeof(ts_lr_parser)); *result = (ts_lr_parser) { @@ -208,7 +208,7 @@ void ts_lr_parser_initialize(ts_lr_parser *parser, ts_input input, ts_input_edit #define DEBUG_PARSE(...) #endif -ts_tree * ts_lr_parser_parse(ts_lr_parser *parser, const char **symbol_names) { +TSTree * ts_lr_parser_parse(ts_lr_parser *parser, const char **symbol_names) { ts_parse_action action = get_next_action(parser); DEBUG_PARSE("LOOKAHEAD %s", symbol_names[ts_tree_symbol(parser->lookahead)]); switch (action.type) { diff --git a/src/runtime/stack.c b/src/runtime/stack.c index 18eb0153..77995ec6 100644 --- a/src/runtime/stack.c +++ b/src/runtime/stack.c @@ -24,12 +24,12 @@ ts_state_id ts_stack_top_state(const ts_stack *stack) { return stack->entries[stack->size - 1].state; } -ts_tree * ts_stack_top_node(const ts_stack *stack) { +TSTree * ts_stack_top_node(const ts_stack *stack) { if (stack->size == 0) return NULL; return stack->entries[stack->size - 1].node; } -void ts_stack_push(ts_stack *stack, ts_state_id state, ts_tree *node) { +void ts_stack_push(ts_stack *stack, ts_state_id state, TSTree *node) { stack->entries[stack->size].state = state; stack->entries[stack->size].node = node; stack->size++; @@ -45,13 +45,13 @@ void ts_stack_shrink(ts_stack *stack, size_t new_size) { size_t ts_stack_right_position(const ts_stack *stack) { size_t result = 0; for (size_t i = 0; i < stack->size; i++) { - ts_tree *node = stack->entries[i].node; + TSTree *node = stack->entries[i].node; result += ts_tree_total_size(node); } return result; } -ts_tree * ts_stack_reduce(ts_stack *stack, +TSTree * ts_stack_reduce(ts_stack *stack, ts_symbol symbol, size_t immediate_child_count, const int *hidden_symbol_flags, @@ -66,9 +66,9 @@ ts_tree * ts_stack_reduce(ts_stack *stack, int child_count = 0; for (size_t i = 0; i < immediate_child_count; i++) { size_t stack_index = stack->size - 1 - i; - ts_tree *child = stack->entries[stack_index].node; + TSTree *child = stack->entries[stack_index].node; size_t grandchild_count; - ts_tree **grandchildren = ts_tree_children(child, &grandchild_count); + TSTree **grandchildren = ts_tree_children(child, &grandchild_count); ts_symbol child_symbol = ts_tree_symbol(child); collapse_flags[i] = ( @@ -89,25 +89,25 @@ ts_tree * ts_stack_reduce(ts_stack *stack, // We store the children and immediate children in the same array, // to reduce allocations. size_t child_index = child_count; - ts_tree **children = malloc((child_count + immediate_child_count) * sizeof(ts_tree *)); - ts_tree **immediate_children = children + child_count; + TSTree **children = malloc((child_count + immediate_child_count) * sizeof(TSTree *)); + TSTree **immediate_children = children + child_count; for (size_t i = 0; i < immediate_child_count; i++) { - ts_tree *child = stack->entries[stack->size - 1 - i].node; + TSTree *child = stack->entries[stack->size - 1 - i].node; immediate_children[immediate_child_count - 1 - i] = child; if (collapse_flags[i]) { size_t grandchild_count; - ts_tree **grandchildren = ts_tree_children(child, &grandchild_count); + TSTree **grandchildren = ts_tree_children(child, &grandchild_count); child_index -= grandchild_count; - memcpy(children + child_index, grandchildren, (grandchild_count * sizeof(ts_tree *))); + memcpy(children + child_index, grandchildren, (grandchild_count * sizeof(TSTree *))); } else { child_index--; children[child_index] = child; } } - ts_tree *lookahead = ts_tree_make_node(symbol, child_count, immediate_child_count, children); + TSTree *lookahead = ts_tree_make_node(symbol, child_count, immediate_child_count, children); ts_stack_shrink(stack, stack->size - immediate_child_count); return lookahead; } diff --git a/src/runtime/tree.c b/src/runtime/tree.c index a2a71f85..f37436b8 100644 --- a/src/runtime/tree.c +++ b/src/runtime/tree.c @@ -3,9 +3,9 @@ #include #include "runtime/tree.h" -static ts_tree * ts_tree_make(ts_symbol symbol, size_t size, size_t offset) { - ts_tree *result = malloc(sizeof(ts_tree)); - *result = (ts_tree) { +static TSTree * ts_tree_make(ts_symbol symbol, size_t size, size_t offset) { + TSTree *result = malloc(sizeof(TSTree)); + *result = (TSTree) { .ref_count = 1, .symbol = symbol, .size = size, @@ -14,19 +14,19 @@ static ts_tree * ts_tree_make(ts_symbol symbol, size_t size, size_t offset) { return result; } -ts_tree * ts_tree_make_leaf(ts_symbol symbol, size_t size, size_t offset) { - ts_tree *result = ts_tree_make(symbol, size, offset); +TSTree * ts_tree_make_leaf(ts_symbol symbol, size_t size, size_t offset) { + TSTree *result = ts_tree_make(symbol, size, offset); result->data.children.count = 0; result->data.children.immediate_count = 0; result->data.children.contents = NULL; return result; } -ts_tree * ts_tree_make_node(ts_symbol symbol, size_t child_count, size_t immediate_child_count, ts_tree **children) { - ts_tree **immediate_children = children + child_count; +TSTree * ts_tree_make_node(ts_symbol symbol, size_t child_count, size_t immediate_child_count, TSTree **children) { + TSTree **immediate_children = children + child_count; size_t size = 0, offset = 0; for (size_t i = 0; i < immediate_child_count; i++) { - ts_tree *child = immediate_children[i]; + TSTree *child = immediate_children[i]; ts_tree_retain(child); if (i == 0) { offset = ts_tree_offset(child); @@ -35,42 +35,42 @@ ts_tree * ts_tree_make_node(ts_symbol symbol, size_t child_count, size_t immedia size += ts_tree_offset(child) + ts_tree_size(child); } } - ts_tree *result = ts_tree_make(symbol, size, offset); + TSTree *result = ts_tree_make(symbol, size, offset); result->data.children.count = child_count; result->data.children.immediate_count = immediate_child_count; result->data.children.contents = children; return result; } -ts_tree * ts_tree_make_error(char lookahead_char, size_t expected_input_count, const ts_symbol *expected_inputs, size_t size, size_t offset) { - ts_tree *result = ts_tree_make(ts_builtin_sym_error, size, offset); +TSTree * ts_tree_make_error(char lookahead_char, size_t expected_input_count, const ts_symbol *expected_inputs, size_t size, size_t offset) { + TSTree *result = ts_tree_make(ts_builtin_sym_error, size, offset); result->data.error.lookahead_char = lookahead_char; result->data.error.expected_input_count = expected_input_count; result->data.error.expected_inputs = expected_inputs; return result; } -ts_symbol ts_tree_symbol(const ts_tree *tree) { +ts_symbol ts_tree_symbol(const TSTree *tree) { return tree->symbol; } -void ts_tree_retain(ts_tree *tree) { +void ts_tree_retain(TSTree *tree) { tree->ref_count++; } -size_t ts_tree_offset(const ts_tree *tree) { +size_t ts_tree_offset(const TSTree *tree) { return tree->offset; } -size_t ts_tree_size(const ts_tree *tree) { +size_t ts_tree_size(const TSTree *tree) { return tree->size; } -size_t ts_tree_total_size(const ts_tree *tree) { +size_t ts_tree_total_size(const TSTree *tree) { return ts_tree_offset(tree) + ts_tree_size(tree); } -ts_tree ** ts_tree_immediate_children(const ts_tree *tree, size_t *count) { +TSTree ** ts_tree_immediate_children(const TSTree *tree, size_t *count) { if (!tree || tree->symbol == ts_builtin_sym_error) { if (count) *count = 0; return NULL; @@ -79,11 +79,11 @@ ts_tree ** ts_tree_immediate_children(const ts_tree *tree, size_t *count) { return tree->data.children.contents + tree->data.children.count; } -void ts_tree_release(ts_tree *tree) { +void ts_tree_release(TSTree *tree) { tree->ref_count--; if (tree->ref_count == 0) { size_t count; - ts_tree **children = ts_tree_immediate_children(tree, &count); + TSTree **children = ts_tree_immediate_children(tree, &count); for (size_t i = 0; i < count; i++) ts_tree_release(children[i]); free(tree->data.children.contents); @@ -91,14 +91,14 @@ void ts_tree_release(ts_tree *tree) { } } -int ts_tree_equals(const ts_tree *node1, const ts_tree *node2) { +int ts_tree_equals(const TSTree *node1, const TSTree *node2) { if (node1->symbol != node2->symbol) return 0; if (node1->symbol == ts_builtin_sym_error) { // check error equality } else { size_t count1, count2; - ts_tree **children1 = ts_tree_children(node1, &count1); - ts_tree **children2 = ts_tree_children(node2, &count2); + TSTree **children1 = ts_tree_children(node1, &count1); + TSTree **children2 = ts_tree_children(node2, &count2); if (count1 != count2) return 0; for (size_t i = 0; i < count1; i++) if (!ts_tree_equals(children1[i], children2[i])) return 0; @@ -106,7 +106,7 @@ int ts_tree_equals(const ts_tree *node1, const ts_tree *node2) { return 1; } -ts_tree ** ts_tree_children(const ts_tree *tree, size_t *count) { +TSTree ** ts_tree_children(const TSTree *tree, size_t *count) { if (!tree || tree->symbol == ts_builtin_sym_error) { if (count) *count = 0; return NULL; @@ -124,7 +124,7 @@ static size_t write_lookahead_to_string(char *string, size_t limit, char lookahe } } -static size_t tree_write_to_string(const ts_tree *tree, const char **symbol_names, char *string, size_t limit) { +static size_t tree_write_to_string(const TSTree *tree, const char **symbol_names, char *string, size_t limit) { char *cursor = string; char **destination = (limit > 0) ? &cursor : &string; @@ -139,7 +139,7 @@ static size_t tree_write_to_string(const ts_tree *tree, const char **symbol_name cursor += snprintf(*destination, limit, "(%s", symbol_names[tree->symbol]); size_t count; - ts_tree **children = ts_tree_children(tree, &count); + TSTree **children = ts_tree_children(tree, &count); for (size_t i = 0; i < count; i++) { cursor += snprintf(*destination, limit, " "); cursor += tree_write_to_string(children[i], symbol_names, *destination, limit); @@ -149,7 +149,7 @@ static size_t tree_write_to_string(const ts_tree *tree, const char **symbol_name return cursor - string; } -char * ts_tree_string(const ts_tree *tree, const char **symbol_names) { +char * ts_tree_string(const TSTree *tree, const char **symbol_names) { static char SCRATCH_STRING[1]; size_t size = tree_write_to_string(tree, symbol_names, SCRATCH_STRING, 0) + 1; char *result = malloc(size * sizeof(char)); @@ -157,6 +157,6 @@ char * ts_tree_string(const ts_tree *tree, const char **symbol_names) { return result; } -char * ts_tree_error_string(const ts_tree *tree, const char **symbol_names) { +char * ts_tree_error_string(const TSTree *tree, const char **symbol_names) { return NULL; } diff --git a/src/runtime/tree.h b/src/runtime/tree.h index 58a5ab15..eb36afee 100644 --- a/src/runtime/tree.h +++ b/src/runtime/tree.h @@ -3,7 +3,7 @@ #include "tree_sitter/runtime.h" -struct ts_tree { +struct TSTree { ts_symbol symbol; size_t ref_count; size_t offset; @@ -13,7 +13,7 @@ struct ts_tree { struct { size_t count; size_t immediate_count; - struct ts_tree **contents; + struct TSTree **contents; } children; struct { char lookahead_char;