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

Fix some egregiously long lines

Browse source
This commit is contained in:
Max Brunsfeld 2014-03-09 23:51:33 -07:00
parent 39cb420df2
commit 3aaa08b948
21 changed files with 117 additions and 49 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -46,7 +46,10 @@ namespace tree_sitter {
parse_table.add_action(state_id, symbol, ParseAction::Shift(new_state_id));
if (symbol == rules::ERROR) {
parse_table.error_table.insert({ state_id, { new_state_id, first_set(transition.second, grammar) } });
parse_table.error_table.insert({
state_id,
{ new_state_id, first_set(transition.second, grammar) }
});
}
}
}
@ -116,10 +119,14 @@ namespace tree_sitter {
void add_error_lex_state() {
LexItemSet error_item_set;
for (auto &pair : lex_grammar.rules)
error_item_set.insert(LexItem(Symbol(pair.first), pair.second));
for (auto &pair : lex_grammar.aux_rules)
error_item_set.insert(LexItem(Symbol(pair.first, rules::SymbolTypeAuxiliary), pair.second));
for (auto &pair : lex_grammar.rules) {
LexItem item(Symbol(pair.first, rules::SymbolTypeNormal), pair.second);
error_item_set.insert(item);
}
for (auto &pair : lex_grammar.aux_rules) {
LexItem item(Symbol(pair.first, rules::SymbolTypeAuxiliary), pair.second);
error_item_set.insert(item);
}
add_advance_actions(error_item_set, LexTable::ERROR_STATE_ID);
add_accept_token_actions(error_item_set, LexTable::ERROR_STATE_ID);
}
@ -146,7 +153,8 @@ namespace tree_sitter {
lex_grammar(lex_grammar) {}
pair<ParseTable, LexTable> build() {
ParseItem item(rules::START, make_shared<Symbol>(grammar.start_rule_name), {}, rules::END_OF_INPUT);
auto start_symbol = make_shared<Symbol>(grammar.start_rule_name);
ParseItem item(rules::START, start_symbol, {}, rules::END_OF_INPUT);
ParseItemSet item_set = item_set_closure(ParseItemSet({ item }), grammar);
add_parse_state(item_set);
add_error_lex_state();
@ -154,7 +162,8 @@ namespace tree_sitter {
}
};
pair<ParseTable, LexTable> build_tables(const PreparedGrammar &grammar, const PreparedGrammar &lex_grammar) {
pair<ParseTable, LexTable> build_tables(const PreparedGrammar &grammar,
const PreparedGrammar &lex_grammar) {
return TableBuilder(grammar, lex_grammar).build();
}
}

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

@ -9,7 +9,8 @@ namespace tree_sitter {
class PreparedGrammar;
namespace build_tables {
std::pair<ParseTable, LexTable> build_tables(const PreparedGrammar &grammar, const PreparedGrammar &lex_grammar);
std::pair<ParseTable, LexTable> build_tables(const PreparedGrammar &grammar,
const PreparedGrammar &lex_grammar);
}
}

6
src/compiler/build_tables/first_set.h
View file

@ -15,13 +15,15 @@ namespace tree_sitter {
* the beginning of a string derivable from a given rule,
* in a given gramamr.
*/
std::set<rules::Symbol> first_set(const rules::rule_ptr &rule, const PreparedGrammar &grammar);
std::set<rules::Symbol>
first_set(const rules::rule_ptr &rule, const PreparedGrammar &grammar);
/*
* Returns the set of terminal symbols that can appear at
* the beginning of any item in the given set.
*/
std::set<rules::Symbol> first_set(const ParseItemSet &item_set, const PreparedGrammar &grammar);
std::set<rules::Symbol>
first_set(const ParseItemSet &item_set, const PreparedGrammar &grammar);
}
}

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

@ -11,7 +11,8 @@ namespace tree_sitter {
using rules::rule_ptr;
namespace build_tables {
map<Symbol, set<Symbol>> follow_sets(const ParseItem &item, const PreparedGrammar &grammar) {
map<Symbol, set<Symbol>> follow_sets(const ParseItem &item,
const PreparedGrammar &grammar) {
map<Symbol, set<Symbol>> result;
for (auto &pair : sym_transitions(item.rule)) {

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

@ -17,7 +17,8 @@ namespace tree_sitter {
* item. The values are the sets of terminals which can appear immediately
* after the corresponding non-terminals.
*/
std::map<rules::Symbol, std::set<rules::Symbol>> follow_sets(const ParseItem &item, const PreparedGrammar &grammar);
std::map<rules::Symbol, std::set<rules::Symbol>>
follow_sets(const ParseItem &item, const PreparedGrammar &grammar);
}
}

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

@ -67,7 +67,10 @@ namespace tree_sitter {
return lhs_eq && rules_eq;
}
ParseItem::ParseItem(const Symbol &lhs, const rule_ptr rule, const vector<bool> &consumed_symbols, const Symbol &lookahead_sym) :
ParseItem::ParseItem(const Symbol &lhs,
const rule_ptr rule,
const vector<bool> &consumed_symbols,
const Symbol &lookahead_sym) :
Item(lhs, rule),
consumed_symbols(consumed_symbols),
lookahead_sym(lookahead_sym) {}

5
src/compiler/build_tables/item.h
View file

@ -28,7 +28,10 @@ namespace tree_sitter {
class ParseItem : public Item {
public:
ParseItem(const rules::Symbol &lhs, const rules::rule_ptr rule, const std::vector<bool> &consumed_symbols, const rules::Symbol &lookahead_sym);
ParseItem(const rules::Symbol &lhs,
const rules::rule_ptr rule,
const std::vector<bool> &consumed_symbols,
const rules::Symbol &lookahead_sym);
bool operator<(const ParseItem &other) const;
bool operator==(const ParseItem &other) const;

10
src/compiler/build_tables/item_set_closure.cc
View file

@ -12,10 +12,13 @@ namespace tree_sitter {
namespace build_tables {
static bool contains(const ParseItemSet *items, const ParseItem &item) {
return items->size() > 0 && (std::find(items->begin(), items->end(), item) != items->end());
if (items->empty()) return false;
return (std::find(items->begin(), items->end(), item) != items->end());
}
static void add_item(ParseItemSet *item_set, const ParseItem &item, const PreparedGrammar &grammar) {
static void add_item(ParseItemSet *item_set,
const ParseItem &item,
const PreparedGrammar &grammar) {
if (!contains(item_set, item)) {
item_set->insert(item);
for (auto &pair : follow_sets(item, grammar)) {
@ -29,7 +32,8 @@ namespace tree_sitter {
}
}
const ParseItemSet item_set_closure(const ParseItemSet &item_set, const PreparedGrammar &grammar) {
const ParseItemSet item_set_closure(const ParseItemSet &item_set,
const PreparedGrammar &grammar) {
ParseItemSet result;
for (ParseItem item : item_set)
add_item(&result, item, grammar);

3
src/compiler/build_tables/item_set_closure.h
View file

@ -7,7 +7,8 @@ namespace tree_sitter {
class PreparedGrammar;
namespace build_tables {
const ParseItemSet item_set_closure(const ParseItemSet &item_set, const PreparedGrammar &grammar);
const ParseItemSet item_set_closure(const ParseItemSet &item_set,
const PreparedGrammar &grammar);
}
}

20
src/compiler/build_tables/item_set_transitions.cc
View file

@ -11,7 +11,8 @@ namespace tree_sitter {
using rules::Symbol;
namespace build_tables {
map<CharacterSet, LexItemSet> char_transitions(const LexItem &item) {
map<CharacterSet, LexItemSet>
char_transitions(const LexItem &item) {
map<CharacterSet, LexItemSet> result;
for (auto &transition : char_transitions(item.rule)) {
LexItem next_item(item.lhs, transition.second);
@ -20,7 +21,8 @@ namespace tree_sitter {
return result;
}
map<Symbol, ParseItemSet> sym_transitions(const ParseItem &item, const PreparedGrammar &grammar) {
map<Symbol, ParseItemSet>
sym_transitions(const ParseItem &item, const PreparedGrammar &grammar) {
map<Symbol, ParseItemSet> result;
for (auto transition : sym_transitions(item.rule)) {
Symbol rule = transition.first;
@ -39,22 +41,28 @@ namespace tree_sitter {
return result;
}
map<CharacterSet, LexItemSet> char_transitions(const LexItemSet &item_set, const PreparedGrammar &grammar) {
map<CharacterSet, LexItemSet>
char_transitions(const LexItemSet &item_set, const PreparedGrammar &grammar) {
map<CharacterSet, LexItemSet> result;
for (const LexItem &item : item_set) {
map<CharacterSet, LexItemSet> item_transitions = char_transitions(item);
result = merge_char_transitions<LexItemSet>(result, item_transitions, [](LexItemSet left, LexItemSet right) {
result = merge_char_transitions<LexItemSet>(result,
item_transitions,
[](LexItemSet left, LexItemSet right) {
return merge_sets(left, right);
});
}
return result;
}
map<Symbol, ParseItemSet> sym_transitions(const ParseItemSet &item_set, const PreparedGrammar &grammar) {
map<Symbol, ParseItemSet>
sym_transitions(const ParseItemSet &item_set, const PreparedGrammar &grammar) {
map<Symbol, ParseItemSet> result;
for (const ParseItem &item : item_set) {
map<Symbol, ParseItemSet> item_transitions = sym_transitions(item, grammar);
result = merge_sym_transitions<ParseItemSet>(result, item_transitions, [&](ParseItemSet left, ParseItemSet right) {
result = merge_sym_transitions<ParseItemSet>(result,
item_transitions,
[&](ParseItemSet left, ParseItemSet right) {
return merge_sets(left, right);
});
}

7
src/compiler/build_tables/item_set_transitions.h
View file

@ -12,8 +12,11 @@ namespace tree_sitter {
}
namespace build_tables {
std::map<rules::CharacterSet, LexItemSet> char_transitions(const LexItemSet &item_set, const PreparedGrammar &grammar);
std::map<rules::Symbol, ParseItemSet> sym_transitions(const ParseItemSet &item_set, const PreparedGrammar &grammar);
std::map<rules::CharacterSet, LexItemSet>
char_transitions(const LexItemSet &item_set, const PreparedGrammar &grammar);
std::map<rules::Symbol, ParseItemSet>
sym_transitions(const ParseItemSet &item_set, const PreparedGrammar &grammar);
}
}

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

@ -24,7 +24,8 @@ namespace tree_sitter {
map<T, rule_ptr> merge_transitions(const map<T, rule_ptr> &left, const map<T, rule_ptr> &right);
template<>
map<CharacterSet, rule_ptr> merge_transitions(const map<CharacterSet, rule_ptr> &left, const map<CharacterSet, rule_ptr> &right) {
map<CharacterSet, rule_ptr>
merge_transitions(const map<CharacterSet, rule_ptr> &left, const map<CharacterSet, rule_ptr> &right) {
auto transitions = merge_char_transitions<rule_ptr>(left, right, [](rule_ptr left, rule_ptr right) {
return make_shared<rules::Choice>(left, right);
});
@ -32,7 +33,8 @@ namespace tree_sitter {
}
template<>
map<Symbol, rule_ptr> merge_transitions(const map<Symbol, rule_ptr> &left, const map<Symbol, rule_ptr> &right) {
map<Symbol, rule_ptr>
merge_transitions(const map<Symbol, rule_ptr> &left, const map<Symbol, rule_ptr> &right) {
auto transitions = merge_sym_transitions<rule_ptr>(left, right, [](rule_ptr left, rule_ptr right) {
return make_shared<rules::Choice>(left, right);
});
@ -40,7 +42,8 @@ namespace tree_sitter {
}
template<typename T>
map<T, rule_ptr> map_transitions(const map<T, rule_ptr> &initial, std::function<const rule_ptr(rule_ptr)> map_fn) {
map<T, rule_ptr>
map_transitions(const map<T, rule_ptr> &initial, std::function<const rule_ptr(rule_ptr)> map_fn) {
map<T, rule_ptr> result;
for (auto &pair : initial)
result.insert({ pair.first, map_fn(pair.second) });
@ -79,14 +82,20 @@ namespace tree_sitter {
void visit(const rules::Repeat *rule) {
this->value = map_transitions(this->apply(rule->content), [&](const rule_ptr &value) {
return rules::Seq::Build({ value, make_shared<rules::Choice>(rule->copy(), make_shared<rules::Blank>()) });
return rules::Seq::Build({
value,
make_shared<rules::Choice>(rule->copy(), make_shared<rules::Blank>())
});
});
}
void visit(const rules::String *rule) {
rule_ptr result = make_shared<rules::Blank>();
for (char val : rule->value)
result = rules::Seq::Build({ result, make_shared<CharacterSet>(set<rules::CharacterRange>({ val })) });
result = rules::Seq::Build({
result,
make_shared<CharacterSet>(set<rules::CharacterRange>({ val }))
});
this->value = this->apply(result);
}

7
src/compiler/build_tables/rule_transitions.h
View file

@ -7,8 +7,11 @@
namespace tree_sitter {
namespace build_tables {
std::map<rules::CharacterSet, rules::rule_ptr> char_transitions(const rules::rule_ptr &rule);
std::map<rules::Symbol, rules::rule_ptr> sym_transitions(const rules::rule_ptr &rule);
std::map<rules::CharacterSet, rules::rule_ptr>
char_transitions(const rules::rule_ptr &rule);
std::map<rules::Symbol, rules::rule_ptr>
sym_transitions(const rules::rule_ptr &rule);
}
}