OpenE2K/gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

c-aux-info.c, [...]: Follow code formatting conventions.

Browse Source 
* c-aux-info.c, c-common.c, c-common.h, c-cppbuiltin.c, c-decl.c,
	c-format.c, c-incpath.c, c-lex.c, c-objc-common.c, c-opts.c,
	c-parse.in, c-pch.c, c-ppoutput.c, c-pragma.c, c-typeck.c: Follow
	code formatting conventions.

From-SVN: r88462
This commit is contained in:
Joseph Myers 2004-10-03 21:53:05 +01:00 committed by Joseph Myers
parent 57c1f13e47
commit 3f75a25471
16 changed files with 213 additions and 206 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
gcc/ChangeLog
View File

@ -1,3 +1,10 @@
2004-10-03 Joseph S. Myers <jsm@polyomino.org.uk>
* c-aux-info.c, c-common.c, c-common.h, c-cppbuiltin.c, c-decl.c,
c-format.c, c-incpath.c, c-lex.c, c-objc-common.c, c-opts.c,
c-parse.in, c-pch.c, c-ppoutput.c, c-pragma.c, c-typeck.c: Follow
code formatting conventions.
2004-10-03 Richard Sandiford <rsandifo@redhat.com>
* config/mips/mips.md (<u>mulsidi3_32bit_r4000): Fix unsigned case.

2
gcc/c-aux-info.c
View File

