CbC/CbC_gcc: gcc/c-parser.c comparison

comparison gcc/c-parser.c @ 70:b81903832de2

merge c-decl.c

author	Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
date	Sun, 21 Aug 2011 09:24:16 +0900
parents	1b10fe6932e1
children	e334828451cb

comparison

equal deleted inserted replaced

-:1b10fe6932e1
+:b81903832de2
 #include "c-family/c-common.h"
 #include "c-family/c-objc.h"
 #include "vec.h"
 #include "target.h"
 #include "cgraph.h"
-#ifndef noCbC
-#include "cbc-tree.h"
-#endif
 #include "plugin.h"
 /* Initialization routine for this file.  */
 mask |= D_C99;
 if (flag_no_asm)
 {
 mask |= D_ASM | D_EXT;
 if (!flag_isoc99)
-mask |= D_EXT89;
+	mask |= D_EXT89;
 }
 if (!c_dialect_objc ())
 mask |= D_OBJC | D_CXX_OBJC;
 ridpointers = ggc_alloc_cleared_vec_tree ((int) RID_MAX);
 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
+	  if (warn_cxx_compat
-&& (c_common_reswords[i].disable & D_CXXWARN))
+	      && (c_common_reswords[i].disable & D_CXXWARN))
-{
+	    {
-id = get_identifier (c_common_reswords[i].word);
+	      id = get_identifier (c_common_reswords[i].word);
-C_SET_RID_CODE (id, RID_CXX_COMPAT_WARN);
+	      C_SET_RID_CODE (id, RID_CXX_COMPAT_WARN);
-C_IS_RESERVED_WORD (id) = 1;
+	      C_IS_RESERVED_WORD (id) = 1;
-}
+	    }
-continue;
+	  continue;
-}
+	}
 id = get_identifier (c_common_reswords[i].word);
 C_SET_RID_CODE (id, c_common_reswords[i].rid);
 C_IS_RESERVED_WORD (id) = 1;
 ridpointers [(int) c_common_reswords[i].rid] = id;
 c_lex_one_token (c_parser *parser, c_token *token)
 {
 timevar_push (TV_LEX);
 token->type = c_lex_with_flags (&token->value, &token->location, NULL,
-(parser->lex_untranslated_string
+				  (parser->lex_untranslated_string
-? C_LEX_STRING_NO_TRANSLATE : 0));
+				   ? C_LEX_STRING_NO_TRANSLATE : 0));
 token->id_kind = C_ID_NONE;
 token->keyword = RID_MAX;
 token->pragma_kind = PRAGMA_NONE;
 switch (token->type)
 case CPP_COLON:
 case CPP_COMMA:
 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.  */
 token->pragma_kind = (enum pragma_kind) TREE_INT_CST_LOW (token->value);
 token->value = NULL;
 {
 switch (token->type)
 {
 case CPP_NAME:
 switch (token->id_kind)
-{
+	{
-case C_ID_ID:
+	case C_ID_ID:
-return false;
+	  return false;
-case C_ID_ADDRSPACE:
+	case C_ID_ADDRSPACE:
-return true;
+	  return true;
-case C_ID_TYPENAME:
+	case C_ID_TYPENAME:
-return true;
+	  return true;
-case C_ID_CLASSNAME:
+	case C_ID_CLASSNAME:
-gcc_assert (c_dialect_objc ());
+	  gcc_assert (c_dialect_objc ());
-return true;
+	  return true;
-default:
+	default:
-gcc_unreachable ();
+	  gcc_unreachable ();
-}
+	}
 case CPP_KEYWORD:
 switch (token->keyword)
 	{
 	case RID_UNSIGNED:
 	case RID_LONG:
 	default:
 	  return false;
 	}
 case CPP_LESS:
 if (c_dialect_objc ())
-return true;
+	return true;
 return false;
 default:
 return false;
 }
 }
 {
 switch (token->type)
 {
 case CPP_NAME:
 switch (token->id_kind)
-{
+	{
-case C_ID_ID:
+	case C_ID_ID:
-return false;
+	  return false;
-case C_ID_ADDRSPACE:
+	case C_ID_ADDRSPACE:
-return true;
+	  return true;
-case C_ID_TYPENAME:
+	case C_ID_TYPENAME:
-return true;
+	  return true;
-case C_ID_CLASSNAME:
+	case C_ID_CLASSNAME:
-gcc_assert (c_dialect_objc ());
+	  gcc_assert (c_dialect_objc ());
-return true;
+	  return true;
-default:
+	default:
-gcc_unreachable ();
+	  gcc_unreachable ();
-}
+	}
 case CPP_KEYWORD:
 switch (token->keyword)
 	{
 	case RID_STATIC:
 	case RID_EXTERN:
 	case RID_RESTRICT:
 	case RID_ATTRIBUTE:
 	case RID_FRACT:
 	case RID_ACCUM:
 	case RID_SAT:
-#ifndef noCbC
+	  return true;
-	case RID_CbC_CODE:
-#endif
-	return true;
 	default:
 	  return false;
 	}
 case CPP_LESS:
 if (c_dialect_objc ())
-return true;
+	return true;
 return false;
 default:
 return false;
 }
 }
 return;
 /* This diagnostic makes more sense if it is tagged to the line of
 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
+		 /* Because c_parse_error does not understand
-CPP_KEYWORD, keywords are treated like
+		    CPP_KEYWORD, keywords are treated like
-identifiers.  */
+		    identifiers.  */
-(token->type == CPP_KEYWORD ? CPP_NAME : token->type),
+		 (token->type == CPP_KEYWORD ? CPP_NAME : token->type),
-/* ??? The C parser does not save the cpp flags of a
+		 /* ??? The C parser does not save the cpp flags of a
-token, we need to pass 0 here and we will not get
+		    token, we need to pass 0 here and we will not get
-the source spelling of some tokens but rather the
+		    the source spelling of some tokens but rather the
-canonical spelling.  */
+		    canonical spelling.  */
-token->value, /*flags=*/0);
+		 token->value, /*flags=*/0);
 }
 /* If the next token is of the indicated TYPE, consume it.  Otherwise,
 issue the error MSGID.  If MSGID is NULL then a message has already
 been produced and no message will be produced this time.  Returns
 true if found, false otherwise.  */
 static bool
 c_parser_require (c_parser *parser,
-enum cpp_ttype type,
+		  enum cpp_ttype type,
-const char *msgid)
+		  const char *msgid)
 {
 if (c_parser_next_token_is (parser, type))
 {
 c_parser_consume_token (parser);
 return true;
 /* If the next token is the indicated keyword, consume it.  Otherwise,
 issue the error MSGID.  Returns true if found, false otherwise.  */
 static bool
 c_parser_require_keyword (c_parser *parser,
-enum rid keyword,
+			  enum rid keyword,
-const char *msgid)
+			  const char *msgid)
 {
 if (c_parser_next_token_is_keyword (parser, keyword))
 {
 c_parser_consume_token (parser);
 return true;
 already been produced and no message will be produced this
 time.  */
 static void
 c_parser_skip_until_found (c_parser *parser,
-enum cpp_ttype type,
+			   enum cpp_ttype type,
-const char *msgid)
+			   const char *msgid)
 {
 unsigned nesting_depth = 0;
 if (c_parser_require (parser, type, msgid))
 return;
 {
 /* Peek at the next token.  */
 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);
+	  c_parser_consume_token (parser);
-break;
+	  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_PAREN
-|| token->type == CPP_OPEN_SQUARE)
+	  || token->type == CPP_OPEN_SQUARE)
-++nesting_depth;
+	++nesting_depth;
 else if (token->type == CPP_CLOSE_BRACE
-|| token->type == CPP_CLOSE_PAREN
+	       || token->type == CPP_CLOSE_PAREN
-|| token->type == CPP_CLOSE_SQUARE)
+	       || token->type == CPP_CLOSE_SQUARE)
-{
+	{
-if (nesting_depth-- == 0)
+	  if (nesting_depth-- == 0)
-break;
+	    break;
-}
+	}
 /* Consume this token.  */
 c_parser_consume_token (parser);
 }
 parser->error = false;
 }
 while (true)
 {
 c_token *token = c_parser_peek_token (parser);
 if ((token->type == CPP_COMMA || token->type == CPP_SEMICOLON)
-&& !nesting_depth)
+	  && !nesting_depth)
-break;
+	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_PAREN
-|| token->type == CPP_OPEN_SQUARE)
+	  || token->type == CPP_OPEN_SQUARE)
-++nesting_depth;
+	++nesting_depth;
 else if (token->type == CPP_CLOSE_BRACE
-|| token->type == CPP_CLOSE_PAREN
+	       || token->type == CPP_CLOSE_PAREN
-|| token->type == CPP_CLOSE_SQUARE)
+	       || token->type == CPP_CLOSE_SQUARE)
-{
+	{
-if (nesting_depth-- == 0)
+	  if (nesting_depth-- == 0)
-break;
+	    break;
-}
+	}
 /* Consume this token.  */
 c_parser_consume_token (parser);
 }
 parser->error = false;
 }
 parser->in_pragma = false;
 if (!c_parser_require (parser, CPP_PRAGMA_EOL, "expected end of line"))
 while (true)
 {
-c_token *token = c_parser_peek_token (parser);
+	c_token *token = c_parser_peek_token (parser);
-if (token->type == CPP_EOF)
+	if (token->type == CPP_EOF)
-break;
+	  break;
-if (token->type == CPP_PRAGMA_EOL)
+	if (token->type == CPP_PRAGMA_EOL)
-{
+	  {
-c_parser_consume_token (parser);
+	    c_parser_consume_token (parser);
-break;
+	    break;
-}
+	  }
-c_parser_consume_token (parser);
+	c_parser_consume_token (parser);
 }
 parser->error = false;
 }
 /* Peek at the next token.  */
 token = c_parser_peek_token (parser);
 switch (token->type)
-{
+	{
-case CPP_EOF:
+	case CPP_EOF:
-return;
+	  return;
-case CPP_PRAGMA_EOL:
+	case CPP_PRAGMA_EOL:
-if (parser->in_pragma)
+	  if (parser->in_pragma)
-return;
+	    return;
-break;
+	  break;
-case CPP_SEMICOLON:
+	case CPP_SEMICOLON:
-/* If the next token is a ';', we have reached the
+	  /* If the next token is a ';', we have reached the
-end of the statement.  */
+	     end of the statement.  */
-if (!nesting_depth)
+	  if (!nesting_depth)
-{
+	    {
-/* Consume the ';'.  */
+	      /* Consume the ';'.  */
-c_parser_consume_token (parser);
+	      c_parser_consume_token (parser);
-goto finished;
+	      goto finished;
-}
+	    }
-break;
+	  break;
-case CPP_CLOSE_BRACE:
+	case CPP_CLOSE_BRACE:
-/* If the next token is a non-nested '}', then we have
+	  /* If the next token is a non-nested '}', then we have
-reached the end of the current block.  */
+	     reached the end of the current block.  */
-if (nesting_depth == 0 || --nesting_depth == 0)
+	  if (nesting_depth == 0 || --nesting_depth == 0)
-{
+	    {
-c_parser_consume_token (parser);
+	      c_parser_consume_token (parser);
-goto finished;
+	      goto finished;
-}
+	    }
-break;
+	  break;
-case CPP_OPEN_BRACE:
+	case CPP_OPEN_BRACE:
-/* If it the next token is a '{', then we are entering a new
+	  /* If it the next token is a '{', then we are entering a new
-block.  Consume the entire block.  */
+	     block.  Consume the entire block.  */
-++nesting_depth;
+	  ++nesting_depth;
-break;
+	  break;
-case CPP_PRAGMA:
+	case CPP_PRAGMA:
-/* If we see a pragma, consume the whole thing at once.  We
+	  /* If we see a pragma, consume the whole thing at once.  We
-have some safeguards against consuming pragmas willy-nilly.
+	     have some safeguards against consuming pragmas willy-nilly.
-Normally, we'd expect to be here with parser->error set,
+	     Normally, we'd expect to be here with parser->error set,
-which disables these safeguards.  But it's possible to get
+	     which disables these safeguards.  But it's possible to get
-here for secondary error recovery, after parser->error has
+	     here for secondary error recovery, after parser->error has
-been cleared.  */
+	     been cleared.  */
-c_parser_consume_pragma (parser);
+	  c_parser_consume_pragma (parser);
-c_parser_skip_to_pragma_eol (parser);
+	  c_parser_skip_to_pragma_eol (parser);
-parser->error = save_error;
+	  parser->error = save_error;
-continue;
+	  continue;
-default:
+	default:
-break;
+	  break;
-}
+	}
 c_parser_consume_token (parser);
 }
 finished:
 static struct c_typespec c_parser_enum_specifier (c_parser *);
 static struct c_typespec c_parser_struct_or_union_specifier (c_parser *);
 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,
+							      bool,
-struct c_declarator *);
+							      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);
 static tree c_parser_simple_asm_expr (c_parser *);
 static tree c_parser_attributes (c_parser *);
 static tree c_parser_asm_operands (c_parser *, bool);
 static tree c_parser_asm_goto_operands (c_parser *);
 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 *);
 static struct c_expr c_parser_sizeof_expression (c_parser *);
 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 *,
+								   struct c_type_name *,
-location_t);
+								   location_t);
 static struct c_expr c_parser_postfix_expression_after_primary (c_parser *,
-location_t loc,
+								location_t loc,
-struct c_expr);
+								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 *);
 static void c_parser_omp_flush (c_parser *);
 static void c_parser_omp_taskwait (c_parser *);
 c_parser_translation_unit (c_parser *parser)
 {
 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 ();
+	  ggc_collect ();
-c_parser_external_declaration (parser);
+	  c_parser_external_declaration (parser);
-obstack_free (&parser_obstack, obstack_position);
+	  obstack_free (&parser_obstack, obstack_position);
-}
+	}
 while (c_parser_next_token_is_not (parser, CPP_EOF));
 }
 }
 /* Parse an external declaration (C90 6.7, C99 6.9).
 	  goto decl_or_fndef;
 	}
 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:
 mark_valid_location_for_stdc_pragma (true);
 c_parser_pragma (parser, pragma_external);
 mark_valid_location_for_stdc_pragma (false);
 break;
 case CPP_PLUS:
 case CPP_MINUS:
 if (c_dialect_objc ())
-{
+	{
-c_parser_objc_method_definition (parser);
+	  c_parser_objc_method_definition (parser);
-break;
+	  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,
 	 an @interface or @protocol with prefix attributes).  We can
 	 only tell which after parsing the declaration specifiers, if
 }
 finish_declspecs (specs);
 if (c_parser_next_token_is (parser, CPP_SEMICOLON))
 {
 if (empty_ok)
-shadow_tag (specs);
+	shadow_tag (specs);
 else
-{
+	{
-shadow_tag_warned (specs, 1);
+	  shadow_tag_warned (specs, 1);
-pedwarn (here, 0, "empty declaration");
+	  pedwarn (here, 0, "empty declaration");
-}
+	}
 c_parser_consume_token (parser);
 return;
 }
 /* Provide better error recovery.  Note that a type name here is usually
 	 implicit int suffices).  */
 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);
