git
/
gcc
mirror of git://gcc.gnu.org/git/gcc.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

re PR c++/29917 (%s substituted with actual words can not be translated correctly (op_error)) 

2009-12-02  Paolo Bonzini  <bonzini@gnu.org>
	    Shujing Zhao  <pearly.zhao@oracle.com>

	PR c++/29917
	* call.c (op_error): Accept a boolean to indicate no match/ambiguous
	match, instead of a string. Callers adjusted.

	PR c++/34836
	* cp-tree.h (readonly_error_kind): New type.
	(readonly_error): Adjust prototype with new argument.
	* typeck2.c (readonly_error): Accept readonly_error_kind as argument
	and add macro ERROR_FOR_ASSIGNMENT to emit diagnostics.
	* semantics.c (finish_asm_stmt): Adjust readonly_error call.
	* typeck.c (cp_build_unary_op, cp_build_modify_expr): Likewise.

	* decl.c (grokparms, grok_op_properties): Put the diagnostics in full
	sentences for easy translation and wrap the diagnostics into G_() when
	needed.
	(create_array_type_for_decl): Likewise.
	* pt.c (tsubst): Likewise.
	* typeck2.c (cp_build_unary_op): Wrap diagnostic into _().
	* rtti.c (build_dynamic_cast_1): Likewise.

Co-Authored-By: Shujing Zhao <pearly.zhao@oracle.com>

From-SVN: r154915
This commit is contained in:
Paolo Bonzini 2009-12-02 15:49:20 +00:00 committed by Paolo Carlini
parent 2f697bc476
commit 4cd5a50a09
10 changed files with 267 additions and 86 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
gcc/cp/ChangeLog
View File

@ -1,3 +1,26 @@
2009-12-02 Paolo Bonzini <bonzini@gnu.org>
Shujing Zhao <pearly.zhao@oracle.com>
PR c++/29917
* call.c (op_error): Accept a boolean to indicate no match/ambiguous
match, instead of a string. Callers adjusted.
PR c++/34836
* cp-tree.h (readonly_error_kind): New type.
(readonly_error): Adjust prototype with new argument.
* typeck2.c (readonly_error): Accept readonly_error_kind as argument
and add macro ERROR_FOR_ASSIGNMENT to emit diagnostics.
* semantics.c (finish_asm_stmt): Adjust readonly_error call.
* typeck.c (cp_build_unary_op, cp_build_modify_expr): Likewise.
* decl.c (grokparms, grok_op_properties): Put the diagnostics in full
sentences for easy translation and wrap the diagnostics into G_() when
needed.
(create_array_type_for_decl): Likewise.
* pt.c (tsubst): Likewise.
* typeck2.c (cp_build_unary_op): Wrap diagnostic into _().
* rtti.c (build_dynamic_cast_1): Likewise.
2009-12-02 Jakub Jelinek <jakub@redhat.com> 2009-12-02 Jakub Jelinek <jakub@redhat.com>
* g++spec.c (lang_specific_driver): Remove unused saw_verbose_flag * g++spec.c (lang_specific_driver): Remove unused saw_verbose_flag

7
gcc/cp/Make-lang.in
View File

