--- 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;
+	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;
+	}
     }
 
   if (result != PRAGMA_OMP_CLAUSE_NONE)
@@ -8811,16 +8368,16 @@
 
 static void
 check_no_duplicate_clause (tree clauses, enum omp_clause_code code,
-               const char *name)
+			   const char *name)
 {
   tree c;
 
   for (c = clauses; c ; c = OMP_CLAUSE_CHAIN (c))
     if (OMP_CLAUSE_CODE (c) == code)
       {
-    location_t loc = OMP_CLAUSE_LOCATION (c);
-    error_at (loc, "too many %qs clauses", name);
-    break;
+	location_t loc = OMP_CLAUSE_LOCATION (c);
+	error_at (loc, "too many %qs clauses", name);
+	break;
       }
 }
 
@@ -8838,8 +8395,8 @@
 
 static tree
 c_parser_omp_variable_list (c_parser *parser,
-                location_t clause_loc,
-                enum omp_clause_code kind,
+			    location_t clause_loc,
+			    enum omp_clause_code kind,
                             tree list)
 {
   if (c_parser_next_token_is_not (parser, CPP_NAME)
@@ -8847,29 +8404,29 @@
     c_parser_error (parser, "expected identifier");
 
   while (c_parser_next_token_is (parser, CPP_NAME)
-     && c_parser_peek_token (parser)->id_kind == C_ID_ID)
+	 && c_parser_peek_token (parser)->id_kind == C_ID_ID)
     {
       tree t = lookup_name (c_parser_peek_token (parser)->value);
 
       if (t == NULL_TREE)
-    undeclared_variable (c_parser_peek_token (parser)->location,
-                 c_parser_peek_token (parser)->value);
+	undeclared_variable (c_parser_peek_token (parser)->location,
+			     c_parser_peek_token (parser)->value);
       else if (t == error_mark_node)
-    ;
+	;
       else if (kind != 0)
-    {
-      tree u = build_omp_clause (clause_loc, kind);
-      OMP_CLAUSE_DECL (u) = t;
-      OMP_CLAUSE_CHAIN (u) = list;
-      list = u;
-    }
+	{
+	  tree u = build_omp_clause (clause_loc, kind);
+	  OMP_CLAUSE_DECL (u) = t;
+	  OMP_CLAUSE_CHAIN (u) = list;
+	  list = u;
+	}
       else
-    list = tree_cons (t, NULL_TREE, list);
+	list = tree_cons (t, NULL_TREE, list);
 
       c_parser_consume_token (parser);
 
       if (c_parser_next_token_is_not (parser, CPP_COMMA))
-    break;
+	break;
 
       c_parser_consume_token (parser);
     }
@@ -8882,7 +8439,7 @@
 
 static tree
 c_parser_omp_var_list_parens (c_parser *parser, enum omp_clause_code kind,
-                  tree list)
+			      tree list)
 {
   /* The clauses location.  */
   location_t loc = c_parser_peek_token (parser)->location;
@@ -8921,7 +8478,7 @@
       || (int) n != n)
     {
       error_at (loc,
-        "collapse argument needs positive constant integer expression");
+		"collapse argument needs positive constant integer expression");
       return list;
     }
   c = build_omp_clause (loc, OMP_CLAUSE_COLLAPSE);
@@ -8965,22 +8522,22 @@
       const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
 
       switch (p[0])
-    {
-    case 'n':
-      if (strcmp ("none", p) != 0)
-        goto invalid_kind;
-      kind = OMP_CLAUSE_DEFAULT_NONE;
-      break;
-
-    case 's':
-      if (strcmp ("shared", p) != 0)
-        goto invalid_kind;
-      kind = OMP_CLAUSE_DEFAULT_SHARED;
-      break;
-
-    default:
-      goto invalid_kind;
-    }
+	{
+	case 'n':
+	  if (strcmp ("none", p) != 0)
+	    goto invalid_kind;
+	  kind = OMP_CLAUSE_DEFAULT_NONE;
+	  break;
+
+	case 's':
+	  if (strcmp ("shared", p) != 0)
+	    goto invalid_kind;
+	  kind = OMP_CLAUSE_DEFAULT_SHARED;
+	  break;
+
+	default:
+	  goto invalid_kind;
+	}
 
       c_parser_consume_token (parser);
     }
@@ -9077,22 +8634,22 @@
       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
 
       if (!INTEGRAL_TYPE_P (TREE_TYPE (t)))
-    {
-      c_parser_error (parser, "expected integer expression");
-      return list;
-    }
+	{
+	  c_parser_error (parser, "expected integer expression");
+	  return list;
+	}
 
       /* Attempt to statically determine when the number isn't positive.  */
       c = fold_build2_loc (expr_loc, LE_EXPR, boolean_type_node, t,
-               build_int_cst (TREE_TYPE (t), 0));
+		       build_int_cst (TREE_TYPE (t), 0));
       if (CAN_HAVE_LOCATION_P (c))
-    SET_EXPR_LOCATION (c, expr_loc);
+	SET_EXPR_LOCATION (c, expr_loc);
       if (c == boolean_true_node)
-    {
-      warning_at (expr_loc, 0,
-              "%<num_threads%> value must be positive");
-      t = integer_one_node;
-    }
+	{
+	  warning_at (expr_loc, 0,
+		      "%<num_threads%> value must be positive");
+	  t = integer_one_node;
+	}
 
       check_no_duplicate_clause (list, OMP_CLAUSE_NUM_THREADS, "num_threads");
 
@@ -9116,7 +8673,7 @@
   check_no_duplicate_clause (list, OMP_CLAUSE_ORDERED, "ordered");
 
   c = build_omp_clause (c_parser_peek_token (parser)->location,
-            OMP_CLAUSE_ORDERED);
+			OMP_CLAUSE_ORDERED);
   OMP_CLAUSE_CHAIN (c) = list;
 
   return c;
