Correct printed source position of several error/warning messages.

[cparser] / ast.c

diff --git a/ast.c b/ast.c
index 80fadcc..3f597b3 100644 (file)
--- a/ast.c
+++ b/ast.c
@@ -463,11 +463,6 @@ static void print_unary_expression(const unary_expression_t *unexpr)
                fputs("--", out);
                return;
        case EXPR_UNARY_CAST_IMPLICIT:
-               if(!print_implicit_casts) {
-                       print_expression_prec(unexpr->value, prec);
-                       return;
-               }
-               /* fallthrough */
        case EXPR_UNARY_CAST:
                fputc('(', out);
                print_type(unexpr->base.type);
@@ -505,12 +500,12 @@ static void print_array_expression(const array_access_expression_t *expression)
        if(!expression->flipped) {
                print_expression_prec(expression->array_ref, prec);
                fputc('[', out);
-               print_expression_prec(expression->index, prec);
+               print_expression_prec(expression->index, PREC_BOTTOM);
                fputc(']', out);
        } else {
                print_expression_prec(expression->index, prec);
                fputc('[', out);
-               print_expression_prec(expression->array_ref, prec);
+               print_expression_prec(expression->array_ref, PREC_BOTTOM);
                fputc(']', out);
        }
 }
@@ -667,7 +662,7 @@ static void print_designator(const designator_t *designator)
        for ( ; designator != NULL; designator = designator->next) {
                if (designator->symbol == NULL) {
                        fputc('[', out);
-                       print_expression_prec(designator->array_index, PREC_ACCESS);
+                       print_expression_prec(designator->array_index, PREC_BOTTOM);
                        fputc(']', out);
                } else {
                        fputc('.', out);
@@ -711,6 +706,9 @@ static void print_statement_expression(const statement_expression_t *expression)
  */
 static void print_expression_prec(const expression_t *expression, unsigned top_prec)
 {
+       if (expression->kind == EXPR_UNARY_CAST_IMPLICIT && !print_implicit_casts) {
+               expression = expression->unary.value;
+       }
        unsigned prec = get_expression_precedence(expression->base.kind);
        if (print_parenthesis && top_prec != PREC_BOTTOM)
                top_prec = PREC_TOP;
@@ -1268,12 +1266,13 @@ static void print_ms_modifiers(const declaration_t *declaration) {
        if((c_mode & _MS) == 0)
                return;
 
-       decl_modifiers_t modifiers = declaration->decl_modifiers;
+       decl_modifiers_t modifiers = declaration->modifiers;
 
        /* DM_FORCEINLINE handled outside. */
-       if((modifiers & ~DM_FORCEINLINE) != 0 ||
-           declaration->alignment != 0 || declaration->deprecated != 0 ||
-           declaration->get_property_sym != NULL || declaration->put_property_sym != NULL) {
+       if ((modifiers & ~DM_FORCEINLINE) != 0    ||
+           declaration->alignment        != 0    ||
+           declaration->get_property_sym != NULL ||
+           declaration->put_property_sym != NULL) {
                char *next = "(";
 
                fputs("__declspec", out);
@@ -1304,7 +1303,7 @@ static void print_ms_modifiers(const declaration_t *declaration) {
                if(modifiers & DM_NOINLINE) {
                        fputs(next, out); next = ", "; fputs("noinline", out);
                }
-               if(declaration->deprecated != 0) {
+               if (modifiers & DM_DEPRECATED) {
                        fputs(next, out); next = ", "; fputs("deprecated", out);
                        if(declaration->deprecated_string != NULL)
                                fprintf(out, "(\"%s\")", declaration->deprecated_string);
@@ -1341,14 +1340,13 @@ static void print_ms_modifiers(const declaration_t *declaration) {
 static void print_normal_declaration(const declaration_t *declaration)
 {
        print_storage_class((storage_class_tag_t) declaration->declared_storage_class);
-       if(declaration->is_inline) {
-               if(declaration->decl_modifiers & DM_FORCEINLINE)
+       if (declaration->is_inline) {
+               if (declaration->modifiers & DM_FORCEINLINE) {
                        fputs("__forceinline ", out);
-               else {
-                       if(declaration->decl_modifiers & DM_MICROSOFT_INLINE)
-                               fputs("__inline ", out);
-                       else
-                               fputs("inline ", out);
+               } else if (declaration->modifiers & DM_MICROSOFT_INLINE) {
+                       fputs("__inline ", out);
+               } else {
+                       fputs("inline ", out);
                }
        }
        print_ms_modifiers(declaration);
@@ -1468,7 +1466,8 @@ static bool is_object_with_linker_constant_address(const expression_t *expressio
                return is_address_constant(expression->unary.value);
 
        case EXPR_SELECT: {
-               if(is_type_pointer(expression->select.compound->base.type)) {
+               type_t *base_type = skip_typeref(expression->select.compound->base.type);
+               if(is_type_pointer(base_type)) {
                        /* it's a -> */
                        return is_address_constant(expression->select.compound);
                } else {
@@ -1504,19 +1503,27 @@ bool is_address_constant(const expression_t *expression)
                return is_object_with_linker_constant_address(expression->unary.value);
 
        case EXPR_UNARY_DEREFERENCE: {
-               type_t *real_type = revert_automatic_type_conversion(expression->unary.value);
+               type_t *real_type
+                       = revert_automatic_type_conversion(expression->unary.value);
                /* dereferencing a function is a NOP */
                if(is_type_function(real_type)) {
                        return is_address_constant(expression->unary.value);
                }
 
-               return false;
+               /* fallthrough */
        }
 
-       case EXPR_UNARY_CAST:
-               return is_type_pointer(skip_typeref(expression->base.type))
-                       && (is_constant_expression(expression->unary.value)
+       case EXPR_UNARY_CAST: {
+               type_t *dest = skip_typeref(expression->base.type);
+               if (!is_type_pointer(dest) &&
+                               ! (dest->kind == TYPE_ATOMIC
+                                       && (get_atomic_type_flags(dest->atomic.akind) & ATOMIC_TYPE_FLAG_INTEGER)
+                                       && (get_atomic_type_size(dest->atomic.akind) >= get_atomic_type_size(get_intptr_kind()))))
+                       return false;
+
+               return (is_constant_expression(expression->unary.value)
                        || is_address_constant(expression->unary.value));
+       }
 
        case EXPR_BINARY_ADD:
        case EXPR_BINARY_SUB: {
@@ -1574,6 +1581,8 @@ static bool is_constant_pointer(const expression_t *expression)
                return true;
 
        switch (expression->kind) {
+       case EXPR_SELECT:
+               return is_constant_pointer(expression->select.compound);
        case EXPR_UNARY_CAST:
                return is_constant_pointer(expression->unary.value);
        default: