From 534fd573cd6058ba2e2312045c46f4cde12060ad Mon Sep 17 00:00:00 2001 From: Matthias Braun Date: Tue, 18 Mar 2008 15:45:11 +0000 Subject: [PATCH] relax assignment semantics [r18982] --- parser.c | 88 ++++++++++++++++++++++++++++++++------------------------ 1 file changed, 51 insertions(+), 37 deletions(-) diff --git a/parser.c b/parser.c index b027d96..c4c8356 100644 --- a/parser.c +++ b/parser.c @@ -836,55 +836,68 @@ static expression_t *create_implicit_cast(expression_t *expression, /** Implements the rules from § 6.5.16.1 */ static type_t *semantic_assign(type_t *orig_type_left, const expression_t *const right, - const char *context) + const char *context, + source_position_t source_position) { type_t *const orig_type_right = right->base.type; type_t *const type_left = skip_typeref(orig_type_left); type_t *const type_right = skip_typeref(orig_type_right); - if ((is_type_arithmetic(type_left) && is_type_arithmetic(type_right)) || - (is_type_pointer(type_left) && is_null_pointer_constant(right)) || - (is_type_atomic(type_left, ATOMIC_TYPE_BOOL) - && is_type_pointer(type_right))) { - return orig_type_left; - } + if(is_type_pointer(type_left)) { + if(is_null_pointer_constant(right)) { + return orig_type_left; + } else if(is_type_pointer(type_right)) { + type_t *points_to_left + = skip_typeref(type_left->pointer.points_to); + type_t *points_to_right + = skip_typeref(type_right->pointer.points_to); + + /* the left type has all qualifiers from the right type */ + unsigned missing_qualifiers + = points_to_right->base.qualifiers & ~points_to_left->base.qualifiers; + if(missing_qualifiers != 0) { + errorf(source_position, + "destination type '%T' in %s from type '%T' lacks qualifiers '%Q' in pointed-to type", type_left, context, type_right, missing_qualifiers); + return orig_type_left; + } - if (is_type_pointer(type_left) && is_type_pointer(type_right)) { - type_t *points_to_left = skip_typeref(type_left->pointer.points_to); - type_t *points_to_right = skip_typeref(type_right->pointer.points_to); + points_to_left = get_unqualified_type(points_to_left); + points_to_right = get_unqualified_type(points_to_right); - /* the left type has all qualifiers from the right type */ - unsigned missing_qualifiers - = points_to_right->base.qualifiers & ~points_to_left->base.qualifiers; - if(missing_qualifiers != 0) { - errorf(HERE, "destination type '%T' in %s from type '%T' lacks qualifiers '%Q' in pointed-to type", type_left, context, type_right, missing_qualifiers); - return orig_type_left; - } + if (is_type_atomic(points_to_left, ATOMIC_TYPE_VOID) || + is_type_atomic(points_to_right, ATOMIC_TYPE_VOID)) { + return orig_type_left; + } - points_to_left = get_unqualified_type(points_to_left); - points_to_right = get_unqualified_type(points_to_right); + if (!types_compatible(points_to_left, points_to_right)) { + warningf(source_position, + "destination type '%T' in %s is incompatible with '%E' of type '%T'", + orig_type_left, context, right, orig_type_right); + } - if (is_type_atomic(points_to_left, ATOMIC_TYPE_VOID) || - is_type_atomic(points_to_right, ATOMIC_TYPE_VOID)) { + return orig_type_left; + } else if(is_type_integer(type_right)) { + warningf(source_position, + "%s makes pointer '%T' from integer '%T' without a cast", + context, orig_type_left, orig_type_right); return orig_type_left; } - - if (!types_compatible(points_to_left, points_to_right)) { - warningf(right->base.source_position, - "destination type '%T' in %s is incompatible with '%E' of type '%T'", - orig_type_left, context, right, orig_type_right); - } - + } else if ((is_type_arithmetic(type_left) && is_type_arithmetic(type_right)) || + (is_type_atomic(type_left, ATOMIC_TYPE_BOOL) + && is_type_pointer(type_right))) { return orig_type_left; - } - - if ((is_type_compound(type_left) && is_type_compound(type_right)) + } else if ((is_type_compound(type_left) && is_type_compound(type_right)) || (is_type_builtin(type_left) && is_type_builtin(type_right))) { type_t *const unqual_type_left = get_unqualified_type(type_left); type_t *const unqual_type_right = get_unqualified_type(type_right); if (types_compatible(unqual_type_left, unqual_type_right)) { return orig_type_left; } + } else if (is_type_integer(type_left) && is_type_pointer(type_right)) { + warningf(source_position, + "%s makes integer '%T' from pointer '%T' without a cast", + context, orig_type_left, orig_type_right); + return orig_type_left; } if (!is_type_valid(type_left)) @@ -1345,7 +1358,8 @@ static initializer_t *initializer_from_expression(type_t *orig_type, } } - type_t *const res_type = semantic_assign(type, expression, "initializer"); + type_t *const res_type = semantic_assign(type, expression, "initializer", + expression->base.source_position); if (res_type == NULL) return NULL; @@ -5372,7 +5386,7 @@ static expression_t *parse_call_expression(unsigned precedence, type_t *expected_type = parameter->type; /* TODO report scope in error messages */ expression_t *const arg_expr = argument->expression; - type_t *const res_type = semantic_assign(expected_type, arg_expr, "function call"); + type_t *const res_type = semantic_assign(expected_type, arg_expr, "function call", arg_expr->base.source_position); if (res_type == NULL) { /* TODO improve error message */ errorf(arg_expr->base.source_position, @@ -6053,7 +6067,7 @@ static void semantic_binexpr_assign(binary_expression_t *expression) } type_t *const res_type = semantic_assign(orig_type_left, expression->right, - "assignment"); + "assignment", left->base.source_position); if (res_type == NULL) { errorf(expression->base.source_position, "cannot assign to '%T' from '%T'", @@ -7091,11 +7105,11 @@ declaration_t *expr_is_variable(const expression_t *expression) */ static statement_t *parse_return(void) { - eat(T_return); - statement_t *statement = allocate_statement_zero(STATEMENT_RETURN); statement->base.source_position = token.source_position; + eat(T_return); + expression_t *return_value = NULL; if(token.type != ';') { return_value = parse_expression(); @@ -7116,7 +7130,7 @@ static statement_t *parse_return(void) return_value = NULL; } else { type_t *const res_type = semantic_assign(return_type, - return_value, "'return'"); + return_value, "'return'", statement->base.source_position); if (res_type == NULL) { errorf(statement->base.source_position, "cannot return something of type '%T' in function returning '%T'", -- 2.20.1