Fix compile error on gcc

include/tree_sitter/parser.h

@@ -7,11 +7,12 @@ extern "C" {
 
 //#define TS_DEBUG_PARSE
 //#define TS_DEBUG_LEX
-    
+
 #include "tree_sitter/runtime.h"
 #include "tree_sitter/parser/lexer.h"
+#include "tree_sitter/parser/stack.h"
 #include "tree_sitter/parser/lr_parser.h"
-    
+
 #define SYMBOL_NAMES \
 static const char *ts_symbol_names[]
 
@@ -61,26 +62,26 @@ static const ts_parse_action ts_parse_actions[STATE_COUNT][SYMBOL_COUNT]
 
 #define ACCEPT_INPUT() \
 { .type = ts_parse_action_type_accept }
-    
+
 #ifdef TS_DEBUG_LEX
 #include <stdio.h>
 #define DEBUG_LEX(...) fprintf(stderr, "\n" __VA_ARGS__)
 #else
 #define DEBUG_LEX(...)
 #endif
-    
+
 #ifdef TS_DEBUG_PARSE
 #include <stdio.h>
 #define DEBUG_PARSE(...) fprintf(stderr, "\n" __VA_ARGS__)
 #else
 #define DEBUG_PARSE(...)
 #endif
-    
-static const ts_tree * 
+
+static const ts_tree *
 ts_parse(void *data, ts_input input, ts_input_edit *edit) {
     ts_lr_parser *parser = (ts_lr_parser *)data;
     ts_lr_parser_initialize(parser, input, edit);
-    
+
     int done = 0;
     while (!done) {
         ts_parse_action action = ts_lr_parser_next_action(parser);
@@ -104,7 +105,7 @@ ts_parse(void *data, ts_input input, ts_input_edit *edit) {
                 break;
         }
     }
-    
+
     return ts_lr_parser_tree_root(parser);
 }
 
@@ -124,7 +125,7 @@ ts_parser constructor_name() { \
         ), \
     }; \
 }
-    
+
 #ifdef __cplusplus
 }
 #endif

include/tree_sitter/parser/lr_parser.h

