changeset 70:b81903832de2

merge c-decl.c
author Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
date Sun, 21 Aug 2011 09:24:16 +0900
parents 1b10fe6932e1
children e334828451cb
files gcc/c-decl.c gcc/c-family/c-common.c gcc/c-family/c-common.h gcc/c-parser.c gcc/c-tree.h gcc/c-typeck.c gcc/calls.c gcc/cfgexpand.c gcc/gcc.c gcc/gimple.c gcc/gimple.h gcc/gimplify.c
diffstat 12 files changed, 10972 insertions(+), 11602 deletions(-) [+]
line wrap: on
line diff
--- a/gcc/c-decl.c	Sun Aug 21 07:53:12 2011 +0900
+++ b/gcc/c-decl.c	Sun Aug 21 09:24:16 2011 +0900
@@ -58,23 +58,23 @@
 #include "hashtab.h"
 #include "langhooks-def.h"
 #include "pointer-set.h"
-#include "gimple.h"
 #ifndef noCbC
 #include "cbc-tree.h"
 tree cbc_env;
 tree cbc_return_f;
 location_t cbc_return;
 #endif
+
 #include "plugin.h"
 #include "c-family/c-ada-spec.h"
 
 /* In grokdeclarator, distinguish syntactic contexts of declarators.  */
 enum decl_context
-{ NORMAL,           /* Ordinary declaration */
-  FUNCDEF,          /* Function definition */
-  PARM,             /* Declaration of parm before function body */
-  FIELD,            /* Declaration inside struct or union */
-  TYPENAME};            /* Typename (inside cast or sizeof)  */
+{ NORMAL,			/* Ordinary declaration */
+  FUNCDEF,			/* Function definition */
+  PARM,				/* Declaration of parm before function body */
+  FIELD,			/* Declaration inside struct or union */
+  TYPENAME};			/* Typename (inside cast or sizeof)  */
 
 /* States indicating how grokdeclarator() should handle declspecs marked
    with __attribute__((deprecated)).  An object declared as
@@ -196,20 +196,20 @@
    invisible bit true.  */
 
 struct GTY((chain_next ("%h.prev"))) c_binding {
-  union GTY(()) {       /* first so GTY desc can use decl */
+  union GTY(()) {		/* first so GTY desc can use decl */
     tree GTY((tag ("0"))) type; /* the type in this scope */
     struct c_label_vars * GTY((tag ("1"))) label; /* for warnings */
   } GTY((desc ("TREE_CODE (%0.decl) == LABEL_DECL"))) u;
-  tree decl;            /* the decl bound */
-  tree id;          /* the identifier it's bound to */
-  struct c_binding *prev;   /* the previous decl in this scope */
-  struct c_binding *shadowed;   /* the innermost decl shadowed by this one */
+  tree decl;			/* the decl bound */
+  tree id;			/* the identifier it's bound to */
+  struct c_binding *prev;	/* the previous decl in this scope */
+  struct c_binding *shadowed;	/* the innermost decl shadowed by this one */
   unsigned int depth : 28;      /* depth of this scope */
   BOOL_BITFIELD invisible : 1;  /* normal lookup should ignore this binding */
   BOOL_BITFIELD nested : 1;     /* do not set DECL_CONTEXT when popping */
   BOOL_BITFIELD inner_comp : 1; /* incomplete array completed in inner scope */
-  BOOL_BITFIELD in_struct : 1;  /* currently defined as struct field */
-  location_t locus;     /* location for nested bindings */
+  BOOL_BITFIELD in_struct : 1;	/* currently defined as struct field */
+  location_t locus;		/* location for nested bindings */
 };
 #define B_IN_SCOPE(b1, b2) ((b1)->depth == (b2)->depth)
 #define B_IN_CURRENT_SCOPE(b) ((b)->depth == current_scope->depth)
@@ -252,7 +252,7 @@
        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))")))  lang_tree_node
  {
   union tree_node GTY ((tag ("0"),
-            desc ("tree_node_structure (&%h)")))
+			desc ("tree_node_structure (&%h)")))
     generic;
   struct lang_identifier GTY ((tag ("1"))) identifier;
 };
@@ -448,25 +448,25 @@
 static GTY((deletable)) struct c_binding *binding_freelist;
 
 /* Append VAR to LIST in scope SCOPE.  */
-#define SCOPE_LIST_APPEND(scope, list, decl) do {   \
-  struct c_scope *s_ = (scope);             \
-  tree d_ = (decl);                 \
-  if (s_->list##_last)                  \
-    BLOCK_CHAIN (s_->list##_last) = d_;         \
-  else                          \
-    s_->list = d_;                  \
-  s_->list##_last = d_;                 \
+#define SCOPE_LIST_APPEND(scope, list, decl) do {	\
+  struct c_scope *s_ = (scope);				\
+  tree d_ = (decl);					\
+  if (s_->list##_last)					\
+    BLOCK_CHAIN (s_->list##_last) = d_;			\
+  else							\
+    s_->list = d_;					\
+  s_->list##_last = d_;					\
 } while (0)
 
 /* Concatenate FROM in scope FSCOPE onto TO in scope TSCOPE.  */
-#define SCOPE_LIST_CONCAT(tscope, to, fscope, from) do {    \
-  struct c_scope *t_ = (tscope);                \
-  struct c_scope *f_ = (fscope);                \
-  if (t_->to##_last)                        \
-    BLOCK_CHAIN (t_->to##_last) = f_->from;         \
-  else                              \
-    t_->to = f_->from;                      \
-  t_->to##_last = f_->from##_last;              \
+#define SCOPE_LIST_CONCAT(tscope, to, fscope, from) do {	\
+  struct c_scope *t_ = (tscope);				\
+  struct c_scope *f_ = (fscope);				\
+  if (t_->to##_last)						\
+    BLOCK_CHAIN (t_->to##_last) = f_->from;			\
+  else								\
+    t_->to = f_->from;						\
+  t_->to##_last = f_->from##_last;				\
 } while (0)
 
 /* A c_inline_static structure stores details of a static identifier
@@ -537,9 +537,9 @@
 static tree lookup_name_in_scope (tree, struct c_scope *);
 static tree c_make_fname_decl (location_t, tree, int);
 static tree grokdeclarator (const struct c_declarator *,
-                struct c_declspecs *,
-                enum decl_context, bool, tree *, tree *, tree *,
-                bool *, enum deprecated_states);
+			    struct c_declspecs *,
+			    enum decl_context, bool, tree *, tree *, tree *,
+			    bool *, enum deprecated_states);
 static tree grokparms (struct c_arg_info *, bool);
 static void layout_array_type (tree);
 
@@ -555,7 +555,7 @@
   if (CAN_HAVE_LOCATION_P (t) && code != LABEL_EXPR)
     {
       if (!EXPR_HAS_LOCATION (t))
-    SET_EXPR_LOCATION (t, input_location);
+	SET_EXPR_LOCATION (t, input_location);
     }
 
   if (code == LABEL_EXPR || code == CASE_LABEL_EXPR)
@@ -605,7 +605,7 @@
       tree rid = ridpointers[C_RID_CODE (node)];
       indent_to (file, indent + 4);
       fprintf (file, "rid " HOST_PTR_PRINTF " \"%s\"",
-           (void *) rid, IDENTIFIER_POINTER (rid));
+	       (void *) rid, IDENTIFIER_POINTER (rid));
     }
 }
 
@@ -694,12 +694,12 @@
    labels, and add the LABEL_VARS value.  */
 static void
 bind_label (tree name, tree label, struct c_scope *scope,
-        struct c_label_vars *label_vars)
+	    struct c_label_vars *label_vars)
 {
   struct c_binding *b;
 
   bind (name, label, scope, /*invisible=*/false, /*nested=*/false,
-    UNKNOWN_LOCATION);
+	UNKNOWN_LOCATION);
 
   scope->has_label_bindings = true;
 
@@ -719,17 +719,17 @@
     {
       tree type = TREE_TYPE (decl);
       if (type != error_mark_node
-      && TREE_CODE (type) == ARRAY_TYPE
-      && !DECL_EXTERNAL (decl)
-      && TYPE_DOMAIN (type) == 0)
-    {
-      warning_at (DECL_SOURCE_LOCATION (decl),
-              0, "array %q+D assumed to have one element", decl);
-
-      complete_array_type (&TREE_TYPE (decl), NULL_TREE, true);
-
-      layout_decl (decl, 0);
-    }
+	  && TREE_CODE (type) == ARRAY_TYPE
+	  && !DECL_EXTERNAL (decl)
+	  && TYPE_DOMAIN (type) == 0)
+	{
+	  warning_at (DECL_SOURCE_LOCATION (decl),
+		      0, "array %q+D assumed to have one element", decl);
+
+	  complete_array_type (&TREE_TYPE (decl), NULL_TREE, true);
+
+	  layout_decl (decl, 0);
+	}
     }
 }
 
@@ -739,7 +739,7 @@
 
 void
 record_inline_static (location_t loc, tree func, tree decl,
-              enum c_inline_static_type type)
+		      enum c_inline_static_type type)
 {
   struct c_inline_static *csi = ggc_alloc_c_inline_static ();
   csi->location = loc;
@@ -761,21 +761,21 @@
   for (csi = c_inline_statics; csi; csi = csi->next)
     {
       if (DECL_EXTERNAL (csi->function))
-    switch (csi->type)
-      {
-      case csi_internal:
-        pedwarn (csi->location, 0,
-             "%qD is static but used in inline function %qD "
-             "which is not static", csi->static_decl, csi->function);
-        break;
-      case csi_modifiable:
-        pedwarn (csi->location, 0,
-             "%q+D is static but declared in inline function %qD "
-             "which is not static", csi->static_decl, csi->function);
-        break;
-      default:
-        gcc_unreachable ();
-      }
+	switch (csi->type)
+	  {
+	  case csi_internal:
+	    pedwarn (csi->location, 0,
+		     "%qD is static but used in inline function %qD "
+		     "which is not static", csi->static_decl, csi->function);
+	    break;
+	  case csi_modifiable:
+	    pedwarn (csi->location, 0,
+		     "%q+D is static but declared in inline function %qD "
+		     "which is not static", csi->static_decl, csi->function);
+	    break;
+	  default:
+	    gcc_unreachable ();
+	  }
     }
   c_inline_statics = NULL;
 }
@@ -809,8 +809,8 @@
   if (p->scope != scope)
     {
       /* This label or goto is defined in some other scope, or it is a
-     label which is not yet defined.  There is nothing to
-     update.  */
+	 label which is not yet defined.  There is nothing to
+	 update.  */
       return false;
     }
 
@@ -844,11 +844,11 @@
        scope = scope->outer)
     {
       for (b = scope->bindings; b; b = b->prev)
-    objc_volatilize_decl (b->decl);
+	objc_volatilize_decl (b->decl);
 
       /* Do not climb up past the current function.  */
       if (scope->function_body)
-    break;
+	break;
     }
 }
 
@@ -858,8 +858,8 @@
 global_bindings_p (void)
 {
   return (current_scope == file_scope && !c_override_global_bindings_to_false
-      ? -1
-      : 0);
+	  ? -1
+	  : 0);
 }
 
 void
@@ -906,15 +906,15 @@
   if (next_is_function_body)
     {
       /* This is the transition from the parameters to the top level
-     of the function body.  These are the same scope
-     (C99 6.2.1p4,6) so we do not push another scope structure.
-     next_is_function_body is set only by store_parm_decls, which
-     in turn is called when and only when we are about to
-     encounter the opening curly brace for the function body.
-
-     The outermost block of a function always gets a BLOCK node,
-     because the debugging output routines expect that each
-     function has at least one BLOCK.  */
+	 of the function body.  These are the same scope
+	 (C99 6.2.1p4,6) so we do not push another scope structure.
+	 next_is_function_body is set only by store_parm_decls, which
+	 in turn is called when and only when we are about to
+	 encounter the opening curly brace for the function body.
+
+	 The outermost block of a function always gets a BLOCK node,
+	 because the debugging output routines expect that each
+	 function has at least one BLOCK.  */
       current_scope->parm_flag         = false;
       current_scope->function_body     = true;
       current_scope->keep              = true;
@@ -926,39 +926,39 @@
 
       /* The FLOAT_CONST_DECIMAL64 pragma applies to nested scopes.  */
       if (current_scope->outer)
-    current_scope->float_const_decimal64
-      = current_scope->outer->float_const_decimal64;
+	current_scope->float_const_decimal64
+	  = current_scope->outer->float_const_decimal64;
       else
-    current_scope->float_const_decimal64 = false;
+	current_scope->float_const_decimal64 = false;
     }
   else
     {
       struct c_scope *scope;
       if (scope_freelist)
-    {
-      scope = scope_freelist;
-      scope_freelist = scope->outer;
-    }
+	{
+	  scope = scope_freelist;
+	  scope_freelist = scope->outer;
+	}
       else
-        scope = ggc_alloc_cleared_c_scope ();
+	scope = ggc_alloc_cleared_c_scope ();
 
       /* The FLOAT_CONST_DECIMAL64 pragma applies to nested scopes.  */
       if (current_scope)
-    scope->float_const_decimal64 = current_scope->float_const_decimal64;
+	scope->float_const_decimal64 = current_scope->float_const_decimal64;
       else
-    scope->float_const_decimal64 = false;
+	scope->float_const_decimal64 = false;
 
       scope->keep          = keep_next_level_flag;
       scope->outer         = current_scope;
-      scope->depth     = current_scope ? (current_scope->depth + 1) : 0;
+      scope->depth	   = current_scope ? (current_scope->depth + 1) : 0;
 
       /* Check for scope depth overflow.  Unlikely (2^28 == 268,435,456) but
-     possible.  */
+	 possible.  */
       if (current_scope && scope->depth == 0)
-    {
-      scope->depth--;
-      sorry ("GCC supports only %u nested scopes", scope->depth);
-    }
+	{
+	  scope->depth--;
+	  sorry ("GCC supports only %u nested scopes", scope->depth);
+	}
 
       current_scope        = scope;
       keep_next_level_flag = false;
@@ -1027,7 +1027,7 @@
 
       /* Don't search beyond the current function.  */
       if (s == current_function_scope)
-    break;
+	break;
 
       s = s->outer;
     }
@@ -1071,7 +1071,7 @@
 
       /* In each subblock, record that this is its superior.  */
       for (p = scope->blocks; p; p = BLOCK_CHAIN (p))
-    BLOCK_SUPERCONTEXT (p) = block;
+	BLOCK_SUPERCONTEXT (p) = block;
 
       BLOCK_VARS (block) = 0;
     }
@@ -1114,6 +1114,7 @@
 	    }
 	  else
 	    warn_for_unused_label (p);
+
 	  /* Labels go in BLOCK_VARS.  */
 	  DECL_CHAIN (p) = BLOCK_VARS (block);
 	  BLOCK_VARS (block) = p;
@@ -1212,7 +1213,6 @@
 		 DECL_EXTERNAL decl for debug info generation.  */
 	      tree extp = copy_node (p);
 
-
 	      DECL_EXTERNAL (extp) = 1;
 	      TREE_STATIC (extp) = 0;
 	      TREE_PUBLIC (extp) = 1;
@@ -1241,7 +1241,6 @@
 		set_type_context (TREE_TYPE (p), context);
 	    }
 
-
 	  /* Fall through.  */
 	  /* Parameters go in DECL_ARGUMENTS, not BLOCK_VARS, and have
 	     already been put there by store_parm_decls.  Unused-
@@ -1276,12 +1275,12 @@
   else if (scope->outer)
     {
       if (block)
-    SCOPE_LIST_APPEND (scope->outer, blocks, block);
+	SCOPE_LIST_APPEND (scope->outer, blocks, block);
       /* If we did not make a block for the scope just exited, any
-     blocks made for inner scopes must be carried forward so they
-     will later become subblocks of something else.  */
+	 blocks made for inner scopes must be carried forward so they
+	 will later become subblocks of something else.  */
       else if (scope->blocks)
-    SCOPE_LIST_CONCAT (scope->outer, blocks, scope, blocks);
+	SCOPE_LIST_CONCAT (scope->outer, blocks, scope, blocks);
     }
 
   /* Pop the current scope, and free the structure for reuse.  */
@@ -1311,7 +1310,7 @@
 
   for (decl = visible_builtins; decl; decl = DECL_CHAIN (decl))
     bind (DECL_NAME (decl), decl, file_scope,
-      /*invisible=*/false, /*nested=*/true, DECL_SOURCE_LOCATION (decl));
+	  /*invisible=*/false, /*nested=*/true, DECL_SOURCE_LOCATION (decl));
 }
 
 void
@@ -1356,7 +1355,7 @@
       struct c_binding *b;
 
       if (!scope->has_label_bindings)
-    continue;
+	continue;
 
       for (b = scope->bindings; b != NULL; b = b->prev)
 	{
@@ -1389,7 +1388,7 @@
       struct c_binding *b;
 
       if (!scope->has_label_bindings)
-    continue;
+	continue;
 
       for (b = scope->bindings; b != NULL; b = b->prev)
 	{
@@ -1449,7 +1448,7 @@
      tagged type.  */
 
   TYPE_STUB_DECL (type) = pushdecl (build_decl (loc,
-                        TYPE_DECL, NULL_TREE, type));
+						TYPE_DECL, NULL_TREE, type));
 
   /* An approximation for now, so we can tell this is a function-scope tag.
      This will be updated in pop_scope.  */
@@ -1460,20 +1459,20 @@
       struct c_binding *b = I_SYMBOL_BINDING (name);
 
       if (b != NULL
-      && b->decl != NULL_TREE
-      && TREE_CODE (b->decl) == TYPE_DECL
-      && (B_IN_CURRENT_SCOPE (b)
-          || (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b)))
-      && (TYPE_MAIN_VARIANT (TREE_TYPE (b->decl))
-          != TYPE_MAIN_VARIANT (type)))
-    {
-      warning_at (loc, OPT_Wc___compat,
-              ("using %qD as both a typedef and a tag is "
-               "invalid in C++"),
-              b->decl);
-      if (b->locus != UNKNOWN_LOCATION)
-        inform (b->locus, "originally defined here");
-    }
+	  && b->decl != NULL_TREE
+	  && TREE_CODE (b->decl) == TYPE_DECL
+	  && (B_IN_CURRENT_SCOPE (b)
+	      || (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b)))
+	  && (TYPE_MAIN_VARIANT (TREE_TYPE (b->decl))
+	      != TYPE_MAIN_VARIANT (type)))
+	{
+	  warning_at (loc, OPT_Wc___compat,
+		      ("using %qD as both a typedef and a tag is "
+		       "invalid in C++"),
+		      b->decl);
+	  if (b->locus != UNKNOWN_LOCATION)
+	    inform (b->locus, "originally defined here");
+	}
     }
 }
 
@@ -1502,12 +1501,12 @@
   while (oldargs || newargs)
     {
       if (!oldargs
-      || !newargs
-      || !TREE_VALUE (oldargs)
-      || !TREE_VALUE (newargs)
-      || TYPE_MODE (TREE_VALUE (oldargs))
-         != TYPE_MODE (TREE_VALUE (newargs)))
-    return 0;
+	  || !newargs
+	  || !TREE_VALUE (oldargs)
+	  || !TREE_VALUE (newargs)
+	  || TYPE_MODE (TREE_VALUE (oldargs))
+	     != TYPE_MODE (TREE_VALUE (newargs)))
+	return 0;
 
       oldargs = TREE_CHAIN (oldargs);
       newargs = TREE_CHAIN (newargs);
@@ -1522,7 +1521,7 @@
    diagnostics.  */
 static void
 diagnose_arglist_conflict (tree newdecl, tree olddecl,
-               tree newtype, tree oldtype)
+			   tree newtype, tree oldtype)
 {
   tree t;
 
@@ -1540,19 +1539,19 @@
       tree type = TREE_VALUE (t);
 
       if (TREE_CHAIN (t) == 0
-      && TYPE_MAIN_VARIANT (type) != void_type_node)
-    {
-      inform (input_location, "a parameter list with an ellipsis can%'t match "
-          "an empty parameter name list declaration");
-      break;
-    }
+	  && TYPE_MAIN_VARIANT (type) != void_type_node)
+	{
+	  inform (input_location, "a parameter list with an ellipsis can%'t match "
+		  "an empty parameter name list declaration");
+	  break;
+	}
 
       if (c_type_promotes_to (type) != type)
-    {
-      inform (input_location, "an argument type that has a default promotion can%'t match "
-          "an empty parameter name list declaration");
-      break;
-    }
+	{
+	  inform (input_location, "an argument type that has a default promotion can%'t match "
+		  "an empty parameter name list declaration");
+	  break;
+	}
     }
 }
 
@@ -1578,38 +1577,38 @@
       tree newargtype = TREE_VALUE (newargs);
 
       if (oldargtype == error_mark_node || newargtype == error_mark_node)
-    return false;
+	return false;
 
       oldargtype = TYPE_MAIN_VARIANT (oldargtype);
       newargtype = TYPE_MAIN_VARIANT (newargtype);
 
       if (END_OF_ARGLIST (oldargtype) && END_OF_ARGLIST (newargtype))
-    break;
+	break;
 
       /* Reaching the end of just one list means the two decls don't
-     agree on the number of arguments.  */
+	 agree on the number of arguments.  */
       if (END_OF_ARGLIST (oldargtype))
-    {
-      error ("prototype for %q+D declares more arguments "
-         "than previous old-style definition", newdecl);
-      return false;
-    }
+	{
+	  error ("prototype for %q+D declares more arguments "
+		 "than previous old-style definition", newdecl);
+	  return false;
+	}
       else if (END_OF_ARGLIST (newargtype))
-    {
-      error ("prototype for %q+D declares fewer arguments "
-         "than previous old-style definition", newdecl);
-      return false;
-    }
+	{
+	  error ("prototype for %q+D declares fewer arguments "
+		 "than previous old-style definition", newdecl);
+	  return false;
+	}
 
       /* Type for passing arg must be consistent with that declared
-     for the arg.  */
+	 for the arg.  */
       else if (!comptypes (oldargtype, newargtype))
-    {
-      error ("prototype for %q+D declares argument %d"
-         " with incompatible type",
-         newdecl, i);
-      return false;
-    }
+	{
+	  error ("prototype for %q+D declares argument %d"
+		 " with incompatible type",
+		 newdecl, i);
+	  return false;
+	}
 
       oldargs = TREE_CHAIN (oldargs);
       newargs = TREE_CHAIN (newargs);
@@ -1619,7 +1618,7 @@
   /* If we get here, no errors were found, but do issue a warning
      for this poor-style construct.  */
   warning (0, "prototype for %q+D follows non-prototype definition",
-       newdecl);
+	   newdecl);
   return true;
 #undef END_OF_ARGLIST
 }
@@ -1650,7 +1649,7 @@
 
 static bool
 diagnose_mismatched_decls (tree newdecl, tree olddecl,
-               tree *newtypep, tree *oldtypep)
+			   tree *newtypep, tree *oldtypep)
 {
   tree newtype, oldtype;
   bool pedwarned = false;
@@ -1658,7 +1657,7 @@
   bool retval = true;
 
 #define DECL_EXTERN_INLINE(DECL) (DECL_DECLARED_INLINE_P (DECL)  \
-                  && DECL_EXTERNAL (DECL))
+				  && DECL_EXTERNAL (DECL))
 
   /* If we have error_mark_node for either decl or type, just discard
      the previous decl - we're in an error cascade already.  */
@@ -1674,18 +1673,18 @@
   if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
     {
       if (!(TREE_CODE (olddecl) == FUNCTION_DECL
-        && DECL_BUILT_IN (olddecl)
-        && !C_DECL_DECLARED_BUILTIN (olddecl)))
-    {
-      error ("%q+D redeclared as different kind of symbol", newdecl);
-      locate_old_decl (olddecl);
-    }
+	    && DECL_BUILT_IN (olddecl)
+	    && !C_DECL_DECLARED_BUILTIN (olddecl)))
+	{
+	  error ("%q+D redeclared as different kind of symbol", newdecl);
+	  locate_old_decl (olddecl);
+	}
       else if (TREE_PUBLIC (newdecl))
-    warning (0, "built-in function %q+D declared as non-function",
-         newdecl);
+	warning (0, "built-in function %q+D declared as non-function",
+		 newdecl);
       else
-    warning (OPT_Wshadow, "declaration of %q+D shadows "
-         "a built-in function", newdecl);
+	warning (OPT_Wshadow, "declaration of %q+D shadows "
+		 "a built-in function", newdecl);
       return false;
     }
 
@@ -1701,98 +1700,98 @@
   if (!comptypes (oldtype, newtype))
     {
       if (TREE_CODE (olddecl) == FUNCTION_DECL
-      && DECL_BUILT_IN (olddecl) && !C_DECL_DECLARED_BUILTIN (olddecl))
-    {
-      /* Accept harmless mismatch in function types.
-         This is for the ffs and fprintf builtins.  */
-      tree trytype = match_builtin_function_types (newtype, oldtype);
-
-      if (trytype && comptypes (newtype, trytype))
-        *oldtypep = oldtype = trytype;
-      else
-        {
-          /* If types don't match for a built-in, throw away the
-         built-in.  No point in calling locate_old_decl here, it
-         won't print anything.  */
-          warning (0, "conflicting types for built-in function %q+D",
-               newdecl);
-          return false;
-        }
-    }
+	  && DECL_BUILT_IN (olddecl) && !C_DECL_DECLARED_BUILTIN (olddecl))
+	{
+	  /* Accept harmless mismatch in function types.
+	     This is for the ffs and fprintf builtins.  */
+	  tree trytype = match_builtin_function_types (newtype, oldtype);
+
+	  if (trytype && comptypes (newtype, trytype))
+	    *oldtypep = oldtype = trytype;
+	  else
+	    {
+	      /* If types don't match for a built-in, throw away the
+		 built-in.  No point in calling locate_old_decl here, it
+		 won't print anything.  */
+	      warning (0, "conflicting types for built-in function %q+D",
+		       newdecl);
+	      return false;
+	    }
+	}
       else if (TREE_CODE (olddecl) == FUNCTION_DECL
-           && DECL_IS_BUILTIN (olddecl))
-    {
-      /* A conflicting function declaration for a predeclared
-         function that isn't actually built in.  Objective C uses
-         these.  The new declaration silently overrides everything
-         but the volatility (i.e. noreturn) indication.  See also
-         below.  FIXME: Make Objective C use normal builtins.  */
-      TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
-      return false;
-    }
+	       && DECL_IS_BUILTIN (olddecl))
+	{
+	  /* A conflicting function declaration for a predeclared
+	     function that isn't actually built in.  Objective C uses
+	     these.  The new declaration silently overrides everything
+	     but the volatility (i.e. noreturn) indication.  See also
+	     below.  FIXME: Make Objective C use normal builtins.  */
+	  TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
+	  return false;
+	}
       /* Permit void foo (...) to match int foo (...) if the latter is
-     the definition and implicit int was used.  See
-     c-torture/compile/920625-2.c.  */
+	 the definition and implicit int was used.  See
+	 c-torture/compile/920625-2.c.  */
       else if (TREE_CODE (newdecl) == FUNCTION_DECL && DECL_INITIAL (newdecl)
-           && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype)) == void_type_node
-           && TYPE_MAIN_VARIANT (TREE_TYPE (newtype)) == integer_type_node
-           && C_FUNCTION_IMPLICIT_INT (newdecl) && !DECL_INITIAL (olddecl))
-    {
-      pedwarned = pedwarn (input_location, 0,
-                   "conflicting types for %q+D", newdecl);
-      /* Make sure we keep void as the return type.  */
-      TREE_TYPE (newdecl) = *newtypep = newtype = oldtype;
-      C_FUNCTION_IMPLICIT_INT (newdecl) = 0;
-    }
+	       && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype)) == void_type_node
+	       && TYPE_MAIN_VARIANT (TREE_TYPE (newtype)) == integer_type_node
+	       && C_FUNCTION_IMPLICIT_INT (newdecl) && !DECL_INITIAL (olddecl))
+	{
+	  pedwarned = pedwarn (input_location, 0,
+			       "conflicting types for %q+D", newdecl);
+	  /* Make sure we keep void as the return type.  */
+	  TREE_TYPE (newdecl) = *newtypep = newtype = oldtype;
+	  C_FUNCTION_IMPLICIT_INT (newdecl) = 0;
+	}
       /* Permit void foo (...) to match an earlier call to foo (...) with
-     no declared type (thus, implicitly int).  */
+	 no declared type (thus, implicitly int).  */
       else if (TREE_CODE (newdecl) == FUNCTION_DECL
-           && TYPE_MAIN_VARIANT (TREE_TYPE (newtype)) == void_type_node
-           && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype)) == integer_type_node
-           && C_DECL_IMPLICIT (olddecl) && !DECL_INITIAL (olddecl))
-    {
-      pedwarned = pedwarn (input_location, 0,
-                   "conflicting types for %q+D", newdecl);
-      /* Make sure we keep void as the return type.  */
-      TREE_TYPE (olddecl) = *oldtypep = oldtype = newtype;
-    }
+	       && TYPE_MAIN_VARIANT (TREE_TYPE (newtype)) == void_type_node
+	       && TYPE_MAIN_VARIANT (TREE_TYPE (oldtype)) == integer_type_node
+	       && C_DECL_IMPLICIT (olddecl) && !DECL_INITIAL (olddecl))
+	{
+	  pedwarned = pedwarn (input_location, 0,
+			       "conflicting types for %q+D", newdecl);
+	  /* Make sure we keep void as the return type.  */
+	  TREE_TYPE (olddecl) = *oldtypep = oldtype = newtype;
+	}
       else
-    {
-      int new_quals = TYPE_QUALS (newtype);
-      int old_quals = TYPE_QUALS (oldtype);
-
-      if (new_quals != old_quals)
-        {
-          addr_space_t new_addr = DECODE_QUAL_ADDR_SPACE (new_quals);
-          addr_space_t old_addr = DECODE_QUAL_ADDR_SPACE (old_quals);
-          if (new_addr != old_addr)
-        {
-          if (ADDR_SPACE_GENERIC_P (new_addr))
-            error ("conflicting named address spaces (generic vs %s) "
-               "for %q+D",
-               c_addr_space_name (old_addr), newdecl);
-          else if (ADDR_SPACE_GENERIC_P (old_addr))
-            error ("conflicting named address spaces (%s vs generic) "
-               "for %q+D",
-               c_addr_space_name (new_addr), newdecl);
-          else
-            error ("conflicting named address spaces (%s vs %s) "
-               "for %q+D",
-               c_addr_space_name (new_addr),
-               c_addr_space_name (old_addr),
-               newdecl);
-        }
-
-          if (CLEAR_QUAL_ADDR_SPACE (new_quals)
-          != CLEAR_QUAL_ADDR_SPACE (old_quals))
-        error ("conflicting type qualifiers for %q+D", newdecl);
-        }
-      else
-        error ("conflicting types for %q+D", newdecl);
-      diagnose_arglist_conflict (newdecl, olddecl, newtype, oldtype);
-      locate_old_decl (olddecl);
-      return false;
-    }
+	{
+	  int new_quals = TYPE_QUALS (newtype);
+	  int old_quals = TYPE_QUALS (oldtype);
+
+	  if (new_quals != old_quals)
+	    {
+	      addr_space_t new_addr = DECODE_QUAL_ADDR_SPACE (new_quals);
+	      addr_space_t old_addr = DECODE_QUAL_ADDR_SPACE (old_quals);
+	      if (new_addr != old_addr)
+		{
+		  if (ADDR_SPACE_GENERIC_P (new_addr))
+		    error ("conflicting named address spaces (generic vs %s) "
+			   "for %q+D",
+			   c_addr_space_name (old_addr), newdecl);
+		  else if (ADDR_SPACE_GENERIC_P (old_addr))
+		    error ("conflicting named address spaces (%s vs generic) "
+			   "for %q+D",
+			   c_addr_space_name (new_addr), newdecl);
+		  else
+		    error ("conflicting named address spaces (%s vs %s) "
+			   "for %q+D",
+			   c_addr_space_name (new_addr),
+			   c_addr_space_name (old_addr),
+			   newdecl);
+		}
+
+	      if (CLEAR_QUAL_ADDR_SPACE (new_quals)
+		  != CLEAR_QUAL_ADDR_SPACE (old_quals))
+		error ("conflicting type qualifiers for %q+D", newdecl);
+	    }
+	  else
+	    error ("conflicting types for %q+D", newdecl);
+	  diagnose_arglist_conflict (newdecl, olddecl, newtype, oldtype);
+	  locate_old_decl (olddecl);
+	  return false;
+	}
     }
 
   /* Redeclaration of a type is a constraint violation (6.7.2.3p1),
@@ -1816,10 +1815,10 @@
 	}
 
       if (DECL_IN_SYSTEM_HEADER (newdecl)
-      || DECL_IN_SYSTEM_HEADER (olddecl)
-      || TREE_NO_WARNING (newdecl)
-      || TREE_NO_WARNING (olddecl))
-    return true;  /* Allow OLDDECL to continue in use.  */
+	  || DECL_IN_SYSTEM_HEADER (olddecl)
+	  || TREE_NO_WARNING (newdecl)
+	  || TREE_NO_WARNING (olddecl))
+	return true;  /* Allow OLDDECL to continue in use.  */
 
       if (pedantic && !flag_isoc1x)
 	{
@@ -1852,9 +1851,9 @@
   else if (TREE_CODE (newdecl) == FUNCTION_DECL)
     {
       /* If you declare a built-in function name as static, or
-     define the built-in with an old-style definition (so we
-     can't validate the argument list) the built-in definition is
-     overridden, but optionally warn this was a bad choice of name.  */
+	 define the built-in with an old-style definition (so we
+	 can't validate the argument list) the built-in definition is
+	 overridden, but optionally warn this was a bad choice of name.  */
       if (DECL_BUILT_IN (olddecl)
 	  && !C_DECL_DECLARED_BUILTIN (olddecl)
 	  && (!TREE_PUBLIC (newdecl)
@@ -1868,33 +1867,33 @@
 	}
 
       if (DECL_INITIAL (newdecl))
-    {
-      if (DECL_INITIAL (olddecl))
-        {
-          /* If both decls are in the same TU and the new declaration
-         isn't overriding an extern inline reject the new decl.
-         In c99, no overriding is allowed in the same translation
-         unit.  */
-          if ((!DECL_EXTERN_INLINE (olddecl)
-           || DECL_EXTERN_INLINE (newdecl)
-           || (!flag_gnu89_inline
-               && (!DECL_DECLARED_INLINE_P (olddecl)
-               || !lookup_attribute ("gnu_inline",
-                         DECL_ATTRIBUTES (olddecl)))
-               && (!DECL_DECLARED_INLINE_P (newdecl)
-               || !lookup_attribute ("gnu_inline",
-                         DECL_ATTRIBUTES (newdecl))))
-          )
-          && same_translation_unit_p (newdecl, olddecl))
-        {
-          error ("redefinition of %q+D", newdecl);
-          locate_old_decl (olddecl);
-          return false;
-        }
-        }
-    }
+	{
+	  if (DECL_INITIAL (olddecl))
+	    {
+	      /* If both decls are in the same TU and the new declaration
+		 isn't overriding an extern inline reject the new decl.
+		 In c99, no overriding is allowed in the same translation
+		 unit.  */
+	      if ((!DECL_EXTERN_INLINE (olddecl)
+		   || DECL_EXTERN_INLINE (newdecl)
+		   || (!flag_gnu89_inline
+		       && (!DECL_DECLARED_INLINE_P (olddecl)
+			   || !lookup_attribute ("gnu_inline",
+						 DECL_ATTRIBUTES (olddecl)))
+		       && (!DECL_DECLARED_INLINE_P (newdecl)
+			   || !lookup_attribute ("gnu_inline",
+						 DECL_ATTRIBUTES (newdecl))))
+		  )
+		  && same_translation_unit_p (newdecl, olddecl))
+		{
+		  error ("redefinition of %q+D", newdecl);
+		  locate_old_decl (olddecl);
+		  return false;
+		}
+	    }
+	}
       /* If we have a prototype after an old-style function definition,
-     the argument types must be checked specially.  */
+	 the argument types must be checked specially.  */
       else if (DECL_INITIAL (olddecl)
 	       && !prototype_p (oldtype) && prototype_p (newtype)
 	       && TYPE_ACTUAL_ARG_TYPES (oldtype)
@@ -1904,172 +1903,172 @@
 	  return false;
 	}
       /* A non-static declaration (even an "extern") followed by a
-     static declaration is undefined behavior per C99 6.2.2p3-5,7.
-     The same is true for a static forward declaration at block
-     scope followed by a non-static declaration/definition at file
-     scope.  Static followed by non-static at the same scope is
-     not undefined behavior, and is the most convenient way to get
-     some effects (see e.g.  what unwind-dw2-fde-glibc.c does to
-     the definition of _Unwind_Find_FDE in unwind-dw2-fde.c), but
-     we do diagnose it if -Wtraditional.  */
+	 static declaration is undefined behavior per C99 6.2.2p3-5,7.
+	 The same is true for a static forward declaration at block
+	 scope followed by a non-static declaration/definition at file
+	 scope.  Static followed by non-static at the same scope is
+	 not undefined behavior, and is the most convenient way to get
+	 some effects (see e.g.  what unwind-dw2-fde-glibc.c does to
+	 the definition of _Unwind_Find_FDE in unwind-dw2-fde.c), but
+	 we do diagnose it if -Wtraditional.  */
       if (TREE_PUBLIC (olddecl) && !TREE_PUBLIC (newdecl))
-    {
-      /* Two exceptions to the rule.  If olddecl is an extern
-         inline, or a predeclared function that isn't actually
-         built in, newdecl silently overrides olddecl.  The latter
-         occur only in Objective C; see also above.  (FIXME: Make
-         Objective C use normal builtins.)  */
-      if (!DECL_IS_BUILTIN (olddecl)
-          && !DECL_EXTERN_INLINE (olddecl))
-        {
-          error ("static declaration of %q+D follows "
-             "non-static declaration", newdecl);
-          locate_old_decl (olddecl);
-        }
-      return false;
-    }
+	{
+	  /* Two exceptions to the rule.  If olddecl is an extern
+	     inline, or a predeclared function that isn't actually
+	     built in, newdecl silently overrides olddecl.  The latter
+	     occur only in Objective C; see also above.  (FIXME: Make
+	     Objective C use normal builtins.)  */
+	  if (!DECL_IS_BUILTIN (olddecl)
+	      && !DECL_EXTERN_INLINE (olddecl))
+	    {
+	      error ("static declaration of %q+D follows "
+		     "non-static declaration", newdecl);
+	      locate_old_decl (olddecl);
+	    }
+	  return false;
+	}
       else if (TREE_PUBLIC (newdecl) && !TREE_PUBLIC (olddecl))
-    {
-      if (DECL_CONTEXT (olddecl))
-        {
-          error ("non-static declaration of %q+D follows "
-             "static declaration", newdecl);
-          locate_old_decl (olddecl);
-          return false;
-        }
-      else if (warn_traditional)
-        {
-          warned |= warning (OPT_Wtraditional,
-                 "non-static declaration of %q+D "
-                 "follows static declaration", newdecl);
-        }
-    }
+	{
+	  if (DECL_CONTEXT (olddecl))
+	    {
+	      error ("non-static declaration of %q+D follows "
+		     "static declaration", newdecl);
+	      locate_old_decl (olddecl);
+	      return false;
+	    }
+	  else if (warn_traditional)
+	    {
+	      warned |= warning (OPT_Wtraditional,
+				 "non-static declaration of %q+D "
+				 "follows static declaration", newdecl);
+	    }
+	}
 
       /* Make sure gnu_inline attribute is either not present, or
-     present on all inline decls.  */
+	 present on all inline decls.  */
       if (DECL_DECLARED_INLINE_P (olddecl)
-      && DECL_DECLARED_INLINE_P (newdecl))
-    {
-      bool newa = lookup_attribute ("gnu_inline",
-                    DECL_ATTRIBUTES (newdecl)) != NULL;
-      bool olda = lookup_attribute ("gnu_inline",
-                    DECL_ATTRIBUTES (olddecl)) != NULL;
-      if (newa != olda)
-        {
-          error_at (input_location, "%<gnu_inline%> attribute present on %q+D",
-            newa ? newdecl : olddecl);
-          error_at (DECL_SOURCE_LOCATION (newa ? olddecl : newdecl),
-            "but not here");
-        }
-    }
+	  && DECL_DECLARED_INLINE_P (newdecl))
+	{
+	  bool newa = lookup_attribute ("gnu_inline",
+					DECL_ATTRIBUTES (newdecl)) != NULL;
+	  bool olda = lookup_attribute ("gnu_inline",
+					DECL_ATTRIBUTES (olddecl)) != NULL;
+	  if (newa != olda)
+	    {
+	      error_at (input_location, "%<gnu_inline%> attribute present on %q+D",
+			newa ? newdecl : olddecl);
+	      error_at (DECL_SOURCE_LOCATION (newa ? olddecl : newdecl),
+			"but not here");
+	    }
+	}
     }
   else if (TREE_CODE (newdecl) == VAR_DECL)
     {
       /* Only variables can be thread-local, and all declarations must
-     agree on this property.  */
+	 agree on this property.  */
       if (C_DECL_THREADPRIVATE_P (olddecl) && !DECL_THREAD_LOCAL_P (newdecl))
-    {
-      /* Nothing to check.  Since OLDDECL is marked threadprivate
-         and NEWDECL does not have a thread-local attribute, we
-         will merge the threadprivate attribute into NEWDECL.  */
-      ;
-    }
+	{
+	  /* Nothing to check.  Since OLDDECL is marked threadprivate
+	     and NEWDECL does not have a thread-local attribute, we
+	     will merge the threadprivate attribute into NEWDECL.  */
+	  ;
+	}
       else if (DECL_THREAD_LOCAL_P (newdecl) != DECL_THREAD_LOCAL_P (olddecl))
-    {
-      if (DECL_THREAD_LOCAL_P (newdecl))
-        error ("thread-local declaration of %q+D follows "
-           "non-thread-local declaration", newdecl);
-      else
-        error ("non-thread-local declaration of %q+D follows "
-           "thread-local declaration", newdecl);
-
-      locate_old_decl (olddecl);
-      return false;
-    }
+	{
+	  if (DECL_THREAD_LOCAL_P (newdecl))
+	    error ("thread-local declaration of %q+D follows "
+		   "non-thread-local declaration", newdecl);
+	  else
+	    error ("non-thread-local declaration of %q+D follows "
+		   "thread-local declaration", newdecl);
+
+	  locate_old_decl (olddecl);
+	  return false;
+	}
 
       /* Multiple initialized definitions are not allowed (6.9p3,5).  */
       if (DECL_INITIAL (newdecl) && DECL_INITIAL (olddecl))
-    {
-      error ("redefinition of %q+D", newdecl);
-      locate_old_decl (olddecl);
-      return false;
-    }
+	{
+	  error ("redefinition of %q+D", newdecl);
+	  locate_old_decl (olddecl);
+	  return false;
+	}
 
       /* Objects declared at file scope: if the first declaration had
-     external linkage (even if it was an external reference) the
-     second must have external linkage as well, or the behavior is
-     undefined.  If the first declaration had internal linkage, then
-     the second must too, or else be an external reference (in which
-     case the composite declaration still has internal linkage).
-     As for function declarations, we warn about the static-then-
-     extern case only for -Wtraditional.  See generally 6.2.2p3-5,7.  */
+	 external linkage (even if it was an external reference) the
+	 second must have external linkage as well, or the behavior is
+	 undefined.  If the first declaration had internal linkage, then
+	 the second must too, or else be an external reference (in which
+	 case the composite declaration still has internal linkage).
+	 As for function declarations, we warn about the static-then-
+	 extern case only for -Wtraditional.  See generally 6.2.2p3-5,7.  */
       if (DECL_FILE_SCOPE_P (newdecl)
-      && TREE_PUBLIC (newdecl) != TREE_PUBLIC (olddecl))
-    {
-      if (DECL_EXTERNAL (newdecl))
-        {
-          if (!DECL_FILE_SCOPE_P (olddecl))
-        {
-          error ("extern declaration of %q+D follows "
-             "declaration with no linkage", newdecl);
-          locate_old_decl (olddecl);
-          return false;
-        }
-          else if (warn_traditional)
-        {
-          warned |= warning (OPT_Wtraditional,
-                     "non-static declaration of %q+D "
-                     "follows static declaration", newdecl);
-        }
-        }
-      else
-        {
-          if (TREE_PUBLIC (newdecl))
-        error ("non-static declaration of %q+D follows "
-               "static declaration", newdecl);
-          else
-        error ("static declaration of %q+D follows "
-               "non-static declaration", newdecl);
-
-          locate_old_decl (olddecl);
-          return false;
-        }
-    }
+	  && TREE_PUBLIC (newdecl) != TREE_PUBLIC (olddecl))
+	{
+	  if (DECL_EXTERNAL (newdecl))
+	    {
+	      if (!DECL_FILE_SCOPE_P (olddecl))
+		{
+		  error ("extern declaration of %q+D follows "
+			 "declaration with no linkage", newdecl);
+		  locate_old_decl (olddecl);
+		  return false;
+		}
+	      else if (warn_traditional)
+		{
+		  warned |= warning (OPT_Wtraditional,
+				     "non-static declaration of %q+D "
+				     "follows static declaration", newdecl);
+		}
+	    }
+	  else
+	    {
+	      if (TREE_PUBLIC (newdecl))
+		error ("non-static declaration of %q+D follows "
+		       "static declaration", newdecl);
+	      else
+		error ("static declaration of %q+D follows "
+		       "non-static declaration", newdecl);
+
+	      locate_old_decl (olddecl);
+	      return false;
+	    }
+	}
       /* Two objects with the same name declared at the same block
-     scope must both be external references (6.7p3).  */
+	 scope must both be external references (6.7p3).  */
       else if (!DECL_FILE_SCOPE_P (newdecl))
-    {
-      if (DECL_EXTERNAL (newdecl))
-        {
-          /* Extern with initializer at block scope, which will
-         already have received an error.  */
-        }
-      else if (DECL_EXTERNAL (olddecl))
-        {
-          error ("declaration of %q+D with no linkage follows "
-             "extern declaration", newdecl);
-          locate_old_decl (olddecl);
-        }
-      else
-        {
-          error ("redeclaration of %q+D with no linkage", newdecl);
-          locate_old_decl (olddecl);
-        }
-
-      return false;
-    }
+	{
+	  if (DECL_EXTERNAL (newdecl))
+	    {
+	      /* Extern with initializer at block scope, which will
+		 already have received an error.  */
+	    }
+	  else if (DECL_EXTERNAL (olddecl))
+	    {
+	      error ("declaration of %q+D with no linkage follows "
+		     "extern declaration", newdecl);
+	      locate_old_decl (olddecl);
+	    }
+	  else
+	    {
+	      error ("redeclaration of %q+D with no linkage", newdecl);
+	      locate_old_decl (olddecl);
+	    }
+
+	  return false;
+	}
 
       /* C++ does not permit a decl to appear multiple times at file
-     scope.  */
+	 scope.  */
       if (warn_cxx_compat
-      && DECL_FILE_SCOPE_P (newdecl)
-      && !DECL_EXTERNAL (newdecl)
-      && !DECL_EXTERNAL (olddecl))
-    warned |= warning_at (DECL_SOURCE_LOCATION (newdecl),
-                  OPT_Wc___compat,
-                  ("duplicate declaration of %qD is "
-                   "invalid in C++"),
-                  newdecl);
+	  && DECL_FILE_SCOPE_P (newdecl)
+	  && !DECL_EXTERNAL (newdecl)
+	  && !DECL_EXTERNAL (olddecl))
+	warned |= warning_at (DECL_SOURCE_LOCATION (newdecl),
+			      OPT_Wc___compat,
+			      ("duplicate declaration of %qD is "
+			       "invalid in C++"),
+			      newdecl);
     }
 
   /* warnings */
@@ -2079,70 +2078,70 @@
       && DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl))
     {
       warned |= warning (0, "redeclaration of %q+D with different visibility "
-             "(old visibility preserved)", newdecl);
+			 "(old visibility preserved)", newdecl);
     }
 
   if (TREE_CODE (newdecl) == FUNCTION_DECL)
     {
       /* Diagnose inline __attribute__ ((noinline)) which is silly.  */
       if (DECL_DECLARED_INLINE_P (newdecl)
-      && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
-    {
-      warned |= warning (OPT_Wattributes,
-                 "inline declaration of %qD follows "
-                 "declaration with attribute noinline", newdecl);
-    }
+	  && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
+	{
+	  warned |= warning (OPT_Wattributes,
+			     "inline declaration of %qD follows "
+			     "declaration with attribute noinline", newdecl);
+	}
       else if (DECL_DECLARED_INLINE_P (olddecl)
-           && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
-    {
-      warned |= warning (OPT_Wattributes,
-                 "declaration of %q+D with attribute "
-                 "noinline follows inline declaration ", newdecl);
-    }
+	       && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
+	{
+	  warned |= warning (OPT_Wattributes,
+			     "declaration of %q+D with attribute "
+			     "noinline follows inline declaration ", newdecl);
+	}
     }
   else /* PARM_DECL, VAR_DECL */
     {
       /* Redeclaration of a parameter is a constraint violation (this is
-     not explicitly stated, but follows from C99 6.7p3 [no more than
-     one declaration of the same identifier with no linkage in the
-     same scope, except type tags] and 6.2.2p6 [parameters have no
-     linkage]).  We must check for a forward parameter declaration,
-     indicated by TREE_ASM_WRITTEN on the old declaration - this is
-     an extension, the mandatory diagnostic for which is handled by
-     mark_forward_parm_decls.  */
+	 not explicitly stated, but follows from C99 6.7p3 [no more than
+	 one declaration of the same identifier with no linkage in the
+	 same scope, except type tags] and 6.2.2p6 [parameters have no
+	 linkage]).  We must check for a forward parameter declaration,
+	 indicated by TREE_ASM_WRITTEN on the old declaration - this is
+	 an extension, the mandatory diagnostic for which is handled by
+	 mark_forward_parm_decls.  */
 
       if (TREE_CODE (newdecl) == PARM_DECL
-      && (!TREE_ASM_WRITTEN (olddecl) || TREE_ASM_WRITTEN (newdecl)))
-    {
-      error ("redefinition of parameter %q+D", newdecl);
-      locate_old_decl (olddecl);
-      return false;
-    }
+	  && (!TREE_ASM_WRITTEN (olddecl) || TREE_ASM_WRITTEN (newdecl)))
+	{
+	  error ("redefinition of parameter %q+D", newdecl);
+	  locate_old_decl (olddecl);
+	  return false;
+	}
     }
 
   /* Optional warning for completely redundant decls.  */
   if (!warned && !pedwarned
       && warn_redundant_decls
       /* Don't warn about a function declaration followed by a
-     definition.  */
+	 definition.  */
       && !(TREE_CODE (newdecl) == FUNCTION_DECL
-       && DECL_INITIAL (newdecl) && !DECL_INITIAL (olddecl))
+	   && DECL_INITIAL (newdecl) && !DECL_INITIAL (olddecl))
       /* Don't warn about redundant redeclarations of builtins.  */
       && !(TREE_CODE (newdecl) == FUNCTION_DECL
-       && !DECL_BUILT_IN (newdecl)
-       && DECL_BUILT_IN (olddecl)
-       && !C_DECL_DECLARED_BUILTIN (olddecl))
+	   && !DECL_BUILT_IN (newdecl)
+	   && DECL_BUILT_IN (olddecl)
+	   && !C_DECL_DECLARED_BUILTIN (olddecl))
       /* Don't warn about an extern followed by a definition.  */
       && !(DECL_EXTERNAL (olddecl) && !DECL_EXTERNAL (newdecl))
       /* Don't warn about forward parameter decls.  */
       && !(TREE_CODE (newdecl) == PARM_DECL
-       && TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl))
+	   && TREE_ASM_WRITTEN (olddecl) && !TREE_ASM_WRITTEN (newdecl))
       /* Don't warn about a variable definition following a declaration.  */
       && !(TREE_CODE (newdecl) == VAR_DECL
-       && DECL_INITIAL (newdecl) && !DECL_INITIAL (olddecl)))
+	   && DECL_INITIAL (newdecl) && !DECL_INITIAL (olddecl)))
     {
       warned = warning (OPT_Wredundant_decls, "redundant redeclaration of %q+D",
-            newdecl);
+			newdecl);
     }
 
   /* Report location of previous decl/defn.  */
@@ -2163,7 +2162,7 @@
 merge_decls (tree newdecl, tree olddecl, tree newtype, tree oldtype)
 {
   bool new_is_definition = (TREE_CODE (newdecl) == FUNCTION_DECL
-                && DECL_INITIAL (newdecl) != 0);
+			    && DECL_INITIAL (newdecl) != 0);
   bool new_is_prototype = (TREE_CODE (newdecl) == FUNCTION_DECL
 			   && prototype_p (TREE_TYPE (newdecl)));
   bool old_is_prototype = (TREE_CODE (olddecl) == FUNCTION_DECL
@@ -2179,8 +2178,8 @@
       struct c_binding *b, **here;
 
       for (here = &current_scope->bindings; *here; here = &(*here)->prev)
-    if ((*here)->decl == olddecl)
-      goto found;
+	if ((*here)->decl == olddecl)
+	  goto found;
       gcc_unreachable ();
 
     found:
@@ -2204,11 +2203,11 @@
   if (!comptypes (oldtype, TREE_TYPE (newdecl)))
     {
       if (TREE_TYPE (newdecl) != error_mark_node)
-    layout_type (TREE_TYPE (newdecl));
+	layout_type (TREE_TYPE (newdecl));
       if (TREE_CODE (newdecl) != FUNCTION_DECL
-      && TREE_CODE (newdecl) != TYPE_DECL
-      && TREE_CODE (newdecl) != CONST_DECL)
-    layout_decl (newdecl, 0);
+	  && TREE_CODE (newdecl) != TYPE_DECL
+	  && TREE_CODE (newdecl) != CONST_DECL)
+	layout_decl (newdecl, 0);
     }
   else
     {
@@ -2217,10 +2216,10 @@
       DECL_SIZE_UNIT (newdecl) = DECL_SIZE_UNIT (olddecl);
       DECL_MODE (newdecl) = DECL_MODE (olddecl);
       if (DECL_ALIGN (olddecl) > DECL_ALIGN (newdecl))
-    {
-      DECL_ALIGN (newdecl) = DECL_ALIGN (olddecl);
-      DECL_USER_ALIGN (newdecl) |= DECL_USER_ALIGN (olddecl);
-    }
+	{
+	  DECL_ALIGN (newdecl) = DECL_ALIGN (olddecl);
+	  DECL_USER_ALIGN (newdecl) |= DECL_USER_ALIGN (olddecl);
+	}
     }
 
   /* Keep the old rtl since we can safely use it.  */
@@ -2247,12 +2246,12 @@
       && !DECL_IN_SYSTEM_HEADER (newdecl) )
     DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
   else if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl), TS_DECL_WITH_VIS)
-       && DECL_IN_SYSTEM_HEADER (newdecl)
-       && !DECL_IN_SYSTEM_HEADER (olddecl))
+	   && DECL_IN_SYSTEM_HEADER (newdecl)
+	   && !DECL_IN_SYSTEM_HEADER (olddecl))
     DECL_SOURCE_LOCATION (olddecl) = DECL_SOURCE_LOCATION (newdecl);
   else if ((DECL_INITIAL (newdecl) == 0 && DECL_INITIAL (olddecl) != 0)
-       || (old_is_prototype && !new_is_prototype
-           && !C_DECL_BUILTIN_PROTOTYPE (olddecl)))
+	   || (old_is_prototype && !new_is_prototype
+	       && !C_DECL_BUILTIN_PROTOTYPE (olddecl)))
     DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
 
   /* Merge the initialization information.  */
@@ -2269,52 +2268,52 @@
   if (CODE_CONTAINS_STRUCT (TREE_CODE (olddecl), TS_DECL_WITH_VIS))
     {
       /* Merge the section attribute.
-     We want to issue an error if the sections conflict but that
-     must be done later in decl_attributes since we are called
-     before attributes are assigned.  */
+	 We want to issue an error if the sections conflict but that
+	 must be done later in decl_attributes since we are called
+	 before attributes are assigned.  */
       if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
-    DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
+	DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
 
       /* Copy the assembler name.
-     Currently, it can only be defined in the prototype.  */
+	 Currently, it can only be defined in the prototype.  */
       COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
 
       /* Use visibility of whichever declaration had it specified */
       if (DECL_VISIBILITY_SPECIFIED (olddecl))
-    {
-      DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl);
-      DECL_VISIBILITY_SPECIFIED (newdecl) = 1;
-    }
+	{
+	  DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl);
+	  DECL_VISIBILITY_SPECIFIED (newdecl) = 1;
+	}
 
       if (TREE_CODE (newdecl) == FUNCTION_DECL)
-    {
-      DECL_STATIC_CONSTRUCTOR(newdecl) |= DECL_STATIC_CONSTRUCTOR(olddecl);
-      DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
-      DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
-      DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
-        |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
-      TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
-      DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl);
-      DECL_IS_OPERATOR_NEW (newdecl) |= DECL_IS_OPERATOR_NEW (olddecl);
-      TREE_READONLY (newdecl) |= TREE_READONLY (olddecl);
-      DECL_PURE_P (newdecl) |= DECL_PURE_P (olddecl);
-      DECL_IS_NOVOPS (newdecl) |= DECL_IS_NOVOPS (olddecl);
-    }
+	{
+	  DECL_STATIC_CONSTRUCTOR(newdecl) |= DECL_STATIC_CONSTRUCTOR(olddecl);
+	  DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
+	  DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
+	  DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
+	    |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
+	  TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
+	  DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl);
+	  DECL_IS_OPERATOR_NEW (newdecl) |= DECL_IS_OPERATOR_NEW (olddecl);
+	  TREE_READONLY (newdecl) |= TREE_READONLY (olddecl);
+	  DECL_PURE_P (newdecl) |= DECL_PURE_P (olddecl);
+	  DECL_IS_NOVOPS (newdecl) |= DECL_IS_NOVOPS (olddecl);
+	}
 
       /* Merge the storage class information.  */
       merge_weak (newdecl, olddecl);
 
       /* For functions, static overrides non-static.  */
       if (TREE_CODE (newdecl) == FUNCTION_DECL)
-    {
-      TREE_PUBLIC (newdecl) &= TREE_PUBLIC (olddecl);
-      /* This is since we don't automatically
-         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))
-        TREE_PUBLIC (DECL_NAME (olddecl)) = 0;
-    }
+	{
+	  TREE_PUBLIC (newdecl) &= TREE_PUBLIC (olddecl);
+	  /* This is since we don't automatically
+	     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))
+	    TREE_PUBLIC (DECL_NAME (olddecl)) = 0;
+	}
     }
 
   /* In c99, 'extern' declaration before (or after) 'inline' means this
@@ -2323,10 +2322,10 @@
   if (TREE_CODE (newdecl) == FUNCTION_DECL
       && !flag_gnu89_inline
       && (DECL_DECLARED_INLINE_P (newdecl)
-      || DECL_DECLARED_INLINE_P (olddecl))
+	  || DECL_DECLARED_INLINE_P (olddecl))
       && (!DECL_DECLARED_INLINE_P (newdecl)
-      || !DECL_DECLARED_INLINE_P (olddecl)
-      || !DECL_EXTERNAL (olddecl))
+	  || !DECL_DECLARED_INLINE_P (olddecl)
+	  || !DECL_EXTERNAL (olddecl))
       && DECL_EXTERNAL (newdecl)
       && !lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (newdecl))
       && !current_function_decl)
@@ -2340,10 +2339,10 @@
       /* An extern decl does not override previous storage class.  */
       TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
       if (!DECL_EXTERNAL (newdecl))
-    {
-      DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
-      DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
-    }
+	{
+	  DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
+	  DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
+	}
     }
   else
     {
@@ -2354,53 +2353,53 @@
   if (TREE_CODE (newdecl) == FUNCTION_DECL)
     {
       /* If we're redefining a function previously defined as extern
-     inline, make sure we emit debug info for the inline before we
-     throw it away, in case it was inlined into a function that
-     hasn't been written out yet.  */
+	 inline, make sure we emit debug info for the inline before we
+	 throw it away, in case it was inlined into a function that
+	 hasn't been written out yet.  */
       if (new_is_definition && DECL_INITIAL (olddecl))
-    /* The new defn must not be inline.  */
-    DECL_UNINLINABLE (newdecl) = 1;
+	/* The new defn must not be inline.  */
+	DECL_UNINLINABLE (newdecl) = 1;
       else
-    {
-      /* If either decl says `inline', this fn is inline, unless
-         its definition was passed already.  */
-      if (DECL_DECLARED_INLINE_P (newdecl)
-          || DECL_DECLARED_INLINE_P (olddecl))
-        DECL_DECLARED_INLINE_P (newdecl) = 1;
-
-      DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
-        = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
-
-      DECL_DISREGARD_INLINE_LIMITS (newdecl)
-        = DECL_DISREGARD_INLINE_LIMITS (olddecl)
-        = (DECL_DISREGARD_INLINE_LIMITS (newdecl)
-           || DECL_DISREGARD_INLINE_LIMITS (olddecl));
-    }
+	{
+	  /* If either decl says `inline', this fn is inline, unless
+	     its definition was passed already.  */
+	  if (DECL_DECLARED_INLINE_P (newdecl)
+	      || DECL_DECLARED_INLINE_P (olddecl))
+	    DECL_DECLARED_INLINE_P (newdecl) = 1;
+
+	  DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
+	    = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
+
+	  DECL_DISREGARD_INLINE_LIMITS (newdecl)
+	    = DECL_DISREGARD_INLINE_LIMITS (olddecl)
+	    = (DECL_DISREGARD_INLINE_LIMITS (newdecl)
+	       || DECL_DISREGARD_INLINE_LIMITS (olddecl));
+	}
 
       if (DECL_BUILT_IN (olddecl))
-    {
-      /* If redeclaring a builtin function, it stays built in.
-         But it gets tagged as having been declared.  */
-      DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
-      DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
-      C_DECL_DECLARED_BUILTIN (newdecl) = 1;
-      if (new_is_prototype)
-        C_DECL_BUILTIN_PROTOTYPE (newdecl) = 0;
-      else
-        C_DECL_BUILTIN_PROTOTYPE (newdecl)
-          = C_DECL_BUILTIN_PROTOTYPE (olddecl);
-    }
+	{
+	  /* If redeclaring a builtin function, it stays built in.
+	     But it gets tagged as having been declared.  */
+	  DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
+	  DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
+	  C_DECL_DECLARED_BUILTIN (newdecl) = 1;
+	  if (new_is_prototype)
+	    C_DECL_BUILTIN_PROTOTYPE (newdecl) = 0;
+	  else
+	    C_DECL_BUILTIN_PROTOTYPE (newdecl)
+	      = C_DECL_BUILTIN_PROTOTYPE (olddecl);
+	}
 
       /* Preserve function specific target and optimization options */
       if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl)
-      && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl))
-    DECL_FUNCTION_SPECIFIC_TARGET (newdecl)
-      = DECL_FUNCTION_SPECIFIC_TARGET (olddecl);
+	  && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl))
+	DECL_FUNCTION_SPECIFIC_TARGET (newdecl)
+	  = DECL_FUNCTION_SPECIFIC_TARGET (olddecl);
 
       if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl)
-      && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl))
-    DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl)
-      = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl);
+	  && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl))
+	DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl)
+	  = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl);
 
       /* Also preserve various other info from the definition.  */
       if (!new_is_definition)
@@ -2446,8 +2445,8 @@
       olddecl_arguments = DECL_ARGUMENTS (olddecl);
 
     memcpy ((char *) olddecl + sizeof (struct tree_common),
-        (char *) newdecl + sizeof (struct tree_common),
-        sizeof (struct tree_decl_common) - sizeof (struct tree_common));
+	    (char *) newdecl + sizeof (struct tree_common),
+	    sizeof (struct tree_decl_common) - sizeof (struct tree_common));
     switch (TREE_CODE (olddecl))
       {
       case FUNCTION_DECL:
@@ -2458,16 +2457,16 @@
       case RESULT_DECL:
       case CONST_DECL:
       case TYPE_DECL:
-    memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
-        (char *) newdecl + sizeof (struct tree_decl_common),
-        tree_code_size (TREE_CODE (olddecl)) - sizeof (struct tree_decl_common));
-    break;
+	memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
+		(char *) newdecl + sizeof (struct tree_decl_common),
+		tree_code_size (TREE_CODE (olddecl)) - sizeof (struct tree_decl_common));
+	break;
 
       default:
 
-    memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
-        (char *) newdecl + sizeof (struct tree_decl_common),
-        sizeof (struct tree_decl_non_common) - sizeof (struct tree_decl_common));
+	memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
+		(char *) newdecl + sizeof (struct tree_decl_common),
+		sizeof (struct tree_decl_non_common) - sizeof (struct tree_decl_common));
       }
     DECL_UID (olddecl) = olddecl_uid;
     DECL_CONTEXT (olddecl) = olddecl_context;
@@ -2480,8 +2479,8 @@
      flags and attributes.  */
   if (DECL_RTL_SET_P (olddecl)
       && (TREE_CODE (olddecl) == FUNCTION_DECL
-      || (TREE_CODE (olddecl) == VAR_DECL
-          && TREE_STATIC (olddecl))))
+	  || (TREE_CODE (olddecl) == VAR_DECL
+	      && TREE_STATIC (olddecl))))
     make_decl_rtl (olddecl);
 
   /* If we changed a function from DECL_EXTERNAL to !DECL_EXTERNAL,
@@ -2534,35 +2533,35 @@
   for (b = I_SYMBOL_BINDING (DECL_NAME (new_decl)); b; b = b->shadowed)
     if (b->decl && b->decl != new_decl && !b->invisible)
       {
-    tree old_decl = b->decl;
-
-    if (old_decl == error_mark_node)
-      {
-        warning (OPT_Wshadow, "declaration of %q+D shadows previous "
-             "non-variable", new_decl);
-        break;
-      }
-    else if (TREE_CODE (old_decl) == PARM_DECL)
-      warning (OPT_Wshadow, "declaration of %q+D shadows a parameter",
-           new_decl);
-    else if (DECL_FILE_SCOPE_P (old_decl))
-      warning (OPT_Wshadow, "declaration of %q+D shadows a global "
-           "declaration", new_decl);
-    else if (TREE_CODE (old_decl) == FUNCTION_DECL
-         && DECL_BUILT_IN (old_decl))
-      {
-        warning (OPT_Wshadow, "declaration of %q+D shadows "
-             "a built-in function", new_decl);
-        break;
-      }
-    else
-      warning (OPT_Wshadow, "declaration of %q+D shadows a previous local",
-           new_decl);
-
-    warning_at (DECL_SOURCE_LOCATION (old_decl), OPT_Wshadow,
-            "shadowed declaration is here");
-
-    break;
+	tree old_decl = b->decl;
+
+	if (old_decl == error_mark_node)
+	  {
+	    warning (OPT_Wshadow, "declaration of %q+D shadows previous "
+		     "non-variable", new_decl);
+	    break;
+	  }
+	else if (TREE_CODE (old_decl) == PARM_DECL)
+	  warning (OPT_Wshadow, "declaration of %q+D shadows a parameter",
+		   new_decl);
+	else if (DECL_FILE_SCOPE_P (old_decl))
+	  warning (OPT_Wshadow, "declaration of %q+D shadows a global "
+		   "declaration", new_decl);
+	else if (TREE_CODE (old_decl) == FUNCTION_DECL
+		 && DECL_BUILT_IN (old_decl))
+	  {
+	    warning (OPT_Wshadow, "declaration of %q+D shadows "
+		     "a built-in function", new_decl);
+	    break;
+	  }
+	else
+	  warning (OPT_Wshadow, "declaration of %q+D shadows a previous local",
+		   new_decl);
+
+	warning_at (DECL_SOURCE_LOCATION (old_decl), OPT_Wshadow,
+		    "shadowed declaration is here");
+
+	break;
       }
 }
 
@@ -2588,14 +2587,14 @@
      unless they have initializers (which generate code).  */
   if (current_function_decl
       && ((TREE_CODE (x) != FUNCTION_DECL && TREE_CODE (x) != VAR_DECL)
-      || DECL_INITIAL (x) || !DECL_EXTERNAL (x)))
+	  || DECL_INITIAL (x) || !DECL_EXTERNAL (x)))
     DECL_CONTEXT (x) = current_function_decl;
 
   /* Anonymous decls are just inserted in the scope.  */
   if (!name)
     {
       bind (name, x, scope, /*invisible=*/false, /*nested=*/false,
-        locus);
+	    locus);
       return x;
     }
 
@@ -2614,49 +2613,49 @@
       tree visdecl = b->decl;
       tree vistype = TREE_TYPE (visdecl);
       if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
-      && COMPLETE_TYPE_P (TREE_TYPE (x)))
-    b->inner_comp = false;
+	  && COMPLETE_TYPE_P (TREE_TYPE (x)))
+	b->inner_comp = false;
       b_use = b;
       b_ext = b;
       /* If this is an external linkage declaration, we should check
-     for compatibility with the type in the external scope before
-     setting the type at this scope based on the visible
-     information only.  */
+	 for compatibility with the type in the external scope before
+	 setting the type at this scope based on the visible
+	 information only.  */
       if (TREE_PUBLIC (x) && TREE_PUBLIC (visdecl))
-    {
-      while (b_ext && !B_IN_EXTERNAL_SCOPE (b_ext))
-        b_ext = b_ext->shadowed;
-      if (b_ext)
-        {
-          b_use = b_ext;
-          if (b_use->u.type)
-        TREE_TYPE (b_use->decl) = b_use->u.type;
-        }
-    }
+	{
+	  while (b_ext && !B_IN_EXTERNAL_SCOPE (b_ext))
+	    b_ext = b_ext->shadowed;
+	  if (b_ext)
+	    {
+	      b_use = b_ext;
+	      if (b_use->u.type)
+		TREE_TYPE (b_use->decl) = b_use->u.type;
+	    }
+	}
       if (duplicate_decls (x, b_use->decl))
-    {
-      if (b_use != b)
-        {
-          /* Save the updated type in the external scope and
-         restore the proper type for this scope.  */
-          tree thistype;
-          if (comptypes (vistype, type))
-        thistype = composite_type (vistype, type);
-          else
-        thistype = TREE_TYPE (b_use->decl);
-          b_use->u.type = TREE_TYPE (b_use->decl);
-          if (TREE_CODE (b_use->decl) == FUNCTION_DECL
-          && DECL_BUILT_IN (b_use->decl))
-        thistype
-          = build_type_attribute_variant (thistype,
-                          TYPE_ATTRIBUTES
-                          (b_use->u.type));
-          TREE_TYPE (b_use->decl) = thistype;
-        }
-      return b_use->decl;
-    }
+	{
+	  if (b_use != b)
+	    {
+	      /* Save the updated type in the external scope and
+		 restore the proper type for this scope.  */
+	      tree thistype;
+	      if (comptypes (vistype, type))
+		thistype = composite_type (vistype, type);
+	      else
+		thistype = TREE_TYPE (b_use->decl);
+	      b_use->u.type = TREE_TYPE (b_use->decl);
+	      if (TREE_CODE (b_use->decl) == FUNCTION_DECL
+		  && DECL_BUILT_IN (b_use->decl))
+		thistype
+		  = build_type_attribute_variant (thistype,
+						  TYPE_ATTRIBUTES
+						  (b_use->u.type));
+	      TREE_TYPE (b_use->decl) = thistype;
+	    }
+	  return b_use->decl;
+	}
       else
-    goto skip_external_and_shadow_checks;
+	goto skip_external_and_shadow_checks;
     }
 
   /* All declarations with external linkage, and all external
@@ -2678,106 +2677,106 @@
       tree visdecl = 0;
       bool type_saved = false;
       if (b && !B_IN_EXTERNAL_SCOPE (b)
-      && (TREE_CODE (b->decl) == FUNCTION_DECL
-          || TREE_CODE (b->decl) == VAR_DECL)
-      && DECL_FILE_SCOPE_P (b->decl))
-    {
-      visdecl = b->decl;
-      vistype = TREE_TYPE (visdecl);
-    }
+	  && (TREE_CODE (b->decl) == FUNCTION_DECL
+	      || TREE_CODE (b->decl) == VAR_DECL)
+	  && DECL_FILE_SCOPE_P (b->decl))
+	{
+	  visdecl = b->decl;
+	  vistype = TREE_TYPE (visdecl);
+	}
       if (scope != file_scope
-      && !DECL_IN_SYSTEM_HEADER (x))
-    warning (OPT_Wnested_externs, "nested extern declaration of %qD", x);
+	  && !DECL_IN_SYSTEM_HEADER (x))
+	warning (OPT_Wnested_externs, "nested extern declaration of %qD", x);
 
       while (b && !B_IN_EXTERNAL_SCOPE (b))
-    {
-      /* If this decl might be modified, save its type.  This is
-         done here rather than when the decl is first bound
-         because the type may change after first binding, through
-         being completed or through attributes being added.  If we
-         encounter multiple such decls, only the first should have
-         its type saved; the others will already have had their
-         proper types saved and the types will not have changed as
-         their scopes will not have been re-entered.  */
-      if (DECL_P (b->decl) && DECL_FILE_SCOPE_P (b->decl) && !type_saved)
-        {
-          b->u.type = TREE_TYPE (b->decl);
-          type_saved = true;
-        }
-      if (B_IN_FILE_SCOPE (b)
-          && TREE_CODE (b->decl) == VAR_DECL
-          && TREE_STATIC (b->decl)
-          && TREE_CODE (TREE_TYPE (b->decl)) == ARRAY_TYPE
-          && !TYPE_DOMAIN (TREE_TYPE (b->decl))
-          && TREE_CODE (type) == ARRAY_TYPE
-          && TYPE_DOMAIN (type)
-          && TYPE_MAX_VALUE (TYPE_DOMAIN (type))
-          && !integer_zerop (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
-        {
-          /* Array type completed in inner scope, which should be
-         diagnosed if the completion does not have size 1 and
-         it does not get completed in the file scope.  */
-          b->inner_comp = true;
-        }
-      b = b->shadowed;
-    }
+	{
+	  /* If this decl might be modified, save its type.  This is
+	     done here rather than when the decl is first bound
+	     because the type may change after first binding, through
+	     being completed or through attributes being added.  If we
+	     encounter multiple such decls, only the first should have
+	     its type saved; the others will already have had their
+	     proper types saved and the types will not have changed as
+	     their scopes will not have been re-entered.  */
+	  if (DECL_P (b->decl) && DECL_FILE_SCOPE_P (b->decl) && !type_saved)
+	    {
+	      b->u.type = TREE_TYPE (b->decl);
+	      type_saved = true;
+	    }
+	  if (B_IN_FILE_SCOPE (b)
+	      && TREE_CODE (b->decl) == VAR_DECL
+	      && TREE_STATIC (b->decl)
+	      && TREE_CODE (TREE_TYPE (b->decl)) == ARRAY_TYPE
+	      && !TYPE_DOMAIN (TREE_TYPE (b->decl))
+	      && TREE_CODE (type) == ARRAY_TYPE
+	      && TYPE_DOMAIN (type)
+	      && TYPE_MAX_VALUE (TYPE_DOMAIN (type))
+	      && !integer_zerop (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
+	    {
+	      /* Array type completed in inner scope, which should be
+		 diagnosed if the completion does not have size 1 and
+		 it does not get completed in the file scope.  */
+	      b->inner_comp = true;
+	    }
+	  b = b->shadowed;
+	}
 
       /* If a matching external declaration has been found, set its
-     type to the composite of all the types of that declaration.
-     After the consistency checks, it will be reset to the
-     composite of the visible types only.  */
+	 type to the composite of all the types of that declaration.
+	 After the consistency checks, it will be reset to the
+	 composite of the visible types only.  */
       if (b && (TREE_PUBLIC (x) || same_translation_unit_p (x, b->decl))
-      && b->u.type)
-    TREE_TYPE (b->decl) = b->u.type;
+	  && b->u.type)
+	TREE_TYPE (b->decl) = b->u.type;
 
       /* The point of the same_translation_unit_p check here is,
-     we want to detect a duplicate decl for a construct like
-     foo() { extern bar(); } ... static bar();  but not if
-     they are in different translation units.  In any case,
-     the static does not go in the externals scope.  */
+	 we want to detect a duplicate decl for a construct like
+	 foo() { extern bar(); } ... static bar();  but not if
+	 they are in different translation units.  In any case,
+	 the static does not go in the externals scope.  */
       if (b
-      && (TREE_PUBLIC (x) || same_translation_unit_p (x, b->decl))
-      && duplicate_decls (x, b->decl))
-    {
-      tree thistype;
-      if (vistype)
-        {
-          if (comptypes (vistype, type))
-        thistype = composite_type (vistype, type);
-          else
-        thistype = TREE_TYPE (b->decl);
-        }
-      else
-        thistype = type;
-      b->u.type = TREE_TYPE (b->decl);
-      if (TREE_CODE (b->decl) == FUNCTION_DECL && DECL_BUILT_IN (b->decl))
-        thistype
-          = build_type_attribute_variant (thistype,
-                          TYPE_ATTRIBUTES (b->u.type));
-      TREE_TYPE (b->decl) = thistype;
-      bind (name, b->decl, scope, /*invisible=*/false, /*nested=*/true,
-        locus);
-      return b->decl;
-    }
+	  && (TREE_PUBLIC (x) || same_translation_unit_p (x, b->decl))
+	  && duplicate_decls (x, b->decl))
+	{
+	  tree thistype;
+	  if (vistype)
+	    {
+	      if (comptypes (vistype, type))
+		thistype = composite_type (vistype, type);
+	      else
+		thistype = TREE_TYPE (b->decl);
+	    }
+	  else
+	    thistype = type;
+	  b->u.type = TREE_TYPE (b->decl);
+	  if (TREE_CODE (b->decl) == FUNCTION_DECL && DECL_BUILT_IN (b->decl))
+	    thistype
+	      = build_type_attribute_variant (thistype,
+					      TYPE_ATTRIBUTES (b->u.type));
+	  TREE_TYPE (b->decl) = thistype;
+	  bind (name, b->decl, scope, /*invisible=*/false, /*nested=*/true,
+		locus);
+	  return b->decl;
+	}
       else if (TREE_PUBLIC (x))
-    {
-      if (visdecl && !b && duplicate_decls (x, visdecl))
-        {
-          /* An external declaration at block scope referring to a
-         visible entity with internal linkage.  The composite
-         type will already be correct for this scope, so we
-         just need to fall through to make the declaration in
-         this scope.  */
-          nested = true;
-          x = visdecl;
-        }
-      else
-        {
-          bind (name, x, external_scope, /*invisible=*/true,
-            /*nested=*/false, locus);
-          nested = true;
-        }
-    }
+	{
+	  if (visdecl && !b && duplicate_decls (x, visdecl))
+	    {
+	      /* An external declaration at block scope referring to a
+		 visible entity with internal linkage.  The composite
+		 type will already be correct for this scope, so we
+		 just need to fall through to make the declaration in
+		 this scope.  */
+	      nested = true;
+	      x = visdecl;
+	    }
+	  else
+	    {
+	      bind (name, x, external_scope, /*invisible=*/true,
+		    /*nested=*/false, locus);
+	      nested = true;
+	    }
+	}
     }
 
   if (TREE_CODE (x) != PARM_DECL)
@@ -2804,16 +2803,16 @@
       tree element = TREE_TYPE (x);
 
       while (TREE_CODE (element) == ARRAY_TYPE)
-    element = TREE_TYPE (element);
+	element = TREE_TYPE (element);
       element = TYPE_MAIN_VARIANT (element);
 
       if ((TREE_CODE (element) == RECORD_TYPE
-       || TREE_CODE (element) == UNION_TYPE)
-      && (TREE_CODE (x) != TYPE_DECL
-          || TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE)
-      && !COMPLETE_TYPE_P (element))
-    C_TYPE_INCOMPLETE_VARS (element)
-      = tree_cons (NULL_TREE, x, C_TYPE_INCOMPLETE_VARS (element));
+	   || TREE_CODE (element) == UNION_TYPE)
+	  && (TREE_CODE (x) != TYPE_DECL
+	      || TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE)
+	  && !COMPLETE_TYPE_P (element))
+	C_TYPE_INCOMPLETE_VARS (element)
+	  = tree_cons (NULL_TREE, x, C_TYPE_INCOMPLETE_VARS (element));
     }
   return x;
 }
@@ -2837,7 +2836,7 @@
   if (TREE_PUBLIC (x))
     {
       bind (name, x, external_scope, /*invisible=*/true, /*nested=*/false,
-        UNKNOWN_LOCATION);
+	    UNKNOWN_LOCATION);
       nested = true;
     }
   if (file_scope)
@@ -2854,13 +2853,13 @@
       bool warned;
 
       if (flag_isoc99)
-    warned = pedwarn (input_location, OPT_Wimplicit_function_declaration,
-              "implicit declaration of function %qE", id);
+	warned = pedwarn (input_location, OPT_Wimplicit_function_declaration,
+			  "implicit declaration of function %qE", id);
       else
-    warned = warning (OPT_Wimplicit_function_declaration,
-              G_("implicit declaration of function %qE"), id);
+	warned = warning (OPT_Wimplicit_function_declaration,
+			  G_("implicit declaration of function %qE"), id);
       if (olddecl && warned)
-    locate_old_decl (olddecl);
+	locate_old_decl (olddecl);
     }
 }
 
@@ -2882,70 +2881,70 @@
   for (b = I_SYMBOL_BINDING (functionid); b; b = b->shadowed)
     {
       if (B_IN_SCOPE (b, external_scope))
-    {
-      decl = b->decl;
-      break;
-    }
+	{
+	  decl = b->decl;
+	  break;
+	}
     }
 
   if (decl)
     {
       if (decl == error_mark_node)
-    return decl;
+	return decl;
 
       /* FIXME: Objective-C has weird not-really-builtin functions
-     which are supposed to be visible automatically.  They wind up
-     in the external scope because they're pushed before the file
-     scope gets created.  Catch this here and rebind them into the
-     file scope.  */
+	 which are supposed to be visible automatically.  They wind up
+	 in the external scope because they're pushed before the file
+	 scope gets created.  Catch this here and rebind them into the
+	 file scope.  */
       if (!DECL_BUILT_IN (decl) && DECL_IS_BUILTIN (decl))
-    {
-      bind (functionid, decl, file_scope,
-        /*invisible=*/false, /*nested=*/true,
-        DECL_SOURCE_LOCATION (decl));
-      return decl;
-    }
+	{
+	  bind (functionid, decl, file_scope,
+		/*invisible=*/false, /*nested=*/true,
+		DECL_SOURCE_LOCATION (decl));
+	  return decl;
+	}
       else
-    {
-      tree newtype = default_function_type;
-      if (b->u.type)
-        TREE_TYPE (decl) = b->u.type;
-      /* Implicit declaration of a function already declared
-         (somehow) in a different scope, or as a built-in.
-         If this is the first time this has happened, warn;
-         then recycle the old declaration but with the new type.  */
-      if (!C_DECL_IMPLICIT (decl))
-        {
-          implicit_decl_warning (functionid, decl);
-          C_DECL_IMPLICIT (decl) = 1;
-        }
-      if (DECL_BUILT_IN (decl))
-        {
-          newtype = build_type_attribute_variant (newtype,
-                              TYPE_ATTRIBUTES
-                              (TREE_TYPE (decl)));
-          if (!comptypes (newtype, TREE_TYPE (decl)))
-        {
-          warning_at (loc, 0, "incompatible implicit declaration of "
-                  "built-in function %qD", decl);
-          newtype = TREE_TYPE (decl);
-        }
-        }
-      else
-        {
-          if (!comptypes (newtype, TREE_TYPE (decl)))
-        {
-          error_at (loc, "incompatible implicit declaration of function %qD", decl);
-          locate_old_decl (decl);
-        }
-        }
-      b->u.type = TREE_TYPE (decl);
-      TREE_TYPE (decl) = newtype;
-      bind (functionid, decl, current_scope,
-        /*invisible=*/false, /*nested=*/true,
-        DECL_SOURCE_LOCATION (decl));
-      return decl;
-    }
+	{
+	  tree newtype = default_function_type;
+	  if (b->u.type)
+	    TREE_TYPE (decl) = b->u.type;
+	  /* Implicit declaration of a function already declared
+	     (somehow) in a different scope, or as a built-in.
+	     If this is the first time this has happened, warn;
+	     then recycle the old declaration but with the new type.  */
+	  if (!C_DECL_IMPLICIT (decl))
+	    {
+	      implicit_decl_warning (functionid, decl);
+	      C_DECL_IMPLICIT (decl) = 1;
+	    }
+	  if (DECL_BUILT_IN (decl))
+	    {
+	      newtype = build_type_attribute_variant (newtype,
+						      TYPE_ATTRIBUTES
+						      (TREE_TYPE (decl)));
+	      if (!comptypes (newtype, TREE_TYPE (decl)))
+		{
+		  warning_at (loc, 0, "incompatible implicit declaration of "
+			      "built-in function %qD", decl);
+		  newtype = TREE_TYPE (decl);
+		}
+	    }
+	  else
+	    {
+	      if (!comptypes (newtype, TREE_TYPE (decl)))
+		{
+		  error_at (loc, "incompatible implicit declaration of function %qD", decl);
+		  locate_old_decl (decl);
+		}
+	    }
+	  b->u.type = TREE_TYPE (decl);
+	  TREE_TYPE (decl) = newtype;
+	  bind (functionid, decl, current_scope,
+		/*invisible=*/false, /*nested=*/true,
+		DECL_SOURCE_LOCATION (decl));
+	  return decl;
+	}
     }
 
   /* Not seen before.  */
@@ -3008,11 +3007,11 @@
 	}
 
       /* If we are parsing old-style parameter decls, current_function_decl
-     will be nonnull but current_function_scope will be null.  */
+	 will be nonnull but current_function_scope will be null.  */
       scope = current_function_scope ? current_function_scope : current_scope;
     }
   bind (id, error_mark_node, scope, /*invisible=*/false, /*nested=*/false,
-    UNKNOWN_LOCATION);
+	UNKNOWN_LOCATION);
 }
 
 /* Subroutine of lookup_label, declare_label, define_label: construct a
@@ -3021,7 +3020,7 @@
 
 static tree
 make_label (location_t location, tree name, bool defining,
-        struct c_label_vars **p_label_vars)
+	    struct c_label_vars **p_label_vars)
 {
   tree label = build_decl (location, LABEL_DECL, name, void_type_node);
   struct c_label_vars *label_vars;
@@ -3061,13 +3060,13 @@
      using __label__.  */
   label = I_LABEL_DECL (name);
   if (label && (DECL_CONTEXT (label) == current_function_decl
-        || C_DECLARED_LABEL_FLAG (label)))
+		|| C_DECLARED_LABEL_FLAG (label)))
     {
       /* If the label has only been declared, update its apparent
-     location to point here, for better diagnostics if it
-     turns out not to have been defined.  */
+	 location to point here, for better diagnostics if it
+	 turns out not to have been defined.  */
       if (DECL_INITIAL (label) == NULL_TREE)
-    DECL_SOURCE_LOCATION (label) = input_location;
+	DECL_SOURCE_LOCATION (label) = input_location;
       return label;
     }
 
@@ -3088,10 +3087,10 @@
 {
   if (variably_modified_type_p (TREE_TYPE (decl), NULL_TREE))
     error_at (goto_loc,
-          "jump into scope of identifier with variably modified type");
+	      "jump into scope of identifier with variably modified type");
   else
     warning_at (goto_loc, OPT_Wjump_misses_init,
-        "jump skips variable initialization");
+		"jump skips variable initialization");
   inform (DECL_SOURCE_LOCATION (label), "label %qD defined here", label);
   inform (DECL_SOURCE_LOCATION (decl), "%qD declared here", decl);
 }
@@ -3214,7 +3213,7 @@
 	}
 
       /* We also need to warn about decls defined in any scopes
-     between the scope of the label and the scope of the goto.  */
+	 between the scope of the label and the scope of the goto.  */
       for (scope = label_vars->label_bindings.scope;
 	   scope != g->goto_bindings.scope;
 	   scope = scope->outer)
@@ -3235,11 +3234,11 @@
 	}
 
       if (g->goto_bindings.stmt_exprs > 0)
-    {
-      error_at (g->loc, "jump into statement expression");
-      inform (DECL_SOURCE_LOCATION (label), "label %qD defined here",
-          label);
-    }
+	{
+	  error_at (g->loc, "jump into statement expression");
+	  inform (DECL_SOURCE_LOCATION (label), "label %qD defined here",
+		  label);
+	}
     }
 
   /* Now that the label is defined, we will issue warnings about
@@ -3263,9 +3262,9 @@
 
   if (label
       && ((DECL_CONTEXT (label) == current_function_decl
-       && DECL_INITIAL (label) != 0)
-      || (DECL_CONTEXT (label) != current_function_decl
-          && C_DECLARED_LABEL_FLAG (label))))
+	   && DECL_INITIAL (label) != 0)
+	  || (DECL_CONTEXT (label) != current_function_decl
+	      && C_DECLARED_LABEL_FLAG (label))))
     {
       error_at (location, "duplicate label %qD", label);
       locate_old_decl (label);
@@ -3276,13 +3275,13 @@
       struct c_label_vars *label_vars = I_LABEL_BINDING (name)->u.label;
 
       /* The label has been used or declared already in this function,
-     but not defined.  Update its location to point to this
-     definition.  */
+	 but not defined.  Update its location to point to this
+	 definition.  */
       DECL_SOURCE_LOCATION (label) = location;
       set_spot_bindings (&label_vars->label_bindings, true);
 
       /* Issue warnings as required about any goto statements from
-     earlier in the function.  */
+	 earlier in the function.  */
       check_earlier_gotos (label, label_vars);
     }
   else
@@ -3298,8 +3297,8 @@
 
   if (!in_system_header && lookup_name (name))
     warning_at (location, OPT_Wtraditional,
-        "traditional C lacks a separate namespace "
-        "for labels, identifier %qE conflicts", name);
+		"traditional C lacks a separate namespace "
+		"for labels, identifier %qE conflicts", name);
 
   /* Mark label as having been defined.  */
   DECL_INITIAL (label) = error_mark_node;
@@ -3333,7 +3332,7 @@
 
 bool
 c_check_switch_jump_warnings (struct c_spot_bindings *switch_bindings,
-                  location_t switch_loc, location_t case_loc)
+			      location_t switch_loc, location_t case_loc)
 {
   bool saw_error;
   struct c_scope *scope;
@@ -3351,24 +3350,24 @@
 	continue;
 
       for (b = scope->bindings; b != NULL; b = b->prev)
-    {
-      if (decl_jump_unsafe (b->decl))
-        {
-          if (variably_modified_type_p (TREE_TYPE (b->decl), NULL_TREE))
-        {
-          saw_error = true;
-          error_at (case_loc,
-                ("switch jumps into scope of identifier with "
-                 "variably modified type"));
-        }
-          else
-        warning_at (case_loc, OPT_Wjump_misses_init,
-                "switch jumps over variable initialization");
-          inform (switch_loc, "switch starts here");
-          inform (DECL_SOURCE_LOCATION (b->decl), "%qD declared here",
-              b->decl);
-        }
-    }
+	{
+	  if (decl_jump_unsafe (b->decl))
+	    {
+	      if (variably_modified_type_p (TREE_TYPE (b->decl), NULL_TREE))
+		{
+		  saw_error = true;
+		  error_at (case_loc,
+			    ("switch jumps into scope of identifier with "
+			     "variably modified type"));
+		}
+	      else
+		warning_at (case_loc, OPT_Wjump_misses_init,
+			    "switch jumps over variable initialization");
+	      inform (switch_loc, "switch starts here");
+	      inform (DECL_SOURCE_LOCATION (b->decl), "%qD declared here",
+		      b->decl);
+	    }
+	}
     }
 
   if (switch_bindings->stmt_exprs > 0)
@@ -3392,7 +3391,7 @@
 
 static tree
 lookup_tag (enum tree_code code, tree name, int thislevel_only,
-        location_t *ploc)
+	    location_t *ploc)
 {
   struct c_binding *b = I_TAG_BINDING (name);
   int thislevel = 0;
@@ -3405,12 +3404,12 @@
   if (thislevel_only || TREE_CODE (b->decl) != code)
     {
       /* For our purposes, a tag in the external scope is the same as
-     a tag in the file scope.  (Primarily relevant to Objective-C
-     and its builtin structure tags, which get pushed before the
-     file scope is created.)  */
+	 a tag in the file scope.  (Primarily relevant to Objective-C
+	 and its builtin structure tags, which get pushed before the
+	 file scope is created.)  */
       if (B_IN_CURRENT_SCOPE (b)
-      || (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b)))
-    thislevel = 1;
+	  || (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b)))
+	thislevel = 1;
     }
 
   if (thislevel_only && !thislevel)
@@ -3423,11 +3422,11 @@
       pending_invalid_xref_location = input_location;
 
       /* If in the same binding level as a declaration as a tag
-     of a different type, this must not be allowed to
-     shadow that tag, so give the error immediately.
-     (For example, "struct foo; union foo;" is invalid.)  */
+	 of a different type, this must not be allowed to
+	 shadow that tag, so give the error immediately.
+	 (For example, "struct foo; union foo;" is invalid.)  */
       if (thislevel)
-    pending_xref_error ();
+	pending_xref_error ();
     }
 
   if (ploc != NULL)
@@ -3446,7 +3445,7 @@
 {
   if (pending_invalid_xref != 0)
     error_at (pending_invalid_xref_location, "%qE defined as wrong kind of tag",
-          pending_invalid_xref);
+	      pending_invalid_xref);
   pending_invalid_xref = 0;
 }
 
@@ -3515,7 +3514,7 @@
 
   /* Even in C99, which has a real boolean type.  */
   pushdecl (build_decl (UNKNOWN_LOCATION, TYPE_DECL, get_identifier ("_Bool"),
-            boolean_type_node));
+			boolean_type_node));
 
   input_location = save_loc;
 
@@ -3541,7 +3540,7 @@
   size_t length = strlen (name);
 
   type = build_array_type (char_type_node,
-               build_index_type (size_int (length)));
+			   build_index_type (size_int (length)));
   type = c_build_qualified_type (type, TYPE_QUAL_CONST);
 
   decl = build_decl (loc, VAR_DECL, id, type);
@@ -3570,7 +3569,7 @@
     {
       DECL_CONTEXT (decl) = current_function_decl;
       bind (id, decl, current_function_scope,
-        /*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION);
+	    /*invisible=*/false, /*nested=*/false, UNKNOWN_LOCATION);
     }
 
   finish_decl (decl, loc, init, NULL_TREE, NULL_TREE);
@@ -3591,7 +3590,7 @@
   gcc_assert (!I_SYMBOL_BINDING (id));
 
   bind (id, decl, external_scope, /*invisible=*/true, /*nested=*/false,
-    UNKNOWN_LOCATION);
+	UNKNOWN_LOCATION);
 
   /* Builtins in the implementation namespace are made visible without
      needing to be explicitly declared.  See push_file_scope.  */
@@ -3617,7 +3616,7 @@
   gcc_assert (!I_SYMBOL_BINDING (id));
 
   bind (id, decl, external_scope, /*invisible=*/false, /*nested=*/false,
-    UNKNOWN_LOCATION);
+	UNKNOWN_LOCATION);
 
   /* Builtins in the implementation namespace are made visible without
      needing to be explicitly declared.  See push_file_scope.  */
@@ -3719,26 +3718,14 @@
 	    }
 	}
       else
-        {
-          pending_invalid_xref = 0;
-          t = lookup_tag (code, name, 1, NULL);
-
-          if (t == 0)
-        {
-          t = make_node (code);
-          pushtag (input_location, name, t);
-        }
-        }
-    }
-      else
-    {
-      if (warned != 1 && !in_system_header)
-        {
-          pedwarn (input_location, 0,
-               "useless type name in empty declaration");
-          warned = 1;
-        }
-    }
+	{
+	  if (warned != 1 && !in_system_header)
+	    {
+	      pedwarn (input_location, 0,
+		       "useless type name in empty declaration");
+	      warned = 1;
+	    }
+	}
     }
   else if (warned != 1 && !in_system_header && declspecs->typedef_p)
     {
@@ -3779,9 +3766,9 @@
     }
 
   if (!warned && !in_system_header && (declspecs->const_p
-                       || declspecs->volatile_p
-                       || declspecs->restrict_p
-                       || declspecs->address_space))
+				       || declspecs->volatile_p
+				       || declspecs->restrict_p
+				       || declspecs->address_space))
     {
       warning (0, "useless type qualifier in empty declaration");
       warned = 2;
@@ -3790,7 +3777,7 @@
   if (warned != 1)
     {
       if (!found_tag)
-    pedwarn (input_location, 0, "empty declaration");
+	pedwarn (input_location, 0, "empty declaration");
     }
 }
 
@@ -3803,24 +3790,24 @@
 quals_from_declspecs (const struct c_declspecs *specs)
 {
   int quals = ((specs->const_p ? TYPE_QUAL_CONST : 0)
-           | (specs->volatile_p ? TYPE_QUAL_VOLATILE : 0)
-           | (specs->restrict_p ? TYPE_QUAL_RESTRICT : 0)
-           | (ENCODE_QUAL_ADDR_SPACE (specs->address_space)));
+	       | (specs->volatile_p ? TYPE_QUAL_VOLATILE : 0)
+	       | (specs->restrict_p ? TYPE_QUAL_RESTRICT : 0)
+	       | (ENCODE_QUAL_ADDR_SPACE (specs->address_space)));
   gcc_assert (!specs->type
-          && !specs->decl_attr
-          && specs->typespec_word == cts_none
-          && specs->storage_class == csc_none
-          && !specs->typedef_p
-          && !specs->explicit_signed_p
-          && !specs->deprecated_p
-          && !specs->long_p
-          && !specs->long_long_p
-          && !specs->short_p
-          && !specs->signed_p
-          && !specs->unsigned_p
-          && !specs->complex_p
-          && !specs->inline_p
-          && !specs->thread_p);
+	      && !specs->decl_attr
+	      && specs->typespec_word == cts_none
+	      && specs->storage_class == csc_none
+	      && !specs->typedef_p
+	      && !specs->explicit_signed_p
+	      && !specs->deprecated_p
+	      && !specs->long_p
+	      && !specs->long_long_p
+	      && !specs->short_p
+	      && !specs->signed_p
+	      && !specs->unsigned_p
+	      && !specs->complex_p
+	      && !specs->inline_p
+	      && !specs->thread_p);
   return quals;
 }
 
@@ -3836,11 +3823,11 @@
 
 struct c_declarator *
 build_array_declarator (location_t loc,
-            tree expr, struct c_declspecs *quals, bool static_p,
-            bool vla_unspec_p)
+			tree expr, struct c_declspecs *quals, bool static_p,
+			bool vla_unspec_p)
 {
   struct c_declarator *declarator = XOBNEW (&parser_obstack,
-                        struct c_declarator);
+					    struct c_declarator);
   declarator->id_loc = loc;
   declarator->kind = cdk_array;
   declarator->declarator = 0;
@@ -3860,23 +3847,23 @@
   if (!flag_isoc99)
     {
       if (static_p || quals != NULL)
-    pedwarn (loc, OPT_pedantic,
-         "ISO C90 does not support %<static%> or type "
-         "qualifiers in parameter array declarators");
+	pedwarn (loc, OPT_pedantic,
+		 "ISO C90 does not support %<static%> or type "
+		 "qualifiers in parameter array declarators");
       if (vla_unspec_p)
-    pedwarn (loc, OPT_pedantic,
-         "ISO C90 does not support %<[*]%> array declarators");
+	pedwarn (loc, OPT_pedantic,
+		 "ISO C90 does not support %<[*]%> array declarators");
     }
   if (vla_unspec_p)
     {
       if (!current_scope->parm_flag)
-    {
-      /* C99 6.7.5.2p4 */
-      error_at (loc, "%<[*]%> not allowed in other than "
-            "function prototype scope");
-      declarator->u.array.vla_unspec_p = false;
-      return NULL;
-    }
+	{
+	  /* C99 6.7.5.2p4 */
+	  error_at (loc, "%<[*]%> not allowed in other than "
+		    "function prototype scope");
+	  declarator->u.array.vla_unspec_p = false;
+	  return NULL;
+	}
       current_scope->had_vla_unspec = true;
     }
   return declarator;
@@ -3888,7 +3875,7 @@
 
 struct c_declarator *
 set_array_declarator_inner (struct c_declarator *decl,
-                struct c_declarator *inner)
+			    struct c_declarator *inner)
 {
   decl->declarator = inner;
   return decl;
@@ -3915,9 +3902,9 @@
     {
       complete_array_type (&type, elt, false);
       DECL_SIZE (decl)
-    = size_binop (PLUS_EXPR, DECL_SIZE (decl), TYPE_SIZE (type));
+	= size_binop (PLUS_EXPR, DECL_SIZE (decl), TYPE_SIZE (type));
       DECL_SIZE_UNIT (decl)
-    = size_binop (PLUS_EXPR, DECL_SIZE_UNIT (decl), TYPE_SIZE_UNIT (type));
+	= size_binop (PLUS_EXPR, DECL_SIZE_UNIT (decl), TYPE_SIZE_UNIT (type));
     }
 }
 
@@ -3929,7 +3916,7 @@
 
 tree
 groktypename (struct c_type_name *type_name, tree *expr,
-          bool *expr_const_operands)
+	      bool *expr_const_operands)
 {
   tree type;
   tree attrs = type_name->specs->attrs;
@@ -3937,8 +3924,8 @@
   type_name->specs->attrs = NULL_TREE;
 
   type = grokdeclarator (type_name->declarator, type_name->specs, TYPENAME,
-             false, NULL, &attrs, expr, expr_const_operands,
-             DEPRECATED_NORMAL);
+			 false, NULL, &attrs, expr, expr_const_operands,
+			 DEPRECATED_NORMAL);
 
   /* Apply attributes.  */
   decl_attributes (&type, attrs, 0);
@@ -3963,7 +3950,7 @@
 
 tree
 start_decl (struct c_declarator *declarator, struct c_declspecs *declspecs,
-        bool initialized, tree attributes)
+	    bool initialized, tree attributes)
 {
   tree decl;
   tree tem;
@@ -3976,8 +3963,8 @@
     deprecated_state = DEPRECATED_SUPPRESS;
 
   decl = grokdeclarator (declarator, declspecs,
-             NORMAL, initialized, NULL, &attributes, &expr, NULL,
-             deprecated_state);
+			 NORMAL, initialized, NULL, &attributes, &expr, NULL,
+			 deprecated_state);
   if (!decl)
     return 0;
 
@@ -3994,64 +3981,64 @@
     switch (TREE_CODE (decl))
       {
       case TYPE_DECL:
-    error ("typedef %qD is initialized (use __typeof__ instead)", decl);
-    initialized = 0;
-    break;
+	error ("typedef %qD is initialized (use __typeof__ instead)", decl);
+	initialized = 0;
+	break;
 
       case FUNCTION_DECL:
-    error ("function %qD is initialized like a variable", decl);
-    initialized = 0;
-    break;
+	error ("function %qD is initialized like a variable", decl);
+	initialized = 0;
+	break;
 
       case PARM_DECL:
-    /* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE.  */
-    error ("parameter %qD is initialized", decl);
-    initialized = 0;
-    break;
+	/* DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE.  */
+	error ("parameter %qD is initialized", decl);
+	initialized = 0;
+	break;
 
       default:
-    /* Don't allow initializations for incomplete types except for
-       arrays which might be completed by the initialization.  */
-
-    /* This can happen if the array size is an undefined macro.
-       We already gave a warning, so we don't need another one.  */
-    if (TREE_TYPE (decl) == error_mark_node)
-      initialized = 0;
-    else if (COMPLETE_TYPE_P (TREE_TYPE (decl)))
-      {
-        /* A complete type is ok if size is fixed.  */
-
-        if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl))) != INTEGER_CST
-        || C_DECL_VARIABLE_SIZE (decl))
-          {
-        error ("variable-sized object may not be initialized");
-        initialized = 0;
-          }
-      }
-    else if (TREE_CODE (TREE_TYPE (decl)) != ARRAY_TYPE)
-      {
-        error ("variable %qD has initializer but incomplete type", decl);
-        initialized = 0;
-      }
-    else if (C_DECL_VARIABLE_SIZE (decl))
-      {
-        /* Although C99 is unclear about whether incomplete arrays
-           of VLAs themselves count as VLAs, it does not make
-           sense to permit them to be initialized given that
-           ordinary VLAs may not be initialized.  */
-        error ("variable-sized object may not be initialized");
-        initialized = 0;
-      }
+	/* Don't allow initializations for incomplete types except for
+	   arrays which might be completed by the initialization.  */
+
+	/* This can happen if the array size is an undefined macro.
+	   We already gave a warning, so we don't need another one.  */
+	if (TREE_TYPE (decl) == error_mark_node)
+	  initialized = 0;
+	else if (COMPLETE_TYPE_P (TREE_TYPE (decl)))
+	  {
+	    /* A complete type is ok if size is fixed.  */
+
+	    if (TREE_CODE (TYPE_SIZE (TREE_TYPE (decl))) != INTEGER_CST
+		|| C_DECL_VARIABLE_SIZE (decl))
+	      {
+		error ("variable-sized object may not be initialized");
+		initialized = 0;
+	      }
+	  }
+	else if (TREE_CODE (TREE_TYPE (decl)) != ARRAY_TYPE)
+	  {
+	    error ("variable %qD has initializer but incomplete type", decl);
+	    initialized = 0;
+	  }
+	else if (C_DECL_VARIABLE_SIZE (decl))
+	  {
+	    /* Although C99 is unclear about whether incomplete arrays
+	       of VLAs themselves count as VLAs, it does not make
+	       sense to permit them to be initialized given that
+	       ordinary VLAs may not be initialized.  */
+	    error ("variable-sized object may not be initialized");
+	    initialized = 0;
+	  }
       }
 
   if (initialized)
     {
       if (current_scope == file_scope)
-    TREE_STATIC (decl) = 1;
+	TREE_STATIC (decl) = 1;
 
       /* Tell 'pushdecl' this is an initialized decl
-     even though we don't yet have the initializer expression.
-     Also tell 'finish_decl' it may store the real initializer.  */
+	 even though we don't yet have the initializer expression.
+	 Also tell 'finish_decl' it may store the real initializer.  */
       DECL_INITIAL (decl) = error_mark_node;
     }
 
@@ -4087,12 +4074,12 @@
       && !flag_gnu89_inline
       && TREE_CODE (decl) == FUNCTION_DECL
       && (lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (decl))
-      || current_function_decl))
+	  || current_function_decl))
     {
       if (declspecs->storage_class == csc_auto && current_scope != file_scope)
-    ;
+	;
       else if (declspecs->storage_class != csc_static)
-    DECL_EXTERNAL (decl) = !DECL_EXTERNAL (decl);
+	DECL_EXTERNAL (decl) = !DECL_EXTERNAL (decl);
     }
 
   if (TREE_CODE (decl) == FUNCTION_DECL
@@ -4101,7 +4088,7 @@
       struct c_declarator *ce = declarator;
 
       if (ce->kind == cdk_pointer)
-    ce = declarator->declarator;
+	ce = declarator->declarator;
       if (ce->kind == cdk_function)
 	{
 	  tree args = ce->u.arg_info->parms;
@@ -4120,7 +4107,7 @@
       && DECL_UNINLINABLE (decl)
       && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
     warning (OPT_Wattributes, "inline function %q+D given attribute noinline",
-         decl);
+	     decl);
 
   /* C99 6.7.4p3: An inline definition of a function with external
      linkage shall not contain a definition of a modifiable object
@@ -4132,7 +4119,7 @@
       && DECL_DECLARED_INLINE_P (current_function_decl)
       && DECL_EXTERNAL (current_function_decl))
     record_inline_static (input_location, current_function_decl,
-              decl, csi_modifiable);
+			  decl, csi_modifiable);
 
   if (c_dialect_objc () 
       && (TREE_CODE (decl) == VAR_DECL
@@ -4191,7 +4178,7 @@
 
 void
 finish_decl (tree decl, location_t init_loc, tree init,
-             tree origtype, tree asmspec_tree)
+    	     tree origtype, tree asmspec_tree)
 {
   tree type;
   bool was_incomplete = (DECL_SIZE (decl) == 0);
@@ -4223,8 +4210,8 @@
     store_init_value (init_loc, decl, init, origtype);
 
   if (c_dialect_objc () && (TREE_CODE (decl) == VAR_DECL
-                || TREE_CODE (decl) == FUNCTION_DECL
-                || TREE_CODE (decl) == FIELD_DECL))
+			    || TREE_CODE (decl) == FUNCTION_DECL
+			    || TREE_CODE (decl) == FIELD_DECL))
     objc_check_decl (decl);
 
   type = TREE_TYPE (decl);
@@ -4235,65 +4222,65 @@
       && TREE_CODE (decl) != TYPE_DECL)
     {
       bool do_default
-    = (TREE_STATIC (decl)
-       /* Even if pedantic, an external linkage array
-          may have incomplete type at first.  */
-       ? pedantic && !TREE_PUBLIC (decl)
-       : !DECL_EXTERNAL (decl));
+	= (TREE_STATIC (decl)
+	   /* Even if pedantic, an external linkage array
+	      may have incomplete type at first.  */
+	   ? pedantic && !TREE_PUBLIC (decl)
+	   : !DECL_EXTERNAL (decl));
       int failure
-    = complete_array_type (&TREE_TYPE (decl), DECL_INITIAL (decl),
-                   do_default);
+	= complete_array_type (&TREE_TYPE (decl), DECL_INITIAL (decl),
+			       do_default);
 
       /* Get the completed type made by complete_array_type.  */
       type = TREE_TYPE (decl);
 
       switch (failure)
-    {
-    case 1:
-      error ("initializer fails to determine size of %q+D", decl);
-      break;
-
-    case 2:
-      if (do_default)
-        error ("array size missing in %q+D", decl);
-      /* If a `static' var's size isn't known,
-         make it extern as well as static, so it does not get
-         allocated.
-         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))
-        DECL_EXTERNAL (decl) = 1;
-      break;
-
-    case 3:
-      error ("zero or negative size array %q+D", decl);
-      break;
-
-    case 0:
-      /* For global variables, update the copy of the type that
-         exists in the binding.  */
-      if (TREE_PUBLIC (decl))
-        {
-          struct c_binding *b_ext = I_SYMBOL_BINDING (DECL_NAME (decl));
-          while (b_ext && !B_IN_EXTERNAL_SCOPE (b_ext))
-        b_ext = b_ext->shadowed;
-          if (b_ext)
-        {
-          if (b_ext->u.type)
-            b_ext->u.type = composite_type (b_ext->u.type, type);
-          else
-            b_ext->u.type = type;
-        }
-        }
-      break;
-
-    default:
-      gcc_unreachable ();
-    }
+	{
+	case 1:
+	  error ("initializer fails to determine size of %q+D", decl);
+	  break;
+
+	case 2:
+	  if (do_default)
+	    error ("array size missing in %q+D", decl);
+	  /* If a `static' var's size isn't known,
+	     make it extern as well as static, so it does not get
+	     allocated.
+	     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))
+	    DECL_EXTERNAL (decl) = 1;
+	  break;
+
+	case 3:
+	  error ("zero or negative size array %q+D", decl);
+	  break;
+
+	case 0:
+	  /* For global variables, update the copy of the type that
+	     exists in the binding.  */
+	  if (TREE_PUBLIC (decl))
+	    {
+	      struct c_binding *b_ext = I_SYMBOL_BINDING (DECL_NAME (decl));
+	      while (b_ext && !B_IN_EXTERNAL_SCOPE (b_ext))
+		b_ext = b_ext->shadowed;
+	      if (b_ext)
+		{
+		  if (b_ext->u.type)
+		    b_ext->u.type = composite_type (b_ext->u.type, type);
+		  else
+		    b_ext->u.type = type;
+		}
+	    }
+	  break;
+
+	default:
+	  gcc_unreachable ();
+	}
 
       if (DECL_INITIAL (decl))
-    TREE_TYPE (DECL_INITIAL (decl)) = type;
+	TREE_TYPE (DECL_INITIAL (decl)) = type;
 
       layout_decl (decl, 0);
     }
@@ -4301,42 +4288,42 @@
   if (TREE_CODE (decl) == VAR_DECL)
     {
       if (init && TREE_CODE (init) == CONSTRUCTOR)
-    add_flexible_array_elts_to_size (decl, init);
+	add_flexible_array_elts_to_size (decl, init);
 
       if (DECL_SIZE (decl) == 0 && TREE_TYPE (decl) != error_mark_node
-      && COMPLETE_TYPE_P (TREE_TYPE (decl)))
-    layout_decl (decl, 0);
+	  && COMPLETE_TYPE_P (TREE_TYPE (decl)))
+	layout_decl (decl, 0);
 
       if (DECL_SIZE (decl) == 0
-      /* Don't give an error if we already gave one earlier.  */
-      && TREE_TYPE (decl) != error_mark_node
-      && (TREE_STATIC (decl)
-          /* A static variable with an incomplete type
-         is an error if it is initialized.
-         Also if it is not file scope.
-         Otherwise, let it through, but if it is not `extern'
-         then it may cause an error message later.  */
-          ? (DECL_INITIAL (decl) != 0
-         || !DECL_FILE_SCOPE_P (decl))
-          /* An automatic variable with an incomplete type
-         is an error.  */
-          : !DECL_EXTERNAL (decl)))
-     {
-       error ("storage size of %q+D isn%'t known", decl);
-       TREE_TYPE (decl) = error_mark_node;
-     }
+	  /* Don't give an error if we already gave one earlier.  */
+	  && TREE_TYPE (decl) != error_mark_node
+	  && (TREE_STATIC (decl)
+	      /* A static variable with an incomplete type
+		 is an error if it is initialized.
+		 Also if it is not file scope.
+		 Otherwise, let it through, but if it is not `extern'
+		 then it may cause an error message later.  */
+	      ? (DECL_INITIAL (decl) != 0
+		 || !DECL_FILE_SCOPE_P (decl))
+	      /* An automatic variable with an incomplete type
+		 is an error.  */
+	      : !DECL_EXTERNAL (decl)))
+	 {
+	   error ("storage size of %q+D isn%'t known", decl);
+	   TREE_TYPE (decl) = error_mark_node;
+	 }
 
       if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
-      && DECL_SIZE (decl) != 0)
-    {
-      if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
-        constant_expression_warning (DECL_SIZE (decl));
-      else
-        {
-          error ("storage size of %q+D isn%'t constant", decl);
-          TREE_TYPE (decl) = error_mark_node;
-        }
-    }
+	  && DECL_SIZE (decl) != 0)
+	{
+	  if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
+	    constant_expression_warning (DECL_SIZE (decl));
+	  else
+	    {
+	      error ("storage size of %q+D isn%'t constant", decl);
+	      TREE_TYPE (decl) = error_mark_node;
+	    }
+	}
 
       if (TREE_USED (type))
 	{
@@ -4351,7 +4338,7 @@
   if (TREE_CODE (decl) == FUNCTION_DECL && asmspec)
     {
       if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
-    set_builtin_user_assembler_name (decl, asmspec);
+	set_builtin_user_assembler_name (decl, asmspec);
       set_user_assembler_name (decl, asmspec);
     }
 
@@ -4366,98 +4353,98 @@
     {
       /* Determine the ELF visibility.  */
       if (TREE_PUBLIC (decl))
-    c_determine_visibility (decl);
+	c_determine_visibility (decl);
 
       /* This is a no-op in c-lang.c or something real in objc-act.c.  */
       if (c_dialect_objc ())
-    objc_check_decl (decl);
+	objc_check_decl (decl);
 
       if (asmspec)
-    {
-      /* If this is not a static variable, issue a warning.
-         It doesn't make any sense to give an ASMSPEC for an
-         ordinary, non-register local variable.  Historically,
-         GCC has accepted -- but ignored -- the ASMSPEC in
-         this case.  */
-      if (!DECL_FILE_SCOPE_P (decl)
-          && TREE_CODE (decl) == VAR_DECL
-          && !C_DECL_REGISTER (decl)
-          && !TREE_STATIC (decl))
-        warning (0, "ignoring asm-specifier for non-static local "
-             "variable %q+D", decl);
-      else
-        set_user_assembler_name (decl, asmspec);
-    }
+	{
+	  /* If this is not a static variable, issue a warning.
+	     It doesn't make any sense to give an ASMSPEC for an
+	     ordinary, non-register local variable.  Historically,
+	     GCC has accepted -- but ignored -- the ASMSPEC in
+	     this case.  */
+	  if (!DECL_FILE_SCOPE_P (decl)
+	      && TREE_CODE (decl) == VAR_DECL
+	      && !C_DECL_REGISTER (decl)
+	      && !TREE_STATIC (decl))
+	    warning (0, "ignoring asm-specifier for non-static local "
+		     "variable %q+D", decl);
+	  else
+	    set_user_assembler_name (decl, asmspec);
+	}
 
       if (DECL_FILE_SCOPE_P (decl))
-    {
-      if (DECL_INITIAL (decl) == NULL_TREE
-          || DECL_INITIAL (decl) == error_mark_node)
-        /* Don't output anything
-           when a tentative file-scope definition is seen.
-           But at end of compilation, do output code for them.  */
-        DECL_DEFER_OUTPUT (decl) = 1;
-      rest_of_decl_compilation (decl, true, 0);
-    }
+	{
+	  if (DECL_INITIAL (decl) == NULL_TREE
+	      || DECL_INITIAL (decl) == error_mark_node)
+	    /* Don't output anything
+	       when a tentative file-scope definition is seen.
+	       But at end of compilation, do output code for them.  */
+	    DECL_DEFER_OUTPUT (decl) = 1;
+	  rest_of_decl_compilation (decl, true, 0);
+	}
       else
-    {
-      /* In conjunction with an ASMSPEC, the `register'
-         keyword indicates that we should place the variable
-         in a particular register.  */
-      if (asmspec && C_DECL_REGISTER (decl))
-        {
-          DECL_HARD_REGISTER (decl) = 1;
-          /* This cannot be done for a structure with volatile
-         fields, on which DECL_REGISTER will have been
-         reset.  */
-          if (!DECL_REGISTER (decl))
-        error ("cannot put object with volatile field into register");
-        }
-
-      if (TREE_CODE (decl) != FUNCTION_DECL)
-        {
-          /* If we're building a variable sized type, and we might be
-         reachable other than via the top of the current binding
-         level, then create a new BIND_EXPR so that we deallocate
-         the object at the right time.  */
-          /* Note that DECL_SIZE can be null due to errors.  */
-          if (DECL_SIZE (decl)
-          && !TREE_CONSTANT (DECL_SIZE (decl))
-          && STATEMENT_LIST_HAS_LABEL (cur_stmt_list))
-        {
-          tree bind;
-          bind = build3 (BIND_EXPR, void_type_node, NULL, NULL, NULL);
-          TREE_SIDE_EFFECTS (bind) = 1;
-          add_stmt (bind);
-          BIND_EXPR_BODY (bind) = push_stmt_list ();
-        }
-          add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl),
-                    DECL_EXPR, decl));
-        }
-    }
+	{
+	  /* In conjunction with an ASMSPEC, the `register'
+	     keyword indicates that we should place the variable
+	     in a particular register.  */
+	  if (asmspec && C_DECL_REGISTER (decl))
+	    {
+	      DECL_HARD_REGISTER (decl) = 1;
+	      /* This cannot be done for a structure with volatile
+		 fields, on which DECL_REGISTER will have been
+		 reset.  */
+	      if (!DECL_REGISTER (decl))
+		error ("cannot put object with volatile field into register");
+	    }
+
+	  if (TREE_CODE (decl) != FUNCTION_DECL)
+	    {
+	      /* If we're building a variable sized type, and we might be
+		 reachable other than via the top of the current binding
+		 level, then create a new BIND_EXPR so that we deallocate
+		 the object at the right time.  */
+	      /* Note that DECL_SIZE can be null due to errors.  */
+	      if (DECL_SIZE (decl)
+		  && !TREE_CONSTANT (DECL_SIZE (decl))
+		  && STATEMENT_LIST_HAS_LABEL (cur_stmt_list))
+		{
+		  tree bind;
+		  bind = build3 (BIND_EXPR, void_type_node, NULL, NULL, NULL);
+		  TREE_SIDE_EFFECTS (bind) = 1;
+		  add_stmt (bind);
+		  BIND_EXPR_BODY (bind) = push_stmt_list ();
+		}
+	      add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl),
+				    DECL_EXPR, decl));
+	    }
+	}
 
 
       if (!DECL_FILE_SCOPE_P (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))
-        {
-          /* If we used it already as memory, it must stay in memory.  */
-          TREE_ADDRESSABLE (decl) = TREE_USED (decl);
-          /* If it's still incomplete now, no init will save it.  */
-          if (DECL_SIZE (decl) == 0)
-        DECL_INITIAL (decl) = 0;
-        }
-    }
+	{
+	  /* 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))
+	    {
+	      /* If we used it already as memory, it must stay in memory.  */
+	      TREE_ADDRESSABLE (decl) = TREE_USED (decl);
+	      /* If it's still incomplete now, no init will save it.  */
+	      if (DECL_SIZE (decl) == 0)
+		DECL_INITIAL (decl) = 0;
+	    }
+	}
     }
 
   if (TREE_CODE (decl) == TYPE_DECL)
     {
       if (!DECL_FILE_SCOPE_P (decl)
-      && variably_modified_type_p (TREE_TYPE (decl), NULL_TREE))
-    add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl), DECL_EXPR, decl));
+	  && variably_modified_type_p (TREE_TYPE (decl), NULL_TREE))
+	add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl), DECL_EXPR, decl));
 
       rest_of_decl_compilation (decl, DECL_FILE_SCOPE_P (decl), 0);
     }
@@ -4519,7 +4506,7 @@
 {
   tree attrs = parm->attrs;
   tree decl = grokdeclarator (parm->declarator, parm->specs, PARM, false,
-                  NULL, &attrs, NULL, NULL, DEPRECATED_NORMAL);
+			      NULL, &attrs, NULL, NULL, DEPRECATED_NORMAL);
 
   decl_attributes (&decl, attrs, 0);
 
@@ -4536,7 +4523,7 @@
   tree decl;
 
   decl = grokdeclarator (parm->declarator, parm->specs, PARM, false, NULL,
-             &attrs, NULL, NULL, DEPRECATED_NORMAL);
+			 &attrs, NULL, NULL, DEPRECATED_NORMAL);
   decl_attributes (&decl, attrs, 0);
 
   decl = pushdecl (decl);
@@ -4555,7 +4542,7 @@
   if (pedantic && !current_scope->warned_forward_parm_decls)
     {
       pedwarn (input_location, OPT_pedantic,
-           "ISO C forbids forward parameter declarations");
+	       "ISO C forbids forward parameter declarations");
       current_scope->warned_forward_parm_decls = true;
     }
 
@@ -4598,7 +4585,7 @@
   if (TREE_CODE (type) == ARRAY_TYPE && !COMPLETE_TYPE_P (type))
     {
       int failure = complete_array_type (&TREE_TYPE (decl),
-                     DECL_INITIAL (decl), true);
+					 DECL_INITIAL (decl), true);
       gcc_assert (!failure);
 
       type = TREE_TYPE (decl);
@@ -4645,7 +4632,7 @@
       && (type_name->specs->typespec_kind == ctsk_tagdef
           || type_name->specs->typespec_kind == ctsk_tagfirstref))
     warning_at (loc, OPT_Wc___compat,
-        "defining a type in a compound literal is invalid in C++");
+		"defining a type in a compound literal is invalid in C++");
 }
 
 /* Determine whether TYPE is a structure with a flexible array member,
@@ -4664,10 +4651,10 @@
       while (DECL_CHAIN (x) != NULL_TREE)
 	x = DECL_CHAIN (x);
       if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
-      && TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
-      && TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE
-      && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE)
-    return true;
+	  && TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
+	  && TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE
+	  && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE)
+	return true;
       return false;
     case UNION_TYPE:
       for (x = TYPE_FIELDS (type); x != NULL_TREE; x = DECL_CHAIN (x))
@@ -4690,8 +4677,8 @@
   unsigned int max_width;
   unsigned HOST_WIDE_INT w;
   const char *name = (orig_name
-              ? identifier_to_locale (IDENTIFIER_POINTER (orig_name))
-              : _("<anonymous>"));
+		      ? identifier_to_locale (IDENTIFIER_POINTER (orig_name))
+		      : _("<anonymous>"));
 
   /* Detect and ignore out of range field width and process valid
      field widths.  */
@@ -4703,29 +4690,29 @@
   else
     {
       if (TREE_CODE (*width) != INTEGER_CST)
-    {
-      *width = c_fully_fold (*width, false, NULL);
-      if (TREE_CODE (*width) == INTEGER_CST)
-        pedwarn (input_location, OPT_pedantic,
-             "bit-field %qs width not an integer constant expression",
-             name);
-    }
+	{
+	  *width = c_fully_fold (*width, false, NULL);
+	  if (TREE_CODE (*width) == INTEGER_CST)
+	    pedwarn (input_location, OPT_pedantic,
+		     "bit-field %qs width not an integer constant expression",
+		     name);
+	}
       if (TREE_CODE (*width) != INTEGER_CST)
-    {
-      error ("bit-field %qs width not an integer constant", name);
-      *width = integer_one_node;
-    }
+	{
+	  error ("bit-field %qs width not an integer constant", name);
+	  *width = integer_one_node;
+	}
       constant_expression_warning (*width);
       if (tree_int_cst_sgn (*width) < 0)
-    {
-      error ("negative width in bit-field %qs", name);
-      *width = integer_one_node;
-    }
+	{
+	  error ("negative width in bit-field %qs", name);
+	  *width = integer_one_node;
+	}
       else if (integer_zerop (*width) && orig_name)
-    {
-      error ("zero width for bit-field %qs", name);
-      *width = integer_one_node;
-    }
+	{
+	  error ("zero width for bit-field %qs", name);
+	  *width = integer_one_node;
+	}
     }
 
   /* Detect invalid bit-field type.  */
@@ -4743,7 +4730,7 @@
       && type_mv != unsigned_type_node
       && type_mv != boolean_type_node)
     pedwarn (input_location, OPT_pedantic,
-         "type of bit-field %qs is a GCC extension", name);
+	     "type of bit-field %qs is a GCC extension", name);
 
   max_width = TYPE_PRECISION (*type);
 
@@ -4760,9 +4747,9 @@
     {
       struct lang_type *lt = TYPE_LANG_SPECIFIC (*type);
       if (!lt
-      || w < tree_int_cst_min_precision (lt->enum_min, TYPE_UNSIGNED (*type))
-      || w < tree_int_cst_min_precision (lt->enum_max, TYPE_UNSIGNED (*type)))
-    warning (0, "%qs is narrower than values of its type", name);
+	  || w < tree_int_cst_min_precision (lt->enum_min, TYPE_UNSIGNED (*type))
+	  || w < tree_int_cst_min_precision (lt->enum_max, TYPE_UNSIGNED (*type)))
+	warning (0, "%qs is narrower than values of its type", name);
     }
 }
 
@@ -4778,48 +4765,48 @@
   if (!flag_isoc99 && pedantic && warn_vla != 0)
     {
       if (const_size)
-    {
-      if (name)
-        pedwarn (input_location, OPT_Wvla,
-             "ISO C90 forbids array %qE whose size "
-             "can%'t be evaluated",
-             name);
+	{
+	  if (name)
+	    pedwarn (input_location, OPT_Wvla,
+		     "ISO C90 forbids array %qE whose size "
+		     "can%'t be evaluated",
+		     name);
+	  else
+	    pedwarn (input_location, OPT_Wvla, "ISO C90 forbids array whose size "
+		     "can%'t be evaluated");
+	}
       else
-        pedwarn (input_location, OPT_Wvla, "ISO C90 forbids array whose size "
-             "can%'t be evaluated");
-    }
-      else
-    {
-      if (name)
-        pedwarn (input_location, OPT_Wvla,
-             "ISO C90 forbids variable length array %qE",
-             name);
-      else
-        pedwarn (input_location, OPT_Wvla, "ISO C90 forbids variable length array");
-    }
+	{
+	  if (name)
+	    pedwarn (input_location, OPT_Wvla,
+		     "ISO C90 forbids variable length array %qE",
+		     name);
+	  else
+	    pedwarn (input_location, OPT_Wvla, "ISO C90 forbids variable length array");
+	}
     }
   else if (warn_vla > 0)
     {
       if (const_size)
         {
-      if (name)
-        warning (OPT_Wvla,
-             "the size of array %qE can"
-             "%'t be evaluated", name);
-      else
-        warning (OPT_Wvla,
-             "the size of array can %'t be evaluated");
-    }
+	  if (name)
+	    warning (OPT_Wvla,
+		     "the size of array %qE can"
+		     "%'t be evaluated", name);
+	  else
+	    warning (OPT_Wvla,
+		     "the size of array can %'t be evaluated");
+	}
       else
-    {
-      if (name)
-        warning (OPT_Wvla,
-             "variable length array %qE is used",
-             name);
-      else
-        warning (OPT_Wvla,
-             "variable length array is used");
-    }
+	{
+	  if (name)
+	    warning (OPT_Wvla,
+		     "variable length array %qE is used",
+		     name);
+	  else
+	    warning (OPT_Wvla,
+		     "variable length array is used");
+	}
     }
 }
 
@@ -4892,10 +4879,10 @@
 
 static tree
 grokdeclarator (const struct c_declarator *declarator,
-        struct c_declspecs *declspecs,
-        enum decl_context decl_context, bool initialized, tree *width,
-        tree *decl_attrs, tree *expr, bool *expr_const_operands,
-        enum deprecated_states deprecated_state)
+		struct c_declspecs *declspecs,
+		enum decl_context decl_context, bool initialized, tree *width,
+		tree *decl_attrs, tree *expr, bool *expr_const_operands,
+		enum deprecated_states deprecated_state)
 {
   tree type = declspecs->type;
   bool threadp = declspecs->thread_p;
@@ -4943,38 +4930,38 @@
 
     while (decl)
       switch (decl->kind)
-    {
-    case cdk_array:
-      loc = decl->id_loc;
-      /* FALL THRU.  */
-
-    case cdk_function:
-    case cdk_pointer:
-      funcdef_syntax = (decl->kind == cdk_function);
-      decl = decl->declarator;
-      break;
-
-    case cdk_attrs:
-      decl = decl->declarator;
-      break;
-
-    case cdk_id:
-      loc = decl->id_loc;
-      if (decl->u.id)
-        name = decl->u.id;
-      decl = 0;
-      break;
-
-    default:
-      gcc_unreachable ();
-    }
+	{
+	case cdk_array:
+	  loc = decl->id_loc;
+	  /* FALL THRU.  */
+
+	case cdk_function:
+	case cdk_pointer:
+	  funcdef_syntax = (decl->kind == cdk_function);
+	  decl = decl->declarator;
+	  break;
+
+	case cdk_attrs:
+	  decl = decl->declarator;
+	  break;
+
+	case cdk_id:
+	  loc = decl->id_loc;
+	  if (decl->u.id)
+	    name = decl->u.id;
+	  decl = 0;
+	  break;
+
+	default:
+	  gcc_unreachable ();
+	}
     if (name == 0)
       {
-    gcc_assert (decl_context == PARM
-            || decl_context == TYPENAME
-            || (decl_context == FIELD
-            && declarator->kind == cdk_id));
-    gcc_assert (!initialized);
+	gcc_assert (decl_context == PARM
+		    || decl_context == TYPENAME
+		    || (decl_context == FIELD
+			&& declarator->kind == cdk_id));
+	gcc_assert (!initialized);
       }
   }
 
@@ -4998,9 +4985,9 @@
       && variably_modified_type_p (type, NULL_TREE))
     {
       if (name)
-    error_at (loc, "variably modified %qE at file scope", name);
+	error_at (loc, "variably modified %qE at file scope", name);
       else
-    error_at (loc, "variably modified field at file scope");
+	error_at (loc, "variably modified field at file scope");
       type = integer_type_node;
     }
 
@@ -5011,21 +4998,21 @@
   if (declspecs->default_int_p && !in_system_header)
     {
       /* Issue a warning if this is an ISO C 99 program or if
-     -Wreturn-type and this is a function, or if -Wimplicit;
-     prefer the former warning since it is more explicit.  */
+	 -Wreturn-type and this is a function, or if -Wimplicit;
+	 prefer the former warning since it is more explicit.  */
       if ((warn_implicit_int || warn_return_type || flag_isoc99)
-      && funcdef_flag)
-    warn_about_return_type = 1;
+	  && funcdef_flag)
+	warn_about_return_type = 1;
       else
-    {
-      if (name)
-        pedwarn_c99 (loc, flag_isoc99 ? 0 : OPT_Wimplicit_int,
-             "type defaults to %<int%> in declaration of %qE",
-             name);
-      else
-        pedwarn_c99 (input_location, flag_isoc99 ? 0 : OPT_Wimplicit_int,
-             "type defaults to %<int%> in type name");
-    }
+	{
+	  if (name)
+	    pedwarn_c99 (loc, flag_isoc99 ? 0 : OPT_Wimplicit_int,
+			 "type defaults to %<int%> in declaration of %qE",
+			 name);
+	  else
+	    pedwarn_c99 (input_location, flag_isoc99 ? 0 : OPT_Wimplicit_int,
+			 "type defaults to %<int%> in type name");
+	}
     }
 
   /* Adjust the type if a bit-field is being declared,
@@ -5057,82 +5044,82 @@
   if (pedantic && !flag_isoc99)
     {
       if (constp > 1)
-    pedwarn (loc, OPT_pedantic, "duplicate %<const%>");
+	pedwarn (loc, OPT_pedantic, "duplicate %<const%>");
       if (restrictp > 1)
-    pedwarn (loc, OPT_pedantic, "duplicate %<restrict%>");
+	pedwarn (loc, OPT_pedantic, "duplicate %<restrict%>");
       if (volatilep > 1)
-    pedwarn (loc, OPT_pedantic, "duplicate %<volatile%>");
+	pedwarn (loc, OPT_pedantic, "duplicate %<volatile%>");
     }
 
   if (!ADDR_SPACE_GENERIC_P (as1) && !ADDR_SPACE_GENERIC_P (as2) && as1 != as2)
     error_at (loc, "conflicting named address spaces (%s vs %s)",
-          c_addr_space_name (as1), c_addr_space_name (as2));
+	      c_addr_space_name (as1), c_addr_space_name (as2));
 
   if (!flag_gen_aux_info && (TYPE_QUALS (element_type)))
     type = TYPE_MAIN_VARIANT (type);
   type_quals = ((constp ? TYPE_QUAL_CONST : 0)
-        | (restrictp ? TYPE_QUAL_RESTRICT : 0)
-        | (volatilep ? TYPE_QUAL_VOLATILE : 0)
-        | ENCODE_QUAL_ADDR_SPACE (address_space));
+		| (restrictp ? TYPE_QUAL_RESTRICT : 0)
+		| (volatilep ? TYPE_QUAL_VOLATILE : 0)
+		| ENCODE_QUAL_ADDR_SPACE (address_space));
 
   /* Warn about storage classes that are invalid for certain
      kinds of declarations (parameters, typenames, etc.).  */
 
   if (funcdef_flag
       && (threadp
-      || storage_class == csc_auto
-      || storage_class == csc_register
-      || storage_class == csc_typedef))
+	  || storage_class == csc_auto
+	  || storage_class == csc_register
+	  || storage_class == csc_typedef))
     {
       if (storage_class == csc_auto)
-    pedwarn (loc,
-         (current_scope == file_scope) ? 0 : OPT_pedantic,
-         "function definition declared %<auto%>");
+	pedwarn (loc,
+		 (current_scope == file_scope) ? 0 : OPT_pedantic,
+		 "function definition declared %<auto%>");
       if (storage_class == csc_register)
-    error_at (loc, "function definition declared %<register%>");
+	error_at (loc, "function definition declared %<register%>");
       if (storage_class == csc_typedef)
-    error_at (loc, "function definition declared %<typedef%>");
+	error_at (loc, "function definition declared %<typedef%>");
       if (threadp)
-    error_at (loc, "function definition declared %<__thread%>");
+	error_at (loc, "function definition declared %<__thread%>");
       threadp = false;
       if (storage_class == csc_auto
-      || storage_class == csc_register
-      || storage_class == csc_typedef)
-    storage_class = csc_none;
+	  || storage_class == csc_register
+	  || storage_class == csc_typedef)
+	storage_class = csc_none;
     }
   else if (decl_context != NORMAL && (storage_class != csc_none || threadp))
     {
       if (decl_context == PARM && storage_class == csc_register)
-    ;
+	;
       else
-    {
-      switch (decl_context)
-        {
-        case FIELD:
-          if (name)
-        error_at (loc, "storage class specified for structure "
-                  "field %qE", name);
-          else
-        error_at (loc, "storage class specified for structure field");
-          break;
-        case PARM:
-          if (name)
-        error_at (loc, "storage class specified for parameter %qE",
-                  name);
-          else
-        error_at (loc, "storage class specified for unnamed parameter");
-          break;
-        default:
-          error_at (loc, "storage class specified for typename");
-          break;
-        }
-      storage_class = csc_none;
-      threadp = false;
-    }
+	{
+	  switch (decl_context)
+	    {
+	    case FIELD:
+	      if (name)
+		error_at (loc, "storage class specified for structure "
+		    	  "field %qE", name);
+	      else
+		error_at (loc, "storage class specified for structure field");
+	      break;
+	    case PARM:
+	      if (name)
+		error_at (loc, "storage class specified for parameter %qE",
+		    	  name);
+	      else
+		error_at (loc, "storage class specified for unnamed parameter");
+	      break;
+	    default:
+	      error_at (loc, "storage class specified for typename");
+	      break;
+	    }
+	  storage_class = csc_none;
+	  threadp = false;
+	}
     }
   else if (storage_class == csc_extern
-       && initialized
-       && !funcdef_flag)
+	   && initialized
+	   && !funcdef_flag)
     {
       /* 'extern' with initialization is invalid if not at file scope.  */
        if (current_scope == file_scope)
@@ -5141,31 +5128,31 @@
               and C++ intersection.  */
            if (!(warn_cxx_compat && constp))
              warning_at (loc, 0, "%qE initialized and declared %<extern%>",
-             name);
+		 	 name);
          }
       else
-    error_at (loc, "%qE has both %<extern%> and initializer", name);
+	error_at (loc, "%qE has both %<extern%> and initializer", name);
     }
   else if (current_scope == file_scope)
     {
       if (storage_class == csc_auto)
-    error_at (loc, "file-scope declaration of %qE specifies %<auto%>",
-              name);
+	error_at (loc, "file-scope declaration of %qE specifies %<auto%>",
+	    	  name);
       if (pedantic && storage_class == csc_register)
-    pedwarn (input_location, OPT_pedantic,
-         "file-scope declaration of %qE specifies %<register%>", name);
+	pedwarn (input_location, OPT_pedantic,
+		 "file-scope declaration of %qE specifies %<register%>", name);
     }
   else
     {
       if (storage_class == csc_extern && funcdef_flag)
-    error_at (loc, "nested function %qE declared %<extern%>", name);
+	error_at (loc, "nested function %qE declared %<extern%>", name);
       else if (threadp && storage_class == csc_none)
-    {
-      error_at (loc, "function-scope %qE implicitly auto and declared "
-            "%<__thread%>",
-            name);
-      threadp = false;
-    }
+	{
+	  error_at (loc, "function-scope %qE implicitly auto and declared "
+		    "%<__thread%>",
+		    name);
+	  threadp = false;
+	}
     }
 
   /* Now figure out the structure of the declarator proper.
@@ -5181,38 +5168,38 @@
   while (declarator && declarator->kind != cdk_id)
     {
       if (type == error_mark_node)
-    {
-      declarator = declarator->declarator;
-      continue;
-    }
+	{
+	  declarator = declarator->declarator;
+	  continue;
+	}
 
       /* Each level of DECLARATOR is either a cdk_array (for ...[..]),
-     a cdk_pointer (for *...),
-     a cdk_function (for ...(...)),
-     a cdk_attrs (for nested attributes),
-     or a cdk_id (for the name being declared
-     or the place in an absolute declarator
-     where the name was omitted).
-     For the last case, we have just exited the loop.
-
-     At this point, TYPE is the type of elements of an array,
-     or for a function to return, or for a pointer to point to.
-     After this sequence of ifs, TYPE is the type of the
-     array or function or pointer, and DECLARATOR has had its
-     outermost layer removed.  */
+	 a cdk_pointer (for *...),
+	 a cdk_function (for ...(...)),
+	 a cdk_attrs (for nested attributes),
+	 or a cdk_id (for the name being declared
+	 or the place in an absolute declarator
+	 where the name was omitted).
+	 For the last case, we have just exited the loop.
+
+	 At this point, TYPE is the type of elements of an array,
+	 or for a function to return, or for a pointer to point to.
+	 After this sequence of ifs, TYPE is the type of the
+	 array or function or pointer, and DECLARATOR has had its
+	 outermost layer removed.  */
 
       if (array_ptr_quals != TYPE_UNQUALIFIED
-      || array_ptr_attrs != NULL_TREE
-      || array_parm_static)
-    {
-      /* Only the innermost declarator (making a parameter be of
-         array type which is converted to pointer type)
-         may have static or type qualifiers.  */
-      error_at (loc, "static or type qualifiers in non-parameter array declarator");
-      array_ptr_quals = TYPE_UNQUALIFIED;
-      array_ptr_attrs = NULL_TREE;
-      array_parm_static = 0;
-    }
+	  || array_ptr_attrs != NULL_TREE
+	  || array_parm_static)
+	{
+	  /* Only the innermost declarator (making a parameter be of
+	     array type which is converted to pointer type)
+	     may have static or type qualifiers.  */
+	  error_at (loc, "static or type qualifiers in non-parameter array declarator");
+	  array_ptr_quals = TYPE_UNQUALIFIED;
+	  array_ptr_attrs = NULL_TREE;
+	  array_parm_static = 0;
+	}
 
       switch (declarator->kind)
 	{
@@ -5272,6 +5259,7 @@
 		            "functions");
 		type = error_mark_node;
 	      }
+
 	    if (pedantic && !in_system_header && flexible_array_type_p (type))
 	      pedwarn (loc, OPT_pedantic,
 		       "invalid use of structure with flexible array member");
@@ -5561,7 +5549,6 @@
 		really_funcdef = (t->kind == cdk_id);
 	      }
 
-
 	    /* Declaring a function type.  Make sure we have a valid
 	       type for the function to return.  */
 	    if (type == error_mark_node)
@@ -5632,9 +5619,7 @@
             }
           else
 #endif
-            {
-              type = build_function_type (type, arg_types);
-            }
+	    type = build_function_type (type, arg_types);
 	    declarator = declarator->declarator;
 
 	    /* Set the TYPE_CONTEXTs for each tagged type which is local to
@@ -5653,6 +5638,7 @@
 	  {
 	    /* Merge any constancy or volatility into the target type
 	       for the pointer.  */
+
 	    if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
 		&& type_quals)
 	      pedwarn (loc, OPT_pedantic,
@@ -5666,13 +5652,16 @@
 	       emitted early enough to dominate all the possible later uses
 	       and late enough for the variables on which it depends to have
 	       been assigned.
+
 	       This is expected to happen automatically when the pointed-to
 	       type has a name/declaration of it's own, but special attention
 	       is required if the type is anonymous.
+
 	       We handle the NORMAL and FIELD contexts here by attaching an
 	       artificial TYPE_DECL to such pointed-to type.  This forces the
 	       sizes evaluation at a safe point and ensures it is not deferred
 	       until e.g. within a deeper conditional context.
+
 	       We expect nothing to be needed here for PARM or TYPENAME.
 	       Pushing a TYPE_DECL at this point for TYPENAME would actually
 	       be incorrect, as we might be in the middle of an expression
@@ -5698,7 +5687,6 @@
 	       that were given inside the `*'.  */
 	    type_quals = declarator->u.pointer_quals;
 
-
 	    declarator = declarator->declarator;
 	    break;
 	  }
@@ -5717,51 +5705,51 @@
   if (!ADDR_SPACE_GENERIC_P (address_space))
     {
       if (decl_context == NORMAL)
-    {
-      switch (storage_class)
-        {
-        case csc_auto:
-          error ("%qs combined with %<auto%> qualifier for %qE",
-             c_addr_space_name (address_space), name);
-          break;
-        case csc_register:
-          error ("%qs combined with %<register%> qualifier for %qE",
-             c_addr_space_name (address_space), name);
-          break;
-        case csc_none:
-          if (current_function_scope)
-        {
-          error ("%qs specified for auto variable %qE",
-             c_addr_space_name (address_space), name);
-          break;
-        }
-          break;
-        case csc_static:
-        case csc_extern:
-        case csc_typedef:
-          break;
-        default:
-          gcc_unreachable ();
-        }
-    }
+	{
+	  switch (storage_class)
+	    {
+	    case csc_auto:
+	      error ("%qs combined with %<auto%> qualifier for %qE",
+		     c_addr_space_name (address_space), name);
+	      break;
+	    case csc_register:
+	      error ("%qs combined with %<register%> qualifier for %qE",
+		     c_addr_space_name (address_space), name);
+	      break;
+	    case csc_none:
+	      if (current_function_scope)
+		{
+		  error ("%qs specified for auto variable %qE",
+			 c_addr_space_name (address_space), name);
+		  break;
+		}
+	      break;
+	    case csc_static:
+	    case csc_extern:
+	    case csc_typedef:
+	      break;
+	    default:
+	      gcc_unreachable ();
+	    }
+	}
       else if (decl_context == PARM && TREE_CODE (type) != ARRAY_TYPE)
-    {
-      if (name)
-        error ("%qs specified for parameter %qE",
-           c_addr_space_name (address_space), name);
-      else
-        error ("%qs specified for unnamed parameter",
-           c_addr_space_name (address_space));
-    }
+	{
+	  if (name)
+	    error ("%qs specified for parameter %qE",
+		   c_addr_space_name (address_space), name);
+	  else
+	    error ("%qs specified for unnamed parameter",
+		   c_addr_space_name (address_space));
+	}
       else if (decl_context == FIELD)
-    {
-      if (name)
-        error ("%qs specified for structure field %qE",
-           c_addr_space_name (address_space), name);
-      else
-        error ("%qs specified for structure field",
-           c_addr_space_name (address_space));
-    }
+	{
+	  if (name)
+	    error ("%qs specified for structure field %qE",
+		   c_addr_space_name (address_space), name);
+	  else
+	    error ("%qs specified for structure field",
+		   c_addr_space_name (address_space));
+	}
     }
 
   /* Check the type and width of a bit-field.  */
@@ -5776,11 +5764,11 @@
       && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
     {
       if (name)
-    error_at (loc, "size of array %qE is too large", name);
+	error_at (loc, "size of array %qE is too large", name);
       else
-    error_at (loc, "size of unnamed array is too large");
+	error_at (loc, "size of unnamed array is too large");
       /* If we proceed with the array type as it is, we'll eventually
-     crash in tree_low_cst().  */
+	 crash in tree_low_cst().  */
       type = error_mark_node;
     }
 
@@ -5790,36 +5778,36 @@
     {
       tree decl;
       if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
-      && type_quals)
-    pedwarn (loc, OPT_pedantic,
-         "ISO C forbids qualified function types");
+	  && type_quals)
+	pedwarn (loc, OPT_pedantic,
+		 "ISO C forbids qualified function types");
       if (type_quals)
-    type = c_build_qualified_type (type, type_quals);
+	type = c_build_qualified_type (type, type_quals);
       decl = build_decl (declarator->id_loc,
-             TYPE_DECL, declarator->u.id, type);
+			 TYPE_DECL, declarator->u.id, type);
       if (declspecs->explicit_signed_p)
-    C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
+	C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
       if (declspecs->inline_p)
-    pedwarn (loc, 0,"typedef %q+D declared %<inline%>", decl);
+	pedwarn (loc, 0,"typedef %q+D declared %<inline%>", decl);
 
       if (warn_cxx_compat && declarator->u.id != NULL_TREE)
-    {
-      struct c_binding *b = I_TAG_BINDING (declarator->u.id);
-
-      if (b != NULL
-          && b->decl != NULL_TREE
-          && (B_IN_CURRENT_SCOPE (b)
-          || (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b)))
-          && TYPE_MAIN_VARIANT (b->decl) != TYPE_MAIN_VARIANT (type))
-        {
-          warning_at (declarator->id_loc, OPT_Wc___compat,
-              ("using %qD as both a typedef and a tag is "
-               "invalid in C++"),
-              decl);
-          if (b->locus != UNKNOWN_LOCATION)
-        inform (b->locus, "originally defined here");
-        }
-    }
+	{
+	  struct c_binding *b = I_TAG_BINDING (declarator->u.id);
+
+	  if (b != NULL
+	      && b->decl != NULL_TREE
+	      && (B_IN_CURRENT_SCOPE (b)
+		  || (current_scope == file_scope && B_IN_EXTERNAL_SCOPE (b)))
+	      && TYPE_MAIN_VARIANT (b->decl) != TYPE_MAIN_VARIANT (type))
+	    {
+	      warning_at (declarator->id_loc, OPT_Wc___compat,
+			  ("using %qD as both a typedef and a tag is "
+			   "invalid in C++"),
+			  decl);
+	      if (b->locus != UNKNOWN_LOCATION)
+		inform (b->locus, "originally defined here");
+	    }
+	}
 
       return decl;
     }
@@ -5830,15 +5818,15 @@
   if (decl_context == TYPENAME)
     {
       /* Note that the grammar rejects storage classes in typenames
-     and fields.  */
+	 and fields.  */
       gcc_assert (storage_class == csc_none && !threadp
-          && !declspecs->inline_p);
+		  && !declspecs->inline_p);
       if (pedantic && TREE_CODE (type) == FUNCTION_TYPE
-      && type_quals)
-    pedwarn (loc, OPT_pedantic,
-         "ISO C forbids const or volatile function types");
+	  && type_quals)
+	pedwarn (loc, OPT_pedantic,
+		 "ISO C forbids const or volatile function types");
       if (type_quals)
-    type = c_build_qualified_type (type, type_quals);
+	type = c_build_qualified_type (type, type_quals);
       return type;
     }
 
@@ -5847,7 +5835,7 @@
     {
       /* C99 6.7.2.1p8 */
       pedwarn (loc, OPT_pedantic, "a member of a structure or union cannot "
-           "have a variably modified type");
+	       "have a variably modified type");
     }
 
   /* Aside from typedefs and type names (handle above),
@@ -5858,10 +5846,10 @@
 
   if (VOID_TYPE_P (type) && decl_context != PARM
       && !((decl_context != FIELD && TREE_CODE (type) != FUNCTION_TYPE)
-        && (storage_class == csc_extern
-        || (current_scope == file_scope
-            && !(storage_class == csc_static
-             || storage_class == csc_register)))))
+	    && (storage_class == csc_extern
+		|| (current_scope == file_scope
+		    && !(storage_class == csc_static
+			 || storage_class == csc_register)))))
     {
       error_at (loc, "variable or field %qE declared void", name);
       type = integer_type_node;
@@ -5875,93 +5863,93 @@
 
     if (decl_context == PARM)
       {
-    tree promoted_type;
-
-    /* A parameter declared as an array of T is really a pointer to T.
-       One declared as a function is really a pointer to a function.  */
-
-    if (TREE_CODE (type) == ARRAY_TYPE)
-      {
-        /* Transfer const-ness of array into that of type pointed to.  */
-        type = TREE_TYPE (type);
-        if (type_quals)
-          type = c_build_qualified_type (type, type_quals);
-        type = build_pointer_type (type);
-        type_quals = array_ptr_quals;
-        if (type_quals)
-          type = c_build_qualified_type (type, type_quals);
-
-        /* We don't yet implement attributes in this context.  */
-        if (array_ptr_attrs != NULL_TREE)
-          warning_at (loc, OPT_Wattributes,
-              "attributes in parameter array declarator ignored");
-
-        size_varies = false;
-      }
-    else if (TREE_CODE (type) == FUNCTION_TYPE)
-      {
-        if (type_quals)
-          pedwarn (loc, OPT_pedantic,
-               "ISO C forbids qualified function types");
-        if (type_quals)
-          type = c_build_qualified_type (type, type_quals);
-        type = build_pointer_type (type);
-        type_quals = TYPE_UNQUALIFIED;
-      }
-    else if (type_quals)
-      type = c_build_qualified_type (type, type_quals);
-
-    decl = build_decl (declarator->id_loc,
-               PARM_DECL, declarator->u.id, type);
-    if (size_varies)
-      C_DECL_VARIABLE_SIZE (decl) = 1;
-
-    /* Compute the type actually passed in the parmlist,
-       for the case where there is no prototype.
-       (For example, shorts and chars are passed as ints.)
-       When there is a prototype, this is overridden later.  */
-
-    if (type == error_mark_node)
-      promoted_type = type;
-    else
-      promoted_type = c_type_promotes_to (type);
-
-    DECL_ARG_TYPE (decl) = promoted_type;
-    if (declspecs->inline_p)
-      pedwarn (loc, 0, "parameter %q+D declared %<inline%>", decl);
+	tree promoted_type;
+
+	/* A parameter declared as an array of T is really a pointer to T.
+	   One declared as a function is really a pointer to a function.  */
+
+	if (TREE_CODE (type) == ARRAY_TYPE)
+	  {
+	    /* Transfer const-ness of array into that of type pointed to.  */
+	    type = TREE_TYPE (type);
+	    if (type_quals)
+	      type = c_build_qualified_type (type, type_quals);
+	    type = build_pointer_type (type);
+	    type_quals = array_ptr_quals;
+	    if (type_quals)
+	      type = c_build_qualified_type (type, type_quals);
+
+	    /* We don't yet implement attributes in this context.  */
+	    if (array_ptr_attrs != NULL_TREE)
+	      warning_at (loc, OPT_Wattributes,
+			  "attributes in parameter array declarator ignored");
+
+	    size_varies = false;
+	  }
+	else if (TREE_CODE (type) == FUNCTION_TYPE)
+	  {
+	    if (type_quals)
+	      pedwarn (loc, OPT_pedantic,
+		       "ISO C forbids qualified function types");
+	    if (type_quals)
+	      type = c_build_qualified_type (type, type_quals);
+	    type = build_pointer_type (type);
+	    type_quals = TYPE_UNQUALIFIED;
+	  }
+	else if (type_quals)
+	  type = c_build_qualified_type (type, type_quals);
+
+	decl = build_decl (declarator->id_loc,
+			   PARM_DECL, declarator->u.id, type);
+	if (size_varies)
+	  C_DECL_VARIABLE_SIZE (decl) = 1;
+
+	/* Compute the type actually passed in the parmlist,
+	   for the case where there is no prototype.
+	   (For example, shorts and chars are passed as ints.)
+	   When there is a prototype, this is overridden later.  */
+
+	if (type == error_mark_node)
+	  promoted_type = type;
+	else
+	  promoted_type = c_type_promotes_to (type);
+
+	DECL_ARG_TYPE (decl) = promoted_type;
+	if (declspecs->inline_p)
+	  pedwarn (loc, 0, "parameter %q+D declared %<inline%>", decl);
       }
     else if (decl_context == FIELD)
       {
-    /* Note that the grammar rejects storage classes in typenames
-       and fields.  */
-    gcc_assert (storage_class == csc_none && !threadp
-            && !declspecs->inline_p);
-
-    /* Structure field.  It may not be a function.  */
-
-    if (TREE_CODE (type) == FUNCTION_TYPE)
-      {
-        error_at (loc, "field %qE declared as a function", name);
-        type = build_pointer_type (type);
-      }
-    else if (TREE_CODE (type) != ERROR_MARK
-         && !COMPLETE_OR_UNBOUND_ARRAY_TYPE_P (type))
-      {
-        if (name)
-          error_at (loc, "field %qE has incomplete type", name);
-        else
-          error_at (loc, "unnamed field has incomplete type");
-        type = error_mark_node;
-      }
-    type = c_build_qualified_type (type, type_quals);
-    decl = build_decl (declarator->id_loc,
-               FIELD_DECL, declarator->u.id, type);
-    DECL_NONADDRESSABLE_P (decl) = bitfield;
-    if (bitfield && !declarator->u.id)
-      TREE_NO_WARNING (decl) = 1;
-
-    if (size_varies)
-      C_DECL_VARIABLE_SIZE (decl) = 1;
+	/* Note that the grammar rejects storage classes in typenames
+	   and fields.  */
+	gcc_assert (storage_class == csc_none && !threadp
+		    && !declspecs->inline_p);
+
+	/* Structure field.  It may not be a function.  */
+
+	if (TREE_CODE (type) == FUNCTION_TYPE)
+	  {
+	    error_at (loc, "field %qE declared as a function", name);
+	    type = build_pointer_type (type);
+	  }
+	else if (TREE_CODE (type) != ERROR_MARK
+		 && !COMPLETE_OR_UNBOUND_ARRAY_TYPE_P (type))
+	  {
+	    if (name)
+	      error_at (loc, "field %qE has incomplete type", name);
+	    else
+	      error_at (loc, "unnamed field has incomplete type");
+	    type = error_mark_node;
+	  }
+	type = c_build_qualified_type (type, type_quals);
+	decl = build_decl (declarator->id_loc,
+			   FIELD_DECL, declarator->u.id, type);
+	DECL_NONADDRESSABLE_P (decl) = bitfield;
+	if (bitfield && !declarator->u.id)
+	  TREE_NO_WARNING (decl) = 1;
+
+	if (size_varies)
+	  C_DECL_VARIABLE_SIZE (decl) = 1;
       }
     else if (TREE_CODE (type) == FUNCTION_TYPE)
       {
@@ -5989,7 +5977,6 @@
 	      }
 	  }
 
-
 	decl = build_decl (declarator->id_loc,
 			   FUNCTION_DECL, declarator->u.id, type);
 	decl = build_decl_attribute_variant (decl, decl_attr);
@@ -6040,76 +6027,76 @@
       }
     else
       {
-    /* It's a variable.  */
-    /* An uninitialized decl with `extern' is a reference.  */
-    int extern_ref = !initialized && storage_class == csc_extern;
-
-    type = c_build_qualified_type (type, type_quals);
-
-    /* C99 6.2.2p7: It is invalid (compile-time undefined
-       behavior) to create an 'extern' declaration for a
-       variable if there is a global declaration that is
-       'static' and the global declaration is not visible.
-       (If the static declaration _is_ currently visible,
-       the 'extern' declaration is taken to refer to that decl.) */
-    if (extern_ref && current_scope != file_scope)
-      {
-        tree global_decl  = identifier_global_value (declarator->u.id);
-        tree visible_decl = lookup_name (declarator->u.id);
-
-        if (global_decl
-        && global_decl != visible_decl
-        && TREE_CODE (global_decl) == VAR_DECL
-        && !TREE_PUBLIC (global_decl))
-          error_at (loc, "variable previously declared %<static%> "
-            "redeclared %<extern%>");
-      }
-
-    decl = build_decl (declarator->id_loc,
-               VAR_DECL, declarator->u.id, type);
-    if (size_varies)
-      C_DECL_VARIABLE_SIZE (decl) = 1;
-
-    if (declspecs->inline_p)
-      pedwarn (loc, 0, "variable %q+D declared %<inline%>", decl);
-
-    /* At file scope, an initialized extern declaration may follow
-       a static declaration.  In that case, DECL_EXTERNAL will be
-       reset later in start_decl.  */
-    DECL_EXTERNAL (decl) = (storage_class == csc_extern);
-
-    /* At file scope, the presence of a `static' or `register' storage
-       class specifier, or the absence of all storage class specifiers
-       makes this declaration a definition (perhaps tentative).  Also,
-       the absence of `static' makes it public.  */
-    if (current_scope == file_scope)
-      {
-        TREE_PUBLIC (decl) = storage_class != csc_static;
-        TREE_STATIC (decl) = !extern_ref;
-      }
-    /* Not at file scope, only `static' makes a static definition.  */
-    else
-      {
-        TREE_STATIC (decl) = (storage_class == csc_static);
-        TREE_PUBLIC (decl) = extern_ref;
-      }
-
-    if (threadp)
-      DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
+	/* It's a variable.  */
+	/* An uninitialized decl with `extern' is a reference.  */
+	int extern_ref = !initialized && storage_class == csc_extern;
+
+	type = c_build_qualified_type (type, type_quals);
+
+	/* C99 6.2.2p7: It is invalid (compile-time undefined
+	   behavior) to create an 'extern' declaration for a
+	   variable if there is a global declaration that is
+	   'static' and the global declaration is not visible.
+	   (If the static declaration _is_ currently visible,
+	   the 'extern' declaration is taken to refer to that decl.) */
+	if (extern_ref && current_scope != file_scope)
+	  {
+	    tree global_decl  = identifier_global_value (declarator->u.id);
+	    tree visible_decl = lookup_name (declarator->u.id);
+
+	    if (global_decl
+		&& global_decl != visible_decl
+		&& TREE_CODE (global_decl) == VAR_DECL
+		&& !TREE_PUBLIC (global_decl))
+	      error_at (loc, "variable previously declared %<static%> "
+			"redeclared %<extern%>");
+	  }
+
+	decl = build_decl (declarator->id_loc,
+			   VAR_DECL, declarator->u.id, type);
+	if (size_varies)
+	  C_DECL_VARIABLE_SIZE (decl) = 1;
+
+	if (declspecs->inline_p)
+	  pedwarn (loc, 0, "variable %q+D declared %<inline%>", decl);
+
+	/* At file scope, an initialized extern declaration may follow
+	   a static declaration.  In that case, DECL_EXTERNAL will be
+	   reset later in start_decl.  */
+	DECL_EXTERNAL (decl) = (storage_class == csc_extern);
+
+	/* At file scope, the presence of a `static' or `register' storage
+	   class specifier, or the absence of all storage class specifiers
+	   makes this declaration a definition (perhaps tentative).  Also,
+	   the absence of `static' makes it public.  */
+	if (current_scope == file_scope)
+	  {
+	    TREE_PUBLIC (decl) = storage_class != csc_static;
+	    TREE_STATIC (decl) = !extern_ref;
+	  }
+	/* Not at file scope, only `static' makes a static definition.  */
+	else
+	  {
+	    TREE_STATIC (decl) = (storage_class == csc_static);
+	    TREE_PUBLIC (decl) = extern_ref;
+	  }
+
+	if (threadp)
+	  DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
       }
 
     if ((storage_class == csc_extern
-     || (storage_class == csc_none
-         && TREE_CODE (type) == FUNCTION_TYPE
-         && !funcdef_flag))
-    && variably_modified_type_p (type, NULL_TREE))
+	 || (storage_class == csc_none
+	     && TREE_CODE (type) == FUNCTION_TYPE
+	     && !funcdef_flag))
+	&& variably_modified_type_p (type, NULL_TREE))
       {
-    /* C99 6.7.5.2p2 */
-    if (TREE_CODE (type) == FUNCTION_TYPE)
-      error_at (loc, "non-nested function with variably modified type");
-    else
-      error_at (loc, "object with variably modified type must have "
-                "no linkage");
+	/* C99 6.7.5.2p2 */
+	if (TREE_CODE (type) == FUNCTION_TYPE)
+	  error_at (loc, "non-nested function with variably modified type");
+	else
+	  error_at (loc, "object with variably modified type must have "
+	      	    "no linkage");
       }
 
     /* Record `register' declaration for warnings on &
@@ -6117,8 +6104,8 @@
 
     if (storage_class == csc_register)
       {
-    C_DECL_REGISTER (decl) = 1;
-    DECL_REGISTER (decl) = 1;
+	C_DECL_REGISTER (decl) = 1;
+	DECL_REGISTER (decl) = 1;
       }
 
     /* Record constancy and volatility.  */
@@ -6129,17 +6116,17 @@
        will be ignored, and would even crash the compiler.
        Of course, this only makes sense on  VAR,PARM, and RESULT decl's.   */
     if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (decl))
-    && (TREE_CODE (decl) == VAR_DECL ||  TREE_CODE (decl) == PARM_DECL
-      || TREE_CODE (decl) == RESULT_DECL))
+	&& (TREE_CODE (decl) == VAR_DECL ||  TREE_CODE (decl) == PARM_DECL
+	  || TREE_CODE (decl) == RESULT_DECL))
       {
-    /* It is not an error for a structure with volatile fields to
-       be declared register, but reset DECL_REGISTER since it
-       cannot actually go in a register.  */
-    int was_reg = C_DECL_REGISTER (decl);
-    C_DECL_REGISTER (decl) = 0;
-    DECL_REGISTER (decl) = 0;
-    c_mark_addressable (decl);
-    C_DECL_REGISTER (decl) = was_reg;
+	/* It is not an error for a structure with volatile fields to
+	   be declared register, but reset DECL_REGISTER since it
+	   cannot actually go in a register.  */
+	int was_reg = C_DECL_REGISTER (decl);
+	C_DECL_REGISTER (decl) = 0;
+	DECL_REGISTER (decl) = 0;
+	c_mark_addressable (decl);
+	C_DECL_REGISTER (decl) = was_reg;
       }
 
   /* This is the earliest point at which we might know the assembler
@@ -6147,17 +6134,17 @@
     gcc_assert (!DECL_ASSEMBLER_NAME_SET_P (decl));
 
     if (warn_cxx_compat
-    && TREE_CODE (decl) == VAR_DECL
-    && TREE_PUBLIC (decl)
-    && TREE_STATIC (decl)
-    && (TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
-        || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
-        || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
-    && TYPE_NAME (TREE_TYPE (decl)) == NULL_TREE)
+	&& TREE_CODE (decl) == VAR_DECL
+	&& TREE_PUBLIC (decl)
+	&& TREE_STATIC (decl)
+	&& (TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
+	    || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
+	    || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
+	&& TYPE_NAME (TREE_TYPE (decl)) == NULL_TREE)
       warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wc___compat,
-          ("non-local variable %qD with anonymous type is "
-           "questionable in C++"),
-          decl);
+		  ("non-local variable %qD with anonymous type is "
+		   "questionable in C++"),
+		  decl);
 
     return decl;
   }
@@ -6191,7 +6178,7 @@
 
   if (arg_types == 0 && !funcdef_flag && !in_system_header)
     warning (OPT_Wstrict_prototypes,
-         "function declaration isn%'t a prototype");
+	     "function declaration isn%'t a prototype");
 
   if (arg_types == error_mark_node)
     return 0;  /* don't set TYPE_ARG_TYPES in this case */
@@ -6205,6 +6192,7 @@
 	}
       else
 	arg_info->parms = arg_info->types;
+
       arg_info->types = 0;
       return 0;
     }
@@ -6215,13 +6203,13 @@
       const char *errmsg;
 
       /* If there is a parameter of incomplete type in a definition,
-     this is an error.  In a declaration this is valid, and a
-     struct or union type may be completed later, before any calls
-     or definition of the function.  In the case where the tag was
-     first declared within the parameter list, a warning has
-     already been given.  If a parameter has void type, then
-     however the function cannot be defined or called, so
-     warn.  */
+	 this is an error.  In a declaration this is valid, and a
+	 struct or union type may be completed later, before any calls
+	 or definition of the function.  In the case where the tag was
+	 first declared within the parameter list, a warning has
+	 already been given.  If a parameter has void type, then
+	 however the function cannot be defined or called, so
+	 warn.  */
 
       for (parm = arg_info->parms, typelt = arg_types, parmno = 1;
 	   parm;
@@ -6330,19 +6318,19 @@
      (by 'const' or 'volatile'), or has a storage class specifier
      ('register'), then the behavior is undefined; issue an error.
      Typedefs for 'void' are OK (see DR#157).  */
-  if (b->prev == 0              /* one binding */
+  if (b->prev == 0			    /* one binding */
       && TREE_CODE (b->decl) == PARM_DECL   /* which is a parameter */
       && !DECL_NAME (b->decl)               /* anonymous */
       && VOID_TYPE_P (TREE_TYPE (b->decl))) /* of void type */
     {
       if (TREE_THIS_VOLATILE (b->decl)
-      || TREE_READONLY (b->decl)
-      || C_DECL_REGISTER (b->decl))
-    error ("%<void%> as only parameter may not be qualified");
+	  || TREE_READONLY (b->decl)
+	  || C_DECL_REGISTER (b->decl))
+	error ("%<void%> as only parameter may not be qualified");
 
       /* There cannot be an ellipsis.  */
       if (ellipsis)
-    error ("%<void%> must be the only parameter");
+	error ("%<void%> must be the only parameter");
 
       arg_info->types = void_list_node;
       return arg_info;
@@ -6516,33 +6504,33 @@
   if (ref && TREE_CODE (ref) == code)
     {
       if (C_TYPE_DEFINED_IN_STRUCT (ref)
-      && loc != UNKNOWN_LOCATION
-      && warn_cxx_compat)
-    {
-      switch (code)
-        {
-        case ENUMERAL_TYPE:
-          warning_at (loc, OPT_Wc___compat,
-              ("enum type defined in struct or union "
-               "is not visible in C++"));
-          inform (refloc, "enum type defined here");
-          break;
-        case RECORD_TYPE:
-          warning_at (loc, OPT_Wc___compat,
-              ("struct defined in struct or union "
-               "is not visible in C++"));
-          inform (refloc, "struct defined here");
-          break;
-        case UNION_TYPE:
-          warning_at (loc, OPT_Wc___compat,
-              ("union defined in struct or union "
-               "is not visible in C++"));
-          inform (refloc, "union defined here");
-          break;
-        default:
-          gcc_unreachable();
-        }
-    }
+	  && loc != UNKNOWN_LOCATION
+	  && warn_cxx_compat)
+	{
+	  switch (code)
+	    {
+	    case ENUMERAL_TYPE:
+	      warning_at (loc, OPT_Wc___compat,
+			  ("enum type defined in struct or union "
+			   "is not visible in C++"));
+	      inform (refloc, "enum type defined here");
+	      break;
+	    case RECORD_TYPE:
+	      warning_at (loc, OPT_Wc___compat,
+			  ("struct defined in struct or union "
+			   "is not visible in C++"));
+	      inform (refloc, "struct defined here");
+	      break;
+	    case UNION_TYPE:
+	      warning_at (loc, OPT_Wc___compat,
+			  ("union defined in struct or union "
+			   "is not visible in C++"));
+	      inform (refloc, "union defined here");
+	      break;
+	    default:
+	      gcc_unreachable();
+	    }
+	}
 
       ret.spec = ref;
       return ret;
@@ -6557,7 +6545,7 @@
   if (code == ENUMERAL_TYPE)
     {
       /* Give the type a default layout like unsigned int
-     to avoid crashing if it does not get defined.  */
+	 to avoid crashing if it does not get defined.  */
       SET_TYPE_MODE (ref, TYPE_MODE (unsigned_type_node));
       TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
       TYPE_USER_ALIGN (ref) = 0;
@@ -6595,7 +6583,7 @@
 
 tree
 start_struct (location_t loc, enum tree_code code, tree name,
-          struct c_struct_parse_info **enclosing_struct_parse_info)
+	      struct c_struct_parse_info **enclosing_struct_parse_info)
 {
   /* If there is already a tag defined at this scope
      (as a forward reference), just return it.  */
@@ -6608,28 +6596,28 @@
   if (ref && TREE_CODE (ref) == code)
     {
       if (TYPE_SIZE (ref))
-    {
-      if (code == UNION_TYPE)
-        error_at (loc, "redefinition of %<union %E%>", name);
-      else
-        error_at (loc, "redefinition of %<struct %E%>", name);
-      if (refloc != UNKNOWN_LOCATION)
-        inform (refloc, "originally defined here");
-      /* Don't create structures using a name already in use.  */
-      ref = NULL_TREE;
-    }
+	{
+	  if (code == UNION_TYPE)
+	    error_at (loc, "redefinition of %<union %E%>", name);
+	  else
+	    error_at (loc, "redefinition of %<struct %E%>", name);
+	  if (refloc != UNKNOWN_LOCATION)
+	    inform (refloc, "originally defined here");
+	  /* Don't create structures using a name already in use.  */
+	  ref = NULL_TREE;
+	}
       else if (C_TYPE_BEING_DEFINED (ref))
-    {
-      if (code == UNION_TYPE)
-        error_at (loc, "nested redefinition of %<union %E%>", name);
-      else
-        error_at (loc, "nested redefinition of %<struct %E%>", name);
-      /* Don't bother to report "originally defined here" for a
-         nested redefinition; the original definition should be
-         obvious.  */
-      /* Don't create structures that contain themselves.  */
-      ref = NULL_TREE;
-    }
+	{
+	  if (code == UNION_TYPE)
+	    error_at (loc, "nested redefinition of %<union %E%>", name);
+	  else
+	    error_at (loc, "nested redefinition of %<struct %E%>", name);
+	  /* Don't bother to report "originally defined here" for a
+	     nested redefinition; the original definition should be
+	     obvious.  */
+	  /* Don't create structures that contain themselves.  */
+	  ref = NULL_TREE;
+	}
     }
 
   /* Otherwise create a forward-reference just so the tag is in scope.  */
@@ -6655,10 +6643,10 @@
      sizeof anyhow.  */
   if (warn_cxx_compat && (in_sizeof || in_typeof || in_alignof))
     warning_at (loc, OPT_Wc___compat,
-        "defining type in %qs expression is invalid in C++",
-        (in_sizeof
-         ? "sizeof"
-         : (in_typeof ? "typeof" : "alignof")));
+		"defining type in %qs expression is invalid in C++",
+		(in_sizeof
+		 ? "sizeof"
+		 : (in_typeof ? "typeof" : "alignof")));
 
   return ref;
 }
@@ -6676,8 +6664,8 @@
 
 tree
 grokfield (location_t loc,
-       struct c_declarator *declarator, struct c_declspecs *declspecs,
-       tree width, tree *decl_attrs)
+	   struct c_declarator *declarator, struct c_declspecs *declspecs,
+	   tree width, tree *decl_attrs)
 {
   tree value;
 
@@ -6707,7 +6695,7 @@
 
       tree type = declspecs->type;
       bool type_ok = (TREE_CODE (type) == RECORD_TYPE
-              || TREE_CODE (type) == UNION_TYPE);
+		      || TREE_CODE (type) == UNION_TYPE);
       bool ok = false;
 
       if (type_ok)
@@ -6719,8 +6707,6 @@
 	  else
 	    ok = false;
 	}
-
-
       if (!ok)
 	{
 	  pedwarn (loc, 0, "declaration does not declare anything");
@@ -6738,8 +6724,8 @@
     }
 
   value = grokdeclarator (declarator, declspecs, FIELD, false,
-              width ? &width : NULL, decl_attrs, NULL, NULL,
-              DEPRECATED_NORMAL);
+			  width ? &width : NULL, decl_attrs, NULL, NULL,
+			  DEPRECATED_NORMAL);
 
   finish_decl (value, loc, NULL_TREE, NULL_TREE, NULL_TREE);
   DECL_INITIAL (value) = width;
@@ -6747,20 +6733,20 @@
   if (warn_cxx_compat && DECL_NAME (value) != NULL_TREE)
     {
       /* If we currently have a binding for this field, set the
-     in_struct field in the binding, so that we warn about lookups
-     which find it.  */
+	 in_struct field in the binding, so that we warn about lookups
+	 which find it.  */
       struct c_binding *b = I_SYMBOL_BINDING (DECL_NAME (value));
       if (b != NULL)
-    {
-      /* If the in_struct field is not yet set, push it on a list
-         to be cleared when this struct is finished.  */
-      if (!b->in_struct)
-        {
-          VEC_safe_push (c_binding_ptr, heap,
-                 struct_parse_info->fields, b);
-          b->in_struct = 1;
-        }
-    }
+	{
+	  /* If the in_struct field is not yet set, push it on a list
+	     to be cleared when this struct is finished.  */
+	  if (!b->in_struct)
+	    {
+	      VEC_safe_push (c_binding_ptr, heap,
+			     struct_parse_info->fields, b);
+	      b->in_struct = 1;
+	    }
+	}
     }
 
   return value;
@@ -6944,7 +6930,7 @@
       && fieldlist != NULL_TREE)
     {
       /* Use a pointer_set using the name of the typedef.  We can use
-     a pointer_set because identifiers are interned.  */
+	 a pointer_set because identifiers are interned.  */
       struct pointer_set_t *tset = pointer_set_create ();
 
       FOR_EACH_VEC_ELT (tree, struct_parse_info->typedefs_seen, ix, x)
@@ -6963,6 +6949,7 @@
 		 the typedef name is used.  */
 	    }
 	}
+
       pointer_set_destroy (tset);
     }
 
@@ -6982,7 +6969,7 @@
 
 tree
 finish_struct (location_t loc, tree t, tree fieldlist, tree attributes,
-           struct c_struct_parse_info *enclosing_struct_parse_info)
+	       struct c_struct_parse_info *enclosing_struct_parse_info)
 {
   tree x;
   bool toplevel = file_scope == current_scope;
@@ -7008,22 +6995,22 @@
 	}
 
       if (x == 0)
-    {
-      if (TREE_CODE (t) == UNION_TYPE)
-        {
-          if (fieldlist)
-        pedwarn (loc, OPT_pedantic, "union has no named members");
-          else
-        pedwarn (loc, OPT_pedantic, "union has no members");
-        }
-      else
-        {
-          if (fieldlist)
-        pedwarn (loc, OPT_pedantic, "struct has no named members");
-          else
-        pedwarn (loc, OPT_pedantic, "struct has no members");
-        }
-    }
+	{
+	  if (TREE_CODE (t) == UNION_TYPE)
+	    {
+	      if (fieldlist)
+		pedwarn (loc, OPT_pedantic, "union has no named members");
+	      else
+		pedwarn (loc, OPT_pedantic, "union has no members");
+	    }
+	  else
+	    {
+	      if (fieldlist)
+		pedwarn (loc, OPT_pedantic, "struct has no named members");
+	      else
+		pedwarn (loc, OPT_pedantic, "struct has no members");
+	    }
+	}
     }
 
   /* Install struct as DECL_CONTEXT of each field decl.
@@ -7037,13 +7024,13 @@
   for (x = fieldlist; x; x = DECL_CHAIN (x))
     {
       if (TREE_TYPE (x) == error_mark_node)
-    continue;
+	continue;
 
       DECL_CONTEXT (x) = t;
 
       /* If any field is const, the structure type is pseudo-const.  */
       if (TREE_READONLY (x))
-    C_TYPE_FIELDS_READONLY (t) = 1;
+	C_TYPE_FIELDS_READONLY (t) = 1;
       else
 	{
 	  /* A field that is pseudo-const makes the structure likewise.  */
@@ -7054,26 +7041,26 @@
 	}
 
       /* Any field that is volatile means variables of this type must be
-     treated in some ways as volatile.  */
+	 treated in some ways as volatile.  */
       if (TREE_THIS_VOLATILE (x))
-    C_TYPE_FIELDS_VOLATILE (t) = 1;
+	C_TYPE_FIELDS_VOLATILE (t) = 1;
 
       /* Any field of nominal variable size implies structure is too.  */
       if (C_DECL_VARIABLE_SIZE (x))
-    C_TYPE_VARIABLE_SIZE (t) = 1;
+	C_TYPE_VARIABLE_SIZE (t) = 1;
 
       if (DECL_INITIAL (x))
-    {
-      unsigned HOST_WIDE_INT width = tree_low_cst (DECL_INITIAL (x), 1);
-      DECL_SIZE (x) = bitsize_int (width);
-      DECL_BIT_FIELD (x) = 1;
-      SET_DECL_C_BIT_FIELD (x);
-    }
+	{
+	  unsigned HOST_WIDE_INT width = tree_low_cst (DECL_INITIAL (x), 1);
+	  DECL_SIZE (x) = bitsize_int (width);
+	  DECL_BIT_FIELD (x) = 1;
+	  SET_DECL_C_BIT_FIELD (x);
+	}
 
       if (TYPE_PACKED (t)
-      && (DECL_BIT_FIELD (x)
-          || TYPE_ALIGN (TREE_TYPE (x)) > BITS_PER_UNIT))
-    DECL_PACKED (x) = 1;
+	  && (DECL_BIT_FIELD (x)
+	      || TYPE_ALIGN (TREE_TYPE (x)) > BITS_PER_UNIT))
+	DECL_PACKED (x) = 1;
 
       /* Detect flexible array member in an invalid context.  */
       if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
@@ -7102,9 +7089,9 @@
 	}
 
       if (pedantic && TREE_CODE (t) == RECORD_TYPE
-      && flexible_array_type_p (TREE_TYPE (x)))
-    pedwarn (DECL_SOURCE_LOCATION (x), OPT_pedantic,
-         "invalid use of structure with flexible array member");
+	  && flexible_array_type_p (TREE_TYPE (x)))
+	pedwarn (DECL_SOURCE_LOCATION (x), OPT_pedantic,
+		 "invalid use of structure with flexible array member");
 
       if (DECL_NAME (x)
 	  || TREE_CODE (TREE_TYPE (x)) == RECORD_TYPE
@@ -7126,19 +7113,19 @@
     tree *fieldlistp = &fieldlist;
     while (*fieldlistp)
       if (TREE_CODE (*fieldlistp) == FIELD_DECL && DECL_INITIAL (*fieldlistp)
-      && TREE_TYPE (*fieldlistp) != error_mark_node)
-    {
-      unsigned HOST_WIDE_INT width
-        = tree_low_cst (DECL_INITIAL (*fieldlistp), 1);
-      tree type = TREE_TYPE (*fieldlistp);
-      if (width != TYPE_PRECISION (type))
-        {
-          TREE_TYPE (*fieldlistp)
-        = c_build_bitfield_integer_type (width, TYPE_UNSIGNED (type));
-          DECL_MODE (*fieldlistp) = TYPE_MODE (TREE_TYPE (*fieldlistp));
-        }
-      DECL_INITIAL (*fieldlistp) = 0;
-    }
+	  && TREE_TYPE (*fieldlistp) != error_mark_node)
+	{
+	  unsigned HOST_WIDE_INT width
+	    = tree_low_cst (DECL_INITIAL (*fieldlistp), 1);
+	  tree type = TREE_TYPE (*fieldlistp);
+	  if (width != TYPE_PRECISION (type))
+	    {
+	      TREE_TYPE (*fieldlistp)
+		= c_build_bitfield_integer_type (width, TYPE_UNSIGNED (type));
+	      DECL_MODE (*fieldlistp) = TYPE_MODE (TREE_TYPE (*fieldlistp));
+	    }
+	  DECL_INITIAL (*fieldlistp) = 0;
+	}
       else
 	fieldlistp = &DECL_CHAIN (*fieldlistp);
   }
@@ -7156,9 +7143,9 @@
 
     for (x = fieldlist; x; x = DECL_CHAIN (x))
       {
-    if (len > 15 || DECL_NAME (x) == NULL)
-      break;
-    len += 1;
+	if (len > 15 || DECL_NAME (x) == NULL)
+	  break;
+	len += 1;
       }
 
     if (len > 15)
@@ -7226,16 +7213,16 @@
     {
       tree decl = TREE_VALUE (x);
       if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
-    layout_array_type (TREE_TYPE (decl));
+	layout_array_type (TREE_TYPE (decl));
       if (TREE_CODE (decl) != TYPE_DECL)
-    {
-      layout_decl (decl, 0);
-      if (c_dialect_objc ())
-        objc_check_decl (decl);
-      rest_of_decl_compilation (decl, toplevel, 0);
-      if (!toplevel)
-        expand_decl (decl);
-    }
+	{
+	  layout_decl (decl, 0);
+	  if (c_dialect_objc ())
+	    objc_check_decl (decl);
+	  rest_of_decl_compilation (decl, toplevel, 0);
+	  if (!toplevel)
+	    expand_decl (decl);
+	}
     }
   C_TYPE_INCOMPLETE_VARS (TYPE_MAIN_VARIANT (t)) = 0;
 
@@ -7252,7 +7239,7 @@
      to be bound now.  */
   if (cur_stmt_list && variably_modified_type_p (t, NULL_TREE))
     add_stmt (build_stmt (loc,
-              DECL_EXPR, build_decl (loc, TYPE_DECL, NULL, t)));
+			  DECL_EXPR, build_decl (loc, TYPE_DECL, NULL, t)));
 
   if (warn_cxx_compat)
     warn_cxx_compat_finish_struct (fieldlist);
@@ -7320,10 +7307,10 @@
       /* This enum is a named one that has been declared already.  */
       error_at (loc, "redeclaration of %<enum %E%>", name);
       if (enumloc != UNKNOWN_LOCATION)
-    inform (enumloc, "originally defined here");
+	inform (enumloc, "originally defined here");
 
       /* Completely replace its old definition.
-     The old enumerators remain defined, however.  */
+	 The old enumerators remain defined, however.  */
       TYPE_VALUES (enumtype) = 0;
     }
 
@@ -7338,10 +7325,10 @@
      as C++ doesn't permit statement exprs within sizeof anyhow.  */
   if (warn_cxx_compat && (in_sizeof || in_typeof || in_alignof))
     warning_at (loc, OPT_Wc___compat,
-        "defining type in %qs expression is invalid in C++",
-        (in_sizeof
-         ? "sizeof"
-         : (in_typeof ? "typeof" : "alignof")));
+		"defining type in %qs expression is invalid in C++",
+		(in_sizeof
+		 ? "sizeof"
+		 : (in_typeof ? "typeof" : "alignof")));
 
   return enumtype;
 }
@@ -7371,13 +7358,13 @@
     {
       minnode = maxnode = TREE_VALUE (values);
       for (pair = TREE_CHAIN (values); pair; pair = TREE_CHAIN (pair))
-    {
-      tree value = TREE_VALUE (pair);
-      if (tree_int_cst_lt (maxnode, value))
-        maxnode = value;
-      if (tree_int_cst_lt (value, minnode))
-        minnode = value;
-    }
+	{
+	  tree value = TREE_VALUE (pair);
+	  if (tree_int_cst_lt (maxnode, value))
+	    maxnode = value;
+	  if (tree_int_cst_lt (value, minnode))
+	    minnode = value;
+	}
     }
 
   /* Construct the final type of this enumeration.  It is the same
@@ -7386,16 +7373,16 @@
      the values are negative.  */
   unsign = (tree_int_cst_sgn (minnode) >= 0);
   precision = MAX (tree_int_cst_min_precision (minnode, unsign),
-           tree_int_cst_min_precision (maxnode, unsign));
+		   tree_int_cst_min_precision (maxnode, unsign));
 
   if (TYPE_PACKED (enumtype) || precision > TYPE_PRECISION (integer_type_node))
     {
       tem = c_common_type_for_size (precision, unsign);
       if (tem == NULL)
-    {
-      warning (0, "enumeration values exceed range of largest integer");
-      tem = long_long_integer_type_node;
-    }
+	{
+	  warning (0, "enumeration values exceed range of largest integer");
+	  tem = long_long_integer_type_node;
+	}
     }
   else
     tem = unsign ? unsigned_type_node : integer_type_node;
@@ -7410,7 +7397,7 @@
   if (TYPE_PRECISION (enumtype))
     {
       if (precision > TYPE_PRECISION (enumtype))
-    error ("specified mode too small for enumeral values");
+	error ("specified mode too small for enumeral values");
     }
   else
     TYPE_PRECISION (enumtype) = TYPE_PRECISION (tem);
@@ -7420,36 +7407,36 @@
   if (values != error_mark_node)
     {
       /* Change the type of the enumerators to be the enum type.  We
-     need to do this irrespective of the size of the enum, for
-     proper type checking.  Replace the DECL_INITIALs of the
-     enumerators, and the value slots of the list, with copies
-     that have the enum type; they cannot be modified in place
-     because they may be shared (e.g.  integer_zero_node) Finally,
-     change the purpose slots to point to the names of the decls.  */
+	 need to do this irrespective of the size of the enum, for
+	 proper type checking.  Replace the DECL_INITIALs of the
+	 enumerators, and the value slots of the list, with copies
+	 that have the enum type; they cannot be modified in place
+	 because they may be shared (e.g.  integer_zero_node) Finally,
+	 change the purpose slots to point to the names of the decls.  */
       for (pair = values; pair; pair = TREE_CHAIN (pair))
-    {
-      tree enu = TREE_PURPOSE (pair);
-      tree ini = DECL_INITIAL (enu);
-
-      TREE_TYPE (enu) = enumtype;
-
-      /* The ISO C Standard mandates enumerators to have type int,
-         even though the underlying type of an enum type is
-         unspecified.  However, GCC allows enumerators of any
-         integer type as an extensions.  build_enumerator()
-         converts any enumerators that fit in an int to type int,
-         to avoid promotions to unsigned types when comparing
-         integers with enumerators that fit in the int range.
-         When -pedantic is given, build_enumerator() would have
-         already warned about those that don't fit. Here we
-         convert the rest to the enumerator type. */
-      if (TREE_TYPE (ini) != integer_type_node)
-        ini = convert (enumtype, ini);
-
-      DECL_INITIAL (enu) = ini;
-      TREE_PURPOSE (pair) = DECL_NAME (enu);
-      TREE_VALUE (pair) = ini;
-    }
+	{
+	  tree enu = TREE_PURPOSE (pair);
+	  tree ini = DECL_INITIAL (enu);
+
+	  TREE_TYPE (enu) = enumtype;
+
+	  /* The ISO C Standard mandates enumerators to have type int,
+	     even though the underlying type of an enum type is
+	     unspecified.  However, GCC allows enumerators of any
+	     integer type as an extensions.  build_enumerator()
+	     converts any enumerators that fit in an int to type int,
+	     to avoid promotions to unsigned types when comparing
+	     integers with enumerators that fit in the int range.
+	     When -pedantic is given, build_enumerator() would have
+	     already warned about those that don't fit. Here we
+	     convert the rest to the enumerator type. */
+	  if (TREE_TYPE (ini) != integer_type_node)
+	    ini = convert (enumtype, ini);
+
+	  DECL_INITIAL (enu) = ini;
+	  TREE_PURPOSE (pair) = DECL_NAME (enu);
+	  TREE_VALUE (pair) = ini;
+	}
 
       TYPE_VALUES (enumtype) = values;
     }
@@ -7465,7 +7452,7 @@
   for (tem = TYPE_MAIN_VARIANT (enumtype); tem; tem = TYPE_NEXT_VARIANT (tem))
     {
       if (tem == enumtype)
-    continue;
+	continue;
       TYPE_VALUES (tem) = TYPE_VALUES (enumtype);
       TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype);
       TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
@@ -7510,37 +7497,37 @@
   if (value != 0)
     {
       /* Don't issue more errors for error_mark_node (i.e. an
-     undeclared identifier) - just ignore the value expression.  */
+	 undeclared identifier) - just ignore the value expression.  */
       if (value == error_mark_node)
-    value = 0;
+	value = 0;
       else if (!INTEGRAL_TYPE_P (TREE_TYPE (value)))
-    {
-      error_at (loc, "enumerator value for %qE is not an integer constant",
-            name);
-      value = 0;
-    }
+	{
+	  error_at (loc, "enumerator value for %qE is not an integer constant",
+		    name);
+	  value = 0;
+	}
       else
-    {
-      if (TREE_CODE (value) != INTEGER_CST)
-        {
-          value = c_fully_fold (value, false, NULL);
-          if (TREE_CODE (value) == INTEGER_CST)
-        pedwarn (loc, OPT_pedantic,
-             "enumerator value for %qE is not an integer "
-             "constant expression", name);
-        }
-      if (TREE_CODE (value) != INTEGER_CST)
-        {
-          error ("enumerator value for %qE is not an integer constant",
-             name);
-          value = 0;
-        }
-      else
-        {
-          value = default_conversion (value);
-          constant_expression_warning (value);
-        }
-    }
+	{
+	  if (TREE_CODE (value) != INTEGER_CST)
+	    {
+	      value = c_fully_fold (value, false, NULL);
+	      if (TREE_CODE (value) == INTEGER_CST)
+		pedwarn (loc, OPT_pedantic,
+			 "enumerator value for %qE is not an integer "
+			 "constant expression", name);
+	    }
+	  if (TREE_CODE (value) != INTEGER_CST)
+	    {
+	      error ("enumerator value for %qE is not an integer constant",
+		     name);
+	      value = 0;
+	    }
+	  else
+	    {
+	      value = default_conversion (value);
+	      constant_expression_warning (value);
+	    }
+	}
     }
 
   /* Default based on previous value.  */
@@ -7550,7 +7537,7 @@
     {
       value = the_enum->enum_next_value;
       if (the_enum->enum_overflow)
-    error_at (loc, "overflow in enumeration values");
+	error_at (loc, "overflow in enumeration values");
     }
   /* Even though the underlying type of an enum is unspecified, the
      type of enumeration constants is explicitly defined as int
@@ -7558,7 +7545,7 @@
      an extension.  */
   else if (!int_fits_type_p (value, integer_type_node))
     pedwarn (loc, OPT_pedantic,
-         "ISO C restricts enumerator values to range of %<int%>");
+	     "ISO C restricts enumerator values to range of %<int%>");
 
   /* The ISO C Standard mandates enumerators to have type int, even
      though the underlying type of an enum type is unspecified.
@@ -7582,10 +7569,10 @@
 
   type = TREE_TYPE (value);
   type = c_common_type_for_size (MAX (TYPE_PRECISION (type),
-                      TYPE_PRECISION (integer_type_node)),
-                 (TYPE_PRECISION (type)
-                  >= TYPE_PRECISION (integer_type_node)
-                  && TYPE_UNSIGNED (type)));
+				      TYPE_PRECISION (integer_type_node)),
+				 (TYPE_PRECISION (type)
+				  >= TYPE_PRECISION (integer_type_node)
+				  && TYPE_UNSIGNED (type)));
 
   decl = build_decl (decl_loc, CONST_DECL, name, type);
   DECL_INITIAL (decl) = convert (type, value);
@@ -7671,7 +7658,7 @@
 
 int
 start_function (struct c_declspecs *declspecs, struct c_declarator *declarator,
-        tree attributes)
+		tree attributes)
 {
   tree decl1, old_decl;
   tree restype, resdecl;
@@ -7714,18 +7701,18 @@
       && DECL_UNINLINABLE (decl1)
       && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl1)))
     warning_at (loc, OPT_Wattributes,
-        "inline function %qD given attribute noinline",
-        decl1);
+		"inline function %qD given attribute noinline",
+		decl1);
 
   /* Handle gnu_inline attribute.  */
   if (declspecs->inline_p
       && !flag_gnu89_inline
       && TREE_CODE (decl1) == FUNCTION_DECL
       && (lookup_attribute ("gnu_inline", DECL_ATTRIBUTES (decl1))
-      || current_function_decl))
+	  || current_function_decl))
     {
       if (declspecs->storage_class != csc_static)
-    DECL_EXTERNAL (decl1) = !DECL_EXTERNAL (decl1);
+	DECL_EXTERNAL (decl1) = !DECL_EXTERNAL (decl1);
     }
 
   announce_function (decl1);
@@ -7735,14 +7722,14 @@
       error_at (loc, "return type is an incomplete type");
       /* Make it return void instead.  */
       TREE_TYPE (decl1)
-    = build_function_type (void_type_node,
-                   TYPE_ARG_TYPES (TREE_TYPE (decl1)));
+	= build_function_type (void_type_node,
+			       TYPE_ARG_TYPES (TREE_TYPE (decl1)));
     }
 
   if (warn_about_return_type)
     pedwarn_c99 (loc, flag_isoc99 ? 0
-         : (warn_return_type ? OPT_Wreturn_type : OPT_Wimplicit_int),
-         "return type defaults to %<int%>");
+		 : (warn_return_type ? OPT_Wreturn_type : OPT_Wimplicit_int),
+		 "return type defaults to %<int%>");
 
   /* Make the init_value nonzero so pushdecl knows this is not tentative.
      error_mark_node is replaced below (in pop_scope) with the BLOCK.  */
@@ -7763,47 +7750,47 @@
   if (!prototype_p (TREE_TYPE (decl1)))
     {
       if (old_decl != 0 && TREE_CODE (TREE_TYPE (old_decl)) == FUNCTION_TYPE
-      && comptypes (TREE_TYPE (TREE_TYPE (decl1)),
-            TREE_TYPE (TREE_TYPE (old_decl))))
-    {
-      TREE_TYPE (decl1) = composite_type (TREE_TYPE (old_decl),
-                          TREE_TYPE (decl1));
-      current_function_prototype_locus = DECL_SOURCE_LOCATION (old_decl);
-      current_function_prototype_built_in
-        = C_DECL_BUILTIN_PROTOTYPE (old_decl);
-      current_function_prototype_arg_types
-        = TYPE_ARG_TYPES (TREE_TYPE (decl1));
-    }
+	  && comptypes (TREE_TYPE (TREE_TYPE (decl1)),
+			TREE_TYPE (TREE_TYPE (old_decl))))
+	{
+	  TREE_TYPE (decl1) = composite_type (TREE_TYPE (old_decl),
+					      TREE_TYPE (decl1));
+	  current_function_prototype_locus = DECL_SOURCE_LOCATION (old_decl);
+	  current_function_prototype_built_in
+	    = C_DECL_BUILTIN_PROTOTYPE (old_decl);
+	  current_function_prototype_arg_types
+	    = TYPE_ARG_TYPES (TREE_TYPE (decl1));
+	}
       if (TREE_PUBLIC (decl1))
-    {
-      /* If there is an external prototype declaration of this
-         function, record its location but do not copy information
-         to this decl.  This may be an invisible declaration
-         (built-in or in a scope which has finished) or simply
-         have more refined argument types than any declaration
-         found above.  */
-      struct c_binding *b;
-      for (b = I_SYMBOL_BINDING (DECL_NAME (decl1)); b; b = b->shadowed)
-        if (B_IN_SCOPE (b, external_scope))
-          break;
-      if (b)
-        {
-          tree ext_decl, ext_type;
-          ext_decl = b->decl;
-          ext_type = b->u.type ? b->u.type : TREE_TYPE (ext_decl);
-          if (TREE_CODE (ext_type) == FUNCTION_TYPE
-          && comptypes (TREE_TYPE (TREE_TYPE (decl1)),
-                TREE_TYPE (ext_type)))
-        {
-          current_function_prototype_locus
-            = DECL_SOURCE_LOCATION (ext_decl);
-          current_function_prototype_built_in
-            = C_DECL_BUILTIN_PROTOTYPE (ext_decl);
-          current_function_prototype_arg_types
-            = TYPE_ARG_TYPES (ext_type);
-        }
-        }
-    }
+	{
+	  /* If there is an external prototype declaration of this
+	     function, record its location but do not copy information
+	     to this decl.  This may be an invisible declaration
+	     (built-in or in a scope which has finished) or simply
+	     have more refined argument types than any declaration
+	     found above.  */
+	  struct c_binding *b;
+	  for (b = I_SYMBOL_BINDING (DECL_NAME (decl1)); b; b = b->shadowed)
+	    if (B_IN_SCOPE (b, external_scope))
+	      break;
+	  if (b)
+	    {
+	      tree ext_decl, ext_type;
+	      ext_decl = b->decl;
+	      ext_type = b->u.type ? b->u.type : TREE_TYPE (ext_decl);
+	      if (TREE_CODE (ext_type) == FUNCTION_TYPE
+		  && comptypes (TREE_TYPE (TREE_TYPE (decl1)),
+				TREE_TYPE (ext_type)))
+		{
+		  current_function_prototype_locus
+		    = DECL_SOURCE_LOCATION (ext_decl);
+		  current_function_prototype_built_in
+		    = C_DECL_BUILTIN_PROTOTYPE (ext_decl);
+		  current_function_prototype_arg_types
+		    = TYPE_ARG_TYPES (ext_type);
+		}
+	    }
+	}
     }
 
   /* Optionally warn of old-fashioned def with no previous prototype.  */
@@ -7812,15 +7799,15 @@
       && !prototype_p (TREE_TYPE (decl1))
       && C_DECL_ISNT_PROTOTYPE (old_decl))
     warning_at (loc, OPT_Wstrict_prototypes,
-        "function declaration isn%'t a prototype");
+		"function declaration isn%'t a prototype");
   /* Optionally warn of any global def with no previous prototype.  */
   else if (warn_missing_prototypes
-       && old_decl != error_mark_node
-       && TREE_PUBLIC (decl1)
-       && !MAIN_NAME_P (DECL_NAME (decl1))
-       && C_DECL_ISNT_PROTOTYPE (old_decl))
+	   && old_decl != error_mark_node
+	   && TREE_PUBLIC (decl1)
+	   && !MAIN_NAME_P (DECL_NAME (decl1))
+	   && C_DECL_ISNT_PROTOTYPE (old_decl))
     warning_at (loc, OPT_Wmissing_prototypes,
-        "no previous prototype for %qD", decl1);
+		"no previous prototype for %qD", decl1);
   /* Optionally warn of any def with no previous prototype
      if the function has already been used.  */
   else if (warn_missing_prototypes
@@ -7829,24 +7816,24 @@
 	   && TREE_USED (old_decl)
 	   && !prototype_p (TREE_TYPE (old_decl)))
     warning_at (loc, OPT_Wmissing_prototypes,
-        "%qD was used with no prototype before its definition", decl1);
+		"%qD was used with no prototype before its definition", decl1);
   /* Optionally warn of any global def with no previous declaration.  */
   else if (warn_missing_declarations
-       && TREE_PUBLIC (decl1)
-       && old_decl == 0
-       && !MAIN_NAME_P (DECL_NAME (decl1)))
+	   && TREE_PUBLIC (decl1)
+	   && old_decl == 0
+	   && !MAIN_NAME_P (DECL_NAME (decl1)))
     warning_at (loc, OPT_Wmissing_declarations,
-        "no previous declaration for %qD",
-        decl1);
+		"no previous declaration for %qD",
+		decl1);
   /* Optionally warn of any def with no previous declaration
      if the function has already been used.  */
   else if (warn_missing_declarations
-       && old_decl != 0
-       && old_decl != error_mark_node
-       && TREE_USED (old_decl)
-       && C_DECL_IMPLICIT (old_decl))
+	   && old_decl != 0
+	   && old_decl != error_mark_node
+	   && TREE_USED (old_decl)
+	   && C_DECL_IMPLICIT (old_decl))
     warning_at (loc, OPT_Wmissing_declarations,
-        "%qD was used with no declaration before its definition", decl1);
+		"%qD was used with no declaration before its definition", decl1);
 
   /* This function exists in static storage.
      (This does not mean `static' in the C sense!)  */
@@ -7864,14 +7851,14 @@
   if (warn_main && MAIN_NAME_P (DECL_NAME (decl1)))
     {
       if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (decl1)))
-      != integer_type_node)
-    pedwarn (loc, OPT_Wmain, "return type of %qD is not %<int%>", decl1);
+	  != integer_type_node)
+	pedwarn (loc, OPT_Wmain, "return type of %qD is not %<int%>", decl1);
 
       check_main_parameter_types (decl1);
 
       if (!TREE_PUBLIC (decl1))
-    pedwarn (loc, OPT_Wmain,
-         "%qD is normally a non-static function", decl1);
+	pedwarn (loc, OPT_Wmain,
+		 "%qD is normally a non-static function", decl1);
     }
 
   /* Record the decl so that the function name is defined.
@@ -7908,8 +7895,8 @@
   if (current_scope->bindings)
     {
       error_at (DECL_SOURCE_LOCATION (fndecl),
-        "old-style parameter declarations in prototyped "
-        "function definition");
+		"old-style parameter declarations in prototyped "
+		"function definition");
 
       /* Get rid of the old-style declarations.  */
       pop_scope ();
@@ -7920,9 +7907,9 @@
      (this happens when a function definition has just an ellipsis in
      its parameter list).  */
   else if (!in_system_header && !current_function_scope
-       && arg_info->types != error_mark_node)
+	   && arg_info->types != error_mark_node)
     warning_at (DECL_SOURCE_LOCATION (fndecl), OPT_Wtraditional,
-        "traditional C rejects ISO C style function definitions");
+		"traditional C rejects ISO C style function definitions");
 
   /* Now make all the parameter declarations visible in the function body.
      We can bypass most of the grunt work of pushdecl.  */
@@ -7930,15 +7917,15 @@
     {
       DECL_CONTEXT (decl) = current_function_decl;
       if (DECL_NAME (decl))
-    {
-      bind (DECL_NAME (decl), decl, current_scope,
-        /*invisible=*/false, /*nested=*/false,
-        UNKNOWN_LOCATION);
-      if (!TREE_USED (decl))
-        warn_if_shadowing (decl);
-    }
+	{
+	  bind (DECL_NAME (decl), decl, current_scope,
+		/*invisible=*/false, /*nested=*/false,
+		UNKNOWN_LOCATION);
+	  if (!TREE_USED (decl))
+	    warn_if_shadowing (decl);
+	}
       else
-    error_at (DECL_SOURCE_LOCATION (decl), "parameter name omitted");
+	error_at (DECL_SOURCE_LOCATION (decl), "parameter name omitted");
     }
 
   /* Record the parameter list in the function declaration.  */
@@ -7975,19 +7962,19 @@
 
   if (!in_system_header)
     warning_at (DECL_SOURCE_LOCATION (fndecl),
-        OPT_Wold_style_definition, "old-style function definition");
+		OPT_Wold_style_definition, "old-style function definition");
 
   /* Match each formal parameter name with its declaration.  Save each
      decl in the appropriate TREE_PURPOSE slot of the parmids chain.  */
   for (parm = parmids; parm; parm = TREE_CHAIN (parm))
     {
       if (TREE_VALUE (parm) == 0)
-    {
-      error_at (DECL_SOURCE_LOCATION (fndecl),
-            "parameter name missing from parameter list");
-      TREE_PURPOSE (parm) = 0;
-      continue;
-    }
+	{
+	  error_at (DECL_SOURCE_LOCATION (fndecl),
+		    "parameter name missing from parameter list");
+	  TREE_PURPOSE (parm) = 0;
+	  continue;
+	}
 
       b = I_SYMBOL_BINDING (TREE_VALUE (parm));
       if (b && B_IN_CURRENT_SCOPE (b))
@@ -8023,32 +8010,32 @@
 	}
       /* If no declaration found, default to int.  */
       else
-    {
-      /* FIXME diagnostics: This should be the location of the argument,
-         not the FNDECL.  E.g., for an old-style declaration
-
-           int f10(v) { blah; }
-
-         We should use the location of the V, not the F10.
-         Unfortunately, the V is an IDENTIFIER_NODE which has no
-         location.  In the future we need locations for c_arg_info
-         entries.
-
-         See gcc.dg/Wshadow-3.c for an example of this problem. */
-      decl = build_decl (DECL_SOURCE_LOCATION (fndecl),
-                 PARM_DECL, TREE_VALUE (parm), integer_type_node);
-      DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
-      pushdecl (decl);
-      warn_if_shadowing (decl);
-
-      if (flag_isoc99)
-        pedwarn (DECL_SOURCE_LOCATION (decl),
-             0, "type of %qD defaults to %<int%>", decl);
-      else
-        warning_at (DECL_SOURCE_LOCATION (decl),
-            OPT_Wmissing_parameter_type,
-            "type of %qD defaults to %<int%>", decl);
-    }
+	{
+	  /* FIXME diagnostics: This should be the location of the argument,
+	     not the FNDECL.  E.g., for an old-style declaration
+
+	       int f10(v) { blah; }
+
+	     We should use the location of the V, not the F10.
+	     Unfortunately, the V is an IDENTIFIER_NODE which has no
+	     location.  In the future we need locations for c_arg_info
+	     entries.
+
+	     See gcc.dg/Wshadow-3.c for an example of this problem. */
+	  decl = build_decl (DECL_SOURCE_LOCATION (fndecl),
+			     PARM_DECL, TREE_VALUE (parm), integer_type_node);
+	  DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
+	  pushdecl (decl);
+	  warn_if_shadowing (decl);
+
+	  if (flag_isoc99)
+	    pedwarn (DECL_SOURCE_LOCATION (decl),
+		     0, "type of %qD defaults to %<int%>", decl);
+	  else
+	    warning_at (DECL_SOURCE_LOCATION (decl),
+			OPT_Wmissing_parameter_type,
+			"type of %qD defaults to %<int%>", decl);
+	}
 
       TREE_PURPOSE (parm) = decl;
       pointer_set_insert (seen_args, decl);
@@ -8061,27 +8048,27 @@
     {
       parm = b->decl;
       if (TREE_CODE (parm) != PARM_DECL)
-    continue;
+	continue;
 
       if (TREE_TYPE (parm) != error_mark_node
-      && !COMPLETE_TYPE_P (TREE_TYPE (parm)))
-    {
-      error_at (DECL_SOURCE_LOCATION (parm),
-            "parameter %qD has incomplete type", parm);
-      TREE_TYPE (parm) = error_mark_node;
-    }
+	  && !COMPLETE_TYPE_P (TREE_TYPE (parm)))
+	{
+	  error_at (DECL_SOURCE_LOCATION (parm),
+		    "parameter %qD has incomplete type", parm);
+	  TREE_TYPE (parm) = error_mark_node;
+	}
 
       if (!pointer_set_contains (seen_args, parm))
-    {
-      error_at (DECL_SOURCE_LOCATION (parm),
-            "declaration for parameter %qD but no such parameter",
-            parm);
-
-      /* Pretend the parameter was not missing.
-         This gets us to a standard state and minimizes
-         further error messages.  */
-      parmids = chainon (parmids, tree_cons (parm, 0, 0));
-    }
+	{
+	  error_at (DECL_SOURCE_LOCATION (parm),
+		    "declaration for parameter %qD but no such parameter",
+		    parm);
+
+	  /* Pretend the parameter was not missing.
+	     This gets us to a standard state and minimizes
+	     further error messages.  */
+	  parmids = chainon (parmids, tree_cons (parm, 0, 0));
+	}
     }
 
   /* Chain the declarations together in the order of the list of
@@ -8116,8 +8103,8 @@
     {
       tree type;
       for (parm = DECL_ARGUMENTS (fndecl),
-         type = current_function_prototype_arg_types;
-       parm || (type && TREE_VALUE (type) != error_mark_node
+	     type = current_function_prototype_arg_types;
+	   parm || (type && TREE_VALUE (type) != error_mark_node
                    && (TYPE_MAIN_VARIANT (TREE_VALUE (type)) != void_type_node));
 	   parm = DECL_CHAIN (parm), type = TREE_CHAIN (type))
 	{
@@ -8221,17 +8208,17 @@
 	}
       type = tree_cons (NULL_TREE, void_type_node, NULL_TREE);
       if (last)
-    TREE_CHAIN (last) = type;
+	TREE_CHAIN (last) = type;
       else
-    actual = type;
+	actual = type;
 
       /* We are going to assign a new value for the TYPE_ACTUAL_ARG_TYPES
-     of the type of this function, but we need to avoid having this
-     affect the types of other similarly-typed functions, so we must
-     first force the generation of an identical (but separate) type
-     node for the relevant function type.  The new node we create
-     will be a variant of the main variant of the original function
-     type.  */
+	 of the type of this function, but we need to avoid having this
+	 affect the types of other similarly-typed functions, so we must
+	 first force the generation of an identical (but separate) type
+	 node for the relevant function type.  The new node we create
+	 will be a variant of the main variant of the original function
+	 type.  */
 
       TREE_TYPE (fndecl) = build_variant_type_copy (TREE_TYPE (fndecl));
 
@@ -8295,7 +8282,7 @@
 
   /* ??? Insert the contents of the pending sizes list into the function
      to be evaluated.  The only reason left to have this is
-    void foo(int n, int array[n++])
+	void foo(int n, int array[n++])
      because we throw away the array type in favor of a pointer type, and
      thus won't naturally see the SAVE_EXPR containing the increment.  All
      other pending sizes would be handled by gimplify_parameters.  */
@@ -8356,10 +8343,10 @@
       == integer_type_node && flag_isoc99)
     {
       /* Hack.  We don't want the middle-end to warn that this return
-     is unreachable, so we mark its location as special.  Using
-     UNKNOWN_LOCATION has the problem that it gets clobbered in
-     annotate_one_with_locus.  A cleaner solution might be to
-     ensure ! should_carry_locus_p (stmt), but that needs a flag.
+	 is unreachable, so we mark its location as special.  Using
+	 UNKNOWN_LOCATION has the problem that it gets clobbered in
+	 annotate_one_with_locus.  A cleaner solution might be to
+	 ensure ! should_carry_locus_p (stmt), but that needs a flag.
       */
       c_finish_return (BUILTINS_LOCATION, integer_zero_node, NULL_TREE);
     }
@@ -8386,7 +8373,7 @@
       && !TREE_PUBLIC (fndecl))
     {
       warning (OPT_Wreturn_type,
-           "no return statement in function returning non-void");
+	       "no return statement in function returning non-void");
       TREE_NO_WARNING (fndecl) = 1;
     }
 
@@ -8429,26 +8416,26 @@
       && !undef_nested_function)
     {
       if (!decl_function_context (fndecl))
-    {
-      invoke_plugin_callbacks (PLUGIN_PRE_GENERICIZE, fndecl);
-      c_genericize (fndecl);
-
-      /* ??? Objc emits functions after finalizing the compilation unit.
-         This should be cleaned up later and this conditional removed.  */
-      if (cgraph_global_info_ready)
-        {
-          cgraph_add_new_function (fndecl, false);
-          return;
-        }
-      cgraph_finalize_function (fndecl, false);
-    }
+	{
+	  invoke_plugin_callbacks (PLUGIN_PRE_GENERICIZE, fndecl);
+	  c_genericize (fndecl);
+
+	  /* ??? Objc emits functions after finalizing the compilation unit.
+	     This should be cleaned up later and this conditional removed.  */
+	  if (cgraph_global_info_ready)
+	    {
+	      cgraph_add_new_function (fndecl, false);
+	      return;
+	    }
+	  cgraph_finalize_function (fndecl, false);
+	}
       else
-    {
-      /* Register this function with cgraph just far enough to get it
-        added to our parent's nested function list.  Handy, since the
-        C front end doesn't have such a list.  */
-      (void) cgraph_node (fndecl);
-    }
+	{
+	  /* Register this function with cgraph just far enough to get it
+	    added to our parent's nested function list.  Handy, since the
+	    C front end doesn't have such a list.  */
+	  (void) cgraph_node (fndecl);
+	}
     }
 
   if (!decl_function_context (fndecl))
@@ -8483,16 +8470,16 @@
     {
       static bool hint = true;
       /* If we get here, declarations have been used in a for loop without
-     the C99 for loop scope.  This doesn't make much sense, so don't
-     allow it.  */
+	 the C99 for loop scope.  This doesn't make much sense, so don't
+	 allow it.  */
       error_at (loc, "%<for%> loop initial declarations "
-        "are only allowed in C99 mode");
+		"are only allowed in C99 mode");
       if (hint)
-    {
-      inform (loc,
-          "use option -std=c99 or -std=gnu99 to compile your code");
-      hint = false;
-    }
+	{
+	  inform (loc,
+		  "use option -std=c99 or -std=gnu99 to compile your code");
+	  hint = false;
+	}
       return NULL_TREE;
     }
   /* C99 subclause 6.8.5 paragraph 3:
@@ -8515,42 +8502,42 @@
       tree decl = b->decl;
 
       if (!id)
-    continue;
+	continue;
 
       switch (TREE_CODE (decl))
-    {
-    case VAR_DECL:
-      {
-        location_t decl_loc = DECL_SOURCE_LOCATION (decl);
-        if (TREE_STATIC (decl))
-          error_at (decl_loc,
-            "declaration of static variable %qD in %<for%> loop "
-            "initial declaration", decl);
-        else if (DECL_EXTERNAL (decl))
-          error_at (decl_loc,
-            "declaration of %<extern%> variable %qD in %<for%> loop "
-            "initial declaration", decl);
-      }
-      break;
-
-    case RECORD_TYPE:
-      error_at (loc,
-            "%<struct %E%> declared in %<for%> loop initial "
-            "declaration", id);
-      break;
-    case UNION_TYPE:
-      error_at (loc,
-            "%<union %E%> declared in %<for%> loop initial declaration",
-            id);
-      break;
-    case ENUMERAL_TYPE:
-      error_at (loc, "%<enum %E%> declared in %<for%> loop "
-            "initial declaration", id);
-      break;
-    default:
-      error_at (loc, "declaration of non-variable "
-            "%qD in %<for%> loop initial declaration", decl);
-    }
+	{
+	case VAR_DECL:
+	  {
+	    location_t decl_loc = DECL_SOURCE_LOCATION (decl);
+	    if (TREE_STATIC (decl))
+	      error_at (decl_loc,
+			"declaration of static variable %qD in %<for%> loop "
+			"initial declaration", decl);
+	    else if (DECL_EXTERNAL (decl))
+	      error_at (decl_loc,
+			"declaration of %<extern%> variable %qD in %<for%> loop "
+			"initial declaration", decl);
+	  }
+	  break;
+
+	case RECORD_TYPE:
+	  error_at (loc,
+		    "%<struct %E%> declared in %<for%> loop initial "
+		    "declaration", id);
+	  break;
+	case UNION_TYPE:
+	  error_at (loc,
+		    "%<union %E%> declared in %<for%> loop initial declaration",
+		    id);
+	  break;
+	case ENUMERAL_TYPE:
+	  error_at (loc, "%<enum %E%> declared in %<for%> loop "
+		    "initial declaration", id);
+	  break;
+	default:
+	  error_at (loc, "declaration of non-variable "
+		    "%qD in %<for%> loop initial declaration", decl);
+	}
 
       n_decls++;
       one_decl = decl;
@@ -8598,7 +8585,7 @@
     {
       /* Stop pointing to the local nodes about to be freed.  */
       /* But DECL_INITIAL must remain nonzero so we know this
-     was an actual function definition.  */
+	 was an actual function definition.  */
       DECL_INITIAL (current_function_decl) = error_mark_node;
       DECL_ARGUMENTS (current_function_decl) = 0;
     }
@@ -8632,7 +8619,7 @@
 /* Return the global value of T as a symbol.  */
 
 tree
-identifier_global_value (tree t)
+identifier_global_value	(tree t)
 {
   struct c_binding *b;
 
@@ -8672,7 +8659,7 @@
 
 struct c_parm *
 build_c_parm (struct c_declspecs *specs, tree attrs,
-          struct c_declarator *declarator)
+	      struct c_declarator *declarator)
 {
   struct c_parm *ret = XOBNEW (&parser_obstack, struct c_parm);
   ret->specs = specs;
@@ -8700,7 +8687,7 @@
 
 struct c_declarator *
 build_function_declarator (struct c_arg_info *args,
-               struct c_declarator *target)
+			   struct c_declarator *target)
 {
   struct c_declarator *ret = XOBNEW (&parser_obstack, struct c_declarator);
   ret->kind = cdk_function;
@@ -8731,7 +8718,7 @@
 
 struct c_declarator *
 make_pointer_declarator (struct c_declspecs *type_quals_attrs,
-             struct c_declarator *target)
+			 struct c_declarator *target)
 {
   tree attrs;
   int quals = 0;
@@ -8742,7 +8729,7 @@
       attrs = type_quals_attrs->attrs;
       quals = quals_from_declspecs (type_quals_attrs);
       if (attrs != NULL_TREE)
-    itarget = build_attrs_declarator (attrs, target);
+	itarget = build_attrs_declarator (attrs, target);
     }
   ret->kind = cdk_pointer;
   ret->declarator = itarget;
@@ -8799,8 +8786,8 @@
   if (!ADDR_SPACE_GENERIC_P (specs->address_space)
       && specs->address_space != as)
     error ("incompatible address space qualifiers %qs and %qs",
-       c_addr_space_name (as),
-       c_addr_space_name (specs->address_space));
+	   c_addr_space_name (as),
+	   c_addr_space_name (specs->address_space));
   else
     specs->address_space = as;
   return specs;
@@ -8817,7 +8804,7 @@
   specs->non_sc_seen_p = true;
   specs->declspecs_seen_p = true;
   gcc_assert (TREE_CODE (qual) == IDENTIFIER_NODE
-          && C_IS_RESERVED_WORD (qual));
+	      && C_IS_RESERVED_WORD (qual));
   i = C_RID_CODE (qual);
   switch (i)
     {
@@ -8846,7 +8833,7 @@
 
 struct c_declspecs *
 declspecs_add_type (location_t loc, struct c_declspecs *specs,
-            struct c_typespec spec)
+		    struct c_typespec spec)
 {
   tree type = spec.spec;
   specs->non_sc_seen_p = true;
@@ -8862,10 +8849,10 @@
     {
       enum rid i = C_RID_CODE (type);
       if (specs->type)
-    {
-      error_at (loc, "two or more data types in declaration specifiers");
-      return specs;
-    }
+	{
+	  error_at (loc, "two or more data types in declaration specifiers");
+	  return specs;
+	}
       if ((int) i <= (int) RID_LAST_MODIFIER)
 	{
 	  /* "long", "short", "signed", "unsigned", "_Complex" or "_Sat".  */
@@ -8901,10 +8888,10 @@
 			  ("both %<long%> and %<void%> in "
 			   "declaration specifiers"));
 #ifndef noCbC
-	      else if (specs->typespec_word == cts_CbC_code)
-		error_at (loc,
-			  ("both %<long%> and %<void%> in "
-			   "declaration specifiers"));
+          else if (specs->typespec_word == cts_CbC_code)
+        error_at (loc,
+              ("both %<long%> and %<void%> in "
+               "declaration specifiers"));
 #endif
 	      else if (specs->typespec_word == cts_int128)
 		  error_at (loc,
@@ -8948,10 +8935,10 @@
 			  ("both %<short%> and %<void%> in "
 			   "declaration specifiers"));
 #ifndef noCbC
-	      else if (specs->typespec_word == cts_CbC_code)
-		error_at (loc,
-			  ("both %<short%> and %<void%> in "
-			   "declaration specifiers"));
+          else if (specs->typespec_word == cts_CbC_code)
+        error_at (loc,
+              ("both %<short%> and %<void%> in "
+               "declaration specifiers"));
 #endif
 	      else if (specs->typespec_word == cts_int128)
 		error_at (loc,
@@ -8974,126 +8961,125 @@
 			  ("both %<short%> and %<double%> in "
 			   "declaration specifiers"));
 	      else if (specs->typespec_word == cts_dfloat32)
->>>>>>> other
                 error_at (loc,
-              ("both %<short%> and %<_Decimal32%> in "
-               "declaration specifiers"));
-          else if (specs->typespec_word == cts_dfloat64)
-        error_at (loc,
-              ("both %<short%> and %<_Decimal64%> in "
-               "declaration specifiers"));
-          else if (specs->typespec_word == cts_dfloat128)
-        error_at (loc,
-              ("both %<short%> and %<_Decimal128%> in "
-               "declaration specifiers"));
-          else
-        specs->short_p = true;
-          break;
-        case RID_SIGNED:
-          dupe = specs->signed_p;
-          if (specs->unsigned_p)
-        error_at (loc,
-              ("both %<signed%> and %<unsigned%> in "
-               "declaration specifiers"));
-          else if (specs->typespec_word == cts_void)
-        error_at (loc,
-              ("both %<signed%> and %<void%> in "
-               "declaration specifiers"));
+			  ("both %<short%> and %<_Decimal32%> in "
+			   "declaration specifiers"));
+	      else if (specs->typespec_word == cts_dfloat64)
+		error_at (loc,
+			  ("both %<short%> and %<_Decimal64%> in "
+			   "declaration specifiers"));
+	      else if (specs->typespec_word == cts_dfloat128)
+		error_at (loc,
+			  ("both %<short%> and %<_Decimal128%> in "
+			   "declaration specifiers"));
+	      else
+		specs->short_p = true;
+	      break;
+	    case RID_SIGNED:
+	      dupe = specs->signed_p;
+	      if (specs->unsigned_p)
+		error_at (loc,
+			  ("both %<signed%> and %<unsigned%> in "
+			   "declaration specifiers"));
+	      else if (specs->typespec_word == cts_void)
+		error_at (loc,
+			  ("both %<signed%> and %<void%> in "
+			   "declaration specifiers"));
 #ifndef noCbC
           else if (specs->typespec_word == cts_CbC_code)
         error_at (loc,
               ("both %<signed%> and %<void%> in "
                "declaration specifiers"));
 #endif
-          else if (specs->typespec_word == cts_bool)
-        error_at (loc,
-              ("both %<signed%> and %<_Bool%> in "
-               "declaration specifiers"));
-          else if (specs->typespec_word == cts_float)
-        error_at (loc,
-              ("both %<signed%> and %<float%> in "
-               "declaration specifiers"));
-          else if (specs->typespec_word == cts_double)
-        error_at (loc,
-              ("both %<signed%> and %<double%> in "
-               "declaration specifiers"));
-          else if (specs->typespec_word == cts_dfloat32)
-        error_at (loc,
-              ("both %<signed%> and %<_Decimal32%> in "
-               "declaration specifiers"));
-          else if (specs->typespec_word == cts_dfloat64)
-        error_at (loc,
-              ("both %<signed%> and %<_Decimal64%> in "
-               "declaration specifiers"));
-          else if (specs->typespec_word == cts_dfloat128)
-        error_at (loc,
-              ("both %<signed%> and %<_Decimal128%> in "
-               "declaration specifiers"));
-          else
-        specs->signed_p = true;
-          break;
-        case RID_UNSIGNED:
-          dupe = specs->unsigned_p;
-          if (specs->signed_p)
-        error_at (loc,
-              ("both %<signed%> and %<unsigned%> in "
-               "declaration specifiers"));
-          else if (specs->typespec_word == cts_void)
-        error_at (loc,
-              ("both %<unsigned%> and %<void%> in "
-               "declaration specifiers"));
+	      else if (specs->typespec_word == cts_bool)
+		error_at (loc,
+			  ("both %<signed%> and %<_Bool%> in "
+			   "declaration specifiers"));
+	      else if (specs->typespec_word == cts_float)
+		error_at (loc,
+			  ("both %<signed%> and %<float%> in "
+			   "declaration specifiers"));
+	      else if (specs->typespec_word == cts_double)
+		error_at (loc,
+			  ("both %<signed%> and %<double%> in "
+			   "declaration specifiers"));
+	      else if (specs->typespec_word == cts_dfloat32)
+		error_at (loc,
+			  ("both %<signed%> and %<_Decimal32%> in "
+			   "declaration specifiers"));
+	      else if (specs->typespec_word == cts_dfloat64)
+		error_at (loc,
+			  ("both %<signed%> and %<_Decimal64%> in "
+			   "declaration specifiers"));
+	      else if (specs->typespec_word == cts_dfloat128)
+		error_at (loc,
+			  ("both %<signed%> and %<_Decimal128%> in "
+			   "declaration specifiers"));
+	      else
+		specs->signed_p = true;
+	      break;
+	    case RID_UNSIGNED:
+	      dupe = specs->unsigned_p;
+	      if (specs->signed_p)
+		error_at (loc,
+			  ("both %<signed%> and %<unsigned%> in "
+			   "declaration specifiers"));
+	      else if (specs->typespec_word == cts_void)
+		error_at (loc,
+			  ("both %<unsigned%> and %<void%> in "
+			   "declaration specifiers"));
 #ifndef noCbC
           else if (specs->typespec_word == cts_CbC_code)
         error_at (loc,
               ("both %<unsigned%> and %<void%> in "
                "declaration specifiers"));
 #endif
-          else if (specs->typespec_word == cts_bool)
-        error_at (loc,
-              ("both %<unsigned%> and %<_Bool%> in "
-               "declaration specifiers"));
-          else if (specs->typespec_word == cts_float)
-        error_at (loc,
-              ("both %<unsigned%> and %<float%> in "
-               "declaration specifiers"));
-          else if (specs->typespec_word == cts_double)
-        error_at (loc,
-              ("both %<unsigned%> and %<double%> in "
-               "declaration specifiers"));
+	      else if (specs->typespec_word == cts_bool)
+		error_at (loc,
+			  ("both %<unsigned%> and %<_Bool%> in "
+			   "declaration specifiers"));
+	      else if (specs->typespec_word == cts_float)
+		error_at (loc,
+			  ("both %<unsigned%> and %<float%> in "
+			   "declaration specifiers"));
+	      else if (specs->typespec_word == cts_double)
+		error_at (loc,
+			  ("both %<unsigned%> and %<double%> in "
+			   "declaration specifiers"));
               else if (specs->typespec_word == cts_dfloat32)
-        error_at (loc,
-              ("both %<unsigned%> and %<_Decimal32%> in "
-               "declaration specifiers"));
-          else if (specs->typespec_word == cts_dfloat64)
-        error_at (loc,
-              ("both %<unsigned%> and %<_Decimal64%> in "
-               "declaration specifiers"));
-          else if (specs->typespec_word == cts_dfloat128)
-        error_at (loc,
-              ("both %<unsigned%> and %<_Decimal128%> in "
-               "declaration specifiers"));
-          else
-        specs->unsigned_p = true;
-          break;
-        case RID_COMPLEX:
-          dupe = specs->complex_p;
-          if (!flag_isoc99 && !in_system_header)
-        pedwarn (loc, OPT_pedantic,
-             "ISO C90 does not support complex types");
-          if (specs->typespec_word == cts_void)
-        error_at (loc,
-              ("both %<complex%> and %<void%> in "
-               "declaration specifiers"));
+		error_at (loc,
+			  ("both %<unsigned%> and %<_Decimal32%> in "
+			   "declaration specifiers"));
+	      else if (specs->typespec_word == cts_dfloat64)
+		error_at (loc,
+			  ("both %<unsigned%> and %<_Decimal64%> in "
+			   "declaration specifiers"));
+	      else if (specs->typespec_word == cts_dfloat128)
+		error_at (loc,
+			  ("both %<unsigned%> and %<_Decimal128%> in "
+			   "declaration specifiers"));
+	      else
+		specs->unsigned_p = true;
+	      break;
+	    case RID_COMPLEX:
+	      dupe = specs->complex_p;
+	      if (!flag_isoc99 && !in_system_header)
+		pedwarn (loc, OPT_pedantic,
+			 "ISO C90 does not support complex types");
+	      if (specs->typespec_word == cts_void)
+		error_at (loc,
+			  ("both %<complex%> and %<void%> in "
+			   "declaration specifiers"));
 #ifndef noCbC
           else if (specs->typespec_word == cts_CbC_code)
         error_at (loc,
               ("both %<complex%> and %<void%> in "
                "declaration specifiers"));
 #endif
-          else if (specs->typespec_word == cts_bool)
-        error_at (loc,
-              ("both %<complex%> and %<_Bool%> in "
-               "declaration specifiers"));
+	      else if (specs->typespec_word == cts_bool)
+		error_at (loc,
+			  ("both %<complex%> and %<_Bool%> in "
+			   "declaration specifiers"));
               else if (specs->typespec_word == cts_dfloat32)
 		error_at (loc,
 			  ("both %<complex%> and %<_Decimal32%> in "
@@ -9156,33 +9142,33 @@
 			  ("both %<_Sat%> and %<double%> in "
 			   "declaration specifiers"));
               else if (specs->typespec_word == cts_dfloat32)
-        error_at (loc,
-              ("both %<_Sat%> and %<_Decimal32%> in "
-               "declaration specifiers"));
-          else if (specs->typespec_word == cts_dfloat64)
-        error_at (loc,
-              ("both %<_Sat%> and %<_Decimal64%> in "
-               "declaration specifiers"));
-          else if (specs->typespec_word == cts_dfloat128)
-        error_at (loc,
-              ("both %<_Sat%> and %<_Decimal128%> in "
-               "declaration specifiers"));
-          else if (specs->complex_p)
-        error_at (loc,
-              ("both %<_Sat%> and %<complex%> in "
-               "declaration specifiers"));
-          else
-        specs->saturating_p = true;
-          break;
-        default:
-          gcc_unreachable ();
-        }
-
-      if (dupe)
-        error_at (loc, "duplicate %qE", type);
-
-      return specs;
-    }
+		error_at (loc,
+			  ("both %<_Sat%> and %<_Decimal32%> in "
+			   "declaration specifiers"));
+	      else if (specs->typespec_word == cts_dfloat64)
+		error_at (loc,
+			  ("both %<_Sat%> and %<_Decimal64%> in "
+			   "declaration specifiers"));
+	      else if (specs->typespec_word == cts_dfloat128)
+		error_at (loc,
+			  ("both %<_Sat%> and %<_Decimal128%> in "
+			   "declaration specifiers"));
+	      else if (specs->complex_p)
+		error_at (loc,
+			  ("both %<_Sat%> and %<complex%> in "
+			   "declaration specifiers"));
+	      else
+		specs->saturating_p = true;
+	      break;
+	    default:
+	      gcc_unreachable ();
+	    }
+
+	  if (dupe)
+	    error_at (loc, "duplicate %qE", type);
+
+	  return specs;
+	}
       else
 	{
 	  /* "void", "_Bool", "char", "int", "float", "double", "_Decimal32",
@@ -9249,25 +9235,25 @@
 		specs->typespec_word = cts_void;
 	      return specs;
 #ifndef noCbC
-	    case RID_CbC_CODE:
-	    if (specs->long_p)
-	      error ("both %<long%> and %<void%> in "
-		     "declaration specifiers");
-	    else if (specs->short_p)
-	      error ("both %<short%> and %<void%> in "
-		     "declaration specifiers");
-	    else if (specs->signed_p)
-	      error ("both %<signed%> and %<void%> in "
-		     "declaration specifiers");
-	    else if (specs->unsigned_p)
-	      error ("both %<unsigned%> and %<void%> in "
-		     "declaration specifiers");
-	    else if (specs->complex_p)
-	      error ("both %<complex%> and %<void%> in "
-		     "declaration specifiers");
-	    else
-	      specs->typespec_word = cts_CbC_code;
-	    return specs;
+        case RID_CbC_CODE:
+          if (specs->long_p)
+        error ("both %<long%> and %<void%> in "
+               "declaration specifiers");
+          else if (specs->short_p)
+        error ("both %<short%> and %<void%> in "
+               "declaration specifiers");
+          else if (specs->signed_p)
+        error ("both %<signed%> and %<void%> in "
+               "declaration specifiers");
+          else if (specs->unsigned_p)
+        error ("both %<unsigned%> and %<void%> in "
+               "declaration specifiers");
+          else if (specs->complex_p)
+        error ("both %<complex%> and %<void%> in "
+               "declaration specifiers");
+          else
+        specs->typespec_word = cts_CbC_code;
+          return specs;
 #endif
 	    case RID_BOOL:
 	      if (specs->long_p)
@@ -9407,57 +9393,57 @@
 			    str);
                 else if (specs->complex_p)
                   error_at (loc,
-                ("both %<complex%> and %<%s%> in "
-                 "declaration specifiers"),
-                str);
+			    ("both %<complex%> and %<%s%> in "
+			     "declaration specifiers"),
+			    str);
                 else if (specs->saturating_p)
                   error_at (loc,
-                ("both %<_Sat%> and %<%s%> in "
-                 "declaration specifiers"),
-                str);
-        else if (i == RID_DFLOAT32)
-          specs->typespec_word = cts_dfloat32;
-        else if (i == RID_DFLOAT64)
-          specs->typespec_word = cts_dfloat64;
-        else
-          specs->typespec_word = cts_dfloat128;
-          }
-          if (!targetm.decimal_float_supported_p ())
-        error_at (loc,
-              ("decimal floating point not supported "
-               "for this target"));
-          pedwarn (loc, OPT_pedantic,
-               "ISO C does not support decimal floating point");
-          return specs;
-        case RID_FRACT:
-        case RID_ACCUM:
-          {
-        const char *str;
-        if (i == RID_FRACT)
-          str = "_Fract";
-        else
-          str = "_Accum";
+			    ("both %<_Sat%> and %<%s%> in "
+			     "declaration specifiers"),
+			    str);
+		else if (i == RID_DFLOAT32)
+		  specs->typespec_word = cts_dfloat32;
+		else if (i == RID_DFLOAT64)
+		  specs->typespec_word = cts_dfloat64;
+		else
+		  specs->typespec_word = cts_dfloat128;
+	      }
+	      if (!targetm.decimal_float_supported_p ())
+		error_at (loc,
+			  ("decimal floating point not supported "
+			   "for this target"));
+	      pedwarn (loc, OPT_pedantic,
+		       "ISO C does not support decimal floating point");
+	      return specs;
+	    case RID_FRACT:
+	    case RID_ACCUM:
+	      {
+		const char *str;
+		if (i == RID_FRACT)
+		  str = "_Fract";
+		else
+		  str = "_Accum";
                 if (specs->complex_p)
                   error_at (loc,
-                ("both %<complex%> and %<%s%> in "
-                 "declaration specifiers"),
-                str);
-        else if (i == RID_FRACT)
-            specs->typespec_word = cts_fract;
-        else
-            specs->typespec_word = cts_accum;
-          }
-          if (!targetm.fixed_point_supported_p ())
-        error_at (loc,
-              "fixed-point types not supported for this target");
-          pedwarn (loc, OPT_pedantic,
-               "ISO C does not support fixed-point types");
-          return specs;
-        default:
-          /* ObjC reserved word "id", handled below.  */
-          break;
-        }
-    }
+			    ("both %<complex%> and %<%s%> in "
+			     "declaration specifiers"),
+			    str);
+		else if (i == RID_FRACT)
+		    specs->typespec_word = cts_fract;
+		else
+		    specs->typespec_word = cts_accum;
+	      }
+	      if (!targetm.fixed_point_supported_p ())
+		error_at (loc,
+			  "fixed-point types not supported for this target");
+	      pedwarn (loc, OPT_pedantic,
+		       "ISO C does not support fixed-point types");
+	      return specs;
+	    default:
+	      /* ObjC reserved word "id", handled below.  */
+	      break;
+	    }
+	}
     }
 
   /* Now we have a typedef (a TYPE_DECL node), an identifier (some
@@ -9472,37 +9458,37 @@
   else if (TREE_CODE (type) == TYPE_DECL)
     {
       if (TREE_TYPE (type) == error_mark_node)
-    ; /* Allow the type to default to int to avoid cascading errors.  */
+	; /* Allow the type to default to int to avoid cascading errors.  */
       else
-    {
-      specs->type = TREE_TYPE (type);
-      specs->decl_attr = DECL_ATTRIBUTES (type);
-      specs->typedef_p = true;
-      specs->explicit_signed_p = C_TYPEDEF_EXPLICITLY_SIGNED (type);
-
-      /* If this typedef name is defined in a struct, then a C++
-         lookup would return a different value.  */
-      if (warn_cxx_compat
-          && I_SYMBOL_BINDING (DECL_NAME (type))->in_struct)
-        warning_at (loc, OPT_Wc___compat,
-            "C++ lookup of %qD would return a field, not a type",
-            type);
-
-      /* If we are parsing a struct, record that a struct field
-         used a typedef.  */
-      if (warn_cxx_compat && struct_parse_info != NULL)
-        VEC_safe_push (tree, heap, struct_parse_info->typedefs_seen, type);
-    }
+	{
+	  specs->type = TREE_TYPE (type);
+	  specs->decl_attr = DECL_ATTRIBUTES (type);
+	  specs->typedef_p = true;
+	  specs->explicit_signed_p = C_TYPEDEF_EXPLICITLY_SIGNED (type);
+
+	  /* If this typedef name is defined in a struct, then a C++
+	     lookup would return a different value.  */
+	  if (warn_cxx_compat
+	      && I_SYMBOL_BINDING (DECL_NAME (type))->in_struct)
+	    warning_at (loc, OPT_Wc___compat,
+			"C++ lookup of %qD would return a field, not a type",
+			type);
+
+	  /* If we are parsing a struct, record that a struct field
+	     used a typedef.  */
+	  if (warn_cxx_compat && struct_parse_info != NULL)
+	    VEC_safe_push (tree, heap, struct_parse_info->typedefs_seen, type);
+	}
     }
   else if (TREE_CODE (type) == IDENTIFIER_NODE)
     {
       tree t = lookup_name (type);
       if (!t || TREE_CODE (t) != TYPE_DECL)
-    error_at (loc, "%qE fails to be a typedef or built in type", type);
+	error_at (loc, "%qE fails to be a typedef or built in type", type);
       else if (TREE_TYPE (t) == error_mark_node)
-    ;
+	;
       else
-    specs->type = TREE_TYPE (t);
+	specs->type = TREE_TYPE (t);
     }
   else
     {
@@ -9536,7 +9522,7 @@
   bool dupe = false;
   specs->declspecs_seen_p = true;
   gcc_assert (TREE_CODE (scspec) == IDENTIFIER_NODE
-          && C_IS_RESERVED_WORD (scspec));
+	      && C_IS_RESERVED_WORD (scspec));
   i = C_RID_CODE (scspec);
   if (specs->non_sc_seen_p)
     warning (OPT_Wold_style_declaration,
@@ -9545,22 +9531,22 @@
     {
     case RID_INLINE:
       /* C99 permits duplicate inline.  Although of doubtful utility,
-     it seems simplest to permit it in gnu89 mode as well, as
-     there is also little utility in maintaining this as a
-     difference between gnu89 and C99 inline.  */
+	 it seems simplest to permit it in gnu89 mode as well, as
+	 there is also little utility in maintaining this as a
+	 difference between gnu89 and C99 inline.  */
       dupe = false;
       specs->inline_p = true;
       break;
     case RID_THREAD:
       dupe = specs->thread_p;
       if (specs->storage_class == csc_auto)
-    error ("%<__thread%> used with %<auto%>");
+	error ("%<__thread%> used with %<auto%>");
       else if (specs->storage_class == csc_register)
-    error ("%<__thread%> used with %<register%>");
+	error ("%<__thread%> used with %<register%>");
       else if (specs->storage_class == csc_typedef)
-    error ("%<__thread%> used with %<typedef%>");
+	error ("%<__thread%> used with %<typedef%>");
       else
-    specs->thread_p = true;
+	specs->thread_p = true;
       break;
     case RID_AUTO:
       n = csc_auto;
@@ -9569,7 +9555,7 @@
       n = csc_extern;
       /* Diagnose "__thread extern".  */
       if (specs->thread_p)
-    error ("%<__thread%> before %<extern%>");
+	error ("%<__thread%> before %<extern%>");
       break;
     case RID_REGISTER:
       n = csc_register;
@@ -9578,7 +9564,7 @@
       n = csc_static;
       /* Diagnose "__thread static".  */
       if (specs->thread_p)
-    error ("%<__thread%> before %<static%>");
+	error ("%<__thread%> before %<static%>");
       break;
     case RID_TYPEDEF:
       n = csc_typedef;
@@ -9593,18 +9579,18 @@
   if (n != csc_none)
     {
       if (specs->storage_class != csc_none && n != specs->storage_class)
-    {
-      error ("multiple storage classes in declaration specifiers");
-    }
+	{
+	  error ("multiple storage classes in declaration specifiers");
+	}
       else
-    {
-      specs->storage_class = n;
-      if (n != csc_extern && n != csc_static && specs->thread_p)
-        {
-          error ("%<__thread%> used with %qE", scspec);
-          specs->thread_p = false;
-        }
-    }
+	{
+	  specs->storage_class = n;
+	  if (n != csc_extern && n != csc_static && specs->thread_p)
+	    {
+	      error ("%<__thread%> used with %qE", scspec);
+	      specs->thread_p = false;
+	    }
+	}
     }
   return specs;
 }
@@ -9651,32 +9637,32 @@
   if (specs->typespec_word == cts_none)
     {
       if (specs->saturating_p)
-    {
-      error ("%<_Sat%> is used without %<_Fract%> or %<_Accum%>");
-      if (!targetm.fixed_point_supported_p ())
-        error ("fixed-point types not supported for this target");
-      specs->typespec_word = cts_fract;
-    }
+	{
+	  error ("%<_Sat%> is used without %<_Fract%> or %<_Accum%>");
+	  if (!targetm.fixed_point_supported_p ())
+	    error ("fixed-point types not supported for this target");
+	  specs->typespec_word = cts_fract;
+	}
       else if (specs->long_p || specs->short_p
-           || specs->signed_p || specs->unsigned_p)
-    {
-      specs->typespec_word = cts_int;
-    }
+	       || specs->signed_p || specs->unsigned_p)
+	{
+	  specs->typespec_word = cts_int;
+	}
       else if (specs->complex_p)
-    {
-      specs->typespec_word = cts_double;
-      pedwarn (input_location, OPT_pedantic,
-           "ISO C does not support plain %<complex%> meaning "
-           "%<double complex%>");
-    }
+	{
+	  specs->typespec_word = cts_double;
+	  pedwarn (input_location, OPT_pedantic,
+		   "ISO C does not support plain %<complex%> meaning "
+		   "%<double complex%>");
+	}
       else
-    {
-      specs->typespec_word = cts_int;
-      specs->default_int_p = true;
-      /* We don't diagnose this here because grokdeclarator will
-         give more specific diagnostics according to whether it is
-         a function definition.  */
-    }
+	{
+	  specs->typespec_word = cts_int;
+	  specs->default_int_p = true;
+	  /* We don't diagnose this here because grokdeclarator will
+	     give more specific diagnostics according to whether it is
+	     a function definition.  */
+	}
     }
 
   /* If "signed" was specified, record this to distinguish "int" and
@@ -9692,31 +9678,31 @@
     case cts_CbC_code:
 #endif
       gcc_assert (!specs->long_p && !specs->short_p
-          && !specs->signed_p && !specs->unsigned_p
-          && !specs->complex_p);
+		  && !specs->signed_p && !specs->unsigned_p
+		  && !specs->complex_p);
       specs->type = void_type_node;
       break;
     case cts_bool:
       gcc_assert (!specs->long_p && !specs->short_p
-          && !specs->signed_p && !specs->unsigned_p
-          && !specs->complex_p);
+		  && !specs->signed_p && !specs->unsigned_p
+		  && !specs->complex_p);
       specs->type = boolean_type_node;
       break;
     case cts_char:
       gcc_assert (!specs->long_p && !specs->short_p);
       gcc_assert (!(specs->signed_p && specs->unsigned_p));
       if (specs->signed_p)
-    specs->type = signed_char_type_node;
+	specs->type = signed_char_type_node;
       else if (specs->unsigned_p)
-    specs->type = unsigned_char_type_node;
+	specs->type = unsigned_char_type_node;
       else
-    specs->type = char_type_node;
+	specs->type = char_type_node;
       if (specs->complex_p)
-    {
-      pedwarn (input_location, OPT_pedantic,
-           "ISO C does not support complex integer types");
-      specs->type = build_complex_type (specs->type);
-    }
+	{
+	  pedwarn (input_location, OPT_pedantic,
+		   "ISO C does not support complex integer types");
+	  specs->type = build_complex_type (specs->type);
+	}
       break;
     case cts_int128:
       gcc_assert (!specs->long_p && !specs->short_p && !specs->long_long_p);
@@ -9735,148 +9721,148 @@
       gcc_assert (!(specs->long_p && specs->short_p));
       gcc_assert (!(specs->signed_p && specs->unsigned_p));
       if (specs->long_long_p)
-    specs->type = (specs->unsigned_p
-               ? long_long_unsigned_type_node
-               : long_long_integer_type_node);
+	specs->type = (specs->unsigned_p
+		       ? long_long_unsigned_type_node
+		       : long_long_integer_type_node);
       else if (specs->long_p)
-    specs->type = (specs->unsigned_p
-               ? long_unsigned_type_node
-               : long_integer_type_node);
+	specs->type = (specs->unsigned_p
+		       ? long_unsigned_type_node
+		       : long_integer_type_node);
       else if (specs->short_p)
-    specs->type = (specs->unsigned_p
-               ? short_unsigned_type_node
-               : short_integer_type_node);
+	specs->type = (specs->unsigned_p
+		       ? short_unsigned_type_node
+		       : short_integer_type_node);
       else
-    specs->type = (specs->unsigned_p
-               ? unsigned_type_node
-               : integer_type_node);
+	specs->type = (specs->unsigned_p
+		       ? unsigned_type_node
+		       : integer_type_node);
       if (specs->complex_p)
-    {
-      pedwarn (input_location, OPT_pedantic,
-           "ISO C does not support complex integer types");
-      specs->type = build_complex_type (specs->type);
-    }
+	{
+	  pedwarn (input_location, OPT_pedantic,
+		   "ISO C does not support complex integer types");
+	  specs->type = build_complex_type (specs->type);
+	}
       break;
     case cts_float:
       gcc_assert (!specs->long_p && !specs->short_p
-          && !specs->signed_p && !specs->unsigned_p);
+		  && !specs->signed_p && !specs->unsigned_p);
       specs->type = (specs->complex_p
-             ? complex_float_type_node
-             : float_type_node);
+		     ? complex_float_type_node
+		     : float_type_node);
       break;
     case cts_double:
       gcc_assert (!specs->long_long_p && !specs->short_p
-          && !specs->signed_p && !specs->unsigned_p);
+		  && !specs->signed_p && !specs->unsigned_p);
       if (specs->long_p)
-    {
-      specs->type = (specs->complex_p
-             ? complex_long_double_type_node
-             : long_double_type_node);
-    }
+	{
+	  specs->type = (specs->complex_p
+			 ? complex_long_double_type_node
+			 : long_double_type_node);
+	}
       else
-    {
-      specs->type = (specs->complex_p
-             ? complex_double_type_node
-             : double_type_node);
-    }
+	{
+	  specs->type = (specs->complex_p
+			 ? complex_double_type_node
+			 : double_type_node);
+	}
       break;
     case cts_dfloat32:
     case cts_dfloat64:
     case cts_dfloat128:
       gcc_assert (!specs->long_p && !specs->long_long_p && !specs->short_p
-          && !specs->signed_p && !specs->unsigned_p && !specs->complex_p);
+		  && !specs->signed_p && !specs->unsigned_p && !specs->complex_p);
       if (specs->typespec_word == cts_dfloat32)
-    specs->type = dfloat32_type_node;
+	specs->type = dfloat32_type_node;
       else if (specs->typespec_word == cts_dfloat64)
-    specs->type = dfloat64_type_node;
+	specs->type = dfloat64_type_node;
       else
-    specs->type = dfloat128_type_node;
+	specs->type = dfloat128_type_node;
       break;
     case cts_fract:
       gcc_assert (!specs->complex_p);
       if (!targetm.fixed_point_supported_p ())
-    specs->type = integer_type_node;
+	specs->type = integer_type_node;
       else if (specs->saturating_p)
-    {
-      if (specs->long_long_p)
-        specs->type = specs->unsigned_p
-              ? sat_unsigned_long_long_fract_type_node
-              : sat_long_long_fract_type_node;
-      else if (specs->long_p)
-        specs->type = specs->unsigned_p
-              ? sat_unsigned_long_fract_type_node
-              : sat_long_fract_type_node;
-      else if (specs->short_p)
-        specs->type = specs->unsigned_p
-              ? sat_unsigned_short_fract_type_node
-              : sat_short_fract_type_node;
+	{
+	  if (specs->long_long_p)
+	    specs->type = specs->unsigned_p
+			  ? sat_unsigned_long_long_fract_type_node
+			  : sat_long_long_fract_type_node;
+	  else if (specs->long_p)
+	    specs->type = specs->unsigned_p
+			  ? sat_unsigned_long_fract_type_node
+			  : sat_long_fract_type_node;
+	  else if (specs->short_p)
+	    specs->type = specs->unsigned_p
+			  ? sat_unsigned_short_fract_type_node
+			  : sat_short_fract_type_node;
+	  else
+	    specs->type = specs->unsigned_p
+			  ? sat_unsigned_fract_type_node
+			  : sat_fract_type_node;
+	}
       else
-        specs->type = specs->unsigned_p
-              ? sat_unsigned_fract_type_node
-              : sat_fract_type_node;
-    }
-      else
-    {
-      if (specs->long_long_p)
-        specs->type = specs->unsigned_p
-              ? unsigned_long_long_fract_type_node
-              : long_long_fract_type_node;
-      else if (specs->long_p)
-        specs->type = specs->unsigned_p
-              ? unsigned_long_fract_type_node
-              : long_fract_type_node;
-      else if (specs->short_p)
-        specs->type = specs->unsigned_p
-              ? unsigned_short_fract_type_node
-              : short_fract_type_node;
-      else
-        specs->type = specs->unsigned_p
-              ? unsigned_fract_type_node
-              : fract_type_node;
-    }
+	{
+	  if (specs->long_long_p)
+	    specs->type = specs->unsigned_p
+			  ? unsigned_long_long_fract_type_node
+			  : long_long_fract_type_node;
+	  else if (specs->long_p)
+	    specs->type = specs->unsigned_p
+			  ? unsigned_long_fract_type_node
+			  : long_fract_type_node;
+	  else if (specs->short_p)
+	    specs->type = specs->unsigned_p
+			  ? unsigned_short_fract_type_node
+			  : short_fract_type_node;
+	  else
+	    specs->type = specs->unsigned_p
+			  ? unsigned_fract_type_node
+			  : fract_type_node;
+	}
       break;
     case cts_accum:
       gcc_assert (!specs->complex_p);
       if (!targetm.fixed_point_supported_p ())
-    specs->type = integer_type_node;
+	specs->type = integer_type_node;
       else if (specs->saturating_p)
-    {
-      if (specs->long_long_p)
-        specs->type = specs->unsigned_p
-              ? sat_unsigned_long_long_accum_type_node
-              : sat_long_long_accum_type_node;
-      else if (specs->long_p)
-        specs->type = specs->unsigned_p
-              ? sat_unsigned_long_accum_type_node
-              : sat_long_accum_type_node;
-      else if (specs->short_p)
-        specs->type = specs->unsigned_p
-              ? sat_unsigned_short_accum_type_node
-              : sat_short_accum_type_node;
+	{
+	  if (specs->long_long_p)
+	    specs->type = specs->unsigned_p
+			  ? sat_unsigned_long_long_accum_type_node
+			  : sat_long_long_accum_type_node;
+	  else if (specs->long_p)
+	    specs->type = specs->unsigned_p
+			  ? sat_unsigned_long_accum_type_node
+			  : sat_long_accum_type_node;
+	  else if (specs->short_p)
+	    specs->type = specs->unsigned_p
+			  ? sat_unsigned_short_accum_type_node
+			  : sat_short_accum_type_node;
+	  else
+	    specs->type = specs->unsigned_p
+			  ? sat_unsigned_accum_type_node
+			  : sat_accum_type_node;
+	}
       else
-        specs->type = specs->unsigned_p
-              ? sat_unsigned_accum_type_node
-              : sat_accum_type_node;
-    }
-      else
-    {
-      if (specs->long_long_p)
-        specs->type = specs->unsigned_p
-              ? unsigned_long_long_accum_type_node
-              : long_long_accum_type_node;
-      else if (specs->long_p)
-        specs->type = specs->unsigned_p
-              ? unsigned_long_accum_type_node
-              : long_accum_type_node;
-      else if (specs->short_p)
-        specs->type = specs->unsigned_p
-              ? unsigned_short_accum_type_node
-              : short_accum_type_node;
-      else
-        specs->type = specs->unsigned_p
-              ? unsigned_accum_type_node
-              : accum_type_node;
-    }
+	{
+	  if (specs->long_long_p)
+	    specs->type = specs->unsigned_p
+			  ? unsigned_long_long_accum_type_node
+			  : long_long_accum_type_node;
+	  else if (specs->long_p)
+	    specs->type = specs->unsigned_p
+			  ? unsigned_long_accum_type_node
+			  : long_accum_type_node;
+	  else if (specs->short_p)
+	    specs->type = specs->unsigned_p
+			  ? unsigned_short_accum_type_node
+			  : short_accum_type_node;
+	  else
+	    specs->type = specs->unsigned_p
+			  ? unsigned_accum_type_node
+			  : accum_type_node;
+	}
       break;
     default:
       gcc_unreachable ();
@@ -9899,17 +9885,17 @@
   for (decl = globals; decl; decl = DECL_CHAIN (decl))
     {
       /* Check for used but undefined static functions using the C
-     standard's definition of "used", and set TREE_NO_WARNING so
-     that check_global_declarations doesn't repeat the check.  */
+	 standard's definition of "used", and set TREE_NO_WARNING so
+	 that check_global_declarations doesn't repeat the check.  */
       if (TREE_CODE (decl) == FUNCTION_DECL
-      && DECL_INITIAL (decl) == 0
-      && DECL_EXTERNAL (decl)
-      && !TREE_PUBLIC (decl)
-      && C_DECL_USED (decl))
-    {
-      pedwarn (input_location, 0, "%q+F used but never defined", decl);
-      TREE_NO_WARNING (decl) = 1;
-    }
+	  && DECL_INITIAL (decl) == 0
+	  && DECL_EXTERNAL (decl)
+	  && !TREE_PUBLIC (decl)
+	  && C_DECL_USED (decl))
+	{
+	  pedwarn (input_location, 0, "%q+F used but never defined", decl);
+	  TREE_NO_WARNING (decl) = 1;
+	}
 
       wrapup_global_declaration_1 (decl);
     }
@@ -10019,10 +10005,10 @@
       int flags;
       FILE * stream = dump_begin (TDI_tu, &flags);
       if (stream && tmp)
-    {
-      dump_node (tmp, flags & ~TDF_SLIM, stream);
-      dump_end (TDI_tu, stream);
-    }
+	{
+	  dump_node (tmp, flags & ~TDF_SLIM, stream);
+	  dump_end (TDI_tu, stream);
+	}
     }
 
   /* Process all file scopes in this compilation, and the external_scope,
--- a/gcc/c-family/c-common.c	Sun Aug 21 07:53:12 2011 +0900
+++ b/gcc/c-family/c-common.c	Sun Aug 21 09:24:16 2011 +0900
@@ -420,6 +420,10 @@
   { "__asm__",		RID_ASM,	0 },
   { "__attribute",	RID_ATTRIBUTE,	0 },
   { "__attribute__",	RID_ATTRIBUTE,	0 },
+#ifndef noCbC
+  /* CbC project */
+  { "__code",         RID_CbC_CODE,   0 },
+#endif
   { "__builtin_choose_expr", RID_CHOOSE_EXPR, D_CONLY },
   { "__builtin_offsetof", RID_OFFSETOF, 0 },
   { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P, D_CONLY },
@@ -428,6 +432,11 @@
   { "__complex__",	RID_COMPLEX,	0 },
   { "__const",		RID_CONST,	0 },
   { "__const__",	RID_CONST,	0 },
+#ifndef noCbC
+  /* CbC project */
+  { "_CbC_environment",  RID_CbC_ENV,    0 },
+  { "_CbC_return",       RID_CbC_RET,    0 },
+#endif
   { "__decltype",       RID_DECLTYPE,   D_CXXONLY },
   { "__extension__",	RID_EXTENSION,	0 },
   { "__func__",		RID_C99_FUNCTION_NAME, 0 },
--- a/gcc/c-family/c-common.h	Sun Aug 21 07:53:12 2011 +0900
+++ b/gcc/c-family/c-common.h	Sun Aug 21 09:24:16 2011 +0900
@@ -155,6 +155,10 @@
   RID_AT_INTERFACE,
   RID_AT_IMPLEMENTATION,
 
+#ifndef noCbC
+  /* Continuation based C */
+  RID_CbC_CODE, RID_CbC_ENV, RID_CbC_RET,
+#endif
   /* Named address support, mapping the keyword to a particular named address
      number.  Named address space 0 is reserved for the generic address.  If
      there are more than 254 named addresses, the addr_space_t type will need
--- a/gcc/c-parser.c	Sun Aug 21 07:53:12 2011 +0900
+++ b/gcc/c-parser.c	Sun Aug 21 09:24:16 2011 +0900
@@ -56,9 +56,6 @@
 #include "vec.h"
 #include "target.h"
 #include "cgraph.h"
-#ifndef noCbC
-#include "cbc-tree.h"
-#endif
 #include "plugin.h"
 
 
@@ -84,7 +81,7 @@
     {
       mask |= D_ASM | D_EXT;
       if (!flag_isoc99)
-    mask |= D_EXT89;
+	mask |= D_EXT89;
     }
   if (!c_dialect_objc ())
     mask |= D_OBJC | D_CXX_OBJC;
@@ -93,18 +90,18 @@
   for (i = 0; i < num_c_common_reswords; i++)
     {
       /* If a keyword is disabled, do not enter it into the table
-     and so create a canonical spelling that isn't a keyword.  */
+	 and so create a canonical spelling that isn't a keyword.  */
       if (c_common_reswords[i].disable & mask)
-    {
-      if (warn_cxx_compat
-          && (c_common_reswords[i].disable & D_CXXWARN))
-        {
-          id = get_identifier (c_common_reswords[i].word);
-          C_SET_RID_CODE (id, RID_CXX_COMPAT_WARN);
-          C_IS_RESERVED_WORD (id) = 1;
-        }
-      continue;
-    }
+	{
+	  if (warn_cxx_compat
+	      && (c_common_reswords[i].disable & D_CXXWARN))
+	    {
+	      id = get_identifier (c_common_reswords[i].word);
+	      C_SET_RID_CODE (id, RID_CXX_COMPAT_WARN);
+	      C_IS_RESERVED_WORD (id) = 1;
+	    }
+	  continue;
+	}
 
       id = get_identifier (c_common_reswords[i].word);
       C_SET_RID_CODE (id, c_common_reswords[i].rid);
@@ -217,8 +214,8 @@
   timevar_push (TV_LEX);
 
   token->type = c_lex_with_flags (&token->value, &token->location, NULL,
-                  (parser->lex_untranslated_string
-                   ? C_LEX_STRING_NO_TRANSLATE : 0));
+				  (parser->lex_untranslated_string
+				   ? C_LEX_STRING_NO_TRANSLATE : 0));
   token->id_kind = C_ID_NONE;
   token->keyword = RID_MAX;
   token->pragma_kind = PRAGMA_NONE;
@@ -376,9 +373,9 @@
     case CPP_CLOSE_PAREN:
     case CPP_SEMICOLON:
       /* These tokens may affect the interpretation of any identifiers
-     following, if doing Objective-C.  */
+	 following, if doing Objective-C.  */
       if (c_dialect_objc ())
-    parser->objc_need_raw_identifier = false;
+	parser->objc_need_raw_identifier = false;
       break;
     case CPP_PRAGMA:
       /* We smuggled the cpp_token->u.pragma value in an INTEGER_CST.  */
@@ -457,19 +454,19 @@
     {
     case CPP_NAME:
       switch (token->id_kind)
-    {
-    case C_ID_ID:
-      return false;
-    case C_ID_ADDRSPACE:
-      return true;
-    case C_ID_TYPENAME:
-      return true;
-    case C_ID_CLASSNAME:
-      gcc_assert (c_dialect_objc ());
-      return true;
-    default:
-      gcc_unreachable ();
-    }
+	{
+	case C_ID_ID:
+	  return false;
+	case C_ID_ADDRSPACE:
+	  return true;
+	case C_ID_TYPENAME:
+	  return true;
+	case C_ID_CLASSNAME:
+	  gcc_assert (c_dialect_objc ());
+	  return true;
+	default:
+	  gcc_unreachable ();
+	}
     case CPP_KEYWORD:
       switch (token->keyword)
 	{
@@ -505,7 +502,7 @@
 	}
     case CPP_LESS:
       if (c_dialect_objc ())
-    return true;
+	return true;
       return false;
     default:
       return false;
@@ -604,19 +601,19 @@
     {
     case CPP_NAME:
       switch (token->id_kind)
-    {
-    case C_ID_ID:
-      return false;
-    case C_ID_ADDRSPACE:
-      return true;
-    case C_ID_TYPENAME:
-      return true;
-    case C_ID_CLASSNAME:
-      gcc_assert (c_dialect_objc ());
-      return true;
-    default:
-      gcc_unreachable ();
-    }
+	{
+	case C_ID_ID:
+	  return false;
+	case C_ID_ADDRSPACE:
+	  return true;
+	case C_ID_TYPENAME:
+	  return true;
+	case C_ID_CLASSNAME:
+	  gcc_assert (c_dialect_objc ());
+	  return true;
+	default:
+	  gcc_unreachable ();
+	}
     case CPP_KEYWORD:
       switch (token->keyword)
 	{
@@ -653,16 +650,13 @@
 	case RID_FRACT:
 	case RID_ACCUM:
 	case RID_SAT:
-#ifndef noCbC
-	case RID_CbC_CODE:
-#endif
-	return true;
+	  return true;
 	default:
 	  return false;
 	}
     case CPP_LESS:
       if (c_dialect_objc ())
-    return true;
+	return true;
       return false;
     default:
       return false;
@@ -797,15 +791,15 @@
      the token we just peeked at.  */
   c_parser_set_source_position_from_token (token);
   c_parse_error (gmsgid,
-         /* Because c_parse_error does not understand
-            CPP_KEYWORD, keywords are treated like
-            identifiers.  */
-         (token->type == CPP_KEYWORD ? CPP_NAME : token->type),
-         /* ??? The C parser does not save the cpp flags of a
-            token, we need to pass 0 here and we will not get
-            the source spelling of some tokens but rather the
-            canonical spelling.  */
-         token->value, /*flags=*/0);
+		 /* Because c_parse_error does not understand
+		    CPP_KEYWORD, keywords are treated like
+		    identifiers.  */
+		 (token->type == CPP_KEYWORD ? CPP_NAME : token->type),
+		 /* ??? The C parser does not save the cpp flags of a
+		    token, we need to pass 0 here and we will not get
+		    the source spelling of some tokens but rather the
+		    canonical spelling.  */
+		 token->value, /*flags=*/0);
 }
 
 /* If the next token is of the indicated TYPE, consume it.  Otherwise,
@@ -815,8 +809,8 @@
 
 static bool
 c_parser_require (c_parser *parser,
-          enum cpp_ttype type,
-          const char *msgid)
+		  enum cpp_ttype type,
+		  const char *msgid)
 {
   if (c_parser_next_token_is (parser, type))
     {
@@ -835,8 +829,8 @@
 
 static bool
 c_parser_require_keyword (c_parser *parser,
-              enum rid keyword,
-              const char *msgid)
+			  enum rid keyword,
+			  const char *msgid)
 {
   if (c_parser_next_token_is_keyword (parser, keyword))
     {
@@ -858,8 +852,8 @@
 
 static void
 c_parser_skip_until_found (c_parser *parser,
-               enum cpp_ttype type,
-               const char *msgid)
+			   enum cpp_ttype type,
+			   const char *msgid)
 {
   unsigned nesting_depth = 0;
 
@@ -873,27 +867,27 @@
       c_token *token = c_parser_peek_token (parser);
       /* If we've reached the token we want, consume it and stop.  */
       if (token->type == type && !nesting_depth)
-    {
-      c_parser_consume_token (parser);
-      break;
-    }
+	{
+	  c_parser_consume_token (parser);
+	  break;
+	}
 
       /* If we've run out of tokens, stop.  */
       if (token->type == CPP_EOF)
-    return;
+	return;
       if (token->type == CPP_PRAGMA_EOL && parser->in_pragma)
-    return;
+	return;
       if (token->type == CPP_OPEN_BRACE
-      || token->type == CPP_OPEN_PAREN
-      || token->type == CPP_OPEN_SQUARE)
-    ++nesting_depth;
+	  || token->type == CPP_OPEN_PAREN
+	  || token->type == CPP_OPEN_SQUARE)
+	++nesting_depth;
       else if (token->type == CPP_CLOSE_BRACE
-           || token->type == CPP_CLOSE_PAREN
-           || token->type == CPP_CLOSE_SQUARE)
-    {
-      if (nesting_depth-- == 0)
-        break;
-    }
+	       || token->type == CPP_CLOSE_PAREN
+	       || token->type == CPP_CLOSE_SQUARE)
+	{
+	  if (nesting_depth-- == 0)
+	    break;
+	}
       /* Consume this token.  */
       c_parser_consume_token (parser);
     }
@@ -912,24 +906,24 @@
     {
       c_token *token = c_parser_peek_token (parser);
       if ((token->type == CPP_COMMA || token->type == CPP_SEMICOLON)
-      && !nesting_depth)
-    break;
+	  && !nesting_depth)
+	break;
       /* If we've run out of tokens, stop.  */
       if (token->type == CPP_EOF)
-    return;
+	return;
       if (token->type == CPP_PRAGMA_EOL && parser->in_pragma)
-    return;
+	return;
       if (token->type == CPP_OPEN_BRACE
-      || token->type == CPP_OPEN_PAREN
-      || token->type == CPP_OPEN_SQUARE)
-    ++nesting_depth;
+	  || token->type == CPP_OPEN_PAREN
+	  || token->type == CPP_OPEN_SQUARE)
+	++nesting_depth;
       else if (token->type == CPP_CLOSE_BRACE
-           || token->type == CPP_CLOSE_PAREN
-           || token->type == CPP_CLOSE_SQUARE)
-    {
-      if (nesting_depth-- == 0)
-        break;
-    }
+	       || token->type == CPP_CLOSE_PAREN
+	       || token->type == CPP_CLOSE_SQUARE)
+	{
+	  if (nesting_depth-- == 0)
+	    break;
+	}
       /* Consume this token.  */
       c_parser_consume_token (parser);
     }
@@ -948,15 +942,15 @@
   if (!c_parser_require (parser, CPP_PRAGMA_EOL, "expected end of line"))
     while (true)
       {
-    c_token *token = c_parser_peek_token (parser);
-    if (token->type == CPP_EOF)
-      break;
-    if (token->type == CPP_PRAGMA_EOL)
-      {
-        c_parser_consume_token (parser);
-        break;
-      }
-    c_parser_consume_token (parser);
+	c_token *token = c_parser_peek_token (parser);
+	if (token->type == CPP_EOF)
+	  break;
+	if (token->type == CPP_PRAGMA_EOL)
+	  {
+	    c_parser_consume_token (parser);
+	    break;
+	  }
+	c_parser_consume_token (parser);
       }
 
   parser->error = false;
@@ -979,57 +973,57 @@
       token = c_parser_peek_token (parser);
 
       switch (token->type)
-    {
-    case CPP_EOF:
-      return;
-
-    case CPP_PRAGMA_EOL:
-      if (parser->in_pragma)
-        return;
-      break;
-
-    case CPP_SEMICOLON:
-      /* If the next token is a ';', we have reached the
-         end of the statement.  */
-      if (!nesting_depth)
-        {
-          /* Consume the ';'.  */
-          c_parser_consume_token (parser);
-          goto finished;
-        }
-      break;
-
-    case CPP_CLOSE_BRACE:
-      /* If the next token is a non-nested '}', then we have
-         reached the end of the current block.  */
-      if (nesting_depth == 0 || --nesting_depth == 0)
-        {
-          c_parser_consume_token (parser);
-          goto finished;
-        }
-      break;
-
-    case CPP_OPEN_BRACE:
-      /* If it the next token is a '{', then we are entering a new
-         block.  Consume the entire block.  */
-      ++nesting_depth;
-      break;
-
-    case CPP_PRAGMA:
-      /* If we see a pragma, consume the whole thing at once.  We
-         have some safeguards against consuming pragmas willy-nilly.
-         Normally, we'd expect to be here with parser->error set,
-         which disables these safeguards.  But it's possible to get
-         here for secondary error recovery, after parser->error has
-         been cleared.  */
-      c_parser_consume_pragma (parser);
-      c_parser_skip_to_pragma_eol (parser);
-      parser->error = save_error;
-      continue;
-
-    default:
-      break;
-    }
+	{
+	case CPP_EOF:
+	  return;
+
+	case CPP_PRAGMA_EOL:
+	  if (parser->in_pragma)
+	    return;
+	  break;
+
+	case CPP_SEMICOLON:
+	  /* If the next token is a ';', we have reached the
+	     end of the statement.  */
+	  if (!nesting_depth)
+	    {
+	      /* Consume the ';'.  */
+	      c_parser_consume_token (parser);
+	      goto finished;
+	    }
+	  break;
+
+	case CPP_CLOSE_BRACE:
+	  /* If the next token is a non-nested '}', then we have
+	     reached the end of the current block.  */
+	  if (nesting_depth == 0 || --nesting_depth == 0)
+	    {
+	      c_parser_consume_token (parser);
+	      goto finished;
+	    }
+	  break;
+
+	case CPP_OPEN_BRACE:
+	  /* If it the next token is a '{', then we are entering a new
+	     block.  Consume the entire block.  */
+	  ++nesting_depth;
+	  break;
+
+	case CPP_PRAGMA:
+	  /* If we see a pragma, consume the whole thing at once.  We
+	     have some safeguards against consuming pragmas willy-nilly.
+	     Normally, we'd expect to be here with parser->error set,
+	     which disables these safeguards.  But it's possible to get
+	     here for secondary error recovery, after parser->error has
+	     been cleared.  */
+	  c_parser_consume_pragma (parser);
+	  c_parser_skip_to_pragma_eol (parser);
+	  parser->error = save_error;
+	  continue;
+
+	default:
+	  break;
+	}
 
       c_parser_consume_token (parser);
     }
@@ -1107,12 +1101,12 @@
 static tree c_parser_struct_declaration (c_parser *);
 static struct c_typespec c_parser_typeof_specifier (c_parser *);
 static struct c_declarator *c_parser_declarator (c_parser *, bool, c_dtr_syn,
-                         bool *);
+						 bool *);
 static struct c_declarator *c_parser_direct_declarator (c_parser *, bool,
-                            c_dtr_syn, bool *);
+							c_dtr_syn, bool *);
 static struct c_declarator *c_parser_direct_declarator_inner (c_parser *,
-                                  bool,
-                                  struct c_declarator *);
+							      bool,
+							      struct c_declarator *);
 static struct c_arg_info *c_parser_parms_declarator (c_parser *, bool, tree);
 static struct c_arg_info *c_parser_parms_list_declarator (c_parser *, tree);
 static struct c_parm *c_parser_parameter_declaration (c_parser *, tree);
@@ -1140,7 +1134,7 @@
 static tree c_parser_asm_clobbers (c_parser *);
 static struct c_expr c_parser_expr_no_commas (c_parser *, struct c_expr *);
 static struct c_expr c_parser_conditional_expression (c_parser *,
-                              struct c_expr *);
+						      struct c_expr *);
 static struct c_expr c_parser_binary_expression (c_parser *, struct c_expr *);
 static struct c_expr c_parser_cast_expression (c_parser *, struct c_expr *);
 static struct c_expr c_parser_unary_expression (c_parser *);
@@ -1148,15 +1142,15 @@
 static struct c_expr c_parser_alignof_expression (c_parser *);
 static struct c_expr c_parser_postfix_expression (c_parser *);
 static struct c_expr c_parser_postfix_expression_after_paren_type (c_parser *,
-                                   struct c_type_name *,
-                                   location_t);
+								   struct c_type_name *,
+								   location_t);
 static struct c_expr c_parser_postfix_expression_after_primary (c_parser *,
-                                location_t loc,
-                                struct c_expr);
+								location_t loc,
+								struct c_expr);
 static struct c_expr c_parser_expression (c_parser *);
 static struct c_expr c_parser_expression_conv (c_parser *);
 static VEC(tree,gc) *c_parser_expr_list (c_parser *, bool, bool,
-                     VEC(tree,gc) **);
+					 VEC(tree,gc) **);
 static void c_parser_omp_construct (c_parser *);
 static void c_parser_omp_threadprivate (c_parser *);
 static void c_parser_omp_barrier (c_parser *);
@@ -1214,18 +1208,18 @@
   if (c_parser_next_token_is (parser, CPP_EOF))
     {
       pedwarn (c_parser_peek_token (parser)->location, OPT_pedantic,
-           "ISO C forbids an empty translation unit");
+	       "ISO C forbids an empty translation unit");
     }
   else
     {
       void *obstack_position = obstack_alloc (&parser_obstack, 0);
       mark_valid_location_for_stdc_pragma (false);
       do
-    {
-      ggc_collect ();
-      c_parser_external_declaration (parser);
-      obstack_free (&parser_obstack, obstack_position);
-    }
+	{
+	  ggc_collect ();
+	  c_parser_external_declaration (parser);
+	  obstack_free (&parser_obstack, obstack_position);
+	}
       while (c_parser_next_token_is_not (parser, CPP_EOF));
     }
 }
@@ -1312,7 +1306,7 @@
       break;
     case CPP_SEMICOLON:
       pedwarn (c_parser_peek_token (parser)->location, OPT_pedantic,
-           "ISO C does not allow extra %<;%> outside of a function");
+	       "ISO C does not allow extra %<;%> outside of a function");
       c_parser_consume_token (parser);
       break;
     case CPP_PRAGMA:
@@ -1323,12 +1317,12 @@
     case CPP_PLUS:
     case CPP_MINUS:
       if (c_dialect_objc ())
-    {
-      c_parser_objc_method_definition (parser);
-      break;
-    }
+	{
+	  c_parser_objc_method_definition (parser);
+	  break;
+	}
       /* Else fall through, and yield a syntax error trying to parse
-     as a declaration or function definition.  */
+	 as a declaration or function definition.  */
     default:
     decl_or_fndef:
       /* A declaration or a function definition (or, in Objective-C,
@@ -1466,12 +1460,12 @@
   if (c_parser_next_token_is (parser, CPP_SEMICOLON))
     {
       if (empty_ok)
-    shadow_tag (specs);
+	shadow_tag (specs);
       else
-    {
-      shadow_tag_warned (specs, 1);
-      pedwarn (here, 0, "empty declaration");
-    }
+	{
+	  shadow_tag_warned (specs, 1);
+	  pedwarn (here, 0, "empty declaration");
+	}
       c_parser_consume_token (parser);
       return;
     }
@@ -1583,10 +1577,10 @@
 					specs->typespec_kind != ctsk_none,
 					C_DTR_NORMAL, &dummy);
       if (declarator == NULL)
-    {
-      c_parser_skip_to_end_of_block_or_statement (parser);
-      return;
-    }
+	{
+	  c_parser_skip_to_end_of_block_or_statement (parser);
+	  return;
+	}
       if (c_parser_next_token_is (parser, CPP_EQ)
 	  || c_parser_next_token_is (parser, CPP_COMMA)
 	  || c_parser_next_token_is (parser, CPP_SEMICOLON)
@@ -1680,67 +1674,67 @@
 	    }
 	}
       else if (!fndef_ok)
-    {
-      c_parser_error (parser, "expected %<=%>, %<,%>, %<;%>, "
-              "%<asm%> or %<__attribute__%>");
-      c_parser_skip_to_end_of_block_or_statement (parser);
-      return;
-    }
+	{
+	  c_parser_error (parser, "expected %<=%>, %<,%>, %<;%>, "
+			  "%<asm%> or %<__attribute__%>");
+	  c_parser_skip_to_end_of_block_or_statement (parser);
+	  return;
+	}
       /* Function definition (nested or otherwise).  */
       if (nested)
-    {
-      pedwarn (here, OPT_pedantic, "ISO C forbids nested functions");
-      c_push_function_context ();
-    }
+	{
+	  pedwarn (here, OPT_pedantic, "ISO C forbids nested functions");
+	  c_push_function_context ();
+	}
       if (!start_function (specs, declarator, all_prefix_attrs))
-    {
-      /* This can appear in many cases looking nothing like a
-         function definition, so we don't give a more specific
-         error suggesting there was one.  */
-      c_parser_error (parser, "expected %<=%>, %<,%>, %<;%>, %<asm%> "
-              "or %<__attribute__%>");
-      if (nested)
-        c_pop_function_context ();
-      break;
-    }
+	{
+	  /* This can appear in many cases looking nothing like a
+	     function definition, so we don't give a more specific
+	     error suggesting there was one.  */
+	  c_parser_error (parser, "expected %<=%>, %<,%>, %<;%>, %<asm%> "
+			  "or %<__attribute__%>");
+	  if (nested)
+	    c_pop_function_context ();
+	  break;
+	}
       /* Parse old-style parameter declarations.  ??? Attributes are
-     not allowed to start declaration specifiers here because of a
-     syntax conflict between a function declaration with attribute
-     suffix and a function definition with an attribute prefix on
-     first old-style parameter declaration.  Following the old
-     parser, they are not accepted on subsequent old-style
-     parameter declarations either.  However, there is no
-     ambiguity after the first declaration, nor indeed on the
-     first as long as we don't allow postfix attributes after a
-     declarator with a nonempty identifier list in a definition;
-     and postfix attributes have never been accepted here in
-     function definitions either.  */
+	 not allowed to start declaration specifiers here because of a
+	 syntax conflict between a function declaration with attribute
+	 suffix and a function definition with an attribute prefix on
+	 first old-style parameter declaration.  Following the old
+	 parser, they are not accepted on subsequent old-style
+	 parameter declarations either.  However, there is no
+	 ambiguity after the first declaration, nor indeed on the
+	 first as long as we don't allow postfix attributes after a
+	 declarator with a nonempty identifier list in a definition;
+	 and postfix attributes have never been accepted here in
+	 function definitions either.  */
       while (c_parser_next_token_is_not (parser, CPP_EOF)
 	     && c_parser_next_token_is_not (parser, CPP_OPEN_BRACE))
 	c_parser_declaration_or_fndef (parser, false, false, false,
 				       true, false, NULL);
       store_parm_decls ();
       DECL_STRUCT_FUNCTION (current_function_decl)->function_start_locus
-    = c_parser_peek_token (parser)->location;
+	= c_parser_peek_token (parser)->location;
       fnbody = c_parser_compound_statement (parser);
       if (nested)
-    {
-      tree decl = current_function_decl;
-      /* Mark nested functions as needing static-chain initially.
-         lower_nested_functions will recompute it but the
-         DECL_STATIC_CHAIN flag is also used before that happens,
-         by initializer_constant_valid_p.  See gcc.dg/nested-fn-2.c.  */
-      DECL_STATIC_CHAIN (decl) = 1;
-      add_stmt (fnbody);
-      finish_function ();
-      c_pop_function_context ();
-      add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl), DECL_EXPR, decl));
-    }
+	{
+	  tree decl = current_function_decl;
+	  /* Mark nested functions as needing static-chain initially.
+	     lower_nested_functions will recompute it but the
+	     DECL_STATIC_CHAIN flag is also used before that happens,
+	     by initializer_constant_valid_p.  See gcc.dg/nested-fn-2.c.  */
+	  DECL_STATIC_CHAIN (decl) = 1;
+	  add_stmt (fnbody);
+	  finish_function ();
+	  c_pop_function_context ();
+	  add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl), DECL_EXPR, decl));
+	}
       else
-    {
-      add_stmt (fnbody);
-      finish_function ();
-    }
+	{
+	  add_stmt (fnbody);
+	  finish_function ();
+	}
       break;
     }
 }
@@ -1956,8 +1950,8 @@
     gcc_assert (la == cla_prefer_id);
 
   while (c_parser_next_token_is (parser, CPP_NAME)
-     || c_parser_next_token_is (parser, CPP_KEYWORD)
-     || (c_dialect_objc () && c_parser_next_token_is (parser, CPP_LESS)))
+	 || c_parser_next_token_is (parser, CPP_KEYWORD)
+	 || (c_dialect_objc () && c_parser_next_token_is (parser, CPP_LESS)))
     {
       struct c_typespec t;
       tree attrs;
@@ -2031,21 +2025,21 @@
 	  continue;
 	}
       if (c_parser_next_token_is (parser, CPP_LESS))
-    {
-      /* Make "<SomeProtocol>" equivalent to "id <SomeProtocol>" -
-         nisse@lysator.liu.se.  */
-      tree proto;
-      gcc_assert (c_dialect_objc ());
-      if (!typespec_ok || seen_type)
-        break;
-      proto = c_parser_objc_protocol_refs (parser);
-      t.kind = ctsk_objc;
-      t.spec = objc_get_protocol_qualified_type (NULL_TREE, proto);
-      t.expr = NULL_TREE;
-      t.expr_const_operands = true;
-      declspecs_add_type (loc, specs, t);
-      continue;
-    }
+	{
+	  /* Make "<SomeProtocol>" equivalent to "id <SomeProtocol>" -
+	     nisse@lysator.liu.se.  */
+	  tree proto;
+	  gcc_assert (c_dialect_objc ());
+	  if (!typespec_ok || seen_type)
+	    break;
+	  proto = c_parser_objc_protocol_refs (parser);
+	  t.kind = ctsk_objc;
+	  t.spec = objc_get_protocol_qualified_type (NULL_TREE, proto);
+	  t.expr = NULL_TREE;
+	  t.expr_const_operands = true;
+	  declspecs_add_type (loc, specs, t);
+	  continue;
+	}
       gcc_assert (c_parser_next_token_is (parser, CPP_KEYWORD));
       switch (c_parser_peek_token (parser)->keyword)
 	{
@@ -2096,30 +2090,6 @@
 	  declspecs_add_type (loc, specs, t);
 	  c_parser_consume_token (parser);
 	  break;
-#ifndef noCbC
-    case RID_CbC_CODE:
-      if (!typespec_ok)
-        goto out;
-      attrs_ok = true;
-      seen_type = true;
-      if (c_dialect_objc ())
-        parser->objc_need_raw_identifier = true;
-      t.kind = ctsk_resword;
-      t.spec = c_parser_peek_token (parser)->value;
-      declspecs_add_type (loc, specs, t);
-
-      /*
-      attrs = get_identifier("fastcall");
-      attrs = build_tree_list(attrs, NULL_TREE);
-      declspecs_add_attrs(specs, attrs);
-      */
-      attrs = build_tree_list (get_identifier("fastcall"), NULL_TREE);
-      /*attrs = build_tree_list (get_identifier("noreturn"), attrs);*/
-      declspecs_add_attrs(specs, attrs);
-
-      c_parser_consume_token (parser);
-      break;
-#endif
 	case RID_ENUM:
 	  if (!typespec_ok)
 	    goto out;
@@ -2136,35 +2106,35 @@
 	  seen_type = true;
 	  t = c_parser_struct_or_union_specifier (parser);
           invoke_plugin_callbacks (PLUGIN_FINISH_TYPE, t.spec);
-      declspecs_add_type (loc, specs, t);
-      break;
-    case RID_TYPEOF:
-      /* ??? The old parser rejected typeof after other type
-         specifiers, but is a syntax error the best way of
-         handling this?  */
-      if (!typespec_ok || seen_type)
-        goto out;
-      attrs_ok = true;
-      seen_type = true;
-      t = c_parser_typeof_specifier (parser);
-      declspecs_add_type (loc, specs, t);
-      break;
-    case RID_CONST:
-    case RID_VOLATILE:
-    case RID_RESTRICT:
-      attrs_ok = true;
-      declspecs_add_qual (specs, c_parser_peek_token (parser)->value);
-      c_parser_consume_token (parser);
-      break;
-    case RID_ATTRIBUTE:
-      if (!attrs_ok)
-        goto out;
-      attrs = c_parser_attributes (parser);
-      declspecs_add_attrs (specs, attrs);
-      break;
-    default:
-      goto out;
-    }
+	  declspecs_add_type (loc, specs, t);
+	  break;
+	case RID_TYPEOF:
+	  /* ??? The old parser rejected typeof after other type
+	     specifiers, but is a syntax error the best way of
+	     handling this?  */
+	  if (!typespec_ok || seen_type)
+	    goto out;
+	  attrs_ok = true;
+	  seen_type = true;
+	  t = c_parser_typeof_specifier (parser);
+	  declspecs_add_type (loc, specs, t);
+	  break;
+	case RID_CONST:
+	case RID_VOLATILE:
+	case RID_RESTRICT:
+	  attrs_ok = true;
+	  declspecs_add_qual (specs, c_parser_peek_token (parser)->value);
+	  c_parser_consume_token (parser);
+	  break;
+	case RID_ATTRIBUTE:
+	  if (!attrs_ok)
+	    goto out;
+	  attrs = c_parser_attributes (parser);
+	  declspecs_add_attrs (specs, attrs);
+	  break;
+	default:
+	  goto out;
+	}
     }
  out: ;
 }
@@ -2220,7 +2190,7 @@
       tree type = start_enum (enum_loc, &the_enum, ident);
       tree postfix_attrs;
       /* We chain the enumerators in reverse order, then put them in
-     forward order at the end.  */
+	 forward order at the end.  */
       tree values = NULL_TREE;
       c_parser_consume_token (parser);
       while (true)
@@ -2281,7 +2251,7 @@
 	}
       postfix_attrs = c_parser_attributes (parser);
       ret.spec = finish_enum (type, nreverse (values),
-                  chainon (attrs, postfix_attrs));
+			      chainon (attrs, postfix_attrs));
       ret.kind = ctsk_tagdef;
       ret.expr = NULL_TREE;
       ret.expr_const_operands = true;
@@ -2303,7 +2273,7 @@
     {
       gcc_assert (ident);
       pedwarn (enum_loc, OPT_pedantic,
-           "ISO C forbids forward references to %<enum%> types");
+	       "ISO C forbids forward references to %<enum%> types");
     }
   return ret;
 }
@@ -2384,51 +2354,51 @@
   if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
     {
       /* Parse a struct or union definition.  Start the scope of the
-     tag before parsing components.  */
+	 tag before parsing components.  */
       struct c_struct_parse_info *struct_info;
       tree type = start_struct (struct_loc, code, ident, &struct_info);
       tree postfix_attrs;
       /* We chain the components in reverse order, then put them in
-     forward order at the end.  Each struct-declaration may
-     declare multiple components (comma-separated), so we must use
-     chainon to join them, although when parsing each
-     struct-declaration we can use TREE_CHAIN directly.
-
-     The theory behind all this is that there will be more
-     semicolon separated fields than comma separated fields, and
-     so we'll be minimizing the number of node traversals required
-     by chainon.  */
+	 forward order at the end.  Each struct-declaration may
+	 declare multiple components (comma-separated), so we must use
+	 chainon to join them, although when parsing each
+	 struct-declaration we can use TREE_CHAIN directly.
+
+	 The theory behind all this is that there will be more
+	 semicolon separated fields than comma separated fields, and
+	 so we'll be minimizing the number of node traversals required
+	 by chainon.  */
       tree contents = NULL_TREE;
       c_parser_consume_token (parser);
       /* Handle the Objective-C @defs construct,
-     e.g. foo(sizeof(struct{ @defs(ClassName) }));.  */
+	 e.g. foo(sizeof(struct{ @defs(ClassName) }));.  */
       if (c_parser_next_token_is_keyword (parser, RID_AT_DEFS))
-    {
-      tree name;
-      gcc_assert (c_dialect_objc ());
-      c_parser_consume_token (parser);
-      if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
-        goto end_at_defs;
-      if (c_parser_next_token_is (parser, CPP_NAME)
-          && c_parser_peek_token (parser)->id_kind == C_ID_CLASSNAME)
-        {
-          name = c_parser_peek_token (parser)->value;
-          c_parser_consume_token (parser);
-        }
-      else
-        {
-          c_parser_error (parser, "expected class name");
-          c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
-          goto end_at_defs;
-        }
-      c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
-                     "expected %<)%>");
-      contents = nreverse (objc_get_class_ivars (name));
-    }
+	{
+	  tree name;
+	  gcc_assert (c_dialect_objc ());
+	  c_parser_consume_token (parser);
+	  if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
+	    goto end_at_defs;
+	  if (c_parser_next_token_is (parser, CPP_NAME)
+	      && c_parser_peek_token (parser)->id_kind == C_ID_CLASSNAME)
+	    {
+	      name = c_parser_peek_token (parser)->value;
+	      c_parser_consume_token (parser);
+	    }
+	  else
+	    {
+	      c_parser_error (parser, "expected class name");
+	      c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
+	      goto end_at_defs;
+	    }
+	  c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
+				     "expected %<)%>");
+	  contents = nreverse (objc_get_class_ivars (name));
+	}
     end_at_defs:
       /* Parse the struct-declarations and semicolons.  Problems with
-     semicolons are diagnosed here; empty structures are diagnosed
-     elsewhere.  */
+	 semicolons are diagnosed here; empty structures are diagnosed
+	 elsewhere.  */
       while (true)
 	{
 	  tree decls;
@@ -2481,7 +2451,7 @@
 	}
       postfix_attrs = c_parser_attributes (parser);
       ret.spec = finish_struct (struct_loc, type, nreverse (contents),
-                chainon (attrs, postfix_attrs), struct_info);
+				chainon (attrs, postfix_attrs), struct_info);
       ret.kind = ctsk_tagdef;
       ret.expr = NULL_TREE;
       ret.expr_const_operands = true;
@@ -2578,18 +2548,18 @@
 	  ret = NULL_TREE;
 	}
       else
-    {
-      /* Support for unnamed structs or unions as members of
-         structs or unions (which is [a] useful and [b] supports
-         MS P-SDK).  */
-      tree attrs = NULL;
-
-      ret = grokfield (c_parser_peek_token (parser)->location,
-               build_id_declarator (NULL_TREE), specs,
-               NULL_TREE, &attrs);
-      if (ret)
-        decl_attributes (&ret, attrs, 0);
-    }
+	{
+	  /* Support for unnamed structs or unions as members of
+	     structs or unions (which is [a] useful and [b] supports
+	     MS P-SDK).  */
+	  tree attrs = NULL;
+
+	  ret = grokfield (c_parser_peek_token (parser)->location,
+			   build_id_declarator (NULL_TREE), specs,
+			   NULL_TREE, &attrs);
+	  if (ret)
+	    decl_attributes (&ret, attrs, 0);
+	}
       return ret;
     }
 
@@ -2616,16 +2586,16 @@
       struct c_declarator *declarator;
       bool dummy = false;
       if (c_parser_next_token_is (parser, CPP_COLON))
-    declarator = build_id_declarator (NULL_TREE);
+	declarator = build_id_declarator (NULL_TREE);
       else
 	declarator = c_parser_declarator (parser,
 					  specs->typespec_kind != ctsk_none,
 					  C_DTR_NORMAL, &dummy);
       if (declarator == NULL)
-    {
-      c_parser_skip_to_end_of_block_or_statement (parser);
-      break;
-    }
+	{
+	  c_parser_skip_to_end_of_block_or_statement (parser);
+	  break;
+	}
       if (c_parser_next_token_is (parser, CPP_COLON)
 	  || c_parser_next_token_is (parser, CPP_COMMA)
 	  || c_parser_next_token_is (parser, CPP_SEMICOLON)
@@ -2668,28 +2638,12 @@
 	    }
 	}
       else
-        all_prefix_attrs = prefix_attrs;
-      if (c_parser_next_token_is (parser, CPP_COMMA))
-        c_parser_consume_token (parser);
-      else if (c_parser_next_token_is (parser, CPP_SEMICOLON)
-           || c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
-        {
-          /* Semicolon consumed in caller.  */
-          break;
-        }
-      else
-        {
-          c_parser_error (parser, "expected %<,%>, %<;%> or %<}%>");
-          break;
-        }
-    }
-      else
-    {
-      c_parser_error (parser,
-              "expected %<:%>, %<,%>, %<;%>, %<}%> or "
-              "%<__attribute__%>");
-      break;
-    }
+	{
+	  c_parser_error (parser,
+			  "expected %<:%>, %<,%>, %<;%>, %<}%> or "
+			  "%<__attribute__%>");
+	  break;
+	}
     }
   return decls;
 }
@@ -2725,10 +2679,10 @@
       c_inhibit_evaluation_warnings--;
       in_typeof--;
       if (type != NULL)
-    {
-      ret.spec = groktypename (type, &ret.expr, &ret.expr_const_operands);
-      pop_maybe_used (variably_modified_type_p (ret.spec, NULL_TREE));
-    }
+	{
+	  ret.spec = groktypename (type, &ret.expr, &ret.expr_const_operands);
+	  pop_maybe_used (variably_modified_type_p (ret.spec, NULL_TREE));
+	}
     }
   else
     {
@@ -2744,9 +2698,9 @@
       ret.spec = TREE_TYPE (expr.value);
       was_vm = variably_modified_type_p (ret.spec, NULL_TREE);
       /* This is returned with the type so that when the type is
-     evaluated, this can be evaluated.  */
+	 evaluated, this can be evaluated.  */
       if (was_vm)
-    ret.expr = c_fully_fold (expr.value, false, &ret.expr_const_operands);
+	ret.expr = c_fully_fold (expr.value, false, &ret.expr_const_operands);
       pop_maybe_used (was_vm);
     }
   c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
@@ -2811,11 +2765,11 @@
 
    direct-declarator:
      direct-declarator ( parameter-forward-declarations
-             parameter-type-list[opt] )
+			 parameter-type-list[opt] )
 
    direct-abstract-declarator:
      direct-abstract-declarator[opt] ( parameter-forward-declarations
-                       parameter-type-list[opt] )
+				       parameter-type-list[opt] )
 
    parameter-forward-declarations:
      parameter-list ;
@@ -2832,7 +2786,7 @@
 
 static struct c_declarator *
 c_parser_declarator (c_parser *parser, bool type_seen_p, c_dtr_syn kind,
-             bool *seen_id)
+		     bool *seen_id)
 {
   /* Parse any initial pointer part.  */
   if (c_parser_next_token_is (parser, CPP_MULT))
@@ -2843,9 +2797,9 @@
       c_parser_declspecs (parser, quals_attrs, false, false, true, cla_prefer_id);
       inner = c_parser_declarator (parser, type_seen_p, kind, seen_id);
       if (inner == NULL)
-    return NULL;
+	return NULL;
       else
-    return make_pointer_declarator (quals_attrs, inner);
+	return make_pointer_declarator (quals_attrs, inner);
     }
   /* Now we have a direct declarator, direct abstract declarator or
      nothing (which counts as a direct abstract declarator here).  */
@@ -2857,7 +2811,7 @@
 
 static struct c_declarator *
 c_parser_direct_declarator (c_parser *parser, bool type_seen_p, c_dtr_syn kind,
-                bool *seen_id)
+			    bool *seen_id)
 {
   /* The direct declarator must start with an identifier (possibly
      omitted) or a parenthesized declarator (possibly abstract).  In
@@ -2901,7 +2855,7 @@
 	  || c_parser_peek_token (parser)->id_kind == C_ID_ID))
     {
       struct c_declarator *inner
-    = build_id_declarator (c_parser_peek_token (parser)->value);
+	= build_id_declarator (c_parser_peek_token (parser)->value);
       *seen_id = true;
       inner->id_loc = c_parser_peek_token (parser)->location;
       c_parser_consume_token (parser);
@@ -2925,51 +2879,51 @@
       c_parser_consume_token (parser);
       attrs = c_parser_attributes (parser);
       if (kind != C_DTR_NORMAL
-      && (c_parser_next_token_starts_declspecs (parser)
-          || c_parser_next_token_is (parser, CPP_CLOSE_PAREN)))
-    {
-      struct c_arg_info *args
-        = c_parser_parms_declarator (parser, kind == C_DTR_NORMAL,
-                     attrs);
-      if (args == NULL)
-        return NULL;
-      else
-        {
-          inner
-        = build_function_declarator (args,
-                         build_id_declarator (NULL_TREE));
-          return c_parser_direct_declarator_inner (parser, *seen_id,
-                               inner);
-        }
-    }
+	  && (c_parser_next_token_starts_declspecs (parser)
+	      || c_parser_next_token_is (parser, CPP_CLOSE_PAREN)))
+	{
+	  struct c_arg_info *args
+	    = c_parser_parms_declarator (parser, kind == C_DTR_NORMAL,
+					 attrs);
+	  if (args == NULL)
+	    return NULL;
+	  else
+	    {
+	      inner
+		= build_function_declarator (args,
+					     build_id_declarator (NULL_TREE));
+	      return c_parser_direct_declarator_inner (parser, *seen_id,
+						       inner);
+	    }
+	}
       /* A parenthesized declarator.  */
       inner = c_parser_declarator (parser, type_seen_p, kind, seen_id);
       if (inner != NULL && attrs != NULL)
-    inner = build_attrs_declarator (attrs, inner);
+	inner = build_attrs_declarator (attrs, inner);
       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
-    {
-      c_parser_consume_token (parser);
-      if (inner == NULL)
-        return NULL;
+	{
+	  c_parser_consume_token (parser);
+	  if (inner == NULL)
+	    return NULL;
+	  else
+	    return c_parser_direct_declarator_inner (parser, *seen_id, inner);
+	}
       else
-        return c_parser_direct_declarator_inner (parser, *seen_id, inner);
-    }
-      else
-    {
-      c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
-                     "expected %<)%>");
-      return NULL;
-    }
+	{
+	  c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
+				     "expected %<)%>");
+	  return NULL;
+	}
     }
   else
     {
       if (kind == C_DTR_NORMAL)
-    {
-      c_parser_error (parser, "expected identifier or %<(%>");
-      return NULL;
-    }
+	{
+	  c_parser_error (parser, "expected identifier or %<(%>");
+	  return NULL;
+	}
       else
-    return build_id_declarator (NULL_TREE);
+	return build_id_declarator (NULL_TREE);
     }
 }
 
@@ -2980,7 +2934,7 @@
 
 static struct c_declarator *
 c_parser_direct_declarator_inner (c_parser *parser, bool id_present,
-                  struct c_declarator *inner)
+				  struct c_declarator *inner)
 {
   /* Parse a sequence of array declarators and parameter lists.  */
   if (c_parser_next_token_is (parser, CPP_OPEN_SQUARE))
@@ -2995,40 +2949,48 @@
       c_parser_declspecs (parser, quals_attrs, false, false, true, cla_prefer_id);
       static_seen = c_parser_next_token_is_keyword (parser, RID_STATIC);
       if (static_seen)
-    c_parser_consume_token (parser);
+	c_parser_consume_token (parser);
       if (static_seen && !quals_attrs->declspecs_seen_p)
 	c_parser_declspecs (parser, quals_attrs, false, false, true, cla_prefer_id);
       if (!quals_attrs->declspecs_seen_p)
-    quals_attrs = NULL;
+	quals_attrs = NULL;
       /* If "static" is present, there must be an array dimension.
-     Otherwise, there may be a dimension, "*", or no
-     dimension.  */
+	 Otherwise, there may be a dimension, "*", or no
+	 dimension.  */
       if (static_seen)
-    {
-      star_seen = false;
-      dimen = c_parser_expr_no_commas (parser, NULL).value;
-    }
+	{
+	  star_seen = false;
+	  dimen = c_parser_expr_no_commas (parser, NULL).value;
+	}
       else
-    {
+	{
+	  if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
+	    {
+	      dimen = NULL_TREE;
+	      star_seen = false;
+	    }
+	  else if (c_parser_next_token_is (parser, CPP_MULT))
+	    {
+	      if (c_parser_peek_2nd_token (parser)->type == CPP_CLOSE_SQUARE)
+		{
+		  dimen = NULL_TREE;
+		  star_seen = true;
+		  c_parser_consume_token (parser);
+		}
+	      else
+		{
+		  star_seen = false;
+		  dimen = c_parser_expr_no_commas (parser, NULL).value;
+		}
+	    }
+	  else
+	    {
+	      star_seen = false;
+	      dimen = c_parser_expr_no_commas (parser, NULL).value;
+	    }
+	}
       if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
-        {
-          dimen = NULL_TREE;
-          star_seen = false;
-        }
-      else if (c_parser_next_token_is (parser, CPP_MULT))
-        {
-          if (c_parser_peek_2nd_token (parser)->type == CPP_CLOSE_SQUARE)
-        {
-          dimen = NULL_TREE;
-          star_seen = true;
-          c_parser_consume_token (parser);
-        }
-          else
-        {
-          star_seen = false;
-          dimen = c_parser_expr_no_commas (parser, NULL).value;
-        }
-        }
+	c_parser_consume_token (parser);
       else
 	{
 	  c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
@@ -3038,9 +3000,9 @@
       if (dimen)
 	mark_exp_read (dimen);
       declarator = build_array_declarator (brace_loc, dimen, quals_attrs,
-                       static_seen, star_seen);
+					   static_seen, star_seen);
       if (declarator == NULL)
-    return NULL;
+	return NULL;
       inner = set_array_declarator_inner (declarator, inner);
       return c_parser_direct_declarator_inner (parser, id_present, inner);
     }
@@ -3052,12 +3014,12 @@
       attrs = c_parser_attributes (parser);
       args = c_parser_parms_declarator (parser, id_present, attrs);
       if (args == NULL)
-    return NULL;
+	return NULL;
       else
-    {
-      inner = build_function_declarator (args, inner);
-      return c_parser_direct_declarator_inner (parser, id_present, inner);
-    }
+	{
+	  inner = build_function_declarator (args, inner);
+	  return c_parser_direct_declarator_inner (parser, id_present, inner);
+	}
     }
   return inner;
 }
@@ -3087,15 +3049,21 @@
     {
       tree list = NULL_TREE, *nextp = &list;
       while (c_parser_next_token_is (parser, CPP_NAME)
-         && c_parser_peek_token (parser)->id_kind == C_ID_ID)
-    {
-      *nextp = build_tree_list (NULL_TREE,
-                    c_parser_peek_token (parser)->value);
-      nextp = & TREE_CHAIN (*nextp);
-      c_parser_consume_token (parser);
-      if (c_parser_next_token_is_not (parser, CPP_COMMA))
-        break;
-      c_parser_consume_token (parser);
+	     && c_parser_peek_token (parser)->id_kind == C_ID_ID)
+	{
+	  *nextp = build_tree_list (NULL_TREE,
+				    c_parser_peek_token (parser)->value);
+	  nextp = & TREE_CHAIN (*nextp);
+	  c_parser_consume_token (parser);
+	  if (c_parser_next_token_is_not (parser, CPP_COMMA))
+	    break;
+	  c_parser_consume_token (parser);
+	  if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
+	    {
+	      c_parser_error (parser, "expected identifier");
+	      break;
+	    }
+	}
       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
 	{
 	  struct c_arg_info *ret = build_arg_info ();
@@ -3105,12 +3073,12 @@
 	  return ret;
 	}
       else
-    {
-      c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
-                     "expected %<)%>");
-      pop_scope ();
-      return NULL;
-    }
+	{
+	  c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
+				     "expected %<)%>");
+	  pop_scope ();
+	  return NULL;
+	}
     }
   else
     {
@@ -3146,19 +3114,19 @@
       /* Suppress -Wold-style-definition for this case.  */
       ret->types = error_mark_node;
       error_at (c_parser_peek_token (parser)->location,
-        "ISO C requires a named argument before %<...%>");
+		"ISO C requires a named argument before %<...%>");
       c_parser_consume_token (parser);
       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
-    {
-      c_parser_consume_token (parser);
-      return ret;
-    }
+	{
+	  c_parser_consume_token (parser);
+	  return ret;
+	}
       else
-    {
-      c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
-                     "expected %<)%>");
-      return NULL;
-    }
+	{
+	  c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
+				     "expected %<)%>");
+	  return NULL;
+	}
     }
   /* Nonempty list of parameters, either terminated with semicolon
      (forward declarations; recurse) or with close parenthesis (normal
@@ -3173,13 +3141,13 @@
       else
 	push_parm_decl (parm);
       if (c_parser_next_token_is (parser, CPP_SEMICOLON))
-    {
-      tree new_attrs;
-      c_parser_consume_token (parser);
-      mark_forward_parm_decls ();
-      new_attrs = c_parser_attributes (parser);
-      return c_parser_parms_list_declarator (parser, new_attrs);
-    }
+	{
+	  tree new_attrs;
+	  c_parser_consume_token (parser);
+	  mark_forward_parm_decls ();
+	  new_attrs = c_parser_attributes (parser);
+	  return c_parser_parms_list_declarator (parser, new_attrs);
+	}
       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
 	{
 	  c_parser_consume_token (parser);
@@ -3192,12 +3160,12 @@
 	    return get_parm_info (false);
 	}
       if (!c_parser_require (parser, CPP_COMMA,
-                 "expected %<;%>, %<,%> or %<)%>"))
-    {
-      c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
-      get_pending_sizes ();
-      return NULL;
-    }
+			     "expected %<;%>, %<,%> or %<)%>"))
+	{
+	  c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
+	  get_pending_sizes ();
+	  return NULL;
+	}
       if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
 	{
 	  c_parser_consume_token (parser);
@@ -3275,7 +3243,7 @@
   if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
     postfix_attrs = c_parser_attributes (parser);
   return build_c_parm (specs, chainon (postfix_attrs, prefix_attrs),
-               declarator);
+		       declarator);
 }
 
 /* Parse a string literal in an asm expression.  It should not be
@@ -3301,7 +3269,7 @@
   else if (c_parser_next_token_is (parser, CPP_WSTRING))
     {
       error_at (c_parser_peek_token (parser)->location,
-        "wide string literal in %<asm%>");
+		"wide string literal in %<asm%>");
       str = build_string (1, "");
       c_parser_consume_token (parser);
     }
@@ -3379,20 +3347,20 @@
   while (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
     {
       /* ??? Follow the C++ parser rather than using the
-     lex_untranslated_string kludge.  */
+	 lex_untranslated_string kludge.  */
       parser->lex_untranslated_string = true;
       c_parser_consume_token (parser);
       if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
-    {
-      parser->lex_untranslated_string = false;
-      return attrs;
-    }
+	{
+	  parser->lex_untranslated_string = false;
+	  return attrs;
+	}
       if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
-    {
-      parser->lex_untranslated_string = false;
-      c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
-      return attrs;
-    }
+	{
+	  parser->lex_untranslated_string = false;
+	  c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
+	  return attrs;
+	}
       /* Parse the attribute list.  */
       while (c_parser_next_token_is (parser, CPP_COMMA)
 	     || c_parser_next_token_is (parser, CPP_NAME)
@@ -3514,34 +3482,23 @@
 	  attrs = chainon (attrs, attr);
 	}
       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
-        c_parser_consume_token (parser);
-      else
-        {
-          parser->lex_untranslated_string = false;
-          c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
-                     "expected %<)%>");
-          return attrs;
-        }
-      attrs = chainon (attrs, attr);
-    }
-      if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
-    c_parser_consume_token (parser);
+	c_parser_consume_token (parser);
       else
-    {
-      parser->lex_untranslated_string = false;
-      c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
-                     "expected %<)%>");
-      return attrs;
-    }
+	{
+	  parser->lex_untranslated_string = false;
+	  c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
+				     "expected %<)%>");
+	  return attrs;
+	}
       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
-    c_parser_consume_token (parser);
+	c_parser_consume_token (parser);
       else
-    {
-      parser->lex_untranslated_string = false;
-      c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
-                     "expected %<)%>");
-      return attrs;
-    }
+	{
+	  parser->lex_untranslated_string = false;
+	  c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
+				     "expected %<)%>");
+	  return attrs;
+	}
       parser->lex_untranslated_string = false;
     }
   return attrs;
@@ -3668,7 +3625,7 @@
   else
     {
       /* Parse a non-empty initializer list, possibly with a trailing
-     comma.  */
+	 comma.  */
       while (true)
 	{
 	  c_parser_initelt (parser, &braced_init_obstack);
@@ -3714,14 +3671,14 @@
 		      braced_init_obstack);
       /* Use the colon as the error location.  */
       pedwarn (c_parser_peek_2nd_token (parser)->location, OPT_pedantic,
-           "obsolete use of designated initializer with %<:%>");
+	       "obsolete use of designated initializer with %<:%>");
       c_parser_consume_token (parser);
       c_parser_consume_token (parser);
     }
   else
     {
       /* des_seen is 0 if there have been no designators, 1 if there
-     has been a single array designator and 2 otherwise.  */
+	 has been a single array designator and 2 otherwise.  */
       int des_seen = 0;
       /* Location of a designator.  */
       location_t des_loc = UNKNOWN_LOCATION;  /* Quiet warning.  */
@@ -3980,7 +3937,7 @@
   if (!c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>"))
     {
       /* Ensure a scope is entered and left anyway to avoid confusion
-     if we have just prepared to enter a function body.  */
+	 if we have just prepared to enter a function body.  */
       stmt = c_begin_compound_stmt (true);
       c_end_compound_stmt (brace_loc, stmt, true);
       return error_mark_node;
@@ -4010,34 +3967,34 @@
   if (c_parser_next_token_is_keyword (parser, RID_LABEL))
     {
       /* Read zero or more forward-declarations for labels that nested
-     functions can jump to.  */
+	 functions can jump to.  */
       mark_valid_location_for_stdc_pragma (false);
       while (c_parser_next_token_is_keyword (parser, RID_LABEL))
-    {
-      label_loc = c_parser_peek_token (parser)->location;
-      c_parser_consume_token (parser);
-      /* Any identifiers, including those declared as type names,
-         are OK here.  */
-      while (true)
-        {
-          tree label;
-          if (c_parser_next_token_is_not (parser, CPP_NAME))
-        {
-          c_parser_error (parser, "expected identifier");
-          break;
-        }
-          label
-        = declare_label (c_parser_peek_token (parser)->value);
-          C_DECLARED_LABEL_FLAG (label) = 1;
-          add_stmt (build_stmt (label_loc, DECL_EXPR, label));
-          c_parser_consume_token (parser);
-          if (c_parser_next_token_is (parser, CPP_COMMA))
-        c_parser_consume_token (parser);
-          else
-        break;
-        }
-      c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
-    }
+	{
+	  label_loc = c_parser_peek_token (parser)->location;
+	  c_parser_consume_token (parser);
+	  /* Any identifiers, including those declared as type names,
+	     are OK here.  */
+	  while (true)
+	    {
+	      tree label;
+	      if (c_parser_next_token_is_not (parser, CPP_NAME))
+		{
+		  c_parser_error (parser, "expected identifier");
+		  break;
+		}
+	      label
+		= declare_label (c_parser_peek_token (parser)->value);
+	      C_DECLARED_LABEL_FLAG (label) = 1;
+	      add_stmt (build_stmt (label_loc, DECL_EXPR, label));
+	      c_parser_consume_token (parser);
+	      if (c_parser_next_token_is (parser, CPP_COMMA))
+		c_parser_consume_token (parser);
+	      else
+		break;
+	    }
+	  c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
+	}
       pedwarn (label_loc, OPT_pedantic, "ISO C forbids label declarations");
     }
   /* We must now have at least one statement, label or declaration.  */
@@ -4052,19 +4009,19 @@
     {
       location_t loc = c_parser_peek_token (parser)->location;
       if (c_parser_next_token_is_keyword (parser, RID_CASE)
-      || c_parser_next_token_is_keyword (parser, RID_DEFAULT)
-      || (c_parser_next_token_is (parser, CPP_NAME)
-          && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
-    {
-      if (c_parser_next_token_is_keyword (parser, RID_CASE))
-        label_loc = c_parser_peek_2nd_token (parser)->location;
-      else
-        label_loc = c_parser_peek_token (parser)->location;
-      last_label = true;
-      last_stmt = false;
-      mark_valid_location_for_stdc_pragma (false);
-      c_parser_label (parser);
-    }
+	  || c_parser_next_token_is_keyword (parser, RID_DEFAULT)
+	  || (c_parser_next_token_is (parser, CPP_NAME)
+	      && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
+	{
+	  if (c_parser_next_token_is_keyword (parser, RID_CASE))
+	    label_loc = c_parser_peek_2nd_token (parser)->location;
+	  else
+	    label_loc = c_parser_peek_token (parser)->location;
+	  last_label = true;
+	  last_stmt = false;
+	  mark_valid_location_for_stdc_pragma (false);
+	  c_parser_label (parser);
+	}
       else if (!last_label
 	       && c_parser_next_tokens_start_declaration (parser))
 	{
@@ -4113,26 +4070,26 @@
 	    goto statement;
 	}
       else if (c_parser_next_token_is (parser, CPP_PRAGMA))
-    {
-      /* External pragmas, and some omp pragmas, are not associated
-         with regular c code, and so are not to be considered statements
-         syntactically.  This ensures that the user doesn't put them
-         places that would turn into syntax errors if the directive
-         were ignored.  */
-      if (c_parser_pragma (parser, pragma_compound))
-        last_label = false, last_stmt = true;
-    }
+	{
+	  /* External pragmas, and some omp pragmas, are not associated
+	     with regular c code, and so are not to be considered statements
+	     syntactically.  This ensures that the user doesn't put them
+	     places that would turn into syntax errors if the directive
+	     were ignored.  */
+	  if (c_parser_pragma (parser, pragma_compound))
+	    last_label = false, last_stmt = true;
+	}
       else if (c_parser_next_token_is (parser, CPP_EOF))
-    {
-      mark_valid_location_for_stdc_pragma (save_valid_for_pragma);
-      c_parser_error (parser, "expected declaration or statement");
-      return;
-    }
+	{
+	  mark_valid_location_for_stdc_pragma (save_valid_for_pragma);
+	  c_parser_error (parser, "expected declaration or statement");
+	  return;
+	}
       else if (c_parser_next_token_is_keyword (parser, RID_ELSE))
         {
           if (parser->in_if_block)
             {
-          mark_valid_location_for_stdc_pragma (save_valid_for_pragma);
+	      mark_valid_location_for_stdc_pragma (save_valid_for_pragma);
               error_at (loc, """expected %<}%> before %<else%>");
               return;
             }
@@ -4144,13 +4101,13 @@
             }
         }
       else
-    {
-    statement:
-      last_label = false;
-      last_stmt = true;
-      mark_valid_location_for_stdc_pragma (false);
-      c_parser_statement_after_labels (parser);
-    }
+	{
+	statement:
+	  last_label = false;
+	  last_stmt = true;
+	  mark_valid_location_for_stdc_pragma (false);
+	  c_parser_statement_after_labels (parser);
+	}
 
       parser->error = false;
     }
@@ -4188,25 +4145,25 @@
       c_parser_consume_token (parser);
       exp1 = c_parser_expr_no_commas (parser, NULL).value;
       if (c_parser_next_token_is (parser, CPP_COLON))
-    {
-      c_parser_consume_token (parser);
-      label = do_case (loc1, exp1, NULL_TREE);
-    }
+	{
+	  c_parser_consume_token (parser);
+	  label = do_case (loc1, exp1, NULL_TREE);
+	}
       else if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
-    {
-      c_parser_consume_token (parser);
-      exp2 = c_parser_expr_no_commas (parser, NULL).value;
-      if (c_parser_require (parser, CPP_COLON, "expected %<:%>"))
-        label = do_case (loc1, exp1, exp2);
-    }
+	{
+	  c_parser_consume_token (parser);
+	  exp2 = c_parser_expr_no_commas (parser, NULL).value;
+	  if (c_parser_require (parser, CPP_COLON, "expected %<:%>"))
+	    label = do_case (loc1, exp1, exp2);
+	}
       else
-    c_parser_error (parser, "expected %<:%> or %<...%>");
+	c_parser_error (parser, "expected %<:%> or %<...%>");
     }
   else if (c_parser_next_token_is_keyword (parser, RID_DEFAULT))
     {
       c_parser_consume_token (parser);
       if (c_parser_require (parser, CPP_COLON, "expected %<:%>"))
-    label = do_case (loc1, NULL_TREE, NULL_TREE);
+	label = do_case (loc1, NULL_TREE, NULL_TREE);
     }
   else
     {
@@ -4221,10 +4178,10 @@
       attrs = c_parser_attributes (parser);
       tlab = define_label (loc2, name);
       if (tlab)
-    {
-      decl_attributes (&tlab, attrs, 0);
-      label = add_stmt (build_stmt (loc1, LABEL_EXPR, tlab));
-    }
+	{
+	  decl_attributes (&tlab, attrs, 0);
+	  label = add_stmt (build_stmt (loc1, LABEL_EXPR, tlab));
+	}
     }
   if (label)
     {
@@ -4342,92 +4299,18 @@
 c_parser_statement (c_parser *parser)
 {
   while (c_parser_next_token_is_keyword (parser, RID_CASE)
-     || c_parser_next_token_is_keyword (parser, RID_DEFAULT)
-     || (c_parser_next_token_is (parser, CPP_NAME)
-         && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
+	 || c_parser_next_token_is_keyword (parser, RID_DEFAULT)
+	 || (c_parser_next_token_is (parser, CPP_NAME)
+	     && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
     c_parser_label (parser);
   c_parser_statement_after_labels (parser);
 }
 
-#if 0
-static tree
-c_parser_cbc_make_env(c_parser *parser)
-{
-  struct c_expr env;
-  tree field, fields=NULL_TREE;
-  tree env_struct, env_struct_type;
-  tree ebp, argsp;
-  tree tmp;
-
-  c_parser_consume_token (parser);
-  env = c_parser_expr_no_commas (parser, NULL);
-  env = default_function_array_conversion (env);
-
-    /* build type_node of environment structure  */
-    env_struct_type = start_struct (RECORD_TYPE, NULL_TREE);
-    field = build_decl (FIELD_DECL, get_identifier("sp"), ptr_type_node);
-    fields = chainon (field, fields);
-    field = build_decl (FIELD_DECL, get_identifier("argsp"), ptr_type_node);
-    fields = chainon (field, fields);
-    //field = build_decl (FIELD_DECL, get_identifier("retval"), intSI_type_node);
-    //fields = chainon (field, fields);
-    fields = nreverse(fields);
-    finish_struct (env_struct_type, fields, NULL_TREE);
-
-    env_struct = build_c_cast (build_pointer_type(env_struct_type), env.value);
-    //build_component_ref (cbc_env, get_identifier("argsp"));
-    ebp = build_component_ref (build_indirect_ref (loc,env_struct, "CbCenv->sp"), get_identifier("sp"));
-    argsp = build_component_ref (build_indirect_ref (loc, env_struct, "CbCenv->sp"), get_identifier("argsp"));
-    //ebp = chainon (ebp, argsp);
-    tmp = build_tree_list (ebp, argsp);
-
-    return tmp;
-}
-#endif
-
-static tree
-cbc_replace_arguments (location_t loc, tree call)
-{
-  tree args;
-  tree fn;
-  tree tmp_decl;
-  int i=0;
-
-  fn = CALL_EXPR_FN (call);
-  if ( TREE_CODE (fn)==PARM_DECL || !TREE_CONSTANT (fn) )
-    {
-      tmp_decl = build_decl (loc, VAR_DECL, NULL_TREE, TREE_TYPE(fn));
-      pushdecl (tmp_decl);
-
-      add_stmt (build_modify_expr (loc, tmp_decl, NULL_TREE, NOP_EXPR, loc, fn, NULL_TREE));
-      CALL_EXPR_FN (call) = tmp_decl;
-    }
-
-  args = CALL_EXPR_ARGS (call);
-  for ( ;args; args = TREE_CHAIN (args), i++)
-    {
-      tree arg = TREE_VALUE (args);
-
-      //if ( !CONSTANT_CLASS_P (arg) && !VAR_OR_FUNCTION_DECL_P (arg) )
-      if ( TREE_CODE (arg)==PARM_DECL || !TREE_CONSTANT (arg) )
-    {
-      tmp_decl = build_decl (loc, VAR_DECL, NULL_TREE, TREE_TYPE(arg));
-      pushdecl (tmp_decl);
-
-      add_stmt (build_modify_expr (loc, tmp_decl, NULL_TREE, NOP_EXPR, loc, arg, NULL_TREE));
-      CALL_EXPR_ARG (call, i) = tmp_decl;
-    }
-    }
-
-  return call;
-}
-
 /* Parse a statement, other than a labeled statement.  */
 
 static void
 c_parser_statement_after_labels (c_parser *parser)
 {
-  struct c_expr expr;
   location_t loc = c_parser_peek_token (parser)->location;
   tree stmt = NULL_TREE;
   bool in_if_block = parser->in_if_block;
@@ -4457,14 +4340,8 @@
 	  break;
 	case RID_GOTO:
 	  c_parser_consume_token (parser);
-#ifndef noCbC
-	  if ( c_parser_next_token_is (parser, CPP_NAME)
-	       && c_parser_peek_2nd_token (parser)->type == CPP_SEMICOLON )
-	    {
-#else
 	  if (c_parser_next_token_is (parser, CPP_NAME))
-   	    {
-#endif
+	    {
 	      stmt = c_finish_goto_label (loc,
 					  c_parser_peek_token (parser)->value);
 	      c_parser_consume_token (parser);
@@ -4472,40 +4349,15 @@
 	  else if (c_parser_next_token_is (parser, CPP_MULT))
 	    {
 	      tree val;
+
 	      c_parser_consume_token (parser);
 	      val = c_parser_expression (parser).value;
 	      mark_exp_read (val);
 	      stmt = c_finish_goto_ptr (loc, val);
 	    }
 	  else
-#ifndef noCbC
-        {
-          if (c_parser_next_token_is (parser, CPP_NAME))
-          {
-              tree id = c_parser_peek_token (parser)->value;
-              location_t loc = c_parser_peek_token (parser)->location;
-              /** build_external_ref (id,RID_CbC_CODE , loc); **/
-              build_external_ref (loc, id, RID_CbC_CODE, &expr.original_type);
-          }
-          expr = c_parser_expr_no_commas (parser, NULL);
-          if (TREE_CODE(expr.value) == CALL_EXPR )
-          {
-              location_t loc = c_parser_peek_token (parser)->location;
-              cbc_replace_arguments (loc, expr.value);
-              TREE_TYPE(expr.value) = void_type_node;
-              /*tree env = NULL_TREE;**/
-              CbC_IS_CbC_GOTO (expr.value) = 1;
-              CALL_EXPR_TAILCALL (expr.value) = 1;
-              add_stmt(expr.value);
-              stmt = c_finish_return(loc, NULL_TREE, NULL_TREE); /* stmt = c_finish_return (0); */
-          }
-          else
-            c_parser_error (parser, "expected code segment jump or %<*%>");
-        }
-#else
 	    c_parser_error (parser, "expected identifier or %<*%>");
-#endif
-	    goto expect_semicolon;
+	  goto expect_semicolon;
 	case RID_CONTINUE:
 	  c_parser_consume_token (parser);
 	  stmt = c_finish_bc_stmt (loc, &c_cont_label, false);
@@ -4566,9 +4418,9 @@
     case CPP_CLOSE_PAREN:
     case CPP_CLOSE_SQUARE:
       /* Avoid infinite loop in error recovery:
-     c_parser_skip_until_found stops at a closing nesting
-     delimiter without consuming it, but here we need to consume
-     it to proceed further.  */
+	 c_parser_skip_until_found stops at a closing nesting
+	 delimiter without consuming it, but here we need to consume
+	 it to proceed further.  */
       c_parser_error (parser, "expected statement");
       c_parser_consume_token (parser);
       break;
@@ -4655,9 +4507,9 @@
   tree block = c_begin_compound_stmt (flag_isoc99);
   location_t body_loc = c_parser_peek_token (parser)->location;
   while (c_parser_next_token_is_keyword (parser, RID_CASE)
-     || c_parser_next_token_is_keyword (parser, RID_DEFAULT)
-     || (c_parser_next_token_is (parser, CPP_NAME)
-         && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
+	 || c_parser_next_token_is_keyword (parser, RID_DEFAULT)
+	 || (c_parser_next_token_is (parser, CPP_NAME)
+	     && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
     c_parser_label (parser);
   *if_p = c_parser_next_token_is_keyword (parser, RID_IF);
   if (c_parser_next_token_is (parser, CPP_SEMICOLON))
@@ -4666,8 +4518,8 @@
       add_stmt (build_empty_stmt (loc));
       c_parser_consume_token (parser);
       if (!c_parser_next_token_is_keyword (parser, RID_ELSE))
-    warning_at (loc, OPT_Wempty_body,
-            "suggest braces around empty body in an %<if%> statement");
+	warning_at (loc, OPT_Wempty_body,
+		    "suggest braces around empty body in an %<if%> statement");
     }
   else if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
     add_stmt (c_parser_compound_statement (parser));
@@ -4686,16 +4538,16 @@
   location_t else_loc = c_parser_peek_token (parser)->location;
   tree block = c_begin_compound_stmt (flag_isoc99);
   while (c_parser_next_token_is_keyword (parser, RID_CASE)
-     || c_parser_next_token_is_keyword (parser, RID_DEFAULT)
-     || (c_parser_next_token_is (parser, CPP_NAME)
-         && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
+	 || c_parser_next_token_is_keyword (parser, RID_DEFAULT)
+	 || (c_parser_next_token_is (parser, CPP_NAME)
+	     && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
     c_parser_label (parser);
   if (c_parser_next_token_is (parser, CPP_SEMICOLON))
     {
       location_t loc = c_parser_peek_token (parser)->location;
       warning_at (loc,
-          OPT_Wempty_body,
-             "suggest braces around empty body in an %<else%> statement");
+		  OPT_Wempty_body,
+	         "suggest braces around empty body in an %<else%> statement");
       add_stmt (build_empty_stmt (loc));
       c_parser_consume_token (parser);
     }
@@ -4825,8 +4677,8 @@
   c_parser_consume_token (parser);
   if (c_parser_next_token_is (parser, CPP_SEMICOLON))
     warning_at (c_parser_peek_token (parser)->location,
-        OPT_Wempty_body,
-        "suggest braces around empty body in %<do%> statement");
+		OPT_Wempty_body,
+		"suggest braces around empty body in %<do%> statement");
   block = c_begin_compound_stmt (flag_isoc99);
   loc = c_parser_peek_token (parser)->location;
   save_break = c_break_label;
@@ -5092,12 +4944,12 @@
       c_parser_consume_token (parser);
     }
   else if (c_parser_next_token_is_keyword (parser, RID_CONST)
-       || c_parser_next_token_is_keyword (parser, RID_RESTRICT))
+	   || c_parser_next_token_is_keyword (parser, RID_RESTRICT))
     {
       warning_at (c_parser_peek_token (parser)->location,
-          0,
-          "%E qualifier ignored on asm",
-          c_parser_peek_token (parser)->value);
+		  0,
+		  "%E qualifier ignored on asm",
+		  c_parser_peek_token (parser)->value);
       quals = NULL_TREE;
       c_parser_consume_token (parser);
     }
@@ -5137,40 +4989,40 @@
   for (section = 0; section < nsections; ++section)
     {
       if (!c_parser_require (parser, CPP_COLON,
-                 is_goto
-                 ? "expected %<:%>"
-                 : "expected %<:%> or %<)%>"))
-    goto error_close_paren;
+			     is_goto
+			     ? "expected %<:%>"
+			     : "expected %<:%> or %<)%>"))
+	goto error_close_paren;
 
       /* Once past any colon, we're no longer a simple asm.  */
       simple = false;
 
       if ((!c_parser_next_token_is (parser, CPP_COLON)
-       && !c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
-      || section == 3)
-    switch (section)
-      {
-      case 0:
-        /* For asm goto, we don't allow output operands, but reserve
-           the slot for a future extension that does allow them.  */
-        if (!is_goto)
-          outputs = c_parser_asm_operands (parser, false);
-        break;
-      case 1:
-        inputs = c_parser_asm_operands (parser, true);
-        break;
-      case 2:
-        clobbers = c_parser_asm_clobbers (parser);
-        break;
-      case 3:
-        labels = c_parser_asm_goto_operands (parser);
-        break;
-      default:
-        gcc_unreachable ();
-      }
+	   && !c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
+	  || section == 3)
+	switch (section)
+	  {
+	  case 0:
+	    /* For asm goto, we don't allow output operands, but reserve
+	       the slot for a future extension that does allow them.  */
+	    if (!is_goto)
+	      outputs = c_parser_asm_operands (parser, false);
+	    break;
+	  case 1:
+	    inputs = c_parser_asm_operands (parser, true);
+	    break;
+	  case 2:
+	    clobbers = c_parser_asm_clobbers (parser);
+	    break;
+	  case 3:
+	    labels = c_parser_asm_goto_operands (parser);
+	    break;
+	  default:
+	    gcc_unreachable ();
+	  }
 
       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN) && !is_goto)
-    goto done_asm;
+	goto done_asm;
     }
 
  done_asm:
@@ -5184,7 +5036,7 @@
     c_parser_skip_to_end_of_block_or_statement (parser);
 
   ret = build_asm_stmt (quals, build_asm_expr (asm_loc, str, outputs, inputs,
-                           clobbers, labels, simple));
+					       clobbers, labels, simple));
 
  error:
   parser->lex_untranslated_string = false;
@@ -5218,53 +5070,53 @@
       tree name, str;
       struct c_expr expr;
       if (c_parser_next_token_is (parser, CPP_OPEN_SQUARE))
-    {
-      c_parser_consume_token (parser);
-      if (c_parser_next_token_is (parser, CPP_NAME))
-        {
-          tree id = c_parser_peek_token (parser)->value;
-          c_parser_consume_token (parser);
-          name = build_string (IDENTIFIER_LENGTH (id),
-                   IDENTIFIER_POINTER (id));
-        }
+	{
+	  c_parser_consume_token (parser);
+	  if (c_parser_next_token_is (parser, CPP_NAME))
+	    {
+	      tree id = c_parser_peek_token (parser)->value;
+	      c_parser_consume_token (parser);
+	      name = build_string (IDENTIFIER_LENGTH (id),
+				   IDENTIFIER_POINTER (id));
+	    }
+	  else
+	    {
+	      c_parser_error (parser, "expected identifier");
+	      c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, NULL);
+	      return NULL_TREE;
+	    }
+	  c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
+				     "expected %<]%>");
+	}
       else
-        {
-          c_parser_error (parser, "expected identifier");
-          c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, NULL);
-          return NULL_TREE;
-        }
-      c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
-                     "expected %<]%>");
-    }
-      else
-    name = NULL_TREE;
+	name = NULL_TREE;
       str = c_parser_asm_string_literal (parser);
       if (str == NULL_TREE)
-    return NULL_TREE;
+	return NULL_TREE;
       parser->lex_untranslated_string = false;
       if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
-    {
-      parser->lex_untranslated_string = true;
-      return NULL_TREE;
-    }
+	{
+	  parser->lex_untranslated_string = true;
+	  return NULL_TREE;
+	}
       loc = c_parser_peek_token (parser)->location;
       expr = c_parser_expression (parser);
       mark_exp_read (expr.value);
       if (convert_p)
-    expr = default_function_array_conversion (loc, expr);
+	expr = default_function_array_conversion (loc, expr);
       expr.value = c_fully_fold (expr.value, false, NULL);
       parser->lex_untranslated_string = true;
       if (!c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
-    {
-      c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
-      return NULL_TREE;
-    }
+	{
+	  c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
+	  return NULL_TREE;
+	}
       list = chainon (list, build_tree_list (build_tree_list (name, str),
-                         expr.value));
+					     expr.value));
       if (c_parser_next_token_is (parser, CPP_COMMA))
-    c_parser_consume_token (parser);
+	c_parser_consume_token (parser);
       else
-    break;
+	break;
     }
   return list;
 }
@@ -5284,13 +5136,13 @@
     {
       tree str = c_parser_asm_string_literal (parser);
       if (str)
-    list = tree_cons (NULL_TREE, str, list);
+	list = tree_cons (NULL_TREE, str, list);
       else
-    return NULL_TREE;
+	return NULL_TREE;
       if (c_parser_next_token_is (parser, CPP_COMMA))
-    c_parser_consume_token (parser);
+	c_parser_consume_token (parser);
       else
-    break;
+	break;
     }
   return list;
 }
@@ -5311,26 +5163,26 @@
       tree name, label;
 
       if (c_parser_next_token_is (parser, CPP_NAME))
-    {
-      c_token *tok = c_parser_peek_token (parser);
-      name = tok->value;
-      label = lookup_label_for_goto (tok->location, name);
-      c_parser_consume_token (parser);
-      TREE_USED (label) = 1;
-    }
+	{
+	  c_token *tok = c_parser_peek_token (parser);
+	  name = tok->value;
+	  label = lookup_label_for_goto (tok->location, name);
+	  c_parser_consume_token (parser);
+	  TREE_USED (label) = 1;
+	}
       else
-    {
-      c_parser_error (parser, "expected identifier");
-      return NULL_TREE;
-    }
+	{
+	  c_parser_error (parser, "expected identifier");
+	  return NULL_TREE;
+	}
 
       name = build_string (IDENTIFIER_LENGTH (name),
-               IDENTIFIER_POINTER (name));
+			   IDENTIFIER_POINTER (name));
       list = tree_cons (name, label, list);
       if (c_parser_next_token_is (parser, CPP_COMMA))
-    c_parser_consume_token (parser);
+	c_parser_consume_token (parser);
       else
-    return nreverse (list);
+	return nreverse (list);
     }
 }
 
@@ -5402,8 +5254,8 @@
   rhs = c_parser_expr_no_commas (parser, NULL);
   rhs = default_function_array_read_conversion (exp_location, rhs);
   ret.value = build_modify_expr (op_location, lhs.value, lhs.original_type,
-                 code, exp_location, rhs.value,
-                 rhs.original_type);
+				 code, exp_location, rhs.value,
+				 rhs.original_type);
   if (code == NOP_EXPR)
     ret.original_code = MODIFY_EXPR;
   else
@@ -5447,19 +5299,20 @@
   if (c_parser_next_token_is (parser, CPP_COLON))
     {
       tree eptype = NULL_TREE;
+
       middle_loc = c_parser_peek_token (parser)->location;
       pedwarn (middle_loc, OPT_pedantic, 
 	       "ISO C forbids omitting the middle term of a ?: expression");
       warn_for_omitted_condop (middle_loc, cond.value);
       if (TREE_CODE (cond.value) == EXCESS_PRECISION_EXPR)
-    {
-      eptype = TREE_TYPE (cond.value);
-      cond.value = TREE_OPERAND (cond.value, 0);
-    }
+	{
+	  eptype = TREE_TYPE (cond.value);
+	  cond.value = TREE_OPERAND (cond.value, 0);
+	}
       /* Make sure first operand is calculated only once.  */
       exp1.value = c_save_expr (default_conversion (cond.value));
       if (eptype)
-    exp1.value = build1 (EXCESS_PRECISION_EXPR, eptype, exp1.value);
+	exp1.value = build1 (EXCESS_PRECISION_EXPR, eptype, exp1.value);
       exp1.original_type = NULL;
       cond.value = c_objc_common_truthvalue_conversion (cond_loc, exp1.value);
       c_inhibit_evaluation_warnings += cond.value == truthvalue_true_node;
@@ -5467,14 +5320,14 @@
   else
     {
       cond.value
-    = c_objc_common_truthvalue_conversion
-    (cond_loc, default_conversion (cond.value));
+	= c_objc_common_truthvalue_conversion
+	(cond_loc, default_conversion (cond.value));
       c_inhibit_evaluation_warnings += cond.value == truthvalue_false_node;
       exp1 = c_parser_expression_conv (parser);
       mark_exp_read (exp1.value);
       c_inhibit_evaluation_warnings +=
-    ((cond.value == truthvalue_true_node)
-     - (cond.value == truthvalue_false_node));
+	((cond.value == truthvalue_true_node)
+	 - (cond.value == truthvalue_false_node));
     }
 
   colon_loc = c_parser_peek_token (parser)->location;
@@ -5493,9 +5346,9 @@
   }
   c_inhibit_evaluation_warnings -= cond.value == truthvalue_true_node;
   ret.value = build_conditional_expr (colon_loc, cond.value,
-                      cond.original_code == C_MAYBE_CONST_EXPR,
-                      exp1.value, exp1.original_type,
-                      exp2.value, exp2.original_type);
+				      cond.original_code == C_MAYBE_CONST_EXPR,
+				      exp1.value, exp1.original_type,
+				      exp2.value, exp2.original_type);
   ret.original_code = ERROR_MARK;
   if (exp1.value == error_mark_node || exp2.value == error_mark_node)
     ret.original_type = NULL;
@@ -5504,16 +5357,16 @@
       tree t1, t2;
 
       /* If both sides are enum type, the default conversion will have
-     made the type of the result be an integer type.  We want to
-     remember the enum types we started with.  */
+	 made the type of the result be an integer type.  We want to
+	 remember the enum types we started with.  */
       t1 = exp1.original_type ? exp1.original_type : TREE_TYPE (exp1.value);
       t2 = exp2.original_type ? exp2.original_type : TREE_TYPE (exp2.value);
       ret.original_type = ((t1 != error_mark_node
-                && t2 != error_mark_node
-                && (TYPE_MAIN_VARIANT (t1)
-                == TYPE_MAIN_VARIANT (t2)))
-               ? t1
-               : NULL);
+			    && t2 != error_mark_node
+			    && (TYPE_MAIN_VARIANT (t1)
+				== TYPE_MAIN_VARIANT (t2)))
+			   ? t1
+			   : NULL);
     }
   return ret;
 }
@@ -5663,90 +5516,90 @@
       enum prec oprec;
       enum tree_code ocode;
       if (parser->error)
-    goto out;
+	goto out;
       switch (c_parser_peek_token (parser)->type)
-    {
-    case CPP_MULT:
-      oprec = PREC_MULT;
-      ocode = MULT_EXPR;
-      break;
-    case CPP_DIV:
-      oprec = PREC_MULT;
-      ocode = TRUNC_DIV_EXPR;
-      break;
-    case CPP_MOD:
-      oprec = PREC_MULT;
-      ocode = TRUNC_MOD_EXPR;
-      break;
-    case CPP_PLUS:
-      oprec = PREC_ADD;
-      ocode = PLUS_EXPR;
-      break;
-    case CPP_MINUS:
-      oprec = PREC_ADD;
-      ocode = MINUS_EXPR;
-      break;
-    case CPP_LSHIFT:
-      oprec = PREC_SHIFT;
-      ocode = LSHIFT_EXPR;
-      break;
-    case CPP_RSHIFT:
-      oprec = PREC_SHIFT;
-      ocode = RSHIFT_EXPR;
-      break;
-    case CPP_LESS:
-      oprec = PREC_REL;
-      ocode = LT_EXPR;
-      break;
-    case CPP_GREATER:
-      oprec = PREC_REL;
-      ocode = GT_EXPR;
-      break;
-    case CPP_LESS_EQ:
-      oprec = PREC_REL;
-      ocode = LE_EXPR;
-      break;
-    case CPP_GREATER_EQ:
-      oprec = PREC_REL;
-      ocode = GE_EXPR;
-      break;
-    case CPP_EQ_EQ:
-      oprec = PREC_EQ;
-      ocode = EQ_EXPR;
-      break;
-    case CPP_NOT_EQ:
-      oprec = PREC_EQ;
-      ocode = NE_EXPR;
-      break;
-    case CPP_AND:
-      oprec = PREC_BITAND;
-      ocode = BIT_AND_EXPR;
-      break;
-    case CPP_XOR:
-      oprec = PREC_BITXOR;
-      ocode = BIT_XOR_EXPR;
-      break;
-    case CPP_OR:
-      oprec = PREC_BITOR;
-      ocode = BIT_IOR_EXPR;
-      break;
-    case CPP_AND_AND:
-      oprec = PREC_LOGAND;
-      ocode = TRUTH_ANDIF_EXPR;
-      break;
-    case CPP_OR_OR:
-      oprec = PREC_LOGOR;
-      ocode = TRUTH_ORIF_EXPR;
-      break;
-    default:
-      /* Not a binary operator, so end of the binary
-         expression.  */
-      goto out;
-    }
+	{
+	case CPP_MULT:
+	  oprec = PREC_MULT;
+	  ocode = MULT_EXPR;
+	  break;
+	case CPP_DIV:
+	  oprec = PREC_MULT;
+	  ocode = TRUNC_DIV_EXPR;
+	  break;
+	case CPP_MOD:
+	  oprec = PREC_MULT;
+	  ocode = TRUNC_MOD_EXPR;
+	  break;
+	case CPP_PLUS:
+	  oprec = PREC_ADD;
+	  ocode = PLUS_EXPR;
+	  break;
+	case CPP_MINUS:
+	  oprec = PREC_ADD;
+	  ocode = MINUS_EXPR;
+	  break;
+	case CPP_LSHIFT:
+	  oprec = PREC_SHIFT;
+	  ocode = LSHIFT_EXPR;
+	  break;
+	case CPP_RSHIFT:
+	  oprec = PREC_SHIFT;
+	  ocode = RSHIFT_EXPR;
+	  break;
+	case CPP_LESS:
+	  oprec = PREC_REL;
+	  ocode = LT_EXPR;
+	  break;
+	case CPP_GREATER:
+	  oprec = PREC_REL;
+	  ocode = GT_EXPR;
+	  break;
+	case CPP_LESS_EQ:
+	  oprec = PREC_REL;
+	  ocode = LE_EXPR;
+	  break;
+	case CPP_GREATER_EQ:
+	  oprec = PREC_REL;
+	  ocode = GE_EXPR;
+	  break;
+	case CPP_EQ_EQ:
+	  oprec = PREC_EQ;
+	  ocode = EQ_EXPR;
+	  break;
+	case CPP_NOT_EQ:
+	  oprec = PREC_EQ;
+	  ocode = NE_EXPR;
+	  break;
+	case CPP_AND:
+	  oprec = PREC_BITAND;
+	  ocode = BIT_AND_EXPR;
+	  break;
+	case CPP_XOR:
+	  oprec = PREC_BITXOR;
+	  ocode = BIT_XOR_EXPR;
+	  break;
+	case CPP_OR:
+	  oprec = PREC_BITOR;
+	  ocode = BIT_IOR_EXPR;
+	  break;
+	case CPP_AND_AND:
+	  oprec = PREC_LOGAND;
+	  ocode = TRUTH_ANDIF_EXPR;
+	  break;
+	case CPP_OR_OR:
+	  oprec = PREC_LOGOR;
+	  ocode = TRUTH_ORIF_EXPR;
+	  break;
+	default:
+	  /* Not a binary operator, so end of the binary
+	     expression.  */
+	  goto out;
+	}
       binary_loc = c_parser_peek_token (parser)->location;
       c_parser_consume_token (parser);
       while (oprec <= stack[sp].prec)
-    POP;
+	POP;
       switch (ocode)
 	{
 	case TRUTH_ANDIF_EXPR:
@@ -5800,7 +5653,7 @@
   gcc_assert (!after || c_dialect_objc ());
   if (after)
     return c_parser_postfix_expression_after_primary (parser,
-                              cast_loc, *after);
+						      cast_loc, *after);
   /* If the expression begins with a parenthesized type name, it may
      be either a cast or a compound literal; we need to see whether
      the next character is '{' to tell the difference.  If not, it is
@@ -5816,19 +5669,19 @@
       type_name = c_parser_type_name (parser);
       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
       if (type_name == NULL)
-    {
-      ret.value = error_mark_node;
-      ret.original_code = ERROR_MARK;
-      ret.original_type = NULL;
-      return ret;
-    }
+	{
+	  ret.value = error_mark_node;
+	  ret.original_code = ERROR_MARK;
+	  ret.original_type = NULL;
+	  return ret;
+	}
 
       /* Save casted types in the function's used types hash table.  */
       used_types_insert (type_name->specs->type);
 
       if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
-    return c_parser_postfix_expression_after_paren_type (parser, type_name,
-                                 cast_loc);
+	return c_parser_postfix_expression_after_paren_type (parser, type_name,
+							     cast_loc);
       {
 	location_t expr_loc = c_parser_peek_token (parser)->location;
 	expr = c_parser_cast_expression (parser, NULL);
@@ -5907,9 +5760,9 @@
       return ret;
     case CPP_PLUS:
       if (!c_dialect_objc () && !in_system_header)
-    warning_at (op_loc,
-            OPT_Wtraditional,
-            "traditional C rejects the unary plus operator");
+	warning_at (op_loc,
+		    OPT_Wtraditional,
+		    "traditional C rejects the unary plus operator");
       c_parser_consume_token (parser);
       exp_loc = c_parser_peek_token (parser)->location;
       op = c_parser_cast_expression (parser, NULL);
@@ -5937,45 +5790,45 @@
       /* Refer to the address of a label as a pointer.  */
       c_parser_consume_token (parser);
       if (c_parser_next_token_is (parser, CPP_NAME))
-    {
-      ret.value = finish_label_address_expr
-        (c_parser_peek_token (parser)->value, op_loc);
-      c_parser_consume_token (parser);
-    }
+	{
+	  ret.value = finish_label_address_expr
+	    (c_parser_peek_token (parser)->value, op_loc);
+	  c_parser_consume_token (parser);
+	}
       else
-    {
-      c_parser_error (parser, "expected identifier");
-      ret.value = error_mark_node;
-    }
-    return ret;
+	{
+	  c_parser_error (parser, "expected identifier");
+	  ret.value = error_mark_node;
+	}
+	return ret;
     case CPP_KEYWORD:
       switch (c_parser_peek_token (parser)->keyword)
-    {
-    case RID_SIZEOF:
-      return c_parser_sizeof_expression (parser);
-    case RID_ALIGNOF:
-      return c_parser_alignof_expression (parser);
-    case RID_EXTENSION:
-      c_parser_consume_token (parser);
-      ext = disable_extension_diagnostics ();
-      ret = c_parser_cast_expression (parser, NULL);
-      restore_extension_diagnostics (ext);
-      return ret;
-    case RID_REALPART:
-      c_parser_consume_token (parser);
-      exp_loc = c_parser_peek_token (parser)->location;
-      op = c_parser_cast_expression (parser, NULL);
-      op = default_function_array_conversion (exp_loc, op);
-      return parser_build_unary_op (op_loc, REALPART_EXPR, op);
-    case RID_IMAGPART:
-      c_parser_consume_token (parser);
-      exp_loc = c_parser_peek_token (parser)->location;
-      op = c_parser_cast_expression (parser, NULL);
-      op = default_function_array_conversion (exp_loc, op);
-      return parser_build_unary_op (op_loc, IMAGPART_EXPR, op);
-    default:
-      return c_parser_postfix_expression (parser);
-    }
+	{
+	case RID_SIZEOF:
+	  return c_parser_sizeof_expression (parser);
+	case RID_ALIGNOF:
+	  return c_parser_alignof_expression (parser);
+	case RID_EXTENSION:
+	  c_parser_consume_token (parser);
+	  ext = disable_extension_diagnostics ();
+	  ret = c_parser_cast_expression (parser, NULL);
+	  restore_extension_diagnostics (ext);
+	  return ret;
+	case RID_REALPART:
+	  c_parser_consume_token (parser);
+	  exp_loc = c_parser_peek_token (parser)->location;
+	  op = c_parser_cast_expression (parser, NULL);
+	  op = default_function_array_conversion (exp_loc, op);
+	  return parser_build_unary_op (op_loc, REALPART_EXPR, op);
+	case RID_IMAGPART:
+	  c_parser_consume_token (parser);
+	  exp_loc = c_parser_peek_token (parser)->location;
+	  op = c_parser_cast_expression (parser, NULL);
+	  op = default_function_array_conversion (exp_loc, op);
+	  return parser_build_unary_op (op_loc, IMAGPART_EXPR, op);
+	default:
+	  return c_parser_postfix_expression (parser);
+	}
     default:
       return c_parser_postfix_expression (parser);
     }
@@ -5996,29 +5849,29 @@
       && c_token_starts_typename (c_parser_peek_2nd_token (parser)))
     {
       /* Either sizeof ( type-name ) or sizeof unary-expression
-     starting with a compound literal.  */
+	 starting with a compound literal.  */
       struct c_type_name *type_name;
       c_parser_consume_token (parser);
       expr_loc = c_parser_peek_token (parser)->location;
       type_name = c_parser_type_name (parser);
       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
       if (type_name == NULL)
-    {
-      struct c_expr ret;
-      c_inhibit_evaluation_warnings--;
-      in_sizeof--;
-      ret.value = error_mark_node;
-      ret.original_code = ERROR_MARK;
-      ret.original_type = NULL;
-      return ret;
-    }
+	{
+	  struct c_expr ret;
+	  c_inhibit_evaluation_warnings--;
+	  in_sizeof--;
+	  ret.value = error_mark_node;
+	  ret.original_code = ERROR_MARK;
+	  ret.original_type = NULL;
+	  return ret;
+	}
       if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
-    {
-      expr = c_parser_postfix_expression_after_paren_type (parser,
-                                   type_name,
-                                   expr_loc);
-      goto sizeof_expr;
-    }
+	{
+	  expr = c_parser_postfix_expression_after_paren_type (parser,
+							       type_name,
+							       expr_loc);
+	  goto sizeof_expr;
+	}
       /* sizeof ( type-name ).  */
       c_inhibit_evaluation_warnings--;
       in_sizeof--;
@@ -6033,8 +5886,8 @@
       in_sizeof--;
       mark_exp_read (expr.value);
       if (TREE_CODE (expr.value) == COMPONENT_REF
-      && DECL_C_BIT_FIELD (TREE_OPERAND (expr.value, 1)))
-    error_at (expr_loc, "%<sizeof%> applied to a bit-field");
+	  && DECL_C_BIT_FIELD (TREE_OPERAND (expr.value, 1)))
+	error_at (expr_loc, "%<sizeof%> applied to a bit-field");
       return c_expr_sizeof_expr (expr_loc, expr);
     }
 }
@@ -6054,7 +5907,7 @@
       && c_token_starts_typename (c_parser_peek_2nd_token (parser)))
     {
       /* Either __alignof__ ( type-name ) or __alignof__
-     unary-expression starting with a compound literal.  */
+	 unary-expression starting with a compound literal.  */
       location_t loc;
       struct c_type_name *type_name;
       struct c_expr ret;
@@ -6063,22 +5916,22 @@
       type_name = c_parser_type_name (parser);
       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
       if (type_name == NULL)
-    {
-      struct c_expr ret;
-      c_inhibit_evaluation_warnings--;
-      in_alignof--;
-      ret.value = error_mark_node;
-      ret.original_code = ERROR_MARK;
-      ret.original_type = NULL;
-      return ret;
-    }
+	{
+	  struct c_expr ret;
+	  c_inhibit_evaluation_warnings--;
+	  in_alignof--;
+	  ret.value = error_mark_node;
+	  ret.original_code = ERROR_MARK;
+	  ret.original_type = NULL;
+	  return ret;
+	}
       if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
-    {
-      expr = c_parser_postfix_expression_after_paren_type (parser,
-                                   type_name,
-                                   loc);
-      goto alignof_expr;
-    }
+	{
+	  expr = c_parser_postfix_expression_after_paren_type (parser,
+							       type_name,
+							       loc);
+	  goto alignof_expr;
+	}
       /* alignof ( type-name ).  */
       c_inhibit_evaluation_warnings--;
       in_alignof--;
@@ -6136,8 +5989,8 @@
      __builtin_va_arg ( assignment-expression , type-name )
      __builtin_offsetof ( type-name , offsetof-member-designator )
      __builtin_choose_expr ( assignment-expression ,
-                 assignment-expression ,
-                 assignment-expression )
+			     assignment-expression ,
+			     assignment-expression )
      __builtin_types_compatible_p ( type-name , type-name )
 
    offsetof-member-designator:
@@ -6156,127 +6009,11 @@
      Classname . identifier
 */
 
-static void
-cbc_finish_labeled_goto (location_t loc, tree label, tree retval)
-{
-  /* add statement below.
-   *
-   * if (0) {
-   *   _cbc_exit0:
-   *   return retval;
-   * }
-   */
-  tree tlab;
-  tree cond;
-
-  tree cstmt = c_begin_compound_stmt (true);
-
-  tlab = define_label (loc, label);
-  gcc_assert (tlab);
-  decl_attributes (&tlab, NULL_TREE, 0);
-  add_stmt (build_stmt (loc, LABEL_EXPR, tlab));
-
-  tree ret = c_finish_return (loc, retval, retval); /*tree ret = c_finish_return (retval);*/
-  TREE_USED(ret) = 1;
-
-  cond = integer_zero_node;
-  tree if_body = c_end_compound_stmt (loc, cstmt, true);
-  TREE_SIDE_EFFECTS (cstmt) = 1;
-  c_finish_if_stmt (loc, cond, if_body, NULL_TREE, false);
-}
-
-static tree
-cbc_finish_nested_function (location_t loc, tree label, tree retval_decl)
-{
-
-  /* add statement below.
-   * void __return_func(int _retval, void *_envp){
-   *   retval = _retval;
-   *   goto exit0;
-   * }
-   */
-  /* TODO:
-   * retval(lhs)のTREE_DECLを引数から取得するように
-   * int _retvalパラメータのタイプはretvalに合わせる
-   */
-
-  tree fnbody;
-  tree _retval_decl, _envp_decl;
-  struct c_declarator *declarator;
-  //tree ident;
-  struct c_arg_info *args;
-  struct c_declspecs *specs;
-  struct c_typespec t;
-  {
-    push_scope ();
-    declare_parm_level ();
-    /*tree retval_type = TREE_TYPE(retval_decl);*/
-
-    _retval_decl = build_decl (loc, PARM_DECL, get_identifier ("_retval"), TREE_TYPE(retval_decl));
-    DECL_SOURCE_LOCATION (_retval_decl) = loc;
-    DECL_ARTIFICIAL (_retval_decl) = 1;
-    DECL_ARG_TYPE (_retval_decl) = TREE_TYPE(retval_decl);
-    pushdecl (_retval_decl);
-    finish_decl (_retval_decl, loc, NULL_TREE, NULL_TREE, NULL_TREE);
-
-    _envp_decl = build_decl (loc, PARM_DECL, get_identifier ("_envp"), ptr_type_node);
-    DECL_SOURCE_LOCATION (_envp_decl) = loc;
-    DECL_ARTIFICIAL (_envp_decl) = 1;
-    DECL_ARG_TYPE (_envp_decl) = ptr_type_node;
-    pushdecl (_envp_decl);
-    finish_decl (_envp_decl, loc, NULL_TREE, NULL_TREE, NULL_TREE);
-
-    args = get_parm_info(false);
-    pop_scope();
-  }
-
-  t.kind = ctsk_resword;
-  t.spec = get_identifier("void");
-  specs = build_null_declspecs();
-  declspecs_add_type (loc, specs, t);
-  finish_declspecs (specs);
-
-  /* make nested function.  */
-  declarator = build_id_declarator (get_identifier ("_cbc_internal_return"));
-  declarator = build_function_declarator (args, declarator);
-
-  c_push_function_context ();
-
-  if (!start_function (specs, declarator, NULL_TREE))
-    {
-      c_pop_function_context();
-      gcc_assert (0);
-    }
-  store_parm_decls ();
-
-
-  /* start compound statement.  */
-  tree cstmt = c_begin_compound_stmt (true);
-
-  add_stmt (build_modify_expr (loc, retval_decl, NULL_TREE, NOP_EXPR, loc, _retval_decl, NULL_TREE));
-  //tree stmt = c_finish_goto_label (loc, label);
-
-  /* end compound statement.  */
-  fnbody = c_end_compound_stmt (loc, cstmt, true);
-  TREE_SIDE_EFFECTS (cstmt) = 1;
-
-  /* finish declaration of nested function.  */
-  tree decl = current_function_decl;
-  add_stmt (fnbody);
-  finish_function ();
-  c_pop_function_context ();
-
-  add_stmt (build_stmt (loc, DECL_EXPR, decl));
-  return decl;
-
-}
-
 static struct c_expr
 c_parser_postfix_expression (c_parser *parser)
 {
   struct c_expr expr, e1, e2, e3;
   struct c_type_name *t1, *t2;
-  //cbc? static tree return_label1;
   location_t loc = c_parser_peek_token (parser)->location;;
   expr.original_code = ERROR_MARK;
   expr.original_type = NULL;
@@ -6287,11 +6024,11 @@
       loc = c_parser_peek_token (parser)->location;
       c_parser_consume_token (parser);
       if (TREE_CODE (expr.value) == FIXED_CST
-      && !targetm.fixed_point_supported_p ())
-    {
-      error_at (loc, "fixed-point types not supported for this target");
-      expr.value = error_mark_node;
-    }
+	  && !targetm.fixed_point_supported_p ())
+	{
+	  error_at (loc, "fixed-point types not supported for this target");
+	  expr.value = error_mark_node;
+	}
       break;
     case CPP_CHAR:
     case CPP_CHAR16:
@@ -6312,7 +6049,7 @@
     case CPP_OBJC_STRING:
       gcc_assert (c_dialect_objc ());
       expr.value
-    = objc_build_string_object (c_parser_peek_token (parser)->value);
+	= objc_build_string_object (c_parser_peek_token (parser)->value);
       c_parser_consume_token (parser);
       break;
     case CPP_NAME:
@@ -6361,7 +6098,7 @@
       break;
     case CPP_OPEN_PAREN:
       /* A parenthesized expression, statement expression or compound
-     literal.  */
+	 literal.  */
       if (c_parser_peek_2nd_token (parser)->type == CPP_OPEN_BRACE)
 	{
 	  /* A statement expression.  */
@@ -6390,40 +6127,40 @@
 	  mark_exp_read (expr.value);
 	}
       else if (c_token_starts_typename (c_parser_peek_2nd_token (parser)))
-    {
-      /* A compound literal.  ??? Can we actually get here rather
-         than going directly to
-         c_parser_postfix_expression_after_paren_type from
-         elsewhere?  */
-      location_t loc;
-      struct c_type_name *type_name;
-      c_parser_consume_token (parser);
-      loc = c_parser_peek_token (parser)->location;
-      type_name = c_parser_type_name (parser);
-      c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
-                     "expected %<)%>");
-      if (type_name == NULL)
-        {
-          expr.value = error_mark_node;
-        }
+	{
+	  /* A compound literal.  ??? Can we actually get here rather
+	     than going directly to
+	     c_parser_postfix_expression_after_paren_type from
+	     elsewhere?  */
+	  location_t loc;
+	  struct c_type_name *type_name;
+	  c_parser_consume_token (parser);
+	  loc = c_parser_peek_token (parser)->location;
+	  type_name = c_parser_type_name (parser);
+	  c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
+				     "expected %<)%>");
+	  if (type_name == NULL)
+	    {
+	      expr.value = error_mark_node;
+	    }
+	  else
+	    expr = c_parser_postfix_expression_after_paren_type (parser,
+								 type_name,
+								 loc);
+	}
       else
-        expr = c_parser_postfix_expression_after_paren_type (parser,
-                                 type_name,
-                                 loc);
-    }
-      else
-    {
-      /* A parenthesized expression.  */
-      c_parser_consume_token (parser);
-      expr = c_parser_expression (parser);
-      if (TREE_CODE (expr.value) == MODIFY_EXPR)
-        TREE_NO_WARNING (expr.value) = 1;
-      if (expr.original_code != C_MAYBE_CONST_EXPR)
-        expr.original_code = ERROR_MARK;
-      /* Don't change EXPR.ORIGINAL_TYPE.  */
-      c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
-                     "expected %<)%>");
-    }
+	{
+	  /* A parenthesized expression.  */
+	  c_parser_consume_token (parser);
+	  expr = c_parser_expression (parser);
+	  if (TREE_CODE (expr.value) == MODIFY_EXPR)
+	    TREE_NO_WARNING (expr.value) = 1;
+	  if (expr.original_code != C_MAYBE_CONST_EXPR)
+	    expr.original_code = ERROR_MARK;
+	  /* Don't change EXPR.ORIGINAL_TYPE.  */
+	  c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
+				     "expected %<)%>");
+	}
       break;
     case CPP_KEYWORD:
       switch (c_parser_peek_token (parser)->keyword)
@@ -6587,6 +6324,7 @@
 				     "expected %<)%>");
 	  {
 	    tree c;
+
 	    c = e1.value;
 	    mark_exp_read (e2.value);
 	    mark_exp_read (e3.value);
@@ -6628,8 +6366,10 @@
 				     "expected %<)%>");
 	  {
 	    tree e1, e2;
+
 	    e1 = TYPE_MAIN_VARIANT (groktypename (t1, NULL, NULL));
 	    e2 = TYPE_MAIN_VARIANT (groktypename (t2, NULL, NULL));
+
 	    expr.value
 	      = comptypes (e1, e2) ? integer_one_node : integer_zero_node;
 	  }
@@ -6695,190 +6435,6 @@
 	    expr.value = objc_build_encode_expr (type);
 	  }
 	  break;
-
-#ifndef noCbC
-    case RID_CbC_ENV:
-          {
-        c_parser_consume_token (parser);
-        /* get value of %ebp.  */
-        /*tree env_tree = build_external_ref (
-                get_identifier ("__builtin_frame_address"), 0,
-                c_parser_peek_token (parser)->location);*/
-        loc = c_parser_peek_token (parser)->location;
-        tree env_tree = build_external_ref (loc,
-            get_identifier ("__builtin_frame_address"), 0, &expr.original_type);
-        expr.value = build_function_call(loc, env_tree,
-               build_tree_list (NULL_TREE, build_int_cst (NULL_TREE,0)));
-        expr.original_code = ERROR_MARK;
-          }
-      break;
-    case RID_CbC_RET:
-    case RID_RETURN:
-
-#if 0
-      if (cbc_return_f==0)
-        {  tree retval;
-
-              /*
-                   Generates something like...
-
-    int retval = 1;
-    void (*ret)(int retval_,void *fp) ;
-
-    ret = ({
-        __label__ exit0;
-        volatile static flag = 0;
-        void __return_func(int retval_,void *fp) {
-            retval = retval_;
-            goto exit0;
-        }
-        if (flag) {
-        exit0:
-            printf("f1: fp = 0x%x\n",__builtin_frame_address(0));
-            return retval;
-        }
-        __return_func;
-    });
-
-               */
-
-          tree stmt = c_begin_stmt_expr ();
-              cbc_return_f = c_parser_peek_token (parser)->value;
-              cbc_return = c_parser_peek_token (parser)->location;
-          c_parser_consume_token (parser);
-              location_t next = c_parser_peek_token (parser)->location;
-
-              // dummy variable for hidden condition
-          struct c_expr cexpr;
-          tree cond;
-          location_t loc;
-          loc = next;
-              tree decl_cond =
-            build_decl (VAR_DECL, get_identifier ("__return"),
-            intHI_type_node);
-              TREE_STATIC (decl_cond) = 1;
-          cexpr.value = lang_hooks.decls.pushdecl(decl_cond);
-
-          cexpr.original_code = ERROR_MARK;
-          cond = c_objc_common_truthvalue_conversion(loc, cexpr.value);
-          if (EXPR_P (cond))
-        SET_EXPR_LOCATION (cond, loc);
-
-
-
-
-          tree fwlabel = create_artificial_label ();
-          //TREE_USED(fwlabel) = 1;
-
-          //add_stmt (build1 (GOTO_EXPR, void_type_node, fwlabel));
-          tree block = c_begin_compound_stmt (flag_isoc99);
-
-          tree tlab = lookup_label(cbc_return_f);
-
-          tree decl= build_stmt (LABEL_EXPR, tlab);
-          //TREE_USED(decl) = 1;
-          add_stmt(decl);
-
-          //tree hoge = build_int_cst(NULL_TREE,55);
-        retval = build_component_ref (cbc_env, get_identifier("retval"));
-          tree ret = c_finish_return (retval);
-          TREE_USED(ret) = 1;
-          tree first_body = c_end_compound_stmt (block, flag_isoc99);
-
-              c_finish_if_stmt (loc, cond, first_body, NULL_TREE, false);
-
-          // define_label(EXPR_LOCATION(decl) ,cbc_return_f);
-          return_label1 =
-           define_label(cbc_return ,cbc_return_f);
-          tree fwdef= build_stmt (LABEL_EXPR, fwlabel);
-
-          //TREE_USED(fwdef) = 1;
-          add_stmt(fwdef);
-          TREE_SIDE_EFFECTS (block) = 1;
-
-          // tree label = lookup_label(c_parser_peek_token (parser)->value);
-          //TREE_USED(label) = 1;
-
-          tree value = build1(ADDR_EXPR, ptr_type_node, return_label1);
-              SET_EXPR_LOCATION (value, next);
-          TREE_SIDE_EFFECTS (value) = 1;
-          add_stmt(value);
-
-          TREE_SIDE_EFFECTS (stmt) = 1;
-          expr.value = c_finish_stmt_expr (stmt);
-          expr.original_code = ERROR_MARK;
-
-
-        }
-      else
-        {
-          //tree label = lookup_label(c_parser_peek_token (parser)->value);
-          //TREE_USED(label) = 1;
-          //expr.value = build1(ADDR_EXPR, ptr_type_node, label);
-          expr.value = build1(ADDR_EXPR, ptr_type_node, return_label1);
-          c_parser_consume_token (parser);
-            }
-#else //by KENT.
-      {
-        /*
-        ({
-            __label__ _cbc_exit0;
-            void __return_func(int retval_, void *_envp){
-            retval = retval_;
-            goto exit0;
-            }
-            if (0) {
-              _cbc_exit0:
-            return retval;
-            }
-            __return_func;
-        });
-         */
-        tree value, stmt, label, tlab, decl;
-        c_parser_consume_token (parser);
-
-        stmt = c_begin_stmt_expr ();
-        cbc_return_f = c_parser_peek_token (parser)->value;
-        location_t location = c_parser_peek_token (parser)->location;
-
-        /* create label. (__label__ _cbc_exit0;) */
-        label = get_identifier ("_cbc_exit0");
-        tlab = declare_label (label);
-        C_DECLARED_LABEL_FLAG (tlab) = 1;
-        add_stmt (build_stmt (location, DECL_EXPR, tlab));
-
-        /* declare retval.  (int retval;) */
-        tree decl_cond =
-          build_decl (location, VAR_DECL, get_identifier ("retval"),
-          TREE_TYPE (TREE_TYPE (current_function_decl)));
-        TREE_STATIC (decl_cond) = 1;
-        DECL_ARTIFICIAL (decl_cond) = 1;
-        pushdecl (decl_cond);
-
-        /* define nested function.  */
-        decl =
-          cbc_finish_nested_function (location, label, decl_cond);
-
-        /* define if-ed goto label and return statement. */
-        cbc_finish_labeled_goto (location, label, decl_cond);
-
-        /* get pointer to nested function.  */
-        value = build_addr (decl , current_function_decl);
-        SET_EXPR_LOCATION (value, location);
-        add_stmt (value);
-        /*value = build_external_ref (get_identifier("_cbc_internal_return"), false, location);*/
-        /*value = build_unary_op (location, ADDR_EXPR, value, 0);*/
-        /*add_stmt (value);*/
-
-        TREE_SIDE_EFFECTS (stmt) = 1;
-        expr.value = c_finish_stmt_expr (location, stmt);
-        expr.original_code = ERROR_MARK;
-      }
-
-#endif //0
-      break;
-#endif  //noCbC
-
 	default:
 	  c_parser_error (parser, "expected expression");
 	  expr.value = error_mark_node;
@@ -6887,17 +6443,17 @@
       break;
     case CPP_OPEN_SQUARE:
       if (c_dialect_objc ())
-    {
-      tree receiver, args;
-      c_parser_consume_token (parser);
-      receiver = c_parser_objc_receiver (parser);
-      args = c_parser_objc_message_args (parser);
-      c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
-                     "expected %<]%>");
-      expr.value = objc_build_message_expr (build_tree_list (receiver,
-                                 args));
-      break;
-    }
+	{
+	  tree receiver, args;
+	  c_parser_consume_token (parser);
+	  receiver = c_parser_objc_receiver (parser);
+	  args = c_parser_objc_message_args (parser);
+	  c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
+				     "expected %<]%>");
+	  expr.value = objc_build_message_expr (build_tree_list (receiver,
+								 args));
+	  break;
+	}
       /* Else fall through to report error.  */
     default:
       c_parser_error (parser, "expected expression");
@@ -6919,8 +6475,8 @@
 
 static struct c_expr
 c_parser_postfix_expression_after_paren_type (c_parser *parser,
-                          struct c_type_name *type_name,
-                          location_t type_loc)
+					      struct c_type_name *type_name,
+					      location_t type_loc)
 {
   tree type;
   struct c_expr init;
@@ -6953,8 +6509,8 @@
   if (!flag_isoc99)
     pedwarn (start_loc, OPT_pedantic, "ISO C90 forbids compound literals");
   non_const = ((init.value && TREE_CODE (init.value) == CONSTRUCTOR)
-           ? CONSTRUCTOR_NON_CONST (init.value)
-           : init.original_code == C_MAYBE_CONST_EXPR);
+	       ? CONSTRUCTOR_NON_CONST (init.value)
+	       : init.original_code == C_MAYBE_CONST_EXPR);
   non_const |= !type_expr_const;
   expr.value = build_compound_literal (start_loc, type, init.value, non_const);
   expr.original_code = ERROR_MARK;
@@ -6962,16 +6518,16 @@
   if (type_expr)
     {
       if (TREE_CODE (expr.value) == C_MAYBE_CONST_EXPR)
-    {
-      gcc_assert (C_MAYBE_CONST_EXPR_PRE (expr.value) == NULL_TREE);
-      C_MAYBE_CONST_EXPR_PRE (expr.value) = type_expr;
-    }
+	{
+	  gcc_assert (C_MAYBE_CONST_EXPR_PRE (expr.value) == NULL_TREE);
+	  C_MAYBE_CONST_EXPR_PRE (expr.value) = type_expr;
+	}
       else
-    {
-      gcc_assert (!non_const);
-      expr.value = build2 (C_MAYBE_CONST_EXPR, type,
-                   type_expr, expr.value);
-    }
+	{
+	  gcc_assert (!non_const);
+	  expr.value = build2 (C_MAYBE_CONST_EXPR, type,
+			       type_expr, expr.value);
+	}
     }
   return c_parser_postfix_expression_after_primary (parser, start_loc, expr);
 }
@@ -6983,8 +6539,8 @@
 
 static struct c_expr
 c_parser_postfix_expression_after_primary (c_parser *parser,
-                       location_t expr_loc,
-                       struct c_expr expr)
+					   location_t expr_loc,
+					   struct c_expr expr)
 {
   struct c_expr orig_expr;
   tree ident, idx;
@@ -7176,7 +6732,7 @@
 
 static VEC(tree,gc) *
 c_parser_expr_list (c_parser *parser, bool convert_p, bool fold_p,
-            VEC(tree,gc) **p_orig_types)
+		    VEC(tree,gc) **p_orig_types)
 {
   VEC(tree,gc) *ret;
   VEC(tree,gc) *orig_types;
@@ -7205,10 +6761,10 @@
       if (convert_p)
 	expr = default_function_array_read_conversion (loc, expr);
       if (fold_p)
-    expr.value = c_fully_fold (expr.value, false, NULL);
+	expr.value = c_fully_fold (expr.value, false, NULL);
       VEC_safe_push (tree, gc, ret, expr.value);
       if (orig_types != NULL)
-    VEC_safe_push (tree, gc, orig_types, expr.original_type);
+	VEC_safe_push (tree, gc, orig_types, expr.original_type);
     }
   if (orig_types != NULL)
     *p_orig_types = orig_types;
@@ -7287,10 +6843,10 @@
 	}
       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
       if (!iface_p)
-    {
-      objc_start_category_implementation (id1, id2);
-      return;
-    }
+	{
+	  objc_start_category_implementation (id1, id2);
+	  return;
+	}
       if (c_parser_next_token_is (parser, CPP_LESS))
 	proto = c_parser_objc_protocol_refs (parser);
       objc_start_category_interface (id1, id2, proto, attributes);
@@ -7303,10 +6859,10 @@
     {
       c_parser_consume_token (parser);
       if (c_parser_next_token_is_not (parser, CPP_NAME))
-    {
-      c_parser_error (parser, "expected identifier");
-      return;
-    }
+	{
+	  c_parser_error (parser, "expected identifier");
+	  return;
+	}
       superclass = c_parser_peek_token (parser)->value;
       c_parser_consume_token (parser);
     }
@@ -7369,18 +6925,18 @@
       tree decls;
       /* Parse any stray semicolon.  */
       if (c_parser_next_token_is (parser, CPP_SEMICOLON))
-    {
-      pedwarn (c_parser_peek_token (parser)->location, OPT_pedantic,
-           "extra semicolon in struct or union specified");
-      c_parser_consume_token (parser);
-      continue;
-    }
+	{
+	  pedwarn (c_parser_peek_token (parser)->location, OPT_pedantic,
+		   "extra semicolon in struct or union specified");
+	  c_parser_consume_token (parser);
+	  continue;
+	}
       /* Stop if at the end of the instance variables.  */
       if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
-    {
-      c_parser_consume_token (parser);
-      break;
-    }
+	{
+	  c_parser_consume_token (parser);
+	  break;
+	}
       /* Parse any objc-visibility-spec.  */
       if (c_parser_next_token_is_keyword (parser, RID_AT_PRIVATE))
 	{
@@ -7407,10 +6963,11 @@
 	  continue;
 	}
       else if (c_parser_next_token_is (parser, CPP_PRAGMA))
-    {
-      c_parser_pragma (parser, pragma_external);
-      continue;
-    }
+	{
+	  c_parser_pragma (parser, pragma_external);
+	  continue;
+	}
+
       /* Parse some comma-separated declarations.  */
       decls = c_parser_struct_declaration (parser);
       {
@@ -7452,9 +7009,9 @@
       list = chainon (list, build_tree_list (NULL_TREE, id));
       c_parser_consume_token (parser);
       if (c_parser_next_token_is (parser, CPP_COMMA))
-    c_parser_consume_token (parser);
+	c_parser_consume_token (parser);
       else
-    break;
+	break;
     }
   c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
   objc_declare_class (list);
@@ -7519,23 +7076,23 @@
     {
       tree list = NULL_TREE;
       /* Any identifiers, including those declared as type names, are
-     OK here.  */
+	 OK here.  */
       while (true)
-    {
-      tree id;
-      if (c_parser_next_token_is_not (parser, CPP_NAME))
-        {
-          c_parser_error (parser, "expected identifier");
-          break;
-        }
-      id = c_parser_peek_token (parser)->value;
-      list = chainon (list, build_tree_list (NULL_TREE, id));
-      c_parser_consume_token (parser);
-      if (c_parser_next_token_is (parser, CPP_COMMA))
-        c_parser_consume_token (parser);
-      else
-        break;
-    }
+	{
+	  tree id;
+	  if (c_parser_next_token_is_not (parser, CPP_NAME))
+	    {
+	      c_parser_error (parser, "expected identifier");
+	      break;
+	    }
+	  id = c_parser_peek_token (parser)->value;
+	  list = chainon (list, build_tree_list (NULL_TREE, id));
+	  c_parser_consume_token (parser);
+	  if (c_parser_next_token_is (parser, CPP_COMMA))
+	    c_parser_consume_token (parser);
+	  else
+	    break;
+	}
       c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
       objc_declare_protocols (list, attributes);
     }
@@ -7545,7 +7102,7 @@
       tree proto = NULL_TREE;
       c_parser_consume_token (parser);
       if (c_parser_next_token_is (parser, CPP_LESS))
-    proto = c_parser_objc_protocol_refs (parser);
+	proto = c_parser_objc_protocol_refs (parser);
       parser->objc_pq_context = true;
       objc_start_protocol (id, proto, attributes);
       c_parser_objc_methodprotolist (parser);
@@ -7600,7 +7157,7 @@
     {
       c_parser_consume_token (parser);
       pedwarn (c_parser_peek_token (parser)->location, OPT_pedantic,
-           "extra semicolon in method definition specified");
+	       "extra semicolon in method definition specified");
     }
 
   if (!c_parser_next_token_is (parser, CPP_OPEN_BRACE))
@@ -7843,8 +7400,8 @@
       attr_err |= c_parser_objc_maybe_method_attributes (parser, attributes) ;
 
       /* Parse the optional parameter list.  Optional Objective-C
-     method parameters follow the C syntax, and may include '...'
-     to denote a variable number of arguments.  */
+	 method parameters follow the C syntax, and may include '...'
+	 to denote a variable number of arguments.  */
       parms = make_node (TREE_LIST);
       while (c_parser_next_token_is (parser, CPP_COMMA))
 	{
@@ -7916,7 +7473,7 @@
 	  c_parser_consume_token (parser);
 	}
       else
-    break;
+	break;
     }
   if (c_parser_next_tokens_start_typename (parser, cla_prefer_type))
     type_name = c_parser_type_name (parser);
@@ -7951,17 +7508,17 @@
     {
       tree id;
       if (c_parser_next_token_is_not (parser, CPP_NAME))
-    {
-      c_parser_error (parser, "expected identifier");
-      break;
-    }
+	{
+	  c_parser_error (parser, "expected identifier");
+	  break;
+	}
       id = c_parser_peek_token (parser)->value;
       list = chainon (list, build_tree_list (NULL_TREE, id));
       c_parser_consume_token (parser);
       if (c_parser_next_token_is (parser, CPP_COMMA))
-    c_parser_consume_token (parser);
+	c_parser_consume_token (parser);
       else
-    break;
+	break;
     }
   c_parser_require (parser, CPP_GREATER, "expected %<>%>");
   return list;
@@ -8050,7 +7607,7 @@
 	}
       objc_begin_catch_clause (parameter_declaration);
       if (c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>"))
-    c_parser_compound_statement_nostart (parser);
+	c_parser_compound_statement_nostart (parser);
       objc_finish_catch_clause ();
     }
   if (c_parser_next_token_is_keyword (parser, RID_AT_FINALLY))
@@ -8190,11 +7747,11 @@
   while (true)
     {
       if (!c_parser_require (parser, CPP_COLON, "expected %<:%>"))
-    return list;
+	return list;
       list = chainon (list, build_tree_list (sel, NULL_TREE));
       sel = c_parser_objc_selector (parser);
       if (!sel && c_parser_next_token_is_not (parser, CPP_COLON))
-    break;
+	break;
     }
   return list;
 }
@@ -8212,7 +7769,7 @@
 {
   if (c_parser_peek_token (parser)->type == CPP_NAME
       && (c_parser_peek_token (parser)->id_kind == C_ID_TYPENAME
-      || c_parser_peek_token (parser)->id_kind == C_ID_CLASSNAME))
+	  || c_parser_peek_token (parser)->id_kind == C_ID_CLASSNAME))
     {
       tree id = c_parser_peek_token (parser)->value;
       c_parser_consume_token (parser);
@@ -8247,12 +7804,12 @@
     {
       tree keywordexpr;
       if (!c_parser_require (parser, CPP_COLON, "expected %<:%>"))
-    return error_mark_node;
+	return error_mark_node;
       keywordexpr = c_parser_objc_keywordexpr (parser);
       list = chainon (list, build_tree_list (sel, keywordexpr));
       sel = c_parser_objc_selector (parser);
       if (!sel && c_parser_next_token_is_not (parser, CPP_COLON))
-    break;
+	break;
     }
   return list;
 }
@@ -8271,7 +7828,7 @@
   if (VEC_length (tree, expr_list) == 1)
     {
       /* Just return the expression, remove a level of
-     indirection.  */
+	 indirection.  */
       ret = VEC_index (tree, expr_list, 0);
     }
   else
@@ -8617,34 +8174,34 @@
     {
     case PRAGMA_OMP_BARRIER:
       if (context != pragma_compound)
-    {
-      if (context == pragma_stmt)
-        c_parser_error (parser, "%<#pragma omp barrier%> may only be "
-                "used in compound statements");
-      goto bad_stmt;
-    }
+	{
+	  if (context == pragma_stmt)
+	    c_parser_error (parser, "%<#pragma omp barrier%> may only be "
+			    "used in compound statements");
+	  goto bad_stmt;
+	}
       c_parser_omp_barrier (parser);
       return false;
 
     case PRAGMA_OMP_FLUSH:
       if (context != pragma_compound)
-    {
-      if (context == pragma_stmt)
-        c_parser_error (parser, "%<#pragma omp flush%> may only be "
-                "used in compound statements");
-      goto bad_stmt;
-    }
+	{
+	  if (context == pragma_stmt)
+	    c_parser_error (parser, "%<#pragma omp flush%> may only be "
+			    "used in compound statements");
+	  goto bad_stmt;
+	}
       c_parser_omp_flush (parser);
       return false;
 
     case PRAGMA_OMP_TASKWAIT:
       if (context != pragma_compound)
-    {
-      if (context == pragma_stmt)
-        c_parser_error (parser, "%<#pragma omp taskwait%> may only be "
-                "used in compound statements");
-      goto bad_stmt;
-    }
+	{
+	  if (context == pragma_stmt)
+	    c_parser_error (parser, "%<#pragma omp taskwait%> may only be "
+			    "used in compound statements");
+	  goto bad_stmt;
+	}
       c_parser_omp_taskwait (parser);
       return false;
 
@@ -8654,8 +8211,8 @@
 
     case PRAGMA_OMP_SECTION:
       error_at (c_parser_peek_token (parser)->location,
-        "%<#pragma omp section%> may only be used in "
-        "%<#pragma omp sections%> construct");
+		"%<#pragma omp section%> may only be used in "
+		"%<#pragma omp sections%> construct");
       c_parser_skip_until_found (parser, CPP_PRAGMA_EOL, NULL);
       return false;
 
@@ -8666,17 +8223,17 @@
 
     default:
       if (id < PRAGMA_FIRST_EXTERNAL)
-    {
-      if (context == pragma_external)
-        {
-        bad_stmt:
-          c_parser_error (parser, "expected declaration specifiers");
-          c_parser_skip_until_found (parser, CPP_PRAGMA_EOL, NULL);
-          return false;
-        }
-      c_parser_omp_construct (parser);
-      return true;
-    }
+	{
+	  if (context == pragma_external)
+	    {
+	    bad_stmt:
+	      c_parser_error (parser, "expected declaration specifiers");
+	      c_parser_skip_until_found (parser, CPP_PRAGMA_EOL, NULL);
+	      return false;
+	    }
+	  c_parser_omp_construct (parser);
+	  return true;
+	}
       break;
     }
 
@@ -8706,7 +8263,7 @@
   else
     {
       if (ret == CPP_KEYWORD)
-    ret = CPP_NAME;
+	ret = CPP_NAME;
       c_parser_consume_token (the_parser);
     }
 
@@ -8753,52 +8310,52 @@
       const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
 
       switch (p[0])
-    {
-    case 'c':
-      if (!strcmp ("collapse", p))
-        result = PRAGMA_OMP_CLAUSE_COLLAPSE;
-      else if (!strcmp ("copyin", p))
-        result = PRAGMA_OMP_CLAUSE_COPYIN;
+	{
+	case 'c':
+	  if (!strcmp ("collapse", p))
+	    result = PRAGMA_OMP_CLAUSE_COLLAPSE;
+	  else if (!strcmp ("copyin", p))
+	    result = PRAGMA_OMP_CLAUSE_COPYIN;
           else if (!strcmp ("copyprivate", p))
-        result = PRAGMA_OMP_CLAUSE_COPYPRIVATE;
-      break;
-    case 'f':
-      if (!strcmp ("firstprivate", p))
-        result = PRAGMA_OMP_CLAUSE_FIRSTPRIVATE;
-      break;
-    case 'l':
-      if (!strcmp ("lastprivate", p))
-        result = PRAGMA_OMP_CLAUSE_LASTPRIVATE;
-      break;
-    case 'n':
-      if (!strcmp ("nowait", p))
-        result = PRAGMA_OMP_CLAUSE_NOWAIT;
-      else if (!strcmp ("num_threads", p))
-        result = PRAGMA_OMP_CLAUSE_NUM_THREADS;
-      break;
-    case 'o':
-      if (!strcmp ("ordered", p))
-        result = PRAGMA_OMP_CLAUSE_ORDERED;
-      break;
-    case 'p':
-      if (!strcmp ("private", p))
-        result = PRAGMA_OMP_CLAUSE_PRIVATE;
-      break;
-    case 'r':
-      if (!strcmp ("reduction", p))
-        result = PRAGMA_OMP_CLAUSE_REDUCTION;
-      break;
-    case 's':
-      if (!strcmp ("schedule", p))
-        result = PRAGMA_OMP_CLAUSE_SCHEDULE;
-      else if (!strcmp ("shared", p))
-        result = PRAGMA_OMP_CLAUSE_SHARED;
-      break;
-    case 'u':
-      if (!strcmp ("untied", p))
-        result = PRAGMA_OMP_CLAUSE_UNTIED;
-      break;
-    }
+	    result = PRAGMA_OMP_CLAUSE_COPYPRIVATE;
+	  break;
+	case 'f':
+	  if (!strcmp ("firstprivate", p))
+	    result = PRAGMA_OMP_CLAUSE_FIRSTPRIVATE;
+	  break;
+	case 'l':
+	  if (!strcmp ("lastprivate", p))
+	    result = PRAGMA_OMP_CLAUSE_LASTPRIVATE;
+	  break;
+	case 'n':
+	  if (!strcmp ("nowait", p))
+	    result = PRAGMA_OMP_CLAUSE_NOWAIT;
+	  else if (!strcmp ("num_threads", p))
+	    result = PRAGMA_OMP_CLAUSE_NUM_THREADS;
+	  break;
+	case 'o':
+	  if (!strcmp ("ordered", p))
+	    result = PRAGMA_OMP_CLAUSE_ORDERED;
+	  break;