Also do not warn about function declarations without a prior declaration. *sigh*

[cparser] / parser.c

diff --git a/parser.c b/parser.c
index 0dc6489..5fa99de 100644 (file)
--- a/parser.c
+++ b/parser.c
@@ -2249,6 +2249,11 @@ static declaration_t *append_declaration(declaration_t* const declaration)
        return declaration;
 }
 
+static bool is_sym_main(const symbol_t *const sym)
+{
+       return strcmp(sym->string, "main") == 0;
+}
+
 static declaration_t *internal_record_declaration(
        declaration_t *const declaration,
        const bool is_function_definition)
@@ -2294,7 +2299,8 @@ static declaration_t *internal_record_declaration(
                                                case STORAGE_CLASS_EXTERN:
                                                        if (is_function_definition) {
                                                                if (warning.missing_prototypes &&
-                                                                   prev_type->function.unspecified_parameters) {
+                                                                   prev_type->function.unspecified_parameters &&
+                                                                   !is_sym_main(symbol)) {
                                                                        warningf(declaration->source_position, "no previous prototype for '%#T'", type, symbol);
                                                                }
                                                        } else if (new_storage_class == STORAGE_CLASS_NONE) {
@@ -2337,13 +2343,21 @@ warn_redundant_declaration:
                        }
                        return previous_declaration;
                }
-       } else if (is_function_definition &&
-                       declaration->storage_class != STORAGE_CLASS_STATIC) {
-               if (warning.missing_prototypes) {
-                       warningf(declaration->source_position, "no previous prototype for '%#T'", type, symbol);
-               } else if (warning.missing_declarations) {
-                       warningf(declaration->source_position, "no previous declaration for '%#T'", type, symbol);
+       } else if (is_function_definition) {
+               if (declaration->storage_class != STORAGE_CLASS_STATIC) {
+                       if (warning.missing_prototypes && !is_sym_main(symbol)) {
+                               warningf(declaration->source_position, "no previous prototype for '%#T'", type, symbol);
+                       } else if (warning.missing_declarations && !is_sym_main(symbol)) {
+                               warningf(declaration->source_position, "no previous declaration for '%#T'", type, symbol);
+                       }
                }
+       } else if (warning.missing_declarations &&
+           context == global_context &&
+           !is_type_function(type) && (
+             declaration->storage_class == STORAGE_CLASS_NONE ||
+             declaration->storage_class == STORAGE_CLASS_THREAD
+           )) {
+               warningf(declaration->source_position, "no previous declaration for '%#T'", type, symbol);
        }
 
        assert(declaration->parent_context == NULL);
@@ -5013,7 +5027,14 @@ static statement_t *parse_label_statement(void)
                errorf(HERE, "label at end of compound statement");
                return (statement_t*) label_statement;
        } else {
-               label_statement->label_statement = parse_statement();
+               if (token.type == ';') {
+                       /* eat an empty statement here, to avoid the warning about an empty
+                        * after a label.  label:; is commonly used to have a label before
+                        * a }. */
+                       next_token();
+               } else {
+                       label_statement->label_statement = parse_statement();
+               }
        }
 
        return (statement_t*) label_statement;