@@ -27,7 +27,7 @@ typedef struct {
     ts_stack stack;
     ts_tree *lookahead;
     ts_tree *next_lookahead;
-    const struct {
+    struct {
         size_t symbol_count;
         const int *hidden_symbol_flags;
         const int *ubiquitous_symbol_flags;
@@ -60,30 +60,30 @@ ts_lr_parser_make(size_t symbol_count,
     return result;
 }
 
-static const ts_parse_action * 
+static const ts_parse_action *
 ts_lr_parser_table_actions(ts_lr_parser *parser, ts_state_id state) {
     return parser->config.parse_table + (state * parser->config.symbol_count);
 }
 
-static size_t 
+static size_t
 ts_lr_parser_breakdown_stack(ts_lr_parser *parser, ts_input_edit *edit) {
     if (!edit) return 0;
-    
+
     ts_stack *stack = &parser->stack;
     size_t position = 0;
-    
+
     for (;;) {
         ts_tree *node = ts_stack_top_node(stack);
         if (!node) break;
-        
+
         position = ts_stack_right_position(stack);
         size_t child_count;
         ts_tree **children = ts_tree_immediate_children(node, &child_count);
         if (position <= edit->position && !children) break;
-        
+
         stack->size--;
         position -= ts_tree_total_size(node);
-        
+
         for (size_t i = 0; i < child_count && position < edit->position; i++) {
             ts_tree *child = children[i];
             ts_state_id state = ts_stack_top_state(stack);
@@ -92,35 +92,35 @@ ts_lr_parser_breakdown_stack(ts_lr_parser *parser, ts_input_edit *edit) {
             ts_tree_retain(child);
             position += ts_tree_total_size(child);
         }
-        
+
         ts_tree_release(node);
     }
-    
+
     return position;
 }
 
-static void 
+static void
 ts_lr_parser_initialize(ts_lr_parser *parser, ts_input input, ts_input_edit *edit) {
     if (!edit) ts_stack_shrink(&parser->stack, 0);
     parser->lookahead = NULL;
     parser->next_lookahead = NULL;
-    
+
     size_t position = ts_lr_parser_breakdown_stack(parser, edit);
     input.seek_fn(input.data, position);
-    
+
     parser->lexer = ts_lexer_make();
     parser->lexer.input = input;
     ts_lexer_advance(&parser->lexer);
 }
 
-static void 
+static void
 ts_lr_parser_shift(ts_lr_parser *parser, ts_state_id parse_state) {
     ts_stack_push(&parser->stack, parse_state, parser->lookahead);
     parser->lookahead = parser->next_lookahead;
     parser->next_lookahead = NULL;
 }
 
-static void 
+static void
 ts_lr_parser_reduce(ts_lr_parser *parser, ts_symbol symbol, size_t child_count) {
     parser->next_lookahead = parser->lookahead;
     parser->lookahead = ts_stack_reduce(&parser->stack,
@@ -130,41 +130,41 @@ ts_lr_parser_reduce(ts_lr_parser *parser, ts_symbol symbol, size_t child_count)
                                         parser->config.ubiquitous_symbol_flags);
 }
 
-static ts_symbol * 
+static ts_symbol *
 ts_lr_parser_expected_symbols(ts_lr_parser *parser, size_t *count) {
     *count = 0;
     const ts_parse_action *actions = ts_lr_parser_table_actions(parser, ts_stack_top_state(&parser->stack));
     for (size_t i = 0; i < parser->config.symbol_count; i++)
         if (actions[i].type != ts_parse_action_type_error)
             ++(*count);
-    
+
     size_t n = 0;
     ts_symbol *result = malloc(*count * sizeof(*result));
     for (ts_symbol i = 0; i < parser->config.symbol_count; i++)
         if (actions[i].type != ts_parse_action_type_error)
             result[n++] = i;
-    
+
     return result;
 }
 
-static int 
+static int
 ts_lr_parser_handle_error(ts_lr_parser *parser) {
     size_t count = 0;
     ts_symbol *expected_symbols = ts_lr_parser_expected_symbols(parser, &count);
     ts_tree *error = ts_tree_make_error(ts_lexer_lookahead_char(&parser->lexer), count, expected_symbols, 0, 0);
-    
+
     for (;;) {
         ts_tree_release(parser->lookahead);
         size_t position = ts_lexer_position(&parser->lexer);
         parser->lookahead = parser->config.lex_fn(&parser->lexer, ts_lex_state_error);
         if (ts_lexer_position(&parser->lexer) == position)
             ts_lexer_advance(&parser->lexer);
-        
+
         if (ts_tree_symbol(parser->lookahead) == ts_builtin_sym_end) {
             ts_stack_push(&parser->stack, 0, error);
             return 0;
         }
-        
+
         /*
          *  Unwind the stack, looking for a state in which this token
          *  may appear after an error.
@@ -185,16 +185,16 @@ ts_lr_parser_handle_error(ts_lr_parser *parser) {
     }
 }
 
-static ts_tree * 
+static ts_tree *
 ts_lr_parser_tree_root(ts_lr_parser *parser) {
     ts_stack *stack = &parser->stack;
     ts_tree *top_node = ts_stack_top_node(stack);
     if (stack->size <= 1)
         return top_node;
-    
+
     size_t immediate_child_count;
     ts_tree **immedate_children = ts_tree_immediate_children(top_node, &immediate_child_count);
-    
+
     stack->size--;
     for (size_t i = 0; i < immediate_child_count; i++) {
         ts_tree *child = immedate_children[i];
@@ -203,7 +203,7 @@ ts_lr_parser_tree_root(ts_lr_parser *parser) {
         ts_state_id next_state = ts_lr_parser_table_actions(parser, state)[ts_tree_symbol(child)].data.to_state;
         ts_stack_push(stack, next_state, child);
     }
-    
+
     ts_tree *new_node = ts_stack_reduce(stack,
                                         ts_tree_symbol(top_node),
                                         stack->size,

include/tree_sitter/parser/stack.h

@@ -4,6 +4,7 @@
 #include "tree_sitter/runtime.h"
 
 typedef unsigned short ts_state_id;
+
 typedef struct {
     size_t size;
     struct {

src/compiler/generate_code/c_code.cc

@@ -102,7 +102,7 @@ namespace tree_sitter {
                         return "ts_sym_" + name;
                 }
             }
-            
+
             string lex_state_index(size_t i) {
                 return to_string(i + 1);
             }