@@ -9146,50 +8703,50 @@
       enum tree_code code;
 
       switch (c_parser_peek_token (parser)->type)
-    {
-    case CPP_PLUS:
-      code = PLUS_EXPR;
-      break;
-    case CPP_MULT:
-      code = MULT_EXPR;
-      break;
-    case CPP_MINUS:
-      code = MINUS_EXPR;
-      break;
-    case CPP_AND:
-      code = BIT_AND_EXPR;
-      break;
-    case CPP_XOR:
-      code = BIT_XOR_EXPR;
-      break;
-    case CPP_OR:
-      code = BIT_IOR_EXPR;
-      break;
-    case CPP_AND_AND:
-      code = TRUTH_ANDIF_EXPR;
-      break;
-    case CPP_OR_OR:
-      code = TRUTH_ORIF_EXPR;
-      break;
-    default:
-      c_parser_error (parser,
-              "expected %<+%>, %<*%>, %<-%>, %<&%>, "
-              "%<^%>, %<|%>, %<&&%>, or %<||%>");
-      c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 0);
-      return list;
-    }
+	{
+	case CPP_PLUS:
+	  code = PLUS_EXPR;
+	  break;
+	case CPP_MULT:
+	  code = MULT_EXPR;
+	  break;
+	case CPP_MINUS:
+	  code = MINUS_EXPR;
+	  break;
+	case CPP_AND:
+	  code = BIT_AND_EXPR;
+	  break;
+	case CPP_XOR:
+	  code = BIT_XOR_EXPR;
+	  break;
+	case CPP_OR:
+	  code = BIT_IOR_EXPR;
+	  break;
+	case CPP_AND_AND:
+	  code = TRUTH_ANDIF_EXPR;
+	  break;
+	case CPP_OR_OR:
+	  code = TRUTH_ORIF_EXPR;
+	  break;
+	default:
+	  c_parser_error (parser,
+			  "expected %<+%>, %<*%>, %<-%>, %<&%>, "
+			  "%<^%>, %<|%>, %<&&%>, or %<||%>");
+	  c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 0);
+	  return list;
+	}
       c_parser_consume_token (parser);
       if (c_parser_require (parser, CPP_COLON, "expected %<:%>"))
-    {
-      tree nl, c;
-
-      nl = c_parser_omp_variable_list (parser, clause_loc,
-                       OMP_CLAUSE_REDUCTION, list);
-      for (c = nl; c != list; c = OMP_CLAUSE_CHAIN (c))
-        OMP_CLAUSE_REDUCTION_CODE (c) = code;
-
-      list = nl;
-    }
+	{
+	  tree nl, c;
+
+	  nl = c_parser_omp_variable_list (parser, clause_loc,
+					   OMP_CLAUSE_REDUCTION, list);
+	  for (c = nl; c != list; c = OMP_CLAUSE_CHAIN (c))
+	    OMP_CLAUSE_REDUCTION_CODE (c) = code;
+
+	  list = nl;
+	}
       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
     }
   return list;
@@ -9220,28 +8777,28 @@
       const char *p = IDENTIFIER_POINTER (kind);
 
       switch (p[0])
-    {
-    case 'd':
-      if (strcmp ("dynamic", p) != 0)
-        goto invalid_kind;
-      OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_DYNAMIC;
-      break;
+	{
+	case 'd':
+	  if (strcmp ("dynamic", p) != 0)
+	    goto invalid_kind;
+	  OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_DYNAMIC;
+	  break;
 
         case 'g':
-      if (strcmp ("guided", p) != 0)
-        goto invalid_kind;
-      OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_GUIDED;
-      break;
-
-    case 'r':
-      if (strcmp ("runtime", p) != 0)
-        goto invalid_kind;
-      OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_RUNTIME;
-      break;
-
-    default:
-      goto invalid_kind;
-    }
+	  if (strcmp ("guided", p) != 0)
+	    goto invalid_kind;
+	  OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_GUIDED;
+	  break;
+
+	case 'r':
+	  if (strcmp ("runtime", p) != 0)
+	    goto invalid_kind;
+	  OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_RUNTIME;
+	  break;
+
+	default:
+	  goto invalid_kind;
+	}
     }
   else if (c_parser_next_token_is_keyword (parser, RID_STATIC))
     OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_STATIC;
@@ -9261,22 +8818,22 @@
       t = c_fully_fold (t, false, NULL);
 
       if (OMP_CLAUSE_SCHEDULE_KIND (c) == OMP_CLAUSE_SCHEDULE_RUNTIME)
-    error_at (here, "schedule %<runtime%> does not take "
-          "a %<chunk_size%> parameter");
+	error_at (here, "schedule %<runtime%> does not take "
+		  "a %<chunk_size%> parameter");
       else if (OMP_CLAUSE_SCHEDULE_KIND (c) == OMP_CLAUSE_SCHEDULE_AUTO)
-    error_at (here,
-          "schedule %<auto%> does not take "
-          "a %<chunk_size%> parameter");
+	error_at (here,
+		  "schedule %<auto%> does not take "
+		  "a %<chunk_size%> parameter");
       else if (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE)
-    OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c) = t;
+	OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c) = t;
       else
-    c_parser_error (parser, "expected integer expression");
+	c_parser_error (parser, "expected integer expression");
 
       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
     }
   else
     c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
-                   "expected %<,%> or %<)%>");
+			       "expected %<,%> or %<)%>");
 
   check_no_duplicate_clause (list, OMP_CLAUSE_SCHEDULE, "schedule");
   OMP_CLAUSE_CHAIN (c) = list;
@@ -9309,7 +8866,7 @@
   check_no_duplicate_clause (list, OMP_CLAUSE_UNTIED, "untied");
 
   c = build_omp_clause (c_parser_peek_token (parser)->location,
-            OMP_CLAUSE_UNTIED);
+			OMP_CLAUSE_UNTIED);
   OMP_CLAUSE_CHAIN (c) = list;
 
   return c;