+	  c_parser_skip_to_end_of_block_or_statement (parser);
-return;
+	  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)
 	  || c_parser_next_token_is_keyword (parser, RID_ASM)
 	  || c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE)
 	      c_parser_skip_to_end_of_block_or_statement (parser);
 	      return;
 	    }
 	}
 else if (!fndef_ok)
-{
+	{
-c_parser_error (parser, "expected %<=%>, %<,%>, %<;%>, "
+	  c_parser_error (parser, "expected %<=%>, %<,%>, %<;%>, "
-"%<asm%> or %<__attribute__%>");
+			  "%<asm%> or %<__attribute__%>");
-c_parser_skip_to_end_of_block_or_statement (parser);
+	  c_parser_skip_to_end_of_block_or_statement (parser);
-return;
+	  return;
-}
+	}
 /* Function definition (nested or otherwise).  */
 if (nested)
-{
+	{
-pedwarn (here, OPT_pedantic, "ISO C forbids nested functions");
+	  pedwarn (here, OPT_pedantic, "ISO C forbids nested functions");
-c_push_function_context ();
+	  c_push_function_context ();
-}
+	}
 if (!start_function (specs, declarator, all_prefix_attrs))
-{
+	{
-/* This can appear in many cases looking nothing like a
+	  /* This can appear in many cases looking nothing like a
-function definition, so we don't give a more specific
+	     function definition, so we don't give a more specific
-error suggesting there was one.  */
+	     error suggesting there was one.  */
-c_parser_error (parser, "expected %<=%>, %<,%>, %<;%>, %<asm%> "
+	  c_parser_error (parser, "expected %<=%>, %<,%>, %<;%>, %<asm%> "
-"or %<__attribute__%>");
+			  "or %<__attribute__%>");
-if (nested)
+	  if (nested)
-c_pop_function_context ();
+	    c_pop_function_context ();
-break;
+	  break;
-}
+	}
 /* Parse old-style parameter declarations.  ??? Attributes are
-not allowed to start declaration specifiers here because of a
+	 not allowed to start declaration specifiers here because of a
-syntax conflict between a function declaration with attribute
+	 syntax conflict between a function declaration with attribute
-suffix and a function definition with an attribute prefix on
+	 suffix and a function definition with an attribute prefix on
-first old-style parameter declaration.  Following the old
+	 first old-style parameter declaration.  Following the old
-parser, they are not accepted on subsequent old-style
+	 parser, they are not accepted on subsequent old-style
-parameter declarations either.  However, there is no
+	 parameter declarations either.  However, there is no
-ambiguity after the first declaration, nor indeed on the
+	 ambiguity after the first declaration, nor indeed on the
-first as long as we don't allow postfix attributes after a
+	 first as long as we don't allow postfix attributes after a
-declarator with a nonempty identifier list in a definition;
+	 declarator with a nonempty identifier list in a definition;
-and postfix attributes have never been accepted here in
+	 and postfix attributes have never been accepted here in
-function definitions either.  */
+	 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;
+	  tree decl = current_function_decl;
-/* Mark nested functions as needing static-chain initially.
+	  /* Mark nested functions as needing static-chain initially.
-lower_nested_functions will recompute it but the
+	     lower_nested_functions will recompute it but the
-DECL_STATIC_CHAIN flag is also used before that happens,
+	     DECL_STATIC_CHAIN flag is also used before that happens,
-by initializer_constant_valid_p.  See gcc.dg/nested-fn-2.c.  */
+	     by initializer_constant_valid_p.  See gcc.dg/nested-fn-2.c.  */
-DECL_STATIC_CHAIN (decl) = 1;
+	  DECL_STATIC_CHAIN (decl) = 1;
-add_stmt (fnbody);
+	  add_stmt (fnbody);
-finish_function ();
+	  finish_function ();
-c_pop_function_context ();
+	  c_pop_function_context ();
-add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl), DECL_EXPR, decl));
+	  add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl), DECL_EXPR, decl));
-}
+	}
 else
-{
+	{
-add_stmt (fnbody);
+	  add_stmt (fnbody);
-finish_function ();
+	  finish_function ();
-}
+	}
 break;
 }
 }
 /* Parse an asm-definition (asm() outside a function body).  This is a
 if (!typespec_ok)
 gcc_assert (la == cla_prefer_id);
 while (c_parser_next_token_is (parser, CPP_NAME)
-|| c_parser_next_token_is (parser, CPP_KEYWORD)
+	 || c_parser_next_token_is (parser, CPP_KEYWORD)
-|| (c_dialect_objc () && c_parser_next_token_is (parser, CPP_LESS)))
+	 || (c_dialect_objc () && c_parser_next_token_is (parser, CPP_LESS)))
 {
 struct c_typespec t;
 tree attrs;
 location_t loc = c_parser_peek_token (parser)->location;
 	  t.expr_const_operands = true;
 	  declspecs_add_type (loc, specs, t);
 	  continue;
 	}
 if (c_parser_next_token_is (parser, CPP_LESS))
-{
+	{
-/* Make "<SomeProtocol>" equivalent to "id <SomeProtocol>" -
+	  /* Make "<SomeProtocol>" equivalent to "id <SomeProtocol>" -
-nisse@lysator.liu.se.  */
+	     nisse@lysator.liu.se.  */
-tree proto;
+	  tree proto;
-gcc_assert (c_dialect_objc ());
+	  gcc_assert (c_dialect_objc ());
-if (!typespec_ok || seen_type)
+	  if (!typespec_ok || seen_type)
-break;
+	    break;
-proto = c_parser_objc_protocol_refs (parser);
+	  proto = c_parser_objc_protocol_refs (parser);
-t.kind = ctsk_objc;
+	  t.kind = ctsk_objc;
-t.spec = objc_get_protocol_qualified_type (NULL_TREE, proto);
+	  t.spec = objc_get_protocol_qualified_type (NULL_TREE, proto);
-t.expr = NULL_TREE;
+	  t.expr = NULL_TREE;
-t.expr_const_operands = true;
+	  t.expr_const_operands = true;
-declspecs_add_type (loc, specs, t);
+	  declspecs_add_type (loc, specs, t);
-continue;
+	  continue;
-}
+	}
 gcc_assert (c_parser_next_token_is (parser, CPP_KEYWORD));
 switch (c_parser_peek_token (parser)->keyword)
 	{
 	case RID_STATIC:
 	case RID_EXTERN:
 	  t.expr = NULL_TREE;
 	  t.expr_const_operands = true;
 	  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;
 	  attrs_ok = true;
 	  seen_type = true;
 	    goto out;
 	  attrs_ok = true;
 	  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);
+	  declspecs_add_type (loc, specs, t);
-break;
+	  break;
-case RID_TYPEOF:
+	case RID_TYPEOF:
-/* ??? The old parser rejected typeof after other type
+	  /* ??? The old parser rejected typeof after other type
-specifiers, but is a syntax error the best way of
+	     specifiers, but is a syntax error the best way of
-handling this?  */
+	     handling this?  */
-if (!typespec_ok || seen_type)
+	  if (!typespec_ok || seen_type)
-goto out;
+	    goto out;
-attrs_ok = true;
+	  attrs_ok = true;
-seen_type = true;
+	  seen_type = true;
-t = c_parser_typeof_specifier (parser);
+	  t = c_parser_typeof_specifier (parser);
-declspecs_add_type (loc, specs, t);
+	  declspecs_add_type (loc, specs, t);
-break;
+	  break;
-case RID_CONST:
+	case RID_CONST:
-case RID_VOLATILE:
+	case RID_VOLATILE:
-case RID_RESTRICT:
+	case RID_RESTRICT:
-attrs_ok = true;
+	  attrs_ok = true;
-declspecs_add_qual (specs, c_parser_peek_token (parser)->value);
+	  declspecs_add_qual (specs, c_parser_peek_token (parser)->value);
-c_parser_consume_token (parser);
+	  c_parser_consume_token (parser);
-break;
+	  break;
-case RID_ATTRIBUTE:
+	case RID_ATTRIBUTE:
-if (!attrs_ok)
+	  if (!attrs_ok)
-goto out;
+	    goto out;
-attrs = c_parser_attributes (parser);
+	  attrs = c_parser_attributes (parser);
-declspecs_add_attrs (specs, attrs);
+	  declspecs_add_attrs (specs, attrs);
-break;
+	  break;
-default:
+	default:
-goto out;
+	  goto out;
-}
+	}
 }
 out: ;
 }
 /* Parse an enum specifier (C90 6.5.2.2, C99 6.7.2.2).
 /* Parse an enum definition.  */
 struct c_enum_contents the_enum;
 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)
 	{
 	  tree enum_id;
 	      break;
 	    }
 	}
 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;
 return ret;
 }
 defined.  */
 if (pedantic && !COMPLETE_TYPE_P (ret.spec))
 {
 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;
 }
 /* Parse a struct or union specifier (C90 6.5.2.1, C99 6.7.2.1).
 c_parser_consume_token (parser);
 }
 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
+	 forward order at the end.  Each struct-declaration may
-declare multiple components (comma-separated), so we must use
+	 declare multiple components (comma-separated), so we must use
-chainon to join them, although when parsing each
+	 chainon to join them, although when parsing each
-struct-declaration we can use TREE_CHAIN directly.
+	 struct-declaration we can use TREE_CHAIN directly.
-The theory behind all this is that there will be more
+	 The theory behind all this is that there will be more
-semicolon separated fields than comma separated fields, and
+	 semicolon separated fields than comma separated fields, and
-so we'll be minimizing the number of node traversals required
+	 so we'll be minimizing the number of node traversals required
-by chainon.  */
+	 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;
+	  tree name;
-gcc_assert (c_dialect_objc ());
+	  gcc_assert (c_dialect_objc ());
-c_parser_consume_token (parser);
+	  c_parser_consume_token (parser);
-if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
+	  if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
-goto end_at_defs;
+	    goto end_at_defs;
-if (c_parser_next_token_is (parser, CPP_NAME)
+	  if (c_parser_next_token_is (parser, CPP_NAME)
-&& c_parser_peek_token (parser)->id_kind == C_ID_CLASSNAME)
+	      && c_parser_peek_token (parser)->id_kind == C_ID_CLASSNAME)
-{
+	    {
-name = c_parser_peek_token (parser)->value;
+	      name = c_parser_peek_token (parser)->value;
-c_parser_consume_token (parser);
+	      c_parser_consume_token (parser);
-}
+	    }
-else
+	  else
-{
+	    {
-c_parser_error (parser, "expected class name");
+	      c_parser_error (parser, "expected class name");
-c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
+	      c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
-goto end_at_defs;
+	      goto end_at_defs;
-}
+	    }
-c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
+	  c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
-"expected %<)%>");
+				     "expected %<)%>");
-contents = nreverse (objc_get_class_ivars (name));
+	  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
+	 semicolons are diagnosed here; empty structures are diagnosed
-elsewhere.  */
+	 elsewhere.  */
 while (true)
 	{
 	  tree decls;
 	  /* Parse any stray semicolon.  */
 	  if (c_parser_next_token_is (parser, CPP_SEMICOLON))
 	         recovered already.  Go on with the next field. */
 	    }
 	}
 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;
 return ret;
 }
 		   "ISO C forbids member declarations with no members");
 	  shadow_tag_warned (specs, pedantic);
 	  ret = NULL_TREE;
 	}
 else
-{
+	{
-/* Support for unnamed structs or unions as members of
+	  /* Support for unnamed structs or unions as members of
-structs or unions (which is [a] useful and [b] supports
+	     structs or unions (which is [a] useful and [b] supports
-MS P-SDK).  */
+	     MS P-SDK).  */
-tree attrs = NULL;
+	  tree attrs = NULL;
-ret = grokfield (c_parser_peek_token (parser)->location,
+	  ret = grokfield (c_parser_peek_token (parser)->location,
-build_id_declarator (NULL_TREE), specs,
+			   build_id_declarator (NULL_TREE), specs,
-NULL_TREE, &attrs);
+			   NULL_TREE, &attrs);
-if (ret)
+	  if (ret)
-decl_attributes (&ret, attrs, 0);
+	    decl_attributes (&ret, attrs, 0);
-}
+	}
 return ret;
 }
 /* Provide better error recovery.  Note that a type name here is valid,
 and will be treated as a field name.  */
 {
 /* Declaring one or more declarators or un-named bit-fields.  */
 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);
+	  c_parser_skip_to_end_of_block_or_statement (parser);
-break;
+	  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)
 	  || c_parser_next_token_is (parser, CPP_CLOSE_BRACE)
 	  || c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
 	      c_parser_error (parser, "expected %<,%>, %<;%> or %<}%>");
 	      break;
 	    }
 	}
 else
-all_prefix_attrs = prefix_attrs;
+	{
-if (c_parser_next_token_is (parser, CPP_COMMA))
+	  c_parser_error (parser,
-c_parser_consume_token (parser);
+			  "expected %<:%>, %<,%>, %<;%>, %<}%> or "
-else if (c_parser_next_token_is (parser, CPP_SEMICOLON)
+			  "%<__attribute__%>");
-|| c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
+	  break;
-{
+	}
-/* Semicolon consumed in caller.  */
-break;
-}
-else
-{
-c_parser_error (parser, "expected %<,%>, %<;%> or %<}%>");
-break;
-}
-}
-else
-{
-c_parser_error (parser,
-"expected %<:%>, %<,%>, %<;%>, %<}%> or "
-"%<__attribute__%>");
-break;
-}
 }
 return decls;
 }
 /* Parse a typeof specifier (a GNU extension).
 {
 struct c_type_name *type = c_parser_type_name (parser);
 c_inhibit_evaluation_warnings--;
 in_typeof--;
 if (type != NULL)
-{
+	{
-ret.spec = groktypename (type, &ret.expr, &ret.expr_const_operands);
+	  ret.spec = groktypename (type, &ret.expr, &ret.expr_const_operands);
-pop_maybe_used (variably_modified_type_p (ret.spec, NULL_TREE));
+	  pop_maybe_used (variably_modified_type_p (ret.spec, NULL_TREE));
-}
+	}
 }
 else
 {
 bool was_vm;
 location_t here = c_parser_peek_token (parser)->location;
 	error_at (here, "%<typeof%> applied to a bit-field");
 mark_exp_read (expr.value);
 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 %<)%>");
 return ret;
 }
 GNU extensions:
 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 ;
 parameter-forward-declarations parameter-list ;
 This function also accepts an omitted abstract declarator as being
 an abstract declarator, although not part of the formal syntax.  */
 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))
 {
 struct c_declspecs *quals_attrs = build_null_declspecs ();
 struct c_declarator *inner;
 c_parser_consume_token (parser);
 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).  */
 return c_parser_direct_declarator (parser, type_seen_p, kind, seen_id);
 }
 /* Parse a direct declarator or direct abstract declarator; arguments
 as c_parser_declarator.  */
 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
 an ordinary declarator, initial parentheses must start a
 parenthesized declarator.  In an abstract declarator or parameter
 	   && (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_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);
 return c_parser_direct_declarator_inner (parser, *seen_id, inner);
 }
 tree attrs;
 struct c_declarator *inner;
 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_starts_declspecs (parser)
