===================================================================
@@ -6354,11 +6354,9 @@ build_new_op_1 (const op_location_t &loc, enum tre
&& (TYPE_MAIN_VARIANT (arg1_type)
!= TYPE_MAIN_VARIANT (arg2_type))
&& (complain & tf_warning))
- {
- warning (OPT_Wenum_compare,
- "comparison between %q#T and %q#T",
- arg1_type, arg2_type);
- }
+ warning_at (loc, OPT_Wenum_compare,
+ "comparison between %q#T and %q#T",
+ arg1_type, arg2_type);
break;
default:
break;
@@ -6416,7 +6414,7 @@ build_new_op_1 (const op_location_t &loc, enum tre
return cp_build_modify_expr (loc, arg1, code2, arg2, complain);
case INDIRECT_REF:
- return cp_build_indirect_ref (arg1, RO_UNARY_STAR, complain);
+ return cp_build_indirect_ref (loc, arg1, RO_UNARY_STAR, complain);
case TRUTH_ANDIF_EXPR:
case TRUTH_ORIF_EXPR:
@@ -6472,8 +6470,9 @@ build_new_op_1 (const op_location_t &loc, enum tre
return cp_build_array_ref (input_location, arg1, arg2, complain);
case MEMBER_REF:
- return build_m_component_ref (cp_build_indirect_ref (arg1, RO_ARROW_STAR,
- complain),
+ return build_m_component_ref (cp_build_indirect_ref (loc, arg1,
+ RO_ARROW_STAR,
+ complain),
arg2, complain);
/* The caller will deal with these. */
===================================================================
@@ -7482,9 +7482,11 @@ extern tree build_class_member_access_expr (c
extern tree finish_class_member_access_expr (cp_expr, tree, bool,
tsubst_flags_t);
extern tree build_x_indirect_ref (location_t, tree,
- ref_operator, tsubst_flags_t);
-extern tree cp_build_indirect_ref (tree, ref_operator,
- tsubst_flags_t);
+ ref_operator,
+ tsubst_flags_t);
+extern tree cp_build_indirect_ref (location_t, tree,
+ ref_operator,
+ tsubst_flags_t);
extern tree cp_build_fold_indirect_ref (tree);
extern tree build_array_ref (location_t, tree, tree);
extern tree cp_build_array_ref (location_t, tree, tree,
===================================================================
@@ -7193,7 +7193,8 @@ finish_omp_clauses (tree clauses, enum c_omp_regio
remove = true;
else
{
- t = cp_build_indirect_ref (addr, RO_UNARY_STAR,
+ t = cp_build_indirect_ref (OMP_CLAUSE_LOCATION (c),
+ addr, RO_UNARY_STAR,
tf_warning_or_error);
if (t == error_mark_node)
remove = true;
@@ -9328,7 +9329,7 @@ finish_omp_depobj (location_t loc, tree depobj,
if (addr == error_mark_node)
depobj = error_mark_node;
else
- depobj = cp_build_indirect_ref (addr, RO_UNARY_STAR,
+ depobj = cp_build_indirect_ref (loc, addr, RO_UNARY_STAR,
tf_warning_or_error);
}
===================================================================
@@ -3278,7 +3278,7 @@ build_x_indirect_ref (location_t loc, tree expr, r
rval = build_new_op (loc, INDIRECT_REF, LOOKUP_NORMAL, expr,
NULL_TREE, NULL_TREE, &overload, complain);
if (!rval)
- rval = cp_build_indirect_ref (expr, errorstring, complain);
+ rval = cp_build_indirect_ref (loc, expr, errorstring, complain);
if (processing_template_decl && rval != error_mark_node)
{
@@ -3296,7 +3296,7 @@ build_x_indirect_ref (location_t loc, tree expr, r
constructs. If DO_FOLD is true, fold away INDIRECT_REF of ADDR_EXPR. */
static tree
-cp_build_indirect_ref_1 (tree ptr, ref_operator errorstring,
+cp_build_indirect_ref_1 (location_t loc, tree ptr, ref_operator errorstring,
tsubst_flags_t complain, bool do_fold)
{
tree pointer, type;
@@ -3345,7 +3345,7 @@ static tree
/* A pointer to incomplete type (other than cv void) can be
dereferenced [expr.unary.op]/1 */
if (complain & tf_error)
- error ("%qT is not a pointer-to-object type", type);
+ error_at (loc, "%qT is not a pointer-to-object type", type);
return error_mark_node;
}
else if (do_fold && TREE_CODE (pointer) == ADDR_EXPR
@@ -3376,23 +3376,25 @@ static tree
switch (errorstring)
{
case RO_ARRAY_INDEXING:
- error ("invalid use of array indexing on pointer to member");
+ error_at (loc,
+ "invalid use of array indexing on pointer to member");
break;
case RO_UNARY_STAR:
- error ("invalid use of unary %<*%> on pointer to member");
+ error_at (loc, "invalid use of unary %<*%> on pointer to member");
break;
case RO_IMPLICIT_CONVERSION:
- error ("invalid use of implicit conversion on pointer to member");
+ error_at (loc, "invalid use of implicit conversion on pointer "
+ "to member");
break;
case RO_ARROW_STAR:
- error ("left hand operand of %<->*%> must be a pointer to class, "
- "but is a pointer to member of type %qT", type);
+ error_at (loc, "left hand operand of %<->*%> must be a pointer to "
+ "class, but is a pointer to member of type %qT", type);
break;
default:
gcc_unreachable ();
}
else if (pointer != error_mark_node)
- invalid_indirection_error (input_location, type, errorstring);
+ invalid_indirection_error (loc, type, errorstring);
return error_mark_node;
}
@@ -3400,10 +3402,10 @@ static tree
/* Entry point used by c-common, which expects folding. */
tree
-build_indirect_ref (location_t /*loc*/,
- tree ptr, ref_operator errorstring)
+build_indirect_ref (location_t loc, tree ptr, ref_operator errorstring)
{
- return cp_build_indirect_ref_1 (ptr, errorstring, tf_warning_or_error, true);
+ return cp_build_indirect_ref_1 (loc, ptr, errorstring,
+ tf_warning_or_error, true);
}
/* Entry point used by internal indirection needs that don't correspond to any
@@ -3412,7 +3414,8 @@ tree
tree
cp_build_fold_indirect_ref (tree pointer)
{
- return cp_build_indirect_ref_1 (pointer, RO_NULL, tf_warning_or_error, true);
+ return cp_build_indirect_ref_1 (input_location, pointer, RO_NULL,
+ tf_warning_or_error, true);
}
/* Entry point used by indirection needs that correspond to some syntactic
@@ -3419,10 +3422,10 @@ cp_build_fold_indirect_ref (tree pointer)
construct. */
tree
-cp_build_indirect_ref (tree ptr, ref_operator errorstring,
+cp_build_indirect_ref (location_t loc, tree ptr, ref_operator errorstring,
tsubst_flags_t complain)
{
- return cp_build_indirect_ref_1 (ptr, errorstring, complain, false);
+ return cp_build_indirect_ref_1 (loc, ptr, errorstring, complain, false);
}
/* This handles expressions of the form "a[i]", which denotes
@@ -3599,7 +3602,7 @@ cp_build_array_ref (location_t loc, tree array, tr
ret = cp_build_binary_op (input_location, PLUS_EXPR, ar, ind, complain);
if (first)
ret = build2_loc (loc, COMPOUND_EXPR, TREE_TYPE (ret), first, ret);
- ret = cp_build_indirect_ref (ret, RO_ARRAY_INDEXING, complain);
+ ret = cp_build_indirect_ref (loc, ret, RO_ARRAY_INDEXING, complain);
protected_set_expr_location (ret, loc);
if (non_lvalue)
ret = non_lvalue_loc (loc, ret);
@@ -8280,7 +8283,8 @@ cp_build_modify_expr (location_t loc, tree lhs, en
if (VOID_TYPE_P (TREE_TYPE (rhs)))
{
if (complain & tf_error)
- error ("void value not ignored as it ought to be");
+ error_at (cp_expr_loc_or_loc (rhs, loc),
+ "void value not ignored as it ought to be");
return error_mark_node;
}
@@ -8493,7 +8497,8 @@ cp_build_modify_expr (location_t loc, tree lhs, en
if (modifycode != INIT_EXPR)
{
if (complain & tf_error)
- error ("assigning to an array from an initializer list");
+ error_at (loc,
+ "assigning to an array from an initializer list");
return error_mark_node;
}
if (check_array_initializer (lhs, lhstype, newrhs))
@@ -8520,8 +8525,8 @@ cp_build_modify_expr (location_t loc, tree lhs, en
TYPE_MAIN_VARIANT (TREE_TYPE (newrhs))))
{
if (complain & tf_error)
- error ("incompatible types in assignment of %qT to %qT",
- TREE_TYPE (rhs), lhstype);
+ error_at (loc, "incompatible types in assignment of %qT to %qT",
+ TREE_TYPE (rhs), lhstype);
return error_mark_node;
}
@@ -8534,9 +8539,9 @@ cp_build_modify_expr (location_t loc, tree lhs, en
if (complain & tf_error)
{
if (modifycode == INIT_EXPR)
- error ("array used as initializer");
+ error_at (loc, "array used as initializer");
else
- error ("invalid array assignment");
+ error_at (loc, "invalid array assignment");
}
return error_mark_node;
}
===================================================================
@@ -2060,7 +2060,7 @@ build_x_arrow (location_t loc, tree expr, tsubst_f
return expr;
}
- return cp_build_indirect_ref (last_rval, RO_ARROW, complain);
+ return cp_build_indirect_ref (loc, last_rval, RO_ARROW, complain);
}
if (complain & tf_error)
===================================================================
@@ -6,5 +6,5 @@ void
foo (int i)
{
int a[i];
- a = { }; // { dg-error "assign" }
+ a = { }; // { dg-error "5:assigning to an array from an initializer list" }
}
===================================================================
@@ -4,5 +4,5 @@
void foo()
{
int a[1];
- throw a = {}; // { dg-error "assign" }
+ throw a = {}; // { dg-error "11:assigning to an array from an initializer list" }
}
===================================================================
@@ -5,7 +5,7 @@ class Mesh
{
public:
Mesh(const char*)
- { typele={0}; } // { dg-error "" }
+ { typele={0}; } // { dg-error "11:assigning to an array from an initializer list" }
private:
int typele[7][2];
===================================================================
@@ -9,5 +9,5 @@ struct base
int main()
{
base ptr_array[1];
- ptr_array = { base() }; // { dg-error "assign" }
+ ptr_array = { base() }; // { dg-error "12:assigning to an array from an initializer list" }
}
===================================================================
@@ -0,0 +1,2 @@
+class C { public: C f(); int get(); };
+int f(C* p) { return p->f()->get(); } // { dg-error "28:base operand of .->. has non-pointer type .C." }
===================================================================
@@ -3,7 +3,7 @@
char a[1];
-int foo(a = "") // { dg-error "invalid array assignment" }
+int foo(a = "") // { dg-error "11:invalid array assignment" }
{
return 0;
}
===================================================================
@@ -8,5 +8,5 @@ struct a
int main()
{
int a::*n[8];
- n = &a::x; // { dg-error "int \\(a::\\*\\)" }
+ n = &a::x; // { dg-error "5:incompatible types in assignment of .int \\(a::\\*\\)" }
}
===================================================================
@@ -2,4 +2,4 @@
// { dg-do compile }
struct A A :: * p ;
-int i = p ->* p ; // { dg-error "" }
+int i = p ->* p ; // { dg-error "11:left hand operand" }
===================================================================
@@ -6,5 +6,5 @@ enum E2 { b };
int foo (E1 e1, E2 e2)
{
- return e1 == e2; /* { dg-warning "comparison between" } */
+ return e1 == e2; /* { dg-warning "13:comparison between" } */
}
===================================================================
@@ -8,7 +8,7 @@ void bar()
{
//-g++: incompatible types in assignment of 'const char[]' to 'char[]'
//-edg: expression must be a modifiable lvalue
- foo = "0123456789012345678901234"; // { dg-error "" } // ERROR -
+ foo = "0123456789012345678901234"; // { dg-error "7:invalid array assignment" } // ERROR -
}
===================================================================
@@ -7,7 +7,7 @@ char foo[26];
void bar()
{
- foo = "0123456789012345678901234"; // { dg-error "array" }
+ foo = "0123456789012345678901234"; // { dg-error "7:invalid array assignment" }
}
===================================================================
@@ -5,5 +5,5 @@ char * bob();
int main()
{
char a[1][2];
- a[0] = bob();// { dg-error "" } .*
+ a[0] = bob();// { dg-error "10:incompatible types in assignment" } .*
}
===================================================================
@@ -16,7 +16,7 @@ int struct0::*dmp;
void global_function_0 ()
{
- i = *dmp; // { dg-error "invalid use of unary '\\\*' on pointer to member" } causes abort
+ i = *dmp; // { dg-error "7:invalid use of unary '\\\*' on pointer to member" } causes abort
}
int main () { return 0; }
===================================================================
@@ -41,8 +41,8 @@ void struct0::function_member ()
i = (this->*fmp) (); // perfectly legal - for both cfront and g++
i = this->*dmp; // perfectly legal - for both cfront and g++
- i = (*fmp) (); // { dg-error "invalid use of unary '\\\*' on pointer to member" }
- i = *dmp; // { dg-error "invalid use of unary '\\\*' on pointer to member" }
+ i = (*fmp) (); // { dg-error "8:invalid use of unary '\\\*' on pointer to member" }
+ i = *dmp; // { dg-error "7:invalid use of unary '\\\*' on pointer to member" }
}
int main () { return 0; }
===================================================================
@@ -20,7 +20,7 @@ int_array ia2;
void function_0 ()
{
- ia1 = ia2; // { dg-error "" } gnu extension
+ ia1 = ia2; // { dg-error "7:invalid array assignment" } gnu extension
}
int main () { return 0; }
===================================================================
@@ -19,5 +19,5 @@ void
ccBgaInspection::reinspect (unsigned long diag_flags)
{
ct2d_rigid physTdev;
- _dev2phys = physTdev; // { dg-error "" }
+ _dev2phys = physTdev; // { dg-error "13:incompatible types in assignment" }
}
===================================================================
@@ -12,5 +12,5 @@ void
test ()
{
b1 = b2; /* OK */
- a1 = a2; /* { dg-error "" } array assignment */
+ a1 = a2; /* { dg-error "6:invalid array assignment" } array assignment */
}
===================================================================
@@ -6,5 +6,5 @@ struct S {
void f()
{
- s->i = 3; // { dg-error "" } base operand
+ s->i = 3; // { dg-error "4:base operand of .->. has non-pointer type .S." } base operand
}
===================================================================
@@ -7,8 +7,8 @@
void fn (void *vp, volatile void *vvp)
{
- *vp; // { dg-error "" } not a pointer to object
- *vvp; // { dg-error "" } not a pointer to object
- &*vp; // { dg-error "" } not a pointer to object
- &*vvp; // { dg-error "" } not a pointer to object
+ *vp; // { dg-error "3:.void\\*. is not a pointer-to-object type" } not a pointer to object
+ *vvp; // { dg-error "3:.volatile void\\*. is not a pointer-to-object type" } not a pointer to object
+ &*vp; // { dg-error "4:.void\\*. is not a pointer-to-object type" } not a pointer to object
+ &*vvp; // { dg-error "4:.volatile void\\*. is not a pointer-to-object type" } not a pointer to object
}