@@ -9321,7 +8878,7 @@
 
 static tree
 c_parser_omp_all_clauses (c_parser *parser, unsigned int mask,
-              const char *where)
+			  const char *where)
 {
   tree clauses = NULL;
   bool first = true;
@@ -9334,86 +8891,86 @@
       tree prev = clauses;
 
       if (!first && c_parser_next_token_is (parser, CPP_COMMA))
-    c_parser_consume_token (parser);
+	c_parser_consume_token (parser);
 
       first = false;
       here = c_parser_peek_token (parser)->location;
       c_kind = c_parser_omp_clause_name (parser);
 
       switch (c_kind)
-    {
-    case PRAGMA_OMP_CLAUSE_COLLAPSE:
-      clauses = c_parser_omp_clause_collapse (parser, clauses);
-      c_name = "collapse";
-      break;
-    case PRAGMA_OMP_CLAUSE_COPYIN:
-      clauses = c_parser_omp_clause_copyin (parser, clauses);
-      c_name = "copyin";
-      break;
-    case PRAGMA_OMP_CLAUSE_COPYPRIVATE:
-      clauses = c_parser_omp_clause_copyprivate (parser, clauses);
-      c_name = "copyprivate";
-      break;
-    case PRAGMA_OMP_CLAUSE_DEFAULT:
-      clauses = c_parser_omp_clause_default (parser, clauses);
-      c_name = "default";
-      break;
-    case PRAGMA_OMP_CLAUSE_FIRSTPRIVATE:
-      clauses = c_parser_omp_clause_firstprivate (parser, clauses);
-      c_name = "firstprivate";
-      break;
-    case PRAGMA_OMP_CLAUSE_IF:
-      clauses = c_parser_omp_clause_if (parser, clauses);
-      c_name = "if";
-      break;
-    case PRAGMA_OMP_CLAUSE_LASTPRIVATE:
-      clauses = c_parser_omp_clause_lastprivate (parser, clauses);
-      c_name = "lastprivate";
-      break;
-    case PRAGMA_OMP_CLAUSE_NOWAIT:
-      clauses = c_parser_omp_clause_nowait (parser, clauses);
-      c_name = "nowait";
-      break;
-    case PRAGMA_OMP_CLAUSE_NUM_THREADS:
-      clauses = c_parser_omp_clause_num_threads (parser, clauses);
-      c_name = "num_threads";
-      break;
-    case PRAGMA_OMP_CLAUSE_ORDERED:
-      clauses = c_parser_omp_clause_ordered (parser, clauses);
-      c_name = "ordered";
-      break;
-    case PRAGMA_OMP_CLAUSE_PRIVATE:
-      clauses = c_parser_omp_clause_private (parser, clauses);
-      c_name = "private";
-      break;
-    case PRAGMA_OMP_CLAUSE_REDUCTION:
-      clauses = c_parser_omp_clause_reduction (parser, clauses);
-      c_name = "reduction";
-      break;
-    case PRAGMA_OMP_CLAUSE_SCHEDULE:
-      clauses = c_parser_omp_clause_schedule (parser, clauses);
-      c_name = "schedule";
-      break;
-    case PRAGMA_OMP_CLAUSE_SHARED:
-      clauses = c_parser_omp_clause_shared (parser, clauses);
-      c_name = "shared";
-      break;
-    case PRAGMA_OMP_CLAUSE_UNTIED:
-      clauses = c_parser_omp_clause_untied (parser, clauses);
-      c_name = "untied";
-      break;
-    default:
-      c_parser_error (parser, "expected %<#pragma omp%> clause");
-      goto saw_error;
-    }
+	{
+	case PRAGMA_OMP_CLAUSE_COLLAPSE:
+	  clauses = c_parser_omp_clause_collapse (parser, clauses);
+	  c_name = "collapse";
+	  break;
+	case PRAGMA_OMP_CLAUSE_COPYIN:
+	  clauses = c_parser_omp_clause_copyin (parser, clauses);
+	  c_name = "copyin";
+	  break;
+	case PRAGMA_OMP_CLAUSE_COPYPRIVATE:
+	  clauses = c_parser_omp_clause_copyprivate (parser, clauses);
+	  c_name = "copyprivate";
+	  break;
+	case PRAGMA_OMP_CLAUSE_DEFAULT:
+	  clauses = c_parser_omp_clause_default (parser, clauses);
+	  c_name = "default";
+	  break;
+	case PRAGMA_OMP_CLAUSE_FIRSTPRIVATE:
+	  clauses = c_parser_omp_clause_firstprivate (parser, clauses);
+	  c_name = "firstprivate";
+	  break;
+	case PRAGMA_OMP_CLAUSE_IF:
+	  clauses = c_parser_omp_clause_if (parser, clauses);
+	  c_name = "if";
+	  break;
+	case PRAGMA_OMP_CLAUSE_LASTPRIVATE:
+	  clauses = c_parser_omp_clause_lastprivate (parser, clauses);
+	  c_name = "lastprivate";
+	  break;
+	case PRAGMA_OMP_CLAUSE_NOWAIT:
+	  clauses = c_parser_omp_clause_nowait (parser, clauses);
+	  c_name = "nowait";
+	  break;
+	case PRAGMA_OMP_CLAUSE_NUM_THREADS:
+	  clauses = c_parser_omp_clause_num_threads (parser, clauses);
+	  c_name = "num_threads";
+	  break;
+	case PRAGMA_OMP_CLAUSE_ORDERED:
+	  clauses = c_parser_omp_clause_ordered (parser, clauses);
+	  c_name = "ordered";
+	  break;
+	case PRAGMA_OMP_CLAUSE_PRIVATE:
+	  clauses = c_parser_omp_clause_private (parser, clauses);
+	  c_name = "private";
+	  break;
+	case PRAGMA_OMP_CLAUSE_REDUCTION:
+	  clauses = c_parser_omp_clause_reduction (parser, clauses);
+	  c_name = "reduction";
+	  break;
+	case PRAGMA_OMP_CLAUSE_SCHEDULE:
+	  clauses = c_parser_omp_clause_schedule (parser, clauses);
+	  c_name = "schedule";
+	  break;
+	case PRAGMA_OMP_CLAUSE_SHARED:
+	  clauses = c_parser_omp_clause_shared (parser, clauses);
+	  c_name = "shared";
+	  break;
+	case PRAGMA_OMP_CLAUSE_UNTIED:
+	  clauses = c_parser_omp_clause_untied (parser, clauses);
+	  c_name = "untied";
+	  break;
+	default:
+	  c_parser_error (parser, "expected %<#pragma omp%> clause");
+	  goto saw_error;
+	}
 
       if (((mask >> c_kind) & 1) == 0 && !parser->error)
-    {
-      /* Remove the invalid clause(s) from the list to avoid
-         confusing the rest of the compiler.  */
-      clauses = prev;
-      error_at (here, "%qs is not valid for %qs", c_name, where);
-    }
+	{
+	  /* Remove the invalid clause(s) from the list to avoid
+	     confusing the rest of the compiler.  */
+	  clauses = prev;
+	  error_at (here, "%qs is not valid for %qs", c_name, where);
+	}
     }
 
  saw_error:
