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

Tweak auto-format settings

Browse source 
Prefer lines that exceed 80 characters by a small margin to
line breaks in argument lists
This commit is contained in:
Max Brunsfeld 2014-09-09 13:15:40 -07:00
parent e9dad529f5
commit 2e7ffb4d14
19 changed files with 42 additions and 61 deletions
Download patch file Download diff file Expand all files Collapse all files

2
.clang-format
View file

@ -25,7 +25,7 @@ PenaltyBreakBeforeFirstCallParameter: 1
PenaltyBreakComment: 60
PenaltyBreakString: 1000
PenaltyBreakFirstLessLess: 120
PenaltyExcessCharacter: 1000000
PenaltyExcessCharacter: 20
PenaltyReturnTypeOnItsOwnLine: 200
PointerBindsToType: true
SpacesBeforeTrailingComments: 2

13
include/tree_sitter/compiler.h
View file

@ -32,18 +32,17 @@ std::ostream &operator<<(std::ostream &stream, const rules::rule_ptr &rule);
} // namespace rules
class Grammar {
const std::vector<std::pair<std::string, rules::rule_ptr> > rules_;
const std::vector<std::pair<std::string, rules::rule_ptr>> rules_;
std::set<rules::rule_ptr> ubiquitous_tokens_;
public:
Grammar(const std::vector<std::pair<std::string, rules::rule_ptr> > &rules);
bool operator==(const Grammar &other) const;
explicit Grammar(const std::vector<std::pair<std::string, rules::rule_ptr>> &);
bool operator==(const Grammar &) const;
std::string start_rule_name() const;
const rules::rule_ptr rule(const std::string &name) const;
const std::vector<std::pair<std::string, rules::rule_ptr> > &rules() const;
const rules::rule_ptr rule(const std::string &) const;
const std::vector<std::pair<std::string, rules::rule_ptr>> &rules() const;
const std::set<rules::rule_ptr> &ubiquitous_tokens() const;
Grammar &ubiquitous_tokens(
const std::set<rules::rule_ptr> &ubiquitous_tokens);
Grammar &ubiquitous_tokens(const std::set<rules::rule_ptr> &);
};
struct Conflict {

19
include/tree_sitter/parser.h
View file

@ -138,16 +138,15 @@ struct TSLanguage {
#define ACCEPT_INPUT() \
{ .type = TSParseActionTypeAccept }
#define EXPORT_LANGUAGE(language_name) \
static TSLanguage language = { \
.symbol_count = SYMBOL_COUNT, \
.hidden_symbol_flags = ts_hidden_symbol_flags, \
.parse_table = (const TSParseAction *)ts_parse_actions, \
.lex_states = ts_lex_states, \
.symbol_names = ts_symbol_names, \
.lex_fn = ts_lex, \
}; \
\
#define EXPORT_LANGUAGE(language_name) \
static TSLanguage language = { .symbol_count = SYMBOL_COUNT, \
.hidden_symbol_flags = ts_hidden_symbol_flags, \
.parse_table = \
(const TSParseAction *)ts_parse_actions, \
.lex_states = ts_lex_states, \
.symbol_names = ts_symbol_names, \
.lex_fn = ts_lex, }; \
\
const TSLanguage *language_name() { return &language; }
#ifdef __cplusplus

4
script/lint.sh
View file

@ -10,5 +10,5 @@ fi
FILTERS='--filter=-legal/copyright,-readability/todo'
$CPPLINT --root=include $FILTERS include/tree_sitter/compiler.h 2>&1
$CPPLINT --root=src $FILTERS $(find src/compiler -type f) 2>&1
$CPPLINT --linelength=90 --root=include $FILTERS include/tree_sitter/compiler.h 2>&1
$CPPLINT --linelength=90 --root=src $FILTERS $(find src/compiler -type f) 2>&1

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

@ -87,8 +87,7 @@ class LexTableBuilder {
}
}
void add_accept_token_actions(const LexItemSet &item_set,
LexStateId state_id) {
void add_accept_token_actions(const LexItemSet &item_set, LexStateId state_id) {
for (const LexItem &item : item_set) {
if (item.is_done()) {
auto current_action = lex_table.state(state_id).default_action;

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

@ -100,8 +100,7 @@ class ParseTableBuilder {
size_t shift_state_id = pair_for_symbol->second.state_index;
for (const auto &pair : actions) {
const Symbol &lookahead_sym = pair.first;
ParseAction reduce_extra =
ParseAction::ReduceExtra(ubiquitous_symbol);
ParseAction reduce_extra = ParseAction::ReduceExtra(ubiquitous_symbol);
if (should_add_action(shift_state_id, lookahead_sym, reduce_extra))
parse_table.add_action(shift_state_id, lookahead_sym, reduce_extra);
}

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

@ -54,8 +54,7 @@ class FirstSet : public rules::RuleFn<set<Symbol> > {
}
};
set<Symbol> first_set(const rules::rule_ptr &rule,
const SyntaxGrammar &grammar) {
set<Symbol> first_set(const rules::rule_ptr &rule, const SyntaxGrammar &grammar) {
return FirstSet(&grammar).apply(rule);
}

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

@ -18,10 +18,9 @@ using std::pair;
using rules::Symbol;
using rules::rule_ptr;
const ParseItemSet item_set_closure(
const ParseItem &starting_item,
const set<Symbol> &starting_lookahead_symbols,
const SyntaxGrammar &grammar) {
const ParseItemSet item_set_closure(const ParseItem &starting_item,
const set<Symbol> &starting_lookahead_symbols,
const SyntaxGrammar &grammar) {
ParseItemSet result;
vector<pair<ParseItem, set<Symbol>>> items_to_process = {

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

@ -247,8 +247,7 @@ class CCodeGenerator {
}
}
void condition_for_character_ranges(
const vector<rules::CharacterRange> &ranges) {
void condition_for_character_ranges(const vector<rules::CharacterRange> &ranges) {
if (ranges.size() == 1) {
add(condition_for_character_range(*ranges.begin()));
} else {

3
src/compiler/grammar.cc
View file

@ -10,8 +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 {

6
src/compiler/parse_table.cc
View file

@ -59,8 +59,7 @@ bool ParseAction::operator==(const ParseAction &other) const {
bool state_indices_eq = state_index == other.state_index;
bool consumed_symbol_counts_eq =
consumed_symbol_count == other.consumed_symbol_count;
return types_eq && symbols_eq && state_indices_eq &&
consumed_symbol_counts_eq;
return types_eq && symbols_eq && state_indices_eq && consumed_symbol_counts_eq;
}
ostream &operator<<(ostream &stream, const ParseAction &action) {
@ -112,8 +111,7 @@ ParseStateId ParseTable::add_state() {
return states.size() - 1;
}
void ParseTable::add_action(ParseStateId id, Symbol symbol,
ParseAction action) {
void ParseTable::add_action(ParseStateId id, Symbol symbol, ParseAction action) {
symbols.insert(symbol);
states[id].actions[symbol] = action;
}

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

@ -37,9 +37,8 @@ class ExpandRepeats : public rules::IdentityRuleFn {
make_shared<Symbol>(offset + index, rules::SymbolOptionAuxiliary);
aux_rules.push_back(
{ helper_rule_name,
Seq::Build(
{ inner_rule,
Choice::Build({ repeat_symbol, make_shared<Blank>() }) }) });
Seq::Build({ inner_rule, Choice::Build({ repeat_symbol,
make_shared<Blank>() }) }) });
return Choice::Build({ repeat_symbol, make_shared<Blank>() });
}

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

@ -91,8 +91,8 @@ class TokenExtractor : public rules::IdentityRuleFn {
vector<pair<string, rule_ptr>> tokens;
};
static tuple<SyntaxGrammar, LexicalGrammar, const GrammarError *>
ubiq_token_err(const rule_ptr rule) {
static tuple<SyntaxGrammar, LexicalGrammar, const GrammarError *> ubiq_token_err(
const rule_ptr rule) {
return make_tuple(SyntaxGrammar(), LexicalGrammar(),
new GrammarError(GrammarErrorTypeInvalidUbiquitousToken,
"Not a token: " + rule->to_string()));

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

@ -42,9 +42,8 @@ class InternSymbols : public rules::IdentityRuleFn {
};
pair<Grammar, const GrammarError *> missing_rule_error(string rule_name) {
return { Grammar({}),
new GrammarError(GrammarErrorTypeUndefinedSymbol,
"Undefined rule '" + rule_name + "'") };
return { Grammar({}), new GrammarError(GrammarErrorTypeUndefinedSymbol,
"Undefined rule '" + rule_name + "'") };
}
pair<Grammar, const GrammarError *> intern_symbols(const Grammar &grammar) {

3
src/compiler/prepare_grammar/parse_regex.h
View file

@ -8,8 +8,7 @@
namespace tree_sitter {
namespace prepare_grammar {
std::pair<rules::rule_ptr, const GrammarError *> parse_regex(
const std::string &);
std::pair<rules::rule_ptr, const GrammarError *> parse_regex(const std::string &);
} // namespace prepare_grammar
} // namespace tree_sitter

3
src/compiler/prepared_grammar.cc
View file

@ -11,8 +11,7 @@ using std::pair;
using std::vector;
using std::set;
const rules::rule_ptr &PreparedGrammar::rule(const rules::Symbol &symbol)
const {
const rules::rule_ptr &PreparedGrammar::rule(const rules::Symbol &symbol) const {
return symbol.is_auxiliary() ? aux_rules[symbol.index].second
: rules[symbol.index].second;
}

6
src/compiler/rules/character_set.cc
View file

@ -17,8 +17,7 @@ static void add_range(set<uint32_t> *characters, uint32_t min, uint32_t max) {
characters->insert(c);
}
static void remove_range(set<uint32_t> *characters, uint32_t min,
uint32_t max) {
static void remove_range(set<uint32_t> *characters, uint32_t min, uint32_t max) {
for (uint32_t c = min; c <= max; c++)
characters->erase(c);
}
@ -33,8 +32,7 @@ static set<uint32_t> remove_chars(set<uint32_t> *left,
return result;
}
static set<uint32_t> add_chars(set<uint32_t> *left,
const set<uint32_t> &right) {
static set<uint32_t> add_chars(set<uint32_t> *left, const set<uint32_t> &right) {
set<uint32_t> result;
for (uint32_t c : right)
if (left->insert(c).second)

3
src/runtime/document.c
View file

@ -32,8 +32,7 @@ static void reparse(TSDocument *document, TSInputEdit *edit) {
}
}
void ts_document_set_language(TSDocument *document,
const TSLanguage *language) {
void ts_document_set_language(TSDocument *document, const TSLanguage *language) {
ts_parser_destroy(&document->parser);
document->parser = ts_parser_make(language);
document->parser.debug = document->debug;

8
src/runtime/tree.c
View file

@ -19,8 +19,7 @@ TSTree *ts_tree_make_leaf(TSSymbol sym, size_t size, size_t padding,
}
TSTree *ts_tree_make_error(size_t size, size_t padding, char lookahead_char) {
TSTree *result =
ts_tree_make_leaf(ts_builtin_sym_error, size, padding, false);
TSTree *result = ts_tree_make_leaf(ts_builtin_sym_error, size, padding, false);
result->lookahead_char = lookahead_char;
return result;
}
@ -161,9 +160,8 @@ static size_t write_lookahead_to_string(char *string, size_t limit,
}
}
static size_t tree_write_to_string(const TSTree *tree,
const char **symbol_names, char *string,
size_t limit, int is_root) {
static size_t tree_write_to_string(const TSTree *tree, const char **symbol_names,
char *string, size_t limit, int is_root) {
if (!tree)
return snprintf(string, limit, "(NULL)");