@ -254,7 +254,8 @@ cp/cp-lang.o: cp/cp-lang.c $(CXX_TREE_H) $(TM_H) toplev.h debug.h langhooks.h \
cp/decl.o: cp/decl.c $(CXX_TREE_H) $(TM_H) $(FLAGS_H) cp/decl.h \ cp/decl.o: cp/decl.c $(CXX_TREE_H) $(TM_H) $(FLAGS_H) cp/decl.h \
output.h $(EXPR_H) except.h toplev.h $(HASHTAB_H) $(RTL_H) \ output.h $(EXPR_H) except.h toplev.h $(HASHTAB_H) $(RTL_H) \
cp/operators.def $(TM_P_H) $(TREE_INLINE_H) $(DIAGNOSTIC_H) $(C_PRAGMA_H) \ cp/operators.def $(TM_P_H) $(TREE_INLINE_H) $(DIAGNOSTIC_H) $(C_PRAGMA_H) \
debug.h gt-cp-decl.h $(TIMEVAR_H) $(TREE_FLOW_H) $(TARGET_H) $(PLUGIN_H) debug.h gt-cp-decl.h $(TIMEVAR_H) $(TREE_FLOW_H) $(TARGET_H) $(PLUGIN_H) \
intl.h
cp/decl2.o: cp/decl2.c $(CXX_TREE_H) $(TM_H) $(FLAGS_H) cp/decl.h $(EXPR_H) \ cp/decl2.o: cp/decl2.c $(CXX_TREE_H) $(TM_H) $(FLAGS_H) cp/decl.h $(EXPR_H) \
output.h except.h toplev.h $(RTL_H) $(C_COMMON_H) gt-cp-decl2.h $(CGRAPH_H) \ output.h except.h toplev.h $(RTL_H) $(C_COMMON_H) gt-cp-decl2.h $(CGRAPH_H) \
$(C_PRAGMA_H) $(TREE_DUMP_H) intl.h $(TARGET_H) $(GIMPLE_H) $(POINTER_SET_H) $(C_PRAGMA_H) $(TREE_DUMP_H) intl.h $(TARGET_H) $(GIMPLE_H) $(POINTER_SET_H)
@ -263,7 +264,7 @@ cp/cp-objcp-common.o : cp/cp-objcp-common.c $(CONFIG_H) $(SYSTEM_H) \
langhooks.h $(LANGHOOKS_DEF_H) $(DIAGNOSTIC_H) debug.h \ langhooks.h $(LANGHOOKS_DEF_H) $(DIAGNOSTIC_H) debug.h \
$(CXX_PRETTY_PRINT_H) cp/cp-objcp-common.h gt-cp-cp-objcp-common.h $(CXX_PRETTY_PRINT_H) cp/cp-objcp-common.h gt-cp-cp-objcp-common.h
cp/typeck2.o: cp/typeck2.c $(CXX_TREE_H) $(TM_H) $(FLAGS_H) toplev.h output.h \ cp/typeck2.o: cp/typeck2.c $(CXX_TREE_H) $(TM_H) $(FLAGS_H) toplev.h output.h \
$(TM_P_H) $(DIAGNOSTIC_H) gt-cp-typeck2.h $(REAL_H) $(TM_P_H) $(DIAGNOSTIC_H) gt-cp-typeck2.h $(REAL_H) intl.h
cp/typeck.o: cp/typeck.c $(CXX_TREE_H) $(TM_H) $(FLAGS_H) $(RTL_H) $(EXPR_H) \ cp/typeck.o: cp/typeck.c $(CXX_TREE_H) $(TM_H) $(FLAGS_H) $(RTL_H) $(EXPR_H) \
toplev.h $(DIAGNOSTIC_H) convert.h $(C_COMMON_H) $(TARGET_H) toplev.h $(DIAGNOSTIC_H) convert.h $(C_COMMON_H) $(TARGET_H)
cp/class.o: cp/class.c $(CXX_TREE_H) $(TM_H) $(FLAGS_H) toplev.h $(RTL_H) \ cp/class.o: cp/class.c $(CXX_TREE_H) $(TM_H) $(FLAGS_H) toplev.h $(RTL_H) \
@ -284,7 +285,7 @@ cp/tree.o: cp/tree.c $(CXX_TREE_H) $(TM_H) $(FLAGS_H) toplev.h $(RTL_H) \
$(TARGET_H) debug.h $(TREE_FLOW_H) $(CGRAPH_H) $(TARGET_H) debug.h $(TREE_FLOW_H) $(CGRAPH_H)
cp/ptree.o: cp/ptree.c $(CXX_TREE_H) $(TM_H) cp/ptree.o: cp/ptree.c $(CXX_TREE_H) $(TM_H)
cp/rtti.o: cp/rtti.c $(CXX_TREE_H) $(TM_H) $(FLAGS_H) toplev.h convert.h \ cp/rtti.o: cp/rtti.c $(CXX_TREE_H) $(TM_H) $(FLAGS_H) toplev.h convert.h \
$(TARGET_H) $(C_PRAGMA_H) gt-cp-rtti.h $(TARGET_H) $(C_PRAGMA_H) gt-cp-rtti.h intl.h
cp/except.o: cp/except.c $(CXX_TREE_H) $(TM_H) $(FLAGS_H) $(RTL_H) except.h \ cp/except.o: cp/except.c $(CXX_TREE_H) $(TM_H) $(FLAGS_H) $(RTL_H) except.h \
toplev.h cp/cfns.h $(EXPR_H) libfuncs.h $(TREE_INLINE_H) $(TARGET_H) toplev.h cp/cfns.h $(EXPR_H) libfuncs.h $(TREE_INLINE_H) $(TARGET_H)
cp/expr.o: cp/expr.c $(CXX_TREE_H) $(TM_H) $(RTL_H) $(FLAGS_H) $(EXPR_H) \ cp/expr.o: cp/expr.c $(CXX_TREE_H) $(TM_H) $(RTL_H) $(FLAGS_H) $(EXPR_H) \