@@ -9522,39 +9079,39 @@
       /* FALLTHRU */
     default:
       switch (c_parser_peek_token (parser)->type)
-    {
-    case CPP_MULT_EQ:
-      code = MULT_EXPR;
-      break;
-    case CPP_DIV_EQ:
-      code = TRUNC_DIV_EXPR;
-      break;
-    case CPP_PLUS_EQ:
-      code = PLUS_EXPR;
-      break;
-    case CPP_MINUS_EQ:
-      code = MINUS_EXPR;
-      break;
-    case CPP_LSHIFT_EQ:
-      code = LSHIFT_EXPR;
-      break;
-    case CPP_RSHIFT_EQ:
-      code = RSHIFT_EXPR;
-      break;
-    case CPP_AND_EQ:
-      code = BIT_AND_EXPR;
-      break;
-    case CPP_OR_EQ:
-      code = BIT_IOR_EXPR;
-      break;
-    case CPP_XOR_EQ:
-      code = BIT_XOR_EXPR;
-      break;
-    default:
-      c_parser_error (parser,
-              "invalid operator for %<#pragma omp atomic%>");
-      goto saw_error;
-    }
+	{
+	case CPP_MULT_EQ:
+	  code = MULT_EXPR;
+	  break;
+	case CPP_DIV_EQ:
+	  code = TRUNC_DIV_EXPR;
+	  break;
+	case CPP_PLUS_EQ:
+	  code = PLUS_EXPR;
+	  break;
+	case CPP_MINUS_EQ:
+	  code = MINUS_EXPR;
+	  break;
+	case CPP_LSHIFT_EQ:
+	  code = LSHIFT_EXPR;
+	  break;
+	case CPP_RSHIFT_EQ:
+	  code = RSHIFT_EXPR;
+	  break;
+	case CPP_AND_EQ:
+	  code = BIT_AND_EXPR;
+	  break;
+	case CPP_OR_EQ:
+	  code = BIT_IOR_EXPR;
+	  break;
+	case CPP_XOR_EQ:
+	  code = BIT_XOR_EXPR;
+	  break;
+	default:
+	  c_parser_error (parser,
+			  "invalid operator for %<#pragma omp atomic%>");
+	  goto saw_error;
+	}
 
       /* Arrange to pass the location of the assignment operator to
 	 c_finish_omp_atomic.  */
@@ -9605,13 +9162,13 @@
     {
       c_parser_consume_token (parser);
       if (c_parser_next_token_is (parser, CPP_NAME))
-    {
-      name = c_parser_peek_token (parser)->value;
-      c_parser_consume_token (parser);
-      c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>");
-    }
+	{
+	  name = c_parser_peek_token (parser)->value;
+	  c_parser_consume_token (parser);
+	  c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>");
+	}
       else
-    c_parser_error (parser, "expected identifier");
+	c_parser_error (parser, "expected identifier");
     }
   else if (c_parser_next_token_is_not (parser, CPP_PRAGMA_EOL))
     c_parser_error (parser, "expected %<(%> or end of line");
@@ -9648,7 +9205,7 @@
 
 static tree
 c_parser_omp_for_loop (location_t loc,
-               c_parser *parser, tree clauses, tree *par_clauses)
+		       c_parser *parser, tree clauses, tree *par_clauses)
 {
   tree decl, cond, incr, save_break, save_cont, body, init, stmt, cl;
   tree declv, condv, incrv, initv, ret = NULL;
@@ -9681,7 +9238,7 @@
       int bracecount = 0;
 
       if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
-    goto pop_scopes;
+	goto pop_scopes;
 
       /* Parse the initialization declaration or expression.  */
       if (c_parser_next_tokens_start_declaration (parser))
@@ -9720,100 +9277,100 @@
 	  c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
 	}
       else
-    {
-    error_init:
-      c_parser_error (parser,
-              "expected iteration declaration or initialization");
-      c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
-                     "expected %<)%>");
-      fail = true;
-      goto parse_next;
-    }
+	{
+	error_init:
+	  c_parser_error (parser,
+			  "expected iteration declaration or initialization");
+	  c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
+				     "expected %<)%>");
+	  fail = true;
+	  goto parse_next;
+	}
 
       /* Parse the loop condition.  */
       cond = NULL_TREE;
       if (c_parser_next_token_is_not (parser, CPP_SEMICOLON))
