From 25f927e32119bf55f28316a5ac0263b98ae7b87d Mon Sep 17 00:00:00 2001 From: Max Brunsfeld Date: Mon, 14 Jul 2014 21:11:15 -0700 Subject: [PATCH] Remove unnecessary accessor functions for tree --- include/tree_sitter/runtime.h | 3 -- spec/runtime/node_position_spec.cc | 17 ++++++----- spec/runtime/parser_spec.cc | 3 +- spec/runtime/stack_spec.cc | 3 +- spec/runtime/tree_spec.cc | 5 ++-- src/runtime/document.c | 3 +- src/runtime/parser.c | 10 +++---- src/runtime/stack.c | 4 +-- src/runtime/tree.c | 48 ++++++++++-------------------- 9 files changed, 41 insertions(+), 55 deletions(-) diff --git a/include/tree_sitter/runtime.h b/include/tree_sitter/runtime.h index 65b4bad8..6d1f8403 100644 --- a/include/tree_sitter/runtime.h +++ b/include/tree_sitter/runtime.h @@ -23,10 +23,7 @@ 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); -TSSymbol ts_tree_symbol(const TSTree *tree); typedef struct { void *data; diff --git a/spec/runtime/node_position_spec.cc b/spec/runtime/node_position_spec.cc index 9e593893..30c0826c 100644 --- a/spec/runtime/node_position_spec.cc +++ b/spec/runtime/node_position_spec.cc @@ -1,4 +1,5 @@ #include "runtime/runtime_spec_helper.h" +#include "runtime/tree.h" extern "C" TSParser * ts_parser_json(); @@ -28,17 +29,17 @@ describe("tracking the positions of AST nodes", []() { AssertThat(ts_document_symbol_name(doc, number1), Equals("number")); AssertThat(ts_document_symbol_name(doc, number2), Equals("number")); - AssertThat(ts_tree_offset(number1), Equals(0)); - AssertThat(ts_tree_size(number1), Equals(2)); + AssertThat(number1->offset, Equals(0)); + AssertThat(number1->size, Equals(2)); - AssertThat(ts_tree_offset(number2), Equals(1)); - AssertThat(ts_tree_size(number2), Equals(1)); + AssertThat(number2->offset, Equals(1)); + AssertThat(number2->size, Equals(1)); - AssertThat(ts_tree_offset(array), Equals(2)); - AssertThat(ts_tree_size(array), Equals(7)); + AssertThat(array->offset, Equals(2)); + AssertThat(array->size, Equals(7)); - AssertThat(ts_tree_offset(tree), Equals(2)); - AssertThat(ts_tree_size(tree), Equals(7)); + AssertThat(tree->offset, Equals(2)); + AssertThat(tree->size, Equals(7)); }); }); diff --git a/spec/runtime/parser_spec.cc b/spec/runtime/parser_spec.cc index f3c29784..981b3299 100644 --- a/spec/runtime/parser_spec.cc +++ b/spec/runtime/parser_spec.cc @@ -1,6 +1,7 @@ #include "runtime/runtime_spec_helper.h" #include "runtime/helpers/spy_reader.h" #include "runtime/helpers/dummy_parser.h" +#include "runtime/tree.h" #include "tree_sitter/parser.h" TSTree *lex_fn_node_to_return; @@ -67,7 +68,7 @@ describe("LR Parsers", [&]() { it("ends the parse, returning an error tree", [&]() { auto result = ts_parser_step(parser); - AssertThat(ts_tree_symbol(result), Equals(ts_builtin_sym_error)); + AssertThat(result->symbol, Equals(ts_builtin_sym_error)); }); }); }); diff --git a/spec/runtime/stack_spec.cc b/spec/runtime/stack_spec.cc index d4ab8df5..e3efeb2b 100644 --- a/spec/runtime/stack_spec.cc +++ b/spec/runtime/stack_spec.cc @@ -1,4 +1,5 @@ #include "runtime/runtime_spec_helper.h" +#include "runtime/tree.h" #include "tree_sitter/parser.h" START_TEST @@ -71,7 +72,7 @@ describe("stacks", [&]() { it("returns a node with the given symbol", [&]() { TSTree *node = ts_stack_reduce(&stack, sym2, 3, hidden_symbols, 0); - AssertThat(ts_tree_symbol(node), Equals(sym2)); + AssertThat(node->symbol, Equals(sym2)); }); it("makes all of the removed nodes immediate children of the new node", [&]() { diff --git a/spec/runtime/tree_spec.cc b/spec/runtime/tree_spec.cc index 857a8c59..fa395e44 100644 --- a/spec/runtime/tree_spec.cc +++ b/spec/runtime/tree_spec.cc @@ -1,4 +1,5 @@ #include "runtime/runtime_spec_helper.h" +#include "runtime/tree.h" START_TEST @@ -30,11 +31,11 @@ describe("trees", []() { describe("making a parent node", [&]() { it("computes its offset and size based on its child nodes", [&]() { - AssertThat(ts_tree_size(parent1), Equals(9)); + AssertThat(parent1->size, Equals(9)); }); it("computes its offset based on its first child", [&]() { - AssertThat(ts_tree_offset(parent1), Equals(2)); + AssertThat(parent1->offset, Equals(2)); }); }); diff --git a/src/runtime/document.c b/src/runtime/document.c index 73579733..4a246b4d 100644 --- a/src/runtime/document.c +++ b/src/runtime/document.c @@ -1,5 +1,6 @@ #include "tree_sitter/runtime.h" #include "tree_sitter/parser.h" +#include "runtime/tree.h" #include struct TSDocument { @@ -42,7 +43,7 @@ void ts_document_edit(TSDocument *document, TSInputEdit edit) { } const char * ts_document_symbol_name(const TSDocument *document, const TSTree *tree) { - return ts_parser_config(document->parser).symbol_names[ts_tree_symbol(tree)]; + return ts_parser_config(document->parser).symbol_names[tree->symbol]; } typedef struct { diff --git a/src/runtime/parser.c b/src/runtime/parser.c index a610f96f..cd04123f 100644 --- a/src/runtime/parser.c +++ b/src/runtime/parser.c @@ -32,7 +32,7 @@ static size_t breakdown_stack(TSParser *parser, TSInputEdit *edit) { for (size_t i = 0; i < child_count && position < edit->position; i++) { TSTree *child = children[i]; TSStateId state = ts_stack_top_state(stack); - TSStateId next_state = actions_for_state(parser->config, state)[ts_tree_symbol(child)].data.to_state; + TSStateId next_state = actions_for_state(parser->config, state)[child->symbol].data.to_state; ts_stack_push(stack, next_state, child); ts_tree_retain(child); position += ts_tree_total_size(child); @@ -146,7 +146,7 @@ int ts_parser_handle_error(TSParser *parser) { if (ts_lexer_position(&parser->lexer) == position) at_end = !ts_lexer_advance(&parser->lexer); - if (at_end || ts_tree_symbol(parser->lookahead) == ts_builtin_sym_end) { + if (at_end || parser->lookahead->symbol == ts_builtin_sym_end) { ts_stack_push(&parser->stack, 0, error); return 0; } @@ -161,7 +161,7 @@ int ts_parser_handle_error(TSParser *parser) { TSParseAction action_on_error = actions_for_state(parser->config, stack_state)[ts_builtin_sym_error]; if (action_on_error.type == TSParseActionTypeShift) { TSStateId state_after_error = action_on_error.data.to_state; - if (actions_for_state(parser->config, state_after_error)[ts_tree_symbol(parser->lookahead)].type != TSParseActionTypeError) { + if (actions_for_state(parser->config, state_after_error)[parser->lookahead->symbol].type != TSParseActionTypeError) { ts_stack_shrink(&parser->stack, i + 1); ts_stack_push(&parser->stack, state_after_error, error); return 1; @@ -190,7 +190,7 @@ TSParseAction ts_parser_next_action(TSParser *parser) { TSStateId state = ts_stack_top_state(&parser->stack); if (!parser->lookahead) parser->lookahead = parser->config.lex_fn(parser, parser->config.lex_states[state]); - return actions_for_state(parser->config, state)[ts_tree_symbol(parser->lookahead)]; + return actions_for_state(parser->config, state)[parser->lookahead->symbol]; } #define DEBUG_PARSE(...) \ @@ -198,7 +198,7 @@ if (parser->debug) { fprintf(stderr, "\n" __VA_ARGS__); } TSTree * ts_parser_step(TSParser *parser) { TSParseAction action = ts_parser_next_action(parser); - DEBUG_PARSE("LOOKAHEAD %s", parser->config.symbol_names[ts_tree_symbol(parser->lookahead)]); + DEBUG_PARSE("LOOKAHEAD %s", parser->config.symbol_names[parser->lookahead->symbol]); switch (action.type) { case TSParseActionTypeShift: DEBUG_PARSE("SHIFT %d", action.data.to_state); diff --git a/src/runtime/stack.c b/src/runtime/stack.c index f2e9e774..904e7ef2 100644 --- a/src/runtime/stack.c +++ b/src/runtime/stack.c @@ -69,11 +69,11 @@ TSTree * ts_stack_reduce(TSStack *stack, TSTree *child = stack->entries[stack_index].node; size_t grandchild_count; TSTree **grandchildren = ts_tree_children(child, &grandchild_count); - TSSymbol child_symbol = ts_tree_symbol(child); + TSSymbol child_symbol = child->symbol; collapse_flags[i] = ( hidden_symbol_flags[child_symbol] || - (grandchild_count == 1 && ts_tree_size(child) == ts_tree_size(grandchildren[0])) + (grandchild_count == 1 && child->size == grandchildren[0]->size) ); child_count += collapse_flags[i] ? grandchild_count : 1; diff --git a/src/runtime/tree.c b/src/runtime/tree.c index a77a657c..c55ef054 100644 --- a/src/runtime/tree.c +++ b/src/runtime/tree.c @@ -29,10 +29,10 @@ TSTree * ts_tree_make_node(TSSymbol symbol, size_t child_count, size_t immediate TSTree *child = immediate_children[i]; ts_tree_retain(child); if (i == 0) { - offset = ts_tree_offset(child); - size = ts_tree_size(child); + offset = child->offset; + size = child->size; } else { - size += ts_tree_offset(child) + ts_tree_size(child); + size += child->offset + child->size; } } TSTree *result = ts_tree_make(symbol, size, offset); @@ -50,35 +50,10 @@ TSTree * ts_tree_make_error(char lookahead_char, size_t expected_input_count, co return result; } -TSSymbol ts_tree_symbol(const TSTree *tree) { - return tree->symbol; -} - void ts_tree_retain(TSTree *tree) { tree->ref_count++; } -size_t ts_tree_offset(const TSTree *tree) { - return tree->offset; -} - -size_t ts_tree_size(const TSTree *tree) { - return tree->size; -} - -size_t ts_tree_total_size(const TSTree *tree) { - return ts_tree_offset(tree) + ts_tree_size(tree); -} - -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; - } - if (count) *count = tree->data.children.immediate_count; - return tree->data.children.contents + tree->data.children.count; -} - void ts_tree_release(TSTree *tree) { tree->ref_count--; if (tree->ref_count == 0) { @@ -91,6 +66,19 @@ void ts_tree_release(TSTree *tree) { } } +size_t ts_tree_total_size(const TSTree *tree) { + return tree->offset + tree->size; +} + +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; + } + if (count) *count = tree->data.children.immediate_count; + return tree->data.children.contents + tree->data.children.count; +} + int ts_tree_equals(const TSTree *node1, const TSTree *node2) { if (node1->symbol != node2->symbol) return 0; if (node1->symbol == ts_builtin_sym_error) { @@ -156,7 +144,3 @@ char * ts_tree_string(const TSTree *tree, const char **symbol_names) { tree_write_to_string(tree, symbol_names, result, size); return result; } - -char * ts_tree_error_string(const TSTree *tree, const char **symbol_names) { - return NULL; -}