+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.
/* 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
char *namep;
int vrb = 2;
- if (! pretty_p)
+ if (!pretty_p)
{
name = "";
vrb = 0;
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");
}
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;
}
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;
{
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);
if (t->expr == x)
break;
- if (! t)
+ if (!t)
{
t = XOBNEW (&tlist_obstack, struct tlist_cache);
t->next = save_expr_cache;
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;
else
log = tree_floor_log2 (value);
- return log + 1 + ! unsignedp;
+ return log + 1 + !unsignedp;
}
\f
/* Print an error message for invalid operands to arith operation
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;
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);
>= 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;
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,
/* 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)))))
{
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. */
{
int i = 0;
int shift, size;
- tree t = (tree)p;
+ tree t = (tree) p;
tree t2;
switch (TREE_CODE (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
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
/* 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++)
{
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);
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;
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;
if (TYPE_P (decl))
{
decl = TYPE_NAME (decl);
- if (! decl)
+ if (!decl)
return NULL_TREE;
}
{
tree decl = *node;
- if (! DECL_THREAD_LOCAL (decl))
+ if (!DECL_THREAD_LOCAL (decl))
{
warning ("%qs attribute ignored", IDENTIFIER_POINTER (name));
*no_add_attrs = true;
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;
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));
/* 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;
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);
{
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)",
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);
};
#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. */
([^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] == '-'));
#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)
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)")))
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);
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
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;
/* 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);
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;
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))
/* 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);
}
/* 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);
/* 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)
/* 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;
}
}
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;
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
{
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.)");
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;
}
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))
/* 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);
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)
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;
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
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
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;
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");
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;
if (c_dialect_objc ())
objc_check_decl (decl);
rest_of_decl_compilation (decl, toplevel, 0);
- if (! toplevel)
+ if (!toplevel)
expand_decl (decl);
}
}
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.
/* 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
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. */
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);
}
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);
/* 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)))
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
: "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)))
int argnum;
int overflow_flag;
const char *fcp = *format;
- if (! ISDIGIT (*fcp))
+ if (!ISDIGIT (*fcp))
{
if (dollar_needed)
{
++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
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)))
/* 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. */
/* 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 =
}
/* 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');
}
/* 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');
}
/* 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');
/* 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;
# 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))
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)
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);
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
{
/* 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);
/* 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. */
break;
}
- if (! no_more_pch)
+ if (!no_more_pch)
{
no_more_pch = true;
c_common_no_more_pch ();
{
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;
}
{
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;
}
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");
? 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)
{
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
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 "
}
}
- 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. */
}
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;
{
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;
}
/* -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,
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");
}
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); }
;
\f
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
| 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
| 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
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;
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)
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;
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;
maybecomma_warn:
/* empty */
| ','
- { if (pedantic && ! flag_isoc99)
+ { if (pedantic && !flag_isoc99)
pedwarn ("comma at end of enumerator list"); }
;
extension:
EXTENSION
- { $$ = SAVE_EXT_FLAGS();
+ { $$ = SAVE_EXT_FLAGS ();
pedantic = 0;
warn_pointer_arith = 0;
warn_traditional = 0;
format. */
static const char *
-get_ident(void)
+get_ident (void)
{
static char result[IDENT_LENGTH];
static const char template[IDENT_LENGTH] = "gpch.012";
void *target_validity;
static const char partial_pch[IDENT_LENGTH] = "gpcWrite";
- if (! pch_file)
+ if (!pch_file)
return;
f = fopen (pch_file, "w+b");
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");
/* 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);
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. */
#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 ()
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. */
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. */
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));
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;
break;
}
tagged_tu_seen_base = tts.next;
- if (! ok)
+ if (!ok)
return 0;
}
return needs_warning ? 2 : 1;
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. */
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
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;
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");
}
??? 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],
/* 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
}
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
{
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");
}
/* 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;
break;
/* Keep looking for a better type, but remember this one. */
- if (! marginal_memb_type)
+ if (!marginal_memb_type)
marginal_memb_type = memb_type;
}
}
if (memb_types || marginal_memb_type)
{
- if (! memb_types)
+ if (!memb_types)
{
/* We have only a marginally acceptable member type;
it needs a warning. */
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);
/* 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);
/* 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);
/* 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;
/* 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;
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. */
{
/* 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);
/* 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
{
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))
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;
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");
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;
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;
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)
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);
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)
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
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");
}
return error_mark_node;
}
- if (! converted)
+ if (!converted)
{
if (TREE_TYPE (op0) != result_type)
op0 = convert (result_type, op0);
projects / gcc.git / commitdiff