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

Remove custom LexicalGrammar and SyntaxGrammar constructors

Browse source
This commit is contained in:
Max Brunsfeld 2015-07-19 16:12:11 -07:00
parent 5d41d23ab1
commit 31b2db12d2
15 changed files with 101 additions and 151 deletions
Download patch file Download diff file Expand all files Collapse all files

13
src/compiler/lexical_grammar.cc
View file

@ -11,19 +11,6 @@ using std::pair;
using std::vector;
using std::set;
LexicalGrammar::LexicalGrammar() {}
LexicalGrammar::LexicalGrammar(
const vector<pair<string, rules::rule_ptr>> &rules,
const vector<pair<string, rules::rule_ptr>> &aux_rules)
: rules(rules), aux_rules(aux_rules) {}
LexicalGrammar::LexicalGrammar(
const vector<pair<string, rules::rule_ptr>> &rules,
const vector<pair<string, rules::rule_ptr>> &aux_rules,
const vector<rules::rule_ptr> &separators)
: rules(rules), aux_rules(aux_rules), separators(separators) {}
const rules::rule_ptr &LexicalGrammar::rule(const rules::Symbol &symbol) const {
return symbol.is_auxiliary() ? aux_rules[symbol.index].second
: rules[symbol.index].second;

13
src/compiler/lexical_grammar.h
View file

@ -11,20 +11,11 @@ namespace tree_sitter {
class LexicalGrammar {
public:
LexicalGrammar();
LexicalGrammar(
const std::vector<std::pair<std::string, rules::rule_ptr>> &rules,
const std::vector<std::pair<std::string, rules::rule_ptr>> &aux_rules);
LexicalGrammar(
const std::vector<std::pair<std::string, rules::rule_ptr>> &rules,
const std::vector<std::pair<std::string, rules::rule_ptr>> &aux_rules,
const std::vector<rules::rule_ptr> &separators);
const std::string &rule_name(const rules::Symbol &symbol) const;
const rules::rule_ptr &rule(const rules::Symbol &symbol) const;
const std::vector<std::pair<std::string, rules::rule_ptr>> rules;
const std::vector<std::pair<std::string, rules::rule_ptr>> aux_rules;
std::vector<std::pair<std::string, rules::rule_ptr>> rules;
std::vector<std::pair<std::string, rules::rule_ptr>> aux_rules;
std::vector<rules::rule_ptr> separators;
};

21
src/compiler/prepare_grammar/expand_repeats.cc
View file

@ -67,19 +67,18 @@ class ExpandRepeats : public rules::IdentityRuleFn {
};
SyntaxGrammar expand_repeats(const SyntaxGrammar &grammar) {
vector<pair<string, rules::rule_ptr>> rules, aux_rules(grammar.aux_rules);
SyntaxGrammar result;
result.aux_rules = grammar.aux_rules;
result.ubiquitous_tokens = grammar.ubiquitous_tokens;
result.expected_conflicts = grammar.expected_conflicts;
ExpandRepeats expander(aux_rules.size());
ExpandRepeats expander(result.aux_rules.size());
for (auto &pair : grammar.rules)
result.rules.push_back({ pair.first, expander.expand(pair.second, pair.first) });
for (auto &pair : grammar.rules) {
rules.push_back({ pair.first, expander.expand(pair.second, pair.first) });
}
aux_rules.insert(aux_rules.end(), expander.aux_rules.begin(),
expander.aux_rules.end());
return SyntaxGrammar(rules, aux_rules, grammar.ubiquitous_tokens,
grammar.expected_conflicts);
result.aux_rules.insert(result.aux_rules.end(), expander.aux_rules.begin(),
expander.aux_rules.end());
return result;
}
} // namespace prepare_grammar

21
src/compiler/prepare_grammar/expand_tokens.cc
View file

@ -56,34 +56,33 @@ class ExpandTokens : public rules::IdentityRuleFn {
ExpandTokens() : error(nullptr) {}
};
pair<LexicalGrammar, const GrammarError *> expand_tokens(
const LexicalGrammar &grammar) {
vector<pair<string, rule_ptr>> rules, aux_rules;
vector<rule_ptr> separators;
pair<LexicalGrammar, const GrammarError *>
expand_tokens(const LexicalGrammar &grammar) {
LexicalGrammar result;
ExpandTokens expander;
for (auto &pair : grammar.rules) {
auto rule = expander.apply(pair.second);
if (expander.error)
return { LexicalGrammar(), expander.error };
rules.push_back({ pair.first, rule });
return { result, expander.error };
result.rules.push_back({ pair.first, rule });
}
for (auto &pair : grammar.aux_rules) {
auto rule = expander.apply(pair.second);
if (expander.error)
return { LexicalGrammar(), expander.error };
aux_rules.push_back({ pair.first, rule });
return { result, expander.error };
result.aux_rules.push_back({ pair.first, rule });
}
for (auto &sep : grammar.separators) {
auto rule = expander.apply(sep);
if (expander.error)
return { LexicalGrammar(), expander.error };
separators.push_back(rule);
return { result, expander.error };
result.separators.push_back(rule);
}
return { LexicalGrammar(rules, aux_rules, separators), nullptr, };
return { result, nullptr, };
}
} // namespace prepare_grammar

16
src/compiler/syntax_grammar.cc
View file

@ -7,22 +7,6 @@
namespace tree_sitter {
using std::string;
using std::pair;
using std::vector;
using std::set;
SyntaxGrammar::SyntaxGrammar() {}
SyntaxGrammar::SyntaxGrammar(const vector<pair<string, rules::rule_ptr>> &rules,
const vector<pair<string, rules::rule_ptr>> &aux_rules)
: rules(rules), aux_rules(aux_rules) {}
SyntaxGrammar::SyntaxGrammar(const vector<pair<string, rules::rule_ptr>> &rules,
const vector<pair<string, rules::rule_ptr>> &aux_rules,
const set<rules::Symbol> &ubiquitous_tokens,
const set<set<rules::Symbol>> &expected_conflicts)
: rules(rules), aux_rules(aux_rules),
ubiquitous_tokens(ubiquitous_tokens), expected_conflicts(expected_conflicts) {}
const rules::rule_ptr &SyntaxGrammar::rule(const rules::Symbol &symbol) const {
return symbol.is_auxiliary() ? aux_rules[symbol.index].second

14
src/compiler/syntax_grammar.h
View file

@ -12,21 +12,11 @@ namespace tree_sitter {
class SyntaxGrammar {
public:
SyntaxGrammar();
SyntaxGrammar(
const std::vector<std::pair<std::string, rules::rule_ptr>> &rules,
const std::vector<std::pair<std::string, rules::rule_ptr>> &aux_rules);
SyntaxGrammar(
const std::vector<std::pair<std::string, rules::rule_ptr>> &rules,
const std::vector<std::pair<std::string, rules::rule_ptr>> &aux_rules,
const std::set<rules::Symbol> &ubiquitous_tokens,
const std::set<std::set<rules::Symbol>> &expected_conflicts);
const std::string &rule_name(const rules::Symbol &symbol) const;
const rules::rule_ptr &rule(const rules::Symbol &symbol) const;
const std::vector<std::pair<std::string, rules::rule_ptr>> rules;
const std::vector<std::pair<std::string, rules::rule_ptr>> aux_rules;
std::vector<std::pair<std::string, rules::rule_ptr>> rules;
std::vector<std::pair<std::string, rules::rule_ptr>> aux_rules;
std::set<rules::Symbol> ubiquitous_tokens;
std::set<std::set<rules::Symbol>> expected_conflicts;
};