X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;ds=sidebyside;f=parser.c;h=09930b025df14de6e72a39736917bc258c2d6257;hb=127a634aa53da8c37ee50f365184cccad67df0d8;hp=e8997b4160232874bb216531f061ab1e1697ae1b;hpb=f91a0738737d5ece68d8291e56f7a7809da56ef9;p=cparser diff --git a/parser.c b/parser.c index e8997b4..09930b0 100644 --- a/parser.c +++ b/parser.c @@ -36,7 +36,7 @@ #include "entity_t.h" #include "attribute_t.h" #include "lang_features.h" -#include "walk_statements.h" +#include "walk.h" #include "warning.h" #include "printer.h" #include "adt/bitfiddle.h" @@ -93,7 +93,7 @@ static switch_statement_t *current_switch = NULL; static statement_t *current_loop = NULL; static statement_t *current_parent = NULL; static ms_try_statement_t *current_try = NULL; -static linkage_kind_t current_linkage = LINKAGE_INVALID; +static linkage_kind_t current_linkage; static goto_statement_t *goto_first = NULL; static goto_statement_t **goto_anchor = NULL; static label_statement_t *label_first = NULL; @@ -283,8 +283,8 @@ static void semantic_comparison(binary_expression_t *expression); static size_t get_statement_struct_size(statement_kind_t kind) { static const size_t sizes[] = { - [STATEMENT_INVALID] = sizeof(invalid_statement_t), - [STATEMENT_EMPTY] = sizeof(empty_statement_t), + [STATEMENT_ERROR] = sizeof(statement_base_t), + [STATEMENT_EMPTY] = sizeof(statement_base_t), [STATEMENT_COMPOUND] = sizeof(compound_statement_t), [STATEMENT_RETURN] = sizeof(return_statement_t), [STATEMENT_DECLARATION] = sizeof(declaration_statement_t), @@ -316,7 +316,7 @@ static size_t get_statement_struct_size(statement_kind_t kind) static size_t get_expression_struct_size(expression_kind_t kind) { static const size_t sizes[] = { - [EXPR_INVALID] = sizeof(expression_base_t), + [EXPR_ERROR] = sizeof(expression_base_t), [EXPR_REFERENCE] = sizeof(reference_expression_t), [EXPR_REFERENCE_ENUM_VALUE] = sizeof(reference_expression_t), [EXPR_LITERAL_BOOLEAN] = sizeof(literal_expression_t), @@ -397,17 +397,19 @@ static expression_t *allocate_expression_zero(expression_kind_t kind) * Creates a new invalid expression at the source position * of the current token. */ -static expression_t *create_invalid_expression(void) +static expression_t *create_error_expression(void) { - return allocate_expression_zero(EXPR_INVALID); + expression_t *expression = allocate_expression_zero(EXPR_ERROR); + expression->base.type = type_error_type; + return expression; } /** * Creates a new invalid statement. */ -static statement_t *create_invalid_statement(void) +static statement_t *create_error_statement(void) { - return allocate_statement_zero(STATEMENT_INVALID); + return allocate_statement_zero(STATEMENT_ERROR); } /** @@ -705,7 +707,6 @@ static void scope_pop(scope_t *old_scope) static entity_t *get_entity(const symbol_t *const symbol, namespace_tag_t namespc) { - assert(namespc != NAMESPACE_INVALID); entity_t *entity = symbol->entity; for (; entity != NULL; entity = entity->base.symbol_next) { if ((namespace_tag_t)entity->base.namespc == namespc) @@ -738,7 +739,7 @@ static void stack_push(stack_entry_t **stack_ptr, entity_t *entity) { symbol_t *symbol = entity->base.symbol; entity_namespace_t namespc = entity->base.namespc; - assert(namespc != NAMESPACE_INVALID); + assert(namespc != 0); /* replace/add entity into entity list of the symbol */ entity_t **anchor; @@ -852,22 +853,11 @@ static void label_pop_to(size_t new_top) stack_pop_to(&label_stack, new_top); } -static int get_akind_rank(atomic_type_kind_t akind) -{ - return (int) akind; -} - -/** - * Return the type rank for an atomic type. - */ -static int get_rank(const type_t *type) +static atomic_type_kind_t get_akind(const type_t *type) { - assert(!is_typeref(type)); - if (type->kind == TYPE_ENUM) - return get_akind_rank(type->enumt.akind); - - assert(type->kind == TYPE_ATOMIC); - return get_akind_rank(type->atomic.akind); + assert(type->kind == TYPE_ATOMIC || type->kind == TYPE_COMPLEX + || type->kind == TYPE_IMAGINARY || type->kind == TYPE_ENUM); + return type->atomic.akind; } /** @@ -878,7 +868,7 @@ static int get_rank(const type_t *type) */ static type_t *promote_integer(type_t *type) { - if (get_rank(type) < get_akind_rank(ATOMIC_TYPE_INT)) + if (get_akind_rank(get_akind(type)) < get_akind_rank(ATOMIC_TYPE_INT)) type = type_int; return type; @@ -1359,19 +1349,17 @@ static entity_t *determine_lhs_ent(expression_t *const expr, ent = determine_lhs_ent(ref, lhs_ent); lhs_ent = ent; } else { - mark_vars_read(expr->select.compound, lhs_ent); + mark_vars_read(ref, lhs_ent); } mark_vars_read(expr->array_access.index, lhs_ent); return ent; } case EXPR_SELECT: { - if (is_type_compound(skip_typeref(expr->base.type))) { + mark_vars_read(expr->select.compound, lhs_ent); + if (is_type_compound(skip_typeref(expr->base.type))) return determine_lhs_ent(expr->select.compound, lhs_ent); - } else { - mark_vars_read(expr->select.compound, lhs_ent); - return NULL; - } + return NULL; } case EXPR_UNARY_DEREFERENCE: { @@ -1448,10 +1436,13 @@ static void mark_vars_read(expression_t *const expr, entity_t *lhs_ent) return; case EXPR_ARRAY_ACCESS: { + mark_vars_read(expr->array_access.index, lhs_ent); expression_t *const ref = expr->array_access.array_ref; + if (!is_type_array(skip_typeref(revert_automatic_type_conversion(ref)))) { + if (lhs_ent == ENT_ANY) + lhs_ent = NULL; + } mark_vars_read(ref, lhs_ent); - lhs_ent = determine_lhs_ent(ref, lhs_ent); - mark_vars_read(expr->array_access.index, lhs_ent); return; } @@ -1547,8 +1538,7 @@ unary: return; EXPR_LITERAL_CASES - case EXPR_UNKNOWN: - case EXPR_INVALID: + case EXPR_ERROR: case EXPR_STRING_LITERAL: case EXPR_WIDE_STRING_LITERAL: case EXPR_COMPOUND_LITERAL: // TODO init? @@ -2517,9 +2507,9 @@ static type_t *parse_enum_specifier(void) entity->base.parent_scope = current_scope; } - type_t *const type = allocate_type_zero(TYPE_ENUM); - type->enumt.enume = &entity->enume; - type->enumt.akind = ATOMIC_TYPE_INT; + type_t *const type = allocate_type_zero(TYPE_ENUM); + type->enumt.enume = &entity->enume; + type->enumt.base.akind = ATOMIC_TYPE_INT; if (token.kind == '{') { if (symbol != NULL) { @@ -3145,15 +3135,13 @@ warn_about_long_long: } if (type_specifiers & SPECIFIER_COMPLEX) { - type = allocate_type_zero(TYPE_COMPLEX); - type->complex.akind = atomic_type; + type = allocate_type_zero(TYPE_COMPLEX); } else if (type_specifiers & SPECIFIER_IMAGINARY) { - type = allocate_type_zero(TYPE_IMAGINARY); - type->imaginary.akind = atomic_type; + type = allocate_type_zero(TYPE_IMAGINARY); } else { - type = allocate_type_zero(TYPE_ATOMIC); - type->atomic.akind = atomic_type; + type = allocate_type_zero(TYPE_ATOMIC); } + type->atomic.akind = atomic_type; newtype = true; } else if (type_specifiers != 0) { errorf(&specifiers->source_position, "multiple datatypes in declaration"); @@ -3336,8 +3324,7 @@ end_error: } typedef enum construct_type_kind_t { - CONSTRUCT_INVALID, - CONSTRUCT_POINTER, + CONSTRUCT_POINTER = 1, CONSTRUCT_REFERENCE, CONSTRUCT_FUNCTION, CONSTRUCT_ARRAY @@ -3634,8 +3621,6 @@ static type_t *construct_declarator_type(construct_type_t *construct_list, for (; iter != NULL; iter = iter->base.next) { source_position_t const* const pos = &iter->base.pos; switch (iter->kind) { - case CONSTRUCT_INVALID: - break; case CONSTRUCT_FUNCTION: { construct_function_type_t *function = &iter->function; type_t *function_type = function->function_type; @@ -3650,7 +3635,7 @@ static type_t *construct_declarator_type(construct_type_t *construct_list, errorf(pos, "function returning array is not allowed"); } else { if (skipped_return_type->base.qualifiers != 0) { - warningf(WARN_OTHER, pos, "type qualifiers in return type of function type are meaningless"); + warningf(WARN_IGNORED_QUALIFIERS, pos, "type qualifiers in return type of function type are meaningless"); } } @@ -4778,7 +4763,7 @@ static bool expression_returns(expression_t const *const expr) case EXPR_BUILTIN_CONSTANT_P: case EXPR_BUILTIN_TYPES_COMPATIBLE_P: case EXPR_OFFSETOF: - case EXPR_INVALID: + case EXPR_ERROR: return true; case EXPR_STATEMENT: { @@ -4830,9 +4815,6 @@ static bool expression_returns(expression_t const *const expr) return expression_returns(expr->binary.left) && expression_returns(expr->binary.right); - - case EXPR_UNKNOWN: - break; } panic("unhandled expression"); @@ -4875,7 +4857,7 @@ static void check_reachable(statement_t *const stmt) statement_t *last = stmt; statement_t *next; switch (stmt->kind) { - case STATEMENT_INVALID: + case STATEMENT_ERROR: case STATEMENT_EMPTY: case STATEMENT_ASM: next = stmt->base.next; @@ -5147,7 +5129,7 @@ found_break_parent: } switch (next->kind) { - case STATEMENT_INVALID: + case STATEMENT_ERROR: case STATEMENT_EMPTY: case STATEMENT_DECLARATION: case STATEMENT_EXPRESSION: @@ -5808,7 +5790,7 @@ static expression_t *expected_expression_error(void) } next_token(); - return create_invalid_expression(); + return create_error_expression(); } static type_t *get_string_type(void) @@ -6205,7 +6187,8 @@ static entity_t *parse_qualified_identifier(void) if (entity == NULL) { if (!strict_mode && token.kind == '(') { /* an implicitly declared function */ - warningf(WARN_IMPLICIT_FUNCTION_DECLARATION, &pos, "implicit declaration of function '%Y'", symbol); + warningf(WARN_IMPLICIT_FUNCTION_DECLARATION, &pos, + "implicit declaration of function '%Y'", symbol); entity = create_implicit_function(symbol, &pos); } else { errorf(&pos, "unknown identifier '%Y' found.", symbol); @@ -6361,7 +6344,7 @@ static expression_t *parse_cast(void) return cast; end_error: - return create_invalid_expression(); + return create_error_expression(); } /** @@ -6576,14 +6559,14 @@ static expression_t *parse_offsetof(void) descend_into_subtype(&path); if (!walk_designator(&path, designator, true)) { - return create_invalid_expression(); + return create_error_expression(); } DEL_ARR_F(path.path); return expression; end_error: - return create_invalid_expression(); + return create_error_expression(); } /** @@ -6619,7 +6602,7 @@ static expression_t *parse_va_start(void) } expect(')', end_error); end_error: - return create_invalid_expression(); + return create_error_expression(); } /** @@ -6643,7 +6626,7 @@ static expression_t *parse_va_arg(void) return expression; end_error: - return create_invalid_expression(); + return create_error_expression(); } /** @@ -6672,7 +6655,7 @@ static expression_t *parse_va_copy(void) return expression; end_error: - return create_invalid_expression(); + return create_error_expression(); } /** @@ -6693,7 +6676,7 @@ static expression_t *parse_builtin_constant(void) return expression; end_error: - return create_invalid_expression(); + return create_error_expression(); } /** @@ -6718,7 +6701,7 @@ static expression_t *parse_builtin_types_compatible(void) return expression; end_error: - return create_invalid_expression(); + return create_error_expression(); } /** @@ -6775,7 +6758,7 @@ static expression_t *parse_compare_builtin(void) return expression; end_error: - return create_invalid_expression(); + return create_error_expression(); } /** @@ -6796,7 +6779,7 @@ static expression_t *parse_assume(void) expression->base.type = type_void; return expression; end_error: - return create_invalid_expression(); + return create_error_expression(); } /** @@ -6833,7 +6816,7 @@ static expression_t *parse_label_address(void) eat(T_ANDAND); if (token.kind != T_IDENTIFIER) { parse_error_expected("while parsing label address", T_IDENTIFIER, NULL); - return create_invalid_expression(); + return create_error_expression(); } label_t *const label = get_label(); @@ -6937,13 +6920,13 @@ static expression_t *parse_primary_expression(void) parse_declaration_specifiers(&specifiers); type_t const *const type = parse_abstract_declarator(specifiers.type); errorf(&pos, "encountered type '%T' while parsing expression", type); - return create_invalid_expression(); + return create_error_expression(); } } errorf(HERE, "unexpected token %K, expected an expression", &token); eat_until_anchor(); - return create_invalid_expression(); + return create_error_expression(); } static expression_t *parse_array_expression(expression_t *left) @@ -7097,7 +7080,7 @@ static expression_t *parse_select_expression(expression_t *addr) if (token.kind != T_IDENTIFIER) { parse_error_expected("while parsing select", T_IDENTIFIER, NULL); - return create_invalid_expression(); + return create_error_expression(); } symbol_t *symbol = token.identifier.symbol; next_token(); @@ -7131,14 +7114,14 @@ static expression_t *parse_select_expression(expression_t *addr) "request for member '%Y' in something not a struct or union, but '%T'", symbol, type_left); } - return create_invalid_expression(); + return create_error_expression(); } compound_t *compound = type_left->compound.compound; if (!compound->complete) { errorf(&pos, "request for member '%Y' in incomplete type '%T'", symbol, type_left); - return create_invalid_expression(); + return create_error_expression(); } type_qualifiers_t qualifiers = type_left->base.qualifiers; @@ -7147,7 +7130,7 @@ static expression_t *parse_select_expression(expression_t *addr) if (result == NULL) { errorf(&pos, "'%T' has no member named '%Y'", orig_type, symbol); - return create_invalid_expression(); + return create_error_expression(); } return result; @@ -7211,32 +7194,25 @@ static void check_call_argument(type_t *expected_type, /** * Handle the semantic restrictions of builtin calls */ -static void handle_builtin_argument_restrictions(call_expression_t *call) { - switch (call->function->reference.entity->function.btk) { - case bk_gnu_builtin_return_address: - case bk_gnu_builtin_frame_address: { +static void handle_builtin_argument_restrictions(call_expression_t *call) +{ + entity_t *entity = call->function->reference.entity; + switch (entity->function.btk) { + case BUILTIN_FIRM: + switch (entity->function.b.firm_builtin_kind) { + case ir_bk_return_address: + case ir_bk_frame_address: { /* argument must be constant */ call_argument_t *argument = call->arguments; if (is_constant_expression(argument->expression) == EXPR_CLASS_VARIABLE) { errorf(&call->base.source_position, - "argument of '%Y' must be a constant expression", - call->function->reference.entity->base.symbol); - } - break; - } - case bk_gnu_builtin_object_size: - if (call->arguments == NULL) - break; - - call_argument_t *arg = call->arguments->next; - if (arg != NULL && is_constant_expression(arg->expression) == EXPR_CLASS_VARIABLE) { - errorf(&call->base.source_position, - "second argument of '%Y' must be a constant expression", + "argument of '%Y' must be a constant expression", call->function->reference.entity->base.symbol); } break; - case bk_gnu_builtin_prefetch: + } + case ir_bk_prefetch: /* second and third argument must be constant if existent */ if (call->arguments == NULL) break; @@ -7246,22 +7222,37 @@ static void handle_builtin_argument_restrictions(call_expression_t *call) { if (rw != NULL) { if (is_constant_expression(rw->expression) == EXPR_CLASS_VARIABLE) { errorf(&call->base.source_position, - "second argument of '%Y' must be a constant expression", - call->function->reference.entity->base.symbol); + "second argument of '%Y' must be a constant expression", + call->function->reference.entity->base.symbol); } locality = rw->next; } if (locality != NULL) { if (is_constant_expression(locality->expression) == EXPR_CLASS_VARIABLE) { errorf(&call->base.source_position, - "third argument of '%Y' must be a constant expression", - call->function->reference.entity->base.symbol); + "third argument of '%Y' must be a constant expression", + call->function->reference.entity->base.symbol); } locality = rw->next; } break; default: break; + } + + case BUILTIN_OBJECT_SIZE: + if (call->arguments == NULL) + break; + + call_argument_t *arg = call->arguments->next; + if (arg != NULL && is_constant_expression(arg->expression) == EXPR_CLASS_VARIABLE) { + errorf(&call->base.source_position, + "second argument of '%Y' must be a constant expression", + call->function->reference.entity->base.symbol); + } + break; + default: + break; } } @@ -7357,7 +7348,7 @@ static expression_t *parse_call_expression(expression_t *expression) if (expression->kind == EXPR_REFERENCE) { reference_expression_t *reference = &expression->reference; if (reference->entity->kind == ENTITY_FUNCTION && - reference->entity->function.btk != bk_none) + reference->entity->function.btk != BUILTIN_NONE) handle_builtin_argument_restrictions(call); } @@ -7584,7 +7575,7 @@ static expression_t *parse_builtin_classify_type(void) return result; end_error: - return create_invalid_expression(); + return create_error_expression(); } /** @@ -7735,6 +7726,13 @@ static void semantic_incdec(unary_expression_t *expression) expression->base.type = orig_type; } +static void promote_unary_int_expr(unary_expression_t *const expr, type_t *const type) +{ + type_t *const res_type = promote_integer(type); + expr->base.type = res_type; + expr->value = create_implicit_cast(expr->value, res_type); +} + static void semantic_unexpr_arithmetic(unary_expression_t *expression) { type_t *const orig_type = expression->value->base.type; @@ -7746,9 +7744,11 @@ static void semantic_unexpr_arithmetic(unary_expression_t *expression) "operation needs an arithmetic type"); } return; + } else if (is_type_integer(type)) { + promote_unary_int_expr(expression, type); + } else { + expression->base.type = orig_type; } - - expression->base.type = orig_type; } static void semantic_unexpr_plus(unary_expression_t *expression) @@ -7777,7 +7777,7 @@ static void semantic_unexpr_integer(unary_expression_t *expression) return; } - expression->base.type = orig_type; + promote_unary_int_expr(expression, type); } static void semantic_dereference(unary_expression_t *expression) @@ -7927,45 +7927,44 @@ static type_t *semantic_arithmetic(type_t *type_left, type_t *type_right) if (type_left == type_right) return type_left; - bool const signed_left = is_type_signed(type_left); - bool const signed_right = is_type_signed(type_right); - int const rank_left = get_rank(type_left); - int const rank_right = get_rank(type_right); + bool const signed_left = is_type_signed(type_left); + bool const signed_right = is_type_signed(type_right); + unsigned const rank_left = get_akind_rank(get_akind(type_left)); + unsigned const rank_right = get_akind_rank(get_akind(type_right)); if (signed_left == signed_right) return rank_left >= rank_right ? type_left : type_right; - int s_rank; - int u_rank; + unsigned s_rank; + unsigned u_rank; + atomic_type_kind_t s_akind; + atomic_type_kind_t u_akind; type_t *s_type; type_t *u_type; if (signed_left) { - s_rank = rank_left; s_type = type_left; - u_rank = rank_right; u_type = type_right; } else { - s_rank = rank_right; s_type = type_right; - u_rank = rank_left; u_type = type_left; } + s_akind = get_akind(s_type); + u_akind = get_akind(u_type); + s_rank = get_akind_rank(s_akind); + u_rank = get_akind_rank(u_akind); if (u_rank >= s_rank) return u_type; - /* casting rank to atomic_type_kind is a bit hacky, but makes things - * easier here... */ - if (get_atomic_type_size((atomic_type_kind_t) s_rank) - > get_atomic_type_size((atomic_type_kind_t) u_rank)) + if (get_atomic_type_size(s_akind) > get_atomic_type_size(u_akind)) return s_type; - switch (s_rank) { - case ATOMIC_TYPE_INT: return type_unsigned_int; - case ATOMIC_TYPE_LONG: return type_unsigned_long; - case ATOMIC_TYPE_LONGLONG: return type_unsigned_long_long; + switch (s_akind) { + case ATOMIC_TYPE_INT: return type_unsigned_int; + case ATOMIC_TYPE_LONG: return type_unsigned_long; + case ATOMIC_TYPE_LONGLONG: return type_unsigned_long_long; - default: panic("invalid atomic type"); + default: panic("invalid atomic type"); } } @@ -8527,8 +8526,7 @@ static void semantic_binexpr_assign(binary_expression_t *expression) static bool expression_has_effect(const expression_t *const expr) { switch (expr->kind) { - case EXPR_UNKNOWN: break; - case EXPR_INVALID: return true; /* do NOT warn */ + case EXPR_ERROR: return true; /* do NOT warn */ case EXPR_REFERENCE: return false; case EXPR_REFERENCE_ENUM_VALUE: return false; case EXPR_LABEL_ADDRESS: return false; @@ -8746,7 +8744,6 @@ static expression_t *parse_subexpression(precedence_t precedence) left = parser->infix_parser(left); assert(left != NULL); - assert(left->kind != EXPR_UNKNOWN); } return left; @@ -9039,7 +9036,7 @@ end_of_asm: return statement; end_error: - return create_invalid_statement(); + return create_error_statement(); } static statement_t *parse_label_inner_statement(statement_t const *const label, char const *const label_kind) @@ -9048,7 +9045,7 @@ static statement_t *parse_label_inner_statement(statement_t const *const label, switch (token.kind) { case '}': errorf(&label->base.source_position, "%s at end of compound statement", label_kind); - inner_stmt = create_invalid_statement(); + inner_stmt = create_error_statement(); break; case ';': @@ -9279,8 +9276,18 @@ end_error: statement->ifs.true_statement = true_stmt; rem_anchor_token(T_else); + if (true_stmt->kind == STATEMENT_EMPTY) { + warningf(WARN_EMPTY_BODY, HERE, + "suggest braces around empty body in an ‘if’ statement"); + } + if (next_if(T_else)) { statement->ifs.false_statement = parse_inner_statement(); + + if (statement->ifs.false_statement->kind == STATEMENT_EMPTY) { + warningf(WARN_EMPTY_BODY, HERE, + "suggest braces around empty body in an ‘if’ statement"); + } } else if (true_stmt->kind == STATEMENT_IF && true_stmt->ifs.false_statement != NULL) { source_position_t const *const pos = &true_stmt->base.source_position; @@ -9352,7 +9359,7 @@ static statement_t *parse_switch(void) type_t * type = skip_typeref(expr->base.type); if (is_type_integer(type)) { type = promote_integer(type); - if (get_rank(type) >= get_akind_rank(ATOMIC_TYPE_LONG)) { + if (get_akind_rank(get_akind(type)) >= get_akind_rank(ATOMIC_TYPE_LONG)) { warningf(WARN_TRADITIONAL, &expr->base.source_position, "'%T' switch expression not converted to '%T' in ISO C", type, type_int); } } else if (is_type_valid(type)) { @@ -9378,7 +9385,7 @@ static statement_t *parse_switch(void) return statement; end_error: POP_PARENT(); - return create_invalid_statement(); + return create_error_statement(); } static statement_t *parse_loop_body(statement_t *const loop) @@ -9420,7 +9427,7 @@ static statement_t *parse_while(void) return statement; end_error: POP_PARENT(); - return create_invalid_statement(); + return create_error_statement(); } /** @@ -9455,7 +9462,7 @@ static statement_t *parse_do(void) return statement; end_error: POP_PARENT(); - return create_invalid_statement(); + return create_error_statement(); } /** @@ -9526,7 +9533,7 @@ end_error2: /* fallthrough */ end_error1: - return create_invalid_statement(); + return create_error_statement(); } /** @@ -9566,7 +9573,7 @@ static statement_t *parse_goto(void) else parse_error_expected("while parsing goto", T_IDENTIFIER, NULL); eat_until_anchor(); - return create_invalid_statement(); + return create_error_statement(); } /* remember the goto's in a list for later checking */ @@ -9834,11 +9841,11 @@ static statement_t *parse_ms_try_statment(void) statement->ms_try.final_statement = parse_compound_statement(false); } else { parse_error_expected("while parsing __try statement", T___except, T___finally, NULL); - return create_invalid_statement(); + return create_error_statement(); } return statement; end_error: - return create_invalid_statement(); + return create_error_statement(); } static statement_t *parse_empty_statement(void) @@ -10021,7 +10028,7 @@ static statement_t *intern_parse_statement(void) default: errorf(HERE, "unexpected token %K while parsing statement", &token); - statement = create_invalid_statement(); + statement = create_error_statement(); if (!at_anchor()) next_token(); break; @@ -10164,7 +10171,7 @@ static statement_t *parse_compound_statement(bool inside_expression_statement) break; } statement_t *sub_statement = intern_parse_statement(); - if (is_invalid_statement(sub_statement)) { + if (sub_statement->kind == STATEMENT_ERROR) { /* an error occurred. if we are at an anchor, return */ if (at_anchor()) goto end_error; @@ -10369,7 +10376,7 @@ static void parse_linkage_specification(void) new_linkage = LINKAGE_CXX; } else { errorf(&pos, "linkage string \"%s\" not recognized", linkage); - new_linkage = LINKAGE_INVALID; + new_linkage = LINKAGE_C; } current_linkage = new_linkage; @@ -10416,7 +10423,7 @@ static void parse_external(void) case ';': if (!strict_mode) { - warningf(WARN_OTHER, HERE, "stray ';' outside of function"); + warningf(WARN_STRAY_SEMICOLON, HERE, "stray ';' outside of function"); next_token(); return; }