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

Extract shared helper functions from example grammars

Browse source
This commit is contained in:
Max Brunsfeld 2014-04-27 21:45:05 -07:00
parent 29bbff655c
commit b86203d205
8 changed files with 1888 additions and 1507 deletions
Download patch file Download diff file Expand all files Collapse all files

24
examples/grammars/arithmetic.cc
View file

@ -1,16 +1,9 @@
#include "tree_sitter/compiler.h"
#include "helpers.h"
namespace tree_sitter_examples {
using tree_sitter::Grammar;
using namespace tree_sitter::rules;
using std::string;
static rule_ptr infix_op(string op, int precedence) {
return prec(precedence, seq({
sym("expression"),
str(op),
sym("expression") }));
}
extern const Grammar arithmetic({
{ "expression", choice({
@ -23,15 +16,12 @@ namespace tree_sitter_examples {
sym("number"),
sym("variable") }) },
{ "sum", infix_op("+", 1) },
{ "difference", infix_op("-", 1) },
{ "product", infix_op("*", 2) },
{ "quotient", infix_op("/", 2) },
{ "exponent", infix_op("^", 3) },
{ "group", seq({
str("("),
err(sym("expression")),
str(")") }) },
{ "sum", infix(1, "+") },
{ "difference", infix(1, "-") },
{ "product", infix(2, "*") },
{ "quotient", infix(2, "/") },
{ "exponent", infix(3, "^") },
{ "group", in_parens(err(sym("expression"))) },
{ "number", pattern("\\d+") },
{ "variable", pattern("\\a[\\w_]*") },

39
examples/grammars/golang.cc
View file

@ -1,25 +1,10 @@
#include "tree_sitter/compiler.h"
#include "helpers.h"
namespace tree_sitter_examples {
using tree_sitter::Grammar;
using namespace tree_sitter::rules;
static rule_ptr comma_sep1(rule_ptr element) {
return seq({ element, repeat(seq({ str(","), element })) });
}
static rule_ptr comma_sep(rule_ptr element) {
return choice({ comma_sep1(element), blank() });
}
static rule_ptr in_parens(rule_ptr rule) {
return seq({ str("("), rule, str(")") });
}
static rule_ptr in_braces(rule_ptr rule) {
return seq({ str("{"), rule, str("}") });
}
extern const Grammar golang({
{ "program", seq({
sym("package_directive"),
@ -57,8 +42,6 @@ namespace tree_sitter_examples {
sym("_func_signature"),
sym("statement_block") }) },
{ "statement_block", in_braces(blank()) },
{ "expression", choice({
sym("number") }) },
{ "type_expression", choice({
sym("pointer_type"),
sym("slice_type"),
@ -93,6 +76,26 @@ namespace tree_sitter_examples {
sym("_func_signature") }))) }) },
// Value expressions
{ "expression", choice({
sym("math_op"),
sym("bool_op"),
sym("number"),
sym("var_name") }) },
{ "math_op", choice({
infix(2, "*"),
infix(2, "/"),
infix(1, "+"),
infix(1, "-") }) },
{ "bool_op", choice({
infix(3, "&&"),
infix(2, "||"),
infix(2, "==="),
infix(2, "=="),
infix(2, "<="),
infix(4, "<"),
infix(2, ">="),
infix(2, ">"),
prefix(4, "!") }) },
{ "_func_signature", seq({
in_parens(comma_sep(seq({
comma_sep1(sym("var_name")),

42
examples/grammars/helpers.cc Normal file
View file

@ -0,0 +1,42 @@
#include "tree_sitter/compiler.h"
namespace tree_sitter_examples {
using namespace tree_sitter::rules;
rule_ptr comma_sep1(rule_ptr element) {
return seq({ element, repeat(seq({ str(","), element })) });
}
rule_ptr comma_sep(rule_ptr element) {
return choice({ comma_sep1(element), blank() });
}
rule_ptr optional(rule_ptr rule) {
return choice({ rule, blank() });
}
rule_ptr in_parens(rule_ptr rule) {
return seq({ str("("), rule, str(")") });
}
rule_ptr in_braces(rule_ptr rule) {
return seq({ str("{"), rule, str("}") });
}
rule_ptr in_brackets(rule_ptr rule) {
return seq({ str("["), rule, str("]") });
}
rule_ptr infix(int precedence, std::string op) {
return prec(precedence, seq({
sym("expression"),
str(op),
sym("expression") }));
}
rule_ptr prefix(int precedence, std::string op) {
return prec(precedence, seq({
str(op),
sym("expression") }));
}
}

19
examples/grammars/helpers.h Normal file
View file

@ -0,0 +1,19 @@
#ifndef TREESITTER_EXAMPLES_HELPERS_
#define TREESITTER_EXAMPLES_HELPERS_
#include "tree_sitter/compiler.h"
namespace tree_sitter_examples {
using namespace tree_sitter::rules;
rule_ptr comma_sep1(rule_ptr element);
rule_ptr comma_sep(rule_ptr element);
rule_ptr optional(rule_ptr rule);
rule_ptr in_parens(rule_ptr rule);
rule_ptr in_braces(rule_ptr rule);
rule_ptr in_brackets(rule_ptr rule);
rule_ptr infix(int precedence, std::string op);
rule_ptr prefix(int precedence, std::string op);
}
#endif // TREESITTER_EXAMPLES_HELPERS_

41
examples/grammars/javascript.cc
View file

@ -1,44 +1,10 @@
#include "tree_sitter/compiler.h"
#include "helpers.h"
namespace tree_sitter_examples {
using tree_sitter::Grammar;
using namespace tree_sitter::rules;
static rule_ptr optional(rule_ptr rule) {
return choice({ rule, blank() });
}
static rule_ptr in_parens(rule_ptr rule) {
return seq({ str("("), rule, str(")") });
}
static rule_ptr in_braces(rule_ptr rule) {
return seq({ str("{"), rule, str("}") });
}
static rule_ptr in_brackets(rule_ptr rule) {
return seq({ str("["), rule, str("]") });
}
static rule_ptr comma_sep(rule_ptr element) {
return choice({
seq({ element, repeat(seq({ str(","), element })) }),
blank() });
}
static rule_ptr infix(int precedence, std::string op) {
return prec(precedence, seq({
sym("expression"),
str(op),
sym("expression") }));
}
static rule_ptr prefix(int precedence, std::string op) {
return prec(precedence, seq({
str(op),
sym("expression") }));
}
extern const Grammar javascript({
{ "program", repeat(sym("statement")) },
@ -73,9 +39,7 @@ namespace tree_sitter_examples {
sym("statement") }))) }) },
{ "switch_statement", seq({
sym("_switch"),
str("("),
err(sym("expression")),
str(")"),
in_parens(err(sym("expression"))),
in_braces(repeat(sym("switch_case"))) }) },
{ "switch_case", seq({
choice({
@ -113,7 +77,6 @@ namespace tree_sitter_examples {
sym("property_access"),
sym("assignment"),
sym("ternary"),
sym("literal"),
sym("math_op"),
sym("bool_op"),
sym("literal"),

24
examples/grammars/json.cc
View file

@ -1,16 +1,10 @@
#include "tree_sitter/compiler.h"
#include "helpers.h"
namespace tree_sitter_examples {
using tree_sitter::Grammar;
using namespace tree_sitter::rules;
static rule_ptr comma_sep(rule_ptr rule) {
return choice({
seq({ rule, repeat(seq({ str(","), rule })) }),
blank(),
});
}
extern const Grammar json({
{ "value", choice({
sym("object"),
@ -20,17 +14,11 @@ namespace tree_sitter_examples {
sym("true"),
sym("false"),
sym("null"), }) },
{ "object", seq({
str("{"),
comma_sep(err(seq({
sym("string"),
str(":"),
sym("value") }))),
str("}"), }) },
{ "array", seq({
str("["),
comma_sep(err(sym("value"))),
str("]"), }) },
{ "object", in_braces(comma_sep(err(seq({
sym("string"),
str(":"),
sym("value") })))) },
{ "array", in_brackets(comma_sep(err(sym("value")))) },
{ "string", pattern("\"([^\"]|\\\\\")+\"") },
{ "number", pattern("\\d+(\\.\\d+)?") },
{ "null", str("null") },

3203
examples/parsers/golang.c
View file

File diff suppressed because it is too large Load diff

3
src/compiler/build_tables/follow_sets.cc
View file

@ -12,9 +12,8 @@ namespace tree_sitter {
namespace build_tables {
map<ISymbol, set<ISymbol>> follow_sets(const ParseItem &item,
const PreparedGrammar &grammar) {
const PreparedGrammar &grammar) {
map<ISymbol, set<ISymbol>> result;
for (auto &pair : sym_transitions(item.rule)) {
ISymbol symbol = pair.first;
rule_ptr next_rule = pair.second;