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

Move sexp-generation code to node.c

Browse source
This commit is contained in:
Max Brunsfeld 2016-02-19 15:41:09 -08:00
parent 3d7df851b5
commit df1d9b2416
5 changed files with 65 additions and 100 deletions
Download patch file Download diff file Expand all files Collapse all files

11
spec/helpers/tree_helpers.cc
View file

@ -1,4 +1,6 @@
#include "helpers/tree_helpers.h"
#include "runtime/document.h"
#include "runtime/node.h"
#include <ostream>
using std::string;
@ -12,6 +14,7 @@ static const char *symbol_names[24] = {
"twenty-two", "twenty-three"
};
TSTree ** tree_array(std::vector<TSTree *> trees) {
TSTree ** result = (TSTree **)calloc(trees.size(), sizeof(TSTree *));
for (size_t i = 0; i < trees.size(); i++)
@ -20,7 +23,13 @@ TSTree ** tree_array(std::vector<TSTree *> trees) {
}
ostream &operator<<(std::ostream &stream, const TSTree *tree) {
return stream << string(ts_tree_string(tree, symbol_names, true));;
static TSLanguage DUMMY_LANGUAGE = {};
static TSDocument DUMMY_DOCUMENT = {};
DUMMY_DOCUMENT.parser.language = &DUMMY_LANGUAGE;
DUMMY_LANGUAGE.symbol_names = symbol_names;
TSNode node;
node.data = tree;
return stream << string(ts_node_string(node, &DUMMY_DOCUMENT));
}
ostream &operator<<(ostream &stream, const TSNode &node) {

36
spec/runtime/tree_spec.cc
View file

@ -345,42 +345,6 @@ describe("Tree", []() {
ts_tree_release(different_parent);
});
});
describe("serialization", [&]() {
it("returns a readable string", [&]() {
char *string1 = ts_tree_string(tree1, names, true);
AssertThat(string(string1), Equals("(cat)"));
free(string1);
char *string2 = ts_tree_string(parent1, names, true);
AssertThat(string(string2), Equals("(dog (cat) (cat))"));
free(string2);
});
it("hides invisible nodes", [&]() {
tree2->visible = false;
char *string1 = ts_tree_string(parent1, names, true);
AssertThat(string(string1), Equals("(dog (cat))"));
free(string1);
});
describe("when the root node is not visible", [&]() {
it("still serializes it", [&]() {
parent1->visible = false;
char *string1 = ts_tree_string(parent1, names, true);
AssertThat(string(string1), Equals("(dog (cat) (cat))"));
free(string1);
tree1->visible = false;
char *string2 = ts_tree_string(tree1, names, true);
AssertThat(string(string2), Equals("(cat)"));
free(string2);
});
});
});
});
END_TEST

57
src/runtime/node.c
View file