57
gcc/cp/call.c
View File

@ -144,7 +144,7 @@ static tree build_java_interface_fn_ref (tree, tree);
static tree convert_like_real (conversion *, tree, tree, int, int, bool, static tree convert_like_real (conversion *, tree, tree, int, int, bool,
bool, tsubst_flags_t); bool, tsubst_flags_t);
static void op_error (enum tree_code, enum tree_code, tree, tree, static void op_error (enum tree_code, enum tree_code, tree, tree,
tree, const char *); tree, bool);
static VEC(tree,gc) *resolve_args (VEC(tree,gc) *); static VEC(tree,gc) *resolve_args (VEC(tree,gc) *);
static struct z_candidate *build_user_type_conversion_1 (tree, tree, int); static struct z_candidate *build_user_type_conversion_1 (tree, tree, int);
static void print_z_candidate (const char *, struct z_candidate *); static void print_z_candidate (const char *, struct z_candidate *);
@ -3489,7 +3489,7 @@ build_op_call (tree obj, VEC(tree,gc) **args, tsubst_flags_t complain)
static void static void
op_error (enum tree_code code, enum tree_code code2, op_error (enum tree_code code, enum tree_code code2,
tree arg1, tree arg2, tree arg3, const char *problem) tree arg1, tree arg2, tree arg3, bool match)
{ {
const char *opname; const char *opname;
@ -3501,31 +3501,58 @@ op_error (enum tree_code code, enum tree_code code2,
switch (code) switch (code)
{ {
case COND_EXPR: case COND_EXPR:
error ("%s for ternary %<operator?:%> in %<%E ? %E : %E%>", if (match)
problem, arg1, arg2, arg3); error ("ambiguous overload for ternary %<operator?:%> "
"in %<%E ? %E : %E%>", arg1, arg2, arg3);
else
error ("no match for ternary %<operator?:%> "
"in %<%E ? %E : %E%>", arg1, arg2, arg3);
break; break;
case POSTINCREMENT_EXPR: case POSTINCREMENT_EXPR:
case POSTDECREMENT_EXPR: case POSTDECREMENT_EXPR:
error ("%s for %<operator%s%> in %<%E%s%>", problem, opname, arg1, opname); if (match)
error ("ambiguous overload for %<operator%s%> in %<%E%s%>",
opname, arg1, opname);
else
error ("no match for %<operator%s%> in %<%E%s%>",
opname, arg1, opname);
break; break;
case ARRAY_REF: case ARRAY_REF:
error ("%s for %<operator[]%> in %<%E[%E]%>", problem, arg1, arg2); if (match)
error ("ambiguous overload for %<operator[]%> in %<%E[%E]%>",
arg1, arg2);
else
error ("no match for %<operator[]%> in %<%E[%E]%>",
arg1, arg2);
break; break;
case REALPART_EXPR: case REALPART_EXPR:
case IMAGPART_EXPR: case IMAGPART_EXPR:
error ("%s for %qs in %<%s %E%>", problem, opname, opname, arg1); if (match)
error ("ambiguous overload for %qs in %<%s %E%>",
opname, opname, arg1);
else
error ("no match for %qs in %<%s %E%>",
opname, opname, arg1);
break; break;
default: default:
if (arg2) if (arg2)
error ("%s for %<operator%s%> in %<%E %s %E%>", if (match)
problem, opname, arg1, opname, arg2); error ("ambiguous overload for %<operator%s%> in %<%E %s %E%>",
opname, arg1, opname, arg2);
else else
error ("%s for %<operator%s%> in %<%s%E%>", error ("no match for %<operator%s%> in %<%E %s %E%>",
problem, opname, opname, arg1); opname, arg1, opname, arg2);
else
if (match)
error ("ambiguous overload for %<operator%s%> in %<%s%E%>",
opname, opname, arg1);
else
error ("no match for %<operator%s%> in %<%s%E%>",
opname, opname, arg1);
break; break;
} }
} }
@ -3852,7 +3879,7 @@ build_conditional_expr (tree arg1, tree arg2, tree arg3,
{ {
if (complain & tf_error) if (complain & tf_error)
{ {
op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match"); op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, FALSE);
print_z_candidates (candidates); print_z_candidates (candidates);
} }
return error_mark_node; return error_mark_node;
@ -3862,7 +3889,7 @@ build_conditional_expr (tree arg1, tree arg2, tree arg3,
{ {
if (complain & tf_error) if (complain & tf_error)
{ {
op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match"); op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, FALSE);
print_z_candidates (candidates); print_z_candidates (candidates);
} }
return error_mark_node; return error_mark_node;
@ -4330,7 +4357,7 @@ build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3,
{ {
/* ... Otherwise, report the more generic /* ... Otherwise, report the more generic
"no matching operator found" error */ "no matching operator found" error */
op_error (code, code2, arg1, arg2, arg3, "no match"); op_error (code, code2, arg1, arg2, arg3, FALSE);
print_z_candidates (candidates); print_z_candidates (candidates);
} }
} }
@ -4345,7 +4372,7 @@ build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3,
{ {
if ((flags & LOOKUP_COMPLAIN) && (complain & tf_error)) if ((flags & LOOKUP_COMPLAIN) && (complain & tf_error))
{ {
op_error (code, code2, arg1, arg2, arg3, "ambiguous overload"); op_error (code, code2, arg1, arg2, arg3, TRUE);
print_z_candidates (candidates); print_z_candidates (candidates);
} }
result = error_mark_node; result = error_mark_node;

15
gcc/cp/cp-tree.h
View File

@ -415,6 +415,19 @@ typedef enum composite_pointer_operation
CPO_CONDITIONAL_EXPR CPO_CONDITIONAL_EXPR
} composite_pointer_operation; } composite_pointer_operation;
/* The various readonly error string used by readonly_error. */
typedef enum readonly_error_kind
{
/* assignment */
REK_ASSIGNMENT,
/* assignment (via 'asm' output) */
REK_ASSIGNMENT_ASM,
/* increment */
REK_INCREMENT,
/* decrement */
REK_DECREMENT
} readonly_error_kind;
/* Macros for access to language-specific slots in an identifier. */ /* Macros for access to language-specific slots in an identifier. */
#define IDENTIFIER_NAMESPACE_BINDINGS(NODE) \ #define IDENTIFIER_NAMESPACE_BINDINGS(NODE) \
@ -5360,7 +5373,7 @@ extern void cxx_incomplete_type_error (const_tree, const_tree);
(cxx_incomplete_type_diagnostic ((V), (T), DK_ERROR)) (cxx_incomplete_type_diagnostic ((V), (T), DK_ERROR))
extern tree error_not_base_type (tree, tree); extern tree error_not_base_type (tree, tree);
extern tree binfo_or_else (tree, tree); extern tree binfo_or_else (tree, tree);
extern void readonly_error (tree, const char *); extern void readonly_error (tree, readonly_error_kind);
extern void complete_type_check_abstract (tree); extern void complete_type_check_abstract (tree);
extern int abstract_virtuals_error (tree, tree); extern int abstract_virtuals_error (tree, tree);

74
gcc/cp/decl.c
View File

@ -39,6 +39,7 @@ along with GCC; see the file COPYING3. If not see
#include "cp-tree.h" #include "cp-tree.h"
#include "tree-inline.h" #include "tree-inline.h"
#include "decl.h" #include "decl.h"
#include "intl.h"
#include "output.h" #include "output.h"
#include "except.h" #include "except.h"
#include "toplev.h" #include "toplev.h"
@ -7431,40 +7432,46 @@ create_array_type_for_decl (tree name, tree type, tree size)
/* Assume that everything will go OK. */ /* Assume that everything will go OK. */
error_msg = NULL; error_msg = NULL;
/* There are some types which cannot be array elements. */ /* If there are some types which cannot be array elements,
issue an error-message and return. */
switch (TREE_CODE (type)) switch (TREE_CODE (type))
{ {
case VOID_TYPE: case VOID_TYPE:
error_msg = "array of void"; if (name)
error ("declaration of %qD as array of void", name);
else
error ("creating array of void");
return error_mark_node;
break; break;
case FUNCTION_TYPE: case FUNCTION_TYPE:
error_msg = "array of functions"; if (name)
error ("declaration of %qD as array of functions", name);
else
error ("creating array of functions");
return error_mark_node;
break; break;
case REFERENCE_TYPE: case REFERENCE_TYPE:
error_msg = "array of references"; if (name)
error ("declaration of %qD as array of references", name);
else
error ("creating array of references");
return error_mark_node;
break; break;
case METHOD_TYPE: case METHOD_TYPE:
error_msg = "array of function members"; if (name)
error ("declaration of %qD as array of function members", name);
else
error ("creating array of function members");
return error_mark_node;
break; break;
default: default:
break; break;
} }
/* If something went wrong, issue an error-message and return. */
if (error_msg)
{
if (name)
error ("declaration of %qD as %s", name, error_msg);
else
error ("creating %s", error_msg);
return error_mark_node;
}
/* [dcl.array] /* [dcl.array]
The constant expressions that specify the bounds of the arrays The constant expressions that specify the bounds of the arrays
@ -9904,9 +9911,12 @@ grokparms (tree parmlist, tree *parms)
t = TREE_TYPE (t); t = TREE_TYPE (t);
} }
if (TREE_CODE (t) == ARRAY_TYPE) if (TREE_CODE (t) == ARRAY_TYPE)
error ("parameter %qD includes %s to array of unknown " error (ptr
"bound %qT", ? G_("parameter %qD includes pointer to array of "
decl, ptr ? "pointer" : "reference", t); "unknown bound %qT")
: G_("parameter %qD includes reference to array of "
"unknown bound %qT"),
decl, t);
} }
if (any_error) if (any_error)
@ -10353,28 +10363,38 @@ grok_op_properties (tree decl, bool complain)
{ {
tree t = TREE_TYPE (name); tree t = TREE_TYPE (name);
int ref = (TREE_CODE (t) == REFERENCE_TYPE); int ref = (TREE_CODE (t) == REFERENCE_TYPE);
const char *what = 0;
if (ref) if (ref)
t = TYPE_MAIN_VARIANT (TREE_TYPE (t)); t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
if (TREE_CODE (t) == VOID_TYPE) if (TREE_CODE (t) == VOID_TYPE)
what = "void"; warning (OPT_Wconversion,
ref
? G_("conversion to a reference to void "
"will never use a type conversion operator")
: G_("conversion to void "
"will never use a type conversion operator"));
else if (class_type) else if (class_type)
{ {
if (t == class_type) if (t == class_type)
what = "the same type"; warning (OPT_Wconversion,
ref
? G_("conversion to a reference to the same type "
"will never use a type conversion operator")
: G_("conversion to the same type "
"will never use a type conversion operator"));
/* Don't force t to be complete here. */ /* Don't force t to be complete here. */
else if (MAYBE_CLASS_TYPE_P (t) else if (MAYBE_CLASS_TYPE_P (t)
&& COMPLETE_TYPE_P (t) && COMPLETE_TYPE_P (t)
&& DERIVED_FROM_P (t, class_type)) && DERIVED_FROM_P (t, class_type))
what = "a base class"; warning (OPT_Wconversion,
ref
? G_("conversion to a reference to a base class "
"will never use a type conversion operator")
: G_("conversion to a base class "
"will never use a type conversion operator"));
} }
if (what)
warning (OPT_Wconversion, "conversion to %s%s will never use a type "
"conversion operator",
ref ? "a reference to " : "", what);
} }
if (operator_code == COND_EXPR) if (operator_code == COND_EXPR)

6
gcc/cp/pt.c
View File

@ -10041,10 +10041,10 @@ tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl)
{ {
if (TREE_CODE (type) == VOID_TYPE) if (TREE_CODE (type) == VOID_TYPE)
error ("forming reference to void"); error ("forming reference to void");
else if (code == POINTER_TYPE)
error ("forming pointer to reference type %qT", type);
else else
error ("forming %s to reference type %qT", error ("forming reference to reference type %qT", type);
(code == POINTER_TYPE) ? "pointer" : "reference",
type);
last_loc = input_location; last_loc = input_location;
} }