-|| c_parser_next_token_is (parser, CPP_CLOSE_PAREN)))
+	      || c_parser_next_token_is (parser, CPP_CLOSE_PAREN)))
-{
+	{
-struct c_arg_info *args
+	  struct c_arg_info *args
-= c_parser_parms_declarator (parser, kind == C_DTR_NORMAL,
+	    = c_parser_parms_declarator (parser, kind == C_DTR_NORMAL,
-attrs);
+					 attrs);
-if (args == NULL)
+	  if (args == NULL)
-return NULL;
+	    return NULL;
-else
+	  else
-{
+	    {
-inner
+	      inner
-= build_function_declarator (args,
+		= build_function_declarator (args,
-build_id_declarator (NULL_TREE));
+					     build_id_declarator (NULL_TREE));
-return c_parser_direct_declarator_inner (parser, *seen_id,
+	      return c_parser_direct_declarator_inner (parser, *seen_id,
-inner);
+						       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);
+	  c_parser_consume_token (parser);
-if (inner == NULL)
+	  if (inner == NULL)
-return 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);
+	{
-}
+	  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;
+	}
 else
-{
+	return build_id_declarator (NULL_TREE);
-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;
-}
-else
-return build_id_declarator (NULL_TREE);
 }
 }
 /* Parse part of a direct declarator or direct abstract declarator,
 given that some (in INNER) has already been parsed; ID_PRESENT is
 true if an identifier is present, false for an abstract
 declarator.  */
 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))
 {
 location_t brace_loc = c_parser_peek_token (parser)->location;
 tree dimen;
 c_parser_consume_token (parser);
 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
+	 Otherwise, there may be a dimension, "*", or no
-dimension.  */
+	 dimension.  */
 if (static_seen)
-{
+	{
-star_seen = false;
+	  star_seen = false;
-dimen = c_parser_expr_no_commas (parser, NULL).value;
+	  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))
-{
+	c_parser_consume_token (parser);
-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
 	{
 	  c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
 				     "expected %<]%>");
 	  return NULL;
 	}
 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);
 }
 else if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
 {
 struct c_arg_info *args;
 c_parser_consume_token (parser);
 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);
+	  inner = build_function_declarator (args, inner);
-return c_parser_direct_declarator_inner (parser, id_present, inner);
+	  return c_parser_direct_declarator_inner (parser, id_present, inner);
-}
+	}
 }
 return inner;
 }
 /* Parse a parameter list or identifier list, including the closing
 && c_parser_peek_2nd_token (parser)->type != CPP_OPEN_PAREN
 && c_parser_peek_2nd_token (parser)->type != CPP_OPEN_SQUARE)
 {
 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)
+	     && c_parser_peek_token (parser)->id_kind == C_ID_ID)
-{
+	{
-*nextp = build_tree_list (NULL_TREE,
+	  *nextp = build_tree_list (NULL_TREE,
-c_parser_peek_token (parser)->value);
+				    c_parser_peek_token (parser)->value);
-nextp = & TREE_CHAIN (*nextp);
+	  nextp = & TREE_CHAIN (*nextp);
-c_parser_consume_token (parser);
+	  c_parser_consume_token (parser);
-if (c_parser_next_token_is_not (parser, CPP_COMMA))
+	  if (c_parser_next_token_is_not (parser, CPP_COMMA))
-break;
+	    break;
-c_parser_consume_token (parser);
+	  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 ();
 	  ret->types = list;
 	  c_parser_consume_token (parser);
 	  pop_scope ();
 	  return ret;
 	}
 else
-{
+	{
-c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
+	  c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
-"expected %<)%>");
+				     "expected %<)%>");
-pop_scope ();
+	  pop_scope ();
-return NULL;
+	  return NULL;
-}
+	}
 }
 else
 {
 struct c_arg_info *ret = c_parser_parms_list_declarator (parser, attrs);
 pop_scope ();
 {
 struct c_arg_info *ret = build_arg_info ();
 /* 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);
+	  c_parser_consume_token (parser);
-return ret;
+	  return ret;
-}
+	}
 else
-{
+	{
-c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
+	  c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
-"expected %<)%>");
+				     "expected %<)%>");
-return NULL;
+	  return NULL;
-}
+	}
 }
 /* Nonempty list of parameters, either terminated with semicolon
 (forward declarations; recurse) or with close parenthesis (normal
 function) or with ", ... )" (variadic function).  */
 while (true)
 if (parm == NULL)
 	bad_parm = true;
 else
 	push_parm_decl (parm);
 if (c_parser_next_token_is (parser, CPP_SEMICOLON))
-{
+	{
-tree new_attrs;
+	  tree new_attrs;
-c_parser_consume_token (parser);
+	  c_parser_consume_token (parser);
-mark_forward_parm_decls ();
+	  mark_forward_parm_decls ();
-new_attrs = c_parser_attributes (parser);
+	  new_attrs = c_parser_attributes (parser);
-return c_parser_parms_list_declarator (parser, new_attrs);
+	  return c_parser_parms_list_declarator (parser, new_attrs);
-}
+	}
 if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
 	{
 	  c_parser_consume_token (parser);
 	  if (bad_parm)
 	    {
 	    }
 	  else
 	    return get_parm_info (false);
 	}
 if (!c_parser_require (parser, CPP_COMMA,
-"expected %<;%>, %<,%> or %<)%>"))
+			     "expected %<;%>, %<,%> or %<)%>"))
-{
+	{
-c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
+	  c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
-get_pending_sizes ();
+	  get_pending_sizes ();
-return NULL;
+	  return NULL;
-}
+	}
 if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
 	{
 	  c_parser_consume_token (parser);
 	  if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
 	    {
 return NULL;
 }
 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
 translated, and wide string literals are an error although
 permitted by the syntax.  This is a GNU extension.
 c_parser_consume_token (parser);
 }
 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);
 }
 else
 {
 {
 tree attrs = NULL_TREE;
 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;
+	  parser->lex_untranslated_string = false;
-return attrs;
+	  return attrs;
-}
+	}
 if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
-{
+	{
-parser->lex_untranslated_string = false;
+	  parser->lex_untranslated_string = false;
-c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
+	  c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
-return attrs;
+	  return attrs;
-}
+	}
 /* Parse the attribute list.  */
 while (c_parser_next_token_is (parser, CPP_COMMA)
 	     || c_parser_next_token_is (parser, CPP_NAME)
 	     || c_parser_next_token_is (parser, CPP_KEYWORD))
 	{
 	      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;
+	  parser->lex_untranslated_string = false;
-c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
+	  c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
-"expected %<)%>");
+				     "expected %<)%>");
-return attrs;
+	  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;
+	  parser->lex_untranslated_string = false;
-c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
+	  c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
-"expected %<)%>");
+				     "expected %<)%>");
-return attrs;
+	  return attrs;
-}
+	}
-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;
-}
 parser->lex_untranslated_string = false;
 }
 return attrs;
 }
 pedwarn (brace_loc, OPT_pedantic, "ISO C forbids empty initializer braces");
 }
 else
 {
 /* Parse a non-empty initializer list, possibly with a trailing
-comma.  */
+	 comma.  */
 while (true)
 	{
 	  c_parser_initelt (parser, &braced_init_obstack);
 	  if (parser->error)
 	    break;
 /* Old-style structure member designator.  */
 set_init_label (c_parser_peek_token (parser)->value,
 		      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.  */
 while (c_parser_next_token_is (parser, CPP_OPEN_SQUARE)
 	     || c_parser_next_token_is (parser, CPP_DOT))
 location_t brace_loc;
 brace_loc = c_parser_peek_token (parser)->location;
 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;
 }
 stmt = c_begin_compound_stmt (true);
 }
 mark_valid_location_for_stdc_pragma (true);
 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;
+	  label_loc = c_parser_peek_token (parser)->location;
-c_parser_consume_token (parser);
+	  c_parser_consume_token (parser);
-/* Any identifiers, including those declared as type names,
+	  /* Any identifiers, including those declared as type names,
-are OK here.  */
+	     are OK here.  */
-while (true)
+	  while (true)
-{
+	    {
-tree label;
+	      tree label;
-if (c_parser_next_token_is_not (parser, CPP_NAME))
+	      if (c_parser_next_token_is_not (parser, CPP_NAME))
-{
+		{
-c_parser_error (parser, "expected identifier");
+		  c_parser_error (parser, "expected identifier");
-break;
+		  break;
-}
+		}
-label
+	      label
-= declare_label (c_parser_peek_token (parser)->value);
+		= declare_label (c_parser_peek_token (parser)->value);
-C_DECLARED_LABEL_FLAG (label) = 1;
+	      C_DECLARED_LABEL_FLAG (label) = 1;
-add_stmt (build_stmt (label_loc, DECL_EXPR, label));
+	      add_stmt (build_stmt (label_loc, DECL_EXPR, label));
-c_parser_consume_token (parser);
+	      c_parser_consume_token (parser);
-if (c_parser_next_token_is (parser, CPP_COMMA))
+	      if (c_parser_next_token_is (parser, CPP_COMMA))
-c_parser_consume_token (parser);
+		c_parser_consume_token (parser);
-else
+	      else
-break;
+		break;
-}
+	    }
-c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
+	  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.  */
 if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
 {
 }
 while (c_parser_next_token_is_not (parser, CPP_CLOSE_BRACE))
 {
 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_keyword (parser, RID_DEFAULT)
-|| (c_parser_next_token_is (parser, CPP_NAME)
+	  || (c_parser_next_token_is (parser, CPP_NAME)
-&& c_parser_peek_2nd_token (parser)->type == CPP_COLON))
+	      && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
-{
+	{
-if (c_parser_next_token_is_keyword (parser, RID_CASE))
+	  if (c_parser_next_token_is_keyword (parser, RID_CASE))
-label_loc = c_parser_peek_2nd_token (parser)->location;
+	    label_loc = c_parser_peek_2nd_token (parser)->location;
-else
+	  else
-label_loc = c_parser_peek_token (parser)->location;
+	    label_loc = c_parser_peek_token (parser)->location;
-last_label = true;
+	  last_label = true;
-last_stmt = false;
+	  last_stmt = false;
-mark_valid_location_for_stdc_pragma (false);
+	  mark_valid_location_for_stdc_pragma (false);
-c_parser_label (parser);
+	  c_parser_label (parser);
-}
+	}
 else if (!last_label
 	       && c_parser_next_tokens_start_declaration (parser))
 	{
 	  last_label = false;
 	  mark_valid_location_for_stdc_pragma (false);
 	    }
 	  else
 	    goto statement;
 	}
 else if (c_parser_next_token_is (parser, CPP_PRAGMA))
-{
+	{
-/* External pragmas, and some omp pragmas, are not associated
+	  /* External pragmas, and some omp pragmas, are not associated
-with regular c code, and so are not to be considered statements
+	     with regular c code, and so are not to be considered statements
-syntactically.  This ensures that the user doesn't put them
+	     syntactically.  This ensures that the user doesn't put them
-places that would turn into syntax errors if the directive
+	     places that would turn into syntax errors if the directive
-were ignored.  */
+	     were ignored.  */
-if (c_parser_pragma (parser, pragma_compound))
+	  if (c_parser_pragma (parser, pragma_compound))
-last_label = false, last_stmt = true;
+	    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);
+	  mark_valid_location_for_stdc_pragma (save_valid_for_pragma);
-c_parser_error (parser, "expected declaration or statement");
+	  c_parser_error (parser, "expected declaration or statement");
-return;
+	  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;
 }
 else
 {
 c_parser_consume_token (parser);
 continue;
 }
 }
 else
-{
+	{
-statement:
+	statement:
-last_label = false;
+	  last_label = false;
-last_stmt = true;
+	  last_stmt = true;
-mark_valid_location_for_stdc_pragma (false);
+	  mark_valid_location_for_stdc_pragma (false);
-c_parser_statement_after_labels (parser);
+	  c_parser_statement_after_labels (parser);
-}
+	}
 parser->error = false;
 }
 if (last_label)
 error_at (label_loc, "label at end of compound statement");
 {
 tree exp1, exp2;
 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);
+	  c_parser_consume_token (parser);
-label = do_case (loc1, exp1, NULL_TREE);
+	  label = do_case (loc1, exp1, NULL_TREE);
-}
+	}
 else if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
-{
+	{
-c_parser_consume_token (parser);
+	  c_parser_consume_token (parser);
-exp2 = c_parser_expr_no_commas (parser, NULL).value;
+	  exp2 = c_parser_expr_no_commas (parser, NULL).value;
-if (c_parser_require (parser, CPP_COLON, "expected %<:%>"))
+	  if (c_parser_require (parser, CPP_COLON, "expected %<:%>"))
-label = do_case (loc1, exp1, exp2);
+	    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
 {
 tree name = c_parser_peek_token (parser)->value;
 tree tlab;
 gcc_assert (c_parser_next_token_is (parser, CPP_COLON));
 c_parser_consume_token (parser);
 attrs = c_parser_attributes (parser);
 tlab = define_label (loc2, name);
 if (tlab)
-{
+	{
-decl_attributes (&tlab, attrs, 0);
+	  decl_attributes (&tlab, attrs, 0);
-label = add_stmt (build_stmt (loc1, LABEL_EXPR, tlab));
+	  label = add_stmt (build_stmt (loc1, LABEL_EXPR, tlab));
-}
+	}
 }
 if (label)
 {
 if (c_parser_next_tokens_start_declaration (parser))
 	{
 static void
 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_keyword (parser, RID_DEFAULT)
-|| (c_parser_next_token_is (parser, CPP_NAME)
+	 || (c_parser_next_token_is (parser, CPP_NAME)
-&& c_parser_peek_2nd_token (parser)->type == CPP_COLON))
+	     && 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;
 parser->in_if_block = false;
 switch (c_parser_peek_token (parser)->type)
 	case RID_FOR:
 	  c_parser_for_statement (parser);
 	  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);
 	    }
 	  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);
 	  goto expect_semicolon;
 	case RID_BREAK:
 c_parser_consume_token (parser);
 break;
 case CPP_CLOSE_PAREN:
 case CPP_CLOSE_SQUARE:
 /* Avoid infinite loop in error recovery:
-c_parser_skip_until_found stops at a closing nesting
+	 c_parser_skip_until_found stops at a closing nesting
-delimiter without consuming it, but here we need to consume
+	 delimiter without consuming it, but here we need to consume
-it to proceed further.  */
+	 it to proceed further.  */
 c_parser_error (parser, "expected statement");
 c_parser_consume_token (parser);
 break;
 case CPP_PRAGMA:
 c_parser_pragma (parser, pragma_stmt);
 c_parser_if_body (c_parser *parser, bool *if_p)
 {
 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_keyword (parser, RID_DEFAULT)
-|| (c_parser_next_token_is (parser, CPP_NAME)
+	 || (c_parser_next_token_is (parser, CPP_NAME)
-&& c_parser_peek_2nd_token (parser)->type == CPP_COLON))
+	     && 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))
 {
 location_t loc = c_parser_peek_token (parser)->location;
 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,
+	warning_at (loc, OPT_Wempty_body,
-"suggest braces around empty body in an %<if%> statement");
+		    "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));
 else
 c_parser_statement_after_labels (parser);
 c_parser_else_body (c_parser *parser)
 {
 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_keyword (parser, RID_DEFAULT)
-|| (c_parser_next_token_is (parser, CPP_NAME)
+	 || (c_parser_next_token_is (parser, CPP_NAME)
-&& c_parser_peek_2nd_token (parser)->type == CPP_COLON))
+	     && 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,
+		  OPT_Wempty_body,
-"suggest braces around empty body in an %<else%> statement");
+	         "suggest braces around empty body in an %<else%> statement");
 add_stmt (build_empty_stmt (loc));
 c_parser_consume_token (parser);
 }
 else
 c_parser_statement_after_labels (parser);
 location_t loc;
 gcc_assert (c_parser_next_token_is_keyword (parser, RID_DO));
 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,
