+2004-09-13 Joseph S. Myers <jsm@polyomino.org.uk>
+
+ * c-common.c, c-decl.c, c-lex.c, c-objc-common.c, c-opts.c,
+ c-parse.in, c-pragma.c, c-typeck.c: Use %q, %< and %> for quoting
+ in diagnostics. Use %' for English apostrophes.
+ * c-tree.h (ATTRIBUTE_GCC_CDIAG): Define.
+ (pedwarn_c90, pedwarn_c99): Use it.
+ * c-decl.c (lookup_label): Quote label name in diagnostic.
+ * c-parse.in (yyprint): Use ' instead of ` for left quote.
+ * c-typeck.c (warn_for_assignment): Likewise.
+
2004-09-13 Jan Hubicka <jh@suse.cz>
* i386.c (x86_schedule): New global variable.
input_location = saved_location;
}
if (!ix && !current_function_decl)
- pedwarn ("%J'%D' is not defined outside of function scope", decl, decl);
+ pedwarn ("%J%qD is not defined outside of function scope", decl, decl);
return decl;
}
nchars = wide_flag ? length / wchar_bytes : length;
if (pedantic && nchars - 1 > nchars_max && !c_dialect_cxx ())
- pedwarn ("string length `%d' is greater than the length `%d' ISO C%d compilers are required to support",
+ pedwarn ("string length %qd is greater than the length %qd ISO C%d compilers are required to support",
nchars - 1, nchars_max, flag_isoc99 ? 99 : 89);
e_type = wide_flag ? wchar_type_node : char_type_node;
&& DECL_NAME (list->expr))
{
warned_ids = new_tlist (warned_ids, written, NULL_TREE);
- warning ("operation on `%s' may be undefined",
+ warning ("operation on %qs may be undefined",
IDENTIFIER_POINTER (DECL_NAME (list->expr)));
}
list = list->next;
if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
{
if (pedantic || warn_pointer_arith)
- pedwarn ("pointer of type `void *' used in arithmetic");
+ pedwarn ("pointer of type %<void *%> used in arithmetic");
size_exp = integer_one_node;
}
else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
{
/* Common Ada/Pascal programmer's mistake. We always warn
about this since it is so bad. */
- warning ("the address of `%D', will always evaluate as `true'",
+ warning ("the address of %qD, will always evaluate as %<true%>",
TREE_OPERAND (expr, 0));
return truthvalue_true_node;
}
&& (!POINTER_TYPE_P (type)
|| !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
{
- error ("invalid use of `restrict'");
+ error ("invalid use of %<restrict%>");
type_quals &= ~TYPE_QUAL_RESTRICT;
}
if (!type
|| !POINTER_TYPE_P (type)
|| !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
- error ("invalid use of `restrict'");
+ error ("invalid use of %<restrict%>");
else if (flag_strict_aliasing && type == TREE_TYPE (decl))
/* Indicate we need to make a unique alias set for this pointer.
We can't do it here because it might be pointing to an
if (op == SIZEOF_EXPR)
{
if (complain && (pedantic || warn_pointer_arith))
- pedwarn ("invalid application of `sizeof' to a function type");
+ pedwarn ("invalid application of %<sizeof%> to a function type");
value = size_one_node;
}
else
{
if (type_code == VOID_TYPE
&& complain && (pedantic || warn_pointer_arith))
- pedwarn ("invalid application of `%s' to a void type", op_name);
+ pedwarn ("invalid application of %qs to a void type", op_name);
value = size_one_node;
}
else if (!COMPLETE_TYPE_P (type))
{
if (complain)
- error ("invalid application of `%s' to incomplete type `%T' ",
+ error ("invalid application of %qs to incomplete type %qT ",
op_name, type);
value = size_zero_node;
}
else if (TREE_CODE (expr) == COMPONENT_REF
&& DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
{
- error ("`__alignof' applied to a bit-field");
+ error ("%<__alignof%> applied to a bit-field");
t = size_one_node;
}
else if (TREE_CODE (expr) == COMPONENT_REF
disable_builtin_function (const char *name)
{
if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
- error ("cannot disable built-in function `%s'", name);
+ error ("cannot disable built-in function %qs", name);
else
{
disabled_builtin *new_disabled_builtin = XNEW (disabled_builtin);
TREE_INT_CST_HIGH (key), TREE_INT_CST_LOW (key));
if (TYPE_NAME (type) == 0)
- warning ("%Jcase value `%s' not in enumerated type",
+ warning ("%Jcase value %qs not in enumerated type",
CASE_LABEL (label), buf);
else
- warning ("%Jcase value `%s' not in enumerated type `%T'",
+ warning ("%Jcase value %qs not in enumerated type %qT",
CASE_LABEL (label), buf, type);
}
{
/* Warn if there are enumerators that don't correspond to
case expressions. */
- warning ("%Henumeration value `%E' not handled in switch",
+ warning ("%Henumeration value %qE not handled in switch",
&switch_location, TREE_PURPOSE (chain));
}
}
that changes what the typedef is typing. */
else
{
- warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
+ warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
*no_add_attrs = true;
}
DECL_COMMON (*node) = 0;
else
{
- warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
+ warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
*no_add_attrs = true;
}
DECL_COMMON (*node) = 1;
else
{
- warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
+ warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
*no_add_attrs = true;
}
TYPE_READONLY (TREE_TYPE (type)), 1));
else
{
- warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
+ warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
*no_add_attrs = true;
}
DECL_UNINLINABLE (*node) = 1;
else
{
- warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
+ warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
*no_add_attrs = true;
}
}
else
{
- warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
+ warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
*no_add_attrs = true;
}
}
else
{
- warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
+ warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
*no_add_attrs = true;
}
TREE_USED (decl) = 1;
else
{
- warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
+ warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
*no_add_attrs = true;
}
}
TREE_THIS_VOLATILE (TREE_TYPE (type))));
else
{
- warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
+ warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
*no_add_attrs = true;
}
DECL_TRANSPARENT_UNION (decl) = 1;
else
{
- warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
+ warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
*no_add_attrs = true;
}
}
else
{
- warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
+ warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
*no_add_attrs = true;
}
}
else
{
- warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
+ warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
*no_add_attrs = true;
}
*no_add_attrs = true;
if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
- warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
+ warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
else
{
int j;
this mode for this type. */
if (TREE_CODE (typefm) != INTEGER_TYPE)
{
- error ("cannot use mode '%s' for enumeral types",
+ error ("cannot use mode %qs for enumeral types",
GET_MODE_NAME (mode));
return NULL_TREE;
}
&& strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
{
- error ("%Jsection of '%D' conflicts with previous declaration",
+ error ("%Jsection of %qD conflicts with previous declaration",
*node, *node);
*no_add_attrs = true;
}
}
else
{
- error ("%Jsection attribute not allowed for '%D'", *node, *node);
+ error ("%Jsection attribute not allowed for %qD", *node, *node);
*no_add_attrs = true;
}
}
else if (TREE_CODE (decl) != VAR_DECL
&& TREE_CODE (decl) != FIELD_DECL)
{
- error ("%Jalignment may not be specified for '%D'", decl, decl);
+ error ("%Jalignment may not be specified for %qD", decl, decl);
*no_add_attrs = true;
}
else
if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
|| (TREE_CODE (decl) != FUNCTION_DECL && ! DECL_EXTERNAL (decl)))
{
- error ("%J'%D' defined both normally and as an alias", decl, decl);
+ error ("%J%qD defined both normally and as an alias", decl, decl);
*no_add_attrs = true;
}
}
else
{
- warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
+ warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
*no_add_attrs = true;
}
{
if (TREE_CODE (*node) != RECORD_TYPE && TREE_CODE (*node) != UNION_TYPE)
{
- warning ("`%s' attribute ignored on non-class types",
+ warning ("%qs attribute ignored on non-class types",
IDENTIFIER_POINTER (name));
return NULL_TREE;
}
}
else if (decl_function_context (decl) != 0 || ! TREE_PUBLIC (decl))
{
- warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
+ warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
return NULL_TREE;
}
if (! DECL_THREAD_LOCAL (decl))
{
- warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
+ warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
*no_add_attrs = true;
}
else
if (TREE_CODE (decl) != FUNCTION_DECL)
{
- error ("%J'%E' attribute applies only to functions", decl, name);
+ error ("%J%qE attribute applies only to functions", decl, name);
*no_add_attrs = true;
}
else if (DECL_INITIAL (decl))
{
- error ("%Jcan't set '%E' attribute after definition", decl, name);
+ error ("%Jcan%'t set %qE attribute after definition", decl, name);
*no_add_attrs = true;
}
else
/* ??? TODO: Support types. */
else
{
- warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
+ warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
*no_add_attrs = true;
}
if (TREE_CODE (decl) != FUNCTION_DECL)
{
- error ("%J'%E' attribute applies only to functions", decl, name);
+ error ("%J%qE attribute applies only to functions", decl, name);
*no_add_attrs = true;
}
else if (DECL_INITIAL (decl))
{
- error ("%Jcan't set '%E' attribute after definition", decl, name);
+ error ("%Jcan%'t set %qE attribute after definition", decl, name);
*no_add_attrs = true;
}
else
/* ??? TODO: Support types. */
else
{
- warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
+ warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
*no_add_attrs = true;
}
what = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
}
if (what)
- warning ("`%s' attribute ignored for `%s'",
+ warning ("%qs attribute ignored for %qs",
IDENTIFIER_POINTER (name), what);
else
- warning ("`%s' attribute ignored",
+ warning ("%qs attribute ignored",
IDENTIFIER_POINTER (name));
}
if (! host_integerp (size, 1))
{
- warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
+ warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
return NULL_TREE;
}
&& GET_MODE_CLASS (orig_mode) != MODE_INT)
|| ! host_integerp (TYPE_SIZE_UNIT (type), 1))
{
- error ("invalid vector type for attribute `%s'",
+ error ("invalid vector type for attribute %qs",
IDENTIFIER_POINTER (name));
return NULL_TREE;
}
/* ??? TODO: Support types. */
else
{
- warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
+ warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
*no_add_attrs = true;
}
we'd be missing too much, since we do have attribute constructor. */
if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
{
- warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
+ warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
*no_add_attrs = true;
return NULL_TREE;
}
/* Ignore the attribute for functions not returning any value. */
if (VOID_TYPE_P (TREE_TYPE (*node)))
{
- warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
+ warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
*no_add_attrs = true;
}
if (!params)
{
- warning ("`%s' attribute requires prototypes with named arguments",
+ warning ("%qs attribute requires prototypes with named arguments",
IDENTIFIER_POINTER (name));
*no_add_attrs = true;
}
if (VOID_TYPE_P (TREE_VALUE (params)))
{
- warning ("`%s' attribute only applies to variadic functions",
+ warning ("%qs attribute only applies to variadic functions",
IDENTIFIER_POINTER (name));
*no_add_attrs = true;
}
else if (token == CPP_NAME)
error ("%s before \"%s\"", string, IDENTIFIER_POINTER (value));
else if (token < N_TTYPES)
- error ("%s before '%s' token", string, cpp_type2name (token));
+ error ("%s before %qs token", string, cpp_type2name (token));
else
error ("%s", string);
}
if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype)))
{
if (fdecl)
- warning ("%Hignoring return value of `%D', "
+ warning ("%Hignoring return value of %qD, "
"declared with attribute warn_unused_result",
EXPR_LOCUS (t), fdecl);
else
if (DECL_C_BIT_FIELD (t))
{
error ("attempt to take address of bit-field structure "
- "member `%s'", IDENTIFIER_POINTER (DECL_NAME (t)));
+ "member %qs", IDENTIFIER_POINTER (DECL_NAME (t)));
return error_mark_node;
}
off = size_binop (PLUS_EXPR, DECL_FIELD_OFFSET (t),
&& ! DECL_EXTERNAL (decl)
&& TYPE_DOMAIN (type) == 0)
{
- warning ("%Jarray '%D' assumed to have one element", decl, decl);
+ warning ("%Jarray %qD assumed to have one element", decl, decl);
complete_array_type (type, NULL_TREE, 1);
/* Warnings for unused labels, errors for undefined labels. */
if (TREE_USED (p) && !DECL_INITIAL (p))
{
- error ("%Jlabel `%D' used but not defined", p, p);
+ error ("%Jlabel %qD used but not defined", p, p);
DECL_INITIAL (p) = error_mark_node;
}
else if (!TREE_USED (p) && warn_unused_label)
{
if (DECL_INITIAL (p))
- warning ("%Jlabel `%D' defined but not used", p, p);
+ warning ("%Jlabel %qD defined but not used", p, p);
else
- warning ("%Jlabel `%D' declared but not defined", p, p);
+ warning ("%Jlabel %qD declared but not defined", p, p);
}
/* Labels go in BLOCK_VARS. */
TREE_CHAIN (p) = BLOCK_VARS (block);
|| (TREE_STATIC (p) && !TREE_PUBLIC (p)
&& !TREE_THIS_VOLATILE (p)))
&& scope != external_scope)
- warning ("%Junused variable `%D'", p, p);
+ warning ("%Junused variable %qD", p, p);
if (b->inner_comp)
{
agree on the number of arguments. */
if (END_OF_ARGLIST (oldargtype))
{
- error ("%Jprototype for '%D' declares more arguments "
+ error ("%Jprototype for %qD declares more arguments "
"than previous old-style definition", newdecl, newdecl);
return false;
}
else if (END_OF_ARGLIST (newargtype))
{
- error ("%Jprototype for '%D' declares fewer arguments "
+ error ("%Jprototype for %qD declares fewer arguments "
"than previous old-style definition", newdecl, newdecl);
return false;
}
for the arg. */
else if (! comptypes (oldargtype, newargtype))
{
- error ("%Jprototype for '%D' declares arg %d with incompatible type",
+ error ("%Jprototype for %qD declares arg %d with incompatible type",
newdecl, newdecl, i);
return false;
}
/* If we get here, no errors were found, but do issue a warning
for this poor-style construct. */
- warning ("%Jprototype for '%D' follows non-prototype definition",
+ warning ("%Jprototype for %qD follows non-prototype definition",
newdecl, newdecl);
return true;
#undef END_OF_ARGLIST
if (TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl))
;
else if (DECL_INITIAL (decl))
- diag (N_("%Jprevious definition of '%D' was here"), decl, decl);
+ diag (N_("%Jprevious definition of %qD was here"), decl, decl);
else if (C_DECL_IMPLICIT (decl))
- diag (N_("%Jprevious implicit declaration of '%D' was here"), decl, decl);
+ diag (N_("%Jprevious implicit declaration of %qD was here"), decl, decl);
else
- diag (N_("%Jprevious declaration of '%D' was here"), decl, decl);
+ diag (N_("%Jprevious declaration of %qD was here"), decl, decl);
}
/* Subroutine of duplicate_decls. Compare NEWDECL to OLDDECL.
&& DECL_BUILT_IN (olddecl)
&& !C_DECL_DECLARED_BUILTIN (olddecl)))
{
- error ("%J'%D' redeclared as different kind of symbol",
+ error ("%J%qD redeclared as different kind of symbol",
newdecl, newdecl);
locate_old_decl (olddecl, error);
}
else if (TREE_PUBLIC (newdecl))
- warning ("%Jbuilt-in function '%D' declared as non-function",
+ warning ("%Jbuilt-in function %qD declared as non-function",
newdecl, newdecl);
else if (warn_shadow)
- warning ("%Jdeclaration of '%D' shadows a built-in function",
+ warning ("%Jdeclaration of %qD shadows a built-in function",
newdecl, newdecl);
return false;
}
/* If types don't match for a built-in, throw away the
built-in. No point in calling locate_old_decl here, it
won't print anything. */
- warning ("%Jconflicting types for built-in function '%D'",
+ warning ("%Jconflicting types for built-in function %qD",
newdecl, newdecl);
return false;
}
&& TYPE_MAIN_VARIANT (TREE_TYPE (newtype)) == integer_type_node
&& C_FUNCTION_IMPLICIT_INT (newdecl))
{
- pedwarn ("%Jconflicting types for '%D'", newdecl, newdecl);
+ pedwarn ("%Jconflicting types for %qD", newdecl, newdecl);
/* Make sure we keep void as the return type. */
TREE_TYPE (newdecl) = *newtypep = newtype = oldtype;
C_FUNCTION_IMPLICIT_INT (newdecl) = 0;
else
{
if (TYPE_QUALS (newtype) != TYPE_QUALS (oldtype))
- error ("%J conflicting type qualifiers for '%D'", newdecl, newdecl);
+ error ("%J conflicting type qualifiers for %qD", newdecl, newdecl);
else
- error ("%Jconflicting types for '%D'", newdecl, newdecl);
+ error ("%Jconflicting types for %qD", newdecl, newdecl);
diagnose_arglist_conflict (newdecl, olddecl, newtype, oldtype);
locate_old_decl (olddecl, error);
return false;
if (DECL_IN_SYSTEM_HEADER (newdecl) || DECL_IN_SYSTEM_HEADER (olddecl))
return true; /* Allow OLDDECL to continue in use. */
- error ("%Jredefinition of typedef '%D'", newdecl, newdecl);
+ error ("%Jredefinition of typedef %qD", newdecl, newdecl);
locate_old_decl (olddecl, error);
return false;
}
&& !TYPE_ARG_TYPES (TREE_TYPE (newdecl)))))
{
if (warn_shadow)
- warning ("%Jdeclaration of '%D' shadows a built-in function",
+ warning ("%Jdeclaration of %qD shadows a built-in function",
newdecl, newdecl);
/* Discard the old built-in function. */
return false;
&& DECL_EXTERNAL (newdecl)
&& same_translation_unit_p (olddecl, newdecl))))
{
- error ("%Jredefinition of '%D'", newdecl, newdecl);
+ error ("%Jredefinition of %qD", newdecl, newdecl);
locate_old_decl (olddecl, error);
return false;
}
&& !(DECL_EXTERNAL (olddecl)
&& DECL_DECLARED_INLINE_P (olddecl)))
{
- error ("%Jstatic declaration of '%D' follows "
+ error ("%Jstatic declaration of %qD follows "
"non-static declaration", newdecl, newdecl);
locate_old_decl (olddecl, error);
}
{
if (DECL_CONTEXT (olddecl))
{
- error ("%Jnon-static declaration of '%D' follows "
+ error ("%Jnon-static declaration of %qD follows "
"static declaration", newdecl, newdecl);
locate_old_decl (olddecl, error);
return false;
}
else if (warn_traditional)
{
- warning ("%Jnon-static declaration of '%D' follows "
+ warning ("%Jnon-static declaration of %qD follows "
"static declaration", newdecl, newdecl);
warned = true;
}
if (DECL_THREAD_LOCAL (newdecl) != DECL_THREAD_LOCAL (olddecl))
{
if (DECL_THREAD_LOCAL (newdecl))
- error ("%Jthread-local declaration of '%D' follows "
+ error ("%Jthread-local declaration of %qD follows "
"non-thread-local declaration", newdecl, newdecl);
else
- error ("%Jnon-thread-local declaration of '%D' follows "
+ error ("%Jnon-thread-local declaration of %qD follows "
"thread-local declaration", newdecl, newdecl);
locate_old_decl (olddecl, error);
/* Multiple initialized definitions are not allowed (6.9p3,5). */
if (DECL_INITIAL (newdecl) && DECL_INITIAL (olddecl))
{
- error ("%Jredefinition of '%D'", newdecl, newdecl);
+ error ("%Jredefinition of %qD", newdecl, newdecl);
locate_old_decl (olddecl, error);
return false;
}
}
else if (warn_traditional)
{
- warning ("%Jnon-static declaration of '%D' follows "
+ warning ("%Jnon-static declaration of %qD follows "
"static declaration", newdecl, newdecl);
warned = true;
}
else
{
if (TREE_PUBLIC (newdecl))
- error ("%Jnon-static declaration of '%D' follows "
+ error ("%Jnon-static declaration of %qD follows "
"static declaration", newdecl, newdecl);
else
- error ("%Jstatic declaration of '%D' follows "
+ error ("%Jstatic declaration of %qD follows "
"non-static declaration", newdecl, newdecl);
locate_old_decl (olddecl, error);
}
else if (DECL_EXTERNAL (olddecl))
{
- error ("%Jdeclaration of '%D' with no linkage follows "
+ error ("%Jdeclaration of %qD with no linkage follows "
"extern declaration", newdecl, newdecl);
locate_old_decl (olddecl, error);
}
else
{
- error ("%Jredeclaration of '%D' with no linkage",
+ error ("%Jredeclaration of %qD with no linkage",
newdecl, newdecl);
locate_old_decl (olddecl, error);
}
if (DECL_VISIBILITY_SPECIFIED (newdecl) && DECL_VISIBILITY_SPECIFIED (olddecl)
&& DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl))
{
- warning ("%Jredeclaration of '%D' with different visibility "
+ warning ("%Jredeclaration of %qD with different visibility "
"(old visibility preserved)", newdecl, newdecl);
warned = true;
}
if (DECL_DECLARED_INLINE_P (newdecl)
&& lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
{
- warning ("%Jinline declaration of '%D' follows "
+ warning ("%Jinline declaration of %qD follows "
"declaration with attribute noinline", newdecl, newdecl);
warned = true;
}
else if (DECL_DECLARED_INLINE_P (olddecl)
&& lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
{
- warning ("%Jdeclaration of '%D' with attribute noinline follows "
+ warning ("%Jdeclaration of %qD with attribute noinline follows "
"inline declaration ", newdecl, newdecl);
warned = true;
}
{
if (TREE_USED (olddecl))
{
- warning ("%J'%D' declared inline after being called",
+ warning ("%J%qD declared inline after being called",
olddecl, olddecl);
warned = true;
}
else if (DECL_INITIAL (olddecl))
{
- warning ("%J'%D' declared inline after its definition",
+ warning ("%J%qD declared inline after its definition",
olddecl, olddecl);
warned = true;
}
if (TREE_CODE (newdecl) == PARM_DECL
&& (!TREE_ASM_WRITTEN (olddecl) || TREE_ASM_WRITTEN (newdecl)))
{
- error ("%Jredefinition of parameter '%D'", newdecl, newdecl);
+ error ("%Jredefinition of parameter %qD", newdecl, newdecl);
locate_old_decl (olddecl, error);
return false;
}
&& !(TREE_CODE (newdecl) == PARM_DECL
&& TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl)))
{
- warning ("%Jredundant redeclaration of '%D'", newdecl, newdecl);
+ warning ("%Jredundant redeclaration of %qD", newdecl, newdecl);
warned = true;
}
tree old_decl = b->decl;
if (TREE_CODE (old_decl) == PARM_DECL)
- warning ("%Jdeclaration of '%D' shadows a parameter",
+ warning ("%Jdeclaration of %qD shadows a parameter",
new_decl, new_decl);
else if (DECL_FILE_SCOPE_P (old_decl))
- warning ("%Jdeclaration of '%D' shadows a global declaration",
+ warning ("%Jdeclaration of %qD shadows a global declaration",
new_decl, new_decl);
else if (TREE_CODE (old_decl) == FUNCTION_DECL
&& DECL_BUILT_IN (old_decl))
- warning ("%Jdeclaration of '%D' shadows a built-in function",
+ warning ("%Jdeclaration of %qD shadows a built-in function",
new_decl, new_decl);
else
- warning ("%Jdeclaration of '%D' shadows a previous local",
+ warning ("%Jdeclaration of %qD shadows a previous local",
new_decl, new_decl);
if (TREE_CODE (old_decl) != FUNCTION_DECL
if (warn_nested_externs
&& scope != file_scope
&& !DECL_IN_SYSTEM_HEADER (x))
- warning ("nested extern declaration of '%D'", x);
+ warning ("nested extern declaration of %qD", x);
while (b && !B_IN_EXTERNAL_SCOPE (b))
{
&& !TREE_PUBLIC (x) && !DECL_INITIAL (x))
{
if (warn_nested_externs && !DECL_IN_SYSTEM_HEADER (x))
- warning ("nested static declaration of '%D'", x);
+ warning ("nested static declaration of %qD", x);
while (b && !B_IN_FILE_SCOPE (b))
b = b->shadowed;
default: gcc_unreachable ();
}
- diag (N_("implicit declaration of function '%E'"), id);
+ diag (N_("implicit declaration of function %qE"), id);
if (olddecl)
locate_old_decl (olddecl, diag);
}
if (current_function_decl == 0)
{
- error ("'%E' undeclared here (not in a function)", id);
+ error ("%qE undeclared here (not in a function)", id);
scope = current_scope;
}
else
{
- error ("'%E' undeclared (first use in this function)", id);
+ error ("%qE undeclared (first use in this function)", id);
if (! already)
{
if (current_function_decl == 0)
{
- error ("label %s referenced outside of any function",
+ error ("label %qs referenced outside of any function",
IDENTIFIER_POINTER (name));
return 0;
}
at this scope */
if (b && B_IN_CURRENT_SCOPE (b))
{
- error ("duplicate label declaration `%s'", IDENTIFIER_POINTER (name));
+ error ("duplicate label declaration %qs", IDENTIFIER_POINTER (name));
locate_old_decl (b->decl, error);
/* Just use the previous declaration. */
|| (DECL_CONTEXT (label) != current_function_decl
&& C_DECLARED_LABEL_FLAG (label))))
{
- error ("%Hduplicate label `%D'", &location, label);
+ error ("%Hduplicate label %qD", &location, label);
locate_old_decl (label, error);
return 0;
}
if (warn_traditional && !in_system_header && lookup_name (name))
warning ("%Htraditional C lacks a separate namespace for labels, "
- "identifier `%s' conflicts", &location,
+ "identifier %qs conflicts", &location,
IDENTIFIER_POINTER (name));
/* Mark label as having been defined. */
pending_xref_error (void)
{
if (pending_invalid_xref != 0)
- error ("%H`%s' defined as wrong kind of tag",
+ error ("%H%qs defined as wrong kind of tag",
&pending_invalid_xref_location,
IDENTIFIER_POINTER (pending_invalid_xref));
pending_invalid_xref = 0;
if (pedantic && !flag_isoc99)
{
if (static_p || quals != NULL)
- pedwarn ("ISO C90 does not support `static' or type qualifiers in parameter array declarators");
+ pedwarn ("ISO C90 does not support %<static%> or type "
+ "qualifiers in parameter array declarators");
if (vla_unspec_p)
- pedwarn ("ISO C90 does not support `[*]' array declarators");
+ pedwarn ("ISO C90 does not support %<[*]%> array declarators");
}
if (vla_unspec_p)
- warning ("GCC does not yet properly implement `[*]' array declarators");
+ warning ("GCC does not yet properly implement %<[*]%> array declarators");
return declarator;
}
if (warn_main > 0 && TREE_CODE (decl) != FUNCTION_DECL
&& MAIN_NAME_P (DECL_NAME (decl)))
- warning ("%J'%D' is usually a function", decl, decl);
+ warning ("%J%qD is usually a function", decl, decl);
if (initialized)
/* Is it valid for this decl to have an initializer at all?
switch (TREE_CODE (decl))
{
case TYPE_DECL:
- error ("typedef '%D' is initialized (use __typeof__ instead)", decl);
+ error ("typedef %qD is initialized (use __typeof__ instead)", decl);
initialized = 0;
break;
case FUNCTION_DECL:
- error ("function '%D' is initialized like a variable", decl);
+ error ("function %qD is initialized like a variable", decl);
initialized = 0;
break;
case PARM_DECL:
/* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE. */
- error ("parameter '%D' is initialized", decl);
+ error ("parameter %qD is initialized", decl);
initialized = 0;
break;
}
else if (TREE_CODE (TREE_TYPE (decl)) != ARRAY_TYPE)
{
- error ("variable '%D' has initializer but incomplete type", decl);
+ error ("variable %qD has initializer but incomplete type", decl);
initialized = 0;
}
else if (!COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (decl))))
{
- error ("elements of array '%D' have incomplete type", decl);
+ error ("elements of array %qD have incomplete type", decl);
initialized = 0;
}
}
&& DECL_DECLARED_INLINE_P (decl)
&& DECL_UNINLINABLE (decl)
&& lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
- warning ("%Jinline function '%D' given attribute noinline", decl, decl);
+ warning ("%Jinline function %qD given attribute noinline", decl, decl);
/* Add this decl to the current scope.
TEM may equal DECL or it may be a previous decl of the same name. */
type = TREE_TYPE (decl);
if (failure == 1)
- error ("%Jinitializer fails to determine size of '%D'", decl, decl);
+ error ("%Jinitializer fails to determine size of %qD", decl, decl);
else if (failure == 2)
{
if (do_default)
- error ("%Jarray size missing in '%D'", decl, decl);
+ error ("%Jarray size missing in %qD", decl, decl);
/* If a `static' var's size isn't known,
make it extern as well as static, so it does not get
allocated.
warn only if the value is less than zero. */
else if (pedantic && TYPE_DOMAIN (type) != 0
&& tree_int_cst_sgn (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) < 0)
- error ("%Jzero or negative size array '%D'", decl, decl);
+ error ("%Jzero or negative size array %qD", decl, decl);
layout_decl (decl, 0);
}
is an error. */
: !DECL_EXTERNAL (decl)))
{
- error ("%Jstorage size of '%D' isn't known", decl, decl);
+ error ("%Jstorage size of %qD isn%'t known", decl, decl);
TREE_TYPE (decl) = error_mark_node;
}
if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
constant_expression_warning (DECL_SIZE (decl));
else
- error ("%Jstorage size of '%D' isn't constant", decl, decl);
+ error ("%Jstorage size of %qD isn%'t constant", decl, decl);
}
if (TREE_USED (type))
&& !C_DECL_REGISTER (decl)
&& !TREE_STATIC (decl))
warning ("%Jignoring asm-specifier for non-static local "
- "variable '%D'", decl, decl);
+ "variable %qD", decl, decl);
else if (C_DECL_REGISTER (decl))
change_decl_assembler_name (decl, get_identifier (asmspec));
else
field widths. */
if (TREE_CODE (*width) != INTEGER_CST)
{
- error ("bit-field `%s' width not an integer constant", name);
+ error ("bit-field %qs width not an integer constant", name);
*width = integer_one_node;
}
else
constant_expression_warning (*width);
if (tree_int_cst_sgn (*width) < 0)
{
- error ("negative width in bit-field `%s'", name);
+ error ("negative width in bit-field %qs", name);
*width = integer_one_node;
}
else if (integer_zerop (*width) && orig_name)
{
- error ("zero width for bit-field `%s'", name);
+ error ("zero width for bit-field %qs", name);
*width = integer_one_node;
}
}
&& TREE_CODE (*type) != BOOLEAN_TYPE
&& TREE_CODE (*type) != ENUMERAL_TYPE)
{
- error ("bit-field `%s' has invalid type", name);
+ error ("bit-field %qs has invalid type", name);
*type = unsigned_type_node;
}
&& type_mv != integer_type_node
&& type_mv != unsigned_type_node
&& type_mv != boolean_type_node)
- pedwarn ("type of bit-field `%s' is a GCC extension", name);
+ pedwarn ("type of bit-field %qs is a GCC extension", name);
if (type_mv == boolean_type_node)
max_width = CHAR_TYPE_SIZE;
if (0 < compare_tree_int (*width, max_width))
{
- error ("width of `%s' exceeds its type", name);
+ error ("width of %qs exceeds its type", name);
w = max_width;
*width = build_int_cst (NULL_TREE, w);
}
if (!lt
|| w < min_precision (lt->enum_min, TYPE_UNSIGNED (*type))
|| w < min_precision (lt->enum_max, TYPE_UNSIGNED (*type)))
- warning ("`%s' is narrower than values of its type", name);
+ warning ("%qs is narrower than values of its type", name);
}
}
\f
&& funcdef_flag)
warn_about_return_type = 1;
else if (warn_implicit_int || flag_isoc99)
- pedwarn_c99 ("type defaults to `int' in declaration of `%s'",
+ pedwarn_c99 ("type defaults to %<int%> in declaration of %qs",
name);
}
if ((specbits & 1 << (int) RID_LONG)
&& (specbits & 1 << (int) RID_SHORT))
- error ("both long and short specified for `%s'", name);
+ error ("both long and short specified for %qs", name);
else if (((specbits & 1 << (int) RID_LONG)
|| (specbits & 1 << (int) RID_SHORT))
&& declspecs->explicit_char_p)
- error ("long or short specified with char for `%s'", name);
+ error ("long or short specified with char for %qs", name);
else if (((specbits & 1 << (int) RID_LONG)
|| (specbits & 1 << (int) RID_SHORT))
&& TREE_CODE (type) == REAL_TYPE)
{
static int already = 0;
- error ("long or short specified with floating type for `%s'", name);
+ error ("long or short specified with floating type for %qs", name);
if (! already && ! pedantic)
{
- error ("the only valid combination is `long double'");
+ error ("the only valid combination is %<long double%>");
already = 1;
}
}
else if ((specbits & 1 << (int) RID_SIGNED)
&& (specbits & 1 << (int) RID_UNSIGNED))
- error ("both signed and unsigned specified for `%s'", name);
+ error ("both signed and unsigned specified for %qs", name);
else if (TREE_CODE (type) != INTEGER_TYPE)
- error ("long, short, signed or unsigned invalid for `%s'", name);
+ error ("long, short, signed or unsigned invalid for %qs", name);
else
{
ok = 1;
if (!declspecs->explicit_int_p && !defaulted_int
&& !declspecs->explicit_char_p)
{
- error ("long, short, signed or unsigned used invalidly for `%s'",
+ error ("long, short, signed or unsigned used invalidly for %qs",
name);
ok = 0;
}
if ((specbits & (1 << (int) RID_COMPLEX))
&& TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
{
- error ("complex invalid for `%s'", name);
+ error ("complex invalid for %qs", name);
specbits &= ~(1 << (int) RID_COMPLEX);
}
| (1 << (int) RID_UNSIGNED))))
{
if (pedantic)
- pedwarn ("ISO C does not support plain `complex' meaning `double complex'");
+ pedwarn ("ISO C does not support plain %<complex%> meaning "
+ "%<double complex%>");
type = complex_double_type_node;
}
else if (type == integer_type_node)
if (pedantic && !flag_isoc99)
{
if (constp > 1)
- pedwarn ("duplicate `const'");
+ pedwarn ("duplicate %<const%>");
if (restrictp > 1)
- pedwarn ("duplicate `restrict'");
+ pedwarn ("duplicate %<restrict%>");
if (volatilep > 1)
- pedwarn ("duplicate `volatile'");
+ pedwarn ("duplicate %<volatile%>");
}
if (! flag_gen_aux_info && (TYPE_QUALS (type)))
type = TYPE_MAIN_VARIANT (type);
else if (current_scope == file_scope)
{
if (storage_class == csc_auto)
- error ("file-scope declaration of `%s' specifies `auto'", name);
+ error ("file-scope declaration of %qs specifies %<auto%>", name);
if (pedantic && storage_class == csc_register)
pedwarn ("file-scope declaration of %qs specifies %<register%>", name);
}
else
{
if (storage_class == csc_extern && funcdef_flag)
- error ("nested function `%s' declared `extern'", name);
+ error ("nested function %qs declared %<extern%>", name);
else if (threadp && storage_class == csc_none)
{
error ("function-scope %qs implicitly auto and declared "
if (VOID_TYPE_P (type))
{
- error ("declaration of `%s' as array of voids", name);
+ error ("declaration of %qs as array of voids", name);
type = error_mark_node;
}
if (TREE_CODE (type) == FUNCTION_TYPE)
{
- error ("declaration of `%s' as array of functions", name);
+ error ("declaration of %qs as array of functions", name);
type = error_mark_node;
}
if (! INTEGRAL_TYPE_P (TREE_TYPE (size)))
{
- error ("size of array `%s' has non-integer type", name);
+ error ("size of array %qs has non-integer type", name);
size = integer_one_node;
}
if (pedantic && integer_zerop (size))
- pedwarn ("ISO C forbids zero-size array `%s'", name);
+ pedwarn ("ISO C forbids zero-size array %qs", name);
if (TREE_CODE (size) == INTEGER_CST)
{
constant_expression_warning (size);
if (tree_int_cst_sgn (size) < 0)
{
- error ("size of array `%s' is negative", name);
+ error ("size of array %qs is negative", name);
size = integer_one_node;
}
}
if (!flag_isoc99 && pedantic)
{
if (TREE_CONSTANT (size))
- pedwarn ("ISO C90 forbids array `%s' whose size can't be evaluated",
+ pedwarn ("ISO C90 forbids array %qs whose size "
+ "can%'t be evaluated",
name);
else
- pedwarn ("ISO C90 forbids variable-size array `%s'",
+ pedwarn ("ISO C90 forbids variable-size array %qs",
name);
}
}
complication. */
if (TREE_OVERFLOW (itype))
{
- error ("size of array `%s' is too large", name);
+ error ("size of array %qs is too large", name);
type = error_mark_node;
continue;
}
/* Warn about some types functions can't return. */
if (TREE_CODE (type) == FUNCTION_TYPE)
{
- error ("`%s' declared as function returning a function", name);
+ error ("%qs declared as function returning a function", name);
type = integer_type_node;
}
if (TREE_CODE (type) == ARRAY_TYPE)
{
- error ("`%s' declared as function returning an array", name);
+ error ("%qs declared as function returning an array", name);
type = integer_type_node;
}
&& COMPLETE_TYPE_P (type)
&& TREE_OVERFLOW (TYPE_SIZE (type)))
{
- error ("size of array `%s' is too large", name);
+ error ("size of array %qs is too large", name);
/* If we proceed with the array type as it is, we'll eventually
crash in tree_low_cst(). */
type = error_mark_node;
&& !(storage_class == csc_static
|| storage_class == csc_register)))))
{
- error ("variable or field `%s' declared void", name);
+ error ("variable or field %qs declared void", name);
type = integer_type_node;
}
if (TREE_CODE (type) == FUNCTION_TYPE)
{
- error ("field `%s' declared as a function", name);
+ error ("field %qs declared as a function", name);
type = build_pointer_type (type);
}
else if (TREE_CODE (type) != ERROR_MARK
&& !COMPLETE_OR_UNBOUND_ARRAY_TYPE_P (type))
{
- error ("field `%s' has incomplete type", name);
+ error ("field %qs has incomplete type", name);
type = error_mark_node;
}
/* Move type qualifiers down to element of an array. */
else if (TREE_CODE (type) == FUNCTION_TYPE)
{
if (storage_class == csc_register || threadp)
- error ("invalid storage class for function `%s'", name);
+ error ("invalid storage class for function %qs", name);
else if (current_scope != file_scope)
{
/* Function declaration not at file scope. Storage
if (storage_class == csc_auto)
{
if (pedantic)
- pedwarn ("invalid storage class for function `%s'", name);
+ pedwarn ("invalid storage class for function %qs", name);
}
if (storage_class == csc_static)
- error ("invalid storage class for function `%s'", name);
+ error ("invalid storage class for function %qs", name);
}
decl = build_decl (FUNCTION_DECL, declarator->u.id, type);
that the function does not return. */
if ((type_quals & TYPE_QUAL_VOLATILE)
&& !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl))))
- warning ("`noreturn' function returns non-void value");
+ warning ("%<noreturn%> function returns non-void value");
/* Every function declaration is an external reference
(DECL_EXTERNAL) except for those which are not at file
if (MAIN_NAME_P (declarator->u.id))
{
if (declspecs->inline_p)
- warning ("cannot inline function `main'");
+ warning ("cannot inline function %<main%>");
}
else if (declspecs->inline_p)
{
&& global_decl != visible_decl
&& TREE_CODE (global_decl) == VAR_DECL
&& !TREE_PUBLIC (global_decl))
- error ("variable previously declared 'static' redeclared "
- "'extern'");
+ error ("variable previously declared %<static%> redeclared "
+ "%<extern%>");
}
decl = build_decl (VAR_DECL, declarator->u.id, type);
C_DECL_VARIABLE_SIZE (decl) = 1;
if (declspecs->inline_p)
- pedwarn ("%Jvariable '%D' declared `inline'", decl, decl);
+ pedwarn ("%Jvariable %qD declared %<inline%>", decl, decl);
/* At file scope, an initialized extern declaration may follow
a static declaration. In that case, DECL_EXTERNAL will be
if (warn_strict_prototypes && arg_types == 0 && !funcdef_flag
&& !in_system_header)
- warning ("function declaration isn't a prototype");
+ warning ("function declaration isn%'t a prototype");
if (arg_types == error_mark_node)
return 0; /* don't set TYPE_ARG_TYPES in this case */
if (funcdef_flag)
{
if (DECL_NAME (parm))
- error ("%Jparameter %u ('%D') has incomplete type",
+ error ("%Jparameter %u (%qD) has incomplete type",
parm, parmno, parm);
else
error ("%Jparameter %u has incomplete type",
else
{
if (DECL_NAME (parm))
- warning ("%Jparameter %u ('%D') has incomplete type",
+ warning ("%Jparameter %u (%qD) has incomplete type",
parm, parmno, parm);
else
warning ("%Jparameter %u has incomplete type",
if (TREE_THIS_VOLATILE (b->decl)
|| TREE_READONLY (b->decl)
|| C_DECL_REGISTER (b->decl))
- error ("'void' as only parameter may not be qualified");
+ error ("%<void%> as only parameter may not be qualified");
/* There cannot be an ellipsis. */
if (ellipsis)
- error ("'void' must be the only parameter");
+ error ("%<void%> must be the only parameter");
arg_info->types = void_list_node;
return arg_info;
/* Check for forward decls that never got their actual decl. */
if (TREE_ASM_WRITTEN (decl))
- error ("%Jparameter '%D' has just a forward declaration",
+ error ("%Jparameter %qD has just a forward declaration",
decl, decl);
/* Check for (..., void, ...) and issue an error. */
else if (VOID_TYPE_P (type) && !DECL_NAME (decl))
{
if (!gave_void_only_once_err)
{
- error ("'void' must be the only parameter");
+ error ("%<void%> must be the only parameter");
gave_void_only_once_err = true;
}
}
{
if (b->id)
/* The %s will be one of 'struct', 'union', or 'enum'. */
- warning ("'%s %E' declared inside parameter list",
+ warning ("%<%s %E%> declared inside parameter list",
keyword, b->id);
else
/* The %s will be one of 'struct', 'union', or 'enum'. */
if (TYPE_FIELDS (ref))
{
if (code == UNION_TYPE)
- error ("redefinition of `union %s'", IDENTIFIER_POINTER (name));
+ error ("redefinition of %<union %s%>", IDENTIFIER_POINTER (name));
else
- error ("redefinition of `struct %s'", IDENTIFIER_POINTER (name));
+ error ("redefinition of %<struct %s%>", IDENTIFIER_POINTER (name));
}
}
else
for (y = fieldlist; y != x; y = TREE_CHAIN (y))
if (DECL_NAME (y) == DECL_NAME (x))
{
- error ("%Jduplicate member '%D'", x, x);
+ error ("%Jduplicate member %qD", x, x);
DECL_NAME (x) = NULL_TREE;
}
}
slot = htab_find_slot (htab, y, INSERT);
if (*slot)
{
- error ("%Jduplicate member '%D'", x, x);
+ error ("%Jduplicate member %qD", x, x);
DECL_NAME (x) = NULL_TREE;
}
*slot = y;
/* Detect invalid nested redefinition. */
if (TREE_TYPE (x) == t)
- error ("nested redefinition of `%s'",
+ error ("nested redefinition of %qs",
IDENTIFIER_POINTER (TYPE_NAME (t)));
if (DECL_INITIAL (x))
if (TYPE_VALUES (enumtype) != 0)
{
/* This enum is a named one that has been declared already. */
- error ("redeclaration of `enum %s'", IDENTIFIER_POINTER (name));
+ error ("redeclaration of %<enum %s%>", IDENTIFIER_POINTER (name));
/* Completely replace its old definition.
The old enumerators remain defined, however. */
value = 0;
else if (TREE_CODE (value) != INTEGER_CST)
{
- error ("enumerator value for '%E' is not an integer constant", name);
+ error ("enumerator value for %qE is not an integer constant", name);
value = 0;
}
else
if (pedantic && ! int_fits_type_p (value, integer_type_node))
{
- pedwarn ("ISO C restricts enumerator values to range of `int'");
+ pedwarn ("ISO C restricts enumerator values to range of %<int%>");
/* XXX This causes -pedantic to change the meaning of the program.
Remove? -zw 2004-03-15 */
value = convert (integer_type_node, value);
if (DECL_DECLARED_INLINE_P (decl1)
&& DECL_UNINLINABLE (decl1)
&& lookup_attribute ("noinline", DECL_ATTRIBUTES (decl1)))
- warning ("%Jinline function '%D' given attribute noinline", decl1, decl1);
+ warning ("%Jinline function %qD given attribute noinline", decl1, decl1);
announce_function (decl1);
}
if (warn_about_return_type)
- pedwarn_c99 ("return type defaults to `int'");
+ pedwarn_c99 ("return type defaults to %<int%>");
/* Make the init_value nonzero so pushdecl knows this is not tentative.
error_mark_node is replaced below (in pop_scope) with the BLOCK. */
if (warn_strict_prototypes
&& TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0
&& C_DECL_ISNT_PROTOTYPE (old_decl))
- warning ("function declaration isn't a prototype");
+ warning ("function declaration isn%'t a prototype");
/* Optionally warn of any global def with no previous prototype. */
else if (warn_missing_prototypes
&& TREE_PUBLIC (decl1)
&& ! MAIN_NAME_P (DECL_NAME (decl1))
&& C_DECL_ISNT_PROTOTYPE (old_decl))
- warning ("%Jno previous prototype for '%D'", decl1, decl1);
+ warning ("%Jno previous prototype for %qD", decl1, decl1);
/* Optionally warn of any def with no previous prototype
if the function has already been used. */
else if (warn_missing_prototypes
&& old_decl != 0 && TREE_USED (old_decl)
&& TYPE_ARG_TYPES (TREE_TYPE (old_decl)) == 0)
- warning ("%J'%D' was used with no prototype before its definition",
+ warning ("%J%qD was used with no prototype before its definition",
decl1, decl1);
/* Optionally warn of any global def with no previous declaration. */
else if (warn_missing_declarations
&& TREE_PUBLIC (decl1)
&& old_decl == 0
&& ! MAIN_NAME_P (DECL_NAME (decl1)))
- warning ("%Jno previous declaration for '%D'", decl1, decl1);
+ warning ("%Jno previous declaration for %qD", decl1, decl1);
/* Optionally warn of any def with no previous declaration
if the function has already been used. */
else if (warn_missing_declarations
&& old_decl != 0 && TREE_USED (old_decl)
&& C_DECL_IMPLICIT (old_decl))
- warning ("%J`%D' was used with no declaration before its definition",
+ warning ("%J%qD was used with no declaration before its definition",
decl1, decl1);
/* This is a definition, not a reference.
if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
!= integer_type_node)
- pedwarn ("%Jreturn type of '%D' is not `int'", decl1, decl1);
+ pedwarn ("%Jreturn type of %qD is not %<int%>", decl1, decl1);
for (args = TYPE_ARG_TYPES (TREE_TYPE (decl1)); args;
args = TREE_CHAIN (args))
{
case 1:
if (TYPE_MAIN_VARIANT (type) != integer_type_node)
- pedwarn ("%Jfirst argument of '%D' should be `int'",
+ pedwarn ("%Jfirst argument of %qD should be %<int%>",
decl1, decl1);
break;
|| TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
|| (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
!= char_type_node))
- pedwarn ("%Jsecond argument of '%D' should be 'char **'",
+ pedwarn ("%Jsecond argument of %qD should be %<char **%>",
decl1, decl1);
break;
|| TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
|| (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
!= char_type_node))
- pedwarn ("%Jthird argument of '%D' should probably be "
- "'char **'", decl1, decl1);
+ pedwarn ("%Jthird argument of %qD should probably be "
+ "%<char **%>", decl1, decl1);
break;
}
}
argument because it's only mentioned in an appendix of the
standard. */
if (argct > 0 && (argct < 2 || argct > 3))
- pedwarn ("%J'%D' takes only zero or two arguments", decl1, decl1);
+ pedwarn ("%J%qD takes only zero or two arguments", decl1, decl1);
if (! TREE_PUBLIC (decl1))
- pedwarn ("%J'%D' is normally a non-static function", decl1, decl1);
+ pedwarn ("%J%qD is normally a non-static function", decl1, decl1);
}
/* Record the decl so that the function name is defined.
decl = b->decl;
/* If we got something other than a PARM_DECL it is an error. */
if (TREE_CODE (decl) != PARM_DECL)
- error ("%J'%D' declared as a non-parameter", decl, decl);
+ error ("%J%qD declared as a non-parameter", decl, decl);
/* If the declaration is already marked, we have a duplicate
name. Complain and ignore the duplicate. */
else if (DECL_WEAK (decl))
{
- error ("%Jmultiple parameters named '%D'", decl, decl);
+ error ("%Jmultiple parameters named %qD", decl, decl);
TREE_PURPOSE (parm) = 0;
continue;
}
an int. */
else if (VOID_TYPE_P (TREE_TYPE (decl)))
{
- error ("%Jparameter '%D' declared with void type", decl, decl);
+ error ("%Jparameter %qD declared with void type", decl, decl);
TREE_TYPE (decl) = integer_type_node;
DECL_ARG_TYPE (decl) = integer_type_node;
layout_decl (decl, 0);
pushdecl (decl);
if (flag_isoc99)
- pedwarn ("%Jtype of '%D' defaults to 'int'", decl, decl);
+ pedwarn ("%Jtype of %qD defaults to %<int%>", decl, decl);
else if (extra_warnings)
- warning ("%Jtype of '%D' defaults to 'int'", decl, decl);
+ warning ("%Jtype of %qD defaults to %<int%>", decl, decl);
}
TREE_PURPOSE (parm) = decl;
if (!COMPLETE_TYPE_P (TREE_TYPE (parm)))
{
- error ("%Jparameter '%D' has incomplete type", parm, parm);
+ error ("%Jparameter %qD has incomplete type", parm, parm);
TREE_TYPE (parm) = error_mark_node;
}
if (! DECL_WEAK (parm))
{
- error ("%Jdeclaration for parameter '%D' but no such parameter",
+ error ("%Jdeclaration for parameter %qD but no such parameter",
parm, parm);
/* Pretend the parameter was not missing.
if (parm == 0 || type == 0
|| TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node)
{
- error ("number of arguments doesn't match prototype");
+ error ("number of arguments doesn%'t match prototype");
error ("%Hprototype declaration",
¤t_function_prototype_locus);
break;
if (pedantic)
{
- pedwarn ("promoted argument '%D' "
- "doesn't match prototype", parm);
+ pedwarn ("promoted argument %qD "
+ "doesn%'t match prototype", parm);
pedwarn ("%Hprototype declaration",
¤t_function_prototype_locus);
}
}
else
{
- error ("argument '%D' doesn't match prototype", parm);
+ error ("argument %qD doesn%'t match prototype", parm);
error ("%Hprototype declaration",
¤t_function_prototype_locus);
}
/* If warn_main is 1 (-Wmain) or 2 (-Wall), we have already warned.
If warn_main is -1 (-Wno-main) we don't want to be warned. */
if (!warn_main)
- pedwarn ("%Jreturn type of '%D' is not `int'", fndecl, fndecl);
+ pedwarn ("%Jreturn type of %qD is not %<int%>", fndecl, fndecl);
}
else
{
/* If we get here, declarations have been used in a for loop without
the C99 for loop scope. This doesn't make much sense, so don't
allow it. */
- error ("'for' loop initial declaration used outside C99 mode");
+ error ("%<for%> loop initial declaration used outside C99 mode");
return;
}
/* C99 subclause 6.8.5 paragraph 3:
{
case VAR_DECL:
if (TREE_STATIC (decl))
- error ("%Jdeclaration of static variable '%D' in 'for' loop "
+ error ("%Jdeclaration of static variable %qD in %<for%> loop "
"initial declaration", decl, decl);
else if (DECL_EXTERNAL (decl))
- error ("%Jdeclaration of 'extern' variable '%D' in 'for' loop "
+ error ("%Jdeclaration of %<extern%> variable %qD in %<for%> loop "
"initial declaration", decl, decl);
break;
case RECORD_TYPE:
- error ("'struct %E' declared in 'for' loop initial declaration", id);
+ error ("%<struct %E%> declared in %<for%> loop initial declaration",
+ id);
break;
case UNION_TYPE:
- error ("'union %E' declared in 'for' loop initial declaration", id);
+ error ("%<union %E%> declared in %<for%> loop initial declaration",
+ id);
break;
case ENUMERAL_TYPE:
- error ("'enum %E' declared in 'for' loop initial declaration", id);
+ error ("%<enum %E%> declared in %<for%> loop initial declaration",
+ id);
break;
default:
- error ("%Jdeclaration of non-variable '%D' in 'for' loop "
+ error ("%Jdeclaration of non-variable %qD in %<for%> loop "
"initial declaration", decl, decl);
}
}
&& !TREE_PUBLIC (decl)
&& C_DECL_USED (decl))
{
- pedwarn ("%J%<%F%> used but never defined", decl, decl);
+ pedwarn ("%J%qF used but never defined", decl, decl);
TREE_NO_WARNING (decl) = 1;
}
}
if (itk > itk_unsigned_long
&& (flags & CPP_N_WIDTH) != CPP_N_LARGE
&& ! in_system_header && ! flag_isoc99)
- pedwarn ("integer constant is too large for \"%s\" type",
+ pedwarn ("integer constant is too large for %qs type",
(flags & CPP_N_UNSIGNED) ? "unsigned long" : "long");
value = build_int_cst_wide (type, integer.low, integer.high);
??? That's a dubious reason... is this a mandatory diagnostic or
isn't it? -- zw, 2001-08-21. */
if (REAL_VALUE_ISINF (real) && pedantic)
- warning ("floating constant exceeds range of \"%s\"", type_name);
+ warning ("floating constant exceeds range of %<%s%>", type_name);
/* Create a node with determined type and value. */
value = build_real (type, real);
&& lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)) == NULL)
{
if (do_warning)
- warning ("%Jfunction '%F' can never be inlined because it "
+ warning ("%Jfunction %qF can never be inlined because it "
"is suppressed using -fno-inline", fn, fn);
goto cannot_inline;
}
if (!DECL_DECLARED_INLINE_P (fn) && !targetm.binds_local_p (fn))
{
if (do_warning)
- warning ("%Jfunction '%F' can never be inlined because it might not "
+ warning ("%Jfunction %qF can never be inlined because it might not "
"be bound within this unit of translation", fn, fn);
goto cannot_inline;
}
if (! function_attribute_inlinable_p (fn))
{
if (do_warning)
- warning ("%Jfunction '%F' can never be inlined because it uses "
+ warning ("%Jfunction %qF can never be inlined because it uses "
"attributes conflicting with inlining", fn, fn);
goto cannot_inline;
}
if (t)
{
if (do_warning)
- warning ("%Jfunction '%F' can never be inlined because it has "
+ warning ("%Jfunction %qF can never be inlined because it has "
"pending sizes", fn, fn);
goto cannot_inline;
}
if (DECL_LANG_SPECIFIC (fn)->pending_sizes)
{
if (do_warning)
- warning ("%Jnested function '%F' can never be inlined because it "
+ warning ("%Jnested function %qF can never be inlined because it "
"has possibly saved pending sizes", fn, fn);
goto cannot_inline;
}
return false;
case OPT_fconstant_string_class_:
- error ("no class name specified with \"%s\"", opt);
+ error ("no class name specified with %qs", opt);
break;
case OPT_A:
- error ("assertion missing after \"%s\"", opt);
+ error ("assertion missing after %qs", opt);
break;
case OPT_D:
case OPT_U:
- error ("macro name missing after \"%s\"", opt);
+ error ("macro name missing after %qs", opt);
break;
case OPT_F:
case OPT_isysroot:
case OPT_isystem:
case OPT_iquote:
- error ("missing path after \"%s\"", opt);
+ error ("missing path after %qs", opt);
break;
case OPT_MF:
case OPT_include:
case OPT_imacros:
case OPT_o:
- error ("missing filename after \"%s\"", opt);
+ error ("missing filename after %qs", opt);
break;
case OPT_MQ:
case OPT_MT:
- error ("missing makefile target after \"%s\"", opt);
+ error ("missing makefile target after %qs", opt);
break;
}
case OPT_fvtable_thunks:
case OPT_fxref:
case OPT_fvtable_gc:
- warning ("switch \"%s\" is no longer supported", option->opt_text);
+ warning ("switch %qs is no longer supported", option->opt_text);
break;
case OPT_faccess_control:
| error '}'
| ';'
{ if (pedantic)
- pedwarn ("ISO C does not allow extra `;' outside of a function"); }
+ pedwarn ("ISO C does not allow extra %<;%> outside of a function"); }
;
\f
fndef:
in_sizeof--;
if (TREE_CODE ($2.value) == COMPONENT_REF
&& DECL_C_BIT_FIELD (TREE_OPERAND ($2.value, 1)))
- error ("`sizeof' applied to a bit-field");
+ error ("%<sizeof%> applied to a bit-field");
$$ = c_expr_sizeof_expr ($2); }
| sizeof '(' typename ')' %prec HYPERUNARY
{ skip_evaluation--;
in_typeof--;
if (TREE_CODE ($3.value) == COMPONENT_REF
&& DECL_C_BIT_FIELD (TREE_OPERAND ($3.value, 1)))
- error ("`typeof' applied to a bit-field");
+ error ("%<typeof%> applied to a bit-field");
$$ = TREE_TYPE ($3.value);
pop_maybe_used (variably_modified_type_p ($$, NULL_TREE)); }
| typeof '(' typename ')'
pedwarn ("ISO C90 forbids specifying subobject to initialize"); }
| designator initval
{ if (pedantic)
- pedwarn ("obsolete use of designated initializer without `='"); }
+ pedwarn ("obsolete use of designated initializer without %<=%>"); }
| identifier ':'
{ set_init_label ($1);
if (pedantic)
- pedwarn ("obsolete use of designated initializer with `:'"); }
+ pedwarn ("obsolete use of designated initializer with %<:%>"); }
initval
{}
| initval
/* In ISO C, enumerated types can be referred to
only if already defined. */
if (pedantic && !COMPLETE_TYPE_P ($$))
- pedwarn ("ISO C forbids forward references to `enum' types"); }
+ pedwarn ("ISO C forbids forward references to %<enum%> types"); }
;
maybecomma:
$$->others = 0;
/* Suppress -Wold-style-definition for this case. */
$$->types = error_mark_node;
- error ("ISO C requires a named argument before `...'");
+ error ("ISO C requires a named argument before %<...%>");
}
| parms
{ $$ = get_parm_info (/*ellipsis=*/false); }
/* These tokens should not survive translation phase 4. */
case CPP_HASH:
case CPP_PASTE:
- error ("syntax error at '%s' token", NAME(last_token));
+ error ("syntax error at %qs token", NAME(last_token));
goto get_next;
default:
case SCSPEC:
case STATIC:
if (IDENTIFIER_POINTER (t))
- fprintf (file, " `%s'", IDENTIFIER_POINTER (t));
+ fprintf (file, " '%s'", IDENTIFIER_POINTER (t));
break;
case CONSTANT:
enum { set, push, pop } action;
if (c_lex (&x) != CPP_OPEN_PAREN)
- GCC_BAD ("missing '(' after '#pragma pack' - ignored");
+ GCC_BAD ("missing %<(%> after %<#pragma pack%> - ignored");
token = c_lex (&x);
if (token == CPP_CLOSE_PAREN)
align = TREE_INT_CST_LOW (x);
action = set;
if (c_lex (&x) != CPP_CLOSE_PAREN)
- GCC_BAD ("malformed '#pragma pack' - ignored");
+ GCC_BAD ("malformed %<#pragma pack%> - ignored");
}
else if (token == CPP_NAME)
{
#define GCC_BAD_ACTION do { if (action != pop) \
- GCC_BAD ("malformed '#pragma pack(push[, id][, <n>])' - ignored"); \
+ GCC_BAD ("malformed %<#pragma pack(push[, id][, <n>])%> - ignored"); \
else \
- GCC_BAD ("malformed '#pragma pack(pop[, id])' - ignored"); \
+ GCC_BAD ("malformed %<#pragma pack(pop[, id])%> - ignored"); \
} while (0)
const char *op = IDENTIFIER_POINTER (x);
else if (!strcmp (op, "pop"))
action = pop;
else
- GCC_BAD2 ("unknown action '%s' for '#pragma pack' - ignored", op);
+ GCC_BAD2 ("unknown action %qs for %<#pragma pack%> - ignored", op);
while ((token = c_lex (&x)) == CPP_COMMA)
{
#undef GCC_BAD_ACTION
}
else
- GCC_BAD ("malformed '#pragma pack' - ignored");
+ GCC_BAD ("malformed %<#pragma pack%> - ignored");
if (c_lex (&x) != CPP_EOF)
- warning ("junk at end of '#pragma pack'");
+ warning ("junk at end of %<#pragma pack%>");
if (flag_pack_struct)
GCC_BAD ("#pragma pack has no effect with -fpack-struct - ignored");
if (SUPPORTS_WEAK && DECL_EXTERNAL (decl) && TREE_USED (decl)
&& !DECL_WEAK (decl) /* Don't complain about a redundant #pragma. */
&& TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
- warning ("%Japplying #pragma weak '%D' after first use results "
+ warning ("%Japplying #pragma weak %qD after first use results "
"in unspecified behavior", decl, decl);
declare_weak (decl);
{
if (!visidx)
{
- GCC_BAD ("No matching push for '#pragma GCC visibility pop'");
+ GCC_BAD ("No matching push for %<#pragma GCC visibility pop%>");
}
else
{
else
{
if (c_lex (&x) != CPP_OPEN_PAREN)
- GCC_BAD ("missing '(' after '#pragma GCC visibility push' - ignored");
+ GCC_BAD ("missing %<(%> after %<#pragma GCC visibility push%> - ignored");
token = c_lex (&x);
if (token != CPP_NAME)
{
visibility_options.inpragma = 1;
}
if (c_lex (&x) != CPP_CLOSE_PAREN)
- GCC_BAD ("missing '(' after '#pragma GCC visibility push' - ignored");
+ GCC_BAD ("missing '(' after %<#pragma GCC visibility push%> - ignored");
}
}
if (c_lex (&x) != CPP_EOF)
- warning ("junk at end of '#pragma GCC visibility'");
+ warning ("junk at end of %<#pragma GCC visibility%>");
}
#endif
extern void set_init_label (tree);
extern void process_init_element (struct c_expr);
extern tree build_compound_literal (tree, tree);
-extern void pedwarn_c90 (const char *, ...) ATTRIBUTE_PRINTF_1;
-extern void pedwarn_c99 (const char *, ...) ATTRIBUTE_PRINTF_1;
extern tree c_start_case (tree);
extern void c_finish_case (tree);
extern tree build_asm_expr (tree, tree, tree, tree, bool);
diagnostic framework extensions, you must include this file before
toplev.h, not after. */
#define GCC_DIAG_STYLE __gcc_cdiag__
+#if GCC_VERSION >= 3005
+#define ATTRIBUTE_GCC_CDIAG(m, n) __attribute__ ((__format__ (GCC_DIAG_STYLE, m ,n))) ATTRIBUTE_NONNULL(m)
+#else
+#define ATTRIBUTE_GCC_CDIAG(m, n) ATTRIBUTE_NONNULL(m)
+#endif
+
+extern void pedwarn_c90 (const char *, ...) ATTRIBUTE_GCC_CDIAG(1,2);
+extern void pedwarn_c99 (const char *, ...) ATTRIBUTE_GCC_CDIAG(1,2);
#endif /* ! GCC_C_TREE_H */
if (value != 0 && (TREE_CODE (value) == VAR_DECL
|| TREE_CODE (value) == PARM_DECL))
- error ("`%s' has an incomplete type",
+ error ("%qs has an incomplete type",
IDENTIFIER_POINTER (DECL_NAME (value)));
else
{
}
if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
- error ("invalid use of undefined type `%s %s'",
+ error ("invalid use of undefined type %<%s %s%>",
type_code_string, IDENTIFIER_POINTER (TYPE_NAME (type)));
else
/* If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL. */
- error ("invalid use of incomplete typedef `%s'",
+ error ("invalid use of incomplete typedef %qs",
IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
}
}
/* 'volatile' qualifiers on a function's return type used to mean
the function is noreturn. */
if (TYPE_VOLATILE (ret1) != TYPE_VOLATILE (ret2))
- pedwarn ("function return types not compatible due to `volatile'");
+ pedwarn ("function return types not compatible due to %<volatile%>");
if (TYPE_VOLATILE (ret1))
ret1 = build_qualified_type (TYPE_MAIN_VARIANT (ret1),
TYPE_QUALS (ret1) & ~TYPE_QUAL_VOLATILE);
if (!field)
{
- error ("%s has no member named `%s'",
+ error ("%s has no member named %qs",
code == RECORD_TYPE ? "structure" : "union",
IDENTIFIER_POINTER (component));
return error_mark_node;
return ref;
}
else if (code != ERROR_MARK)
- error ("request for member `%s' in something not a structure or union",
+ error ("request for member %qs in something not a structure or union",
IDENTIFIER_POINTER (component));
return error_mark_node;
return error_mark_node;
}
if (VOID_TYPE_P (t) && skip_evaluation == 0)
- warning ("dereferencing `void *' pointer");
+ warning ("dereferencing %<void *%> pointer");
/* We *must* set TREE_READONLY when dereferencing a pointer to const,
so that we get the proper error message if the result is used
}
}
else if (TREE_CODE (pointer) != ERROR_MARK)
- error ("invalid type argument of `%s'", errorstring);
+ error ("invalid type argument of %qs", errorstring);
return error_mark_node;
}
must have done so deliberately. */
if (warn_char_subscripts
&& TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node)
- warning ("array subscript has type `char'");
+ warning ("array subscript has type %<char%>");
/* Apply default promotions *after* noticing character types. */
index = default_conversion (index);
while (TREE_CODE (foo) == COMPONENT_REF)
foo = TREE_OPERAND (foo, 0);
if (TREE_CODE (foo) == VAR_DECL && C_DECL_REGISTER (foo))
- pedwarn ("ISO C forbids subscripting `register' array");
+ pedwarn ("ISO C forbids subscripting %<register%> array");
else if (! flag_isoc99 && ! lvalue_p (foo))
pedwarn ("ISO C90 forbids subscripting non-lvalue array");
}
if (warn_char_subscripts
&& TREE_CODE (TREE_TYPE (index)) == INTEGER_TYPE
&& TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node)
- warning ("subscript has type `char'");
+ warning ("subscript has type %<char%>");
/* Put the integer in IND to simplify error checking. */
if (TREE_CODE (TREE_TYPE (ar)) == INTEGER_TYPE)
ref = decl;
else if (decl != objc_ivar && !DECL_FILE_SCOPE_P (decl))
{
- warning ("local declaration of `%s' hides instance variable",
+ warning ("local declaration of %qs hides instance variable",
IDENTIFIER_POINTER (id));
ref = decl;
}
if (type == void_type_node)
{
if (name)
- error ("too many arguments to function `%s'",
+ error ("too many arguments to function %qs",
IDENTIFIER_POINTER (name));
else
error ("too many arguments to function");
/* Warn if any argument is passed as `float',
since without a prototype it would be `double'. */
if (formal_prec == TYPE_PRECISION (float_type_node))
- warn_for_assignment ("%s as `float' rather than `double' due to prototype", (char *) 0, name, parmnum + 1);
+ warn_for_assignment ("%s as %<float%> rather than "
+ "%<double%> due to prototype",
+ (char *) 0, name, parmnum + 1);
}
/* Detect integer changing in width or signedness.
These warnings are only activated with
if (typetail != 0 && TREE_VALUE (typetail) != void_type_node)
{
if (name)
- error ("too few arguments to function `%s'",
+ error ("too few arguments to function %qs",
IDENTIFIER_POINTER (name));
else
error ("too few arguments to function");
if (pedantic || warn_pointer_arith)
{
if (TREE_CODE (target_type) == VOID_TYPE)
- pedwarn ("pointer of type `void *' used in subtraction");
+ pedwarn ("pointer of type %<void *%> used in subtraction");
if (TREE_CODE (target_type) == FUNCTION_TYPE)
pedwarn ("pointer to a function used in subtraction");
}
{
code = CONJ_EXPR;
if (pedantic)
- pedwarn ("ISO C does not support `~' for complex conjugation");
+ pedwarn ("ISO C does not support %<~%> for complex conjugation");
if (!noconvert)
arg = default_conversion (arg);
}
tree real, imag;
if (pedantic)
- pedwarn ("ISO C does not support `++' and `--' on complex types");
+ pedwarn ("ISO C does not support %<++%> and %<--%>"
+ " on complex types");
arg = stabilize_reference (arg);
real = build_unary_op (REALPART_EXPR, arg, 1);
/* Anything not already handled and not a true memory reference
or a non-lvalue array is an error. */
else if (typecode != FUNCTION_TYPE && !flag
- && !lvalue_or_else (arg, "invalid lvalue in unary `&'"))
+ && !lvalue_or_else (arg, "invalid lvalue in unary %<&%>"))
return error_mark_node;
/* Ordinary case; arg is a COMPONENT_REF or a decl. */
if (TREE_CODE (arg) == COMPONENT_REF
&& DECL_C_BIT_FIELD (TREE_OPERAND (arg, 1)))
{
- error ("attempt to take address of bit-field structure member `%D'",
+ error ("attempt to take address of bit-field structure member %qD",
TREE_OPERAND (arg, 1));
return error_mark_node;
}
if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
readonly_error (TREE_OPERAND (arg, 0), msgid);
else
- error ("%s of read-only member `%s'", _(msgid),
+ error ("%s of read-only member %qs", _(msgid),
IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (arg, 1))));
}
else if (TREE_CODE (arg) == VAR_DECL)
- error ("%s of read-only variable `%s'", _(msgid),
+ error ("%s of read-only variable %qs", _(msgid),
IDENTIFIER_POINTER (DECL_NAME (arg)));
else
error ("%s of read-only location", _(msgid));
case COMPONENT_REF:
if (DECL_C_BIT_FIELD (TREE_OPERAND (x, 1)))
{
- error ("cannot take address of bit-field `%s'",
+ error ("cannot take address of bit-field %qs",
IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (x, 1))));
return false;
}
{
if (TREE_PUBLIC (x) || TREE_STATIC (x) || DECL_EXTERNAL (x))
{
- error ("global register variable `%s' used in nested function",
+ error ("global register variable %qs used in nested function",
IDENTIFIER_POINTER (DECL_NAME (x)));
return false;
}
- pedwarn ("register variable `%s' used in nested function",
+ pedwarn ("register variable %qs used in nested function",
IDENTIFIER_POINTER (DECL_NAME (x)));
}
else if (C_DECL_REGISTER (x))
{
if (TREE_PUBLIC (x) || TREE_STATIC (x) || DECL_EXTERNAL (x))
{
- error ("address of global register variable `%s' requested",
+ error ("address of global register variable %qs requested",
IDENTIFIER_POINTER (DECL_NAME (x)));
return false;
}
- pedwarn ("address of register variable `%s' requested",
+ pedwarn ("address of register variable %qs requested",
IDENTIFIER_POINTER (DECL_NAME (x)));
}
else if (VOID_TYPE_P (TREE_TYPE (type1)))
{
if (pedantic && TREE_CODE (TREE_TYPE (type2)) == FUNCTION_TYPE)
- pedwarn ("ISO C forbids conditional expr between `void *' and function pointer");
+ pedwarn ("ISO C forbids conditional expr between "
+ "%<void *%> and function pointer");
result_type = build_pointer_type (qualify_type (TREE_TYPE (type1),
TREE_TYPE (type2)));
}
else if (VOID_TYPE_P (TREE_TYPE (type2)))
{
if (pedantic && TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE)
- pedwarn ("ISO C forbids conditional expr between `void *' and function pointer");
+ pedwarn ("ISO C forbids conditional expr between "
+ "%<void *%> and function pointer");
result_type = build_pointer_type (qualify_type (TREE_TYPE (type2),
TREE_TYPE (type1)));
}
which are not ANSI null ptr constants. */
&& (!integer_zerop (rhs) || TREE_CODE (rhs) == NOP_EXPR)
&& TREE_CODE (ttl) == FUNCTION_TYPE)))
- warn_for_assignment ("ISO C forbids %s between function pointer and `void *'",
+ warn_for_assignment ("ISO C forbids %s between function "
+ "pointer and %<void *%>",
errtype, funname, parmnum);
/* Const and volatile mean something different for function types,
so the usual warnings are not appropriate. */
tree selector = objc_message_selector ();
if (selector && parmnum > 2)
- error ("incompatible type for argument %d of `%s'",
+ error ("incompatible type for argument %d of %qs",
parmnum - 2, IDENTIFIER_POINTER (selector));
else
- error ("incompatible type for argument %d of `%s'",
+ error ("incompatible type for argument %d of %qs",
parmnum, IDENTIFIER_POINTER (funname));
}
else
if (function)
{
/* Function name is known; supply it. */
- const char *const argstring = _("passing arg of `%s'");
+ const char *const argstring = _("passing arg of '%s'");
new_opname = (char *) alloca (IDENTIFIER_LENGTH (function)
+ strlen (argstring) + 1 + 1);
sprintf (new_opname, argstring,
else if (function)
{
/* Function name is known; supply it. */
- const char *const argstring = _("passing arg %d of `%s'");
+ const char *const argstring = _("passing arg %d of '%s'");
new_opname = (char *) alloca (IDENTIFIER_LENGTH (function)
+ strlen (argstring) + 1 + 25 /*%d*/ + 1);
sprintf (new_opname, argstring, argnum,
error ("%s", _(msgid));
ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
if (*ofwhat)
- error ("(near initialization for `%s')", ofwhat);
+ error ("(near initialization for %qs)", ofwhat);
}
/* Issue a pedantic warning for a bad initializer component.
pedwarn ("%s", _(msgid));
ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
if (*ofwhat)
- pedwarn ("(near initialization for `%s')", ofwhat);
+ pedwarn ("(near initialization for %qs)", ofwhat);
}
/* Issue a warning for a bad initializer component.
warning ("%s", _(msgid));
ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
if (*ofwhat)
- warning ("(near initialization for `%s')", ofwhat);
+ warning ("(near initialization for %qs)", ofwhat);
}
\f
/* If TYPE is an array type and EXPR is a parenthesized string
}
if (tail == 0)
- error ("unknown field `%s' specified in initializer",
+ error ("unknown field %qs specified in initializer",
IDENTIFIER_POINTER (fieldname));
else
{
c_finish_goto_ptr (tree expr)
{
if (pedantic)
- pedwarn ("ISO C forbids `goto *expr;'");
+ pedwarn ("ISO C forbids %<goto *expr;%>");
expr = convert (ptr_type_node, expr);
return add_stmt (build1 (GOTO_EXPR, void_type_node, expr));
}
tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl));
if (TREE_THIS_VOLATILE (current_function_decl))
- warning ("function declared `noreturn' has a `return' statement");
+ warning ("function declared %<noreturn%> has a %<return%> statement");
if (!retval)
{
current_function_returns_null = 1;
if ((warn_return_type || flag_isoc99)
&& valtype != 0 && TREE_CODE (valtype) != VOID_TYPE)
- pedwarn_c99 ("`return' with no value, in function returning non-void");
+ pedwarn_c99 ("%<return%> with no value, in "
+ "function returning non-void");
}
else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE)
{
current_function_returns_null = 1;
if (pedantic || TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
- pedwarn ("`return' with a value, in function returning void");
+ pedwarn ("%<return%> with a value, in function returning void");
}
else
{
if (warn_traditional && !in_system_header
&& (type == long_integer_type_node
|| type == long_unsigned_type_node))
- warning ("`long' switch expression not converted to `int' in ISO C");
+ warning ("%<long%> switch expression not converted to "
+ "%<int%> in ISO C");
exp = default_conversion (exp);
type = TREE_TYPE (exp);
else if (low_value)
error ("case label not within a switch statement");
else
- error ("`default' label not within a switch statement");
+ error ("%<default%> label not within a switch statement");
return label;
}
found:
if (COND_EXPR_ELSE (inner_if))
- warning ("%Hsuggest explicit braces to avoid ambiguous `else'",
+ warning ("%Hsuggest explicit braces to avoid ambiguous %<else%>",
&if_locus);
}
whose value is 0 but which isn't a valid null ptr const. */
if (pedantic && (!integer_zerop (op0) || op0 != orig_op0)
&& TREE_CODE (tt1) == FUNCTION_TYPE)
- pedwarn ("ISO C forbids comparison of `void *' with function pointer");
+ pedwarn ("ISO C forbids comparison of %<void *%>"
+ " with function pointer");
}
else if (VOID_TYPE_P (tt1))
{
if (pedantic && (!integer_zerop (op1) || op1 != orig_op1)
&& TREE_CODE (tt0) == FUNCTION_TYPE)
- pedwarn ("ISO C forbids comparison of `void *' with function pointer");
+ pedwarn ("ISO C forbids comparison of %<void *%>"
+ " with function pointer");
}
else
pedwarn ("comparison of distinct pointer types lacks a cast");
+2004-09-13 Joseph S. Myers <jsm@polyomino.org.uk>
+
+ * g++.dg/warn/Wswitch-1.C, g++.dg/warn/Wswitch-2.C,
+ gcc.dg/Wswitch-2.c, gcc.dg/Wswitch-enum.c, gcc.dg/Wswitch.c,
+ gcc.dg/declspec-9.c, gcc.dg/declspec-10.c, gcc.dg/declspec-11.c,
+ gcc.dg/m-un-2.c, gcc.dg/noreturn-1.c, gcc.dg/wtr-conversion-1.c:
+ Update expected messages.
+
2004-09-13 Hans-Peter Nilsson <hp@axis.com>
* gcc.dg/asmreg-1.c (__syscall_getdents64): Adjust signedness
case 4: return 3;
default: break;
}
- switch (ei) /* { dg-warning "enumeration value `e1' not handled in switch" "enum e1" } */
- { /* { dg-warning "enumeration value `e2' not handled in switch" "enum e2" { target *-*-* } 22 } */
+ switch (ei) /* { dg-warning "enumeration value 'e1' not handled in switch" "enum e1" } */
+ { /* { dg-warning "enumeration value 'e2' not handled in switch" "enum e2" { target *-*-* } 22 } */
}
switch (ej)
{
default: break;
}
- switch (ek) /* { dg-warning "enumeration value `e2' not handled in switch" "enum e2" } */
+ switch (ek) /* { dg-warning "enumeration value 'e2' not handled in switch" "enum e2" } */
{
case e1: return 1;
}
{
case e1: return 1;
case e2: return 2;
- case 3: return 3; /* { dg-warning "case value `3' not in enumerated type `e'" "excess 3" } */
+ case 3: return 3; /* { dg-warning "case value '3' not in enumerated type 'e'" "excess 3" } */
}
switch (ep)
{
case e3: return 2;
case e4: return 3;
} /* No warning here since e2 has the same value as e3. */
- switch (ei) /* { dg-warning "enumeration value `e4' not handled in switch" "enum e4" } */
+ switch (ei) /* { dg-warning "enumeration value 'e4' not handled in switch" "enum e4" } */
{
case e1: return 1;
case e2: return 2;
{
case e1: return 1;
} /* No warning here since switch condition was cast to int. */
- switch ((enum e) j) /* { dg-warning "enumeration value `e1' not handled in switch" "enum e1" } */
+ switch ((enum e) j) /* { dg-warning "enumeration value 'e1' not handled in switch" "enum e1" } */
{
case e2: return 1;
case e4: return 2;
case e3: return 2;
case e4: return 3;
} /* No warning here since e2 has the same value as e3. */
- switch (ei) /* { dg-warning "enumeration value `e4' not handled in switch" "enum e4" } */
+ switch (ei) /* { dg-warning "enumeration value 'e4' not handled in switch" "enum e4" } */
{
case e1: return 1;
case e2: return 2;
{
case e1: return 1;
} /* No warning here since switch condition was cast to int. */
- switch ((enum e) j) /* { dg-warning "enumeration value `e1' not handled in switch" "enum e1" } */
+ switch ((enum e) j) /* { dg-warning "enumeration value 'e1' not handled in switch" "enum e1" } */
{
case e2: return 1;
case e4: return 2;
case 4: return 3;
default: break;
}
- switch (ei) /* { dg-warning "enumeration value `e1' not handled in switch" "enum e1" } */
- { /* { dg-warning "enumeration value `e2' not handled in switch" "enum e2" { target *-*-* } 22 } */
+ switch (ei) /* { dg-warning "enumeration value 'e1' not handled in switch" "enum e1" } */
+ { /* { dg-warning "enumeration value 'e2' not handled in switch" "enum e2" { target *-*-* } 22 } */
}
- switch (ej) /* { dg-warning "enumeration value `e1' not handled in switch" "enum e1" } */
- { /* { dg-warning "enumeration value `e2' not handled in switch" "enum e2" { target *-*-* } 25 } */
+ switch (ej) /* { dg-warning "enumeration value 'e1' not handled in switch" "enum e1" } */
+ { /* { dg-warning "enumeration value 'e2' not handled in switch" "enum e2" { target *-*-* } 25 } */
default: break;
}
- switch (ek) /* { dg-warning "enumeration value `e2' not handled in switch" "enum e2" } */
+ switch (ek) /* { dg-warning "enumeration value 'e2' not handled in switch" "enum e2" } */
{
case e1: return 1;
}
- switch (el) /* { dg-warning "enumeration value `e2' not handled in switch" "enum e2" } */
+ switch (el) /* { dg-warning "enumeration value 'e2' not handled in switch" "enum e2" } */
{
case e1: return 1;
default: break;
{
case e1: return 1;
case e2: return 2;
- case 3: return 3; /* { dg-warning "case value `3' not in enumerated type `enum e'" "excess 3" } */
+ case 3: return 3; /* { dg-warning "case value '3' not in enumerated type 'enum e'" "excess 3" } */
}
switch (ep)
{
case e1: return 1;
case e2: return 2;
- case 3: return 3; /* { dg-warning "case value `3' not in enumerated type `enum e'" "excess 3" } */
+ case 3: return 3; /* { dg-warning "case value '3' not in enumerated type 'enum e'" "excess 3" } */
default: break;
}
return 0;
case 4: return 3;
default: break;
}
- switch (ei) /* { dg-warning "enumeration value `e1' not handled in switch" "enum e1" } */
- { /*{ dg-warning "enumeration value `e2' not handled in switch" "enum e2" { target *-*-* } 22 } */
+ switch (ei) /* { dg-warning "enumeration value 'e1' not handled in switch" "enum e1" } */
+ { /*{ dg-warning "enumeration value 'e2' not handled in switch" "enum e2" { target *-*-* } 22 } */
}
switch (ej)
{
default: break;
}
- switch (ek) /* { dg-warning "enumeration value `e2' not handled in switch" "enum e2" } */
+ switch (ek) /* { dg-warning "enumeration value 'e2' not handled in switch" "enum e2" } */
{
case e1: return 1;
}
{
case e1: return 1;
case e2: return 2;
- case 3: return 3; /* { dg-warning "case value `3' not in enumerated type `enum e'" "excess 3" } */
+ case 3: return 3; /* { dg-warning "case value '3' not in enumerated type 'enum e'" "excess 3" } */
}
switch (ep)
{
void f6 (static int); /* { dg-error "error: storage class specified for parameter 'type name'" } */
void f7 (typedef int); /* { dg-error "error: storage class specified for parameter 'type name'" } */
-auto int x; /* { dg-error "error: file-scope declaration of `x' specifies `auto'" } */
+auto int x; /* { dg-error "error: file-scope declaration of 'x' specifies 'auto'" } */
register int y; /* { dg-warning "warning: file-scope declaration of 'y' specifies 'register'" } */
-void h (void) { extern void x (void) {} } /* { dg-error "error: nested function `x' declared `extern'" } */
+void h (void) { extern void x (void) {} } /* { dg-error "error: nested function 'x' declared 'extern'" } */
/* { dg-warning "warning: ISO C forbids nested functions" "nested" { target *-*-* } 21 } */
void
g (void)
{
- void a; /* { dg-error "error: variable or field `a' declared void" } */
- const void b; /* { dg-error "error: variable or field `b' declared void" } */
- static void c; /* { dg-error "error: variable or field `c' declared void" } */
+ void a; /* { dg-error "error: variable or field 'a' declared void" } */
+ const void b; /* { dg-error "error: variable or field 'b' declared void" } */
+ static void c; /* { dg-error "error: variable or field 'c' declared void" } */
}
void p;
const void p1;
extern void q;
extern const void q1;
-static void r; /* { dg-error "error: variable or field `r' declared void" } */
-static const void r1; /* { dg-error "error: variable or field `r1' declared void" } */
+static void r; /* { dg-error "error: variable or field 'r' declared void" } */
+static const void r1; /* { dg-error "error: variable or field 'r1' declared void" } */
-register void f8 (void); /* { dg-error "error: invalid storage class for function `f8'" } */
+register void f8 (void); /* { dg-error "error: invalid storage class for function 'f8'" } */
/* { dg-warning "warning: file-scope declaration of 'f8' specifies 'register'" "register function" { target *-*-* } 39 } */
void i (void) { auto void y (void) {} } /* { dg-warning "warning: ISO C forbids nested functions" } */
/* { dg-warning "warning: function definition declared 'auto'" "nested" { target *-*-* } 42 } */
-inline int main (void) { return 0; } /* { dg-warning "warning: cannot inline function `main'" } */
+inline int main (void) { return 0; } /* { dg-warning "warning: cannot inline function 'main'" } */
void f6 (static int); /* { dg-error "error: storage class specified for parameter 'type name'" } */
void f7 (typedef int); /* { dg-error "error: storage class specified for parameter 'type name'" } */
-auto int x; /* { dg-error "error: file-scope declaration of `x' specifies `auto'" } */
+auto int x; /* { dg-error "error: file-scope declaration of 'x' specifies 'auto'" } */
register int y; /* { dg-error "error: file-scope declaration of 'y' specifies 'register'" } */
-void h (void) { extern void x (void) {} } /* { dg-error "error: nested function `x' declared `extern'" } */
+void h (void) { extern void x (void) {} } /* { dg-error "error: nested function 'x' declared 'extern'" } */
/* { dg-error "error: ISO C forbids nested functions" "nested" { target *-*-* } 21 } */
void
g (void)
{
- void a; /* { dg-error "error: variable or field `a' declared void" } */
- const void b; /* { dg-error "error: variable or field `b' declared void" } */
- static void c; /* { dg-error "error: variable or field `c' declared void" } */
+ void a; /* { dg-error "error: variable or field 'a' declared void" } */
+ const void b; /* { dg-error "error: variable or field 'b' declared void" } */
+ static void c; /* { dg-error "error: variable or field 'c' declared void" } */
}
void p;
const void p1;
extern void q;
extern const void q1;
-static void r; /* { dg-error "error: variable or field `r' declared void" } */
-static const void r1; /* { dg-error "error: variable or field `r1' declared void" } */
+static void r; /* { dg-error "error: variable or field 'r' declared void" } */
+static const void r1; /* { dg-error "error: variable or field 'r1' declared void" } */
-register void f8 (void); /* { dg-error "error: invalid storage class for function `f8'" } */
+register void f8 (void); /* { dg-error "error: invalid storage class for function 'f8'" } */
/* { dg-error "error: file-scope declaration of 'f8' specifies 'register'" "register function" { target *-*-* } 39 } */
void i (void) { auto void y (void) {} } /* { dg-error "error: ISO C forbids nested functions" } */
/* { dg-error "error: function definition declared 'auto'" "nested" { target *-*-* } 42 } */
-inline int main (void) { return 0; } /* { dg-warning "warning: cannot inline function `main'" } */
+inline int main (void) { return 0; } /* { dg-warning "warning: cannot inline function 'main'" } */
void f6 (static int); /* { dg-error "error: storage class specified for parameter 'type name'" } */
void f7 (typedef int); /* { dg-error "error: storage class specified for parameter 'type name'" } */
-auto int x; /* { dg-error "error: file-scope declaration of `x' specifies `auto'" } */
+auto int x; /* { dg-error "error: file-scope declaration of 'x' specifies 'auto'" } */
register int y;
-void h (void) { extern void x (void) {} } /* { dg-error "error: nested function `x' declared `extern'" } */
+void h (void) { extern void x (void) {} } /* { dg-error "error: nested function 'x' declared 'extern'" } */
void
g (void)
{
- void a; /* { dg-error "error: variable or field `a' declared void" } */
- const void b; /* { dg-error "error: variable or field `b' declared void" } */
- static void c; /* { dg-error "error: variable or field `c' declared void" } */
+ void a; /* { dg-error "error: variable or field 'a' declared void" } */
+ const void b; /* { dg-error "error: variable or field 'b' declared void" } */
+ static void c; /* { dg-error "error: variable or field 'c' declared void" } */
}
void p;
const void p1;
extern void q;
extern const void q1;
-static void r; /* { dg-error "error: variable or field `r' declared void" } */
-static const void r1; /* { dg-error "error: variable or field `r1' declared void" } */
+static void r; /* { dg-error "error: variable or field 'r' declared void" } */
+static const void r1; /* { dg-error "error: variable or field 'r1' declared void" } */
-register void f8 (void); /* { dg-error "error: invalid storage class for function `f8'" } */
+register void f8 (void); /* { dg-error "error: invalid storage class for function 'f8'" } */
void i (void) { auto void y (void) {} }
-inline int main (void) { return 0; } /* { dg-warning "warning: cannot inline function `main'" } */
+inline int main (void) { return 0; } /* { dg-warning "warning: cannot inline function 'main'" } */
malloc,
free
}; /* { dg-warning "missing initializer" "warning regression" { target *-*-* } {18} } */
- /* { dg-warning "initialization for `mtable._realloc'" "warning regression" { target *-*-* } {18} } */
+ /* { dg-warning "initialization for 'mtable._realloc'" "warning regression" { target *-*-* } {18} } */
/* With designated initializers, we assume you meant to leave out the
initialization of any blank fields. */
void
foo5(void)
{
- return; /* { dg-warning "`noreturn' has a `return' statement" "detect invalid return" } */
+ return; /* { dg-warning "'noreturn' has a 'return' statement" "detect invalid return" } */
} /* { dg-warning "function does return" "detect return from noreturn" } */
extern void foo6(void);
foo_i (cd); /* { dg-warning "as integer rather than complex" "prototype conversion warning" } */
foo_f (i); /* { dg-warning "as floating rather than integer" "prototype conversion warning" } */
- foo_f (f); /* { dg-warning "as `float' rather than `double'" "prototype conversion warning" } */
- foo_f (ld); /* { dg-warning "as `float' rather than `double'" "prototype conversion warning" } */
+ foo_f (f); /* { dg-warning "as 'float' rather than 'double'" "prototype conversion warning" } */
+ foo_f (ld); /* { dg-warning "as 'float' rather than 'double'" "prototype conversion warning" } */
foo_f (cd); /* { dg-warning "as floating rather than complex" "prototype conversion warning" } */
foo_ld (i); /* { dg-warning "as floating rather than integer" "prototype conversion warning" } */
projects / gcc.git / commitdiff