fixed crash with unclosed string literal

[cparser] / parser.c

diff --git a/parser.c b/parser.c
index 2a075f5..1550ee7 100644 (file)
--- a/parser.c
+++ b/parser.c
@@ -136,6 +136,11 @@ static void *allocate_ast_zero(size_t size)
        return res;
 }
 
+static declaration_t *allocate_declaration_zero(void)
+{
+       return allocate_ast_zero(sizeof(*allocate_declaration_zero()));
+}
+
 /**
  * Returns the size of a statement node.
  *
@@ -848,7 +853,7 @@ static type_t *make_global_typedef(const char *name, type_t *type)
 {
        symbol_t *const symbol       = symbol_table_insert(name);
 
-       declaration_t *declaration   = allocate_ast_zero(sizeof(declaration[0]));
+       declaration_t *const declaration = allocate_declaration_zero();
        declaration->namespc         = NAMESPACE_NORMAL;
        declaration->storage_class   = STORAGE_CLASS_TYPEDEF;
        declaration->type            = type;
@@ -863,15 +868,15 @@ static type_t *make_global_typedef(const char *name, type_t *type)
        return typedef_type;
 }
 
-static const char *parse_string_literals(void)
+static string_t parse_string_literals(void)
 {
        assert(token.type == T_STRING_LITERAL);
-       const char *result = token.v.string;
+       string_t result = token.v.string;
 
        next_token();
 
-       while(token.type == T_STRING_LITERAL) {
-               result = concat_strings(result, token.v.string);
+       while (token.type == T_STRING_LITERAL) {
+               result = concat_strings(&result, &token.v.string);
                next_token();
        }
 
@@ -974,13 +979,13 @@ static designator_t *parse_designation(void)
 #endif
 
 static initializer_t *initializer_from_string(array_type_t *type,
-                                              const char *string)
+                                              const string_t *const string)
 {
        /* TODO: check len vs. size of array type */
        (void) type;
 
        initializer_t *initializer = allocate_initializer_zero(INITIALIZER_STRING);
-       initializer->string.string = string;
+       initializer->string.string = *string;
 
        return initializer;
 }
