add support for gcc nested functions

[cparser] / parser.c

diff --git a/parser.c b/parser.c
index b1f4a51..77c5884 100644 (file)
--- a/parser.c
+++ b/parser.c
@@ -643,16 +643,6 @@ static void eat_block(void)
                next_token();
 }
 
-/**
- * eat all token until a ';' is reached or a stop token is found.
- */
-static void eat_statement(void)
-{
-       eat_until_matching_token(';');
-       if (token.type == ';')
-               next_token();
-}
-
 #define eat(token_type)  do { assert(token.type == token_type); next_token(); } while (0)
 
 /**
@@ -3914,9 +3904,8 @@ static construct_type_t *parse_array_declarator(void)
        rem_anchor_token(']');
        expect(']');
 
-       return (construct_type_t*) array;
 end_error:
-       return NULL;
+       return (construct_type_t*) array;
 }
 
 static construct_type_t *parse_function_declarator(declaration_t *declaration)
@@ -4055,13 +4044,7 @@ static construct_type_t *parse_inner_declarator(declaration_t *declaration,
                if (may_be_abstract)
                        break;
                parse_error_expected("while parsing declarator", T_IDENTIFIER, '(', NULL);
-               /* avoid a loop in the outermost scope, because eat_statement doesn't
-                * eat '}' */
-               if (token.type == '}' && current_function == NULL) {
-                       next_token();
-               } else {
-                       eat_statement();
-               }
+               eat_until_anchor();
                return NULL;
        }
 
@@ -4379,7 +4362,7 @@ static declaration_t *record_declaration(
                        previous_declaration == NULL) {
                warningf(&declaration->source_position,
                         "function declaration '%#T' is not a prototype",
-                        orig_type, declaration->symbol);
+                        orig_type, symbol);
        }
 
        if (warning.main && is_type_function(type) && is_sym_main(symbol)) {
@@ -4610,24 +4593,17 @@ static void parse_anonymous_declaration_rest(
 {
        eat(';');
 
-       declaration_t *const declaration    = allocate_declaration_zero();
-       declaration->type                   = specifiers->type;
-       declaration->declared_storage_class = specifiers->declared_storage_class;
-       declaration->source_position        = specifiers->source_position;
-       declaration->modifiers              = specifiers->modifiers;
-
-       if (declaration->declared_storage_class != STORAGE_CLASS_NONE) {
-               warningf(&declaration->source_position,
+       if (specifiers->declared_storage_class != STORAGE_CLASS_NONE) {
+               warningf(&specifiers->source_position,
                         "useless storage class in empty declaration");
        }
-       declaration->storage_class = STORAGE_CLASS_NONE;
 
-       type_t *type = declaration->type;
+       type_t *type = specifiers->type;
        switch (type->kind) {
                case TYPE_COMPOUND_STRUCT:
                case TYPE_COMPOUND_UNION: {
                        if (type->compound.declaration->symbol == NULL) {
-                               warningf(&declaration->source_position,
+                               warningf(&specifiers->source_position,
                                         "unnamed struct/union that defines no instances");
                        }
                        break;
@@ -4637,11 +4613,20 @@ static void parse_anonymous_declaration_rest(
                        break;
 
                default:
-                       warningf(&declaration->source_position, "empty declaration");
+                       warningf(&specifiers->source_position, "empty declaration");
                        break;
        }
 
+#ifdef RECORD_EMPTY_DECLARATIONS
+       declaration_t *const declaration    = allocate_declaration_zero();
+       declaration->type                   = specifiers->type;
+       declaration->declared_storage_class = specifiers->declared_storage_class;
+       declaration->source_position        = specifiers->source_position;
+       declaration->modifiers              = specifiers->modifiers;
+       declaration->storage_class          = STORAGE_CLASS_NONE;
+
        append_declaration(declaration);
+#endif
 }
 
 static void parse_declaration_rest(declaration_t *ndeclaration,
@@ -4722,7 +4707,10 @@ static void parse_declaration(parsed_declaration_func finished_declaration)
 {
        declaration_specifiers_t specifiers;
        memset(&specifiers, 0, sizeof(specifiers));
+
+       add_anchor_token(';');
        parse_declaration_specifiers(&specifiers);
+       rem_anchor_token(';');
 
        if (token.type == ';') {
                parse_anonymous_declaration_rest(&specifiers);
@@ -6911,12 +6899,16 @@ static expression_t *parse_typeprop(expression_kind_t const kind,
                                     source_position_t const pos,
                                     unsigned const precedence)
 {
-       expression_t *tp_expression = allocate_expression_zero(kind);
+       expression_t  *tp_expression = allocate_expression_zero(kind);
        tp_expression->base.type            = type_size_t;
        tp_expression->base.source_position = pos;
 
        char const* const what = kind == EXPR_SIZEOF ? "sizeof" : "alignof";
 
+       /* we only refer to a type property, not the value, so do not warn
+        * when using current_init_decl */
+       declaration_t *old = current_init_decl;
+       current_init_decl  = NULL;
        if (token.type == '(' && is_declaration_specifier(look_ahead(1), true)) {
                next_token();
                add_anchor_token(')');
@@ -6957,6 +6949,7 @@ static expression_t *parse_typeprop(expression_kind_t const kind,
        }
 
 end_error:
+       current_init_decl  = old;
        return tp_expression;
 }
 
@@ -9155,7 +9148,7 @@ static statement_t *parse_goto(void)
                                parse_error_expected("while parsing goto", T_IDENTIFIER, '*', NULL);
                        else
                                parse_error_expected("while parsing goto", T_IDENTIFIER, NULL);
-                       eat_statement();
+                       eat_until_anchor();
                        goto end_error;
                }
                symbol_t *symbol = token.v.symbol;
@@ -9363,7 +9356,10 @@ static statement_t *parse_declaration_statement(void)
        statement->base.source_position = token.source_position;
 
        declaration_t *before = last_declaration;
-       parse_declaration(record_declaration);
+       if (c_mode & _GNUC)
+               parse_external_declaration();
+       else
+               parse_declaration(record_declaration);
 
        if (before == NULL) {
                statement->declaration.declarations_begin = scope->declarations;