-    {
-      location_t cond_loc = c_parser_peek_token (parser)->location;
-      struct c_expr cond_expr = c_parser_binary_expression (parser, NULL);
-
-      cond = cond_expr.value;
-      cond = c_objc_common_truthvalue_conversion (cond_loc, cond);
-      cond = c_fully_fold (cond, false, NULL);
-      switch (cond_expr.original_code)
-        {
-        case GT_EXPR:
-        case GE_EXPR:
-        case LT_EXPR:
-        case LE_EXPR:
-          break;
-        default:
-          /* Can't be cond = error_mark_node, because we want to preserve
-         the location until c_finish_omp_for.  */
-          cond = build1 (NOP_EXPR, boolean_type_node, error_mark_node);
-          break;
-        }
-      protected_set_expr_location (cond, cond_loc);
-    }
+	{
+	  location_t cond_loc = c_parser_peek_token (parser)->location;
+	  struct c_expr cond_expr = c_parser_binary_expression (parser, NULL);
+
+	  cond = cond_expr.value;
+	  cond = c_objc_common_truthvalue_conversion (cond_loc, cond);
+	  cond = c_fully_fold (cond, false, NULL);
+	  switch (cond_expr.original_code)
+	    {
+	    case GT_EXPR:
+	    case GE_EXPR:
+	    case LT_EXPR:
+	    case LE_EXPR:
+	      break;
+	    default:
+	      /* Can't be cond = error_mark_node, because we want to preserve
+		 the location until c_finish_omp_for.  */
+	      cond = build1 (NOP_EXPR, boolean_type_node, error_mark_node);
+	      break;
+	    }
+	  protected_set_expr_location (cond, cond_loc);
+	}
       c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
 
       /* Parse the increment expression.  */
       incr = NULL_TREE;
       if (c_parser_next_token_is_not (parser, CPP_CLOSE_PAREN))
-    {
-      location_t incr_loc = c_parser_peek_token (parser)->location;
-
-      incr = c_process_expr_stmt (incr_loc,
-                      c_parser_expression (parser).value);
-    }
+	{
+	  location_t incr_loc = c_parser_peek_token (parser)->location;
+
+	  incr = c_process_expr_stmt (incr_loc,
+				      c_parser_expression (parser).value);
+	}
       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
 
       if (decl == NULL || decl == error_mark_node || init == error_mark_node)
-    fail = true;
+	fail = true;
       else
-    {
-      TREE_VEC_ELT (declv, i) = decl;
-      TREE_VEC_ELT (initv, i) = init;
-      TREE_VEC_ELT (condv, i) = cond;
-      TREE_VEC_ELT (incrv, i) = incr;
-    }
+	{
+	  TREE_VEC_ELT (declv, i) = decl;
+	  TREE_VEC_ELT (initv, i) = init;
+	  TREE_VEC_ELT (condv, i) = cond;
+	  TREE_VEC_ELT (incrv, i) = incr;
+	}
 
     parse_next:
       if (i == collapse - 1)
