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

Auto-format all source code with clang-format

Browse source
This commit is contained in:
Max Brunsfeld 2014-07-20 21:43:27 -07:00
parent b8d8386e63
commit 98cc2f2264
105 changed files with 4223 additions and 4052 deletions
Download patch file Download diff file Expand all files Collapse all files

36
src/runtime/document.c
View file

@ -11,11 +11,9 @@ struct TSDocument {
size_t error_count;
};
TSDocument * ts_document_make() {
TSDocument *ts_document_make() {
TSDocument *document = malloc(sizeof(TSDocument));
*document = (TSDocument) {
.input = (TSInput) {}
};
*document = (TSDocument) { .input = (TSInput) {} };
return document;
}
@ -33,12 +31,13 @@ void ts_document_set_parser(TSDocument *document, TSParser *parser) {
document->parser = parser;
}
const TSTree * ts_document_tree(const TSDocument *document) {
const TSTree *ts_document_tree(const TSDocument *document) {
return document->tree;
}
const char * ts_document_string(const TSDocument *document) {
return ts_tree_string(document->tree, ts_parser_config(document->parser).symbol_names);
const char *ts_document_string(const TSDocument *document) {
return ts_tree_string(document->tree,
ts_parser_config(document->parser).symbol_names);
}
void ts_document_set_input(TSDocument *document, TSInput input) {
@ -50,7 +49,8 @@ void ts_document_edit(TSDocument *document, TSInputEdit edit) {
document->tree = ts_parser_parse(document->parser, document->input, &edit);
}
const char * ts_document_symbol_name(const TSDocument *document, const TSTree *tree) {
const char *ts_document_symbol_name(const TSDocument *document,
const TSTree *tree) {
return ts_parser_config(document->parser).symbol_names[tree->symbol];
}
@ -60,7 +60,7 @@ typedef struct {
size_t length;
} TSStringInput;
const char * ts_string_input_read(void *d, size_t *bytes_read) {
const char *ts_string_input_read(void *d, size_t *bytes_read) {
TSStringInput *data = (TSStringInput *)d;
if (data->position >= data->length) {
*bytes_read = 0;
@ -83,24 +83,22 @@ TSInput ts_string_input_make(const char *string) {
data->string = string;
data->position = 0;
data->length = strlen(string);
TSInput input = {
.data = (void *)data,
.read_fn = ts_string_input_read,
.seek_fn = ts_string_input_seek,
.release_fn = free,
};
return input;
return (TSInput) { .data = (void *)data,
.read_fn = ts_string_input_read,
.seek_fn = ts_string_input_seek,
.release_fn = free };
}
void ts_document_set_input_string(TSDocument *document, const char *text) {
ts_document_set_input(document, ts_string_input_make(text));
}
TSNode * ts_document_root_node(const TSDocument *document) {
return ts_node_make_root(document->tree, document->parser->config.symbol_names);
TSNode *ts_document_root_node(const TSDocument *document) {
return ts_node_make_root(document->tree,
document->parser->config.symbol_names);
}
TSNode * ts_document_get_node(const TSDocument *document, size_t pos) {
TSNode *ts_document_get_node(const TSDocument *document, size_t pos) {
TSNode *root = ts_document_root_node(document);
TSNode *result = ts_node_leaf_at_pos(root, pos);
ts_node_release(root);

21
src/runtime/lexer.c
View file

@ -2,16 +2,14 @@
#include "runtime/tree.h"
TSLexer ts_lexer_make() {
return (TSLexer) {
.chunk = NULL,
.debug = 0,
.chunk_start = 0,
.chunk_size = 0,
.position_in_chunk = 0,
.token_start_position = 0,
.token_end_position = 0,
.reached_end = 0
};
return (TSLexer) { .chunk = NULL,
.debug = 0,
.chunk_start = 0,
.chunk_size = 0,
.position_in_chunk = 0,
.token_start_position = 0,
.token_end_position = 0,
.reached_end = 0 };
}
int ts_lexer_advance(TSLexer *lexer) {
@ -33,11 +31,10 @@ int ts_lexer_advance(TSLexer *lexer) {
return 1;
}
TSTree * ts_lexer_build_node(TSLexer *lexer, TSSymbol symbol, int is_hidden) {
TSTree *ts_lexer_build_node(TSLexer *lexer, TSSymbol symbol, int is_hidden) {
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;
lexer->token_end_position = current_position;
return ts_tree_make_leaf(symbol, size, offset, is_hidden);
}

61
src/runtime/node.c
View file

@ -1,34 +1,33 @@
#include "runtime/node.h"
#include "runtime/tree.h"
TSNode * ts_node_make(const TSTree *tree, TSNode *parent, size_t index, size_t start_position, const char **names) {
if (parent) ts_node_retain(parent);
TSNode *ts_node_make(const TSTree *tree, TSNode *parent, size_t index,
size_t start_position, const char **names) {
if (parent)
ts_node_retain(parent);
TSNode *result = malloc(sizeof(TSNode));
*result = (TSNode) {
.ref_count = 1,
.parent = parent,
.index = index,
.content = tree,
.start_position = start_position,
.names = names,
};
*result = (TSNode) { .ref_count = 1,
.parent = parent,
.index = index,
.content = tree,
.start_position = start_position,
.names = names, };
return result;
}
TSNode * ts_node_make_root(const TSTree *tree, const char **names) {
TSNode *ts_node_make_root(const TSTree *tree, const char **names) {
while (ts_tree_is_wrapper(tree))
tree = tree->children[0];
return ts_node_make(tree, NULL, 0, 0, names);
}
void ts_node_retain(TSNode *node) {
node->ref_count++;
}
void ts_node_retain(TSNode *node) { node->ref_count++; }
void ts_node_release(TSNode *node) {
node->ref_count--;
if (node->ref_count == 0) {
if (node->parent) ts_node_release(node->parent);
if (node->parent)
ts_node_release(node->parent);
free(node);
}
}
@ -37,31 +36,27 @@ size_t ts_node_pos(const TSNode *node) {
return node->start_position + node->content->offset;
}
size_t ts_node_size(const TSNode *node) {
return node->content->size;
}
size_t ts_node_size(const TSNode *node) { return node->content->size; }
int ts_node_eq(const TSNode *left, const TSNode *right) {
return ts_tree_equals(left->content, right->content);
}
const char * ts_node_name(const TSNode *node) {
const char *ts_node_name(const TSNode *node) {
return node->names[node->content->symbol];
}
const char * ts_node_string(const TSNode *node) {
const char *ts_node_string(const TSNode *node) {
return ts_tree_string(node->content, node->names);
}
TSNode * ts_node_parent(TSNode *child) {
return child->parent;
}
TSNode *ts_node_parent(TSNode *child) { return child->parent; }
TSNode * ts_node_prev_sibling(TSNode *child) {
TSNode *ts_node_prev_sibling(TSNode *child) {
return ts_node_child(child->parent, child->index - 1);
}
TSNode * ts_node_next_sibling(TSNode *child) {
TSNode *ts_node_next_sibling(TSNode *child) {
return ts_node_child(child->parent, child->index + 1);
}
@ -71,25 +66,29 @@ size_t ts_node_child_count(const TSNode *parent) {
return result;
}
TSNode * ts_node_child(TSNode *parent, size_t index) {
TSNode *ts_node_child(TSNode *parent, size_t index) {
size_t child_count;
TSChildWithPosition *children = ts_tree_visible_children(parent->content, &child_count);
TSChildWithPosition *children =
ts_tree_visible_children(parent->content, &child_count);
if (child_count <= index)
return NULL;
size_t position = parent->start_position + children[index].position;
return ts_node_make(children[index].tree, parent, index, position, parent->names);
return ts_node_make(children[index].tree, parent, index, position,
parent->names);
}
TSNode * ts_node_leaf_at_pos(TSNode *parent, size_t position) {
TSNode *ts_node_leaf_at_pos(TSNode *parent, size_t position) {
size_t child_count;
TSChildWithPosition *children = ts_tree_visible_children(parent->content, &child_count);
TSChildWithPosition *children =
ts_tree_visible_children(parent->content, &child_count);
for (size_t i = 0; i < child_count; i++) {
TSChildWithPosition child = children[i];
size_t child_left = child.position + child.tree->offset;
if (child_left > position)
break;
if (child_left + child.tree->size > position) {
TSNode *node = ts_node_make(child.tree, parent, i, child.position, parent->names);
TSNode *node =
ts_node_make(child.tree, parent, i, child.position, parent->names);
TSNode *result = ts_node_leaf_at_pos(node, position);
ts_node_release(node);
return result;

5
src/runtime/node.h
View file

@ -13,7 +13,8 @@ struct TSNode {
const char **names;
};
TSNode * ts_node_make(const TSTree *tree, TSNode *parent, size_t index, size_t start_position, const char **names);
TSNode * ts_node_make_root(const TSTree *tree, const char **names);
TSNode *ts_node_make(const TSTree *tree, TSNode *parent, size_t index,
size_t start_position, const char **names);
TSNode *ts_node_make_root(const TSTree *tree, const char **names);
#endif

96
src/runtime/parser.c
View file

@ -7,24 +7,28 @@
* Private
*/
static const TSParseAction * actions_for_state(TSParserConfig config, TSStateId state) {
static const TSParseAction *actions_for_state(TSParserConfig config,
TSStateId state) {
return config.parse_table + (state * config.symbol_count);
}
static size_t breakdown_stack(TSParser *parser, TSInputEdit *edit) {
if (!edit) return 0;
if (!edit)
return 0;
TSStack *stack = &parser->stack;
size_t position = 0;
for (;;) {
TSTree *node = ts_stack_top_node(stack);
if (!node) break;
if (!node)
break;
position = ts_stack_right_position(stack);
size_t child_count;
TSTree **children = ts_tree_children(node, &child_count);
if (position <= edit->position && !children) break;
if (position <= edit->position && !children)
break;
stack->size--;
position -= ts_tree_total_size(node);
@ -32,7 +36,8 @@ 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)[child->symbol].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);
@ -44,9 +49,10 @@ static size_t breakdown_stack(TSParser *parser, TSInputEdit *edit) {
return position;
}
static TSSymbol * expected_symbols(TSParser *parser, size_t *count) {
static TSSymbol *expected_symbols(TSParser *parser, size_t *count) {
*count = 0;
const TSParseAction *actions = actions_for_state(parser->config, ts_stack_top_state(&parser->stack));
const TSParseAction *actions =
actions_for_state(parser->config, ts_stack_top_state(&parser->stack));
for (size_t i = 0; i < parser->config.symbol_count; i++)
if (actions[i].type != TSParseActionTypeError)
(*count)++;
@ -64,26 +70,27 @@ static TSSymbol * expected_symbols(TSParser *parser, size_t *count) {
* Public
*/
TSParser * ts_parser_make(TSParserConfig config) {
TSParser *ts_parser_make(TSParserConfig config) {
TSParser *result = malloc(sizeof(*result));
*result = (TSParser) {
.lexer = ts_lexer_make(),
.stack = ts_stack_make(),
.debug = 0,
.config = config,
};
*result = (TSParser) { .lexer = ts_lexer_make(),
.stack = ts_stack_make(),
.debug = 0,
.config = config, };
return result;
}
void ts_parser_free(TSParser *parser) {
if (parser->lookahead) ts_tree_release(parser->lookahead);
if (parser->next_lookahead) ts_tree_release(parser->next_lookahead);
if (parser->lookahead)
ts_tree_release(parser->lookahead);
if (parser->next_lookahead)
ts_tree_release(parser->next_lookahead);
ts_stack_delete(&parser->stack);
free(parser);
}
void ts_parser_start(TSParser *parser, TSInput input, TSInputEdit *edit) {
if (!edit) ts_stack_shrink(&parser->stack, 0);
if (!edit)
ts_stack_shrink(&parser->stack, 0);
parser->lookahead = NULL;
parser->next_lookahead = NULL;
@ -110,11 +117,8 @@ void ts_parser_shift_extra(TSParser *parser) {
void ts_parser_reduce(TSParser *parser, TSSymbol symbol, size_t child_count) {
parser->next_lookahead = parser->lookahead;
parser->lookahead = ts_stack_reduce(
&parser->stack,
symbol,
child_count,
parser->config.hidden_symbol_flags, 1);
parser->lookahead = ts_stack_reduce(&parser->stack, symbol, child_count,
parser->config.hidden_symbol_flags, 1);
}
int ts_parser_reduce_extra(TSParser *parser, TSSymbol symbol) {
@ -131,12 +135,8 @@ int ts_parser_reduce_extra(TSParser *parser, TSSymbol symbol) {
int ts_parser_handle_error(TSParser *parser) {
size_t count = 0;
const TSSymbol *inputs = expected_symbols(parser, &count);
TSTree *error = ts_tree_make_error(
ts_lexer_lookahead_char(&parser->lexer),
count,
inputs,
0,
0);
TSTree *error = ts_tree_make_error(ts_lexer_lookahead_char(&parser->lexer),
count, inputs, 0, 0);
for (;;) {
ts_tree_release(parser->lookahead);
@ -159,10 +159,13 @@ int ts_parser_handle_error(TSParser *parser) {
for (size_t j = 0; j < parser->stack.size; j++) {
size_t i = parser->stack.size - 1 - j;
TSStateId stack_state = parser->stack.entries[i].state;
TSParseAction action_on_error = actions_for_state(parser->config, stack_state)[ts_builtin_sym_error];
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)[parser->lookahead->symbol].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;
@ -172,7 +175,7 @@ int ts_parser_handle_error(TSParser *parser) {
}
}
TSTree * ts_parser_tree_root(TSParser *parser) {
TSTree *ts_parser_tree_root(TSParser *parser) {
TSStack *stack = &parser->stack;
size_t node_count = 0;
for (size_t i = 0; i < stack->size; i++) {
@ -182,7 +185,8 @@ TSTree * ts_parser_tree_root(TSParser *parser) {
}
if (node_count > 1)
return ts_stack_reduce(stack, 2, stack->size, parser->config.hidden_symbol_flags, 0);
return ts_stack_reduce(stack, 2, stack->size,
parser->config.hidden_symbol_flags, 0);
else
return ts_stack_top_node(stack);
}
@ -190,16 +194,20 @@ TSTree * ts_parser_tree_root(TSParser *parser) {
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]);
parser->lookahead =
parser->config.lex_fn(parser, parser->config.lex_states[state]);
return actions_for_state(parser->config, state)[parser->lookahead->symbol];
}
#define DEBUG_PARSE(...) \
if (parser->debug) { fprintf(stderr, "\n" __VA_ARGS__); }
#define DEBUG_PARSE(...) \
if (parser->debug) { \
fprintf(stderr, "\n" __VA_ARGS__); \
}
TSTree * ts_parser_step(TSParser *parser) {
TSTree *ts_parser_step(TSParser *parser) {
TSParseAction action = ts_parser_next_action(parser);
DEBUG_PARSE("LOOKAHEAD %s", parser->config.symbol_names[parser->lookahead->symbol]);
DEBUG_PARSE("LOOKAHEAD %s",
parser->config.symbol_names[parser->lookahead->symbol]);
switch (action.type) {
case TSParseActionTypeShift:
DEBUG_PARSE("SHIFT %d", action.data.to_state);
@ -210,7 +218,9 @@ TSTree * ts_parser_step(TSParser *parser) {
ts_parser_shift_extra(parser);
return NULL;
case TSParseActionTypeReduce:
DEBUG_PARSE("REDUCE %s %d", parser->config.symbol_names[action.data.symbol], action.data.child_count);
DEBUG_PARSE("REDUCE %s %d",
parser->config.symbol_names[action.data.symbol],
action.data.child_count);
ts_parser_reduce(parser, action.data.symbol, action.data.child_count);
return NULL;
case TSParseActionTypeReduceExtra:
@ -235,15 +245,15 @@ error:
return NULL;
}
const TSTree * ts_parser_parse(TSParser *parser, TSInput input, TSInputEdit *edit) {
const TSTree *ts_parser_parse(TSParser *parser, TSInput input,
TSInputEdit *edit) {
ts_parser_start(parser, input, edit);
for (;;) {
const TSTree *tree = ts_parser_step(parser);
if (tree) return tree;
if (tree)
return tree;
}
}
TSParserConfig ts_parser_config(TSParser *parser) {
return parser->config;
}
TSParserConfig ts_parser_config(TSParser *parser) { return parser->config; }

19
src/runtime/stack.c
View file

@ -8,8 +8,7 @@ static TSStateId INITIAL_STATE = 0;
TSStack ts_stack_make() {
TSStack result = {
.entries = calloc(INITIAL_STACK_SIZE, sizeof(*result.entries)),
.size = 0,
.entries = calloc(INITIAL_STACK_SIZE, sizeof(*result.entries)), .size = 0,
};
return result;
}
@ -25,7 +24,7 @@ TSStateId ts_stack_top_state(const TSStack *stack) {
return stack->entries[stack->size - 1].state;
}
TSTree * ts_stack_top_node(const TSStack *stack) {
TSTree *ts_stack_top_node(const TSStack *stack) {
if (stack->size == 0)
return NULL;
return stack->entries[stack->size - 1].node;
@ -53,11 +52,8 @@ size_t ts_stack_right_position(const TSStack *stack) {
return result;
}
TSTree * ts_stack_reduce(TSStack *stack,
TSSymbol symbol,
size_t child_count,
const int *hidden_symbol_flags,
int dont_count_extras) {
TSTree *ts_stack_reduce(TSStack *stack, TSSymbol symbol, size_t child_count,
const int *hidden_symbol_flags, int dont_count_extras) {
// First, walk down the stack to determine which symbols will be reduced.
// The child node count is known ahead of time, but some children may be
@ -73,11 +69,8 @@ TSTree * ts_stack_reduce(TSStack *stack,
for (size_t i = 0; i < child_count; i++)
children[i] = stack->entries[start_index + i].node;
TSTree *lookahead = ts_tree_make_node(
symbol,
child_count,
children,
hidden_symbol_flags[symbol]);
TSTree *lookahead = ts_tree_make_node(symbol, child_count, children,
hidden_symbol_flags[symbol]);
ts_stack_shrink(stack, stack->size - child_count);
return lookahead;

97
src/runtime/tree.c
View file

@ -3,26 +3,27 @@
#include "tree_sitter/parser.h"
#include "runtime/tree.h"
static TSTree * ts_tree_make(TSSymbol symbol, size_t size, size_t offset, int is_hidden) {
static TSTree *ts_tree_make(TSSymbol symbol, size_t size, size_t offset,
int is_hidden) {
TSTree *result = malloc(sizeof(TSTree));
*result = (TSTree) {
.ref_count = 1,
.symbol = symbol,
.size = size,
.offset = offset,
.options = is_hidden ? TSTreeOptionsHidden : 0,
};
*result = (TSTree) { .ref_count = 1,
.symbol = symbol,
.size = size,
.offset = offset,
.options = is_hidden ? TSTreeOptionsHidden : 0, };
return result;
}
TSTree * ts_tree_make_leaf(TSSymbol symbol, size_t size, size_t offset, int is_hidden) {
TSTree *ts_tree_make_leaf(TSSymbol symbol, size_t size, size_t offset,
int is_hidden) {
TSTree *result = ts_tree_make(symbol, size, offset, is_hidden);
result->child_count = 0;
result->children = NULL;
return result;
}
TSTree * ts_tree_make_node(TSSymbol symbol, size_t child_count, TSTree **children, int is_hidden) {
TSTree *ts_tree_make_node(TSSymbol symbol, size_t child_count,
TSTree **children, int is_hidden) {
size_t size = 0, offset = 0, visible_child_count = 0;
for (size_t i = 0; i < child_count; i++) {
TSTree *child = children[i];
@ -43,34 +44,34 @@ TSTree * ts_tree_make_node(TSSymbol symbol, size_t child_count, TSTree **childre
TSTreeOptions options = 0;
if (is_hidden)
options |= TSTreeOptionsHidden;
if (child_count == 1 && (ts_tree_is_visible(children[0]) || ts_tree_is_wrapper(children[0])))
if (child_count == 1 &&
(ts_tree_is_visible(children[0]) || ts_tree_is_wrapper(children[0])))
options |= (TSTreeOptionsWrapper | TSTreeOptionsHidden);
TSTree *result = malloc(sizeof(TSTree) + (visible_child_count * sizeof(TSChildWithPosition)));
*result = (TSTree) {
.ref_count = 1,
.symbol = symbol,
.size = size,
.offset = offset,
.options = options,
.children = children,
.child_count = child_count,
.visible_child_count = visible_child_count,
};
TSTree *result = malloc(sizeof(TSTree) +
(visible_child_count * sizeof(TSChildWithPosition)));
*result = (TSTree) { .ref_count = 1,
.symbol = symbol,
.size = size,
.offset = offset,
.options = options,
.children = children,
.child_count = child_count,
.visible_child_count = visible_child_count, };
TSChildWithPosition *visible_children = ts_tree_visible_children(result, NULL);
TSChildWithPosition *visible_children =
ts_tree_visible_children(result, NULL);
for (size_t i = 0, visible_i = 0, child_position = 0; i < child_count; i++) {
TSTree *child = children[i];
if (ts_tree_is_visible(child)) {
visible_children[visible_i] = (TSChildWithPosition) {
.tree = child,
.position = child_position
};
visible_children[visible_i] =
(TSChildWithPosition) { .tree = child, .position = child_position };
visible_i++;
} else {
size_t granchild_count = 0;
TSChildWithPosition *grandchildren = ts_tree_visible_children(child, &granchild_count);
TSChildWithPosition *grandchildren =
ts_tree_visible_children(child, &granchild_count);
for (size_t j = 0; j < granchild_count; j++) {
visible_children[visible_i] = (TSChildWithPosition) {
.tree = grandchildren[j].tree,
@ -86,7 +87,9 @@ TSTree * ts_tree_make_node(TSSymbol symbol, size_t child_count, TSTree **childre
return result;
}
TSTree * ts_tree_make_error(char lookahead_char, size_t expected_input_count, const TSSymbol *expected_inputs, size_t size, size_t offset) {
TSTree *ts_tree_make_error(char lookahead_char, size_t expected_input_count,
const TSSymbol *expected_inputs, size_t size,
size_t offset) {
TSTree *result = ts_tree_make(ts_builtin_sym_error, size, offset, 0);
result->lookahead_char = lookahead_char;
result->expected_input_count = expected_input_count;
@ -94,9 +97,7 @@ TSTree * ts_tree_make_error(char lookahead_char, size_t expected_input_count, co
return result;
}
void ts_tree_retain(TSTree *tree) {
tree->ref_count++;
}
void ts_tree_retain(TSTree *tree) { tree->ref_count++; }
void ts_tree_release(TSTree *tree) {
tree->ref_count--;
@ -115,27 +116,33 @@ size_t ts_tree_total_size(const TSTree *tree) {
}
int ts_tree_equals(const TSTree *node1, const TSTree *node2) {
if (node1->symbol != node2->symbol) return 0;
if (node1->symbol != node2->symbol)
return 0;
if (node1->symbol == ts_builtin_sym_error) {
// check error equality
} else {
if (node1->child_count != node2->child_count) return 0;
if (node1->child_count != node2->child_count)
return 0;
for (size_t i = 0; i < node1->child_count; i++)
if (!ts_tree_equals(node1->children[i], node2->children[i])) return 0;
if (!ts_tree_equals(node1->children[i], node2->children[i]))
return 0;
}
return 1;
}
TSTree ** ts_tree_children(const TSTree *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;
if (count)
*count = 0;
return NULL;
}
if (count) *count = tree->child_count;
if (count)
*count = tree->child_count;
return tree->children;
}
static size_t write_lookahead_to_string(char *string, size_t limit, char lookahead) {
static size_t write_lookahead_to_string(char *string, size_t limit,
char lookahead) {
switch (lookahead) {
case '\0':
return snprintf(string, limit, "<EOF>");
@ -144,7 +151,9 @@ static size_t write_lookahead_to_string(char *string, size_t limit, char lookahe
}
}
static size_t tree_write_to_string(const TSTree *tree, const char **symbol_names, char *string, size_t limit, int is_root) {
static size_t tree_write_to_string(const TSTree *tree,
const char **symbol_names, char *string,
size_t limit, int is_root) {
char *cursor = string;
char **writer = (limit > 0) ? &cursor : &string;
int visible = ts_tree_is_visible(tree);
@ -167,7 +176,8 @@ static size_t tree_write_to_string(const TSTree *tree, const char **symbol_names
}
for (size_t i = 0; i < tree->child_count; i++)
cursor += tree_write_to_string(tree->children[i], symbol_names, *writer, limit, is_root);
cursor += tree_write_to_string(tree->children[i], symbol_names, *writer,
limit, is_root);
if (visible)
cursor += snprintf(*writer, limit, ")");
@ -175,9 +185,10 @@ static size_t tree_write_to_string(const TSTree *tree, const char **symbol_names
return cursor - string;
}
char * ts_tree_string(const TSTree *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) + 1;
size_t size =
tree_write_to_string(tree, symbol_names, SCRATCH_STRING, 0, 1) + 1;
char *result = malloc(size * sizeof(char));
tree_write_to_string(tree, symbol_names, result, size, 1);
return result;

25
src/runtime/tree.h
View file

@ -61,25 +61,32 @@ static inline size_t ts_tree_visible_child_count(const TSTree *tree) {
return tree->visible_child_count;
}
static inline TSChildWithPosition * ts_tree_visible_children(const TSTree *tree, size_t *count) {
static inline TSChildWithPosition *ts_tree_visible_children(const TSTree *tree,
size_t *count) {
if (tree->symbol == ts_builtin_sym_error || tree->visible_child_count == 0) {
if (count) *count = 0;
if (count)
*count = 0;
return NULL;
} else {
if (count) *count = tree->visible_child_count;
if (count)
*count = tree->visible_child_count;
return (TSChildWithPosition *)(tree + 1);
}
}
TSTree * ts_tree_make_leaf(TSSymbol symbol, size_t size, size_t offset, int is_hidden);
TSTree * ts_tree_make_node(TSSymbol symbol, size_t child_count, TSTree **children, int is_hidden);
TSTree * ts_tree_make_error(char lookahead_char, size_t expected_input_count, const TSSymbol *expected_inputs, size_t size, size_t offset);
TSTree *ts_tree_make_leaf(TSSymbol symbol, size_t size, size_t offset,
int is_hidden);
TSTree *ts_tree_make_node(TSSymbol symbol, size_t child_count,
TSTree **children, int is_hidden);
TSTree *ts_tree_make_error(char lookahead_char, size_t expected_input_count,
const TSSymbol *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);
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);
size_t ts_tree_total_size(const TSTree *tree);
#ifdef __cplusplus