@ -1,4 +1,6 @@
#include <stdbool.h>
#include <string.h>
#include <stdio.h>
#include "runtime/node.h"
#include "runtime/tree.h"
#include "runtime/document.h"
@ -206,9 +208,60 @@ const char *ts_node_name(TSNode self, const TSDocument *document) {
return document->parser.language->symbol_names[ts_node__tree(self)->symbol];
}
static size_t write_lookahead_to_string(char *string, size_t limit,
char lookahead) {
switch (lookahead) {
case '\0':
return snprintf(string, limit, "<EOF>");
default:
return snprintf(string, limit, "'%c'", lookahead);
}
}
static size_t ts_tree__write_to_string(const TSTree *self,
const char **symbol_names, char *string,
size_t limit, bool is_root,
bool include_anonymous) {
if (!self)
return snprintf(string, limit, "(NULL)");
char *cursor = string;
char **writer = (limit > 0) ? &cursor : &string;
bool visible =
is_root || (self->visible && (include_anonymous || self->named));
if (visible && !is_root)
cursor += snprintf(*writer, limit, " ");
if (visible) {
if (self->symbol == ts_builtin_sym_error && self->child_count == 0) {
cursor += snprintf(*writer, limit, "(UNEXPECTED ");
cursor += write_lookahead_to_string(*writer, limit, self->lookahead_char);
} else {
cursor += snprintf(*writer, limit, "(%s", symbol_names[self->symbol]);
}
}
for (size_t i = 0; i < self->child_count; i++) {
TSTree *child = self->children[i];
cursor += ts_tree__write_to_string(child, symbol_names, *writer, limit,
false, include_anonymous);
}
if (visible)
cursor += snprintf(*writer, limit, ")");
return cursor - string;
}
char *ts_node_string(TSNode self, const TSDocument *document) {
return ts_tree_string(ts_node__tree(self),
document->parser.language->symbol_names, false);
static char SCRATCH[1];
const TSTree *tree = ts_node__tree(self);
const char **symbol_names = document->parser.language->symbol_names;
size_t size = ts_tree__write_to_string(tree, symbol_names, SCRATCH, 0, true, false) + 1;
char *result = ts_malloc(size * sizeof(char));
ts_tree__write_to_string(tree, symbol_names, result, size, true, false);
return result;
}
bool ts_node_eq(TSNode self, TSNode other) {

59
src/runtime/tree.c
View file

@ -1,8 +1,6 @@
#include <assert.h>
#include <limits.h>
#include <string.h>
#include <stdbool.h>
#include <stdio.h>
#include "tree_sitter/parser.h"
#include "runtime/alloc.h"
#include "runtime/tree.h"
@ -235,63 +233,6 @@ int ts_tree_compare(const TSTree *left, const TSTree *right) {
return 0;
}
static size_t write_lookahead_to_string(char *string, size_t limit,
char lookahead) {
switch (lookahead) {
case '\0':
return snprintf(string, limit, "<EOF>");
default:
return snprintf(string, limit, "'%c'", lookahead);
}
}
static size_t ts_tree__write_to_string(const TSTree *self,
const char **symbol_names, char *string,
size_t limit, bool is_root,
bool include_anonymous) {
if (!self)
return snprintf(string, limit, "(NULL)");
char *cursor = string;
char **writer = (limit > 0) ? &cursor : &string;
bool visible =
is_root || (self->visible && (include_anonymous || self->named));
if (visible && !is_root)
cursor += snprintf(*writer, limit, " ");
if (visible) {
if (self->symbol == ts_builtin_sym_error && self->child_count == 0) {
cursor += snprintf(*writer, limit, "(UNEXPECTED ");
cursor += write_lookahead_to_string(*writer, limit, self->lookahead_char);
} else {
cursor += snprintf(*writer, limit, "(%s", symbol_names[self->symbol]);
}
}
for (size_t i = 0; i < self->child_count; i++) {
TSTree *child = self->children[i];
cursor += ts_tree__write_to_string(child, symbol_names, *writer, limit,
false, include_anonymous);
}
if (visible)
cursor += snprintf(*writer, limit, ")");
return cursor - string;
}
char *ts_tree_string(const TSTree *self, const char **symbol_names,
bool include_anonymous) {
static char SCRATCH[1];
size_t size = 1 + ts_tree__write_to_string(self, symbol_names, SCRATCH, 0,
true, include_anonymous);
char *result = ts_malloc(size * sizeof(char));
ts_tree__write_to_string(self, symbol_names, result, size, true,
include_anonymous);
return result;
}
static inline long min(long a, long b) {
return a <= b ? a : b;
}

2
src/runtime/tree.h
View file

@ -50,8 +50,6 @@ void ts_tree_retain(TSTree *tree);
void ts_tree_release(TSTree *tree);
bool ts_tree_eq(const TSTree *tree1, const TSTree *tree2);
int ts_tree_compare(const TSTree *tree1, const TSTree *tree2);
char *ts_tree_string(const TSTree *tree, const char **names,
bool include_anonymous);
size_t ts_tree_start_column(const TSTree *self);
size_t ts_tree_end_column(const TSTree *self);