-    break;
+	break;
 
       /* FIXME: OpenMP 3.0 draft isn't very clear on what exactly is allowed
-     in between the collapsed for loops to be still considered perfectly
-     nested.  Hopefully the final version clarifies this.
-     For now handle (multiple) {'s and empty statements.  */
+	 in between the collapsed for loops to be still considered perfectly
+	 nested.  Hopefully the final version clarifies this.
+	 For now handle (multiple) {'s and empty statements.  */
       do
-    {
-      if (c_parser_next_token_is_keyword (parser, RID_FOR))
-        {
-          c_parser_consume_token (parser);
-          break;
-        }
-      else if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
-        {
-          c_parser_consume_token (parser);
-          bracecount++;
-        }
-      else if (bracecount
-           && c_parser_next_token_is (parser, CPP_SEMICOLON))
-        c_parser_consume_token (parser);
-      else
-        {
-          c_parser_error (parser, "not enough perfectly nested loops");
-          if (bracecount)
-        {
-          open_brace_parsed = true;
-          bracecount--;
-        }
-          fail = true;
-          collapse = 0;
-          break;
-        }
-    }
+	{
+	  if (c_parser_next_token_is_keyword (parser, RID_FOR))
+	    {
+	      c_parser_consume_token (parser);
+	      break;
+	    }
+	  else if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
+	    {
+	      c_parser_consume_token (parser);
+	      bracecount++;
+	    }
+	  else if (bracecount
+		   && c_parser_next_token_is (parser, CPP_SEMICOLON))
+	    c_parser_consume_token (parser);
+	  else
+	    {
+	      c_parser_error (parser, "not enough perfectly nested loops");
+	      if (bracecount)
+		{
+		  open_brace_parsed = true;
+		  bracecount--;
+		}
+	      fail = true;
+	      collapse = 0;
+	      break;
+	    }
+	}
       while (1);
 
       nbraces += bracecount;
@@ -9848,26 +9405,26 @@
   while (nbraces)
     {
       if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
-    {
-      c_parser_consume_token (parser);
-      nbraces--;
-    }
+	{
+	  c_parser_consume_token (parser);
+	  nbraces--;
+	}
       else if (c_parser_next_token_is (parser, CPP_SEMICOLON))
-    c_parser_consume_token (parser);
+	c_parser_consume_token (parser);
       else
-    {
-      c_parser_error (parser, "collapsed loops not perfectly nested");
-      while (nbraces)
-        {
-          location_t here = c_parser_peek_token (parser)->location;
-          stmt = c_begin_compound_stmt (true);
-          add_stmt (body);
-          c_parser_compound_statement_nostart (parser);
-          body = c_end_compound_stmt (here, stmt, true);
-          nbraces--;
-        }
-      goto pop_scopes;
-    }
+	{
+	  c_parser_error (parser, "collapsed loops not perfectly nested");
+	  while (nbraces)
+	    {
+	      location_t here = c_parser_peek_token (parser)->location;
+	      stmt = c_begin_compound_stmt (true);
+	      add_stmt (body);
+	      c_parser_compound_statement_nostart (parser);
+	      body = c_end_compound_stmt (here, stmt, true);
+	      nbraces--;
+	    }
+	  goto pop_scopes;
+	}
     }
 
   /* Only bother calling c_finish_omp_for if we haven't already generated
@@ -9876,44 +9433,44 @@
     {
       stmt = c_finish_omp_for (loc, declv, initv, condv, incrv, body, NULL);
       if (stmt)
-    {
-      if (par_clauses != NULL)
-        {
-          tree *c;
-          for (c = par_clauses; *c ; )
-        if (OMP_CLAUSE_CODE (*c) != OMP_CLAUSE_FIRSTPRIVATE
-            && OMP_CLAUSE_CODE (*c) != OMP_CLAUSE_LASTPRIVATE)
-          c = &OMP_CLAUSE_CHAIN (*c);
-        else
-          {
-            for (i = 0; i < collapse; i++)
-              if (TREE_VEC_ELT (declv, i) == OMP_CLAUSE_DECL (*c))
-            break;
-            if (i == collapse)
-              c = &OMP_CLAUSE_CHAIN (*c);
-            else if (OMP_CLAUSE_CODE (*c) == OMP_CLAUSE_FIRSTPRIVATE)
-              {
-            error_at (loc,
-                  "iteration variable %qD should not be firstprivate",
-                  OMP_CLAUSE_DECL (*c));
-            *c = OMP_CLAUSE_CHAIN (*c);
-              }
-            else
-              {
-            /* Copy lastprivate (decl) clause to OMP_FOR_CLAUSES,
-               change it to shared (decl) in
-               OMP_PARALLEL_CLAUSES.  */
-            tree l = build_omp_clause (OMP_CLAUSE_LOCATION (*c),
-                           OMP_CLAUSE_LASTPRIVATE);
-            OMP_CLAUSE_DECL (l) = OMP_CLAUSE_DECL (*c);
-            OMP_CLAUSE_CHAIN (l) = clauses;
-            clauses = l;
-            OMP_CLAUSE_SET_CODE (*c, OMP_CLAUSE_SHARED);
-              }
-          }
-        }
-      OMP_FOR_CLAUSES (stmt) = clauses;
-    }
+	{
+	  if (par_clauses != NULL)
+	    {
+	      tree *c;
+	      for (c = par_clauses; *c ; )
+		if (OMP_CLAUSE_CODE (*c) != OMP_CLAUSE_FIRSTPRIVATE
+		    && OMP_CLAUSE_CODE (*c) != OMP_CLAUSE_LASTPRIVATE)
+		  c = &OMP_CLAUSE_CHAIN (*c);
+		else
+		  {
+		    for (i = 0; i < collapse; i++)
+		      if (TREE_VEC_ELT (declv, i) == OMP_CLAUSE_DECL (*c))
+			break;
+		    if (i == collapse)
+		      c = &OMP_CLAUSE_CHAIN (*c);
+		    else if (OMP_CLAUSE_CODE (*c) == OMP_CLAUSE_FIRSTPRIVATE)
+		      {
+			error_at (loc,
+				  "iteration variable %qD should not be firstprivate",
+				  OMP_CLAUSE_DECL (*c));
+			*c = OMP_CLAUSE_CHAIN (*c);
+		      }
+		    else
+		      {
+			/* Copy lastprivate (decl) clause to OMP_FOR_CLAUSES,
+			   change it to shared (decl) in
+			   OMP_PARALLEL_CLAUSES.  */
+			tree l = build_omp_clause (OMP_CLAUSE_LOCATION (*c),
+						   OMP_CLAUSE_LASTPRIVATE);
+			OMP_CLAUSE_DECL (l) = OMP_CLAUSE_DECL (*c);
+			OMP_CLAUSE_CHAIN (l) = clauses;
+			clauses = l;
+			OMP_CLAUSE_SET_CODE (*c, OMP_CLAUSE_SHARED);
+		      }
+		  }
+	    }
+	  OMP_FOR_CLAUSES (stmt) = clauses;
+	}
       ret = stmt;
     }
 pop_scopes:
@@ -9936,15 +9493,15 @@
    LOC is the location of the #pragma token.
 */
 
