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

Remove whitespace between template closing tags

Browse source
This commit is contained in:
Max Brunsfeld 2014-10-12 11:50:36 -07:00
parent fb38140317
commit aae6f6de14
14 changed files with 41 additions and 41 deletions
Download patch file Download diff file Expand all files Collapse all files

6
src/compiler/build_tables/build_parse_table.cc
View file

@ -28,7 +28,7 @@ class ParseTableBuilder {
const SyntaxGrammar grammar;
ParseConflictManager conflict_manager;
unordered_map<const ParseItemSet, ParseStateId> parse_state_ids;
vector<pair<ParseItemSet, ParseStateId> > item_sets_to_process;
vector<pair<ParseItemSet, ParseStateId>> item_sets_to_process;
ParseTable parse_table;
ParseStateId add_parse_state(const ParseItemSet &item_set) {
@ -132,7 +132,7 @@ class ParseTableBuilder {
: grammar(grammar),
conflict_manager(ParseConflictManager(grammar, lex_grammar)) {}
pair<ParseTable, vector<Conflict> > build() {
pair<ParseTable, vector<Conflict>> build() {
auto start_symbol = grammar.rules.empty()
? make_shared<Symbol>(0, rules::SymbolOptionToken)
: make_shared<Symbol>(0);
@ -162,7 +162,7 @@ class ParseTableBuilder {
}
};
pair<ParseTable, vector<Conflict> > build_parse_table(
pair<ParseTable, vector<Conflict>> build_parse_table(
const SyntaxGrammar &grammar, const LexicalGrammar &lex_grammar) {
return ParseTableBuilder(grammar, lex_grammar).build();
}

2
src/compiler/build_tables/build_parse_table.h
View file

@ -11,7 +11,7 @@ class SyntaxGrammar;
class LexicalGrammar;
namespace build_tables {
std::pair<ParseTable, std::vector<Conflict> > build_parse_table(
std::pair<ParseTable, std::vector<Conflict>> build_parse_table(
const SyntaxGrammar &grammar, const LexicalGrammar &lex_grammar);
}
}

2
src/compiler/build_tables/build_tables.cc
View file

@ -10,7 +10,7 @@ using std::tuple;
using std::vector;
using std::make_tuple;
tuple<ParseTable, LexTable, vector<Conflict> > build_tables(
tuple<ParseTable, LexTable, vector<Conflict>> build_tables(
const SyntaxGrammar &grammar, const LexicalGrammar &lex_grammar) {
auto parse_table_result = build_parse_table(grammar, lex_grammar);
ParseTable parse_table = parse_table_result.first;

2
src/compiler/build_tables/build_tables.h
View file

@ -12,7 +12,7 @@ class SyntaxGrammar;
class LexicalGrammar;
namespace build_tables {
std::tuple<ParseTable, LexTable, std::vector<Conflict> > build_tables(
std::tuple<ParseTable, LexTable, std::vector<Conflict>> build_tables(
const SyntaxGrammar &grammar, const LexicalGrammar &lex_grammar);
}
}

5
src/compiler/build_tables/first_symbols.cc
View file

@ -14,7 +14,7 @@ namespace build_tables {
using std::set;
using rules::Symbol;
class FirstSymbols : public rules::RuleFn<set<Symbol> > {
class FirstSymbols : public rules::RuleFn<set<Symbol>> {
const SyntaxGrammar *grammar;
set<Symbol> visited_symbols;
@ -58,7 +58,8 @@ class FirstSymbols : public rules::RuleFn<set<Symbol> > {
}
};
set<Symbol> first_symbols(const rules::rule_ptr &rule, const SyntaxGrammar &grammar) {
set<Symbol> first_symbols(const rules::rule_ptr &rule,
const SyntaxGrammar &grammar) {
return FirstSymbols(&grammar).apply(rule);
}

2
src/compiler/build_tables/first_symbols.h
View file

@ -17,7 +17,7 @@ namespace build_tables {
* in a given grammar.
*/
std::set<rules::Symbol> first_symbols(const rules::rule_ptr &rule,
const SyntaxGrammar &grammar);
const SyntaxGrammar &grammar);
} // namespace build_tables
} // namespace tree_sitter

2
src/compiler/build_tables/parse_item.h
View file

@ -20,7 +20,7 @@ class ParseItem : public Item {
std::ostream &operator<<(std::ostream &stream, const ParseItem &item);
typedef std::unordered_map<ParseItem, std::set<rules::Symbol> > ParseItemSet;
typedef std::unordered_map<ParseItem, std::set<rules::Symbol>> ParseItemSet;
} // namespace build_tables
} // namespace tree_sitter

2
src/compiler/build_tables/rule_transitions.cc
View file

@ -45,7 +45,7 @@ void merge_transitions(map<Symbol, rule_ptr> *left,
}
template <typename T>
class RuleTransitions : public rules::RuleFn<map<T, rule_ptr> > {
class RuleTransitions : public rules::RuleFn<map<T, rule_ptr>> {
map<T, rule_ptr> apply_to_atom(const rules::Rule *rule) {
auto atom = dynamic_cast<const T *>(rule);
if (atom)

4
src/compiler/grammar.cc
View file

@ -10,7 +10,7 @@ using std::string;
using std::vector;
using rules::rule_ptr;
Grammar::Grammar(const std::vector<std::pair<std::string, rules::rule_ptr> > &rules)
Grammar::Grammar(const std::vector<std::pair<std::string, rules::rule_ptr>> &rules)
: rules_(rules), ubiquitous_tokens_({}) {}
bool Grammar::operator==(const Grammar &other) const {
@ -69,6 +69,6 @@ Grammar &Grammar::ubiquitous_tokens(const set<rule_ptr> &ubiquitous_tokens) {
return *this;
}
const vector<pair<string, rule_ptr> > &Grammar::rules() const { return rules_; }
const vector<pair<string, rule_ptr>> &Grammar::rules() const { return rules_; }
} // namespace tree_sitter

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

@ -47,11 +47,11 @@ class ExpandRepeats : public rules::IdentityRuleFn {
: rule_name(rule_name), offset(offset) {}
size_t offset;
vector<pair<string, rules::rule_ptr> > aux_rules;
vector<pair<string, rules::rule_ptr>> aux_rules;
};
SyntaxGrammar expand_repeats(const SyntaxGrammar &grammar) {
vector<pair<string, rules::rule_ptr> > rules, aux_rules(grammar.aux_rules);
vector<pair<string, rules::rule_ptr>> rules, aux_rules(grammar.aux_rules);
for (auto &pair : grammar.rules) {
ExpandRepeats expander(pair.first, aux_rules.size());

2
src/compiler/prepare_grammar/intern_symbols.cc
View file

@ -48,7 +48,7 @@ pair<Grammar, const GrammarError *> missing_rule_error(string rule_name) {
pair<Grammar, const GrammarError *> intern_symbols(const Grammar &grammar) {
InternSymbols interner(grammar);
vector<pair<string, rule_ptr> > rules;
vector<pair<string, rule_ptr>> rules;
for (auto &pair : grammar.rules()) {
auto new_rule = interner.apply(pair.second);

24
src/compiler/prepared_grammar.cc
View file

@ -25,30 +25,28 @@ PreparedGrammar::PreparedGrammar() {}
SyntaxGrammar::SyntaxGrammar() {}
LexicalGrammar::LexicalGrammar() {}
SyntaxGrammar::SyntaxGrammar(
const vector<pair<string, rules::rule_ptr> > &rules,
const vector<pair<string, rules::rule_ptr> > &aux_rules)
SyntaxGrammar::SyntaxGrammar(const vector<pair<string, rules::rule_ptr>> &rules,
const vector<pair<string, rules::rule_ptr>> &aux_rules)
: PreparedGrammar(rules, aux_rules) {}
LexicalGrammar::LexicalGrammar(
const vector<pair<string, rules::rule_ptr> > &rules,
const vector<pair<string, rules::rule_ptr> > &aux_rules)
const vector<pair<string, rules::rule_ptr>> &rules,
const vector<pair<string, rules::rule_ptr>> &aux_rules)
: PreparedGrammar(rules, aux_rules) {}
PreparedGrammar::PreparedGrammar(
const vector<pair<string, rules::rule_ptr> > &rules,
const vector<pair<string, rules::rule_ptr> > &aux_rules)
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)
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)
: PreparedGrammar(rules, aux_rules), ubiquitous_tokens(ubiquitous_tokens) {}
LexicalGrammar::LexicalGrammar(
const vector<pair<string, rules::rule_ptr> > &rules,
const vector<pair<string, rules::rule_ptr> > &aux_rules,
const vector<pair<string, rules::rule_ptr>> &rules,
const vector<pair<string, rules::rule_ptr>> &aux_rules,
const vector<rules::rule_ptr> &separators)
: PreparedGrammar(rules, aux_rules), separators(separators) {}

24
src/compiler/prepared_grammar.h
View file

@ -14,11 +14,11 @@ class PreparedGrammar {
public:
PreparedGrammar();
PreparedGrammar(
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<std::pair<std::string, rules::rule_ptr>> &rules,
const std::vector<std::pair<std::string, rules::rule_ptr>> &aux_rules);
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<std::pair<std::string, rules::rule_ptr>> rules;
const std::vector<std::pair<std::string, rules::rule_ptr>> aux_rules;
const std::string &rule_name(const rules::Symbol &symbol) const;
const rules::rule_ptr &rule(const rules::Symbol &symbol) const;
@ -28,11 +28,11 @@ class SyntaxGrammar : public PreparedGrammar {
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);
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::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);
std::set<rules::Symbol> ubiquitous_tokens;
@ -42,11 +42,11 @@ class LexicalGrammar : public PreparedGrammar {
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);
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<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);
std::vector<rules::rule_ptr> separators;

1
src/compiler/rules/visitor.h
View file

@ -43,6 +43,7 @@ class RuleFn : private Visitor {
protected:
virtual T default_apply(const Rule *rule) { return T(); }
virtual T apply_to(const Blank *rule) {
return default_apply((const Rule *)rule);
}