From 412cc9381222d84ffafb8de0ebe9c3e52df4e1c3 Mon Sep 17 00:00:00 2001 From: Max Brunsfeld Date: Thu, 31 Jul 2014 13:11:39 -0700 Subject: [PATCH] clang format --- include/tree_sitter/parser.h | 70 ++++++++++++++++++------------------ src/runtime/document.c | 9 +++-- src/runtime/lexer.c | 5 ++- src/runtime/parser.c | 15 ++++---- 4 files changed, 50 insertions(+), 49 deletions(-) diff --git a/include/tree_sitter/parser.h b/include/tree_sitter/parser.h index d4e76de5..8872dbbd 100644 --- a/include/tree_sitter/parser.h +++ b/include/tree_sitter/parser.h @@ -23,8 +23,8 @@ typedef struct TSLexer { size_t token_start_position; int reached_end; - TSTree * (* accept_fn)(struct TSLexer *, TSSymbol, int); - int (* advance_fn)(struct TSLexer *); + TSTree *(*accept_fn)(struct TSLexer *, TSSymbol, int); + int (*advance_fn)(struct TSLexer *); } TSLexer; static inline size_t ts_lexer_position(const TSLexer *lexer) { @@ -43,7 +43,8 @@ static inline int ts_lexer_advance(TSLexer *lexer) { return lexer->advance_fn(lexer); } -static inline TSTree *ts_lexer_accept(TSLexer *lexer, TSSymbol symbol, int is_hidden) { +static inline TSTree *ts_lexer_accept(TSLexer *lexer, TSSymbol symbol, + int is_hidden) { return lexer->accept_fn(lexer, symbol, is_hidden); } @@ -90,38 +91,37 @@ struct TSLanguage { #define LEX_FN() static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) #define DEBUG_LEX(...) \ - if (lexer->debug) { \ + if (lexer->debug) { \ fprintf(stderr, "\n" __VA_ARGS__); \ } -#define START_LEXER() \ - DEBUG_LEX("LEX %d", lex_state); \ - char lookahead; \ - next_state: \ +#define START_LEXER() \ + DEBUG_LEX("LEX %d", lex_state); \ + char lookahead; \ + next_state: \ lookahead = ts_lexer_lookahead_char(lexer); \ DEBUG_LEX("CHAR '%c'", lookahead); #define START_TOKEN() ts_lexer_start_token(lexer); -#define ADVANCE(state_index) \ - { \ - DEBUG_LEX("ADVANCE %d", state_index); \ - if (!ts_lexer_advance(lexer)) \ - ACCEPT_TOKEN(ts_builtin_sym_end); \ - lex_state = state_index; \ - goto next_state; \ +#define ADVANCE(state_index) \ + { \ + DEBUG_LEX("ADVANCE %d", state_index); \ + if (!ts_lexer_advance(lexer)) \ + ACCEPT_TOKEN(ts_builtin_sym_end); \ + lex_state = state_index; \ + goto next_state; \ } -#define ACCEPT_TOKEN(symbol) \ - { \ - DEBUG_LEX("TOKEN %s", ts_symbol_names[symbol]); \ - return ts_lexer_accept(lexer, symbol, \ - ts_hidden_symbol_flags[symbol]); \ +#define ACCEPT_TOKEN(symbol) \ + { \ + DEBUG_LEX("TOKEN %s", ts_symbol_names[symbol]); \ + return ts_lexer_accept(lexer, symbol, ts_hidden_symbol_flags[symbol]); \ } -#define LEX_ERROR() \ - { \ - DEBUG_LEX("ERROR"); \ +#define LEX_ERROR() \ + { \ + DEBUG_LEX("ERROR"); \ return ts_lexer_accept(lexer, ts_builtin_sym_error, 0); \ } @@ -153,19 +153,17 @@ 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, \ - }; \ - \ - const TSLanguage * language_name() { \ - return &language; \ - } +#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 } diff --git a/src/runtime/document.c b/src/runtime/document.c index f54391d9..3bf7b5b0 100644 --- a/src/runtime/document.c +++ b/src/runtime/document.c @@ -27,7 +27,8 @@ void ts_document_free(TSDocument *document) { free(document); } -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); } @@ -37,7 +38,8 @@ const TSTree *ts_document_tree(const TSDocument *document) { } const char *ts_document_string(const TSDocument *document) { - return ts_tree_string(document->tree, document->parser.language->symbol_names); + return ts_tree_string(document->tree, + document->parser.language->symbol_names); } void ts_document_set_input(TSDocument *document, TSInput input) { @@ -94,7 +96,8 @@ void ts_document_set_input_string(TSDocument *document, const char *text) { } TSNode *ts_document_root_node(const TSDocument *document) { - return ts_node_make_root(document->tree, document->parser.language->symbol_names); + return ts_node_make_root(document->tree, + document->parser.language->symbol_names); } TSNode *ts_document_get_node(const TSDocument *document, size_t pos) { diff --git a/src/runtime/lexer.c b/src/runtime/lexer.c index cbced29a..0ed80544 100644 --- a/src/runtime/lexer.c +++ b/src/runtime/lexer.c @@ -20,7 +20,7 @@ static int advance(TSLexer *lexer) { return 1; } -static TSTree * accept(TSLexer *lexer, TSSymbol symbol, int is_hidden) { +static TSTree *accept(TSLexer *lexer, TSSymbol symbol, int is_hidden) { size_t current_position = ts_lexer_position(lexer); size_t size = current_position - lexer->token_start_position; size_t offset = lexer->token_start_position - lexer->token_end_position; @@ -38,6 +38,5 @@ TSLexer ts_lexer_make() { .token_end_position = 0, .reached_end = 0, .advance_fn = advance, - .accept_fn = accept, - }; + .accept_fn = accept, }; } diff --git a/src/runtime/parser.c b/src/runtime/parser.c index c4501c9d..7e46b346 100644 --- a/src/runtime/parser.c +++ b/src/runtime/parser.c @@ -39,8 +39,8 @@ static size_t breakdown_stack(TSParser *parser, TSInputEdit *edit) { for (size_t i = 0; i < child_count && position < edit->position; i++) { TSTree *child = children[i]; TSStateId state = ts_stack_top_state(stack); - TSStateId next_state = - actions_for_state(parser->language, state)[child->symbol].data.to_state; + TSStateId next_state = actions_for_state( + parser->language, state)[child->symbol].data.to_state; ts_stack_push(stack, next_state, child); ts_tree_retain(child); position += ts_tree_total_size(child); @@ -141,7 +141,8 @@ int ts_parser_handle_error(TSParser *parser) { for (;;) { ts_tree_release(parser->lookahead); size_t position = ts_lexer_position(&parser->lexer); - parser->lookahead = parser->language->lex_fn(&parser->lexer, ts_lex_state_error); + parser->lookahead = + parser->language->lex_fn(&parser->lexer, ts_lex_state_error); int at_end = 0; if (ts_lexer_position(&parser->lexer) == position) @@ -159,8 +160,8 @@ int ts_parser_handle_error(TSParser *parser) { for (size_t j = 0; j < parser->stack.size; j++) { size_t i = parser->stack.size - 1 - j; TSStateId stack_state = parser->stack.entries[i].state; - TSParseAction action_on_error = - actions_for_state(parser->language, stack_state)[ts_builtin_sym_error]; + TSParseAction action_on_error = actions_for_state( + parser->language, stack_state)[ts_builtin_sym_error]; if (action_on_error.type == TSParseActionTypeShift) { TSStateId state_after_error = action_on_error.data.to_state; if (actions_for_state(parser->language, @@ -194,8 +195,8 @@ TSTree *ts_parser_tree_root(TSParser *parser) { TSParseAction ts_parser_next_action(TSParser *parser) { TSStateId state = ts_stack_top_state(&parser->stack); if (!parser->lookahead) - parser->lookahead = - parser->language->lex_fn(&parser->lexer, parser->language->lex_states[state]); + parser->lookahead = parser->language->lex_fn( + &parser->lexer, parser->language->lex_states[state]); return actions_for_state(parser->language, state)[parser->lookahead->symbol]; }