+		OPT_Wempty_body,
-"suggest braces around empty body in %<do%> statement");
+		"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;
 c_break_label = NULL_TREE;
 save_cont = c_cont_label;
 {
 quals = c_parser_peek_token (parser)->value;
 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,
+		  0,
-"%E qualifier ignored on asm",
+		  "%E qualifier ignored on asm",
-c_parser_peek_token (parser)->value);
+		  c_parser_peek_token (parser)->value);
 quals = NULL_TREE;
 c_parser_consume_token (parser);
 }
 else
 quals = NULL_TREE;
 /* Parse each colon-delimited section of operands.  */
 nsections = 3 + is_goto;
 for (section = 0; section < nsections; ++section)
 {
 if (!c_parser_require (parser, CPP_COLON,
-is_goto
+			     is_goto
-? "expected %<:%>"
+			     ? "expected %<:%>"
-: "expected %<:%> or %<)%>"))
+			     : "expected %<:%> or %<)%>"))
-goto error_close_paren;
+	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))
+	   && !c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
-|| section == 3)
+	  || section == 3)
-switch (section)
+	switch (section)
-{
+	  {
-case 0:
+	  case 0:
-/* For asm goto, we don't allow output operands, but reserve
+	    /* For asm goto, we don't allow output operands, but reserve
-the slot for a future extension that does allow them.  */
+	       the slot for a future extension that does allow them.  */
-if (!is_goto)
+	    if (!is_goto)
-outputs = c_parser_asm_operands (parser, false);
+	      outputs = c_parser_asm_operands (parser, false);
-break;
+	    break;
-case 1:
+	  case 1:
-inputs = c_parser_asm_operands (parser, true);
+	    inputs = c_parser_asm_operands (parser, true);
-break;
+	    break;
-case 2:
+	  case 2:
-clobbers = c_parser_asm_clobbers (parser);
+	    clobbers = c_parser_asm_clobbers (parser);
-break;
+	    break;
-case 3:
+	  case 3:
-labels = c_parser_asm_goto_operands (parser);
+	    labels = c_parser_asm_goto_operands (parser);
-break;
+	    break;
-default:
+	  default:
-gcc_unreachable ();
+	    gcc_unreachable ();
-}
+	  }
 if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN) && !is_goto)
-goto done_asm;
+	goto done_asm;
 }
 done_asm:
 if (!c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
 {
 if (!c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>"))
 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;
 return ret;
 while (true)
 {
 tree name, str;
 struct c_expr expr;
 if (c_parser_next_token_is (parser, CPP_OPEN_SQUARE))
-{
+	{
-c_parser_consume_token (parser);
+	  c_parser_consume_token (parser);
-if (c_parser_next_token_is (parser, CPP_NAME))
+	  if (c_parser_next_token_is (parser, CPP_NAME))
-{
+	    {
-tree id = c_parser_peek_token (parser)->value;
+	      tree id = c_parser_peek_token (parser)->value;
-c_parser_consume_token (parser);
+	      c_parser_consume_token (parser);
-name = build_string (IDENTIFIER_LENGTH (id),
+	      name = build_string (IDENTIFIER_LENGTH (id),
-IDENTIFIER_POINTER (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
-{
+	name = NULL_TREE;
-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;
 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;
+	  parser->lex_untranslated_string = true;
-return NULL_TREE;
+	  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);
+	  c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
-return NULL_TREE;
+	  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;
 }
 /* Parse asm clobbers, a GNU extension.
 tree list = NULL_TREE;
 while (true)
 {
 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;
 }
 /* Parse asm goto labels, a GNU extension.
 while (true)
 {
 tree name, label;
 if (c_parser_next_token_is (parser, CPP_NAME))
-{
+	{
-c_token *tok = c_parser_peek_token (parser);
+	  c_token *tok = c_parser_peek_token (parser);
-name = tok->value;
+	  name = tok->value;
-label = lookup_label_for_goto (tok->location, name);
+	  label = lookup_label_for_goto (tok->location, name);
-c_parser_consume_token (parser);
+	  c_parser_consume_token (parser);
-TREE_USED (label) = 1;
+	  TREE_USED (label) = 1;
-}
+	}
 else
-{
+	{
-c_parser_error (parser, "expected identifier");
+	  c_parser_error (parser, "expected identifier");
-return NULL_TREE;
+	  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);
 }
 }
 /* Parse an expression other than a compound expression; that is, an
 assignment expression (C90 6.3.16, C99 6.5.16).  If AFTER is not
 c_parser_consume_token (parser);
 exp_location = c_parser_peek_token (parser)->location;
 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,
+				 code, exp_location, rhs.value,
-rhs.original_type);
+				 rhs.original_type);
 if (code == NOP_EXPR)
 ret.original_code = MODIFY_EXPR;
 else
 {
 TREE_NO_WARNING (ret.value) = 1;
 cond = default_function_array_read_conversion (cond_loc, cond);
 c_parser_consume_token (parser);
 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);
+	  eptype = TREE_TYPE (cond.value);
-cond.value = TREE_OPERAND (cond.value, 0);
+	  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;
 }
 else
 {
 cond.value
-= c_objc_common_truthvalue_conversion
+	= c_objc_common_truthvalue_conversion
-(cond_loc, default_conversion (cond.value));
+	(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_true_node)
-- (cond.value == truthvalue_false_node));
+	 - (cond.value == truthvalue_false_node));
 }
 colon_loc = c_parser_peek_token (parser)->location;
 if (!c_parser_require (parser, CPP_COLON, "expected %<:%>"))
 {
 exp2 = c_parser_conditional_expression (parser, NULL);
 exp2 = default_function_array_read_conversion (exp2_loc, exp2);
 }
 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,
+				      cond.original_code == C_MAYBE_CONST_EXPR,
-exp1.value, exp1.original_type,
+				      exp1.value, exp1.original_type,
-exp2.value, exp2.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;
 else
 {
 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
+	 made the type of the result be an integer type.  We want to
-remember the enum types we started with.  */
+	 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
+			    && t2 != error_mark_node
-&& (TYPE_MAIN_VARIANT (t1)
+			    && (TYPE_MAIN_VARIANT (t1)
-== TYPE_MAIN_VARIANT (t2)))
+				== TYPE_MAIN_VARIANT (t2)))
-? t1
+			   ? t1
-: NULL);
+			   : NULL);
 }
 return ret;
 }
 /* Parse a binary expression; that is, a logical-OR-expression (C90
 while (true)
 {
 enum prec oprec;
 enum tree_code ocode;
 if (parser->error)
-goto out;
+	goto out;
 switch (c_parser_peek_token (parser)->type)
-{
+	{
-case CPP_MULT:
+	case CPP_MULT:
-oprec = PREC_MULT;
+	  oprec = PREC_MULT;
-ocode = MULT_EXPR;
+	  ocode = MULT_EXPR;
-break;
+	  break;
-case CPP_DIV:
+	case CPP_DIV:
-oprec = PREC_MULT;
+	  oprec = PREC_MULT;
-ocode = TRUNC_DIV_EXPR;
+	  ocode = TRUNC_DIV_EXPR;
-break;
+	  break;
-case CPP_MOD:
+	case CPP_MOD:
-oprec = PREC_MULT;
+	  oprec = PREC_MULT;
-ocode = TRUNC_MOD_EXPR;
+	  ocode = TRUNC_MOD_EXPR;
-break;
+	  break;
-case CPP_PLUS:
+	case CPP_PLUS:
-oprec = PREC_ADD;
+	  oprec = PREC_ADD;
-ocode = PLUS_EXPR;
+	  ocode = PLUS_EXPR;
-break;
+	  break;
-case CPP_MINUS:
+	case CPP_MINUS:
-oprec = PREC_ADD;
+	  oprec = PREC_ADD;
-ocode = MINUS_EXPR;
+	  ocode = MINUS_EXPR;
-break;
+	  break;
-case CPP_LSHIFT:
+	case CPP_LSHIFT:
-oprec = PREC_SHIFT;
+	  oprec = PREC_SHIFT;
-ocode = LSHIFT_EXPR;
+	  ocode = LSHIFT_EXPR;
-break;
+	  break;
-case CPP_RSHIFT:
+	case CPP_RSHIFT:
-oprec = PREC_SHIFT;
+	  oprec = PREC_SHIFT;
-ocode = RSHIFT_EXPR;
+	  ocode = RSHIFT_EXPR;
-break;
+	  break;
-case CPP_LESS:
+	case CPP_LESS:
-oprec = PREC_REL;
+	  oprec = PREC_REL;
-ocode = LT_EXPR;
+	  ocode = LT_EXPR;
-break;
+	  break;
-case CPP_GREATER:
+	case CPP_GREATER:
-oprec = PREC_REL;
+	  oprec = PREC_REL;
-ocode = GT_EXPR;
+	  ocode = GT_EXPR;
-break;
+	  break;
-case CPP_LESS_EQ:
+	case CPP_LESS_EQ:
-oprec = PREC_REL;
+	  oprec = PREC_REL;
-ocode = LE_EXPR;
+	  ocode = LE_EXPR;
-break;
+	  break;
-case CPP_GREATER_EQ:
+	case CPP_GREATER_EQ:
-oprec = PREC_REL;
+	  oprec = PREC_REL;
-ocode = GE_EXPR;
+	  ocode = GE_EXPR;
-break;
+	  break;
-case CPP_EQ_EQ:
+	case CPP_EQ_EQ:
-oprec = PREC_EQ;
+	  oprec = PREC_EQ;
-ocode = EQ_EXPR;
+	  ocode = EQ_EXPR;
-break;
+	  break;
-case CPP_NOT_EQ:
+	case CPP_NOT_EQ:
-oprec = PREC_EQ;
+	  oprec = PREC_EQ;
-ocode = NE_EXPR;
+	  ocode = NE_EXPR;
-break;
+	  break;
-case CPP_AND:
+	case CPP_AND:
-oprec = PREC_BITAND;
+	  oprec = PREC_BITAND;
-ocode = BIT_AND_EXPR;
+	  ocode = BIT_AND_EXPR;
-break;
+	  break;
-case CPP_XOR:
+	case CPP_XOR:
-oprec = PREC_BITXOR;
+	  oprec = PREC_BITXOR;
-ocode = BIT_XOR_EXPR;
+	  ocode = BIT_XOR_EXPR;
-break;
+	  break;
-case CPP_OR:
+	case CPP_OR:
-oprec = PREC_BITOR;
+	  oprec = PREC_BITOR;
-ocode = BIT_IOR_EXPR;
+	  ocode = BIT_IOR_EXPR;
-break;
+	  break;
-case CPP_AND_AND:
+	case CPP_AND_AND:
-oprec = PREC_LOGAND;
+	  oprec = PREC_LOGAND;
-ocode = TRUTH_ANDIF_EXPR;
+	  ocode = TRUTH_ANDIF_EXPR;
-break;
+	  break;
-case CPP_OR_OR:
+	case CPP_OR_OR:
-oprec = PREC_LOGOR;
+	  oprec = PREC_LOGOR;
-ocode = TRUTH_ORIF_EXPR;
+	  ocode = TRUTH_ORIF_EXPR;
-break;
+	  break;
-default:
+	default:
-/* Not a binary operator, so end of the binary
+	  /* Not a binary operator, so end of the binary
-expression.  */
+	     expression.  */
-goto out;
+	  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:
 	  stack[sp].expr
 	    = default_function_array_read_conversion (stack[sp].loc,
 {
 location_t cast_loc = c_parser_peek_token (parser)->location;
 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
 an unary expression.  Full detection of unknown typenames here
 would require a 3-token lookahead.  */
 struct c_expr expr;
 c_parser_consume_token (parser);
 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.value = error_mark_node;
-ret.original_code = ERROR_MARK;
+	  ret.original_code = ERROR_MARK;
-ret.original_type = NULL;
+	  ret.original_type = NULL;
-return ret;
+	  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,
+	return c_parser_postfix_expression_after_paren_type (parser, type_name,
-cast_loc);
+							     cast_loc);
 {
 	location_t expr_loc = c_parser_peek_token (parser)->location;
 	expr = c_parser_cast_expression (parser, NULL);
 	expr = default_function_array_read_conversion (expr_loc, expr);
 }
 op = default_function_array_read_conversion (exp_loc, op);
 ret.value = build_indirect_ref (op_loc, op.value, RO_UNARY_STAR);
 return ret;
 case CPP_PLUS:
 if (!c_dialect_objc () && !in_system_header)
-warning_at (op_loc,
+	warning_at (op_loc,
-OPT_Wtraditional,
+		    OPT_Wtraditional,
-"traditional C rejects the unary plus operator");
+		    "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);
 op = default_function_array_read_conversion (exp_loc, op);
 return parser_build_unary_op (op_loc, CONVERT_EXPR, op);
 return parser_build_unary_op (op_loc, TRUTH_NOT_EXPR, op);
 case CPP_AND_AND:
 /* 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
+	  ret.value = finish_label_address_expr
-(c_parser_peek_token (parser)->value, op_loc);
+	    (c_parser_peek_token (parser)->value, op_loc);
-c_parser_consume_token (parser);
+	  c_parser_consume_token (parser);
-}
+	}
 else
-{
+	{
-c_parser_error (parser, "expected identifier");
+	  c_parser_error (parser, "expected identifier");
-ret.value = error_mark_node;
+	  ret.value = error_mark_node;
-}
+	}
-return ret;
+	return ret;
 case CPP_KEYWORD:
 switch (c_parser_peek_token (parser)->keyword)
-{
+	{
-case RID_SIZEOF:
+	case RID_SIZEOF:
-return c_parser_sizeof_expression (parser);
+	  return c_parser_sizeof_expression (parser);
-case RID_ALIGNOF:
+	case RID_ALIGNOF:
-return c_parser_alignof_expression (parser);
+	  return c_parser_alignof_expression (parser);
-case RID_EXTENSION:
+	case RID_EXTENSION:
-c_parser_consume_token (parser);
+	  c_parser_consume_token (parser);
-ext = disable_extension_diagnostics ();
+	  ext = disable_extension_diagnostics ();
-ret = c_parser_cast_expression (parser, NULL);
+	  ret = c_parser_cast_expression (parser, NULL);
-restore_extension_diagnostics (ext);
+	  restore_extension_diagnostics (ext);
-return ret;
+	  return ret;
-case RID_REALPART:
+	case RID_REALPART:
-c_parser_consume_token (parser);
+	  c_parser_consume_token (parser);
-exp_loc = c_parser_peek_token (parser)->location;
+	  exp_loc = c_parser_peek_token (parser)->location;
-op = c_parser_cast_expression (parser, NULL);
+	  op = c_parser_cast_expression (parser, NULL);
-op = default_function_array_conversion (exp_loc, op);
+	  op = default_function_array_conversion (exp_loc, op);
-return parser_build_unary_op (op_loc, REALPART_EXPR, op);
+	  return parser_build_unary_op (op_loc, REALPART_EXPR, op);
-case RID_IMAGPART:
+	case RID_IMAGPART:
-c_parser_consume_token (parser);
+	  c_parser_consume_token (parser);
-exp_loc = c_parser_peek_token (parser)->location;
+	  exp_loc = c_parser_peek_token (parser)->location;
-op = c_parser_cast_expression (parser, NULL);
+	  op = c_parser_cast_expression (parser, NULL);
-op = default_function_array_conversion (exp_loc, op);
+	  op = default_function_array_conversion (exp_loc, op);
-return parser_build_unary_op (op_loc, IMAGPART_EXPR, op);
+	  return parser_build_unary_op (op_loc, IMAGPART_EXPR, op);
-default:
+	default:
-return c_parser_postfix_expression (parser);
+	  return c_parser_postfix_expression (parser);
-}
+	}
 default:
 return c_parser_postfix_expression (parser);
 }
 }
 in_sizeof++;
 if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)
 && 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;
+	  struct c_expr ret;
-c_inhibit_evaluation_warnings--;
+	  c_inhibit_evaluation_warnings--;
-in_sizeof--;
+	  in_sizeof--;
-ret.value = error_mark_node;
+	  ret.value = error_mark_node;
-ret.original_code = ERROR_MARK;
+	  ret.original_code = ERROR_MARK;
-ret.original_type = NULL;
+	  ret.original_type = NULL;
-return ret;
+	  return ret;
-}
+	}
 if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
-{
+	{
-expr = c_parser_postfix_expression_after_paren_type (parser,
+	  expr = c_parser_postfix_expression_after_paren_type (parser,
-type_name,
+							       type_name,
-expr_loc);
+							       expr_loc);
-goto sizeof_expr;
+	  goto sizeof_expr;
-}
+	}
 /* sizeof ( type-name ).  */
 c_inhibit_evaluation_warnings--;
 in_sizeof--;
 return c_expr_sizeof_type (expr_loc, type_name);
 }
 sizeof_expr:
 c_inhibit_evaluation_warnings--;
 in_sizeof--;
 mark_exp_read (expr.value);
 if (TREE_CODE (expr.value) == COMPONENT_REF
-&& DECL_C_BIT_FIELD (TREE_OPERAND (expr.value, 1)))
+	  && DECL_C_BIT_FIELD (TREE_OPERAND (expr.value, 1)))
-error_at (expr_loc, "%<sizeof%> applied to a bit-field");
+	error_at (expr_loc, "%<sizeof%> applied to a bit-field");
 return c_expr_sizeof_expr (expr_loc, expr);
 }
 }
 /* Parse an alignof expression.  */
 in_alignof++;
 if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)
 && 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;
 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)