21
gcc/cp/rtti.c
View File

@ -22,6 +22,7 @@ along with GCC; see the file COPYING3. If not see
#include "config.h" #include "config.h"
#include "system.h" #include "system.h"
#include "intl.h"
#include "coretypes.h" #include "coretypes.h"
#include "tm.h" #include "tm.h"
#include "tree.h" #include "tree.h"
@ -525,18 +526,18 @@ build_dynamic_cast_1 (tree type, tree expr, tsubst_flags_t complain)
case REFERENCE_TYPE: case REFERENCE_TYPE:
if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (type))) if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (type)))
{ {
errstr = "target is not pointer or reference to class"; errstr = _("target is not pointer or reference to class");
goto fail; goto fail;
} }
if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type)))) if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
{ {
errstr = "target is not pointer or reference to complete type"; errstr = _("target is not pointer or reference to complete type");
goto fail; goto fail;
} }
break; break;
default: default:
errstr = "target is not pointer or reference"; errstr = _("target is not pointer or reference");
goto fail; goto fail;
} }
@ -547,17 +548,17 @@ build_dynamic_cast_1 (tree type, tree expr, tsubst_flags_t complain)
if (TREE_CODE (exprtype) != POINTER_TYPE) if (TREE_CODE (exprtype) != POINTER_TYPE)
{ {
errstr = "source is not a pointer"; errstr = _("source is not a pointer");
goto fail; goto fail;
} }
if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (exprtype))) if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (exprtype)))
{ {
errstr = "source is not a pointer to class"; errstr = _("source is not a pointer to class");
goto fail; goto fail;
} }
if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype)))) if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype))))
{ {
errstr = "source is a pointer to incomplete type"; errstr = _("source is a pointer to incomplete type");
goto fail; goto fail;
} }
} }
@ -570,12 +571,12 @@ build_dynamic_cast_1 (tree type, tree expr, tsubst_flags_t complain)
if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (exprtype))) if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (exprtype)))
{ {
errstr = "source is not of class type"; errstr = _("source is not of class type");
goto fail; goto fail;
} }
if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype)))) if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype))))
{ {
errstr = "source is of incomplete class type"; errstr = _("source is of incomplete class type");
goto fail; goto fail;
} }
@ -588,7 +589,7 @@ build_dynamic_cast_1 (tree type, tree expr, tsubst_flags_t complain)
if (!at_least_as_qualified_p (TREE_TYPE (type), if (!at_least_as_qualified_p (TREE_TYPE (type),
TREE_TYPE (exprtype))) TREE_TYPE (exprtype)))
{ {
errstr = "conversion casts away constness"; errstr = _("conversion casts away constness");
goto fail; goto fail;
} }
@ -748,7 +749,7 @@ build_dynamic_cast_1 (tree type, tree expr, tsubst_flags_t complain)
} }
} }
else else
errstr = "source type is not polymorphic"; errstr = _("source type is not polymorphic");
fail: fail:
if (complain & tf_error) if (complain & tf_error)

