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

Remove unnecessary accessor functions for tree

Browse source
This commit is contained in:
Max Brunsfeld 2014-07-14 21:11:15 -07:00
parent 6e551d6d9f
commit 25f927e321
9 changed files with 41 additions and 55 deletions
Download patch file Download diff file Expand all files Collapse all files

3
include/tree_sitter/runtime.h
View file

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

17
spec/runtime/node_position_spec.cc
View file

@ -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<size_t>(0));
AssertThat(ts_tree_size(number1), Equals<size_t>(2));
AssertThat(number1->offset, Equals<size_t>(0));
AssertThat(number1->size, Equals<size_t>(2));
AssertThat(ts_tree_offset(number2), Equals<size_t>(1));
AssertThat(ts_tree_size(number2), Equals<size_t>(1));
AssertThat(number2->offset, Equals<size_t>(1));
AssertThat(number2->size, Equals<size_t>(1));
AssertThat(ts_tree_offset(array), Equals<size_t>(2));
AssertThat(ts_tree_size(array), Equals<size_t>(7));
AssertThat(array->offset, Equals<size_t>(2));
AssertThat(array->size, Equals<size_t>(7));
AssertThat(ts_tree_offset(tree), Equals<size_t>(2));
AssertThat(ts_tree_size(tree), Equals<size_t>(7));
AssertThat(tree->offset, Equals<size_t>(2));
AssertThat(tree->size, Equals<size_t>(7));
});
});

3
spec/runtime/parser_spec.cc
View file

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

3
spec/runtime/stack_spec.cc
View file

@ -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", [&]() {

5
spec/runtime/tree_spec.cc
View file

@ -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<size_t>(9));
AssertThat(parent1->size, Equals<size_t>(9));
});
it("computes its offset based on its first child", [&]() {
AssertThat(ts_tree_offset(parent1), Equals<size_t>(2));
AssertThat(parent1->offset, Equals<size_t>(2));
});
});

3
src/runtime/document.c
View file

@ -1,5 +1,6 @@
#include "tree_sitter/runtime.h"
#include "tree_sitter/parser.h"
#include "runtime/tree.h"
#include <string.h>
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 {

10
src/runtime/parser.c
View file

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

4
src/runtime/stack.c
View file

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

48
src/runtime/tree.c
View file

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