-#define OMP_FOR_CLAUSE_MASK             \
-    ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE)     \
-    | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE)    \
-    | (1u << PRAGMA_OMP_CLAUSE_LASTPRIVATE)     \
-    | (1u << PRAGMA_OMP_CLAUSE_REDUCTION)       \
-    | (1u << PRAGMA_OMP_CLAUSE_ORDERED)     \
-    | (1u << PRAGMA_OMP_CLAUSE_SCHEDULE)        \
-    | (1u << PRAGMA_OMP_CLAUSE_COLLAPSE)        \
-    | (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
+#define OMP_FOR_CLAUSE_MASK				\
+	( (1u << PRAGMA_OMP_CLAUSE_PRIVATE)		\
+	| (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE)	\
+	| (1u << PRAGMA_OMP_CLAUSE_LASTPRIVATE)		\
+	| (1u << PRAGMA_OMP_CLAUSE_REDUCTION)		\
+	| (1u << PRAGMA_OMP_CLAUSE_ORDERED)		\
+	| (1u << PRAGMA_OMP_CLAUSE_SCHEDULE)		\
+	| (1u << PRAGMA_OMP_CLAUSE_COLLAPSE)		\
+	| (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
 
 static tree
 c_parser_omp_for (location_t loc, c_parser *parser)
@@ -9952,7 +9509,7 @@
   tree block, clauses, ret;
 
   clauses = c_parser_omp_all_clauses (parser, OMP_FOR_CLAUSE_MASK,
-                      "#pragma omp for");
+				      "#pragma omp for");
 
   block = c_begin_compound_stmt (true);
   ret = c_parser_omp_for_loop (loc, parser, clauses, NULL);
@@ -10023,16 +9580,16 @@
       substmt = push_stmt_list ();
 
       while (1)
-    {
+	{
           c_parser_statement (parser);
 
-      if (c_parser_peek_token (parser)->pragma_kind == PRAGMA_OMP_SECTION)
-        break;
-      if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
-        break;
-      if (c_parser_next_token_is (parser, CPP_EOF))
-        break;
-    }
+	  if (c_parser_peek_token (parser)->pragma_kind == PRAGMA_OMP_SECTION)
+	    break;
+	  if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
+	    break;
+	  if (c_parser_next_token_is (parser, CPP_EOF))
+	    break;
+	}
 
       substmt = pop_stmt_list (substmt);
       substmt = build1 (OMP_SECTION, void_type_node, substmt);
@@ -10043,22 +9600,22 @@
   while (1)
     {
       if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
-    break;
+	break;
       if (c_parser_next_token_is (parser, CPP_EOF))
-    break;
+	break;
 
       loc = c_parser_peek_token (parser)->location;
       if (c_parser_peek_token (parser)->pragma_kind == PRAGMA_OMP_SECTION)
-    {
-      c_parser_consume_pragma (parser);
-      c_parser_skip_to_pragma_eol (parser);
-      error_suppress = false;
-    }
+	{
+	  c_parser_consume_pragma (parser);
+	  c_parser_skip_to_pragma_eol (parser);
+	  error_suppress = false;
+	}
       else if (!error_suppress)
-    {
-      error_at (loc, "expected %<#pragma omp section%> or %<}%>");
-      error_suppress = true;
-    }
+	{
+	  error_at (loc, "expected %<#pragma omp section%> or %<}%>");
+	  error_suppress = true;
+	}
 
       substmt = c_parser_omp_structured_block (parser);
       substmt = build1 (OMP_SECTION, void_type_node, substmt);
@@ -10066,7 +9623,7 @@
       add_stmt (substmt);
     }
   c_parser_skip_until_found (parser, CPP_CLOSE_BRACE,
-                 "expected %<#pragma omp section%> or %<}%>");
+			     "expected %<#pragma omp section%> or %<}%>");
 
   substmt = pop_stmt_list (stmt);
 
@@ -10085,12 +9642,12 @@
    LOC is the location of the #pragma token.
 */
 
-#define OMP_SECTIONS_CLAUSE_MASK            \
-    ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE)     \
-    | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE)    \
-    | (1u << PRAGMA_OMP_CLAUSE_LASTPRIVATE)     \
-    | (1u << PRAGMA_OMP_CLAUSE_REDUCTION)       \
-    | (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
+#define OMP_SECTIONS_CLAUSE_MASK			\
+	( (1u << PRAGMA_OMP_CLAUSE_PRIVATE)		\
+	| (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE)	\
+	| (1u << PRAGMA_OMP_CLAUSE_LASTPRIVATE)		\
+	| (1u << PRAGMA_OMP_CLAUSE_REDUCTION)		\
+	| (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
 
 static tree
 c_parser_omp_sections (location_t loc, c_parser *parser)
@@ -10098,7 +9655,7 @@
   tree block, clauses, ret;
 
   clauses = c_parser_omp_all_clauses (parser, OMP_SECTIONS_CLAUSE_MASK,
-                      "#pragma omp sections");
+				      "#pragma omp sections");
 
   block = c_begin_compound_stmt (true);
   ret = c_parser_omp_sections_scope (loc, parser);
@@ -10118,15 +9675,15 @@
    LOC is the location of the #pragma token.
 */
 
-#define OMP_PARALLEL_CLAUSE_MASK            \
-    ( (1u << PRAGMA_OMP_CLAUSE_IF)          \
-    | (1u << PRAGMA_OMP_CLAUSE_PRIVATE)     \
-    | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE)    \
-    | (1u << PRAGMA_OMP_CLAUSE_DEFAULT)     \
-    | (1u << PRAGMA_OMP_CLAUSE_SHARED)      \
-    | (1u << PRAGMA_OMP_CLAUSE_COPYIN)      \
-    | (1u << PRAGMA_OMP_CLAUSE_REDUCTION)       \
-    | (1u << PRAGMA_OMP_CLAUSE_NUM_THREADS))
+#define OMP_PARALLEL_CLAUSE_MASK			\
+	( (1u << PRAGMA_OMP_CLAUSE_IF)			\
+	| (1u << PRAGMA_OMP_CLAUSE_PRIVATE)		\
+	| (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE)	\
+	| (1u << PRAGMA_OMP_CLAUSE_DEFAULT)		\
+	| (1u << PRAGMA_OMP_CLAUSE_SHARED)		\
+	| (1u << PRAGMA_OMP_CLAUSE_COPYIN)		\
+	| (1u << PRAGMA_OMP_CLAUSE_REDUCTION)		\
+	| (1u << PRAGMA_OMP_CLAUSE_NUM_THREADS))
 
 static tree
 c_parser_omp_parallel (location_t loc, c_parser *parser)
@@ -10148,13 +9705,13 @@
     {
       const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
       if (strcmp (p, "sections") == 0)
-    {
-      c_parser_consume_token (parser);
-      p_kind = PRAGMA_OMP_PARALLEL_SECTIONS;
-      p_name = "#pragma omp parallel sections";
-      mask |= OMP_SECTIONS_CLAUSE_MASK;
-      mask &= ~(1u << PRAGMA_OMP_CLAUSE_NOWAIT);
-    }
+	{
+	  c_parser_consume_token (parser);
+	  p_kind = PRAGMA_OMP_PARALLEL_SECTIONS;
+	  p_name = "#pragma omp parallel sections";
+	  mask |= OMP_SECTIONS_CLAUSE_MASK;
+	  mask &= ~(1u << PRAGMA_OMP_CLAUSE_NOWAIT);
+	}
     }
 
   clauses = c_parser_omp_all_clauses (parser, mask, p_name);
@@ -10180,7 +9737,7 @@
       c_split_parallel_clauses (loc, clauses, &par_clause, &ws_clause);
       stmt = c_parser_omp_sections_scope (loc, parser);
       if (stmt)
-    OMP_SECTIONS_CLAUSES (stmt) = ws_clause;
+	OMP_SECTIONS_CLAUSES (stmt) = ws_clause;
       stmt = c_finish_omp_parallel (loc, par_clause, block);
       OMP_PARALLEL_COMBINED (stmt) = 1;
       break;
@@ -10199,11 +9756,11 @@
    LOC is the location of the #pragma.
 */
 
-#define OMP_SINGLE_CLAUSE_MASK              \
-    ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE)     \
-    | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE)    \
-    | (1u << PRAGMA_OMP_CLAUSE_COPYPRIVATE)     \
-    | (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
+#define OMP_SINGLE_CLAUSE_MASK				\
+	( (1u << PRAGMA_OMP_CLAUSE_PRIVATE)		\
+	| (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE)	\
+	| (1u << PRAGMA_OMP_CLAUSE_COPYPRIVATE)		\
+	| (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
 
 static tree
 c_parser_omp_single (location_t loc, c_parser *parser)
@@ -10214,7 +9771,7 @@
 
   OMP_SINGLE_CLAUSES (stmt)
     = c_parser_omp_all_clauses (parser, OMP_SINGLE_CLAUSE_MASK,
-                "#pragma omp single");
+				"#pragma omp single");
   OMP_SINGLE_BODY (stmt) = c_parser_omp_structured_block (parser);
 
   return add_stmt (stmt);
@@ -10226,13 +9783,13 @@
    LOC is the location of the #pragma.
 */
 
-#define OMP_TASK_CLAUSE_MASK                \
-    ( (1u << PRAGMA_OMP_CLAUSE_IF)          \
-    | (1u << PRAGMA_OMP_CLAUSE_UNTIED)      \
-    | (1u << PRAGMA_OMP_CLAUSE_DEFAULT)     \
-    | (1u << PRAGMA_OMP_CLAUSE_PRIVATE)     \
-    | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE)    \
-    | (1u << PRAGMA_OMP_CLAUSE_SHARED))
+#define OMP_TASK_CLAUSE_MASK				\
+	( (1u << PRAGMA_OMP_CLAUSE_IF)			\
+	| (1u << PRAGMA_OMP_CLAUSE_UNTIED)		\
+	| (1u << PRAGMA_OMP_CLAUSE_DEFAULT)		\
+	| (1u << PRAGMA_OMP_CLAUSE_PRIVATE)		\
+	| (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE)	\
+	| (1u << PRAGMA_OMP_CLAUSE_SHARED))
 
 static tree
 c_parser_omp_task (location_t loc, c_parser *parser)
@@ -10240,7 +9797,7 @@
   tree clauses, block;
 
   clauses = c_parser_omp_all_clauses (parser, OMP_TASK_CLAUSE_MASK,
-                      "#pragma omp task");
+				      "#pragma omp task");
 
   block = c_begin_omp_task ();
   c_parser_statement (parser);