2
gcc/cp/semantics.c
View File

@ -1254,7 +1254,7 @@ finish_asm_stmt (int volatile_p, tree string, tree output_operands,
effectively const. */ effectively const. */
|| (CLASS_TYPE_P (TREE_TYPE (operand)) || (CLASS_TYPE_P (TREE_TYPE (operand))
&& C_TYPE_FIELDS_READONLY (TREE_TYPE (operand))))) && C_TYPE_FIELDS_READONLY (TREE_TYPE (operand)))))
readonly_error (operand, "assignment (via 'asm' output)"); readonly_error (operand, REK_ASSIGNMENT_ASM);
constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t))); constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t)));
oconstraints[i] = constraint; oconstraints[i] = constraint;

24
gcc/cp/typeck.c
View File

@ -4462,8 +4462,8 @@ cp_build_unary_op (enum tree_code code, tree xarg, int noconvert,
arg = build_expr_type_conversion (flags, arg, true); arg = build_expr_type_conversion (flags, arg, true);
if (!arg) if (!arg)
errstring = (code == NEGATE_EXPR errstring = (code == NEGATE_EXPR
? "wrong type argument to unary minus" ? _("wrong type argument to unary minus")
: "wrong type argument to unary plus"); : _("wrong type argument to unary plus"));
else else
{ {
if (!noconvert && CP_INTEGRAL_TYPE_P (TREE_TYPE (arg))) if (!noconvert && CP_INTEGRAL_TYPE_P (TREE_TYPE (arg)))
@ -4486,14 +4486,14 @@ cp_build_unary_op (enum tree_code code, tree xarg, int noconvert,
else if (!(arg = build_expr_type_conversion (WANT_INT | WANT_ENUM else if (!(arg = build_expr_type_conversion (WANT_INT | WANT_ENUM
| WANT_VECTOR, | WANT_VECTOR,
arg, true))) arg, true)))
errstring = "wrong type argument to bit-complement"; errstring = _("wrong type argument to bit-complement");
else if (!noconvert && CP_INTEGRAL_TYPE_P (TREE_TYPE (arg))) else if (!noconvert && CP_INTEGRAL_TYPE_P (TREE_TYPE (arg)))
arg = perform_integral_promotions (arg); arg = perform_integral_promotions (arg);
break; break;
case ABS_EXPR: case ABS_EXPR:
if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, true))) if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, true)))
errstring = "wrong type argument to abs"; errstring = _("wrong type argument to abs");
else if (!noconvert) else if (!noconvert)
arg = default_conversion (arg); arg = default_conversion (arg);
break; break;
@ -4501,7 +4501,7 @@ cp_build_unary_op (enum tree_code code, tree xarg, int noconvert,
case CONJ_EXPR: case CONJ_EXPR:
/* Conjugating a real value is a no-op, but allow it anyway. */ /* Conjugating a real value is a no-op, but allow it anyway. */
if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, true))) if (!(arg = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, arg, true)))
errstring = "wrong type argument to conjugation"; errstring = _("wrong type argument to conjugation");
else if (!noconvert) else if (!noconvert)
arg = default_conversion (arg); arg = default_conversion (arg);
break; break;
@ -4512,7 +4512,7 @@ cp_build_unary_op (enum tree_code code, tree xarg, int noconvert,
val = invert_truthvalue_loc (input_location, arg); val = invert_truthvalue_loc (input_location, arg);
if (arg != error_mark_node) if (arg != error_mark_node)
return val; return val;
errstring = "in argument to unary !"; errstring = _("in argument to unary !");
break; break;
case NOP_EXPR: case NOP_EXPR:
@ -4573,13 +4573,13 @@ cp_build_unary_op (enum tree_code code, tree xarg, int noconvert,
arg, true))) arg, true)))
{ {
if (code == PREINCREMENT_EXPR) if (code == PREINCREMENT_EXPR)
errstring ="no pre-increment operator for type"; errstring = _("no pre-increment operator for type");
else if (code == POSTINCREMENT_EXPR) else if (code == POSTINCREMENT_EXPR)
errstring ="no post-increment operator for type"; errstring = _("no post-increment operator for type");
else if (code == PREDECREMENT_EXPR) else if (code == PREDECREMENT_EXPR)
errstring ="no pre-decrement operator for type"; errstring = _("no pre-decrement operator for type");
else else
errstring ="no post-decrement operator for type"; errstring = _("no post-decrement operator for type");
break; break;
} }
else if (arg == error_mark_node) else if (arg == error_mark_node)
@ -4593,7 +4593,7 @@ cp_build_unary_op (enum tree_code code, tree xarg, int noconvert,
if (complain & tf_error) if (complain & tf_error)
readonly_error (arg, ((code == PREINCREMENT_EXPR readonly_error (arg, ((code == PREINCREMENT_EXPR
|| code == POSTINCREMENT_EXPR) || code == POSTINCREMENT_EXPR)
? "increment" : "decrement")); ? REK_INCREMENT : REK_DECREMENT));
else else
return error_mark_node; return error_mark_node;
} }
@ -6327,7 +6327,7 @@ cp_build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs,
&& C_TYPE_FIELDS_READONLY (lhstype)))) && C_TYPE_FIELDS_READONLY (lhstype))))
{ {
if (complain & tf_error) if (complain & tf_error)
readonly_error (lhs, "assignment"); readonly_error (lhs, REK_ASSIGNMENT);
else else
return error_mark_node; return error_mark_node;
} }