@ -559,7 +559,7 @@ gen_aux_info_record (tree fndecl, int is_definition, int is_implicit,
/* Each output .X file must have a header line. Write one now if we
have not yet done so. */
if (! compiled_from_record++)
if (!compiled_from_record++)
{
/* The first line tells which directory file names are relative to.
Currently, -aux-info works only for files in the working

84
gcc/c-common.c
View File

@ -735,7 +735,7 @@ fname_as_string (int pretty_p)
char *namep;
int vrb = 2;
if (! pretty_p)
if (!pretty_p)
{
name = "";
vrb = 0;
@ -1009,8 +1009,8 @@ convert_and_check (tree type, tree expr)
don't warn unless pedantic. */
if ((pedantic
|| TYPE_UNSIGNED (type)
|| ! constant_fits_type_p (expr,
c_common_unsigned_type (type)))
|| !constant_fits_type_p (expr,
c_common_unsigned_type (type)))
&& skip_evaluation == 0)
warning ("overflow in implicit constant conversion");
}
@ -1080,9 +1080,9 @@ add_tlist (struct tlist **to, struct tlist *add, tree exclude_writer, int copy)
while (add)
{
struct tlist *next = add->next;
if (! copy)
if (!copy)
add->next = *to;
if (! exclude_writer || add->writer != exclude_writer)
if (!exclude_writer || add->writer != exclude_writer)
*to = copy ? new_tlist (*to, add->expr, add->writer) : add;
add = next;
}
@ -1112,10 +1112,10 @@ merge_tlist (struct tlist **to, struct tlist *add, int copy)
if (tmp2->expr == add->expr)
{
found = 1;
if (! tmp2->writer)
if (!tmp2->writer)
tmp2->writer = add->writer;
}
if (! found)
if (!found)
{
*end = copy ? add : new_tlist (NULL, add->expr, add->writer);
end = &(*end)->next;
@ -1144,7 +1144,7 @@ warn_for_collisions_1 (tree written, tree writer, struct tlist *list,
{
if (list->expr == written
&& list->writer != writer
&& (! only_writes || list->writer)
&& (!only_writes || list->writer)
&& DECL_NAME (list->expr))
{
warned_ids = new_tlist (warned_ids, written, NULL_TREE);
@ -1333,7 +1333,7 @@ verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
if (t->expr == x)
break;
if (! t)
if (!t)
{
t = XOBNEW (&tlist_obstack, struct tlist_cache);
t->next = save_expr_cache;
@ -1711,7 +1711,7 @@ c_common_signed_type (tree type)
tree
c_common_signed_or_unsigned_type (int unsignedp, tree type)
{
if (! INTEGRAL_TYPE_P (type)
if (!INTEGRAL_TYPE_P (type)
|| TYPE_UNSIGNED (type) == unsignedp)
return type;
@ -1803,7 +1803,7 @@ min_precision (tree value, int unsignedp)
else
log = tree_floor_log2 (value);
return log + 1 + ! unsignedp;
return log + 1 + !unsignedp;
}
/* Print an error message for invalid operands to arith operation
@ -1921,7 +1921,7 @@ shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
the second arg is 0. */
if (TREE_CONSTANT (primop0)
&& ! integer_zerop (primop1) && ! real_zerop (primop1))
&& !integer_zerop (primop1) && !real_zerop (primop1))
{
tree tem = primop0;
int temi = unsignedp0;
@ -1993,7 +1993,7 @@ shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
enumerated type itself. In C++, TYPE_MAX_VALUE and
TYPE_MIN_VALUE have already been set correctly on the
enumeration type. */
if (!c_dialect_cxx() && TREE_CODE (type) == ENUMERAL_TYPE)
if (!c_dialect_cxx () && TREE_CODE (type) == ENUMERAL_TYPE)
type = c_common_type_for_size (TYPE_PRECISION (type), unsignedp0);
maxval = TYPE_MAX_VALUE (type);
@ -2181,18 +2181,18 @@ shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
>= 0, the signedness of the comparison isn't an issue,
so suppress the warning. */
if (extra_warnings && !in_system_header
&& ! (TREE_CODE (primop0) == INTEGER_CST
&& ! TREE_OVERFLOW (convert (c_common_signed_type (type),
primop0))))
&& !(TREE_CODE (primop0) == INTEGER_CST
&& !TREE_OVERFLOW (convert (c_common_signed_type (type),
primop0))))
warning ("comparison of unsigned expression >= 0 is always true");
value = truthvalue_true_node;
break;
case LT_EXPR:
if (extra_warnings && !in_system_header
&& ! (TREE_CODE (primop0) == INTEGER_CST
&& ! TREE_OVERFLOW (convert (c_common_signed_type (type),
primop0))))
&& !(TREE_CODE (primop0) == INTEGER_CST
&& !TREE_OVERFLOW (convert (c_common_signed_type (type),
primop0))))
warning ("comparison of unsigned expression < 0 is always false");
value = truthvalue_false_node;
break;
@ -2259,7 +2259,7 @@ pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
This helps produce common subexpressions. */
if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
&& ! TREE_CONSTANT (intop)
&& !TREE_CONSTANT (intop)
&& TREE_CONSTANT (TREE_OPERAND (intop, 1))
&& TREE_CONSTANT (size_exp)
/* If the constant comes from pointer subtraction,
@ -2268,7 +2268,7 @@ pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
/* If the constant is unsigned, and smaller than the pointer size,
then we must skip this optimization. This is because it could cause
an overflow error if the constant is negative but INTOP is not. */
&& (! TYPE_UNSIGNED (TREE_TYPE (intop))
&& (!TYPE_UNSIGNED (TREE_TYPE (intop))
|| (TYPE_PRECISION (TREE_TYPE (intop))
== TYPE_PRECISION (TREE_TYPE (ptrop)))))
{
@ -2351,7 +2351,7 @@ c_common_truthvalue_conversion (tree expr)
case ADDR_EXPR:
{
if (TREE_CODE (TREE_OPERAND (expr, 0)) == FUNCTION_DECL
&& ! DECL_WEAK (TREE_OPERAND (expr, 0)))
&& !DECL_WEAK (TREE_OPERAND (expr, 0)))
{
/* Common Ada/Pascal programmer's mistake. We always warn
about this since it is so bad. */
@ -2559,7 +2559,7 @@ c_type_hash (const void *p)
{
int i = 0;
int shift, size;
tree t = (tree)p;
tree t = (tree) p;
tree t2;
switch (TREE_CODE (t))
{
@ -2616,7 +2616,7 @@ c_common_get_alias_set (tree t)
return 0;
/* That's all the expressions we handle specially. */
if (! TYPE_P (t))
if (!TYPE_P (t))
return -1;
/* The C standard guarantees that any object may be accessed via an
@ -3550,8 +3550,8 @@ c_add_case_label (splay_tree cases, tree cond, tree orig_type,
expression. If both low_value and high_value are out of range,
don't insert the case label and return NULL_TREE. */
if (low_value
&& ! check_case_bounds (type, orig_type,
&low_value, high_value ? &high_value : NULL))
&& !check_case_bounds (type, orig_type,
&low_value, high_value ? &high_value : NULL))
return NULL_TREE;
/* Look up the LOW_VALUE in the table of case labels we already
@ -4294,11 +4294,11 @@ handle_mode_attribute (tree *node, tree name, tree args,
/* Change this type to have a type with the specified mode.
First check for the special modes. */
if (! strcmp (p, "byte"))
if (!strcmp (p, "byte"))
mode = byte_mode;
else if (!strcmp (p, "word"))
mode = word_mode;
else if (! strcmp (p, "pointer"))
else if (!strcmp (p, "pointer"))
mode = ptr_mode;
else
for (j = 0; j < NUM_MACHINE_MODES; j++)
@ -4410,7 +4410,7 @@ handle_section_attribute (tree *node, tree ARG_UNUSED (name), tree args,
{
if (TREE_CODE (decl) == VAR_DECL
&& current_function_decl != NULL_TREE
&& ! TREE_STATIC (decl))
&& !TREE_STATIC (decl))
{
error ("%Jsection attribute cannot be specified for "
"local variables", decl);
@ -4548,7 +4548,7 @@ handle_alias_attribute (tree *node, tree name, tree args,
tree decl = *node;
if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
|| (TREE_CODE (decl) != FUNCTION_DECL && ! DECL_EXTERNAL (decl)))
|| (TREE_CODE (decl) != FUNCTION_DECL && !DECL_EXTERNAL (decl)))
{
error ("%J%qD defined both normally and as an alias", decl, decl);
*no_add_attrs = true;
@ -4613,7 +4613,7 @@ handle_visibility_attribute (tree *node, tree name, tree args,
return NULL_TREE;
}
}
else if (decl_function_context (decl) != 0 || ! TREE_PUBLIC (decl))
else if (decl_function_context (decl) != 0 || !TREE_PUBLIC (decl))
{
warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
return NULL_TREE;
@ -4629,7 +4629,7 @@ handle_visibility_attribute (tree *node, tree name, tree args,
if (TYPE_P (decl))
{
decl = TYPE_NAME (decl);
if (! decl)
if (!decl)
return NULL_TREE;
}
@ -4699,7 +4699,7 @@ handle_tls_model_attribute (tree *node, tree name, tree args,
{
tree decl = *node;
if (! DECL_THREAD_LOCAL (decl))
if (!DECL_THREAD_LOCAL (decl))
{
warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
*no_add_attrs = true;
@ -4899,7 +4899,7 @@ handle_vector_size_attribute (tree *node, tree name, tree args,
if (TREE_CODE (size) == NON_LVALUE_EXPR)
size = TREE_OPERAND (size, 0);
if (! host_integerp (size, 1))
if (!host_integerp (size, 1))
{
warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
return NULL_TREE;
@ -4928,7 +4928,7 @@ handle_vector_size_attribute (tree *node, tree name, tree args,
if (TREE_CODE (type) == RECORD_TYPE
|| (GET_MODE_CLASS (orig_mode) != MODE_FLOAT
&& GET_MODE_CLASS (orig_mode) != MODE_INT)
|| ! host_integerp (TYPE_SIZE_UNIT (type), 1))
|| !host_integerp (TYPE_SIZE_UNIT (type), 1))
{
error ("invalid vector type for attribute %qs",
IDENTIFIER_POINTER (name));
@ -4963,9 +4963,9 @@ handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
/* If no arguments are specified, all pointer arguments should be
non-null. Verify a full prototype is given so that the arguments
will have the correct types when we actually check them later. */
if (! args)
if (!args)
{
if (! TYPE_ARG_TYPES (type))
if (!TYPE_ARG_TYPES (type))
{
error ("nonnull attribute without arguments on a non-prototype");
*no_add_attrs = true;
@ -4980,7 +4980,7 @@ handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
tree argument;
unsigned HOST_WIDE_INT arg_num = 0, ck_num;
if (! get_nonnull_operand (TREE_VALUE (args), &arg_num))
if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
{
error ("nonnull argument has invalid operand number (arg %lu)",
(unsigned long) attr_arg_num);
@ -4993,12 +4993,12 @@ handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
{
for (ck_num = 1; ; ck_num++)
{
if (! argument || ck_num == arg_num)
if (!argument || ck_num == arg_num)
break;
argument = TREE_CHAIN (argument);
}
if (! argument
if (!argument
|| TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
{
error ("nonnull argument with out-of-range operand number (arg %lu, operand %lu)",
@ -5042,9 +5042,9 @@ check_function_nonnull (tree attrs, tree params)
for (param = params, param_num = 1; ;
param_num++, param = TREE_CHAIN (param))
{
if (! param)
if (!param)
break;
if (! args || nonnull_check_p (args, param_num))
if (!args || nonnull_check_p (args, param_num))
check_function_arguments_recurse (check_nonnull_arg, NULL,
TREE_VALUE (param),
param_num);

10
gcc/c-common.h
View File

@ -113,16 +113,16 @@ enum rid
};
#define OBJC_IS_AT_KEYWORD(rid) \
((unsigned int)(rid) >= (unsigned int)RID_FIRST_AT && \
(unsigned int)(rid) <= (unsigned int)RID_LAST_AT)
((unsigned int) (rid) >= (unsigned int) RID_FIRST_AT && \
(unsigned int) (rid) <= (unsigned int) RID_LAST_AT)
#define OBJC_IS_PQ_KEYWORD(rid) \
((unsigned int)(rid) >= (unsigned int)RID_FIRST_PQ && \
(unsigned int)(rid) <= (unsigned int)RID_LAST_PQ)
((unsigned int) (rid) >= (unsigned int) RID_FIRST_PQ && \
(unsigned int) (rid) <= (unsigned int) RID_LAST_PQ)
/* The elements of `ridpointers' are identifier nodes for the reserved
type names and storage classes. It is indexed by a RID_... value. */
extern GTY ((length ("(int)RID_MAX"))) tree *ridpointers;
extern GTY ((length ("(int) RID_MAX"))) tree *ridpointers;
/* Standard named or nameless data types of the C compiler. */

2
gcc/c-cppbuiltin.c
View File

@ -259,7 +259,7 @@ define__GNUC__ (void)
([^0-9]*-)?[0-9]+[.][0-9]+([.][0-9]+)?([- ].*)? */
const char *q, *v = version_string;
while (*v && ! ISDIGIT (*v))
while (*v && !ISDIGIT (*v))
v++;
gcc_assert (*v && (v <= version_string || v[-1] == '-'));

76
gcc/c-decl.c
View File

@ -205,17 +205,17 @@ struct c_binding GTY((chain_next ("%h.prev")))
#define B_IN_EXTERNAL_SCOPE(b) ((b)->depth == 0 /*external_scope->depth*/)
#define I_SYMBOL_BINDING(node) \
(((struct lang_identifier *)IDENTIFIER_NODE_CHECK(node))->symbol_binding)
(((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->symbol_binding)
#define I_SYMBOL_DECL(node) \
(I_SYMBOL_BINDING(node) ? I_SYMBOL_BINDING(node)->decl : 0)
#define I_TAG_BINDING(node) \
(((struct lang_identifier *)IDENTIFIER_NODE_CHECK(node))->tag_binding)
(((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->tag_binding)
#define I_TAG_DECL(node) \
(I_TAG_BINDING(node) ? I_TAG_BINDING(node)->decl : 0)
#define I_LABEL_BINDING(node) \
(((struct lang_identifier *)IDENTIFIER_NODE_CHECK(node))->label_binding)
(((struct lang_identifier *) IDENTIFIER_NODE_CHECK(node))->label_binding)
#define I_LABEL_DECL(node) \
(I_LABEL_BINDING(node) ? I_LABEL_BINDING(node)->decl : 0)
@ -239,7 +239,7 @@ extern char C_SIZEOF_STRUCT_LANG_IDENTIFIER_isnt_accurate
union lang_tree_node
GTY((desc ("TREE_CODE (&%h.generic) == IDENTIFIER_NODE"),
chain_next ("TREE_CODE (&%h.generic) == INTEGER_TYPE ? (union lang_tree_node *)TYPE_NEXT_VARIANT (&%h.generic) : (union lang_tree_node *)TREE_CHAIN (&%h.generic)")))
chain_next ("TREE_CODE (&%h.generic) == INTEGER_TYPE ? (union lang_tree_node *) TYPE_NEXT_VARIANT (&%h.generic) : (union lang_tree_node *) TREE_CHAIN (&%h.generic)")))
{
union tree_node GTY ((tag ("0"),
desc ("tree_node_structure (&%h)")))
@ -518,7 +518,7 @@ c_finish_incomplete_decl (tree decl)
tree type = TREE_TYPE (decl);
if (type != error_mark_node
&& TREE_CODE (type) == ARRAY_TYPE
&& ! DECL_EXTERNAL (decl)
&& !DECL_EXTERNAL (decl)
&& TYPE_DOMAIN (type) == 0)
{
warning ("%Jarray %qD assumed to have one element", decl, decl);
@ -752,7 +752,7 @@ pop_scope (void)
case FUNCTION_DECL:
/* Propagate TREE_ADDRESSABLE from nested functions to their
containing functions. */
if (! TREE_ASM_WRITTEN (p)
if (!TREE_ASM_WRITTEN (p)
&& DECL_INITIAL (p) != 0
&& TREE_ADDRESSABLE (p)
&& DECL_ABSTRACT_ORIGIN (p) != 0
@ -965,10 +965,10 @@ match_builtin_function_types (tree newtype, tree oldtype)
while (oldargs || newargs)
{
if (! oldargs
|| ! newargs
|| ! TREE_VALUE (oldargs)
|| ! TREE_VALUE (newargs)
if (!oldargs
|| !newargs
|| !TREE_VALUE (oldargs)
|| !TREE_VALUE (newargs)
|| TYPE_MODE (TREE_VALUE (oldargs))
!= TYPE_MODE (TREE_VALUE (newargs)))
return 0;
@ -1063,7 +1063,7 @@ validate_proto_after_old_defn (tree newdecl, tree newtype, tree oldtype)
/* Type for passing arg must be consistent with that declared
for the arg. */
else if (! comptypes (oldargtype, newargtype))
else if (!comptypes (oldargtype, newargtype))
{
error ("%Jprototype for %qD declares arg %d with incompatible type",
newdecl, newdecl, i);
@ -1522,7 +1522,7 @@ merge_decls (tree newdecl, tree olddecl, tree newtype, tree oldtype)
in its new location and clear TREE_ASM_WRITTEN (it's not a
forward decl anymore). */
if (TREE_CODE (newdecl) == PARM_DECL
&& TREE_ASM_WRITTEN (olddecl) && ! TREE_ASM_WRITTEN (newdecl))
&& TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl))
{
struct c_binding *b, **here;
@ -1646,7 +1646,7 @@ merge_decls (tree newdecl, tree olddecl, tree newtype, tree oldtype)
copy the attributes of NEWDECL into OLDDECL. */
TREE_PUBLIC (olddecl) = TREE_PUBLIC (newdecl);
/* If this clears `static', clear it in the identifier too. */
if (! TREE_PUBLIC (olddecl))
if (!TREE_PUBLIC (olddecl))
TREE_PUBLIC (DECL_NAME (olddecl)) = 0;
}
if (DECL_EXTERNAL (newdecl))
@ -1656,7 +1656,7 @@ merge_decls (tree newdecl, tree olddecl, tree newtype, tree oldtype)
/* An extern decl does not override previous storage class. */
TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
if (! DECL_EXTERNAL (newdecl))
if (!DECL_EXTERNAL (newdecl))
{
DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
@ -1709,7 +1709,7 @@ merge_decls (tree newdecl, tree olddecl, tree newtype, tree oldtype)
}
/* Also preserve various other info from the definition. */
if (! new_is_definition)
if (!new_is_definition)
{
DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
@ -1719,7 +1719,7 @@ merge_decls (tree newdecl, tree olddecl, tree newtype, tree oldtype)
/* Set DECL_INLINE on the declaration if we've got a body
from which to instantiate. */
if (DECL_INLINE (olddecl) && ! DECL_UNINLINABLE (newdecl))
if (DECL_INLINE (olddecl) && !DECL_UNINLINABLE (newdecl))
{
DECL_INLINE (newdecl) = 1;
DECL_ABSTRACT_ORIGIN (newdecl)
@ -1731,7 +1731,7 @@ merge_decls (tree newdecl, tree olddecl, tree newtype, tree oldtype)
/* If a previous declaration said inline, mark the
definition as inlinable. */
if (DECL_DECLARED_INLINE_P (newdecl)
&& ! DECL_UNINLINABLE (newdecl))
&& !DECL_UNINLINABLE (newdecl))
DECL_INLINE (newdecl) = 1;
}
}
@ -1820,7 +1820,7 @@ warn_if_shadowing (tree new_decl)
new_decl, new_decl);
if (TREE_CODE (old_decl) != FUNCTION_DECL
|| ! DECL_BUILT_IN (old_decl))
|| !DECL_BUILT_IN (old_decl))
warning ("%Jshadowed declaration is here", old_decl);
break;
@ -1909,7 +1909,7 @@ pushdecl (tree x)
bool nested = false;
/* Functions need the lang_decl data. */
if (TREE_CODE (x) == FUNCTION_DECL && ! DECL_LANG_SPECIFIC (x))
if (TREE_CODE (x) == FUNCTION_DECL && !DECL_LANG_SPECIFIC (x))
DECL_LANG_SPECIFIC (x) = GGC_CNEW (struct lang_decl);
/* Must set DECL_CONTEXT for everything not at file scope or
@ -2286,7 +2286,7 @@ undeclared_variable (tree id)
{
error ("%qE undeclared (first use in this function)", id);
if (! already)
if (!already)
{
error ("(Each undeclared identifier is reported only once");
error ("for each function it appears in.)");
@ -3143,7 +3143,7 @@ finish_decl (tree decl, tree init, tree asmspec_tree)
If it is not `static', then do not mark extern;
finish_incomplete_decl will give it a default size
and it will get allocated. */
else if (!pedantic && TREE_STATIC (decl) && ! TREE_PUBLIC (decl))
else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
DECL_EXTERNAL (decl) = 1;
}
@ -3239,7 +3239,7 @@ finish_decl (tree decl, tree init, tree asmspec_tree)
ordinary, non-register local variable. Historically,
GCC has accepted -- but ignored -- the ASMSPEC in
this case. */
if (! DECL_FILE_SCOPE_P (decl)
if (!DECL_FILE_SCOPE_P (decl)
&& TREE_CODE (decl) == VAR_DECL
&& !C_DECL_REGISTER (decl)
&& !TREE_STATIC (decl))
@ -3303,7 +3303,7 @@ finish_decl (tree decl, tree init, tree asmspec_tree)
/* Recompute the RTL of a local array now
if it used to be an incomplete type. */
if (was_incomplete
&& ! TREE_STATIC (decl) && ! DECL_EXTERNAL (decl))
&& !TREE_STATIC (decl) && !DECL_EXTERNAL (decl))
{
/* If we used it already as memory, it must stay in memory. */
TREE_ADDRESSABLE (decl) = TREE_USED (decl);
@ -3817,7 +3817,7 @@ grokdeclarator (const struct c_declarator *declarator,
if (volatilep > 1)
pedwarn ("duplicate %<volatile%>");
}
if (! flag_gen_aux_info && (TYPE_QUALS (type)))
if (!flag_gen_aux_info && (TYPE_QUALS (type)))
type = TYPE_MAIN_VARIANT (type);
type_quals = ((constp ? TYPE_QUAL_CONST : 0)
| (restrictp ? TYPE_QUAL_RESTRICT : 0)
@ -4009,7 +4009,7 @@ grokdeclarator (const struct c_declarator *declarator,
lvalue. */
STRIP_TYPE_NOPS (size);
if (! INTEGRAL_TYPE_P (TREE_TYPE (size)))
if (!INTEGRAL_TYPE_P (TREE_TYPE (size)))
{
error ("size of array %qs has non-integer type", name);
size = integer_one_node;
@ -4308,7 +4308,7 @@ grokdeclarator (const struct c_declarator *declarator,
a better error message can be made later. */
if (VOID_TYPE_P (type) && decl_context != PARM
&& ! ((decl_context != FIELD && TREE_CODE (type) != FUNCTION_TYPE)
&& !((decl_context != FIELD && TREE_CODE (type) != FUNCTION_TYPE)
&& (storage_class == csc_extern
|| (current_scope == file_scope
&& !(storage_class == csc_static
@ -4436,7 +4436,7 @@ grokdeclarator (const struct c_declarator *declarator,
DECL_LANG_SPECIFIC (decl) = GGC_CNEW (struct lang_decl);
if (pedantic && type_quals && ! DECL_IN_SYSTEM_HEADER (decl))
if (pedantic && type_quals && !DECL_IN_SYSTEM_HEADER (decl))
pedwarn ("ISO C forbids qualified function types");
/* GNU C interprets a volatile-qualified function type to indicate
@ -4637,7 +4637,7 @@ grokparms (struct c_arg_info *arg_info, bool funcdef_flag)
else if (arg_types && TREE_CODE (TREE_VALUE (arg_types)) == IDENTIFIER_NODE)
{
if (! funcdef_flag)
if (!funcdef_flag)
pedwarn ("parameter names (without types) in function declaration");
arg_info->parms = arg_info->types;
@ -4824,7 +4824,7 @@ get_parm_info (bool ellipsis)
warning ("anonymous %s declared inside parameter list",
keyword);
if (! explained_incomplete_types)
if (!explained_incomplete_types)
{
warning ("its scope is only this definition or declaration,"
" which is probably not what you want");
@ -5183,7 +5183,7 @@ finish_struct (tree t, tree fieldlist, tree attributes)
error ("%Jflexible array member not at end of struct", x);
TREE_TYPE (x) = error_mark_node;
}
else if (! saw_named_field)
else if (!saw_named_field)
{
error ("%Jflexible array member in otherwise empty struct", x);
TREE_TYPE (x) = error_mark_node;
@ -5315,7 +5315,7 @@ finish_struct (tree t, tree fieldlist, tree attributes)
if (c_dialect_objc ())
objc_check_decl (decl);
rest_of_decl_compilation (decl, toplevel, 0);
if (! toplevel)
if (!toplevel)
expand_decl (decl);
}
}
@ -5568,7 +5568,7 @@ build_enumerator (tree name, tree value)
error ("overflow in enumeration values");
}
if (pedantic && ! int_fits_type_p (value, integer_type_node))
if (pedantic && !int_fits_type_p (value, integer_type_node))
{
pedwarn ("ISO C restricts enumerator values to range of %<int%>");
/* XXX This causes -pedantic to change the meaning of the program.
@ -5683,7 +5683,7 @@ start_function (struct c_declspecs *declspecs, struct c_declarator *declarator,
/* Optionally warn of any global def with no previous prototype. */
else if (warn_missing_prototypes
&& TREE_PUBLIC (decl1)
&& ! MAIN_NAME_P (DECL_NAME (decl1))
&& !MAIN_NAME_P (DECL_NAME (decl1))
&& C_DECL_ISNT_PROTOTYPE (old_decl))
warning ("%Jno previous prototype for %qD", decl1, decl1);
/* Optionally warn of any def with no previous prototype
@ -5697,7 +5697,7 @@ start_function (struct c_declspecs *declspecs, struct c_declarator *declarator,
else if (warn_missing_declarations
&& TREE_PUBLIC (decl1)
&& old_decl == 0
&& ! MAIN_NAME_P (DECL_NAME (decl1)))
&& !MAIN_NAME_P (DECL_NAME (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. */
@ -5782,7 +5782,7 @@ start_function (struct c_declspecs *declspecs, struct c_declarator *declarator,
if (argct > 0 && (argct < 2 || argct > 3))
pedwarn ("%J%qD takes only zero or two arguments", decl1, decl1);
if (! TREE_PUBLIC (decl1))
if (!TREE_PUBLIC (decl1))
pedwarn ("%J%qD is normally a non-static function", decl1, decl1);
}
@ -5965,7 +5965,7 @@ store_parm_decls_oldstyle (tree fndecl, const struct c_arg_info *arg_info)
TREE_TYPE (parm) = error_mark_node;
}
if (! DECL_WEAK (parm))
if (!DECL_WEAK (parm))
{
error ("%Jdeclaration for parameter %qD but no such parameter",
parm, parm);
@ -6025,8 +6025,8 @@ store_parm_decls_oldstyle (tree fndecl, const struct c_arg_info *arg_info)
/* Type for passing arg must be consistent with that
declared for the arg. ISO C says we take the unqualified
type for parameters declared with qualified type. */
if (! comptypes (TYPE_MAIN_VARIANT (DECL_ARG_TYPE (parm)),
TYPE_MAIN_VARIANT (TREE_VALUE (type))))
if (!comptypes (TYPE_MAIN_VARIANT (DECL_ARG_TYPE (parm)),
TYPE_MAIN_VARIANT (TREE_VALUE (type))))
{
if (TYPE_MAIN_VARIANT (TREE_TYPE (parm))
== TYPE_MAIN_VARIANT (TREE_VALUE (type)))

44
gcc/c-format.c
View File

@ -232,10 +232,10 @@ decode_format_attr (tree args, function_format_info *info, int validated_p)
or inheriting from, for the purpose of format features supported. */
#define CPLUSPLUS_STD_VER STD_C94
/* The C standard version we are checking formats against when pedantic. */
#define C_STD_VER ((int)(c_dialect_cxx () \
? CPLUSPLUS_STD_VER \
: (flag_isoc99 \
? STD_C99 \
#define C_STD_VER ((int) (c_dialect_cxx () \
? CPLUSPLUS_STD_VER \
: (flag_isoc99 \
? STD_C99 \
: (flag_isoc94 ? STD_C94 : STD_C89))))
/* The name to give to the standard version we are warning about when
pedantic. FEATURE_VER is the version in which the feature warned out
@ -247,7 +247,7 @@ decode_format_attr (tree args, function_format_info *info, int validated_p)
: "ISO C90"))
/* Adjust a C standard version, which may be STD_C9L, to account for
-Wno-long-long. Returns other standard versions unchanged. */
#define ADJ_STD(VER) ((int)((VER) == STD_C9L \
#define ADJ_STD(VER) ((int) ((VER) == STD_C9L \
? (warn_long_long ? STD_C99 : STD_C89) \
: (VER)))
@ -924,7 +924,7 @@ maybe_read_dollar_number (const char **format,
int argnum;
int overflow_flag;
const char *fcp = *format;
if (! ISDIGIT (*fcp))
if (!ISDIGIT (*fcp))
{
if (dollar_needed)
{
@ -1744,7 +1744,7 @@ check_format_info_main (format_check_results *res,
++fci;
if (fci->format_chars == 0)
{
if (ISGRAPH(format_char))
if (ISGRAPH (format_char))
warning ("unknown conversion type character %qc in format",
format_char);
else
@ -2150,7 +2150,7 @@ check_format_types (format_wanted_type *types, const char *format_start,
a second level of indirection. */
if (TREE_CODE (wanted_type) == INTEGER_TYPE
&& TREE_CODE (cur_type) == INTEGER_TYPE
&& (! pedantic || i == 0 || (i == 1 && char_type_flag))
&& (!pedantic || i == 0 || (i == 1 && char_type_flag))
&& (TYPE_UNSIGNED (wanted_type)
? wanted_type == c_common_unsigned_type (cur_type)
: wanted_type == c_common_signed_type (cur_type)))
@ -2158,7 +2158,7 @@ check_format_types (format_wanted_type *types, const char *format_start,
/* Likewise, "signed char", "unsigned char" and "char" are
equivalent but the above test won't consider them equivalent. */
if (wanted_type == char_type_node
&& (! pedantic || i < 2)
&& (!pedantic || i < 2)
&& char_type_flag)
continue;
/* Now we have a type mismatch. */
@ -2350,7 +2350,7 @@ init_dynamic_diag_info (void)
/* Assign the new data for use. */
/* All the GCC diag formats use the same length specs. */
if (! diag_ls)
if (!diag_ls)
dynamic_format_types[gcc_diag_format_type].length_char_specs =
dynamic_format_types[gcc_cdiag_format_type].length_char_specs =
dynamic_format_types[gcc_cxxdiag_format_type].length_char_specs =
@ -2371,12 +2371,12 @@ init_dynamic_diag_info (void)
}
/* Handle the __gcc_diag__ format specifics. */
if (! diag_fci)
if (!diag_fci)
dynamic_format_types[gcc_diag_format_type].conversion_specs =
diag_fci = (format_char_info *)
xmemdup (gcc_diag_char_table,
sizeof(gcc_diag_char_table),
sizeof(gcc_diag_char_table));
sizeof (gcc_diag_char_table),
sizeof (gcc_diag_char_table));
if (loc)
{
i = find_char_info_specifier_index (diag_fci, 'H');
@ -2391,12 +2391,12 @@ init_dynamic_diag_info (void)
}
/* Handle the __gcc_cdiag__ format specifics. */
if (! cdiag_fci)
if (!cdiag_fci)
dynamic_format_types[gcc_cdiag_format_type].conversion_specs =
cdiag_fci = (format_char_info *)
xmemdup (gcc_cdiag_char_table,
sizeof(gcc_cdiag_char_table),
sizeof(gcc_cdiag_char_table));
sizeof (gcc_cdiag_char_table),
sizeof (gcc_cdiag_char_table));
if (loc)
{
i = find_char_info_specifier_index (cdiag_fci, 'H');
@ -2415,12 +2415,12 @@ init_dynamic_diag_info (void)
}
/* Handle the __gcc_cxxdiag__ format specifics. */
if (! cxxdiag_fci)
if (!cxxdiag_fci)
dynamic_format_types[gcc_cxxdiag_format_type].conversion_specs =
cxxdiag_fci = (format_char_info *)
xmemdup (gcc_cxxdiag_char_table,
sizeof(gcc_cxxdiag_char_table),
sizeof(gcc_cxxdiag_char_table));
sizeof (gcc_cxxdiag_char_table),
sizeof (gcc_cxxdiag_char_table));
if (loc)
{
i = find_char_info_specifier_index (cxxdiag_fci, 'H');
@ -2527,15 +2527,15 @@ handle_format_attribute (tree *node, tree ARG_UNUSED (name), tree args,
/* If this is format __asm_fprintf__, we have to initialize
GCC's notion of HOST_WIDE_INT for checking %wd. */
if (info.format_type == asm_fprintf_format_type)
init_dynamic_asm_fprintf_info();
init_dynamic_asm_fprintf_info ();
/* If this is one of the diagnostic attributes, then we have to
initialize 'location_t' and 'tree' at runtime. */
else if (info.format_type == gcc_diag_format_type
|| info.format_type == gcc_cdiag_format_type
|| info.format_type == gcc_cxxdiag_format_type)
init_dynamic_diag_info();
init_dynamic_diag_info ();
else
gcc_unreachable();
gcc_unreachable ();
}
return NULL_TREE;

2
gcc/c-incpath.c
View File

@ -37,7 +37,7 @@ Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
# define INO_T_EQ(A, B) (!memcmp (&(A), &(B), sizeof (A)))
# define INO_T_COPY(DEST, SRC) memcpy(&(DEST), &(SRC), sizeof (SRC))
#else
# if (defined _WIN32 && ! defined (_UWIN)) || defined __MSDOS__
# if (defined _WIN32 && !defined (_UWIN)) || defined __MSDOS__
# define INO_T_EQ(A, B) 0
# else
# define INO_T_EQ(A, B) ((A) == (B))

38
gcc/c-lex.c
View File

@ -121,9 +121,9 @@ get_fileinfo (const char *name)
struct c_fileinfo *fi;
if (!file_info_tree)
file_info_tree = splay_tree_new ((splay_tree_compare_fn)strcmp,
file_info_tree = splay_tree_new ((splay_tree_compare_fn) strcmp,
0,
(splay_tree_delete_value_fn)free);
(splay_tree_delete_value_fn) free);
n = splay_tree_lookup (file_info_tree, (splay_tree_key) name);
if (n)
@ -172,7 +172,7 @@ dump_time_statistics (void)
print_time ("header files (total)", header_time);
print_time ("main file (total)", this_time - body_time);
fprintf (stderr, "ratio = %g : 1\n",
(double)header_time / (double)(this_time - body_time));
(double) header_time / (double) (this_time - body_time));
fprintf (stderr, "\n******\n");
splay_tree_foreach (file_info_tree, dump_one_header, 0);
@ -184,14 +184,14 @@ cb_ident (cpp_reader * ARG_UNUSED (pfile),
const cpp_string * ARG_UNUSED (str))
{
#ifdef ASM_OUTPUT_IDENT
if (! flag_no_ident)
if (!flag_no_ident)
{
/* Convert escapes in the string. */
cpp_string cstr = { 0, 0 };
if (cpp_interpret_string (pfile, str, 1, &cstr, false))
{
ASM_OUTPUT_IDENT (asm_out_file, (const char *) cstr.text);
free ((void *)cstr.text);
free ((void *) cstr.text);
}
}
#endif
@ -225,7 +225,7 @@ fe_file_change (const struct line_map *new_map)
{
/* Don't stack the main buffer on the input stack;
we already did in compile_file. */
if (! MAIN_FILE_P (new_map))
if (!MAIN_FILE_P (new_map))
{
#ifdef USE_MAPPED_LOCATION
int included_at = LAST_SOURCE_LINE_LOCATION (new_map - 1);
@ -437,7 +437,7 @@ c_lex_with_flags (tree *value, unsigned char *cpp_flags)
/* else fall through */
case CPP_PRAGMA:
*value = build_string (tok->val.str.len, (char *)tok->val.str.text);
*value = build_string (tok->val.str.len, (char *) tok->val.str.text);
break;
/* These tokens should not be visible outside cpplib. */
@ -451,7 +451,7 @@ c_lex_with_flags (tree *value, unsigned char *cpp_flags)
break;
}
if (! no_more_pch)
if (!no_more_pch)
{
no_more_pch = true;
c_common_no_more_pch ();
@ -490,8 +490,8 @@ narrowest_unsigned_type (unsigned HOST_WIDE_INT low,
{
tree upper = TYPE_MAX_VALUE (integer_types[itk]);
if ((unsigned HOST_WIDE_INT)TREE_INT_CST_HIGH (upper) > high
|| ((unsigned HOST_WIDE_INT)TREE_INT_CST_HIGH (upper) == high
if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) > high
|| ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) == high
&& TREE_INT_CST_LOW (upper) >= low))
return itk;
}
@ -518,8 +518,8 @@ narrowest_signed_type (unsigned HOST_WIDE_INT low,
{
tree upper = TYPE_MAX_VALUE (integer_types[itk]);
if ((unsigned HOST_WIDE_INT)TREE_INT_CST_HIGH (upper) > high
|| ((unsigned HOST_WIDE_INT)TREE_INT_CST_HIGH (upper) == high
if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) > high
|| ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) == high
&& TREE_INT_CST_LOW (upper) >= low))
return itk;
}
@ -592,7 +592,7 @@ interpret_integer (const cpp_token *token, unsigned int flags)
if (itk > itk_unsigned_long
&& (flags & CPP_N_WIDTH) != CPP_N_LARGE
&& ! in_system_header && ! flag_isoc99)
&& !in_system_header && !flag_isoc99)
pedwarn ("integer constant is too large for %qs type",
(flags & CPP_N_UNSIGNED) ? "unsigned long" : "long");
@ -741,8 +741,8 @@ lex_string (const cpp_token *tok, tree *valp, bool objc_string)
? cpp_interpret_string : cpp_interpret_string_notranslate)
(parse_in, strs, count, &istr, wide))
{
value = build_string (istr.len, (char *)istr.text);
free ((void *)istr.text);
value = build_string (istr.len, (char *) istr.text);
free ((void *) istr.text);
if (c_lex_string_translate == -1)
{
@ -752,17 +752,17 @@ lex_string (const cpp_token *tok, tree *valp, bool objc_string)
then the untranslated parsing will always succeed. */
gcc_assert (xlated);
if (TREE_STRING_LENGTH (value) != (int)istr.len
|| 0 != strncmp (TREE_STRING_POINTER (value), (char *)istr.text,
if (TREE_STRING_LENGTH (value) != (int) istr.len
|| 0 != strncmp (TREE_STRING_POINTER (value), (char *) istr.text,
istr.len))
{
/* Arrange for us to return the untranslated string in
*valp, but to set up the C type of the translated
one. */
*valp = build_string (istr.len, (char *)istr.text);
*valp = build_string (istr.len, (char *) istr.text);
valp = &TREE_CHAIN (*valp);
}
free ((void *)istr.text);
free ((void *) istr.text);
}
}
else

4
gcc/c-objc-common.c
View File

@ -93,7 +93,7 @@ c_cannot_inline_tree_fn (tree *fnp)
goto cannot_inline;
}
if (! function_attribute_inlinable_p (fn))
if (!function_attribute_inlinable_p (fn))
{
if (do_warning)
warning ("%Jfunction %qF can never be inlined because it uses "
@ -117,7 +117,7 @@ c_cannot_inline_tree_fn (tree *fnp)
}
}
if (! DECL_FILE_SCOPE_P (fn))
if (!DECL_FILE_SCOPE_P (fn))
{
/* If a nested function has pending sizes, we may have already
saved them. */

8
gcc/c-opts.c
View File

@ -1036,7 +1036,7 @@ c_common_post_options (const char **pfilename)
}
if (flag_working_directory
&& flag_preprocess_only && ! flag_no_line_commands)
&& flag_preprocess_only && !flag_no_line_commands)
pp_dir_change (parse_in, get_src_pwd ());
return flag_preprocess_only;
@ -1343,7 +1343,7 @@ push_command_line_include (void)
{
struct deferred_opt *opt = &deferred_opts[include_cursor++];
if (! cpp_opts->preprocessed && opt->code == OPT_include
if (!cpp_opts->preprocessed && opt->code == OPT_include
&& cpp_push_include (parse_in, opt->arg))
return;
}
@ -1354,7 +1354,7 @@ push_command_line_include (void)
/* -Wunused-macros should only warn about macros defined hereafter. */
cpp_opts->warn_unused_macros = warn_unused_macros;
/* Restore the line map from <command line>. */
if (! cpp_opts->preprocessed)
if (!cpp_opts->preprocessed)
cpp_change_file (parse_in, LC_RENAME, main_input_filename);
/* Set this here so the client can change the option if it wishes,
@ -1380,7 +1380,7 @@ cb_file_change (cpp_reader * ARG_UNUSED (pfile),
void
cb_dir_change (cpp_reader * ARG_UNUSED (pfile), const char *dir)
{
if (! set_src_pwd (dir))
if (!set_src_pwd (dir))
warning ("too late for # directive to set debug directory");
}

30
gcc/c-parse.in
View File

@ -386,7 +386,7 @@ extdefs:
save_obstack_position { $<dsptype>$ = NULL; } extdef
{ obstack_free (&parser_obstack, $1); }
| extdefs save_obstack_position
{ $<dsptype>$ = NULL; ggc_collect(); } extdef
{ $<dsptype>$ = NULL; ggc_collect (); } extdef
{ obstack_free (&parser_obstack, $2); }
;
@ -430,8 +430,8 @@ datadef:
fndef:
declspecs_ts setspecs declarator
{ if (! start_function (current_declspecs, $3,
all_prefix_attributes))
{ if (!start_function (current_declspecs, $3,
all_prefix_attributes))
YYERROR1;
}
old_style_parm_decls save_location
@ -443,8 +443,8 @@ fndef:
| declspecs_ts setspecs declarator error
{ POP_DECLSPEC_STACK; }
| declspecs_nots setspecs notype_declarator
{ if (! start_function (current_declspecs, $3,
all_prefix_attributes))
{ if (!start_function (current_declspecs, $3,
all_prefix_attributes))
YYERROR1;
}
old_style_parm_decls save_location
@ -456,8 +456,8 @@ fndef:
| declspecs_nots setspecs notype_declarator error
{ POP_DECLSPEC_STACK; }
| setspecs notype_declarator
{ if (! start_function (current_declspecs, $2,
all_prefix_attributes))
{ if (!start_function (current_declspecs, $2,
all_prefix_attributes))
YYERROR1;
}
old_style_parm_decls save_location
@ -690,7 +690,7 @@ primary:
finish_init ();
maybe_warn_string_init (type, init);
if (pedantic && ! flag_isoc99)
if (pedantic && !flag_isoc99)
pedwarn ("ISO C90 forbids compound literals");
$$.value = build_compound_literal (type, constructor);
$$.original_code = ERROR_MARK;
@ -1433,7 +1433,7 @@ initlist1:
It may use braces. */
initelt:
designator_list '=' initval
{ if (pedantic && ! flag_isoc99)
{ if (pedantic && !flag_isoc99)
pedwarn ("ISO C90 forbids specifying subobject to initialize"); }
| designator initval
{ if (pedantic)
@ -1479,8 +1479,8 @@ nested_function:
pedwarn ("ISO C forbids nested functions");
push_function_context ();
if (! start_function (current_declspecs, $1,
all_prefix_attributes))
if (!start_function (current_declspecs, $1,
all_prefix_attributes))
{
pop_function_context ();
YYERROR1;
@ -1509,8 +1509,8 @@ notype_nested_function:
pedwarn ("ISO C forbids nested functions");
push_function_context ();
if (! start_function (current_declspecs, $1,
all_prefix_attributes))
if (!start_function (current_declspecs, $1,
all_prefix_attributes))
{
pop_function_context ();
YYERROR1;
@ -1692,7 +1692,7 @@ maybecomma:
maybecomma_warn:
/* empty */
| ','
{ if (pedantic && ! flag_isoc99)
{ if (pedantic && !flag_isoc99)
pedwarn ("comma at end of enumerator list"); }
;
@ -2568,7 +2568,7 @@ identifiers_or_typenames:
extension:
EXTENSION
{ $$ = SAVE_EXT_FLAGS();
{ $$ = SAVE_EXT_FLAGS ();
pedantic = 0;
warn_pointer_arith = 0;
warn_traditional = 0;

6
gcc/c-pch.c
View File

@ -99,7 +99,7 @@ static const char *get_ident (void);
format. */
static const char *
get_ident(void)
get_ident (void)
{
static char result[IDENT_LENGTH];
static const char template[IDENT_LENGTH] = "gpch.012";
@ -122,7 +122,7 @@ pch_init (void)
void *target_validity;
static const char partial_pch[IDENT_LENGTH] = "gpcWrite";
if (! pch_file)
if (!pch_file)
return;
f = fopen (pch_file, "w+b");
@ -484,7 +484,7 @@ c_common_pch_pragma (cpp_reader *pfile)
return;
}
if (! cpp_get_options (pfile)->preprocessed)
if (!cpp_get_options (pfile)->preprocessed)
{
error ("pch_preprocess pragma should only be used with -fpreprocessed");
inform ("use #include instead");

2
gcc/c-ppoutput.c
View File

@ -254,7 +254,7 @@ print_line (source_location src_loc, const char *special_flags)
/* cpp_quote_string does not nul-terminate, so we have to do it
ourselves. */
p = cpp_quote_string (to_file_quoted,
(unsigned char *)map->to_file, to_file_len);
(unsigned char *) map->to_file, to_file_len);
*p = '\0';
fprintf (print.outf, "# %u \"%s\"%s", print.src_line,
to_file_quoted, special_flags);

6
gcc/c-pragma.c
View File

@ -95,7 +95,7 @@ pop_alignment (tree id)
align_stack * entry;
if (alignment_stack == NULL)
GCC_BAD("#pragma pack (pop) encountered without matching #pragma pack (push)");
GCC_BAD ("#pragma pack (pop) encountered without matching #pragma pack (push)");
/* If we got an identifier, strip away everything above the target
entry so that the next step will restore the state just below it. */
@ -122,9 +122,9 @@ pop_alignment (tree id)
#else /* not HANDLE_PRAGMA_PACK_PUSH_POP */
#define SET_GLOBAL_ALIGNMENT(ALIGN) (maximum_field_alignment = (ALIGN))
#define push_alignment(ID, N) \
GCC_BAD("#pragma pack(push[, id], <n>) is not supported on this target")
GCC_BAD ("#pragma pack(push[, id], <n>) is not supported on this target")
#define pop_alignment(ID) \
GCC_BAD("#pragma pack(pop[, id], <n>) is not supported on this target")
GCC_BAD ("#pragma pack(pop[, id], <n>) is not supported on this target")
#endif /* HANDLE_PRAGMA_PACK_PUSH_POP */
/* #pragma pack ()

98
gcc/c-typeck.c
View File

@ -310,9 +310,9 @@ composite_type (tree t1, tree t2)
int i;
/* Save space: see if the result is identical to one of the args. */
if (valtype == TREE_TYPE (t1) && ! TYPE_ARG_TYPES (t2))
if (valtype == TREE_TYPE (t1) && !TYPE_ARG_TYPES (t2))
return build_type_attribute_variant (t1, attributes);
if (valtype == TREE_TYPE (t2) && ! TYPE_ARG_TYPES (t1))
if (valtype == TREE_TYPE (t2) && !TYPE_ARG_TYPES (t1))
return build_type_attribute_variant (t2, attributes);
/* Simple way if one arg fails to specify argument types. */
@ -637,7 +637,7 @@ comptypes (tree type1, tree type2)
return 1;
/* 1 if no need for warning yet, 2 if warning cause has been seen. */
if (! (attrval = targetm.comp_type_attributes (t1, t2)))
if (!(attrval = targetm.comp_type_attributes (t1, t2)))
return 0;
/* 1 if no need for warning yet, 2 if warning cause has been seen. */
@ -675,13 +675,13 @@ comptypes (tree type1, tree type2)
if (d1 == 0 || d2 == 0 || d1 == d2)
break;
d1_zero = ! TYPE_MAX_VALUE (d1);
d2_zero = ! TYPE_MAX_VALUE (d2);
d1_zero = !TYPE_MAX_VALUE (d1);
d2_zero = !TYPE_MAX_VALUE (d2);
d1_variable = (! d1_zero
d1_variable = (!d1_zero
&& (TREE_CODE (TYPE_MIN_VALUE (d1)) != INTEGER_CST
|| TREE_CODE (TYPE_MAX_VALUE (d1)) != INTEGER_CST));
d2_variable = (! d2_zero
d2_variable = (!d2_zero
&& (TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST
|| TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST));
@ -690,8 +690,8 @@ comptypes (tree type1, tree type2)
if (d1_zero && d2_zero)
break;
if (d1_zero || d2_zero
|| ! tree_int_cst_equal (TYPE_MIN_VALUE (d1), TYPE_MIN_VALUE (d2))
|| ! tree_int_cst_equal (TYPE_MAX_VALUE (d1), TYPE_MAX_VALUE (d2)))
|| !tree_int_cst_equal (TYPE_MIN_VALUE (d1), TYPE_MIN_VALUE (d2))
|| !tree_int_cst_equal (TYPE_MAX_VALUE (d1), TYPE_MAX_VALUE (d2)))
val = 0;
break;
@ -915,7 +915,7 @@ tagged_types_tu_compatible_p (tree t1, tree t2)
break;
}
tagged_tu_seen_base = tts.next;
if (! ok)
if (!ok)
return 0;
}
return needs_warning ? 2 : 1;
@ -1063,8 +1063,8 @@ type_lists_compatible_p (tree args1, tree args2)
else if (TREE_CODE (TREE_VALUE (args1)) == ERROR_MARK
|| TREE_CODE (TREE_VALUE (args2)) == ERROR_MARK)
;
else if (! (newval = comptypes (TYPE_MAIN_VARIANT (TREE_VALUE (args1)),
TYPE_MAIN_VARIANT (TREE_VALUE (args2)))))
else if (!(newval = comptypes (TYPE_MAIN_VARIANT (TREE_VALUE (args1)),
TYPE_MAIN_VARIANT (TREE_VALUE (args2)))))
{
/* Allow wait (union {union wait *u; int *i} *)
and wait (union wait *) to be compatible. */
@ -1143,7 +1143,7 @@ decl_constant_value (tree decl)
isn't valid for a PARM_DECL. */
current_function_decl != 0
&& TREE_CODE (decl) != PARM_DECL
&& ! TREE_THIS_VOLATILE (decl)
&& !TREE_THIS_VOLATILE (decl)
&& TREE_READONLY (decl)
&& DECL_INITIAL (decl) != 0
&& TREE_CODE (DECL_INITIAL (decl)) != ERROR_MARK
@ -1631,7 +1631,7 @@ build_array_ref (tree array, tree index)
to access a non-existent part of the register. */
if (TREE_CODE (index) == INTEGER_CST
&& TYPE_DOMAIN (TREE_TYPE (array))
&& ! int_fits_type_p (index, TYPE_DOMAIN (TREE_TYPE (array))))
&& !int_fits_type_p (index, TYPE_DOMAIN (TREE_TYPE (array))))
{
if (!c_mark_addressable (array))
return error_mark_node;
@ -1644,7 +1644,7 @@ build_array_ref (tree array, tree index)
foo = TREE_OPERAND (foo, 0);
if (TREE_CODE (foo) == VAR_DECL && C_DECL_REGISTER (foo))
pedwarn ("ISO C forbids subscripting %<register%> array");
else if (! flag_isoc99 && ! lvalue_p (foo))
else if (!flag_isoc99 && !lvalue_p (foo))
pedwarn ("ISO C90 forbids subscripting non-lvalue array");
}
@ -1936,11 +1936,11 @@ build_function_call (tree function, tree params)
??? This doesn't work for Objective-C because objc_comptypes
refuses to compare function prototypes, yet the compiler appears
to build calls that are flagged as invalid by C's comptypes. */
if (! c_dialect_objc ()
if (!c_dialect_objc ()
&& TREE_CODE (function) == NOP_EXPR
&& TREE_CODE (tem = TREE_OPERAND (function, 0)) == ADDR_EXPR
&& TREE_CODE (tem = TREE_OPERAND (tem, 0)) == FUNCTION_DECL
&& ! comptypes (fntype, TREE_TYPE (tem)))
&& !comptypes (fntype, TREE_TYPE (tem)))
{
tree return_type = TREE_TYPE (fntype);
tree trap = build_function_call (built_in_decls[BUILT_IN_TRAP],
@ -2905,7 +2905,7 @@ build_conditional_expr (tree ifexp, tree op1, tree op2)
/* Do not warn if the result type is signed, since the
signed type will only be chosen if it can represent
all the values of the unsigned type. */
if (! TYPE_UNSIGNED (result_type))
if (!TYPE_UNSIGNED (result_type))
/* OK */;
/* Do not warn if the signed quantity is an unsuffixed
integer literal (or some static constant expression
@ -2958,7 +2958,7 @@ build_conditional_expr (tree ifexp, tree op1, tree op2)
}
else if (code1 == POINTER_TYPE && code2 == INTEGER_TYPE)
{
if (! integer_zerop (op2))
if (!integer_zerop (op2))
pedwarn ("pointer/integer type mismatch in conditional expression");
else
{
@ -3018,13 +3018,13 @@ build_compound_expr (tree expr1, tree expr2)
if (integer_zerop (expr2))
expr2 = non_lvalue (expr2);
if (! TREE_SIDE_EFFECTS (expr1))
if (!TREE_SIDE_EFFECTS (expr1))
{
/* The left-hand operand of a comma expression is like an expression
statement: with -Wextra or -Wunused, we should warn if it doesn't have
any side-effects, unless it was explicitly cast to (void). */
if (warn_unused_value
&& ! (TREE_CODE (expr1) == CONVERT_EXPR
&& !(TREE_CODE (expr1) == CONVERT_EXPR
&& VOID_TYPE_P (TREE_TYPE (expr1))))
warning ("left-hand operand of comma expression has no effect");
}
@ -3479,7 +3479,7 @@ convert_for_assignment (tree type, tree rhs, const char *errtype,
/* Conversion to a transparent union from its member types.
This applies only to function arguments. */
else if (codel == UNION_TYPE && TYPE_TRANSPARENT_UNION (type) && ! errtype)
else if (codel == UNION_TYPE && TYPE_TRANSPARENT_UNION (type) && !errtype)
{
tree memb_types;
tree marginal_memb_type = 0;
@ -3519,7 +3519,7 @@ convert_for_assignment (tree type, tree rhs, const char *errtype,
break;
/* Keep looking for a better type, but remember this one. */
if (! marginal_memb_type)
if (!marginal_memb_type)
marginal_memb_type = memb_type;
}
}
@ -3536,7 +3536,7 @@ convert_for_assignment (tree type, tree rhs, const char *errtype,
if (memb_types || marginal_memb_type)
{
if (! memb_types)
if (!memb_types)
{
/* We have only a marginally acceptable member type;
it needs a warning. */
@ -3563,7 +3563,7 @@ convert_for_assignment (tree type, tree rhs, const char *errtype,
parmnum);
}
if (pedantic && ! DECL_IN_SYSTEM_HEADER (fundecl))
if (pedantic && !DECL_IN_SYSTEM_HEADER (fundecl))
pedwarn ("ISO C prohibits argument conversion to union type");
return build1 (NOP_EXPR, type, rhs);
@ -3650,12 +3650,12 @@ convert_for_assignment (tree type, tree rhs, const char *errtype,
/* An explicit constant 0 can convert to a pointer,
or one that results from arithmetic, even including
a cast to integer type. */
if (! (TREE_CODE (rhs) == INTEGER_CST && integer_zerop (rhs))
if (!(TREE_CODE (rhs) == INTEGER_CST && integer_zerop (rhs))
&&
! (TREE_CODE (rhs) == NOP_EXPR
&& TREE_CODE (TREE_TYPE (rhs)) == INTEGER_TYPE
&& TREE_CODE (TREE_OPERAND (rhs, 0)) == INTEGER_CST
&& integer_zerop (TREE_OPERAND (rhs, 0))))
!(TREE_CODE (rhs) == NOP_EXPR
&& TREE_CODE (TREE_TYPE (rhs)) == INTEGER_TYPE
&& TREE_CODE (TREE_OPERAND (rhs, 0)) == INTEGER_CST
&& integer_zerop (TREE_OPERAND (rhs, 0))))
warn_for_assignment ("%s makes pointer from integer without a cast",
errtype, funname, parmnum);
@ -3704,7 +3704,7 @@ c_convert_parm_for_inlining (tree parm, tree value, tree fn, int argnum)
/* If FN was prototyped, the value has been converted already
in convert_arguments. */
if (! value || TYPE_ARG_TYPES (TREE_TYPE (fn)))
if (!value || TYPE_ARG_TYPES (TREE_TYPE (fn)))
return value;
type = TREE_TYPE (parm);
@ -3806,7 +3806,7 @@ store_init_value (tree decl, tree init)
/* Store the expression if valid; else report error. */
if (warn_traditional && !in_system_header
&& AGGREGATE_TYPE_P (TREE_TYPE (decl)) && ! TREE_STATIC (decl))
&& AGGREGATE_TYPE_P (TREE_TYPE (decl)) && !TREE_STATIC (decl))
warning ("traditional C rejects automatic aggregate initialization");
DECL_INITIAL (decl) = value;
@ -4232,7 +4232,7 @@ digest_init (tree type, tree init, bool strict_string, int require_constant)
/* Check to see if we have already given an error message. */
if (inside_init == error_mark_node)
;
else if (require_constant && ! TREE_CONSTANT (inside_init))
else if (require_constant && !TREE_CONSTANT (inside_init))
{
error_init ("initializer element is not constant");
inside_init = error_mark_node;
@ -4848,7 +4848,7 @@ pop_init_level (int implicit)
if (constructor_type && constructor_fields
&& TREE_CODE (constructor_type) == ARRAY_TYPE
&& TYPE_DOMAIN (constructor_type)
&& ! TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)))
&& !TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)))
{
/* Silently discard empty initializations. The parser will
already have pedwarned for empty brackets. */
@ -4879,7 +4879,7 @@ pop_init_level (int implicit)
{
/* Do not warn for flexible array members or zero-length arrays. */
while (constructor_unfilled_fields
&& (! DECL_SIZE (constructor_unfilled_fields)
&& (!DECL_SIZE (constructor_unfilled_fields)
|| integer_zerop (DECL_SIZE (constructor_unfilled_fields))))
constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
@ -5854,7 +5854,7 @@ output_pending_init_elements (int all)
/* Ordinarily return, but not if we want to output all
and there are elements left. */
if (! (all && next != 0))
if (!(all && next != 0))
return;
/* If it's not incremental, just skip over the gap, so that after
@ -6395,7 +6395,7 @@ c_finish_return (tree retval)
{
tree op1 = TREE_OPERAND (inner, 1);
while (! POINTER_TYPE_P (TREE_TYPE (op1))
while (!POINTER_TYPE_P (TREE_TYPE (op1))
&& (TREE_CODE (op1) == NOP_EXPR
|| TREE_CODE (op1) == NON_LVALUE_EXPR
|| TREE_CODE (op1) == CONVERT_EXPR))
@ -6416,8 +6416,8 @@ c_finish_return (tree retval)
inner = TREE_OPERAND (inner, 0);
if (DECL_P (inner)
&& ! DECL_EXTERNAL (inner)
&& ! TREE_STATIC (inner)
&& !DECL_EXTERNAL (inner)
&& !TREE_STATIC (inner)
&& DECL_CONTEXT (inner) == current_function_decl)
warning ("function returns address of local variable");
break;
@ -6477,7 +6477,7 @@ c_start_case (tree exp)
code = TREE_CODE (TREE_TYPE (exp));
orig_type = TREE_TYPE (exp);
if (! INTEGRAL_TYPE_P (orig_type)
if (!INTEGRAL_TYPE_P (orig_type)
&& code != ERROR_MARK)
{
error ("switch quantity not an integer");
@ -7093,7 +7093,7 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1,
dividing by something we know != -1. */
shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0))
|| (TREE_CODE (op1) == INTEGER_CST
&& ! integer_all_onesp (op1)));
&& !integer_all_onesp (op1)));
common = 1;
}
break;
@ -7120,7 +7120,7 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1,
only if unsigned or if dividing by something we know != -1. */
shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0))
|| (TREE_CODE (op1) == INTEGER_CST
&& ! integer_all_onesp (op1)));
&& !integer_all_onesp (op1)));
common = 1;
}
break;
@ -7158,7 +7158,7 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1,
warning ("right shift count is negative");
else
{
if (! integer_zerop (op1))
if (!integer_zerop (op1))
short_shift = 1;
if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
@ -7523,8 +7523,8 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1,
if (warn_sign_compare && skip_evaluation == 0)
{
int op0_signed = ! TYPE_UNSIGNED (TREE_TYPE (orig_op0));
int op1_signed = ! TYPE_UNSIGNED (TREE_TYPE (orig_op1));
int op0_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op0));
int op1_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op1));
int unsignedp0, unsignedp1;
tree primop0 = get_narrower (op0, &unsignedp0);
tree primop1 = get_narrower (op1, &unsignedp1);
@ -7543,7 +7543,7 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1,
Do not warn if the comparison is being done in a signed type,
since the signed type will only be chosen if it can represent
all the values of the unsigned type. */
if (! TYPE_UNSIGNED (result_type))
if (!TYPE_UNSIGNED (result_type))
/* OK */;
/* Do not warn if both operands are the same signedness. */
else if (op0_signed == op1_signed)
@ -7578,7 +7578,7 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1,
else if (TREE_CODE (uop) == INTEGER_CST
&& TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE
&& int_fits_type_p
(TYPE_MAX_VALUE (TREE_TYPE(uop)),
(TYPE_MAX_VALUE (TREE_TYPE (uop)),
c_common_signed_type (result_type)))
/* OK */;
else
@ -7626,7 +7626,7 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1,
if (bits < TYPE_PRECISION (result_type)
&& bits < HOST_BITS_PER_WIDE_INT && unsignedp)
{
mask = (~ (HOST_WIDE_INT) 0) << bits;
mask = (~(HOST_WIDE_INT) 0) << bits;
if ((mask & constant) != mask)
warning ("comparison of promoted ~unsigned with constant");
}
@ -7654,7 +7654,7 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1,
return error_mark_node;
}
if (! converted)
if (!converted)
{
if (TREE_TYPE (op0) != result_type)
op0 = convert (result_type, op0);