-{
+	{
-struct c_expr ret;
+	  struct c_expr ret;
-c_inhibit_evaluation_warnings--;
+	  c_inhibit_evaluation_warnings--;
-in_alignof--;
+	  in_alignof--;
-ret.value = error_mark_node;
+	  ret.value = error_mark_node;
-ret.original_code = ERROR_MARK;
+	  ret.original_code = ERROR_MARK;
-ret.original_type = NULL;
+	  ret.original_type = NULL;
-return ret;
+	  return ret;
-}
+	}
 if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
-{
+	{
-expr = c_parser_postfix_expression_after_paren_type (parser,
+	  expr = c_parser_postfix_expression_after_paren_type (parser,
-type_name,
+							       type_name,
-loc);
+							       loc);
-goto alignof_expr;
+	  goto alignof_expr;
-}
+	}
 /* alignof ( type-name ).  */
 c_inhibit_evaluation_warnings--;
 in_alignof--;
 ret.value = c_alignof (loc, groktypename (type_name, NULL, NULL));
 ret.original_code = ERROR_MARK;
 __PRETTY_FUNCTION__
 ( compound-statement )
 __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:
 identifier
 offsetof-member-designator . identifier
 @encode ( type-name )
 objc-string-literal
 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;
 switch (c_parser_peek_token (parser)->type)
 {
 case CPP_NUMBER:
 expr.value = c_parser_peek_token (parser)->value;
 loc = c_parser_peek_token (parser)->location;
 c_parser_consume_token (parser);
 if (TREE_CODE (expr.value) == FIXED_CST
-&& !targetm.fixed_point_supported_p ())
+	  && !targetm.fixed_point_supported_p ())
-{
+	{
-error_at (loc, "fixed-point types not supported for this target");
+	  error_at (loc, "fixed-point types not supported for this target");
-expr.value = error_mark_node;
+	  expr.value = error_mark_node;
-}
+	}
 break;
 case CPP_CHAR:
 case CPP_CHAR16:
 case CPP_CHAR32:
 case CPP_WCHAR:
 c_parser_consume_token (parser);
 break;
 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:
 switch (c_parser_peek_token (parser)->id_kind)
 	{
 	  break;
 	}
 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.  */
 	  tree stmt;
 	  location_t brace_loc;
 		   "ISO C forbids braced-groups within expressions");
 	  expr.value = c_finish_stmt_expr (brace_loc, stmt);
 	  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
+	  /* A compound literal.  ??? Can we actually get here rather
-than going directly to
+	     than going directly to
-c_parser_postfix_expression_after_paren_type from
+	     c_parser_postfix_expression_after_paren_type from
-elsewhere?  */
+	     elsewhere?  */
-location_t loc;
+	  location_t loc;
-struct c_type_name *type_name;
+	  struct c_type_name *type_name;
-c_parser_consume_token (parser);
+	  c_parser_consume_token (parser);
-loc = c_parser_peek_token (parser)->location;
+	  loc = c_parser_peek_token (parser)->location;
-type_name = c_parser_type_name (parser);
+	  type_name = c_parser_type_name (parser);
-c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
+	  c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
-"expected %<)%>");
+				     "expected %<)%>");
-if (type_name == NULL)
+	  if (type_name == NULL)
-{
+	    {
-expr.value = error_mark_node;
+	      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,
+	  /* A parenthesized expression.  */
-loc);
+	  c_parser_consume_token (parser);
-}
+	  expr = c_parser_expression (parser);
-else
+	  if (TREE_CODE (expr.value) == MODIFY_EXPR)
-{
+	    TREE_NO_WARNING (expr.value) = 1;
-/* A parenthesized expression.  */
+	  if (expr.original_code != C_MAYBE_CONST_EXPR)
-c_parser_consume_token (parser);
+	    expr.original_code = ERROR_MARK;
-expr = c_parser_expression (parser);
+	  /* Don't change EXPR.ORIGINAL_TYPE.  */
-if (TREE_CODE (expr.value) == MODIFY_EXPR)
+	  c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
-TREE_NO_WARNING (expr.value) = 1;
+				     "expected %<)%>");
-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)
 	{
 	case RID_FUNCTION_NAME:
 	  e3 = c_parser_expr_no_commas (parser, NULL);
 	  c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
 				     "expected %<)%>");
 	  {
 	    tree c;
 	    c = e1.value;
 	    mark_exp_read (e2.value);
 	    mark_exp_read (e3.value);
 	    if (TREE_CODE (c) != INTEGER_CST
 		|| !INTEGRAL_TYPE_P (TREE_TYPE (c)))
 	    }
 	  c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
 				     "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;
 	  }
 	  break;
 	case RID_AT_SELECTOR:
 	  {
 	    tree type = groktypename (t1, NULL, NULL);
 	    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;
 	  break;
 	}
 break;
 case CPP_OPEN_SQUARE:
 if (c_dialect_objc ())
-{
+	{
-tree receiver, args;
+	  tree receiver, args;
-c_parser_consume_token (parser);
+	  c_parser_consume_token (parser);
-receiver = c_parser_objc_receiver (parser);
+	  receiver = c_parser_objc_receiver (parser);
-args = c_parser_objc_message_args (parser);
+	  args = c_parser_objc_message_args (parser);
-c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
+	  c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
-"expected %<]%>");
+				     "expected %<]%>");
-expr.value = objc_build_message_expr (build_tree_list (receiver,
+	  expr.value = objc_build_message_expr (build_tree_list (receiver,
-args));
+								 args));
-break;
+	  break;
-}
+	}
 /* Else fall through to report error.  */
 default:
 c_parser_error (parser, "expected expression");
 expr.value = error_mark_node;
 break;
 location of the first token after the parentheses around the type
 name.  */
 static struct c_expr
 c_parser_postfix_expression_after_paren_type (c_parser *parser,
-struct c_type_name *type_name,
+					      struct c_type_name *type_name,
-location_t type_loc)
+					      location_t type_loc)
 {
 tree type;
 struct c_expr init;
 bool non_const;
 struct c_expr expr;
 }
 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)
+	       ? CONSTRUCTOR_NON_CONST (init.value)
-: init.original_code == C_MAYBE_CONST_EXPR);
+	       : 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;
 expr.original_type = NULL;
 if (type_expr)
 {
 if (TREE_CODE (expr.value) == C_MAYBE_CONST_EXPR)
-{
+	{
-gcc_assert (C_MAYBE_CONST_EXPR_PRE (expr.value) == NULL_TREE);
+	  gcc_assert (C_MAYBE_CONST_EXPR_PRE (expr.value) == NULL_TREE);
-C_MAYBE_CONST_EXPR_PRE (expr.value) = type_expr;
+	  C_MAYBE_CONST_EXPR_PRE (expr.value) = type_expr;
-}
+	}
 else
-{
+	{
-gcc_assert (!non_const);
+	  gcc_assert (!non_const);
-expr.value = build2 (C_MAYBE_CONST_EXPR, type,
+	  expr.value = build2 (C_MAYBE_CONST_EXPR, type,
-type_expr, expr.value);
+			       type_expr, expr.value);
-}
+	}
 }
 return c_parser_postfix_expression_after_primary (parser, start_loc, expr);
 }
 /* Parse a postfix expression after the initial primary or compound
 EXPR_LOC is the location of the primary expression.  */
 static struct c_expr
 c_parser_postfix_expression_after_primary (c_parser *parser,
-location_t expr_loc,
+					   location_t expr_loc,
-struct c_expr expr)
+					   struct c_expr expr)
 {
 struct c_expr orig_expr;
 tree ident, idx;
 VEC(tree,gc) *exprlist;
 VEC(tree,gc) *origtypes;
 nonempty-expr-list , assignment-expression
 */
 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;
 struct c_expr expr;
 location_t loc = c_parser_peek_token (parser)->location;
 loc = c_parser_peek_token (parser)->location;
 expr = c_parser_expr_no_commas (parser, NULL);
 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;
 return ret;
 }
 	  id2 = c_parser_peek_token (parser)->value;
 	  c_parser_consume_token (parser);
 	}
 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
 if (!iface_p)
-{
+	{
-objc_start_category_implementation (id1, id2);
+	  objc_start_category_implementation (id1, id2);
-return;
+	  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);
 c_parser_objc_methodprotolist (parser);
 c_parser_require_keyword (parser, RID_AT_END, "expected %<@end%>");
 }
 if (c_parser_next_token_is (parser, CPP_COLON))
 {
 c_parser_consume_token (parser);
 if (c_parser_next_token_is_not (parser, CPP_NAME))
-{
+	{
-c_parser_error (parser, "expected identifier");
+	  c_parser_error (parser, "expected identifier");
-return;
+	  return;
-}
+	}
 superclass = c_parser_peek_token (parser)->value;
 c_parser_consume_token (parser);
 }
 else
 superclass = NULL_TREE;
 while (c_parser_next_token_is_not (parser, CPP_EOF))
 {
 tree decls;
 /* Parse any stray semicolon.  */
 if (c_parser_next_token_is (parser, CPP_SEMICOLON))
-{
+	{
-pedwarn (c_parser_peek_token (parser)->location, OPT_pedantic,
+	  pedwarn (c_parser_peek_token (parser)->location, OPT_pedantic,
-"extra semicolon in struct or union specified");
+		   "extra semicolon in struct or union specified");
-c_parser_consume_token (parser);
+	  c_parser_consume_token (parser);
-continue;
+	  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);
+	  c_parser_consume_token (parser);
-break;
+	  break;
-}
+	}
 /* Parse any objc-visibility-spec.  */
 if (c_parser_next_token_is_keyword (parser, RID_AT_PRIVATE))
 	{
 	  c_parser_consume_token (parser);
 	  objc_set_visibility (OBJC_IVAR_VIS_PRIVATE);
 	  c_parser_consume_token (parser);
 	  objc_set_visibility (OBJC_IVAR_VIS_PACKAGE);
 	  continue;
 	}
 else if (c_parser_next_token_is (parser, CPP_PRAGMA))
-{
+	{
-c_parser_pragma (parser, pragma_external);
+	  c_parser_pragma (parser, pragma_external);
-continue;
+	  continue;
-}
+	}
 /* Parse some comma-separated declarations.  */
 decls = c_parser_struct_declaration (parser);
 {
 	/* Comma-separated instance variables are chained together in
 	   reverse order; add them one by one.  */
 	}
 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_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
 objc_declare_class (list);
 }
 if (c_parser_peek_2nd_token (parser)->type == CPP_COMMA
 || c_parser_peek_2nd_token (parser)->type == CPP_SEMICOLON)
 {
 tree list = NULL_TREE;
 /* Any identifiers, including those declared as type names, are
-OK here.  */
+	 OK here.  */
 while (true)
-{
+	{
-tree id;
+	  tree id;
-if (c_parser_next_token_is_not (parser, CPP_NAME))
+	  if (c_parser_next_token_is_not (parser, CPP_NAME))
-{
+	    {
-c_parser_error (parser, "expected identifier");
+	      c_parser_error (parser, "expected identifier");
-break;
+	      break;
-}
+	    }
-id = c_parser_peek_token (parser)->value;
+	  id = c_parser_peek_token (parser)->value;
-list = chainon (list, build_tree_list (NULL_TREE, id));
+	  list = chainon (list, build_tree_list (NULL_TREE, id));
-c_parser_consume_token (parser);
+	  c_parser_consume_token (parser);
-if (c_parser_next_token_is (parser, CPP_COMMA))
+	  if (c_parser_next_token_is (parser, CPP_COMMA))
-c_parser_consume_token (parser);
+	    c_parser_consume_token (parser);
-else
+	  else
-break;
+	    break;
-}
+	}
 c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
 objc_declare_protocols (list, attributes);
 }
 else
 {
 tree id = c_parser_peek_token (parser)->value;
 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);
 c_parser_require_keyword (parser, RID_AT_END, "expected %<@end%>");
 parser->objc_pq_context = false;
 if (c_parser_next_token_is (parser, CPP_SEMICOLON))
 {
 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))
 {
 c_parser_error (parser, "expected %<{%>");
 	}
 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 '...'