122
gcc/cp/typeck2.c
View File

@ -32,6 +32,7 @@ along with GCC; see the file COPYING3. If not see
#include "coretypes.h" #include "coretypes.h"
#include "tm.h" #include "tm.h"
#include "tree.h" #include "tree.h"
#include "intl.h"
#include "cp-tree.h" #include "cp-tree.h"
#include "flags.h" #include "flags.h"
#include "toplev.h" #include "toplev.h"
@ -71,41 +72,136 @@ binfo_or_else (tree base, tree type)
value may not be changed thereafter. */ value may not be changed thereafter. */
void void
readonly_error (tree arg, const char* string) readonly_error (tree arg, readonly_error_kind errstring)
{ {
const char *fmt;
/* This macro is used to emit diagnostics to ensure that all format
strings are complete sentences, visible to gettext and checked at
compile time. */
#define ERROR_FOR_ASSIGNMENT(AS, ASM, IN, DE, ARG) \
do { \
switch (errstring) \
{ \
case REK_ASSIGNMENT: \
error(AS, ARG); \
break; \
case REK_ASSIGNMENT_ASM: \
error(ASM, ARG); \
break; \
case REK_INCREMENT: \
error (IN, ARG); \
break; \
case REK_DECREMENT: \
error (DE, ARG); \
break; \
default: \
gcc_unreachable (); \
} \
} while (0)
if (TREE_CODE (arg) == COMPONENT_REF) if (TREE_CODE (arg) == COMPONENT_REF)
{ {
if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0)))) if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
fmt = "%s of data-member %qD in read-only structure"; ERROR_FOR_ASSIGNMENT (G_("assignment of "
"data-member %qD in read-only structure"),
G_("assignment (via 'asm' output) of "
"data-member %qD in read-only structure"),
G_("increment of "
"data-member %qD in read-only structure"),
G_("decrement of "
"data-member %qD in read-only structure"),
TREE_OPERAND (arg, 1));
else else
fmt = "%s of read-only data-member %qD"; ERROR_FOR_ASSIGNMENT (G_("assignment of "
error (fmt, string, TREE_OPERAND (arg, 1)); "read-only data-member %qD"),
G_("assignment (via 'asm' output) of "
"read-only data-member %qD"),
G_("increment of "
"read-only data-member %qD"),
G_("decrement of "
"read-only data-member %qD"),
TREE_OPERAND (arg, 1));
} }
else if (TREE_CODE (arg) == VAR_DECL) else if (TREE_CODE (arg) == VAR_DECL)
{ {
if (DECL_LANG_SPECIFIC (arg) if (DECL_LANG_SPECIFIC (arg)
&& DECL_IN_AGGR_P (arg) && DECL_IN_AGGR_P (arg)
&& !TREE_STATIC (arg)) && !TREE_STATIC (arg))
fmt = "%s of constant field %qD"; ERROR_FOR_ASSIGNMENT (G_("assignment of "
"constant field %qD"),
G_("assignment (via 'asm' output) of "
"constant field %qD"),
G_("increment of "
"constant field %qD"),
G_("decrement of "
"constant field %qD"),
arg);
else else
fmt = "%s of read-only variable %qD"; ERROR_FOR_ASSIGNMENT (G_("assignment of "
error (fmt, string, arg); "read-only variable %qD"),
G_("assignment (via 'asm' output) of "
"read-only variable %qD"),
G_("increment of "
"read-only variable %qD"),
G_("decrement of "
"read-only variable %qD"),
arg);
} }
else if (TREE_CODE (arg) == PARM_DECL) else if (TREE_CODE (arg) == PARM_DECL)
error ("%s of read-only parameter %qD", string, arg); ERROR_FOR_ASSIGNMENT (G_("assignment of "
"read-only parameter %qD"),
G_("assignment (via 'asm' output) of "
"read-only parameter %qD"),
G_("increment of "
"read-only parameter %qD"),
G_("decrement of "
"read-only parameter %qD"),
arg);
else if (TREE_CODE (arg) == INDIRECT_REF else if (TREE_CODE (arg) == INDIRECT_REF
&& TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 0))) == REFERENCE_TYPE && TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 0))) == REFERENCE_TYPE
&& (TREE_CODE (TREE_OPERAND (arg, 0)) == VAR_DECL && (TREE_CODE (TREE_OPERAND (arg, 0)) == VAR_DECL
|| TREE_CODE (TREE_OPERAND (arg, 0)) == PARM_DECL)) || TREE_CODE (TREE_OPERAND (arg, 0)) == PARM_DECL))
error ("%s of read-only reference %qD", string, TREE_OPERAND (arg, 0)); ERROR_FOR_ASSIGNMENT (G_("assignment of "
"read-only reference %qD"),
G_("assignment (via 'asm' output) of "
"read-only reference %qD"),
G_("increment of "
"read-only reference %qD"),
G_("decrement of "
"read-only reference %qD"),
TREE_OPERAND (arg, 0));
else if (TREE_CODE (arg) == RESULT_DECL) else if (TREE_CODE (arg) == RESULT_DECL)
error ("%s of read-only named return value %qD", string, arg); ERROR_FOR_ASSIGNMENT (G_("assignment of "
"read-only named return value %qD"),
G_("assignment (via 'asm' output) of "
"read-only named return value %qD"),
G_("increment of "
"read-only named return value %qD"),
G_("decrement of "
"read-only named return value %qD"),
arg);
else if (TREE_CODE (arg) == FUNCTION_DECL) else if (TREE_CODE (arg) == FUNCTION_DECL)
error ("%s of function %qD", string, arg); ERROR_FOR_ASSIGNMENT (G_("assignment of "
"function %qD"),
G_("assignment (via 'asm' output) of "
"function %qD"),
G_("increment of "
"function %qD"),
G_("decrement of "
"function %qD"),
arg);
else else
error ("%s of read-only location %qE", string, arg); ERROR_FOR_ASSIGNMENT (G_("assignment of "
"read-only location %qE"),
G_("assignment (via 'asm' output) of "
"read-only location %qE"),
G_("increment of "
"read-only location %qE"),
G_("decrement of "
"read-only location %qE"),
arg);
} }