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

	* 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

16 files changed, 213 insertions, 206 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 998270c..c934ea5 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -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.
diff --git a/gcc/c-aux-info.c b/gcc/c-aux-info.c
index b42adce..ddc3e37 100644
--- a/gcc/c-aux-info.c
+++ b/gcc/c-aux-info.c
@@ -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
diff --git a/gcc/c-common.c b/gcc/c-common.c
index 7eda4d1..b2751f3 100644
--- a/gcc/c-common.c
+++ b/gcc/c-common.c
@@ -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);
diff --git a/gcc/c-common.h b/gcc/c-common.h
index 46e843b..77a415d 100644
--- a/gcc/c-common.h
+++ b/gcc/c-common.h
@@ -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.  */
 
diff --git a/gcc/c-cppbuiltin.c b/gcc/c-cppbuiltin.c
index c20e987..a970df5 100644
--- a/gcc/c-cppbuiltin.c
+++ b/gcc/c-cppbuiltin.c
@@ -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] == '-'));
 
diff --git a/gcc/c-decl.c b/gcc/c-decl.c
index 7502a07..df61736 100644
--- a/gcc/c-decl.c
+++ b/gcc/c-decl.c
@@ -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)))
diff --git a/gcc/c-format.c b/gcc/c-format.c
index 341eb59..e5009a3 100644
--- a/gcc/c-format.c
+++ b/gcc/c-format.c
@@ -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;
diff --git a/gcc/c-incpath.c b/gcc/c-incpath.c
index 4fd1b13..177af98 100644
--- a/gcc/c-incpath.c
+++ b/gcc/c-incpath.c
@@ -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))
diff --git a/gcc/c-lex.c b/gcc/c-lex.c
index aff84e0..98f60f6 100644
--- a/gcc/c-lex.c
+++ b/gcc/c-lex.c
@@ -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
diff --git a/gcc/c-objc-common.c b/gcc/c-objc-common.c
index 4d32136..278529e 100644
--- a/gcc/c-objc-common.c
+++ b/gcc/c-objc-common.c
@@ -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.  */
diff --git a/gcc/c-opts.c b/gcc/c-opts.c
index c199c48..0377a5d 100644
--- a/gcc/c-opts.c
+++ b/gcc/c-opts.c
@@ -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");
 }
 
diff --git a/gcc/c-parse.in b/gcc/c-parse.in
index 87dfc10..b682700 100644
--- a/gcc/c-parse.in
+++ b/gcc/c-parse.in
@@ -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;
diff --git a/gcc/c-pch.c b/gcc/c-pch.c
index 04eee83..8b21235 100644
--- a/gcc/c-pch.c
+++ b/gcc/c-pch.c
@@ -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");
diff --git a/gcc/c-ppoutput.c b/gcc/c-ppoutput.c
index d34ec61..9556399 100644
--- a/gcc/c-ppoutput.c
+++ b/gcc/c-ppoutput.c
@@ -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);
diff --git a/gcc/c-pragma.c b/gcc/c-pragma.c
index fd2f7f7..f59bfc0 100644
--- a/gcc/c-pragma.c
+++ b/gcc/c-pragma.c
@@ -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 ()
diff --git a/gcc/c-typeck.c b/gcc/c-typeck.c
index 08b5953..27c8cd4 100644
--- a/gcc/c-typeck.c
+++ b/gcc/c-typeck.c
@@ -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);