X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=parser.c;h=9331189e3046f5886daa156431f52892a3181f12;hb=f90c8ee3fe8b601816238164ae396a6734539850;hp=f14f2423265f72aac59a77df5f56edea10adb8ba;hpb=9d26a49e94a6cd2a4ad0d35faa6d7b0b628866d9;p=cparser diff --git a/parser.c b/parser.c index f14f242..9331189 100644 --- a/parser.c +++ b/parser.c @@ -34,6 +34,7 @@ #include "type_hash.h" #include "ast_t.h" #include "lang_features.h" +#include "walk_statements.h" #include "warning.h" #include "adt/bitfiddle.h" #include "adt/error.h" @@ -115,7 +116,7 @@ static stack_entry_t *environment_stack = NULL; static stack_entry_t *label_stack = NULL; static stack_entry_t *local_label_stack = NULL; /** The global file scope. */ -static scope_t *global_scope = NULL; +static scope_t *file_scope = NULL; /** The current scope. */ static scope_t *scope = NULL; static declaration_t *last_declaration = NULL; @@ -141,7 +142,7 @@ static struct obstack temp_obst; #define PUSH_PARENT(stmt) \ statement_t *const prev_parent = current_parent; \ - current_parent = (stmt); + ((void)(current_parent = (stmt))) #define POP_PARENT ((void)(current_parent = prev_parent)) static source_position_t null_position = { NULL, 0 }; @@ -183,7 +184,27 @@ static type_t *type_valist; static statement_t *parse_compound_statement(bool inside_expression_statement); static statement_t *parse_statement(void); -static expression_t *parse_sub_expression(unsigned precedence); +typedef enum precedence_t { + PREC_EXPRESSION, + PREC_ASSIGNMENT, + PREC_CONDITIONAL, + PREC_LOGICAL_OR, + PREC_LOGICAL_AND, + PREC_OR, + PREC_XOR, + PREC_AND, + PREC_EQUALITY, + PREC_RELATIONAL, + PREC_SHIFT, + PREC_ADDITIVE, + PREC_MULTIPLICATIVE, + PREC_CAST, + PREC_UNARY, + PREC_POSTFIX, + PREC_PRIMARY +} precedence_t; + +static expression_t *parse_sub_expression(precedence_t); static expression_t *parse_expression(void); static type_t *parse_typename(void); @@ -356,8 +377,9 @@ static statement_t *allocate_statement_zero(statement_kind_t kind) size_t size = get_statement_struct_size(kind); statement_t *res = allocate_ast_zero(size); - res->base.kind = kind; - res->base.parent = current_parent; + res->base.kind = kind; + res->base.parent = current_parent; + res->base.source_position = token.source_position; return res; } @@ -390,9 +412,7 @@ static expression_t *create_invalid_expression(void) */ static statement_t *create_invalid_statement(void) { - statement_t *statement = allocate_statement_zero(STATEMENT_INVALID); - statement->base.source_position = token.source_position; - return statement; + return allocate_statement_zero(STATEMENT_INVALID); } /** @@ -400,9 +420,7 @@ static statement_t *create_invalid_statement(void) */ static statement_t *create_empty_statement(void) { - statement_t *statement = allocate_statement_zero(STATEMENT_EMPTY); - statement->base.source_position = token.source_position; - return statement; + return allocate_statement_zero(STATEMENT_EMPTY); } /** @@ -845,10 +863,14 @@ static void stack_pop_to(stack_entry_t **stack_ptr, size_t new_top) break; } - /* Because of scopes and appending other namespaces to the end of - * the list, this must hold. */ - assert((old_declaration != NULL ? old_declaration->symbol_next : NULL) == iter->symbol_next); - *anchor = old_declaration; + /* Not all declarations adhere scopes (e.g. jump labels), so this + * correction is necessary */ + if (old_declaration != NULL) { + old_declaration->symbol_next = iter->symbol_next; + *anchor = old_declaration; + } else { + *anchor = iter->symbol_next; + } } ARR_SHRINKLEN(*stack_ptr, (int) new_top); @@ -1105,8 +1127,7 @@ static assign_error_t semantic_assign(type_t *orig_type_left, static expression_t *parse_constant_expression(void) { - /* start parsing at precedence 7 (conditional expression) */ - expression_t *result = parse_sub_expression(7); + expression_t *result = parse_sub_expression(PREC_CONDITIONAL); if (!is_constant_expression(result)) { errorf(&result->base.source_position, @@ -1118,8 +1139,7 @@ static expression_t *parse_constant_expression(void) static expression_t *parse_assignment_expression(void) { - /* start parsing at precedence 2 (assignment expression) */ - return parse_sub_expression(2); + return parse_sub_expression(PREC_ASSIGNMENT); } static type_t *make_global_typedef(const char *name, type_t *type) @@ -1661,7 +1681,6 @@ static decl_modifiers_t parse_gnu_attribute(gnu_attribute_t **attributes) } switch(kind) { - case GNU_AK_CONST: case GNU_AK_VOLATILE: case GNU_AK_NAKED: case GNU_AK_MALLOC: @@ -1701,6 +1720,7 @@ static decl_modifiers_t parse_gnu_attribute(gnu_attribute_t **attributes) case GNU_AK_UNUSED: modifiers |= DM_UNUSED; goto no_arg; case GNU_AK_USED: modifiers |= DM_USED; goto no_arg; case GNU_AK_PURE: modifiers |= DM_PURE; goto no_arg; + case GNU_AK_CONST: modifiers |= DM_CONST; goto no_arg; case GNU_AK_ALWAYS_INLINE: modifiers |= DM_FORCEINLINE; goto no_arg; case GNU_AK_DLLIMPORT: modifiers |= DM_DLLIMPORT; goto no_arg; case GNU_AK_DLLEXPORT: modifiers |= DM_DLLEXPORT; goto no_arg; @@ -1871,6 +1891,215 @@ end_error: } } +static void mark_decls_read(expression_t *expr, declaration_t *lhs_decl); + +static declaration_t *determine_lhs_decl(expression_t *const expr, declaration_t *lhs_decl) +{ + switch (expr->kind) { + case EXPR_REFERENCE: { + declaration_t *const decl = expr->reference.declaration; + return decl; + } + + case EXPR_ARRAY_ACCESS: { + expression_t *const ref = expr->array_access.array_ref; + declaration_t * decl = NULL; + if (is_type_array(skip_typeref(revert_automatic_type_conversion(ref)))) { + decl = determine_lhs_decl(ref, lhs_decl); + lhs_decl = decl; + } else { + mark_decls_read(expr->select.compound, lhs_decl); + } + mark_decls_read(expr->array_access.index, lhs_decl); + return decl; + } + + case EXPR_SELECT: { + if (is_type_compound(skip_typeref(expr->base.type))) { + return determine_lhs_decl(expr->select.compound, lhs_decl); + } else { + mark_decls_read(expr->select.compound, lhs_decl); + return NULL; + } + } + + case EXPR_UNARY_DEREFERENCE: { + expression_t *const val = expr->unary.value; + if (val->kind == EXPR_UNARY_TAKE_ADDRESS) { + /* *&x is a NOP */ + return determine_lhs_decl(val->unary.value, lhs_decl); + } else { + mark_decls_read(val, NULL); + return NULL; + } + } + + default: + mark_decls_read(expr, NULL); + return NULL; + } +} + +#define DECL_ANY ((declaration_t*)-1) + +/** + * Mark declarations, which are read. This is used to deted variables, which + * are never read. + * Example: + * x = x + 1; + * x is not marked as "read", because it is only read to calculate its own new + * value. + * + * x += y; y += x; + * x and y are not detected as "not read", because multiple variables are + * involved. + */ +static void mark_decls_read(expression_t *const expr, declaration_t *lhs_decl) +{ + switch (expr->kind) { + case EXPR_REFERENCE: { + declaration_t *const decl = expr->reference.declaration; + if (lhs_decl != decl && lhs_decl != DECL_ANY) + decl->read = true; + return; + } + + case EXPR_CALL: + // TODO respect pure/const + mark_decls_read(expr->call.function, NULL); + for (call_argument_t *arg = expr->call.arguments; arg != NULL; arg = arg->next) { + mark_decls_read(arg->expression, NULL); + } + return; + + case EXPR_CONDITIONAL: + // TODO lhs_decl should depend on whether true/false have an effect + mark_decls_read(expr->conditional.condition, NULL); + if (expr->conditional.true_expression != NULL) + mark_decls_read(expr->conditional.true_expression, lhs_decl); + mark_decls_read(expr->conditional.false_expression, lhs_decl); + return; + + case EXPR_SELECT: + if (lhs_decl == DECL_ANY && !is_type_compound(skip_typeref(expr->base.type))) + lhs_decl = NULL; + mark_decls_read(expr->select.compound, lhs_decl); + return; + + case EXPR_ARRAY_ACCESS: { + expression_t *const ref = expr->array_access.array_ref; + mark_decls_read(ref, lhs_decl); + lhs_decl = determine_lhs_decl(ref, lhs_decl); + mark_decls_read(expr->array_access.index, lhs_decl); + return; + } + + case EXPR_VA_ARG: + mark_decls_read(expr->va_arge.ap, lhs_decl); + return; + + case EXPR_UNARY_CAST: + /* Special case: Use void cast to mark a variable as "read" */ + if (is_type_atomic(skip_typeref(expr->base.type), ATOMIC_TYPE_VOID)) + lhs_decl = NULL; + goto unary; + + case EXPR_UNARY_DEREFERENCE: + if (lhs_decl == DECL_ANY) + lhs_decl = NULL; + goto unary; + + case EXPR_UNARY_NEGATE: + case EXPR_UNARY_PLUS: + case EXPR_UNARY_BITWISE_NEGATE: + case EXPR_UNARY_NOT: + case EXPR_UNARY_TAKE_ADDRESS: + case EXPR_UNARY_POSTFIX_INCREMENT: + case EXPR_UNARY_POSTFIX_DECREMENT: + case EXPR_UNARY_PREFIX_INCREMENT: + case EXPR_UNARY_PREFIX_DECREMENT: + case EXPR_UNARY_CAST_IMPLICIT: + case EXPR_UNARY_ASSUME: +unary: + mark_decls_read(expr->unary.value, lhs_decl); + return; + + case EXPR_BINARY_ADD: + case EXPR_BINARY_SUB: + case EXPR_BINARY_MUL: + case EXPR_BINARY_DIV: + case EXPR_BINARY_MOD: + case EXPR_BINARY_EQUAL: + case EXPR_BINARY_NOTEQUAL: + case EXPR_BINARY_LESS: + case EXPR_BINARY_LESSEQUAL: + case EXPR_BINARY_GREATER: + case EXPR_BINARY_GREATEREQUAL: + case EXPR_BINARY_BITWISE_AND: + case EXPR_BINARY_BITWISE_OR: + case EXPR_BINARY_BITWISE_XOR: + case EXPR_BINARY_LOGICAL_AND: + case EXPR_BINARY_LOGICAL_OR: + case EXPR_BINARY_SHIFTLEFT: + case EXPR_BINARY_SHIFTRIGHT: + case EXPR_BINARY_COMMA: + case EXPR_BINARY_ISGREATER: + case EXPR_BINARY_ISGREATEREQUAL: + case EXPR_BINARY_ISLESS: + case EXPR_BINARY_ISLESSEQUAL: + case EXPR_BINARY_ISLESSGREATER: + case EXPR_BINARY_ISUNORDERED: + mark_decls_read(expr->binary.left, lhs_decl); + mark_decls_read(expr->binary.right, lhs_decl); + return; + + case EXPR_BINARY_ASSIGN: + case EXPR_BINARY_MUL_ASSIGN: + case EXPR_BINARY_DIV_ASSIGN: + case EXPR_BINARY_MOD_ASSIGN: + case EXPR_BINARY_ADD_ASSIGN: + case EXPR_BINARY_SUB_ASSIGN: + case EXPR_BINARY_SHIFTLEFT_ASSIGN: + case EXPR_BINARY_SHIFTRIGHT_ASSIGN: + case EXPR_BINARY_BITWISE_AND_ASSIGN: + case EXPR_BINARY_BITWISE_XOR_ASSIGN: + case EXPR_BINARY_BITWISE_OR_ASSIGN: { + if (lhs_decl == DECL_ANY) + lhs_decl = NULL; + lhs_decl = determine_lhs_decl(expr->binary.left, lhs_decl); + mark_decls_read(expr->binary.right, lhs_decl); + return; + } + + case EXPR_VA_START: + determine_lhs_decl(expr->va_starte.ap, lhs_decl); + return; + + case EXPR_UNKNOWN: + case EXPR_INVALID: + case EXPR_CONST: + case EXPR_CHARACTER_CONSTANT: + case EXPR_WIDE_CHARACTER_CONSTANT: + case EXPR_STRING_LITERAL: + case EXPR_WIDE_STRING_LITERAL: + case EXPR_COMPOUND_LITERAL: // TODO init? + case EXPR_SIZEOF: + case EXPR_CLASSIFY_TYPE: + case EXPR_ALIGNOF: + case EXPR_FUNCNAME: + case EXPR_BUILTIN_SYMBOL: + case EXPR_BUILTIN_CONSTANT_P: + case EXPR_BUILTIN_PREFETCH: + case EXPR_OFFSETOF: + case EXPR_STATEMENT: // TODO + case EXPR_LABEL_ADDRESS: + case EXPR_BINARY_BUILTIN_EXPECT: + return; + } + + panic("unhandled expression"); +} + static designator_t *parse_designation(void) { designator_t *result = NULL; @@ -1990,6 +2219,11 @@ static initializer_t *initializer_from_expression(type_t *orig_type, &expression->base.source_position); initializer_t *const result = allocate_initializer_zero(INITIALIZER_VALUE); +#if 0 + if (type->kind == TYPE_BITFIELD) { + type = type->bitfield.base_type; + } +#endif result->value.value = create_implicit_cast(expression, type); return result; @@ -2023,6 +2257,7 @@ static initializer_t *parse_scalar_initializer(type_t *type, } expression_t *expression = parse_assignment_expression(); + mark_decls_read(expression, NULL); if (must_be_constant && !is_initializer_constant(expression)) { errorf(&expression->base.source_position, "Initialisation expression '%E' is not constant\n", @@ -2210,34 +2445,37 @@ static bool walk_designator(type_path_t *path, const designator_t *designator, "'.%Y' designator used for non-compound type '%T'", symbol, orig_type); } - goto failed; - } - declaration_t *declaration = type->compound.declaration; - declaration_t *iter = declaration->scope.declarations; - for( ; iter != NULL; iter = iter->next) { - if (iter->symbol == symbol) { - break; + top->type = type_error_type; + top->v.compound_entry = NULL; + orig_type = type_error_type; + } else { + declaration_t *declaration = type->compound.declaration; + declaration_t *iter = declaration->scope.declarations; + for( ; iter != NULL; iter = iter->next) { + if (iter->symbol == symbol) { + break; + } } - } - if (iter == NULL) { - errorf(&designator->source_position, - "'%T' has no member named '%Y'", orig_type, symbol); - goto failed; - } - if (used_in_offsetof) { - type_t *real_type = skip_typeref(iter->type); - if (real_type->kind == TYPE_BITFIELD) { + if (iter == NULL) { errorf(&designator->source_position, - "offsetof designator '%Y' may not specify bitfield", - symbol); + "'%T' has no member named '%Y'", orig_type, symbol); goto failed; } - } + if (used_in_offsetof) { + type_t *real_type = skip_typeref(iter->type); + if (real_type->kind == TYPE_BITFIELD) { + errorf(&designator->source_position, + "offsetof designator '%Y' may not specify bitfield", + symbol); + goto failed; + } + } - top->type = orig_type; - top->v.compound_entry = iter; - orig_type = iter->type; + top->type = orig_type; + top->v.compound_entry = iter; + orig_type = iter->type; + } } else { expression_t *array_index = designator->array_index; assert(designator->array_index != NULL); @@ -2250,24 +2488,18 @@ static bool walk_designator(type_path_t *path, const designator_t *designator, } goto failed; } - if (!is_type_valid(array_index->base.type)) { - goto failed; - } long index = fold_constant(array_index); if (!used_in_offsetof) { if (index < 0) { errorf(&designator->source_position, "array index [%E] must be positive", array_index); - goto failed; - } - if (type->array.size_constant == true) { + } else if (type->array.size_constant) { long array_size = type->array.size; if (index >= array_size) { errorf(&designator->source_position, "designator [%E] (%d) exceeds array size %d", array_index, index, array_size); - goto failed; } } } @@ -2305,7 +2537,7 @@ static void advance_current_object(type_path_t *path, size_t top_path_level) path->top_type = entry->type; return; } - } else { + } else if (is_type_array(type)) { assert(is_type_array(type)); top->v.index++; @@ -2313,6 +2545,9 @@ static void advance_current_object(type_path_t *path, size_t top_path_level) if (!type->array.size_constant || top->v.index < type->array.size) { return; } + } else { + assert(!is_type_valid(type)); + return; } /* we're past the last member of the current sub-aggregate, try if we @@ -2384,13 +2619,6 @@ static initializer_t *parse_sub_initializer(type_path_t *path, /* We are initializing an empty compound. */ } else { type = skip_typeref(orig_type); - - /* we can't do usefull stuff if we didn't even parse the type. Skip the - * initializers in this case. */ - if (!is_type_valid(type)) { - skip_initializers(); - return create_empty_initializer(); - } } initializer_t **initializers = NEW_ARR_F(initializer_t*, 0); @@ -2467,8 +2695,9 @@ finish_designator: if (type == NULL) { /* we are already outside, ... */ - if (is_type_compound(outer_type) && - !outer_type->compound.declaration->init.complete) { + type_t *const outer_type_skip = skip_typeref(outer_type); + if (is_type_compound(outer_type_skip) && + !outer_type_skip->compound.declaration->init.complete) { goto error_parse_next; } goto error_excess; @@ -3112,7 +3341,7 @@ static declaration_t *create_error_declaration(symbol_t *symbol, storage_class_t decl->source_position = *HERE; decl->declared_storage_class = storage_class; decl->storage_class = - storage_class != STORAGE_CLASS_NONE || scope == global_scope ? + storage_class != STORAGE_CLASS_NONE || scope == file_scope ? storage_class : STORAGE_CLASS_AUTO; decl->symbol = symbol; decl->implicit = true; @@ -3364,8 +3593,8 @@ static void parse_declaration_specifiers(declaration_specifiers_t *specifiers) type->compound.declaration = parse_compound_type_specifier(false); if (type->compound.declaration->modifiers & DM_TRANSPARENT_UNION) modifiers |= TYPE_MODIFIER_TRANSPARENT_UNION; - break; finish_union_type(&type->compound); + break; } case T_enum: type = parse_enum_specifier(); @@ -3978,7 +4207,6 @@ static construct_type_t *parse_function_declarator(declaration_t *declaration) if (declaration != NULL) { declaration->scope.declarations = parameters; declaration->scope.last_declaration = last; - declaration->scope.is_parameter = true; } construct_function_type_t *construct_function_type = @@ -4186,12 +4414,8 @@ static type_t *construct_declarator_type(construct_type_t *construct_list, case CONSTRUCT_POINTER: { parsed_pointer_t *parsed_pointer = (parsed_pointer_t*) iter; - type_t *pointer_type = allocate_type_zero(TYPE_POINTER, &null_position); - pointer_type->pointer.points_to = type; - pointer_type->base.qualifiers = parsed_pointer->type_qualifiers; - - type = pointer_type; - break; + type = make_pointer_type(type, parsed_pointer->type_qualifiers); + continue; } case CONSTRUCT_ARRAY: { @@ -4259,8 +4483,8 @@ static declaration_t *parse_declarator( declaration->is_inline = specifiers->is_inline; declaration->storage_class = specifiers->declared_storage_class; - if (declaration->storage_class == STORAGE_CLASS_NONE - && scope != global_scope) { + if (declaration->storage_class == STORAGE_CLASS_NONE && + scope != file_scope) { declaration->storage_class = STORAGE_CLASS_AUTO; } @@ -4396,14 +4620,14 @@ static declaration_t *record_declaration( if (warning.nested_externs && declaration->storage_class == STORAGE_CLASS_EXTERN && - scope != global_scope) { + scope != file_scope) { warningf(&declaration->source_position, "nested extern declaration of '%#T'", declaration->type, symbol); } assert(declaration != previous_declaration); if (previous_declaration != NULL && - previous_declaration->parent_scope->is_parameter && + previous_declaration->parent_scope == ¤t_function->scope && scope->depth == previous_declaration->parent_scope->depth + 1) { errorf(&declaration->source_position, "declaration '%#T' redeclares the parameter '%#T' (declared %P)", @@ -4536,7 +4760,7 @@ warn_redundant_declaration: } } else { if (warning.missing_declarations && - scope == global_scope && ( + scope == file_scope && ( declaration->storage_class == STORAGE_CLASS_NONE || declaration->storage_class == STORAGE_CLASS_THREAD )) { @@ -4592,9 +4816,9 @@ static void parse_init_declarator_rest(declaration_t *declaration) } bool must_be_constant = false; - if (declaration->storage_class == STORAGE_CLASS_STATIC - || declaration->storage_class == STORAGE_CLASS_THREAD_STATIC - || declaration->parent_scope == global_scope) { + if (declaration->storage_class == STORAGE_CLASS_STATIC || + declaration->storage_class == STORAGE_CLASS_THREAD_STATIC || + declaration->parent_scope == file_scope) { must_be_constant = true; } @@ -4916,6 +5140,45 @@ static void check_labels(void) label_first = label_last = NULL; } +static void warn_unused_decl(declaration_t *decl, declaration_t *end, char const *const what) +{ + for (; decl != NULL; decl = decl->next) { + if (decl->implicit) + continue; + + if (!decl->used) { + print_in_function(); + warningf(&decl->source_position, "%s '%Y' is unused", what, decl->symbol); + } else if (!decl->read) { + print_in_function(); + warningf(&decl->source_position, "%s '%Y' is never read", what, decl->symbol); + } + + if (decl == end) + break; + } +} + +static void check_unused_variables(statement_t *const stmt, void *const env) +{ + (void)env; + + switch (stmt->kind) { + case STATEMENT_DECLARATION: { + declaration_statement_t const *const decls = &stmt->declaration; + warn_unused_decl(decls->declarations_begin, decls->declarations_end, "variable"); + return; + } + + case STATEMENT_FOR: + warn_unused_decl(stmt->fors.scope.declarations, NULL, "variable"); + return; + + default: + return; + } +} + /** * Check declarations of current_function for unused entities. */ @@ -4924,20 +5187,13 @@ static void check_declarations(void) if (warning.unused_parameter) { const scope_t *scope = ¤t_function->scope; - if (is_sym_main(current_function->symbol)) { - /* do not issue unused warnings for main */ - return; - } - const declaration_t *parameter = scope->declarations; - for (; parameter != NULL; parameter = parameter->next) { - if (! parameter->used) { - print_in_function(); - warningf(¶meter->source_position, - "unused parameter '%Y'", parameter->symbol); - } + /* do not issue unused warnings for main */ + if (!is_sym_main(current_function->symbol)) { + warn_unused_decl(scope->declarations, NULL, "parameter"); } } if (warning.unused_variable) { + walk_statements(current_function->init.statement, check_unused_variables, NULL); } } @@ -5300,57 +5556,12 @@ continue_for:; check_reachable(next); } -static void check_unreachable(statement_t const* const stmt) +static void check_unreachable(statement_t* const stmt, void *const env) { - if (!stmt->base.reachable && - stmt->kind != STATEMENT_DO_WHILE && - stmt->kind != STATEMENT_FOR && - (stmt->kind != STATEMENT_COMPOUND || stmt->compound.statements == NULL)) { - warningf(&stmt->base.source_position, "statement is unreachable"); - } + (void)env; switch (stmt->kind) { - case STATEMENT_INVALID: - case STATEMENT_EMPTY: - case STATEMENT_RETURN: - case STATEMENT_DECLARATION: - case STATEMENT_EXPRESSION: - case STATEMENT_CONTINUE: - case STATEMENT_BREAK: - case STATEMENT_GOTO: - case STATEMENT_ASM: - case STATEMENT_LEAVE: - break; - - case STATEMENT_COMPOUND: - if (stmt->compound.statements) - check_unreachable(stmt->compound.statements); - break; - - case STATEMENT_IF: - check_unreachable(stmt->ifs.true_statement); - if (stmt->ifs.false_statement != NULL) - check_unreachable(stmt->ifs.false_statement); - break; - - case STATEMENT_SWITCH: - check_unreachable(stmt->switchs.body); - break; - - case STATEMENT_LABEL: - check_unreachable(stmt->label.statement); - break; - - case STATEMENT_CASE_LABEL: - check_unreachable(stmt->case_label.statement); - break; - - case STATEMENT_WHILE: - check_unreachable(stmt->whiles.body); - break; - case STATEMENT_DO_WHILE: - check_unreachable(stmt->do_while.body); if (!stmt->base.reachable) { expression_t const *const cond = stmt->do_while.condition; if (determine_truth(cond) >= 0) { @@ -5358,7 +5569,7 @@ static void check_unreachable(statement_t const* const stmt) "condition of do-while-loop is unreachable"); } } - break; + return; case STATEMENT_FOR: { for_statement_t const* const fors = &stmt->fors; @@ -5382,20 +5593,19 @@ static void check_unreachable(statement_t const* const stmt) "step of for-statement is unreachable"); } } - - check_unreachable(fors->body); - break; + return; } - case STATEMENT_MS_TRY: { - ms_try_statement_t const *const ms_try = &stmt->ms_try; - check_unreachable(ms_try->try_statement); - check_unreachable(ms_try->final_statement); - } - } + case STATEMENT_COMPOUND: + if (stmt->compound.statements != NULL) + return; + /* FALLTHROUGH*/ - if (stmt->base.next) - check_unreachable(stmt->base.next); + default: + if (!stmt->base.reachable) + warningf(&stmt->base.source_position, "statement is unreachable"); + return; + } } static void parse_external_declaration(void) @@ -5534,7 +5744,7 @@ static void parse_external_declaration(void) noreturn_candidate = true; check_reachable(body); if (warning.unreachable_code) - check_unreachable(body); + walk_statements(body, check_unreachable, NULL); if (warning.missing_noreturn && noreturn_candidate && !(declaration->modifiers & DM_NORETURN)) { @@ -5751,9 +5961,8 @@ static type_t *parse_typename(void) -typedef expression_t* (*parse_expression_function) (unsigned precedence); -typedef expression_t* (*parse_expression_infix_function) (unsigned precedence, - expression_t *left); +typedef expression_t* (*parse_expression_function)(void); +typedef expression_t* (*parse_expression_infix_function)(expression_t *left); typedef struct expression_parser_function_t expression_parser_function_t; struct expression_parser_function_t { @@ -6014,11 +6223,17 @@ static type_t *get_builtin_symbol_type(symbol_t *symbol) return make_function_1_type(type_void_ptr, type_size_t); case T___builtin_huge_val: return make_function_0_type(type_double); + case T___builtin_inf: + return make_function_0_type(type_double); + case T___builtin_inff: + return make_function_0_type(type_float); + case T___builtin_infl: + return make_function_0_type(type_long_double); case T___builtin_nan: return make_function_1_type(type_double, type_char_ptr); case T___builtin_nanf: return make_function_1_type(type_float, type_char_ptr); - case T___builtin_nand: + case T___builtin_nanl: return make_function_1_type(type_long_double, type_char_ptr); case T___builtin_va_end: return make_function_1_type(type_void, type_valist); @@ -6139,12 +6354,11 @@ static expression_t *parse_reference(void) /* this declaration is used */ declaration->used = true; - if (declaration->parent_scope != global_scope && + if (declaration->parent_scope != file_scope && declaration->parent_scope->depth < current_function->scope.depth && is_type_valid(orig_type) && !is_type_function(orig_type)) { /* access of a variable from an outer function */ declaration->address_taken = true; - ref->is_outer_ref = true; current_function->need_closure = true; } @@ -6260,7 +6474,7 @@ static expression_t *parse_cast(void) expression_t *cast = allocate_expression_zero(EXPR_UNARY_CAST); cast->base.source_position = source_position; - expression_t *value = parse_sub_expression(20); + expression_t *value = parse_sub_expression(PREC_CAST); cast->base.type = type; cast->unary.value = value; @@ -6639,7 +6853,6 @@ static expression_t *parse_compare_builtin(void) break; default: internal_errorf(HERE, "invalid compare builtin found"); - break; } expression->base.source_position = *HERE; next_token(); @@ -6847,9 +7060,12 @@ static expression_t *parse_primary_expression(void) case T___builtin_va_arg: return parse_va_arg(); case T___builtin_expect: case T___builtin_alloca: + case T___builtin_inf: + case T___builtin_inff: + case T___builtin_infl: case T___builtin_nan: - case T___builtin_nand: case T___builtin_nanf: + case T___builtin_nanl: case T___builtin_huge_val: case T___builtin_va_end: return parse_builtin_symbol(); case T___builtin_isgreater: @@ -6889,11 +7105,8 @@ static void check_for_char_index_type(const expression_t *expression) } } -static expression_t *parse_array_expression(unsigned precedence, - expression_t *left) +static expression_t *parse_array_expression(expression_t *left) { - (void) precedence; - eat('['); add_anchor_token(']'); @@ -6944,8 +7157,7 @@ static expression_t *parse_array_expression(unsigned precedence, } static expression_t *parse_typeprop(expression_kind_t const kind, - source_position_t const pos, - unsigned const precedence) + source_position_t const pos) { expression_t *tp_expression = allocate_expression_zero(kind); tp_expression->base.type = type_size_t; @@ -6976,7 +7188,7 @@ static expression_t *parse_typeprop(expression_kind_t const kind, rem_anchor_token(')'); expect(')'); } else { - expression_t *expression = parse_sub_expression(precedence); + expression_t *expression = parse_sub_expression(PREC_UNARY); type_t* const orig_type = revert_automatic_type_conversion(expression); expression->base.type = orig_type; @@ -7000,24 +7212,22 @@ end_error: return tp_expression; } -static expression_t *parse_sizeof(unsigned precedence) +static expression_t *parse_sizeof(void) { source_position_t pos = *HERE; eat(T_sizeof); - return parse_typeprop(EXPR_SIZEOF, pos, precedence); + return parse_typeprop(EXPR_SIZEOF, pos); } -static expression_t *parse_alignof(unsigned precedence) +static expression_t *parse_alignof(void) { source_position_t pos = *HERE; eat(T___alignof__); - return parse_typeprop(EXPR_ALIGNOF, pos, precedence); + return parse_typeprop(EXPR_ALIGNOF, pos); } -static expression_t *parse_select_expression(unsigned precedence, - expression_t *compound) +static expression_t *parse_select_expression(expression_t *compound) { - (void) precedence; assert(token.type == '.' || token.type == T_MINUSGREATER); bool is_pointer = (token.type == T_MINUSGREATER); @@ -7162,10 +7372,8 @@ static void check_call_argument(const function_parameter_t *parameter, * * @param expression the function address */ -static expression_t *parse_call_expression(unsigned precedence, - expression_t *expression) +static expression_t *parse_call_expression(expression_t *expression) { - (void) precedence; expression_t *result = allocate_expression_zero(EXPR_CALL); result->base.source_position = expression->base.source_position; @@ -7272,8 +7480,7 @@ static bool same_compound_type(const type_t *type1, const type_t *type2) * * @param expression the conditional expression */ -static expression_t *parse_conditional_expression(unsigned precedence, - expression_t *expression) +static expression_t *parse_conditional_expression(expression_t *expression) { expression_t *result = allocate_expression_zero(EXPR_CONDITIONAL); @@ -7300,7 +7507,7 @@ static expression_t *parse_conditional_expression(unsigned precedence, true_expression = parse_expression(); rem_anchor_token(':'); expect(':'); - expression_t *false_expression = parse_sub_expression(precedence); + expression_t *false_expression = parse_sub_expression(PREC_CONDITIONAL); type_t *const orig_true_type = true_expression->base.type; type_t *const orig_false_type = false_expression->base.type; @@ -7373,13 +7580,13 @@ static expression_t *parse_conditional_expression(unsigned precedence, "pointer/integer type mismatch in conditional expression ('%T' and '%T')", true_type, false_type); result_type = pointer_type; } else { - type_error_incompatible("while parsing conditional", - &expression->base.source_position, true_type, false_type); + if (is_type_valid(other_type)) { + type_error_incompatible("while parsing conditional", + &expression->base.source_position, true_type, false_type); + } result_type = type_error_type; } } else { - /* TODO: one pointer to void*, other some pointer */ - if (is_type_valid(true_type) && is_type_valid(false_type)) { type_error_incompatible("while parsing conditional", &conditional->base.source_position, true_type, @@ -7401,13 +7608,13 @@ end_error: /** * Parse an extension expression. */ -static expression_t *parse_extension(unsigned precedence) +static expression_t *parse_extension(void) { eat(T___extension__); bool old_gcc_extension = in_gcc_extension; in_gcc_extension = true; - expression_t *expression = parse_sub_expression(precedence); + expression_t *expression = parse_sub_expression(PREC_UNARY); in_gcc_extension = old_gcc_extension; return expression; } @@ -7415,7 +7622,7 @@ static expression_t *parse_extension(unsigned precedence) /** * Parse a __builtin_classify_type() expression. */ -static expression_t *parse_builtin_classify_type(const unsigned precedence) +static expression_t *parse_builtin_classify_type(void) { eat(T___builtin_classify_type); @@ -7424,7 +7631,7 @@ static expression_t *parse_builtin_classify_type(const unsigned precedence) expect('('); add_anchor_token(')'); - expression_t *expression = parse_sub_expression(precedence); + expression_t *expression = parse_expression(); rem_anchor_token(')'); expect(')'); result->classify_type.type_expression = expression; @@ -7477,7 +7684,10 @@ static bool is_lvalue(const expression_t *expression) return true; default: - return false; + /* Claim it is an lvalue, if the type is invalid. There was a parse + * error before, which maybe prevented properly recognizing it as + * lvalue. */ + return !is_type_valid(skip_typeref(expression->base.type)); } } @@ -7647,7 +7857,7 @@ static void semantic_take_addr(unary_expression_t *expression) value->base.type = revert_automatic_type_conversion(value); type_t *orig_type = value->base.type; - if (!is_type_valid(orig_type)) + if (!is_type_valid(skip_typeref(orig_type))) return; set_address_taken(value, false); @@ -7655,18 +7865,18 @@ static void semantic_take_addr(unary_expression_t *expression) expression->base.type = make_pointer_type(orig_type, TYPE_QUALIFIER_NONE); } -#define CREATE_UNARY_EXPRESSION_PARSER(token_type, unexpression_type, sfunc) \ -static expression_t *parse_##unexpression_type(unsigned precedence) \ -{ \ - expression_t *unary_expression \ - = allocate_expression_zero(unexpression_type); \ - unary_expression->base.source_position = *HERE; \ - eat(token_type); \ - unary_expression->unary.value = parse_sub_expression(precedence); \ - \ - sfunc(&unary_expression->unary); \ - \ - return unary_expression; \ +#define CREATE_UNARY_EXPRESSION_PARSER(token_type, unexpression_type, sfunc) \ +static expression_t *parse_##unexpression_type(void) \ +{ \ + expression_t *unary_expression \ + = allocate_expression_zero(unexpression_type); \ + unary_expression->base.source_position = *HERE; \ + eat(token_type); \ + unary_expression->unary.value = parse_sub_expression(PREC_UNARY); \ + \ + sfunc(&unary_expression->unary); \ + \ + return unary_expression; \ } CREATE_UNARY_EXPRESSION_PARSER('-', EXPR_UNARY_NEGATE, @@ -7688,11 +7898,8 @@ CREATE_UNARY_EXPRESSION_PARSER(T_MINUSMINUS, EXPR_UNARY_PREFIX_DECREMENT, #define CREATE_UNARY_POSTFIX_EXPRESSION_PARSER(token_type, unexpression_type, \ sfunc) \ -static expression_t *parse_##unexpression_type(unsigned precedence, \ - expression_t *left) \ +static expression_t *parse_##unexpression_type(expression_t *left) \ { \ - (void) precedence; \ - \ expression_t *unary_expression \ = allocate_expression_zero(unexpression_type); \ unary_expression->base.source_position = *HERE; \ @@ -8344,78 +8551,58 @@ static void semantic_comma(binary_expression_t *expression) expression->base.type = expression->right->base.type; } -#define CREATE_BINEXPR_PARSER(token_type, binexpression_type, sfunc, lr) \ -static expression_t *parse_##binexpression_type(unsigned precedence, \ - expression_t *left) \ -{ \ - expression_t *binexpr = allocate_expression_zero(binexpression_type); \ - binexpr->base.source_position = *HERE; \ - binexpr->binary.left = left; \ - eat(token_type); \ - \ - expression_t *right = parse_sub_expression(precedence + lr); \ - \ - binexpr->binary.right = right; \ - sfunc(&binexpr->binary); \ - \ - return binexpr; \ -} - -CREATE_BINEXPR_PARSER(',', EXPR_BINARY_COMMA, semantic_comma, 1) -CREATE_BINEXPR_PARSER('*', EXPR_BINARY_MUL, semantic_binexpr_arithmetic, 1) -CREATE_BINEXPR_PARSER('/', EXPR_BINARY_DIV, semantic_divmod_arithmetic, 1) -CREATE_BINEXPR_PARSER('%', EXPR_BINARY_MOD, semantic_divmod_arithmetic, 1) -CREATE_BINEXPR_PARSER('+', EXPR_BINARY_ADD, semantic_add, 1) -CREATE_BINEXPR_PARSER('-', EXPR_BINARY_SUB, semantic_sub, 1) -CREATE_BINEXPR_PARSER('<', EXPR_BINARY_LESS, semantic_comparison, 1) -CREATE_BINEXPR_PARSER('>', EXPR_BINARY_GREATER, semantic_comparison, 1) -CREATE_BINEXPR_PARSER('=', EXPR_BINARY_ASSIGN, semantic_binexpr_assign, 0) - -CREATE_BINEXPR_PARSER(T_EQUALEQUAL, EXPR_BINARY_EQUAL, - semantic_comparison, 1) -CREATE_BINEXPR_PARSER(T_EXCLAMATIONMARKEQUAL, EXPR_BINARY_NOTEQUAL, - semantic_comparison, 1) -CREATE_BINEXPR_PARSER(T_LESSEQUAL, EXPR_BINARY_LESSEQUAL, - semantic_comparison, 1) -CREATE_BINEXPR_PARSER(T_GREATEREQUAL, EXPR_BINARY_GREATEREQUAL, - semantic_comparison, 1) - -CREATE_BINEXPR_PARSER('&', EXPR_BINARY_BITWISE_AND, - semantic_binexpr_arithmetic, 1) -CREATE_BINEXPR_PARSER('|', EXPR_BINARY_BITWISE_OR, - semantic_binexpr_arithmetic, 1) -CREATE_BINEXPR_PARSER('^', EXPR_BINARY_BITWISE_XOR, - semantic_binexpr_arithmetic, 1) -CREATE_BINEXPR_PARSER(T_ANDAND, EXPR_BINARY_LOGICAL_AND, - semantic_logical_op, 1) -CREATE_BINEXPR_PARSER(T_PIPEPIPE, EXPR_BINARY_LOGICAL_OR, - semantic_logical_op, 1) -CREATE_BINEXPR_PARSER(T_LESSLESS, EXPR_BINARY_SHIFTLEFT, - semantic_shift_op, 1) -CREATE_BINEXPR_PARSER(T_GREATERGREATER, EXPR_BINARY_SHIFTRIGHT, - semantic_shift_op, 1) -CREATE_BINEXPR_PARSER(T_PLUSEQUAL, EXPR_BINARY_ADD_ASSIGN, - semantic_arithmetic_addsubb_assign, 0) -CREATE_BINEXPR_PARSER(T_MINUSEQUAL, EXPR_BINARY_SUB_ASSIGN, - semantic_arithmetic_addsubb_assign, 0) -CREATE_BINEXPR_PARSER(T_ASTERISKEQUAL, EXPR_BINARY_MUL_ASSIGN, - semantic_arithmetic_assign, 0) -CREATE_BINEXPR_PARSER(T_SLASHEQUAL, EXPR_BINARY_DIV_ASSIGN, - semantic_divmod_assign, 0) -CREATE_BINEXPR_PARSER(T_PERCENTEQUAL, EXPR_BINARY_MOD_ASSIGN, - semantic_divmod_assign, 0) -CREATE_BINEXPR_PARSER(T_LESSLESSEQUAL, EXPR_BINARY_SHIFTLEFT_ASSIGN, - semantic_arithmetic_assign, 0) -CREATE_BINEXPR_PARSER(T_GREATERGREATEREQUAL, EXPR_BINARY_SHIFTRIGHT_ASSIGN, - semantic_arithmetic_assign, 0) -CREATE_BINEXPR_PARSER(T_ANDEQUAL, EXPR_BINARY_BITWISE_AND_ASSIGN, - semantic_arithmetic_assign, 0) -CREATE_BINEXPR_PARSER(T_PIPEEQUAL, EXPR_BINARY_BITWISE_OR_ASSIGN, - semantic_arithmetic_assign, 0) -CREATE_BINEXPR_PARSER(T_CARETEQUAL, EXPR_BINARY_BITWISE_XOR_ASSIGN, - semantic_arithmetic_assign, 0) - -static expression_t *parse_sub_expression(unsigned precedence) +/** + * @param prec_r precedence of the right operand + */ +#define CREATE_BINEXPR_PARSER(token_type, binexpression_type, prec_r, sfunc) \ +static expression_t *parse_##binexpression_type(expression_t *left) \ +{ \ + expression_t *binexpr = allocate_expression_zero(binexpression_type); \ + binexpr->base.source_position = *HERE; \ + binexpr->binary.left = left; \ + eat(token_type); \ + \ + expression_t *right = parse_sub_expression(prec_r); \ + \ + binexpr->binary.right = right; \ + sfunc(&binexpr->binary); \ + \ + return binexpr; \ +} + +CREATE_BINEXPR_PARSER('*', EXPR_BINARY_MUL, PREC_CAST, semantic_binexpr_arithmetic) +CREATE_BINEXPR_PARSER('/', EXPR_BINARY_DIV, PREC_CAST, semantic_divmod_arithmetic) +CREATE_BINEXPR_PARSER('%', EXPR_BINARY_MOD, PREC_CAST, semantic_divmod_arithmetic) +CREATE_BINEXPR_PARSER('+', EXPR_BINARY_ADD, PREC_MULTIPLICATIVE, semantic_add) +CREATE_BINEXPR_PARSER('-', EXPR_BINARY_SUB, PREC_MULTIPLICATIVE, semantic_sub) +CREATE_BINEXPR_PARSER(T_LESSLESS, EXPR_BINARY_SHIFTLEFT, PREC_ADDITIVE, semantic_shift_op) +CREATE_BINEXPR_PARSER(T_GREATERGREATER, EXPR_BINARY_SHIFTRIGHT, PREC_ADDITIVE, semantic_shift_op) +CREATE_BINEXPR_PARSER('<', EXPR_BINARY_LESS, PREC_SHIFT, semantic_comparison) +CREATE_BINEXPR_PARSER('>', EXPR_BINARY_GREATER, PREC_SHIFT, semantic_comparison) +CREATE_BINEXPR_PARSER(T_LESSEQUAL, EXPR_BINARY_LESSEQUAL, PREC_SHIFT, semantic_comparison) +CREATE_BINEXPR_PARSER(T_GREATEREQUAL, EXPR_BINARY_GREATEREQUAL, PREC_SHIFT, semantic_comparison) +CREATE_BINEXPR_PARSER(T_EXCLAMATIONMARKEQUAL, EXPR_BINARY_NOTEQUAL, PREC_RELATIONAL, semantic_comparison) +CREATE_BINEXPR_PARSER(T_EQUALEQUAL, EXPR_BINARY_EQUAL, PREC_RELATIONAL, semantic_comparison) +CREATE_BINEXPR_PARSER('&', EXPR_BINARY_BITWISE_AND, PREC_EQUALITY, semantic_binexpr_arithmetic) +CREATE_BINEXPR_PARSER('^', EXPR_BINARY_BITWISE_XOR, PREC_AND, semantic_binexpr_arithmetic) +CREATE_BINEXPR_PARSER('|', EXPR_BINARY_BITWISE_OR, PREC_XOR, semantic_binexpr_arithmetic) +CREATE_BINEXPR_PARSER(T_ANDAND, EXPR_BINARY_LOGICAL_AND, PREC_OR, semantic_logical_op) +CREATE_BINEXPR_PARSER(T_PIPEPIPE, EXPR_BINARY_LOGICAL_OR, PREC_LOGICAL_AND, semantic_logical_op) +CREATE_BINEXPR_PARSER('=', EXPR_BINARY_ASSIGN, PREC_ASSIGNMENT, semantic_binexpr_assign) +CREATE_BINEXPR_PARSER(T_PLUSEQUAL, EXPR_BINARY_ADD_ASSIGN, PREC_ASSIGNMENT, semantic_arithmetic_addsubb_assign) +CREATE_BINEXPR_PARSER(T_MINUSEQUAL, EXPR_BINARY_SUB_ASSIGN, PREC_ASSIGNMENT, semantic_arithmetic_addsubb_assign) +CREATE_BINEXPR_PARSER(T_ASTERISKEQUAL, EXPR_BINARY_MUL_ASSIGN, PREC_ASSIGNMENT, semantic_arithmetic_assign) +CREATE_BINEXPR_PARSER(T_SLASHEQUAL, EXPR_BINARY_DIV_ASSIGN, PREC_ASSIGNMENT, semantic_divmod_assign) +CREATE_BINEXPR_PARSER(T_PERCENTEQUAL, EXPR_BINARY_MOD_ASSIGN, PREC_ASSIGNMENT, semantic_divmod_assign) +CREATE_BINEXPR_PARSER(T_LESSLESSEQUAL, EXPR_BINARY_SHIFTLEFT_ASSIGN, PREC_ASSIGNMENT, semantic_arithmetic_assign) +CREATE_BINEXPR_PARSER(T_GREATERGREATEREQUAL, EXPR_BINARY_SHIFTRIGHT_ASSIGN, PREC_ASSIGNMENT, semantic_arithmetic_assign) +CREATE_BINEXPR_PARSER(T_ANDEQUAL, EXPR_BINARY_BITWISE_AND_ASSIGN, PREC_ASSIGNMENT, semantic_arithmetic_assign) +CREATE_BINEXPR_PARSER(T_PIPEEQUAL, EXPR_BINARY_BITWISE_OR_ASSIGN, PREC_ASSIGNMENT, semantic_arithmetic_assign) +CREATE_BINEXPR_PARSER(T_CARETEQUAL, EXPR_BINARY_BITWISE_XOR_ASSIGN, PREC_ASSIGNMENT, semantic_arithmetic_assign) +CREATE_BINEXPR_PARSER(',', EXPR_BINARY_COMMA, PREC_ASSIGNMENT, semantic_comma) + + +static expression_t *parse_sub_expression(precedence_t precedence) { if (token.type < 0) { return expected_expression_error(); @@ -8427,7 +8614,7 @@ static expression_t *parse_sub_expression(unsigned precedence) expression_t *left; if (parser->parser != NULL) { - left = parser->parser(parser->precedence); + left = parser->parser(); } else { left = parse_primary_expression(); } @@ -8445,7 +8632,7 @@ static expression_t *parse_sub_expression(unsigned precedence) if (parser->infix_precedence < precedence) break; - left = parser->infix_parser(parser->infix_precedence, left); + left = parser->infix_parser(left); assert(left != NULL); assert(left->kind != EXPR_UNKNOWN); @@ -8460,7 +8647,7 @@ static expression_t *parse_sub_expression(unsigned precedence) */ static expression_t *parse_expression(void) { - return parse_sub_expression(1); + return parse_sub_expression(PREC_EXPRESSION); } /** @@ -8511,69 +8698,56 @@ static void init_expression_parsers(void) { memset(&expression_parsers, 0, sizeof(expression_parsers)); - register_infix_parser(parse_array_expression, '[', 30); - register_infix_parser(parse_call_expression, '(', 30); - register_infix_parser(parse_select_expression, '.', 30); - register_infix_parser(parse_select_expression, T_MINUSGREATER, 30); - register_infix_parser(parse_EXPR_UNARY_POSTFIX_INCREMENT, - T_PLUSPLUS, 30); - register_infix_parser(parse_EXPR_UNARY_POSTFIX_DECREMENT, - T_MINUSMINUS, 30); - - register_infix_parser(parse_EXPR_BINARY_MUL, '*', 17); - register_infix_parser(parse_EXPR_BINARY_DIV, '/', 17); - register_infix_parser(parse_EXPR_BINARY_MOD, '%', 17); - register_infix_parser(parse_EXPR_BINARY_ADD, '+', 16); - register_infix_parser(parse_EXPR_BINARY_SUB, '-', 16); - register_infix_parser(parse_EXPR_BINARY_SHIFTLEFT, T_LESSLESS, 15); - register_infix_parser(parse_EXPR_BINARY_SHIFTRIGHT, T_GREATERGREATER, 15); - register_infix_parser(parse_EXPR_BINARY_LESS, '<', 14); - register_infix_parser(parse_EXPR_BINARY_GREATER, '>', 14); - register_infix_parser(parse_EXPR_BINARY_LESSEQUAL, T_LESSEQUAL, 14); - register_infix_parser(parse_EXPR_BINARY_GREATEREQUAL, T_GREATEREQUAL, 14); - register_infix_parser(parse_EXPR_BINARY_EQUAL, T_EQUALEQUAL, 13); - register_infix_parser(parse_EXPR_BINARY_NOTEQUAL, - T_EXCLAMATIONMARKEQUAL, 13); - register_infix_parser(parse_EXPR_BINARY_BITWISE_AND, '&', 12); - register_infix_parser(parse_EXPR_BINARY_BITWISE_XOR, '^', 11); - register_infix_parser(parse_EXPR_BINARY_BITWISE_OR, '|', 10); - register_infix_parser(parse_EXPR_BINARY_LOGICAL_AND, T_ANDAND, 9); - register_infix_parser(parse_EXPR_BINARY_LOGICAL_OR, T_PIPEPIPE, 8); - register_infix_parser(parse_conditional_expression, '?', 7); - register_infix_parser(parse_EXPR_BINARY_ASSIGN, '=', 2); - register_infix_parser(parse_EXPR_BINARY_ADD_ASSIGN, T_PLUSEQUAL, 2); - register_infix_parser(parse_EXPR_BINARY_SUB_ASSIGN, T_MINUSEQUAL, 2); - register_infix_parser(parse_EXPR_BINARY_MUL_ASSIGN, T_ASTERISKEQUAL, 2); - register_infix_parser(parse_EXPR_BINARY_DIV_ASSIGN, T_SLASHEQUAL, 2); - register_infix_parser(parse_EXPR_BINARY_MOD_ASSIGN, T_PERCENTEQUAL, 2); - register_infix_parser(parse_EXPR_BINARY_SHIFTLEFT_ASSIGN, - T_LESSLESSEQUAL, 2); - register_infix_parser(parse_EXPR_BINARY_SHIFTRIGHT_ASSIGN, - T_GREATERGREATEREQUAL, 2); - register_infix_parser(parse_EXPR_BINARY_BITWISE_AND_ASSIGN, - T_ANDEQUAL, 2); - register_infix_parser(parse_EXPR_BINARY_BITWISE_OR_ASSIGN, - T_PIPEEQUAL, 2); - register_infix_parser(parse_EXPR_BINARY_BITWISE_XOR_ASSIGN, - T_CARETEQUAL, 2); - - register_infix_parser(parse_EXPR_BINARY_COMMA, ',', 1); - - register_expression_parser(parse_EXPR_UNARY_NEGATE, '-', 25); - register_expression_parser(parse_EXPR_UNARY_PLUS, '+', 25); - register_expression_parser(parse_EXPR_UNARY_NOT, '!', 25); - register_expression_parser(parse_EXPR_UNARY_BITWISE_NEGATE, '~', 25); - register_expression_parser(parse_EXPR_UNARY_DEREFERENCE, '*', 25); - register_expression_parser(parse_EXPR_UNARY_TAKE_ADDRESS, '&', 25); - register_expression_parser(parse_EXPR_UNARY_PREFIX_INCREMENT, - T_PLUSPLUS, 25); - register_expression_parser(parse_EXPR_UNARY_PREFIX_DECREMENT, - T_MINUSMINUS, 25); - register_expression_parser(parse_sizeof, T_sizeof, 25); - register_expression_parser(parse_alignof, T___alignof__, 25); - register_expression_parser(parse_extension, T___extension__, 25); - register_expression_parser(parse_builtin_classify_type, - T___builtin_classify_type, 25); + register_infix_parser(parse_array_expression, '[', PREC_POSTFIX); + register_infix_parser(parse_call_expression, '(', PREC_POSTFIX); + register_infix_parser(parse_select_expression, '.', PREC_POSTFIX); + register_infix_parser(parse_select_expression, T_MINUSGREATER, PREC_POSTFIX); + register_infix_parser(parse_EXPR_UNARY_POSTFIX_INCREMENT, T_PLUSPLUS, PREC_POSTFIX); + register_infix_parser(parse_EXPR_UNARY_POSTFIX_DECREMENT, T_MINUSMINUS, PREC_POSTFIX); + register_infix_parser(parse_EXPR_BINARY_MUL, '*', PREC_MULTIPLICATIVE); + register_infix_parser(parse_EXPR_BINARY_DIV, '/', PREC_MULTIPLICATIVE); + register_infix_parser(parse_EXPR_BINARY_MOD, '%', PREC_MULTIPLICATIVE); + register_infix_parser(parse_EXPR_BINARY_ADD, '+', PREC_ADDITIVE); + register_infix_parser(parse_EXPR_BINARY_SUB, '-', PREC_ADDITIVE); + register_infix_parser(parse_EXPR_BINARY_SHIFTLEFT, T_LESSLESS, PREC_SHIFT); + register_infix_parser(parse_EXPR_BINARY_SHIFTRIGHT, T_GREATERGREATER, PREC_SHIFT); + register_infix_parser(parse_EXPR_BINARY_LESS, '<', PREC_RELATIONAL); + register_infix_parser(parse_EXPR_BINARY_GREATER, '>', PREC_RELATIONAL); + register_infix_parser(parse_EXPR_BINARY_LESSEQUAL, T_LESSEQUAL, PREC_RELATIONAL); + register_infix_parser(parse_EXPR_BINARY_GREATEREQUAL, T_GREATEREQUAL, PREC_RELATIONAL); + register_infix_parser(parse_EXPR_BINARY_EQUAL, T_EQUALEQUAL, PREC_EQUALITY); + register_infix_parser(parse_EXPR_BINARY_NOTEQUAL, T_EXCLAMATIONMARKEQUAL, PREC_EQUALITY); + register_infix_parser(parse_EXPR_BINARY_BITWISE_AND, '&', PREC_AND); + register_infix_parser(parse_EXPR_BINARY_BITWISE_XOR, '^', PREC_XOR); + register_infix_parser(parse_EXPR_BINARY_BITWISE_OR, '|', PREC_OR); + register_infix_parser(parse_EXPR_BINARY_LOGICAL_AND, T_ANDAND, PREC_LOGICAL_AND); + register_infix_parser(parse_EXPR_BINARY_LOGICAL_OR, T_PIPEPIPE, PREC_LOGICAL_OR); + register_infix_parser(parse_conditional_expression, '?', PREC_CONDITIONAL); + register_infix_parser(parse_EXPR_BINARY_ASSIGN, '=', PREC_ASSIGNMENT); + register_infix_parser(parse_EXPR_BINARY_ADD_ASSIGN, T_PLUSEQUAL, PREC_ASSIGNMENT); + register_infix_parser(parse_EXPR_BINARY_SUB_ASSIGN, T_MINUSEQUAL, PREC_ASSIGNMENT); + register_infix_parser(parse_EXPR_BINARY_MUL_ASSIGN, T_ASTERISKEQUAL, PREC_ASSIGNMENT); + register_infix_parser(parse_EXPR_BINARY_DIV_ASSIGN, T_SLASHEQUAL, PREC_ASSIGNMENT); + register_infix_parser(parse_EXPR_BINARY_MOD_ASSIGN, T_PERCENTEQUAL, PREC_ASSIGNMENT); + register_infix_parser(parse_EXPR_BINARY_SHIFTLEFT_ASSIGN, T_LESSLESSEQUAL, PREC_ASSIGNMENT); + register_infix_parser(parse_EXPR_BINARY_SHIFTRIGHT_ASSIGN, T_GREATERGREATEREQUAL, PREC_ASSIGNMENT); + register_infix_parser(parse_EXPR_BINARY_BITWISE_AND_ASSIGN, T_ANDEQUAL, PREC_ASSIGNMENT); + register_infix_parser(parse_EXPR_BINARY_BITWISE_OR_ASSIGN, T_PIPEEQUAL, PREC_ASSIGNMENT); + register_infix_parser(parse_EXPR_BINARY_BITWISE_XOR_ASSIGN, T_CARETEQUAL, PREC_ASSIGNMENT); + register_infix_parser(parse_EXPR_BINARY_COMMA, ',', PREC_EXPRESSION); + + register_expression_parser(parse_EXPR_UNARY_NEGATE, '-', PREC_UNARY); + register_expression_parser(parse_EXPR_UNARY_PLUS, '+', PREC_UNARY); + register_expression_parser(parse_EXPR_UNARY_NOT, '!', PREC_UNARY); + register_expression_parser(parse_EXPR_UNARY_BITWISE_NEGATE, '~', PREC_UNARY); + register_expression_parser(parse_EXPR_UNARY_DEREFERENCE, '*', PREC_UNARY); + register_expression_parser(parse_EXPR_UNARY_TAKE_ADDRESS, '&', PREC_UNARY); + register_expression_parser(parse_EXPR_UNARY_PREFIX_INCREMENT, T_PLUSPLUS, PREC_UNARY); + register_expression_parser(parse_EXPR_UNARY_PREFIX_DECREMENT, T_MINUSMINUS, PREC_UNARY); + register_expression_parser(parse_sizeof, T_sizeof, PREC_UNARY); + register_expression_parser(parse_alignof, T___alignof__, PREC_UNARY); + register_expression_parser(parse_extension, T___extension__, PREC_UNARY); + register_expression_parser(parse_builtin_classify_type, T___builtin_classify_type, PREC_UNARY); } /** @@ -8654,6 +8828,11 @@ static asm_argument_t *parse_asm_arguments(bool is_out) errorf(&expression->base.source_position, "asm output argument is not an lvalue"); } + + if (argument->constraints.begin[0] == '+') + mark_decls_read(expression, NULL); + } else { + mark_decls_read(expression, NULL); } argument->expression = expression; expect(')'); @@ -8709,13 +8888,11 @@ static asm_clobber_t *parse_asm_clobbers(void) */ static statement_t *parse_asm_statement(void) { - eat(T_asm); - - statement_t *statement = allocate_statement_zero(STATEMENT_ASM); - statement->base.source_position = token.source_position; - + statement_t *statement = allocate_statement_zero(STATEMENT_ASM); asm_statement_t *asm_statement = &statement->asms; + eat(T_asm); + if (token.type == T_volatile) { next_token(); asm_statement->is_volatile = true; @@ -8770,19 +8947,18 @@ end_error: */ static statement_t *parse_case_statement(void) { - eat(T_case); - statement_t *const statement = allocate_statement_zero(STATEMENT_CASE_LABEL); source_position_t *const pos = &statement->base.source_position; - *pos = token.source_position; + eat(T_case); + expression_t *const expression = parse_expression(); statement->case_label.expression = expression; if (!is_constant_expression(expression)) { /* This check does not prevent the error message in all cases of an * prior error while parsing the expression. At least it catches the * common case of a mistyped enum entry. */ - if (is_type_valid(expression->base.type)) { + if (is_type_valid(skip_typeref(expression->base.type))) { errorf(pos, "case label does not reduce to an integer constant"); } statement->case_label.is_bad = true; @@ -8801,7 +8977,7 @@ static statement_t *parse_case_statement(void) /* This check does not prevent the error message in all cases of an * prior error while parsing the expression. At least it catches the * common case of a mistyped enum entry. */ - if (is_type_valid(end_range->base.type)) { + if (is_type_valid(skip_typeref(end_range->base.type))) { errorf(pos, "case range does not reduce to an integer constant"); } statement->case_label.is_bad = true; @@ -8866,10 +9042,9 @@ end_error: */ static statement_t *parse_default_statement(void) { - eat(T_default); - statement_t *statement = allocate_statement_zero(STATEMENT_CASE_LABEL); - statement->base.source_position = token.source_position; + + eat(T_default); PUSH_PARENT(statement); @@ -8914,14 +9089,13 @@ end_error: static statement_t *parse_label_statement(void) { assert(token.type == T_IDENTIFIER); - symbol_t *symbol = token.v.symbol; - next_token(); - - declaration_t *label = get_label(symbol); + symbol_t *symbol = token.v.symbol; + declaration_t *label = get_label(symbol); statement_t *const statement = allocate_statement_zero(STATEMENT_LABEL); - statement->base.source_position = token.source_position; - statement->label.label = label; + statement->label.label = label; + + next_token(); PUSH_PARENT(statement); @@ -8977,19 +9151,25 @@ static statement_t *parse_label_statement(void) */ static statement_t *parse_if(void) { - eat(T_if); + statement_t *statement = allocate_statement_zero(STATEMENT_IF); - statement_t *statement = allocate_statement_zero(STATEMENT_IF); - statement->base.source_position = token.source_position; + eat(T_if); PUSH_PARENT(statement); + add_anchor_token('{'); + expect('('); add_anchor_token(')'); - statement->ifs.condition = parse_expression(); + expression_t *const expr = parse_expression(); + statement->ifs.condition = expr; + mark_decls_read(expr, NULL); rem_anchor_token(')'); expect(')'); +end_error: + rem_anchor_token('{'); + add_anchor_token(T_else); statement->ifs.true_statement = parse_statement(); rem_anchor_token(T_else); @@ -9001,9 +9181,6 @@ static statement_t *parse_if(void) POP_PARENT; return statement; -end_error: - POP_PARENT; - return create_invalid_statement(); } /** @@ -9051,16 +9228,16 @@ static void check_enum_cases(const switch_statement_t *statement) { */ static statement_t *parse_switch(void) { - eat(T_switch); + statement_t *statement = allocate_statement_zero(STATEMENT_SWITCH); - statement_t *statement = allocate_statement_zero(STATEMENT_SWITCH); - statement->base.source_position = token.source_position; + eat(T_switch); PUSH_PARENT(statement); expect('('); add_anchor_token(')'); expression_t *const expr = parse_expression(); + mark_decls_read(expr, NULL); type_t * type = skip_typeref(expr->base.type); if (is_type_integer(type)) { type = promote_integer(type); @@ -9115,16 +9292,17 @@ static statement_t *parse_loop_body(statement_t *const loop) */ static statement_t *parse_while(void) { - eat(T_while); + statement_t *statement = allocate_statement_zero(STATEMENT_WHILE); - statement_t *statement = allocate_statement_zero(STATEMENT_WHILE); - statement->base.source_position = token.source_position; + eat(T_while); PUSH_PARENT(statement); expect('('); add_anchor_token(')'); - statement->whiles.condition = parse_expression(); + expression_t *const cond = parse_expression(); + statement->whiles.condition = cond; + mark_decls_read(cond, NULL); rem_anchor_token(')'); expect(')'); @@ -9142,12 +9320,11 @@ end_error: */ static statement_t *parse_do(void) { - eat(T_do); - statement_t *statement = allocate_statement_zero(STATEMENT_DO_WHILE); - statement->base.source_position = token.source_position; - PUSH_PARENT(statement) + eat(T_do); + + PUSH_PARENT(statement); add_anchor_token(T_while); statement->do_while.body = parse_loop_body(statement); @@ -9156,7 +9333,9 @@ static statement_t *parse_do(void) expect(T_while); expect('('); add_anchor_token(')'); - statement->do_while.condition = parse_expression(); + expression_t *const cond = parse_expression(); + statement->do_while.condition = cond; + mark_decls_read(cond, NULL); rem_anchor_token(')'); expect(')'); expect(';'); @@ -9173,10 +9352,9 @@ end_error: */ static statement_t *parse_for(void) { - eat(T_for); + statement_t *statement = allocate_statement_zero(STATEMENT_FOR); - statement_t *statement = allocate_statement_zero(STATEMENT_FOR); - statement->base.source_position = token.source_position; + eat(T_for); PUSH_PARENT(statement); @@ -9193,6 +9371,7 @@ static statement_t *parse_for(void) add_anchor_token(';'); expression_t *const init = parse_expression(); statement->fors.initialisation = init; + mark_decls_read(init, DECL_ANY); if (warning.unused_value && !expression_has_effect(init)) { warningf(&init->base.source_position, "initialisation of 'for'-statement has no effect"); @@ -9206,13 +9385,16 @@ static statement_t *parse_for(void) if (token.type != ';') { add_anchor_token(';'); - statement->fors.condition = parse_expression(); + expression_t *const cond = parse_expression(); + statement->fors.condition = cond; + mark_decls_read(cond, NULL); rem_anchor_token(';'); } expect(';'); if (token.type != ')') { expression_t *const step = parse_expression(); statement->fors.step = step; + mark_decls_read(step, DECL_ANY); if (warning.unused_value && !expression_has_effect(step)) { warningf(&step->base.source_position, "step of 'for'-statement has no effect"); @@ -9244,13 +9426,13 @@ end_error: */ static statement_t *parse_goto(void) { - source_position_t source_position = token.source_position; + statement_t *statement = allocate_statement_zero(STATEMENT_GOTO); eat(T_goto); - statement_t *statement; if (GNU_MODE && token.type == '*') { next_token(); expression_t *expression = parse_expression(); + mark_decls_read(expression, NULL); /* Argh: although documentation say the expression must be of type void *, * gcc excepts anything that can be casted into void * without error */ @@ -9258,17 +9440,16 @@ static statement_t *parse_goto(void) if (type != type_error_type) { if (!is_type_pointer(type) && !is_type_integer(type)) { - errorf(&source_position, "cannot convert to a pointer type"); + errorf(&expression->base.source_position, + "cannot convert to a pointer type"); } else if (type != type_void_ptr) { - warningf(&source_position, + warningf(&expression->base.source_position, "type of computed goto expression should be 'void*' not '%T'", type); } expression = create_implicit_cast(expression, type_void_ptr); } - statement = allocate_statement_zero(STATEMENT_GOTO); - statement->base.source_position = source_position; - statement->gotos.expression = expression; + statement->gotos.expression = expression; } else { if (token.type != T_IDENTIFIER) { if (GNU_MODE) @@ -9281,13 +9462,7 @@ static statement_t *parse_goto(void) symbol_t *symbol = token.v.symbol; next_token(); - statement = allocate_statement_zero(STATEMENT_GOTO); - statement->base.source_position = source_position; - statement->gotos.label = get_label(symbol); - - if (statement->gotos.label->parent_scope->depth < current_function->scope.depth) { - statement->gotos.outer_fkt_jmp = true; - } + statement->gotos.label = get_label(symbol); } /* remember the goto's in a list for later checking */ @@ -9315,7 +9490,6 @@ static statement_t *parse_continue(void) } statement_t *statement = allocate_statement_zero(STATEMENT_CONTINUE); - statement->base.source_position = token.source_position; eat(T_continue); expect(';'); @@ -9334,7 +9508,6 @@ static statement_t *parse_break(void) } statement_t *statement = allocate_statement_zero(STATEMENT_BREAK); - statement->base.source_position = token.source_position; eat(T_break); expect(';'); @@ -9353,7 +9526,6 @@ static statement_t *parse_leave_statement(void) } statement_t *statement = allocate_statement_zero(STATEMENT_LEAVE); - statement->base.source_position = token.source_position; eat(T___leave); expect(';'); @@ -9426,14 +9598,14 @@ declaration_t *expr_is_variable(const expression_t *expression) */ static statement_t *parse_return(void) { - statement_t *statement = allocate_statement_zero(STATEMENT_RETURN); - statement->base.source_position = token.source_position; - eat(T_return); + statement_t *statement = allocate_statement_zero(STATEMENT_RETURN); + expression_t *return_value = NULL; if (token.type != ';') { return_value = parse_expression(); + mark_decls_read(return_value, NULL); } const type_t *const func_type = current_function->type; @@ -9484,8 +9656,6 @@ static statement_t *parse_declaration_statement(void) { statement_t *statement = allocate_statement_zero(STATEMENT_DECLARATION); - statement->base.source_position = token.source_position; - declaration_t *before = last_declaration; if (GNU_MODE) parse_external_declaration(); @@ -9509,9 +9679,9 @@ static statement_t *parse_expression_statement(void) { statement_t *statement = allocate_statement_zero(STATEMENT_EXPRESSION); - statement->base.source_position = token.source_position; expression_t *const expr = parse_expression(); statement->expression.expression = expr; + mark_decls_read(expr, DECL_ANY); expect(';'); @@ -9526,7 +9696,6 @@ end_error: static statement_t *parse_ms_try_statment(void) { statement_t *statement = allocate_statement_zero(STATEMENT_MS_TRY); - statement->base.source_position = token.source_position; eat(T___try); PUSH_PARENT(statement); @@ -9543,6 +9712,7 @@ static statement_t *parse_ms_try_statment(void) expect('('); add_anchor_token(')'); expression_t *const expr = parse_expression(); + mark_decls_read(expr, NULL); type_t * type = skip_typeref(expr->base.type); if (is_type_integer(type)) { type = promote_integer(type); @@ -9579,7 +9749,6 @@ static statement_t *parse_empty_statement(void) static statement_t *parse_local_label_declaration(void) { statement_t *statement = allocate_statement_zero(STATEMENT_DECLARATION); - statement->base.source_position = token.source_position; eat(T___label__); @@ -9694,7 +9863,7 @@ expression_statment: case T_do: statement = parse_do(); break; case T_for: statement = parse_for(); break; case T_goto: statement = parse_goto(); break; - case T_if: statement = parse_if (); break; + case T_if: statement = parse_if(); break; case T_return: statement = parse_return(); break; case T_switch: statement = parse_switch(); break; case T_while: statement = parse_while(); break; @@ -9730,9 +9899,12 @@ expression_statment: case T___builtin_islessequal: case T___builtin_islessgreater: case T___builtin_isunordered: + case T___builtin_inf: + case T___builtin_inff: + case T___builtin_infl: case T___builtin_nan: - case T___builtin_nand: case T___builtin_nanf: + case T___builtin_nanl: case T___builtin_offsetof: case T___builtin_prefetch: case T___builtin_va_arg: @@ -9786,7 +9958,6 @@ static statement_t *parse_statement(void) static statement_t *parse_compound_statement(bool inside_expression_statement) { statement_t *statement = allocate_statement_zero(STATEMENT_COMPOUND); - statement->base.source_position = token.source_position; PUSH_PARENT(statement); @@ -9896,7 +10067,7 @@ static void check_unused_globals(void) if (!warning.unused_function && !warning.unused_variable) return; - for (const declaration_t *decl = global_scope->declarations; decl != NULL; decl = decl->next) { + for (const declaration_t *decl = file_scope->declarations; decl != NULL; decl = decl->next) { if (decl->used || decl->modifiers & DM_UNUSED || decl->modifiers & DM_USED || @@ -9924,14 +10095,14 @@ static void check_unused_globals(void) static void parse_global_asm(void) { + statement_t *statement = allocate_statement_zero(STATEMENT_ASM); + eat(T_asm); expect('('); - statement_t *statement = allocate_statement_zero(STATEMENT_ASM); - statement->base.source_position = token.source_position; - statement->asms.asm_text = parse_string_literals(); - statement->base.next = unit->global_asm; - unit->global_asm = statement; + statement->asms.asm_text = parse_string_literals(); + statement->base.next = unit->global_asm; + unit->global_asm = statement; expect(')'); expect(';'); @@ -9981,13 +10152,16 @@ static void parse_translation_unit(void) break; case T_EOF: + rem_anchor_token(T_EOF); return; case ';': - /* TODO error in strict mode */ - warningf(HERE, "stray ';' outside of function"); - next_token(); - break; + if (!strict_mode) { + warningf(HERE, "stray ';' outside of function"); + next_token(); + break; + } + /* FALLTHROUGH */ default: errorf(HERE, "stray %K outside of function", &token); @@ -9997,8 +10171,6 @@ static void parse_translation_unit(void) break; } } - - rem_anchor_token(T_EOF); } /** @@ -10021,8 +10193,8 @@ void start_parsing(void) assert(unit == NULL); unit = allocate_ast_zero(sizeof(unit[0])); - assert(global_scope == NULL); - global_scope = &unit->scope; + assert(file_scope == NULL); + file_scope = &unit->scope; assert(scope == NULL); scope_push(&unit->scope); @@ -10037,9 +10209,9 @@ translation_unit_t *finish_parsing(void) scope = NULL; last_declaration = NULL; - assert(global_scope == &unit->scope); + assert(file_scope == &unit->scope); check_unused_globals(); - global_scope = NULL; + file_scope = NULL; DEL_ARR_F(environment_stack); DEL_ARR_F(label_stack);