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

7
script/lint.sh
View file

@ -1,6 +1,9 @@
#!/usr/bin/env bash
filters=-whitespace,-readability/namespace,-legal/copyright
cpplint=externals/cpplint.py
find src/compiler -type f | xargs $cpplint --root=src --filter=$filters 2>&1
find src/compiler -type f | xargs $cpplint \
--root=src \
--linelength=110 \
--filter=-readability/namespace,-legal/copyright \
2>&1

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);
}
}

27
src/compiler/generate_code/c_code.cc
View file

@ -123,7 +123,8 @@ namespace tree_sitter {
return result;
}
string code_for_parse_actions(const set<ParseAction> &actions, const set<rules::Symbol> &expected_inputs) {
string code_for_parse_actions(const set<ParseAction> &actions,
const set<rules::Symbol> &expected_inputs) {
auto action = actions.begin();
switch (action->type) {
case ParseActionTypeAccept:
@ -131,7 +132,10 @@ namespace tree_sitter {
case ParseActionTypeShift:
return "SHIFT(" + to_string(action->state_index) + ");";
case ParseActionTypeReduce:
return "REDUCE(" + symbol_id(action->symbol) + ", " + to_string(action->child_flags.size()) + ", COLLAPSE({" + collapse_flags(action->child_flags) + "}));";
return "REDUCE(" +
symbol_id(action->symbol) + ", " +
to_string(action->child_flags.size()) + ", " +
"COLLAPSE({" + collapse_flags(action->child_flags) + "}));";
default:
return "";
}
@ -149,7 +153,8 @@ namespace tree_sitter {
return result;
}
string code_for_lex_actions(const set<LexAction> &actions, const set<rules::CharacterSet> &expected_inputs) {
string code_for_lex_actions(const set<LexAction> &actions,
const set<rules::CharacterSet> &expected_inputs) {
auto action = actions.begin();
if (action == actions.end()) {
return "LEX_ERROR();";
@ -169,7 +174,8 @@ namespace tree_sitter {
string body = "";
auto expected_inputs = parse_state.expected_inputs();
for (auto pair : parse_state.actions)
body += _case(symbol_id(pair.first), code_for_parse_actions(pair.second, expected_inputs));
body += _case(symbol_id(pair.first),
code_for_parse_actions(pair.second, expected_inputs));
body += _default(parse_error_call(expected_inputs));
return
string("SET_LEX_STATE(") + to_string(parse_state.lex_state_id) + ");\n" +
@ -180,7 +186,8 @@ namespace tree_sitter {
string result = "";
auto expected_inputs = parse_state.expected_inputs();
for (auto pair : parse_state.actions)
result += _if(condition_for_character_rule(pair.first), code_for_lex_actions(pair.second, expected_inputs));
result += _if(condition_for_character_rule(pair.first),
code_for_lex_actions(pair.second, expected_inputs));
result += code_for_lex_actions(parse_state.default_actions, expected_inputs);
return result;
}
@ -223,7 +230,9 @@ namespace tree_sitter {
}
string recover_case(ParseStateId state, set<rules::Symbol> symbols) {
string result = "RECOVER(" + to_string(state) + ", " + to_string(symbols.size()) + ", EXPECT({";
string result = "RECOVER(" +
to_string(state) + ", " +
to_string(symbols.size()) + ", EXPECT({";
bool started = false;
for (auto &symbol : symbols) {
if (started) {
@ -239,13 +248,15 @@ namespace tree_sitter {
string cases;
for (auto &pair : parse_table.error_table) {
auto pair_for_state = pair.second;
cases += _case(to_string(pair.first), recover_case(pair_for_state.first, pair_for_state.second));
cases += _case(to_string(pair.first),
recover_case(pair_for_state.first, pair_for_state.second));
}
cases += _default(recover_case(0, set<rules::Symbol>()));
string body = _switch("state", cases);
return join({
"static const ts_symbol * ts_recover(ts_state state, ts_state *to_state, size_t *count) {",
"static const ts_symbol * "
"ts_recover(ts_state state, ts_state *to_state, size_t *count) {",
indent(body),
"}"
});

5
src/compiler/parse_table.cc
View file

@ -9,7 +9,10 @@ namespace tree_sitter {
using std::vector;
using rules::Symbol;
ParseAction::ParseAction(ParseActionType type, size_t state_index, Symbol symbol, const vector<bool> &child_flags) :
ParseAction::ParseAction(ParseActionType type,
size_t state_index,
Symbol symbol,
const vector<bool> &child_flags) :
type(type),
symbol(symbol),
state_index(state_index),

5
src/compiler/parse_table.h
View file

@ -17,7 +17,10 @@ namespace tree_sitter {
} ParseActionType;
class ParseAction {
ParseAction(ParseActionType type, size_t state_index, rules::Symbol symbol, const std::vector<bool> &child_flags);
ParseAction(ParseActionType type,
size_t state_index,
rules::Symbol symbol,
const std::vector<bool> &child_flags);
public:
static ParseAction Accept();
static ParseAction Error();

2
src/compiler/rules/repeat.cc
View file

@ -4,7 +4,7 @@
namespace tree_sitter {
using std::string;
namespace rules {
Repeat::Repeat(const rule_ptr content) : content(content) {}

2
src/compiler/rules/rule.cc
View file

@ -4,7 +4,7 @@
namespace tree_sitter {
using std::ostream;
using std::string;
namespace rules {
bool Rule::operator!=(const Rule &other) const {
return !this->operator==(other);

2
src/compiler/rules/string.cc
View file

@ -5,7 +5,7 @@
namespace tree_sitter {
using std::string;
using std::hash;
namespace rules {
String::String(string value) : value(value) {}

2
src/compiler/rules/symbol.cc
View file

@ -6,7 +6,7 @@
namespace tree_sitter {
using std::string;
using std::hash;
namespace rules {
Symbol::Symbol(const std::string &name) : name(name), type(SymbolTypeNormal) {}
Symbol::Symbol(const std::string &name, SymbolType type) : name(name), type(type) {}