&& ! 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;
warned = 2;
}
+ if (!warned && !in_system_header && (declspecs->const_p
+ || declspecs->volatile_p
+ || declspecs->restrict_p))
+ {
+ warning ("useless type qualifier in empty declaration");
+ warned = 2;
+ }
+
if (!warned && !in_system_header && declspecs->specbits)
{
warning ("useless keyword or type name in empty declaration");
}
}
\f
+
+/* Return the qualifiers from SPECS as a bitwise OR of TYPE_QUAL_*
+ bits. SPECS represents declaration specifiers that the grammar
+ only permits to contain type qualifiers and attributes. */
+
+int
+quals_from_declspecs (const struct c_declspecs *specs)
+{
+ int quals = ((specs->const_p ? TYPE_QUAL_CONST : 0)
+ | (specs->volatile_p ? TYPE_QUAL_VOLATILE : 0)
+ | (specs->restrict_p ? TYPE_QUAL_RESTRICT : 0));
+ gcc_assert (!specs->type
+ && !specs->decl_attr
+ && !specs->specbits
+ && specs->storage_class == csc_none
+ && !specs->typedef_p
+ && !specs->typedef_signed_p
+ && !specs->deprecated_p
+ && !specs->explicit_int_p
+ && !specs->explicit_char_p
+ && !specs->long_long_p
+ && !specs->inline_p
+ && !specs->thread_p);
+ return quals;
+}
+
/* Construct an array declarator. EXPR is the expression inside [], or
NULL_TREE. QUALS are the type qualifiers inside the [] (to be applied
to the pointer to which a parameter array is converted). STATIC_P is
declarator->kind = cdk_array;
declarator->declarator = 0;
declarator->u.array.dimen = expr;
- declarator->u.array.quals = quals;
+ if (quals)
+ {
+ declarator->u.array.attrs = quals->attrs;
+ declarator->u.array.quals = quals_from_declspecs (quals);
+ }
+ else
+ {
+ declarator->u.array.attrs = NULL_TREE;
+ declarator->u.array.quals = 0;
+ }
declarator->u.array.static_p = static_p;
declarator->u.array.vla_unspec_p = vla_unspec_p;
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;
}
struct c_declarator *inner, bool abstract_p)
{
decl->declarator = inner;
- if (abstract_p && (decl->u.array.quals != NULL
+ if (abstract_p && (decl->u.array.quals != TYPE_UNQUALIFIED
+ || decl->u.array.attrs != NULL_TREE
|| decl->u.array.static_p))
error ("static or type qualifiers in abstract declarator");
return decl;
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. */
tem = pushdecl (decl);
- if (initialized)
- DECL_EXTERNAL (tem) = 0;
+ if (initialized && DECL_EXTERNAL (tem))
+ {
+ DECL_EXTERNAL (tem) = 0;
+ TREE_STATIC (tem) = 1;
+ }
return tem;
}
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
bool funcdef_syntax = false;
int size_varies = 0;
tree decl_attr = NULL_TREE;
- struct c_declspecs *array_ptr_quals = 0;
+ int array_ptr_quals = TYPE_UNQUALIFIED;
+ tree array_ptr_attrs = NULL_TREE;
int array_parm_static = 0;
tree returned_attrs = NULL_TREE;
bool bitfield = width != NULL;
&& 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)
duplicate qualifiers should be diagnosed in this case, but it
seems most appropriate to do so). */
element_type = strip_array_types (type);
- constp = !! (specbits & 1 << (int) RID_CONST) + TYPE_READONLY (element_type);
- restrictp
- = !! (specbits & 1 << (int) RID_RESTRICT) + TYPE_RESTRICT (element_type);
- volatilep
- = !! (specbits & 1 << (int) RID_VOLATILE) + TYPE_VOLATILE (element_type);
+ constp = declspecs->const_p + TYPE_READONLY (element_type);
+ restrictp = declspecs->restrict_p + TYPE_RESTRICT (element_type);
+ volatilep = declspecs->volatile_p + TYPE_VOLATILE (element_type);
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 "
array or function or pointer, and DECLARATOR has had its
outermost layer removed. */
- if (array_ptr_quals != NULL || array_parm_static)
+ if (array_ptr_quals != TYPE_UNQUALIFIED
+ || array_ptr_attrs != NULL_TREE
+ || array_parm_static)
{
/* Only the innermost declarator (making a parameter be of
array type which is converted to pointer type)
may have static or type qualifiers. */
error ("static or type qualifiers in non-parameter array declarator");
- array_ptr_quals = NULL;
+ array_ptr_quals = TYPE_UNQUALIFIED;
+ array_ptr_attrs = NULL_TREE;
array_parm_static = 0;
}
tree index_type = c_common_signed_type (sizetype);
array_ptr_quals = declarator->u.array.quals;
+ array_ptr_attrs = declarator->u.array.attrs;
array_parm_static = declarator->u.array.static_p;
declarator = declarator->declarator;
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;
}
layout_type (type);
if (decl_context != PARM
- && (array_ptr_quals != NULL || array_parm_static))
+ && (array_ptr_quals != TYPE_UNQUALIFIED
+ || array_ptr_attrs != NULL_TREE
+ || array_parm_static))
{
error ("static or type qualifiers in non-parameter array declarator");
- array_ptr_quals = NULL;
+ array_ptr_quals = TYPE_UNQUALIFIED;
+ array_ptr_attrs = NULL_TREE;
array_parm_static = 0;
}
break;
/* 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;
}
pedwarn ("ISO C forbids qualified function types");
if (type_quals)
type = c_build_qualified_type (type, type_quals);
- type_quals = TYPE_UNQUALIFIED;
size_varies = 0;
-
+
type = build_pointer_type (type);
/* Process type qualifiers (such as const or volatile)
that were given inside the `*'. */
- if (declarator->u.pointer_quals)
- {
- int pbits = declarator->u.pointer_quals->specbits;
-
- /* The grammar should only permit qualifiers here. */
- gcc_assert (!declarator->u.pointer_quals->type
- && !(pbits & ~((1 << (int) RID_CONST)
- | (1 << (int) RID_VOLATILE)
- | (1 << (int) RID_RESTRICT))));
-
- constp = !!(pbits & (1 << (int) RID_CONST));
- volatilep = !!(pbits & (1 << (int) RID_VOLATILE));
- restrictp = !!(pbits & (1 << (int) RID_RESTRICT));
-
- type_quals = ((constp ? TYPE_QUAL_CONST : 0)
- | (restrictp ? TYPE_QUAL_RESTRICT : 0)
- | (volatilep ? TYPE_QUAL_VOLATILE : 0));
- }
+ type_quals = declarator->u.pointer_quals;
declarator = declarator->declarator;
break;
&& 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;
if (storage_class == csc_typedef)
{
tree decl;
- /* Note that the grammar rejects storage classes
- in typenames, fields or parameters */
if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
&& type_quals)
pedwarn ("ISO C forbids qualified function types");
|| declspecs->typedef_signed_p)
C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
decl_attributes (&decl, returned_attrs, 0);
+ if (declspecs->inline_p)
+ pedwarn ("%Jtypedef %qD declared %<inline%>", decl, decl);
return decl;
}
if (decl_context == TYPENAME)
{
- /* Note that the grammar rejects storage classes
- in typenames, fields or parameters */
+ /* Note that the grammar rejects storage classes in typenames
+ and fields. */
+ gcc_assert (storage_class == csc_none && !threadp
+ && !declspecs->inline_p);
if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
&& type_quals)
pedwarn ("ISO C forbids const or volatile function types");
&& !(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 (type_quals)
type = c_build_qualified_type (type, type_quals);
type = build_pointer_type (type);
- type_quals = TYPE_UNQUALIFIED;
- if (array_ptr_quals)
- {
- int apqbits = array_ptr_quals->specbits;
-
- /* We don't yet implement attributes in this context. */
- if (array_ptr_quals->attrs != NULL_TREE)
- warning ("attributes in parameter array declarator ignored");
-
- /* The grammar should only permit qualifiers here. */
- gcc_assert (!array_ptr_quals->type
- && !(apqbits & ~((1 << (int) RID_CONST)
- | (1 << (int) RID_VOLATILE)
- | (1 << (int) RID_RESTRICT))));
+ type_quals = array_ptr_quals;
- constp = !!(apqbits & (1 << (int) RID_CONST));
- volatilep = !!(apqbits & (1 << (int) RID_VOLATILE));
- restrictp = !!(apqbits & (1 << (int) RID_RESTRICT));
+ /* We don't yet implement attributes in this context. */
+ if (array_ptr_attrs != NULL_TREE)
+ warning ("attributes in parameter array declarator ignored");
- type_quals = ((constp ? TYPE_QUAL_CONST : 0)
- | (restrictp ? TYPE_QUAL_RESTRICT : 0)
- | (volatilep ? TYPE_QUAL_VOLATILE : 0));
- }
size_varies = 0;
}
else if (TREE_CODE (type) == FUNCTION_TYPE)
DECL_ARG_TYPE (decl) = promoted_type;
DECL_ARG_TYPE_AS_WRITTEN (decl) = type_as_written;
+ if (declspecs->inline_p)
+ pedwarn ("%Jparameter %qD declared %<inline%>", decl, decl);
}
else if (decl_context == FIELD)
{
+ /* Note that the grammar rejects storage classes in typenames
+ and fields. */
+ gcc_assert (storage_class == csc_none && !threadp
+ && !declspecs->inline_p);
+
/* Structure field. It may not be a function. */
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
C_FUNCTION_IMPLICIT_INT (decl) = 1;
/* Record presence of `inline', if it is reasonable. */
- if (MAIN_NAME_P (declarator->u.id))
+ if (flag_hosted && MAIN_NAME_P (declarator->u.id))
{
if (declspecs->inline_p)
- warning ("cannot inline function `main'");
+ pedwarn ("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);
}
}
struct c_declarator *target)
{
tree attrs;
+ int quals = 0;
struct c_declarator *itarget = target;
struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
if (type_quals_attrs)
{
attrs = type_quals_attrs->attrs;
- type_quals_attrs->attrs = NULL_TREE;
+ quals = quals_from_declspecs (type_quals_attrs);
if (attrs != NULL_TREE)
itarget = build_attrs_declarator (attrs, target);
}
ret->kind = cdk_pointer;
ret->declarator = itarget;
- ret->u.pointer_quals = type_quals_attrs;
+ ret->u.pointer_quals = quals;
return ret;
}
ret->long_long_p = false;
ret->inline_p = false;
ret->thread_p = false;
+ ret->const_p = false;
+ ret->volatile_p = false;
+ ret->restrict_p = false;
return ret;
}
declspecs_add_qual (struct c_declspecs *specs, tree qual)
{
enum rid i;
+ bool dupe = false;
specs->non_sc_seen_p = true;
gcc_assert (TREE_CODE (qual) == IDENTIFIER_NODE
&& C_IS_RESERVED_WORD (qual));
i = C_RID_CODE (qual);
- gcc_assert (i == RID_CONST || i == RID_VOLATILE || i == RID_RESTRICT);
- if ((specs->specbits & (1 << (int) i)) && pedantic && !flag_isoc99)
+ switch (i)
+ {
+ case RID_CONST:
+ dupe = specs->const_p;
+ specs->const_p = true;
+ break;
+ case RID_VOLATILE:
+ dupe = specs->volatile_p;
+ specs->volatile_p = true;
+ break;
+ case RID_RESTRICT:
+ dupe = specs->restrict_p;
+ specs->restrict_p = true;
+ break;
+ default:
+ gcc_unreachable ();
+ }
+ if (dupe && pedantic && !flag_isoc99)
pedwarn ("duplicate %qs", IDENTIFIER_POINTER (qual));
- specs->specbits |= 1 << (int) i;
return specs;
}
switch (i)
{
case RID_INLINE:
- /* GCC has hitherto given an error for duplicate inline, but
- this should be revisited since C99 permits duplicate
- inline. */
- dupe = specs->inline_p;
+ /* C99 permits duplicate inline. Although of doubtful utility,
+ it seems simplest to permit it in gnu89 mode as well, as
+ there is also little utility in maintaining this as a
+ difference between gnu89 and C99 inline. */
+ dupe = false;
specs->inline_p = true;
break;
case RID_THREAD:
&& !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;
}
}