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

Rename type ts_tree -> TSTree

Browse source
This commit is contained in:
Max Brunsfeld 2014-06-28 18:45:22 -07:00
parent 2795078633
commit 5f59de72a8
16 changed files with 120 additions and 120 deletions
Download patch file Download diff file Expand all files Collapse all files

6
include/tree_sitter/parser.h
View file

@ -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 <stdio.h>
@ -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;
}
}

4
include/tree_sitter/parser/lexer.h
View file

@ -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
#endif

10
include/tree_sitter/parser/lr_parser.h
View file

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

8
include/tree_sitter/parser/stack.h
View file

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

38
include/tree_sitter/runtime.h
View file

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

4
spec/runtime/helpers/tree_helpers.cc
View file

@ -1,7 +1,7 @@
#include "runtime/helpers/tree_helpers.h"
ts_tree ** tree_array(std::vector<ts_tree *> trees) {
ts_tree ** result = (ts_tree **)calloc(trees.size(), sizeof(ts_tree *));
TSTree ** tree_array(std::vector<TSTree *> trees) {
TSTree ** result = (TSTree **)calloc(trees.size(), sizeof(TSTree *));
for (size_t i = 0; i < trees.size(); i++)
result[i] = trees[i];
return result;

2
spec/runtime/helpers/tree_helpers.h
View file

@ -5,6 +5,6 @@
#include <vector>
ts_tree ** tree_array(std::vector<ts_tree *> trees);
TSTree ** tree_array(std::vector<TSTree *> trees);
#endif // HELPERS_TREE_HELPERS_H_

6
spec/runtime/lr_parser_spec.cc
View file

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

8
spec/runtime/node_position_spec.cc
View file

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

30
spec/runtime/stack_spec.cc
View file

@ -20,11 +20,11 @@ describe("stacks", [&]() {
it("starts out empty", [&]() {
AssertThat(stack.size, Equals<size_t>(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<size_t>(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<size_t>(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<size_t>(4));
for (size_t i = 0; i < 4; i++)

14
spec/runtime/tree_spec.cc
View file

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

6
src/runtime/document.c
View file

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

22
src/runtime/lr_parser.c
View file

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

24
src/runtime/stack.c
View file

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

54
src/runtime/tree.c
View file

@ -3,9 +3,9 @@
#include <stdio.h>
#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;
}

4
src/runtime/tree.h
View file

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