+	 method parameters follow the C syntax, and may include '...'
-to denote a variable number of arguments.  */
+	 to denote a variable number of arguments.  */
 parms = make_node (TREE_LIST);
 while (c_parser_next_token_is (parser, CPP_COMMA))
 	{
 	  struct c_parm *parm;
 	  c_parser_consume_token (parser);
 	{
 	  quals = chainon (build_tree_list (NULL_TREE, token->value), quals);
 	  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);
 if (type_name)
 type = groktypename (type_name, NULL, NULL);
 here.  */
 while (true)
 {
 tree id;
 if (c_parser_next_token_is_not (parser, CPP_NAME))
-{
+	{
-c_parser_error (parser, "expected identifier");
+	  c_parser_error (parser, "expected identifier");
-break;
+	  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;
 }
 	     all (ie, they typed "@catch NSException *e").  So, just
 	     forget about the closing parenthesis and keep going.  */
 	}
 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))
 {
 c_parser_consume_token (parser);
 if (sel && c_parser_next_token_is_not (parser, CPP_COLON))
 return sel;
 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;
 }
 /* Parse an objc-receiver.
 static tree
 c_parser_objc_receiver (c_parser *parser)
 {
 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);
 return objc_get_class_reference (id);
 }
 return sel;
 while (true)
 {
 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;
 }
 /* Parse an objc-keywordexpr.
 tree ret;
 VEC(tree,gc) *expr_list = c_parser_expr_list (parser, true, true, NULL);
 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
 {
 /* We have a comma expression, we will collapse later.  */
 switch (id)
 {
 case PRAGMA_OMP_BARRIER:
 if (context != pragma_compound)
-{
+	{
-if (context == pragma_stmt)
+	  if (context == pragma_stmt)
-c_parser_error (parser, "%<#pragma omp barrier%> may only be "
+	    c_parser_error (parser, "%<#pragma omp barrier%> may only be "
-"used in compound statements");
+			    "used in compound statements");
-goto bad_stmt;
+	  goto bad_stmt;
-}
+	}
 c_parser_omp_barrier (parser);
 return false;
 case PRAGMA_OMP_FLUSH:
 if (context != pragma_compound)
-{
+	{
-if (context == pragma_stmt)
+	  if (context == pragma_stmt)
-c_parser_error (parser, "%<#pragma omp flush%> may only be "
+	    c_parser_error (parser, "%<#pragma omp flush%> may only be "
-"used in compound statements");
+			    "used in compound statements");
-goto bad_stmt;
+	  goto bad_stmt;
-}
+	}
 c_parser_omp_flush (parser);
 return false;
 case PRAGMA_OMP_TASKWAIT:
 if (context != pragma_compound)
-{
+	{
-if (context == pragma_stmt)
+	  if (context == pragma_stmt)
-c_parser_error (parser, "%<#pragma omp taskwait%> may only be "
+	    c_parser_error (parser, "%<#pragma omp taskwait%> may only be "
-"used in compound statements");
+			    "used in compound statements");
-goto bad_stmt;
+	  goto bad_stmt;
-}
+	}
 c_parser_omp_taskwait (parser);
 return false;
 case PRAGMA_OMP_THREADPRIVATE:
 c_parser_omp_threadprivate (parser);
 return false;
 case PRAGMA_OMP_SECTION:
 error_at (c_parser_peek_token (parser)->location,
-"%<#pragma omp section%> may only be used in "
+		"%<#pragma omp section%> may only be used in "
-"%<#pragma omp sections%> construct");
+		"%<#pragma omp sections%> construct");
 c_parser_skip_until_found (parser, CPP_PRAGMA_EOL, NULL);
 return false;
 case PRAGMA_GCC_PCH_PREPROCESS:
 c_parser_error (parser, "%<#pragma GCC pch_preprocess%> must be first");
 c_parser_skip_until_found (parser, CPP_PRAGMA_EOL, NULL);
 return false;
 default:
 if (id < PRAGMA_FIRST_EXTERNAL)
-{
+	{
-if (context == pragma_external)
+	  if (context == pragma_external)
-{
+	    {
-bad_stmt:
+	    bad_stmt:
-c_parser_error (parser, "expected declaration specifiers");
+	      c_parser_error (parser, "expected declaration specifiers");
-c_parser_skip_until_found (parser, CPP_PRAGMA_EOL, NULL);
+	      c_parser_skip_until_found (parser, CPP_PRAGMA_EOL, NULL);
-return false;
+	      return false;
-}
+	    }
-c_parser_omp_construct (parser);
+	  c_parser_omp_construct (parser);
-return true;
+	  return true;
-}
+	}
 break;
 }
 c_parser_consume_pragma (parser);
 c_invoke_pragma_handler (id);
 if (ret == CPP_PRAGMA_EOL || ret == CPP_EOF)
 ret = CPP_EOF;
 else
 {
 if (ret == CPP_KEYWORD)
-ret = CPP_NAME;
+	ret = CPP_NAME;
 c_parser_consume_token (the_parser);
 }
 return ret;
 }
 else if (c_parser_next_token_is (parser, CPP_NAME))
 {
 const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
 switch (p[0])
-{
+	{
-case 'c':
+	case 'c':
-if (!strcmp ("collapse", p))
+	  if (!strcmp ("collapse", p))
-result = PRAGMA_OMP_CLAUSE_COLLAPSE;
+	    result = PRAGMA_OMP_CLAUSE_COLLAPSE;
-else if (!strcmp ("copyin", p))
+	  else if (!strcmp ("copyin", p))
-result = PRAGMA_OMP_CLAUSE_COPYIN;
+	    result = PRAGMA_OMP_CLAUSE_COPYIN;
 else if (!strcmp ("copyprivate", p))
-result = PRAGMA_OMP_CLAUSE_COPYPRIVATE;
+	    result = PRAGMA_OMP_CLAUSE_COPYPRIVATE;
-break;
+	  break;
-case 'f':
+	case 'f':
-if (!strcmp ("firstprivate", p))
+	  if (!strcmp ("firstprivate", p))
-result = PRAGMA_OMP_CLAUSE_FIRSTPRIVATE;
+	    result = PRAGMA_OMP_CLAUSE_FIRSTPRIVATE;
-break;
+	  break;
-case 'l':
+	case 'l':
-if (!strcmp ("lastprivate", p))
+	  if (!strcmp ("lastprivate", p))
-result = PRAGMA_OMP_CLAUSE_LASTPRIVATE;
+	    result = PRAGMA_OMP_CLAUSE_LASTPRIVATE;
-break;
+	  break;
-case 'n':
+	case 'n':
-if (!strcmp ("nowait", p))
+	  if (!strcmp ("nowait", p))
-result = PRAGMA_OMP_CLAUSE_NOWAIT;
+	    result = PRAGMA_OMP_CLAUSE_NOWAIT;
-else if (!strcmp ("num_threads", p))
+	  else if (!strcmp ("num_threads", p))
-result = PRAGMA_OMP_CLAUSE_NUM_THREADS;
+	    result = PRAGMA_OMP_CLAUSE_NUM_THREADS;
-break;
+	  break;
-case 'o':
+	case 'o':
-if (!strcmp ("ordered", p))
+	  if (!strcmp ("ordered", p))
-result = PRAGMA_OMP_CLAUSE_ORDERED;
+	    result = PRAGMA_OMP_CLAUSE_ORDERED;
-break;
+	  break;
-case 'p':
+	case 'p':
-if (!strcmp ("private", p))
+	  if (!strcmp ("private", p))
-result = PRAGMA_OMP_CLAUSE_PRIVATE;
+	    result = PRAGMA_OMP_CLAUSE_PRIVATE;
-break;
+	  break;
-case 'r':
+	case 'r':
-if (!strcmp ("reduction", p))
+	  if (!strcmp ("reduction", p))
-result = PRAGMA_OMP_CLAUSE_REDUCTION;
+	    result = PRAGMA_OMP_CLAUSE_REDUCTION;
-break;
+	  break;
-case 's':
+	case 's':
-if (!strcmp ("schedule", p))
+	  if (!strcmp ("schedule", p))
-result = PRAGMA_OMP_CLAUSE_SCHEDULE;
+	    result = PRAGMA_OMP_CLAUSE_SCHEDULE;
-else if (!strcmp ("shared", p))
+	  else if (!strcmp ("shared", p))
-result = PRAGMA_OMP_CLAUSE_SHARED;
+	    result = PRAGMA_OMP_CLAUSE_SHARED;
-break;
+	  break;
-case 'u':
+	case 'u':
-if (!strcmp ("untied", p))
+	  if (!strcmp ("untied", p))
-result = PRAGMA_OMP_CLAUSE_UNTIED;
+	    result = PRAGMA_OMP_CLAUSE_UNTIED;
-break;
+	  break;
-}
+	}
 }
 if (result != PRAGMA_OMP_CLAUSE_NONE)
 c_parser_consume_token (parser);
 /* Validate that a clause of the given type does not already exist.  */
 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);
+	location_t loc = OMP_CLAUSE_LOCATION (c);
-error_at (loc, "too many %qs clauses", name);
+	error_at (loc, "too many %qs clauses", name);
-break;
+	break;
 }
 }
 /* OpenMP 2.5:
 variable-list:
 If KIND is zero, create a TREE_LIST with the decl in TREE_PURPOSE;
 return the list created.  */
 static tree
 c_parser_omp_variable_list (c_parser *parser,
-location_t clause_loc,
+			    location_t clause_loc,
-enum omp_clause_code kind,
+			    enum omp_clause_code kind,
 tree list)
 {
 if (c_parser_next_token_is_not (parser, CPP_NAME)
 || c_parser_peek_token (parser)->id_kind != C_ID_ID)
 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,
+	undeclared_variable (c_parser_peek_token (parser)->location,
-c_parser_peek_token (parser)->value);
+			     c_parser_peek_token (parser)->value);
 else if (t == error_mark_node)
-;
+	;
 else if (kind != 0)
-{
+	{
-tree u = build_omp_clause (clause_loc, kind);
+	  tree u = build_omp_clause (clause_loc, kind);
-OMP_CLAUSE_DECL (u) = t;
+	  OMP_CLAUSE_DECL (u) = t;
-OMP_CLAUSE_CHAIN (u) = list;
+	  OMP_CLAUSE_CHAIN (u) = list;
-list = u;
+	  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);
 }
 return list;
 /* Similarly, but expect leading and trailing parenthesis.  This is a very
 common case for omp clauses.  */
 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;
 if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
 || !host_integerp (num, 0)
 || (n = tree_low_cst (num, 0)) <= 0
 || (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);
 OMP_CLAUSE_COLLAPSE_EXPR (c) = num;
 OMP_CLAUSE_CHAIN (c) = list;
 if (c_parser_next_token_is (parser, CPP_NAME))
 {
 const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
 switch (p[0])
-{
+	{
-case 'n':
+	case 'n':
-if (strcmp ("none", p) != 0)
+	  if (strcmp ("none", p) != 0)
-goto invalid_kind;
+	    goto invalid_kind;
-kind = OMP_CLAUSE_DEFAULT_NONE;
+	  kind = OMP_CLAUSE_DEFAULT_NONE;
-break;
+	  break;
-case 's':
+	case 's':
-if (strcmp ("shared", p) != 0)
+	  if (strcmp ("shared", p) != 0)
-goto invalid_kind;
+	    goto invalid_kind;
-kind = OMP_CLAUSE_DEFAULT_SHARED;
+	  kind = OMP_CLAUSE_DEFAULT_SHARED;
-break;
+	  break;
-default:
+	default:
-goto invalid_kind;
+	  goto invalid_kind;
-}
+	}
 c_parser_consume_token (parser);
 }
 else
 {
 t = c_fully_fold (t, false, NULL);
 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
 if (!INTEGRAL_TYPE_P (TREE_TYPE (t)))
-{
+	{
-c_parser_error (parser, "expected integer expression");
+	  c_parser_error (parser, "expected integer expression");
-return list;
+	  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,
+	  warning_at (expr_loc, 0,
-"%<num_threads%> value must be positive");
+		      "%<num_threads%> value must be positive");
-t = integer_one_node;
+	  t = integer_one_node;
-}
+	}
 check_no_duplicate_clause (list, OMP_CLAUSE_NUM_THREADS, "num_threads");
 c = build_omp_clause (num_threads_loc, OMP_CLAUSE_NUM_THREADS);
 OMP_CLAUSE_NUM_THREADS_EXPR (c) = t;
 tree c;
 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;
 }
 if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
 {
 enum tree_code code;
 switch (c_parser_peek_token (parser)->type)
-{
+	{
-case CPP_PLUS:
+	case CPP_PLUS:
-code = PLUS_EXPR;
+	  code = PLUS_EXPR;
-break;
+	  break;
-case CPP_MULT:
+	case CPP_MULT:
-code = MULT_EXPR;
+	  code = MULT_EXPR;
-break;
+	  break;
-case CPP_MINUS:
+	case CPP_MINUS:
-code = MINUS_EXPR;
+	  code = MINUS_EXPR;
-break;
+	  break;
-case CPP_AND:
+	case CPP_AND:
-code = BIT_AND_EXPR;
+	  code = BIT_AND_EXPR;
-break;
+	  break;
-case CPP_XOR:
+	case CPP_XOR:
-code = BIT_XOR_EXPR;
+	  code = BIT_XOR_EXPR;
-break;
+	  break;
-case CPP_OR:
+	case CPP_OR:
-code = BIT_IOR_EXPR;
+	  code = BIT_IOR_EXPR;
-break;
+	  break;
-case CPP_AND_AND:
+	case CPP_AND_AND:
-code = TRUTH_ANDIF_EXPR;
+	  code = TRUTH_ANDIF_EXPR;
-break;
+	  break;
-case CPP_OR_OR:
+	case CPP_OR_OR:
-code = TRUTH_ORIF_EXPR;
+	  code = TRUTH_ORIF_EXPR;
-break;
+	  break;
-default:
+	default:
-c_parser_error (parser,
+	  c_parser_error (parser,
-"expected %<+%>, %<*%>, %<-%>, %<&%>, "
+			  "expected %<+%>, %<*%>, %<-%>, %<&%>, "
-"%<^%>, %<|%>, %<&&%>, or %<||%>");
+			  "%<^%>, %<|%>, %<&&%>, or %<||%>");
-c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 0);
+	  c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 0);
-return list;
+	  return list;
-}
+	}
 c_parser_consume_token (parser);
 if (c_parser_require (parser, CPP_COLON, "expected %<:%>"))