@@ -1014,7 +1019,7 @@ static initializer_t *initializer_from_expression(type_t *type,
                                case EXPR_STRING_LITERAL:
                                        if (element_type->atomic.akind == ATOMIC_TYPE_CHAR) {
                                                return initializer_from_string(array_type,
-                                                       expression->string.value);
+                                                       &expression->string.value);
                                        }
 
                                case EXPR_WIDE_STRING_LITERAL: {
@@ -1259,6 +1264,10 @@ static initializer_t *parse_initializer(type_t *type)
 
        if(token.type != '{') {
                expression_t  *expression  = parse_assignment_expression();
+               if (expression->base.datatype == NULL) {
+                       /* something bad happens, don't produce further errors */
+                       return NULL;
+               }
                initializer_t *initializer = initializer_from_expression(type, expression);
                if(initializer == NULL) {
                        errorf(HERE,
@@ -1327,13 +1336,9 @@ static declaration_t *parse_compound_type_specifier(bool is_struct)
        }
 
        if(declaration == NULL) {
-               declaration = allocate_ast_zero(sizeof(declaration[0]));
-
-               if(is_struct) {
-                       declaration->namespc = NAMESPACE_STRUCT;
-               } else {
-                       declaration->namespc = NAMESPACE_UNION;
-               }
+               declaration = allocate_declaration_zero();
+               declaration->namespc         =
+                       (is_struct ? NAMESPACE_STRUCT : NAMESPACE_UNION);
                declaration->source_position = token.source_position;
                declaration->symbol          = symbol;
                declaration->parent_context  = context;
@@ -1384,7 +1389,7 @@ static void parse_enum_entries(type_t *const enum_type)
                        return;
                }
 
-               declaration_t *const entry = allocate_ast_zero(sizeof(entry[0]));
+               declaration_t *const entry = allocate_declaration_zero();
                entry->storage_class   = STORAGE_CLASS_ENUM_ENTRY;
                entry->type            = enum_type;
                entry->symbol          = token.v.symbol;
@@ -1430,9 +1435,8 @@ static type_t *parse_enum_specifier(void)
        }
 
        if(declaration == NULL) {
-               declaration = allocate_ast_zero(sizeof(declaration[0]));
-
-               declaration->namespc       = NAMESPACE_ENUM;
+               declaration = allocate_declaration_zero();
+               declaration->namespc         = NAMESPACE_ENUM;
                declaration->source_position = token.source_position;
                declaration->symbol          = symbol;
                declaration->parent_context  = context;
@@ -1874,8 +1878,7 @@ static declaration_t *parse_identifier_list(void)
        declaration_t *declarations     = NULL;
        declaration_t *last_declaration = NULL;
        do {
-               declaration_t *declaration = allocate_ast_zero(sizeof(declaration[0]));
-
+               declaration_t *const declaration = allocate_declaration_zero();
                declaration->source_position = token.source_position;
                declaration->symbol          = token.v.symbol;
                next_token();
@@ -2272,7 +2275,7 @@ static declaration_t *parse_declarator(
                const declaration_specifiers_t *specifiers, bool may_be_abstract)
 {
        type_t        *type         = specifiers->type;
-       declaration_t *declaration  = allocate_ast_zero(sizeof(declaration[0]));
+       declaration_t *const declaration = allocate_declaration_zero();
        declaration->storage_class  = specifiers->storage_class;
        declaration->modifiers      = specifiers->decl_modifiers;
        declaration->is_inline      = specifiers->is_inline;
@@ -2473,7 +2476,7 @@ static void parse_init_declarator_rest(declaration_t *declaration)
 
                                case INITIALIZER_STRING: {
                                        initializer_string_t *const string = &initializer->string;
-                                       cnst->conste.v.int_value = strlen(string->string) + 1;
+                                       cnst->conste.v.int_value = string->string.size;
                                        break;
                                }
 
@@ -2507,8 +2510,7 @@ static void parse_anonymous_declaration_rest(
 {
        eat(';');
 
-       declaration_t *declaration = allocate_ast_zero(sizeof(declaration[0]));
-
+       declaration_t *const declaration = allocate_declaration_zero();
        declaration->type            = specifiers->type;
        declaration->storage_class   = specifiers->storage_class;
        declaration->source_position = specifiers->source_position;
@@ -2844,15 +2846,12 @@ static void parse_struct_declarators(const declaration_specifiers_t *specifiers)
 
                        type_t *type = make_bitfield_type(base_type, size);
 
-                       declaration = allocate_ast_zero(sizeof(declaration[0]));
-
+                       declaration = allocate_declaration_zero();
                        declaration->namespc         = NAMESPACE_NORMAL;
                        declaration->storage_class   = STORAGE_CLASS_NONE;
                        declaration->source_position = token.source_position;
                        declaration->modifiers       = specifiers->decl_modifiers;
                        declaration->type            = type;
-
-                       record_declaration(declaration);
                } else {
                        declaration = parse_declarator(specifiers,/*may_be_abstract=*/true);
 
@@ -2934,10 +2933,15 @@ static expression_t *create_invalid_expression(void)
        return expression;
 }
 
+/**
+ * Prints an error message if an expression was expected but not read
+ */
 static expression_t *expected_expression_error(void)
 {
-       errorf(HERE, "expected expression, got token '%K'", &token);
-
+       /* skip the error message if the error token was read */
+       if (token.type != T_ERROR) {
+               errorf(HERE, "expected expression, got token '%K'", &token);
+       }
        next_token();
 
        return create_invalid_expression();
@@ -3007,8 +3011,7 @@ static declaration_t *create_implicit_function(symbol_t *symbol,
                free_type(ntype);
        }
 
-       declaration_t *declaration = allocate_ast_zero(sizeof(declaration[0]));
-
+       declaration_t *const declaration = allocate_declaration_zero();
        declaration->storage_class   = STORAGE_CLASS_EXTERN;
        declaration->type            = type;
        declaration->symbol          = symbol;
@@ -3288,7 +3291,6 @@ static expression_t *parse_function_keyword(void)
 
        expression->expression.kind     = EXPR_FUNCTION;
        expression->expression.datatype = type_string;
-       expression->value               = current_function->symbol->string;
 
        return (expression_t*) expression;
 }
@@ -3307,7 +3309,6 @@ static expression_t *parse_pretty_function_keyword(void)
 
        expression->expression.kind     = EXPR_PRETTY_FUNCTION;
        expression->expression.datatype = type_string;
-       expression->value               = current_function->symbol->string;
 
        return (expression_t*) expression;
 }
@@ -4969,7 +4970,7 @@ static declaration_t *get_label(symbol_t *symbol)
        }
 
        /* otherwise we need to create a new one */
-       declaration_t *declaration = allocate_ast_zero(sizeof(declaration[0]));
+       declaration_t *const declaration = allocate_declaration_zero();
        declaration->namespc       = NAMESPACE_LABEL;
        declaration->symbol        = symbol;
 
@@ -5203,20 +5204,20 @@ static statement_t *parse_goto(void)
  */
 static statement_t *parse_continue(void)
 {
-       statement_base_t *statement;
+       statement_t *statement;
        if (current_loop == NULL) {
                errorf(HERE, "continue statement not within loop");
                statement = NULL;
        } else {
-               statement                  = allocate_ast_zero(sizeof(statement[0]));
-               statement->kind            = STATEMENT_CONTINUE;
-               statement->source_position = token.source_position;
+               statement = allocate_statement_zero(STATEMENT_CONTINUE);
+
+               statement->base.source_position = token.source_position;
        }
 
        eat(T_continue);
        expect(';');
 
-       return (statement_t*)statement;
+       return statement;
 }
 
 /**
@@ -5224,20 +5225,20 @@ static statement_t *parse_continue(void)
  */
 static statement_t *parse_break(void)
 {
-       statement_base_t *statement;
+       statement_t *statement;
        if (current_switch == NULL && current_loop == NULL) {
                errorf(HERE, "break statement not within loop or switch");
                statement = NULL;
        } else {
-               statement                  = allocate_ast_zero(sizeof(statement[0]));
-               statement->kind            = STATEMENT_BREAK;
-               statement->source_position = token.source_position;
+               statement = allocate_statement_zero(STATEMENT_BREAK);
+
+               statement->base.source_position = token.source_position;
        }
 
        eat(T_break);
        expect(';');
 
-       return (statement_t*)statement;
+       return statement;
 }
 
 /**