X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=parser.c;h=fdc013d9c998b1b86c3a6314ca3bd89002ca820d;hb=776944099aee0467915e9ea4f3c2f3f10f742aaa;hp=0f40e75735d5b67d9cb3669b4c71cc5937dd0e41;hpb=57218f2f71b3eb4902a50e743e7bd12c00f46bef;p=cparser diff --git a/parser.c b/parser.c index 0f40e75..fdc013d 100644 --- a/parser.c +++ b/parser.c @@ -23,6 +23,7 @@ #include #include +#include "adt/strutil.h" #include "parser.h" #include "diagnostic.h" #include "format_check.h" @@ -36,7 +37,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 +94,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 +284,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 +317,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 +398,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 +708,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 +740,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 +854,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) +static atomic_type_kind_t get_akind(const type_t *type) { - return (int) akind; -} - -/** - * Return the type rank for an atomic type. - */ -static int get_rank(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 +869,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; @@ -1081,22 +1072,6 @@ static string_t parse_string_literals(void) return result; } -/** - * compare two string, ignoring double underscores on the second. - */ -static int strcmp_underscore(const char *s1, const char *s2) -{ - if (s2[0] == '_' && s2[1] == '_') { - size_t len2 = strlen(s2); - size_t len1 = strlen(s1); - if (len1 == len2-4 && s2[len2-2] == '_' && s2[len2-1] == '_') { - return strncmp(s1, s2+2, len2-4); - } - } - - return strcmp(s1, s2); -} - static attribute_t *allocate_attribute_zero(attribute_kind_t kind) { attribute_t *attribute = allocate_ast_zero(sizeof(*attribute)); @@ -1241,8 +1216,7 @@ static attribute_t *parse_attribute_gnu_single(void) } const char *attribute_name = get_attribute_name(kind); - if (attribute_name != NULL - && strcmp_underscore(attribute_name, name) == 0) + if (attribute_name != NULL && streq_underscore(attribute_name, name)) break; } @@ -1359,19 +1333,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 +1420,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; } @@ -1546,9 +1521,8 @@ unary: determine_lhs_ent(expr->va_starte.ap, lhs_ent); return; - EXPR_LITERAL_CASES - case EXPR_UNKNOWN: - case EXPR_INVALID: + case EXPR_LITERAL_CASES: + case EXPR_ERROR: case EXPR_STRING_LITERAL: case EXPR_WIDE_STRING_LITERAL: case EXPR_COMPOUND_LITERAL: // TODO init? @@ -1691,15 +1665,6 @@ static initializer_t *initializer_from_expression(type_t *orig_type, return result; } -/** - * Checks if a given expression can be used as a constant initializer. - */ -static bool is_initializer_constant(const expression_t *expression) -{ - return is_constant_expression(expression) != EXPR_CLASS_VARIABLE || - is_linker_constant(expression) != EXPR_CLASS_VARIABLE; -} - /** * Parses an scalar initializer. * @@ -1720,7 +1685,7 @@ static initializer_t *parse_scalar_initializer(type_t *type, expression_t *expression = parse_assignment_expression(); mark_vars_read(expression, NULL); - if (must_be_constant && !is_initializer_constant(expression)) { + if (must_be_constant && !is_linker_constant(expression)) { errorf(&expression->base.source_position, "initialisation expression '%E' is not constant", expression); @@ -1843,11 +1808,10 @@ static void descend_into_subtype(type_path_t *path) top->type = top_type; if (is_type_compound(top_type)) { - compound_t *compound = top_type->compound.compound; - entity_t *entry = compound->members.entities; + compound_t *const compound = top_type->compound.compound; + entity_t *const entry = skip_unnamed_bitfields(compound->members.entities); if (entry != NULL) { - assert(entry->kind == ENTITY_COMPOUND_MEMBER); top->v.compound_entry = &entry->declaration; path->top_type = entry->declaration.type; } else { @@ -1987,7 +1951,7 @@ static void advance_current_object(type_path_t *path, size_t top_path_level) } else if (is_type_struct(type)) { declaration_t *entry = top->v.compound_entry; - entity_t *next_entity = entry->base.next; + entity_t *const next_entity = skip_unnamed_bitfields(entry->base.next); if (next_entity != NULL) { assert(is_declaration(next_entity)); entry = &next_entity->declaration; @@ -2141,7 +2105,7 @@ finish_designator: expression_t *expression = parse_assignment_expression(); mark_vars_read(expression, NULL); - if (env->must_be_constant && !is_initializer_constant(expression)) { + if (env->must_be_constant && !is_linker_constant(expression)) { errorf(&expression->base.source_position, "Initialisation expression '%E' is not constant", expression); @@ -2517,9 +2481,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) { @@ -2638,9 +2602,9 @@ static attribute_t *parse_attribute_ms_property(attribute_t *attribute) symbol_t **prop; symbol_t *symbol = token.identifier.symbol; - if (strcmp(symbol->string, "put") == 0) { + if (streq(symbol->string, "put")) { prop = &property->put_symbol; - } else if (strcmp(symbol->string, "get") == 0) { + } else if (streq(symbol->string, "get")) { prop = &property->get_symbol; } else { errorf(HERE, "expected put or get in property declspec"); @@ -2676,7 +2640,7 @@ static attribute_t *parse_microsoft_extended_decl_modifier_single(void) for (attribute_kind_t k = ATTRIBUTE_MS_FIRST; k <= ATTRIBUTE_MS_LAST; ++k) { const char *attribute_name = get_attribute_name(k); - if (attribute_name != NULL && strcmp(attribute_name, name) == 0) { + if (attribute_name != NULL && streq(attribute_name, name)) { kind = k; break; } @@ -3145,15 +3109,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 +3298,7 @@ end_error: } typedef enum construct_type_kind_t { - CONSTRUCT_INVALID, - CONSTRUCT_POINTER, + CONSTRUCT_POINTER = 1, CONSTRUCT_REFERENCE, CONSTRUCT_FUNCTION, CONSTRUCT_ARRAY @@ -3634,8 +3595,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 +3609,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"); } } @@ -3904,6 +3863,10 @@ static entity_t *parse_declarator(const declaration_specifiers_t *specifiers, handle_entity_attributes(attributes, entity); } + if (entity->kind == ENTITY_FUNCTION && !freestanding) { + adapt_special_functions(&entity->function); + } + return entity; } @@ -3994,7 +3957,7 @@ warn_arg_count: */ static bool is_sym_main(const symbol_t *const sym) { - return strcmp(sym->string, "main") == 0; + return streq(sym->string, "main"); } static void error_redefined_as_different_kind(const source_position_t *pos, @@ -4120,8 +4083,22 @@ entity_t *record_entity(entity_t *entity, const bool is_definition) goto finish; } if (previous_entity->kind == ENTITY_TYPEDEF) { - /* TODO: C++ allows this for exactly the same type */ - errorf(pos, "redefinition of '%N' (declared %P)", entity, ppos); + type_t *const type = skip_typeref(entity->typedefe.type); + type_t *const prev_type + = skip_typeref(previous_entity->typedefe.type); + if (c_mode & _CXX) { + /* C++ allows double typedef if they are identical + * (after skipping typedefs) */ + if (type == prev_type) + goto finish; + } else { + /* GCC extension: redef in system headers is allowed */ + if ((pos->is_system_header || ppos->is_system_header) && + types_compatible(type, prev_type)) + goto finish; + } + errorf(pos, "redefinition of '%N' (declared %P)", + entity, ppos); goto finish; } @@ -4201,7 +4178,7 @@ warn_redundant_declaration: ; merge_in_attributes(decl, prev_decl->attributes); } else if (!is_definition && is_type_valid(prev_type) && - strcmp(ppos->input_name, "") != 0) { + !pos->is_system_header) { warningf(WARN_REDUNDANT_DECLS, pos, "redundant declaration for '%Y' (declared %P)", symbol, ppos); } } else if (current_function == NULL) { @@ -4746,10 +4723,12 @@ static bool expression_returns(expression_t const *const expr) switch (expr->kind) { case EXPR_CALL: { expression_t const *const func = expr->call.function; - if (func->kind == EXPR_REFERENCE) { - entity_t *entity = func->reference.entity; - if (entity->kind == ENTITY_FUNCTION - && entity->declaration.modifiers & DM_NORETURN) + type_t const *const type = skip_typeref(func->base.type); + if (type->kind == TYPE_POINTER) { + type_t const *const points_to + = skip_typeref(type->pointer.points_to); + if (points_to->kind == TYPE_FUNCTION + && points_to->function.modifiers & DM_NORETURN) return false; } @@ -4766,7 +4745,7 @@ static bool expression_returns(expression_t const *const expr) case EXPR_REFERENCE: case EXPR_REFERENCE_ENUM_VALUE: - EXPR_LITERAL_CASES + case EXPR_LITERAL_CASES: case EXPR_STRING_LITERAL: case EXPR_WIDE_STRING_LITERAL: case EXPR_COMPOUND_LITERAL: // TODO descend into initialisers @@ -4778,7 +4757,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: { @@ -4819,20 +4798,17 @@ static bool expression_returns(expression_t const *const expr) case EXPR_VA_COPY: return expression_returns(expr->va_copye.src); - EXPR_UNARY_CASES_MANDATORY + case EXPR_UNARY_CASES_MANDATORY: return expression_returns(expr->unary.value); case EXPR_UNARY_THROW: return false; - EXPR_BINARY_CASES + case EXPR_BINARY_CASES: // TODO handle constant lhs of && and || return expression_returns(expr->binary.left) && expression_returns(expr->binary.right); - - case EXPR_UNKNOWN: - break; } panic("unhandled expression"); @@ -4875,7 +4851,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 +5123,7 @@ found_break_parent: } switch (next->kind) { - case STATEMENT_INVALID: + case STATEMENT_ERROR: case STATEMENT_EMPTY: case STATEMENT_DECLARATION: case STATEMENT_EXPRESSION: @@ -5338,6 +5314,22 @@ warn_unreachable: } } +static bool is_main(entity_t *entity) +{ + static symbol_t *sym_main = NULL; + if (sym_main == NULL) { + sym_main = symbol_table_insert("main"); + } + + if (entity->base.symbol != sym_main) + return false; + /* must be in outermost scope */ + if (entity->base.parent_scope != file_scope) + return false; + + return true; +} + static void parse_external_declaration(void) { /* function-definitions and declarations both start with declaration @@ -5487,6 +5479,9 @@ static void parse_external_declaration(void) } } + if (is_main(entity) && enable_main_collect2_hack) + prepare_main_collect2(entity); + POP_PARENT(); assert(current_function == function); assert(current_entity == entity); @@ -5722,6 +5717,8 @@ static void parse_compound_declarators(compound_t *compound, token.kind != ';' || look_ahead(1)->kind != '}') { errorf(pos, "'%N' has incomplete type '%T'", entity, orig_type); + } else if (compound->members.entities == NULL) { + errorf(pos, "flexible array member in otherwise empty struct"); } } } @@ -5808,7 +5805,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 +6202,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 +6359,7 @@ static expression_t *parse_cast(void) return cast; end_error: - return create_invalid_expression(); + return create_error_expression(); } /** @@ -6576,14 +6574,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 +6617,7 @@ static expression_t *parse_va_start(void) } expect(')', end_error); end_error: - return create_invalid_expression(); + return create_error_expression(); } /** @@ -6643,7 +6641,7 @@ static expression_t *parse_va_arg(void) return expression; end_error: - return create_invalid_expression(); + return create_error_expression(); } /** @@ -6672,7 +6670,7 @@ static expression_t *parse_va_copy(void) return expression; end_error: - return create_invalid_expression(); + return create_error_expression(); } /** @@ -6693,7 +6691,7 @@ static expression_t *parse_builtin_constant(void) return expression; end_error: - return create_invalid_expression(); + return create_error_expression(); } /** @@ -6718,7 +6716,7 @@ static expression_t *parse_builtin_types_compatible(void) return expression; end_error: - return create_invalid_expression(); + return create_error_expression(); } /** @@ -6775,7 +6773,7 @@ static expression_t *parse_compare_builtin(void) return expression; end_error: - return create_invalid_expression(); + return create_error_expression(); } /** @@ -6796,7 +6794,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 +6831,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 +6935,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 +7095,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 +7129,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 +7145,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 +7209,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 +7237,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 +7363,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 +7590,7 @@ static expression_t *parse_builtin_classify_type(void) return result; end_error: - return create_invalid_expression(); + return create_error_expression(); } /** @@ -7735,6 +7741,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 +7759,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 +7792,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 +7942,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"); } } @@ -8208,7 +8222,7 @@ static bool maybe_negative(expression_t const *const expr) { switch (is_constant_expression(expr)) { case EXPR_CLASS_ERROR: return false; - case EXPR_CLASS_CONSTANT: return fold_constant_to_int(expr) < 0; + case EXPR_CLASS_CONSTANT: return constant_is_negative(expr); default: return true; } } @@ -8527,8 +8541,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 +8759,6 @@ static expression_t *parse_subexpression(precedence_t precedence) left = parser->infix_parser(left); assert(left != NULL); - assert(left->kind != EXPR_UNKNOWN); } return left; @@ -8904,7 +8916,7 @@ static asm_argument_t *parse_asm_arguments(bool is_out) size = get_atomic_type_size(akind); } else { flags = ATOMIC_TYPE_FLAG_INTEGER | ATOMIC_TYPE_FLAG_ARITHMETIC; - size = get_atomic_type_size(get_intptr_kind()); + size = get_type_size(type_void_ptr); } do { @@ -8920,7 +8932,7 @@ static asm_argument_t *parse_asm_arguments(bool is_out) value_size = get_atomic_type_size(value_akind); } else if (value_kind == TYPE_POINTER) { value_flags = ATOMIC_TYPE_FLAG_INTEGER | ATOMIC_TYPE_FLAG_ARITHMETIC; - value_size = get_atomic_type_size(get_intptr_kind()); + value_size = get_type_size(type_void_ptr); } else { break; } @@ -9039,7 +9051,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 +9060,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 ';': @@ -9084,7 +9096,22 @@ static statement_t *parse_case_statement(void) eat(T_case); - expression_t *const expression = parse_expression(); + expression_t *expression = parse_expression(); + type_t *expression_type = expression->base.type; + type_t *skipped = skip_typeref(expression_type); + if (!is_type_integer(skipped) && is_type_valid(skipped)) { + errorf(pos, "case expression '%E' must have integer type but has type '%T'", + expression, expression_type); + } + + type_t *type = expression_type; + if (current_switch != NULL) { + type_t *switch_type = current_switch->expression->base.type; + if (is_type_valid(switch_type)) { + expression = create_implicit_cast(expression, switch_type); + } + } + statement->case_label.expression = expression; expression_classification_t const expr_class = is_constant_expression(expression); if (expr_class != EXPR_CLASS_CONSTANT) { @@ -9100,7 +9127,15 @@ static statement_t *parse_case_statement(void) if (GNU_MODE) { if (next_if(T_DOTDOTDOT)) { - expression_t *const end_range = parse_expression(); + expression_t *end_range = parse_expression(); + expression_type = expression->base.type; + skipped = skip_typeref(expression_type); + if (!is_type_integer(skipped) && is_type_valid(skipped)) { + errorf(pos, "case expression '%E' must have integer type but has type '%T'", + expression, expression_type); + } + + end_range = create_implicit_cast(end_range, type); statement->case_label.end_range = end_range; expression_classification_t const end_class = is_constant_expression(end_range); if (end_class != EXPR_CLASS_CONSTANT) { @@ -9279,8 +9314,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 +9397,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 +9423,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 +9465,7 @@ static statement_t *parse_while(void) return statement; end_error: POP_PARENT(); - return create_invalid_statement(); + return create_error_statement(); } /** @@ -9455,7 +9500,7 @@ static statement_t *parse_do(void) return statement; end_error: POP_PARENT(); - return create_invalid_statement(); + return create_error_statement(); } /** @@ -9526,7 +9571,7 @@ end_error2: /* fallthrough */ end_error1: - return create_invalid_statement(); + return create_error_statement(); } /** @@ -9566,7 +9611,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 +9879,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 +10066,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 +10209,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; @@ -10363,13 +10408,13 @@ static void parse_linkage_specification(void) linkage_kind_t old_linkage = current_linkage; linkage_kind_t new_linkage; - if (strcmp(linkage, "C") == 0) { + if (streq(linkage, "C")) { new_linkage = LINKAGE_C; - } else if (strcmp(linkage, "C++") == 0) { + } else if (streq(linkage, "C++")) { 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 +10461,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; } @@ -10563,6 +10608,8 @@ static void complete_incomplete_arrays(void) void prepare_main_collect2(entity_t *entity) { + PUSH_SCOPE(&entity->function.statement->compound.scope); + // create call to __main symbol_t *symbol = symbol_table_insert("__main"); entity_t *subsubmain_ent @@ -10589,6 +10636,8 @@ void prepare_main_collect2(entity_t *entity) expr_statement->base.next = compounds->statements; compounds->statements = expr_statement; + + POP_SCOPE(); } void parse(void)