-{
+	{
-tree nl, c;
+	  tree nl, c;
-nl = c_parser_omp_variable_list (parser, clause_loc,
+	  nl = c_parser_omp_variable_list (parser, clause_loc,
-OMP_CLAUSE_REDUCTION, list);
+					   OMP_CLAUSE_REDUCTION, list);
-for (c = nl; c != list; c = OMP_CLAUSE_CHAIN (c))
+	  for (c = nl; c != list; c = OMP_CLAUSE_CHAIN (c))
-OMP_CLAUSE_REDUCTION_CODE (c) = code;
+	    OMP_CLAUSE_REDUCTION_CODE (c) = code;
-list = nl;
+	  list = nl;
-}
+	}
 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
 }
 return list;
 }
 {
 tree kind = c_parser_peek_token (parser)->value;
 const char *p = IDENTIFIER_POINTER (kind);
 switch (p[0])
-{
+	{
-case 'd':
+	case 'd':
-if (strcmp ("dynamic", p) != 0)
+	  if (strcmp ("dynamic", p) != 0)
-goto invalid_kind;
+	    goto invalid_kind;
-OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_DYNAMIC;
+	  OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_DYNAMIC;
-break;
+	  break;
 case 'g':
-if (strcmp ("guided", p) != 0)
+	  if (strcmp ("guided", p) != 0)
-goto invalid_kind;
+	    goto invalid_kind;
-OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_GUIDED;
+	  OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_GUIDED;
-break;
+	  break;
-case 'r':
+	case 'r':
-if (strcmp ("runtime", p) != 0)
+	  if (strcmp ("runtime", p) != 0)
-goto invalid_kind;
+	    goto invalid_kind;
-OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_RUNTIME;
+	  OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_RUNTIME;
-break;
+	  break;
-default:
+	default:
-goto invalid_kind;
+	  goto invalid_kind;
-}
+	}
 }
 else if (c_parser_next_token_is_keyword (parser, RID_STATIC))
 OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_STATIC;
 else if (c_parser_next_token_is_keyword (parser, RID_AUTO))
 OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_AUTO;
 here = c_parser_peek_token (parser)->location;
 t = c_parser_expr_no_commas (parser, NULL).value;
 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 "
+	error_at (here, "schedule %<runtime%> does not take "
-"a %<chunk_size%> parameter");
+		  "a %<chunk_size%> parameter");
 else if (OMP_CLAUSE_SCHEDULE_KIND (c) == OMP_CLAUSE_SCHEDULE_AUTO)
-error_at (here,
+	error_at (here,
-"schedule %<auto%> does not take "
+		  "schedule %<auto%> does not take "
-"a %<chunk_size%> parameter");
+		  "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;
 return c;
 /* FIXME: Should we allow duplicates?  */
 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;
 }
 is a bitmask in MASK.  Return the list of clauses found; the result
 of clause default goes in *pdefault.  */
 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;
 while (c_parser_next_token_is_not (parser, CPP_PRAGMA_EOL))
 pragma_omp_clause c_kind;
 const char *c_name;
 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:
+	case PRAGMA_OMP_CLAUSE_COLLAPSE:
-clauses = c_parser_omp_clause_collapse (parser, clauses);
+	  clauses = c_parser_omp_clause_collapse (parser, clauses);
-c_name = "collapse";
+	  c_name = "collapse";
-break;
+	  break;
-case PRAGMA_OMP_CLAUSE_COPYIN:
+	case PRAGMA_OMP_CLAUSE_COPYIN:
-clauses = c_parser_omp_clause_copyin (parser, clauses);
+	  clauses = c_parser_omp_clause_copyin (parser, clauses);
-c_name = "copyin";
+	  c_name = "copyin";
-break;
+	  break;
-case PRAGMA_OMP_CLAUSE_COPYPRIVATE:
+	case PRAGMA_OMP_CLAUSE_COPYPRIVATE:
-clauses = c_parser_omp_clause_copyprivate (parser, clauses);
+	  clauses = c_parser_omp_clause_copyprivate (parser, clauses);
-c_name = "copyprivate";
+	  c_name = "copyprivate";
-break;
+	  break;
-case PRAGMA_OMP_CLAUSE_DEFAULT:
+	case PRAGMA_OMP_CLAUSE_DEFAULT:
-clauses = c_parser_omp_clause_default (parser, clauses);
+	  clauses = c_parser_omp_clause_default (parser, clauses);
-c_name = "default";
+	  c_name = "default";
-break;
+	  break;
-case PRAGMA_OMP_CLAUSE_FIRSTPRIVATE:
+	case PRAGMA_OMP_CLAUSE_FIRSTPRIVATE:
-clauses = c_parser_omp_clause_firstprivate (parser, clauses);
+	  clauses = c_parser_omp_clause_firstprivate (parser, clauses);
-c_name = "firstprivate";
+	  c_name = "firstprivate";
-break;
+	  break;
-case PRAGMA_OMP_CLAUSE_IF:
+	case PRAGMA_OMP_CLAUSE_IF:
-clauses = c_parser_omp_clause_if (parser, clauses);
+	  clauses = c_parser_omp_clause_if (parser, clauses);
-c_name = "if";
+	  c_name = "if";
-break;
+	  break;
-case PRAGMA_OMP_CLAUSE_LASTPRIVATE:
+	case PRAGMA_OMP_CLAUSE_LASTPRIVATE:
-clauses = c_parser_omp_clause_lastprivate (parser, clauses);
+	  clauses = c_parser_omp_clause_lastprivate (parser, clauses);
-c_name = "lastprivate";
+	  c_name = "lastprivate";
-break;
+	  break;
-case PRAGMA_OMP_CLAUSE_NOWAIT:
+	case PRAGMA_OMP_CLAUSE_NOWAIT:
-clauses = c_parser_omp_clause_nowait (parser, clauses);
+	  clauses = c_parser_omp_clause_nowait (parser, clauses);
-c_name = "nowait";
+	  c_name = "nowait";
-break;
+	  break;
-case PRAGMA_OMP_CLAUSE_NUM_THREADS:
+	case PRAGMA_OMP_CLAUSE_NUM_THREADS:
-clauses = c_parser_omp_clause_num_threads (parser, clauses);
+	  clauses = c_parser_omp_clause_num_threads (parser, clauses);
-c_name = "num_threads";
+	  c_name = "num_threads";
-break;
+	  break;
-case PRAGMA_OMP_CLAUSE_ORDERED:
+	case PRAGMA_OMP_CLAUSE_ORDERED:
-clauses = c_parser_omp_clause_ordered (parser, clauses);
+	  clauses = c_parser_omp_clause_ordered (parser, clauses);
-c_name = "ordered";
+	  c_name = "ordered";
-break;
+	  break;
-case PRAGMA_OMP_CLAUSE_PRIVATE:
+	case PRAGMA_OMP_CLAUSE_PRIVATE:
-clauses = c_parser_omp_clause_private (parser, clauses);
+	  clauses = c_parser_omp_clause_private (parser, clauses);
-c_name = "private";
+	  c_name = "private";
-break;
+	  break;
-case PRAGMA_OMP_CLAUSE_REDUCTION:
+	case PRAGMA_OMP_CLAUSE_REDUCTION:
-clauses = c_parser_omp_clause_reduction (parser, clauses);
+	  clauses = c_parser_omp_clause_reduction (parser, clauses);
-c_name = "reduction";
+	  c_name = "reduction";
-break;
+	  break;
-case PRAGMA_OMP_CLAUSE_SCHEDULE:
+	case PRAGMA_OMP_CLAUSE_SCHEDULE:
-clauses = c_parser_omp_clause_schedule (parser, clauses);
+	  clauses = c_parser_omp_clause_schedule (parser, clauses);
-c_name = "schedule";
+	  c_name = "schedule";
-break;
+	  break;
-case PRAGMA_OMP_CLAUSE_SHARED:
+	case PRAGMA_OMP_CLAUSE_SHARED:
-clauses = c_parser_omp_clause_shared (parser, clauses);
+	  clauses = c_parser_omp_clause_shared (parser, clauses);
-c_name = "shared";
+	  c_name = "shared";
-break;
+	  break;
-case PRAGMA_OMP_CLAUSE_UNTIED:
+	case PRAGMA_OMP_CLAUSE_UNTIED:
-clauses = c_parser_omp_clause_untied (parser, clauses);
+	  clauses = c_parser_omp_clause_untied (parser, clauses);
-c_name = "untied";
+	  c_name = "untied";
-break;
+	  break;
-default:
+	default:
-c_parser_error (parser, "expected %<#pragma omp%> clause");
+	  c_parser_error (parser, "expected %<#pragma omp%> clause");
-goto saw_error;
+	  goto saw_error;
-}
+	}
 if (((mask >> c_kind) & 1) == 0 && !parser->error)
-{
+	{
-/* Remove the invalid clause(s) from the list to avoid
+	  /* Remove the invalid clause(s) from the list to avoid
-confusing the rest of the compiler.  */
+	     confusing the rest of the compiler.  */
-clauses = prev;
+	  clauses = prev;
-error_at (here, "%qs is not valid for %qs", c_name, where);
+	  error_at (here, "%qs is not valid for %qs", c_name, where);
-}
+	}
 }
 saw_error:
 c_parser_skip_to_pragma_eol (parser);
 	    }
 	}
 /* FALLTHRU */
 default:
 switch (c_parser_peek_token (parser)->type)