@@ -10331,36 +9888,36 @@
       tree v = TREE_PURPOSE (t);
 
       /* FIXME diagnostics: Ideally we should keep individual
-     locations for all the variables in the var list to make the
-     following errors more precise.  Perhaps
-     c_parser_omp_var_list_parens() should construct a list of
-     locations to go along with the var list.  */
+	 locations for all the variables in the var list to make the
+	 following errors more precise.  Perhaps
+	 c_parser_omp_var_list_parens() should construct a list of
+	 locations to go along with the var list.  */
 
       /* If V had already been marked threadprivate, it doesn't matter
-     whether it had been used prior to this point.  */
+	 whether it had been used prior to this point.  */
       if (TREE_CODE (v) != VAR_DECL)
-    error_at (loc, "%qD is not a variable", v);
+	error_at (loc, "%qD is not a variable", v);
       else if (TREE_USED (v) && !C_DECL_THREADPRIVATE_P (v))
-    error_at (loc, "%qE declared %<threadprivate%> after first use", v);
+	error_at (loc, "%qE declared %<threadprivate%> after first use", v);
       else if (! TREE_STATIC (v) && ! DECL_EXTERNAL (v))
-    error_at (loc, "automatic variable %qE cannot be %<threadprivate%>", v);
+	error_at (loc, "automatic variable %qE cannot be %<threadprivate%>", v);
       else if (TREE_TYPE (v) == error_mark_node)
-    ;
+	;
       else if (! COMPLETE_TYPE_P (TREE_TYPE (v)))
-    error_at (loc, "%<threadprivate%> %qE has incomplete type", v);
+	error_at (loc, "%<threadprivate%> %qE has incomplete type", v);
       else
-    {
-      if (! DECL_THREAD_LOCAL_P (v))
-        {
-          DECL_TLS_MODEL (v) = decl_default_tls_model (v);
-          /* If rtl has been already set for this var, call
-         make_decl_rtl once again, so that encode_section_info
-         has a chance to look at the new decl flags.  */
-          if (DECL_RTL_SET_P (v))
-        make_decl_rtl (v);
-        }
-      C_DECL_THREADPRIVATE_P (v) = 1;
-    }
+	{
+	  if (! DECL_THREAD_LOCAL_P (v))
+	    {
+	      DECL_TLS_MODEL (v) = decl_default_tls_model (v);
+	      /* If rtl has been already set for this var, call
+		 make_decl_rtl once again, so that encode_section_info
+		 has a chance to look at the new decl flags.  */
+	      if (DECL_RTL_SET_P (v))
+		make_decl_rtl (v);
+	    }
+	  C_DECL_THREADPRIVATE_P (v) = 1;
+	}
     }
 
   c_parser_skip_to_pragma_eol (parser);