-{
+	{
-case CPP_MULT_EQ:
+	case CPP_MULT_EQ:
-code = MULT_EXPR;
+	  code = MULT_EXPR;
-break;
+	  break;
-case CPP_DIV_EQ:
+	case CPP_DIV_EQ:
-code = TRUNC_DIV_EXPR;
+	  code = TRUNC_DIV_EXPR;
-break;
+	  break;
-case CPP_PLUS_EQ:
+	case CPP_PLUS_EQ:
-code = PLUS_EXPR;
+	  code = PLUS_EXPR;
-break;
+	  break;
-case CPP_MINUS_EQ:
+	case CPP_MINUS_EQ:
-code = MINUS_EXPR;
+	  code = MINUS_EXPR;
-break;
+	  break;
-case CPP_LSHIFT_EQ:
+	case CPP_LSHIFT_EQ:
-code = LSHIFT_EXPR;
+	  code = LSHIFT_EXPR;
-break;
+	  break;
-case CPP_RSHIFT_EQ:
+	case CPP_RSHIFT_EQ:
-code = RSHIFT_EXPR;
+	  code = RSHIFT_EXPR;
-break;
+	  break;
-case CPP_AND_EQ:
+	case CPP_AND_EQ:
-code = BIT_AND_EXPR;
+	  code = BIT_AND_EXPR;
-break;
+	  break;
-case CPP_OR_EQ:
+	case CPP_OR_EQ:
-code = BIT_IOR_EXPR;
+	  code = BIT_IOR_EXPR;
-break;
+	  break;
-case CPP_XOR_EQ:
+	case CPP_XOR_EQ:
-code = BIT_XOR_EXPR;
+	  code = BIT_XOR_EXPR;
-break;
+	  break;
-default:
+	default:
-c_parser_error (parser,
+	  c_parser_error (parser,
-"invalid operator for %<#pragma omp atomic%>");
+			  "invalid operator for %<#pragma omp atomic%>");
-goto saw_error;
+	  goto saw_error;
-}
+	}
 /* Arrange to pass the location of the assignment operator to
 	 c_finish_omp_atomic.  */
 loc = c_parser_peek_token (parser)->location;
 c_parser_consume_token (parser);
 if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
 {
 c_parser_consume_token (parser);
 if (c_parser_next_token_is (parser, CPP_NAME))
-{
+	{
-name = c_parser_peek_token (parser)->value;
+	  name = c_parser_peek_token (parser)->value;
-c_parser_consume_token (parser);
+	  c_parser_consume_token (parser);
-c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>");
+	  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");
 c_parser_skip_to_pragma_eol (parser);
 so that we can push a new decl if necessary to make it private.
 LOC is the location of the OMP in "#pragma omp".  */
 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;
 bool fail = false, open_brace_parsed = false;
 int i, collapse = 1, nbraces = 0;
 for (i = 0; i < collapse; i++)
 {
 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))
 	{
 	  if (i > 0)
 	  init = c_process_expr_stmt (init_loc, init);
 	  c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
 	}
 else
-{
+	{
-error_init:
+	error_init:
-c_parser_error (parser,
+	  c_parser_error (parser,
-"expected iteration declaration or initialization");
+			  "expected iteration declaration or initialization");
-c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
+	  c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
-"expected %<)%>");
+				     "expected %<)%>");
-fail = true;
+	  fail = true;
-goto parse_next;
+	  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;
+	  location_t cond_loc = c_parser_peek_token (parser)->location;
-struct c_expr cond_expr = c_parser_binary_expression (parser, NULL);
+	  struct c_expr cond_expr = c_parser_binary_expression (parser, NULL);
-cond = cond_expr.value;
+	  cond = cond_expr.value;
-cond = c_objc_common_truthvalue_conversion (cond_loc, cond);
+	  cond = c_objc_common_truthvalue_conversion (cond_loc, cond);
-cond = c_fully_fold (cond, false, NULL);
+	  cond = c_fully_fold (cond, false, NULL);
-switch (cond_expr.original_code)
+	  switch (cond_expr.original_code)
-{
+	    {
-case GT_EXPR:
+	    case GT_EXPR:
-case GE_EXPR:
+	    case GE_EXPR:
-case LT_EXPR:
+	    case LT_EXPR:
-case LE_EXPR:
+	    case LE_EXPR:
-break;
+	      break;
-default:
+	    default:
-/* Can't be cond = error_mark_node, because we want to preserve
+	      /* Can't be cond = error_mark_node, because we want to preserve
-the location until c_finish_omp_for.  */
+		 the location until c_finish_omp_for.  */
-cond = build1 (NOP_EXPR, boolean_type_node, error_mark_node);
+	      cond = build1 (NOP_EXPR, boolean_type_node, error_mark_node);
-break;
+	      break;
-}
+	    }
-protected_set_expr_location (cond, cond_loc);
+	  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;
+	  location_t incr_loc = c_parser_peek_token (parser)->location;
-incr = c_process_expr_stmt (incr_loc,
+	  incr = c_process_expr_stmt (incr_loc,
-c_parser_expression (parser).value);
+				      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 (declv, i) = decl;
-TREE_VEC_ELT (initv, i) = init;
+	  TREE_VEC_ELT (initv, i) = init;
-TREE_VEC_ELT (condv, i) = cond;
+	  TREE_VEC_ELT (condv, i) = cond;
-TREE_VEC_ELT (incrv, i) = incr;
+	  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
+	 in between the collapsed for loops to be still considered perfectly
-nested.  Hopefully the final version clarifies this.
+	 nested.  Hopefully the final version clarifies this.
-For now handle (multiple) {'s and empty statements.  */
+	 For now handle (multiple) {'s and empty statements.  */
 do
-{
+	{
-if (c_parser_next_token_is_keyword (parser, RID_FOR))
+	  if (c_parser_next_token_is_keyword (parser, RID_FOR))
-{
+	    {
-c_parser_consume_token (parser);
+	      c_parser_consume_token (parser);
-break;
+	      break;
-}
+	    }
-else if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
+	  else if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
-{
+	    {
-c_parser_consume_token (parser);
+	      c_parser_consume_token (parser);
-bracecount++;
+	      bracecount++;
-}
+	    }
-else if (bracecount
+	  else if (bracecount
-&& c_parser_next_token_is (parser, CPP_SEMICOLON))
+		   && c_parser_next_token_is (parser, CPP_SEMICOLON))
-c_parser_consume_token (parser);
+	    c_parser_consume_token (parser);
-else
+	  else
-{
+	    {
-c_parser_error (parser, "not enough perfectly nested loops");
+	      c_parser_error (parser, "not enough perfectly nested loops");
-if (bracecount)
+	      if (bracecount)
-{
+		{
-open_brace_parsed = true;
+		  open_brace_parsed = true;
-bracecount--;
+		  bracecount--;
-}
+		}
-fail = true;
+	      fail = true;
-collapse = 0;
+	      collapse = 0;
-break;
+	      break;
-}
+	    }
-}
+	}
 while (1);
 nbraces += bracecount;
 }
 c_cont_label = save_cont;
 while (nbraces)
 {
 if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
-{
+	{
-c_parser_consume_token (parser);
+	  c_parser_consume_token (parser);
-nbraces--;
+	  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");
+	  c_parser_error (parser, "collapsed loops not perfectly nested");
-while (nbraces)
+	  while (nbraces)
-{
+	    {
-location_t here = c_parser_peek_token (parser)->location;
+	      location_t here = c_parser_peek_token (parser)->location;
-stmt = c_begin_compound_stmt (true);
+	      stmt = c_begin_compound_stmt (true);
-add_stmt (body);
+	      add_stmt (body);
-c_parser_compound_statement_nostart (parser);
+	      c_parser_compound_statement_nostart (parser);
-body = c_end_compound_stmt (here, stmt, true);
+	      body = c_end_compound_stmt (here, stmt, true);
-nbraces--;
+	      nbraces--;
-}
+	    }
-goto pop_scopes;
+	  goto pop_scopes;
-}
+	}
 }
 /* Only bother calling c_finish_omp_for if we haven't already generated
 an error from the initialization parsing.  */
 if (!fail)
 {
 stmt = c_finish_omp_for (loc, declv, initv, condv, incrv, body, NULL);
 if (stmt)
-{
+	{
-if (par_clauses != NULL)
+	  if (par_clauses != NULL)
-{
+	    {
-tree *c;
+	      tree *c;
-for (c = par_clauses; *c ; )
+	      for (c = par_clauses; *c ; )
-if (OMP_CLAUSE_CODE (*c) != OMP_CLAUSE_FIRSTPRIVATE
+		if (OMP_CLAUSE_CODE (*c) != OMP_CLAUSE_FIRSTPRIVATE
-&& OMP_CLAUSE_CODE (*c) != OMP_CLAUSE_LASTPRIVATE)
+		    && OMP_CLAUSE_CODE (*c) != OMP_CLAUSE_LASTPRIVATE)
-c = &OMP_CLAUSE_CHAIN (*c);
+		  c = &OMP_CLAUSE_CHAIN (*c);
-else
+		else
-{
+		  {
-for (i = 0; i < collapse; i++)
+		    for (i = 0; i < collapse; i++)
-if (TREE_VEC_ELT (declv, i) == OMP_CLAUSE_DECL (*c))
+		      if (TREE_VEC_ELT (declv, i) == OMP_CLAUSE_DECL (*c))
-break;
+			break;
-if (i == collapse)
+		    if (i == collapse)
-c = &OMP_CLAUSE_CHAIN (*c);
+		      c = &OMP_CLAUSE_CHAIN (*c);
-else if (OMP_CLAUSE_CODE (*c) == OMP_CLAUSE_FIRSTPRIVATE)
+		    else if (OMP_CLAUSE_CODE (*c) == OMP_CLAUSE_FIRSTPRIVATE)
-{
+		      {
-error_at (loc,
+			error_at (loc,
-"iteration variable %qD should not be firstprivate",
+				  "iteration variable %qD should not be firstprivate",
-OMP_CLAUSE_DECL (*c));
+				  OMP_CLAUSE_DECL (*c));
-*c = OMP_CLAUSE_CHAIN (*c);
+			*c = OMP_CLAUSE_CHAIN (*c);
-}
+		      }
-else
+		    else
-{
+		      {
-/* Copy lastprivate (decl) clause to OMP_FOR_CLAUSES,
+			/* Copy lastprivate (decl) clause to OMP_FOR_CLAUSES,
-change it to shared (decl) in
+			   change it to shared (decl) in
-OMP_PARALLEL_CLAUSES.  */
+			   OMP_PARALLEL_CLAUSES.  */
-tree l = build_omp_clause (OMP_CLAUSE_LOCATION (*c),
+			tree l = build_omp_clause (OMP_CLAUSE_LOCATION (*c),
-OMP_CLAUSE_LASTPRIVATE);
+						   OMP_CLAUSE_LASTPRIVATE);
-OMP_CLAUSE_DECL (l) = OMP_CLAUSE_DECL (*c);
+			OMP_CLAUSE_DECL (l) = OMP_CLAUSE_DECL (*c);
-OMP_CLAUSE_CHAIN (l) = clauses;
+			OMP_CLAUSE_CHAIN (l) = clauses;
-clauses = l;
+			clauses = l;
-OMP_CLAUSE_SET_CODE (*c, OMP_CLAUSE_SHARED);
+			OMP_CLAUSE_SET_CODE (*c, OMP_CLAUSE_SHARED);
-}
+		      }
-}
+		  }
-}
+	    }
-OMP_FOR_CLAUSES (stmt) = clauses;
+	  OMP_FOR_CLAUSES (stmt) = clauses;
-}
+	}
 ret = stmt;
 }
 pop_scopes:
 while (!VEC_empty (tree, for_block))
 {
 for-loop
 LOC is the location of the #pragma token.
 */
-#define OMP_FOR_CLAUSE_MASK             \
+#define OMP_FOR_CLAUSE_MASK				\
-( (1u << PRAGMA_OMP_CLAUSE_PRIVATE)     \
+	( (1u << PRAGMA_OMP_CLAUSE_PRIVATE)		\
-| (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE)    \
+	| (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE)	\
-| (1u << PRAGMA_OMP_CLAUSE_LASTPRIVATE)     \
+	| (1u << PRAGMA_OMP_CLAUSE_LASTPRIVATE)		\
-| (1u << PRAGMA_OMP_CLAUSE_REDUCTION)       \
+	| (1u << PRAGMA_OMP_CLAUSE_REDUCTION)		\
-| (1u << PRAGMA_OMP_CLAUSE_ORDERED)     \
+	| (1u << PRAGMA_OMP_CLAUSE_ORDERED)		\
-| (1u << PRAGMA_OMP_CLAUSE_SCHEDULE)        \
+	| (1u << PRAGMA_OMP_CLAUSE_SCHEDULE)		\
-| (1u << PRAGMA_OMP_CLAUSE_COLLAPSE)        \
+	| (1u << PRAGMA_OMP_CLAUSE_COLLAPSE)		\
-| (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
+	| (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
 static tree
 c_parser_omp_for (location_t loc, c_parser *parser)
 {
 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);
 block = c_end_compound_stmt (loc, block, true);
 add_stmt (block);
 if (c_parser_peek_token (parser)->pragma_kind != PRAGMA_OMP_SECTION)
 {
 substmt = push_stmt_list ();
 while (1)
-{
+	{
 c_parser_statement (parser);
-if (c_parser_peek_token (parser)->pragma_kind == PRAGMA_OMP_SECTION)
+	  if (c_parser_peek_token (parser)->pragma_kind == PRAGMA_OMP_SECTION)
-break;
+	    break;
-if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
+	  if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
-break;
+	    break;
-if (c_parser_next_token_is (parser, CPP_EOF))
+	  if (c_parser_next_token_is (parser, CPP_EOF))
-break;
+	    break;
-}
+	}
 substmt = pop_stmt_list (substmt);
 substmt = build1 (OMP_SECTION, void_type_node, substmt);
 SET_EXPR_LOCATION (substmt, loc);
 add_stmt (substmt);
 }
 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_consume_pragma (parser);
-c_parser_skip_to_pragma_eol (parser);
+	  c_parser_skip_to_pragma_eol (parser);
-error_suppress = false;
+	  error_suppress = false;
-}
+	}
 else if (!error_suppress)
-{
+	{
-error_at (loc, "expected %<#pragma omp section%> or %<}%>");
+	  error_at (loc, "expected %<#pragma omp section%> or %<}%>");
-error_suppress = true;
+	  error_suppress = true;
-}
+	}
 substmt = c_parser_omp_structured_block (parser);
 substmt = build1 (OMP_SECTION, void_type_node, substmt);
 SET_EXPR_LOCATION (substmt, loc);
 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);
 stmt = make_node (OMP_SECTIONS);
 SET_EXPR_LOCATION (stmt, sections_loc);
 sections-scope
 LOC is the location of the #pragma token.
 */
-#define OMP_SECTIONS_CLAUSE_MASK            \
+#define OMP_SECTIONS_CLAUSE_MASK			\
-( (1u << PRAGMA_OMP_CLAUSE_PRIVATE)     \
+	( (1u << PRAGMA_OMP_CLAUSE_PRIVATE)		\
-| (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE)    \
+	| (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE)	\
-| (1u << PRAGMA_OMP_CLAUSE_LASTPRIVATE)     \
+	| (1u << PRAGMA_OMP_CLAUSE_LASTPRIVATE)		\
-| (1u << PRAGMA_OMP_CLAUSE_REDUCTION)       \
+	| (1u << PRAGMA_OMP_CLAUSE_REDUCTION)		\
-| (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
+	| (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
 static tree
 c_parser_omp_sections (location_t loc, c_parser *parser)
 {
 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);
 if (ret)
 OMP_SECTIONS_CLAUSES (ret) = clauses;
 # pragma parallel sections parallel-sections-clause new-line
 LOC is the location of the #pragma token.
 */
-#define OMP_PARALLEL_CLAUSE_MASK            \
+#define OMP_PARALLEL_CLAUSE_MASK			\
-( (1u << PRAGMA_OMP_CLAUSE_IF)          \
+	( (1u << PRAGMA_OMP_CLAUSE_IF)			\
-| (1u << PRAGMA_OMP_CLAUSE_PRIVATE)     \
+	| (1u << PRAGMA_OMP_CLAUSE_PRIVATE)		\
-| (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE)    \
+	| (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE)	\
-| (1u << PRAGMA_OMP_CLAUSE_DEFAULT)     \
+	| (1u << PRAGMA_OMP_CLAUSE_DEFAULT)		\
-| (1u << PRAGMA_OMP_CLAUSE_SHARED)      \
+	| (1u << PRAGMA_OMP_CLAUSE_SHARED)		\
-| (1u << PRAGMA_OMP_CLAUSE_COPYIN)      \
+	| (1u << PRAGMA_OMP_CLAUSE_COPYIN)		\
-| (1u << PRAGMA_OMP_CLAUSE_REDUCTION)       \
+	| (1u << PRAGMA_OMP_CLAUSE_REDUCTION)		\
-| (1u << PRAGMA_OMP_CLAUSE_NUM_THREADS))
+	| (1u << PRAGMA_OMP_CLAUSE_NUM_THREADS))
 static tree
 c_parser_omp_parallel (location_t loc, c_parser *parser)
 {
 enum pragma_kind p_kind = PRAGMA_OMP_PARALLEL;
 }
 else if (c_parser_next_token_is (parser, CPP_NAME))
 {
 const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
 if (strcmp (p, "sections") == 0)
-{
+	{
-c_parser_consume_token (parser);
+	  c_parser_consume_token (parser);
-p_kind = PRAGMA_OMP_PARALLEL_SECTIONS;
+	  p_kind = PRAGMA_OMP_PARALLEL_SECTIONS;
-p_name = "#pragma omp parallel sections";
+	  p_name = "#pragma omp parallel sections";
-mask |= OMP_SECTIONS_CLAUSE_MASK;
+	  mask |= OMP_SECTIONS_CLAUSE_MASK;
-mask &= ~(1u << PRAGMA_OMP_CLAUSE_NOWAIT);
+	  mask &= ~(1u << PRAGMA_OMP_CLAUSE_NOWAIT);
-}
+	}
 }
 clauses = c_parser_omp_all_clauses (parser, mask, p_name);
 switch (p_kind)
 case PRAGMA_OMP_PARALLEL_SECTIONS:
 block = c_begin_omp_parallel ();
 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;
 default:
 structured-block
 LOC is the location of the #pragma.
 */
-#define OMP_SINGLE_CLAUSE_MASK              \
+#define OMP_SINGLE_CLAUSE_MASK				\
-( (1u << PRAGMA_OMP_CLAUSE_PRIVATE)     \
+	( (1u << PRAGMA_OMP_CLAUSE_PRIVATE)		\
-| (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE)    \
+	| (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE)	\
-| (1u << PRAGMA_OMP_CLAUSE_COPYPRIVATE)     \
+	| (1u << PRAGMA_OMP_CLAUSE_COPYPRIVATE)		\
-| (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
+	| (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
 static tree
 c_parser_omp_single (location_t loc, c_parser *parser)
 {
 tree stmt = make_node (OMP_SINGLE);
 SET_EXPR_LOCATION (stmt, loc);
 TREE_TYPE (stmt) = void_type_node;
 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);
 }
 # pragma omp task task-clause[optseq] new-line
 LOC is the location of the #pragma.
 */
-#define OMP_TASK_CLAUSE_MASK                \
+#define OMP_TASK_CLAUSE_MASK				\
-( (1u << PRAGMA_OMP_CLAUSE_IF)          \
+	( (1u << PRAGMA_OMP_CLAUSE_IF)			\
-| (1u << PRAGMA_OMP_CLAUSE_UNTIED)      \
+	| (1u << PRAGMA_OMP_CLAUSE_UNTIED)		\
-| (1u << PRAGMA_OMP_CLAUSE_DEFAULT)     \
+	| (1u << PRAGMA_OMP_CLAUSE_DEFAULT)		\
-| (1u << PRAGMA_OMP_CLAUSE_PRIVATE)     \
+	| (1u << PRAGMA_OMP_CLAUSE_PRIVATE)		\
-| (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE)    \
+	| (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE)	\
-| (1u << PRAGMA_OMP_CLAUSE_SHARED))
+	| (1u << PRAGMA_OMP_CLAUSE_SHARED))
 static tree
 c_parser_omp_task (location_t loc, c_parser *parser)
 {
 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);
 return c_finish_omp_task (loc, clauses, block);
 }
 for (t = vars; t; t = TREE_CHAIN (t))
 {
 tree v = TREE_PURPOSE (t);
 /* FIXME diagnostics: Ideally we should keep individual
-locations for all the variables in the var list to make the
+	 locations for all the variables in the var list to make the
-following errors more precise.  Perhaps
+	 following errors more precise.  Perhaps
-c_parser_omp_var_list_parens() should construct a list of
+	 c_parser_omp_var_list_parens() should construct a list of
-locations to go along with the var list.  */
+	 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))
+	  if (! DECL_THREAD_LOCAL_P (v))
-{
+	    {
-DECL_TLS_MODEL (v) = decl_default_tls_model (v);
+	      DECL_TLS_MODEL (v) = decl_default_tls_model (v);
-/* If rtl has been already set for this var, call
+	      /* If rtl has been already set for this var, call
-make_decl_rtl once again, so that encode_section_info
+		 make_decl_rtl once again, so that encode_section_info
-has a chance to look at the new decl flags.  */
+		 has a chance to look at the new decl flags.  */
-if (DECL_RTL_SET_P (v))
+	      if (DECL_RTL_SET_P (v))
-make_decl_rtl (v);
+		make_decl_rtl (v);
-}
+	    }
-C_DECL_THREADPRIVATE_P (v) = 1;
+	  C_DECL_THREADPRIVATE_P (v) = 1;
-}
+	}
 }
 c_parser_skip_to_pragma_eol (parser);
 }

Mercurial > hg > CbC > CbC_gcc

comparison gcc/c-parser.c @ 70:b81903832de2