gcc/c-parser.c

   1 /* Parser for C and Objective-C.
   2    Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
   4    Free Software Foundation, Inc.
   5
   6    Parser actions based on the old Bison parser; structure somewhat
   7    influenced by and fragments based on the C++ parser.
   8
   9 This file is part of GCC.
  10
  11 GCC is free software; you can redistribute it and/or modify it under
  12 the terms of the GNU General Public License as published by the Free
  13 Software Foundation; either version 3, or (at your option) any later
  14 version.
  15
  16 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  17 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  19 for more details.
  20
  21 You should have received a copy of the GNU General Public License
  22 along with GCC; see the file COPYING3.  If not see
  23 <http://www.gnu.org/licenses/>.  */
  24
  25 /* TODO:
  26
  27    Make sure all relevant comments, and all relevant code from all
  28    actions, brought over from old parser.  Verify exact correspondence
  29    of syntax accepted.
  30
  31    Add testcases covering every input symbol in every state in old and
  32    new parsers.
  33
  34    Include full syntax for GNU C, including erroneous cases accepted
  35    with error messages, in syntax productions in comments.
  36
  37    Make more diagnostics in the front end generally take an explicit
  38    location rather than implicitly using input_location.  */
  39
  40 #include "config.h"
  41 #include "system.h"
  42 #include "coretypes.h"
  43 #include "tm.h"                 /* For rtl.h: needs enum reg_class.  */
  44 #include "tree.h"
  45 #include "langhooks.h"
  46 #include "input.h"
  47 #include "cpplib.h"
  48 #include "timevar.h"
  49 #include "c-family/c-pragma.h"
  50 #include "c-tree.h"
  51 #include "flags.h"
  52 #include "output.h"
  53 #include "toplev.h"
  54 #include "ggc.h"
  55 #include "c-family/c-common.h"
  56 #include "vec.h"
  57 #include "target.h"
  58 #include "cgraph.h"
  59 #include "plugin.h"
  60
  61 \f
  62 /* Initialization routine for this file.  */
  63
  64 void
  65 c_parse_init (void)
  66 {
  67   /* The only initialization required is of the reserved word
  68      identifiers.  */
  69   unsigned int i;
  70   tree id;
  71   int mask = 0;
  72
  73   /* Make sure RID_MAX hasn't grown past the 8 bits used to hold the keyword in
  74      the c_token structure.  */
  75   gcc_assert (RID_MAX <= 255);
  76
  77   mask |= D_CXXONLY;
  78   if (!flag_isoc99)
  79     mask |= D_C99;
  80   if (flag_no_asm)
  81     {
  82       mask |= D_ASM | D_EXT;
  83       if (!flag_isoc99)
  84         mask |= D_EXT89;
  85     }
  86   if (!c_dialect_objc ())
  87     mask |= D_OBJC | D_CXX_OBJC;
  88
  89   ridpointers = ggc_alloc_cleared_vec_tree ((int) RID_MAX);
  90   for (i = 0; i < num_c_common_reswords; i++)
  91     {
  92       /* If a keyword is disabled, do not enter it into the table
  93          and so create a canonical spelling that isn't a keyword.  */
  94       if (c_common_reswords[i].disable & mask)
  95         {
  96           if (warn_cxx_compat
  97               && (c_common_reswords[i].disable & D_CXXWARN))
  98             {
  99               id = get_identifier (c_common_reswords[i].word);
 100               C_SET_RID_CODE (id, RID_CXX_COMPAT_WARN);
 101               C_IS_RESERVED_WORD (id) = 1;
 102             }
 103           continue;
 104         }
 105
 106       id = get_identifier (c_common_reswords[i].word);
 107       C_SET_RID_CODE (id, c_common_reswords[i].rid);
 108       C_IS_RESERVED_WORD (id) = 1;
 109       ridpointers [(int) c_common_reswords[i].rid] = id;
 110     }
 111 }
 112 \f
 113 /* The C lexer intermediates between the lexer in cpplib and c-lex.c
 114    and the C parser.  Unlike the C++ lexer, the parser structure
 115    stores the lexer information instead of using a separate structure.
 116    Identifiers are separated into ordinary identifiers, type names,
 117    keywords and some other Objective-C types of identifiers, and some
 118    look-ahead is maintained.
 119
 120    ??? It might be a good idea to lex the whole file up front (as for
 121    C++).  It would then be possible to share more of the C and C++
 122    lexer code, if desired.  */
 123
 124 /* The following local token type is used.  */
 125
 126 /* A keyword.  */
 127 #define CPP_KEYWORD ((enum cpp_ttype) (N_TTYPES + 1))
 128
 129 /* More information about the type of a CPP_NAME token.  */
 130 typedef enum c_id_kind {
 131   /* An ordinary identifier.  */
 132   C_ID_ID,
 133   /* An identifier declared as a typedef name.  */
 134   C_ID_TYPENAME,
 135   /* An identifier declared as an Objective-C class name.  */
 136   C_ID_CLASSNAME,
 137   /* An address space identifier.  */
 138   C_ID_ADDRSPACE,
 139   /* Not an identifier.  */
 140   C_ID_NONE
 141 } c_id_kind;
 142
 143 /* A single C token after string literal concatenation and conversion
 144    of preprocessing tokens to tokens.  */
 145 typedef struct GTY (()) c_token {
 146   /* The kind of token.  */
 147   ENUM_BITFIELD (cpp_ttype) type : 8;
 148   /* If this token is a CPP_NAME, this value indicates whether also
 149      declared as some kind of type.  Otherwise, it is C_ID_NONE.  */
 150   ENUM_BITFIELD (c_id_kind) id_kind : 8;
 151   /* If this token is a keyword, this value indicates which keyword.
 152      Otherwise, this value is RID_MAX.  */
 153   ENUM_BITFIELD (rid) keyword : 8;
 154   /* If this token is a CPP_PRAGMA, this indicates the pragma that
 155      was seen.  Otherwise it is PRAGMA_NONE.  */
 156   ENUM_BITFIELD (pragma_kind) pragma_kind : 8;
 157   /* The location at which this token was found.  */
 158   location_t location;
 159   /* The value associated with this token, if any.  */
 160   tree value;
 161 } c_token;
 162
 163 /* A parser structure recording information about the state and
 164    context of parsing.  Includes lexer information with up to two
 165    tokens of look-ahead; more are not needed for C.  */
 166 typedef struct GTY(()) c_parser {
 167   /* The look-ahead tokens.  */
 168   c_token tokens[2];
 169   /* How many look-ahead tokens are available (0, 1 or 2).  */
 170   short tokens_avail;
 171   /* True if a syntax error is being recovered from; false otherwise.
 172      c_parser_error sets this flag.  It should clear this flag when
 173      enough tokens have been consumed to recover from the error.  */
 174   BOOL_BITFIELD error : 1;
 175   /* True if we're processing a pragma, and shouldn't automatically
 176      consume CPP_PRAGMA_EOL.  */
 177   BOOL_BITFIELD in_pragma : 1;
 178   /* True if we're parsing the outermost block of an if statement.  */
 179   BOOL_BITFIELD in_if_block : 1;
 180   /* True if we want to lex an untranslated string.  */
 181   BOOL_BITFIELD lex_untranslated_string : 1;
 182
 183   /* Objective-C specific parser/lexer information.  */
 184
 185   /* True if we are in a context where the Objective-C "PQ" keywords
 186      are considered keywords.  */
 187   BOOL_BITFIELD objc_pq_context : 1;
 188   /* The following flag is needed to contextualize Objective-C lexical
 189      analysis.  In some cases (e.g., 'int NSObject;'), it is
 190      undesirable to bind an identifier to an Objective-C class, even
 191      if a class with that name exists.  */
 192   BOOL_BITFIELD objc_need_raw_identifier : 1;
 193 } c_parser;
 194
 195
 196 /* The actual parser and external interface.  ??? Does this need to be
 197    garbage-collected?  */
 198
 199 static GTY (()) c_parser *the_parser;
 200
 201 /* Read in and lex a single token, storing it in *TOKEN.  */
 202
 203 static void
 204 c_lex_one_token (c_parser *parser, c_token *token)
 205 {
 206   timevar_push (TV_LEX);
 207
 208   token->type = c_lex_with_flags (&token->value, &token->location, NULL,
 209                                   (parser->lex_untranslated_string
 210                                    ? C_LEX_STRING_NO_TRANSLATE : 0));
 211   token->id_kind = C_ID_NONE;
 212   token->keyword = RID_MAX;
 213   token->pragma_kind = PRAGMA_NONE;
 214
 215   switch (token->type)
 216     {
 217     case CPP_NAME:
 218       {
 219         tree decl;
 220
 221         bool objc_force_identifier = parser->objc_need_raw_identifier;
 222         if (c_dialect_objc ())
 223           parser->objc_need_raw_identifier = false;
 224
 225         if (C_IS_RESERVED_WORD (token->value))
 226           {
 227             enum rid rid_code = C_RID_CODE (token->value);
 228
 229             if (rid_code == RID_CXX_COMPAT_WARN)
 230               {
 231                 warning_at (token->location,
 232                             OPT_Wc___compat,
 233                             "identifier %qE conflicts with C++ keyword",
 234                             token->value);
 235               }
 236             else if (rid_code >= RID_FIRST_ADDR_SPACE
 237                      && rid_code <= RID_LAST_ADDR_SPACE)
 238               {
 239                 token->id_kind = C_ID_ADDRSPACE;
 240                 token->keyword = rid_code;
 241                 break;
 242               }
 243             else if (c_dialect_objc () && OBJC_IS_PQ_KEYWORD (rid_code))
 244               {
 245                 /* We found an Objective-C "pq" keyword (in, out,
 246                    inout, bycopy, byref, oneway).  They need special
 247                    care because the interpretation depends on the
 248                    context.
 249                  */
 250                 if (parser->objc_pq_context)
 251                   {
 252                     token->type = CPP_KEYWORD;
 253                     token->keyword = rid_code;
 254                     break;
 255                   }
 256                 /* Else, "pq" keywords outside of the "pq" context are
 257                    not keywords, and we fall through to the code for
 258                    normal tokens.
 259                 */
 260               }
 261             else if (c_dialect_objc ()
 262                      && (OBJC_IS_AT_KEYWORD (rid_code)
 263                          || OBJC_IS_CXX_KEYWORD (rid_code)))
 264               {
 265                 /* We found one of the Objective-C "@" keywords (defs,
 266                    selector, synchronized, etc) or one of the
 267                    Objective-C "cxx" keywords (class, private,
 268                    protected, public, try, catch, throw) without a
 269                    preceding '@' sign.  Do nothing and fall through to
 270                    the code for normal tokens (in C++ we would still
 271                    consider the CXX ones keywords, but not in C).
 272                 */
 273                 ;
 274               }
 275             else
 276               {
 277                 token->type = CPP_KEYWORD;
 278                 token->keyword = rid_code;
 279                 break;
 280               }
 281           }
 282
 283         decl = lookup_name (token->value);
 284         if (decl)
 285           {
 286             if (TREE_CODE (decl) == TYPE_DECL)
 287               {
 288                 token->id_kind = C_ID_TYPENAME;
 289                 break;
 290               }
 291           }
 292         else if (c_dialect_objc ())
 293           {
 294             tree objc_interface_decl = objc_is_class_name (token->value);
 295             /* Objective-C class names are in the same namespace as
 296                variables and typedefs, and hence are shadowed by local
 297                declarations.  */
 298             if (objc_interface_decl
 299                 && (global_bindings_p ()
 300                     || (!objc_force_identifier && !decl)))
 301               {
 302                 token->value = objc_interface_decl;
 303                 token->id_kind = C_ID_CLASSNAME;
 304                 break;
 305               }
 306           }
 307         token->id_kind = C_ID_ID;
 308       }
 309       break;
 310     case CPP_AT_NAME:
 311       /* This only happens in Objective-C; it must be a keyword.  */
 312       token->type = CPP_KEYWORD;
 313       switch (C_RID_CODE (token->value))
 314         {
 315           /* Replace 'class' with '@class', 'private' with '@private',
 316              etc.  This prevents confusion with the C++ keyword
 317              'class', and makes the tokens consistent with other
 318              Objective-C 'AT' keywords.  For example '@class' is
 319              reported as RID_AT_CLASS which is consistent with
 320              '@synchronized', which is reported as
 321              RID_AT_SYNCHRONIZED.
 322           */
 323         case RID_CLASS:     token->keyword = RID_AT_CLASS; break;
 324         case RID_PRIVATE:   token->keyword = RID_AT_PRIVATE; break;
 325         case RID_PROTECTED: token->keyword = RID_AT_PROTECTED; break;
 326         case RID_PUBLIC:    token->keyword = RID_AT_PUBLIC; break;
 327         case RID_THROW:     token->keyword = RID_AT_THROW; break;
 328         case RID_TRY:       token->keyword = RID_AT_TRY; break;
 329         case RID_CATCH:     token->keyword = RID_AT_CATCH; break;
 330         default:            token->keyword = C_RID_CODE (token->value);
 331         }
 332       break;
 333     case CPP_COLON:
 334     case CPP_COMMA:
 335     case CPP_CLOSE_PAREN:
 336     case CPP_SEMICOLON:
 337       /* These tokens may affect the interpretation of any identifiers
 338          following, if doing Objective-C.  */
 339       if (c_dialect_objc ())
 340         parser->objc_need_raw_identifier = false;
 341       break;
 342     case CPP_PRAGMA:
 343       /* We smuggled the cpp_token->u.pragma value in an INTEGER_CST.  */
 344       token->pragma_kind = (enum pragma_kind) TREE_INT_CST_LOW (token->value);
 345       token->value = NULL;
 346       break;
 347     default:
 348       break;
 349     }
 350   timevar_pop (TV_LEX);
 351 }
 352
 353 /* Return a pointer to the next token from PARSER, reading it in if
 354    necessary.  */
 355
 356 static inline c_token *
 357 c_parser_peek_token (c_parser *parser)
 358 {
 359   if (parser->tokens_avail == 0)
 360     {
 361       c_lex_one_token (parser, &parser->tokens[0]);
 362       parser->tokens_avail = 1;
 363     }
 364   return &parser->tokens[0];
 365 }
 366
 367 /* Return true if the next token from PARSER has the indicated
 368    TYPE.  */
 369
 370 static inline bool
 371 c_parser_next_token_is (c_parser *parser, enum cpp_ttype type)
 372 {
 373   return c_parser_peek_token (parser)->type == type;
 374 }
 375
 376 /* Return true if the next token from PARSER does not have the
 377    indicated TYPE.  */
 378
 379 static inline bool
 380 c_parser_next_token_is_not (c_parser *parser, enum cpp_ttype type)
 381 {
 382   return !c_parser_next_token_is (parser, type);
 383 }
 384
 385 /* Return true if the next token from PARSER is the indicated
 386    KEYWORD.  */
 387
 388 static inline bool
 389 c_parser_next_token_is_keyword (c_parser *parser, enum rid keyword)
 390 {
 391   return c_parser_peek_token (parser)->keyword == keyword;
 392 }
 393
 394 /* Return true if TOKEN can start a type name,
 395    false otherwise.  */
 396 static bool
 397 c_token_starts_typename (c_token *token)
 398 {
 399   switch (token->type)
 400     {
 401     case CPP_NAME:
 402       switch (token->id_kind)
 403         {
 404         case C_ID_ID:
 405           return false;
 406         case C_ID_ADDRSPACE:
 407           return true;
 408         case C_ID_TYPENAME:
 409           return true;
 410         case C_ID_CLASSNAME:
 411           gcc_assert (c_dialect_objc ());
 412           return true;
 413         default:
 414           gcc_unreachable ();
 415         }
 416     case CPP_KEYWORD:
 417       switch (token->keyword)
 418         {
 419         case RID_UNSIGNED:
 420         case RID_LONG:
 421         case RID_INT128:
 422         case RID_SHORT:
 423         case RID_SIGNED:
 424         case RID_COMPLEX:
 425         case RID_INT:
 426         case RID_CHAR:
 427         case RID_FLOAT:
 428         case RID_DOUBLE:
 429         case RID_VOID:
 430         case RID_DFLOAT32:
 431         case RID_DFLOAT64:
 432         case RID_DFLOAT128:
 433         case RID_BOOL:
 434         case RID_ENUM:
 435         case RID_STRUCT:
 436         case RID_UNION:
 437         case RID_TYPEOF:
 438         case RID_CONST:
 439         case RID_VOLATILE:
 440         case RID_RESTRICT:
 441         case RID_ATTRIBUTE:
 442         case RID_FRACT:
 443         case RID_ACCUM:
 444         case RID_SAT:
 445           return true;
 446         default:
 447           return false;
 448         }
 449     case CPP_LESS:
 450       if (c_dialect_objc ())
 451         return true;
 452       return false;
 453     default:
 454       return false;
 455     }
 456 }
 457
 458 /* Return true if the next token from PARSER can start a type name,
 459    false otherwise.  */
 460 static inline bool
 461 c_parser_next_token_starts_typename (c_parser *parser)
 462 {
 463   c_token *token = c_parser_peek_token (parser);
 464   return c_token_starts_typename (token);
 465 }
 466
 467 /* Return true if TOKEN can start declaration specifiers, false
 468    otherwise.  */
 469 static bool
 470 c_token_starts_declspecs (c_token *token)
 471 {
 472   switch (token->type)
 473     {
 474     case CPP_NAME:
 475       switch (token->id_kind)
 476         {
 477         case C_ID_ID:
 478           return false;
 479         case C_ID_ADDRSPACE:
 480           return true;
 481         case C_ID_TYPENAME:
 482           return true;
 483         case C_ID_CLASSNAME:
 484           gcc_assert (c_dialect_objc ());
 485           return true;
 486         default:
 487           gcc_unreachable ();
 488         }
 489     case CPP_KEYWORD:
 490       switch (token->keyword)
 491         {
 492         case RID_STATIC:
 493         case RID_EXTERN:
 494         case RID_REGISTER:
 495         case RID_TYPEDEF:
 496         case RID_INLINE:
 497         case RID_AUTO:
 498         case RID_THREAD:
 499         case RID_UNSIGNED:
 500         case RID_LONG:
 501         case RID_INT128:
 502         case RID_SHORT:
 503         case RID_SIGNED:
 504         case RID_COMPLEX:
 505         case RID_INT:
 506         case RID_CHAR:
 507         case RID_FLOAT:
 508         case RID_DOUBLE:
 509         case RID_VOID:
 510         case RID_DFLOAT32:
 511         case RID_DFLOAT64:
 512         case RID_DFLOAT128:
 513         case RID_BOOL:
 514         case RID_ENUM:
 515         case RID_STRUCT:
 516         case RID_UNION:
 517         case RID_TYPEOF:
 518         case RID_CONST:
 519         case RID_VOLATILE:
 520         case RID_RESTRICT:
 521         case RID_ATTRIBUTE:
 522         case RID_FRACT:
 523         case RID_ACCUM:
 524         case RID_SAT:
 525           return true;
 526         default:
 527           return false;
 528         }
 529     case CPP_LESS:
 530       if (c_dialect_objc ())
 531         return true;
 532       return false;
 533     default:
 534       return false;
 535     }
 536 }
 537
 538
 539 /* Return true if TOKEN can start declaration specifiers or a static
 540    assertion, false otherwise.  */
 541 static bool
 542 c_token_starts_declaration (c_token *token)
 543 {
 544   if (c_token_starts_declspecs (token)
 545       || token->keyword == RID_STATIC_ASSERT)
 546     return true;
 547   else
 548     return false;
 549 }
 550
 551 /* Return true if the next token from PARSER can start declaration
 552    specifiers, false otherwise.  */
 553 static inline bool
 554 c_parser_next_token_starts_declspecs (c_parser *parser)
 555 {
 556   c_token *token = c_parser_peek_token (parser);
 557   return c_token_starts_declspecs (token);
 558 }
 559
 560 /* Return true if the next token from PARSER can start declaration
 561    specifiers or a static assertion, false otherwise.  */
 562 static inline bool
 563 c_parser_next_token_starts_declaration (c_parser *parser)
 564 {
 565   c_token *token = c_parser_peek_token (parser);
 566   return c_token_starts_declaration (token);
 567 }
 568
 569 /* Return a pointer to the next-but-one token from PARSER, reading it
 570    in if necessary.  The next token is already read in.  */
 571
 572 static c_token *
 573 c_parser_peek_2nd_token (c_parser *parser)
 574 {
 575   if (parser->tokens_avail >= 2)
 576     return &parser->tokens[1];
 577   gcc_assert (parser->tokens_avail == 1);
 578   gcc_assert (parser->tokens[0].type != CPP_EOF);
 579   gcc_assert (parser->tokens[0].type != CPP_PRAGMA_EOL);
 580   c_lex_one_token (parser, &parser->tokens[1]);
 581   parser->tokens_avail = 2;
 582   return &parser->tokens[1];
 583 }
 584
 585 /* Consume the next token from PARSER.  */
 586
 587 static void
 588 c_parser_consume_token (c_parser *parser)
 589 {
 590   gcc_assert (parser->tokens_avail >= 1);
 591   gcc_assert (parser->tokens[0].type != CPP_EOF);
 592   gcc_assert (!parser->in_pragma || parser->tokens[0].type != CPP_PRAGMA_EOL);
 593   gcc_assert (parser->error || parser->tokens[0].type != CPP_PRAGMA);
 594   if (parser->tokens_avail == 2)
 595     parser->tokens[0] = parser->tokens[1];
 596   parser->tokens_avail--;
 597 }
 598
 599 /* Expect the current token to be a #pragma.  Consume it and remember
 600    that we've begun parsing a pragma.  */
 601
 602 static void
 603 c_parser_consume_pragma (c_parser *parser)
 604 {
 605   gcc_assert (!parser->in_pragma);
 606   gcc_assert (parser->tokens_avail >= 1);
 607   gcc_assert (parser->tokens[0].type == CPP_PRAGMA);
 608   if (parser->tokens_avail == 2)
 609     parser->tokens[0] = parser->tokens[1];
 610   parser->tokens_avail--;
 611   parser->in_pragma = true;
 612 }
 613
 614 /* Update the globals input_location and in_system_header from
 615    TOKEN.  */
 616 static inline void
 617 c_parser_set_source_position_from_token (c_token *token)
 618 {
 619   if (token->type != CPP_EOF)
 620     {
 621       input_location = token->location;
 622     }
 623 }
 624
 625 /* Issue a diagnostic of the form
 626       FILE:LINE: MESSAGE before TOKEN
 627    where TOKEN is the next token in the input stream of PARSER.
 628    MESSAGE (specified by the caller) is usually of the form "expected
 629    OTHER-TOKEN".
 630
 631    Do not issue a diagnostic if still recovering from an error.
 632
 633    ??? This is taken from the C++ parser, but building up messages in
 634    this way is not i18n-friendly and some other approach should be
 635    used.  */
 636
 637 static void
 638 c_parser_error (c_parser *parser, const char *gmsgid)
 639 {
 640   c_token *token = c_parser_peek_token (parser);
 641   if (parser->error)
 642     return;
 643   parser->error = true;
 644   if (!gmsgid)
 645     return;
 646   /* This diagnostic makes more sense if it is tagged to the line of
 647      the token we just peeked at.  */
 648   c_parser_set_source_position_from_token (token);
 649   c_parse_error (gmsgid,
 650                  /* Because c_parse_error does not understand
 651                     CPP_KEYWORD, keywords are treated like
 652                     identifiers.  */
 653                  (token->type == CPP_KEYWORD ? CPP_NAME : token->type),
 654                  /* ??? The C parser does not save the cpp flags of a
 655                     token, we need to pass 0 here and we will not get
 656                     the source spelling of some tokens but rather the
 657                     canonical spelling.  */
 658                  token->value, /*flags=*/0);
 659 }
 660
 661 /* If the next token is of the indicated TYPE, consume it.  Otherwise,
 662    issue the error MSGID.  If MSGID is NULL then a message has already
 663    been produced and no message will be produced this time.  Returns
 664    true if found, false otherwise.  */
 665
 666 static bool
 667 c_parser_require (c_parser *parser,
 668                   enum cpp_ttype type,
 669                   const char *msgid)
 670 {
 671   if (c_parser_next_token_is (parser, type))
 672     {
 673       c_parser_consume_token (parser);
 674       return true;
 675     }
 676   else
 677     {
 678       c_parser_error (parser, msgid);
 679       return false;
 680     }
 681 }
 682
 683 /* If the next token is the indicated keyword, consume it.  Otherwise,
 684    issue the error MSGID.  Returns true if found, false otherwise.  */
 685
 686 static bool
 687 c_parser_require_keyword (c_parser *parser,
 688                           enum rid keyword,
 689                           const char *msgid)
 690 {
 691   if (c_parser_next_token_is_keyword (parser, keyword))
 692     {
 693       c_parser_consume_token (parser);
 694       return true;
 695     }
 696   else
 697     {
 698       c_parser_error (parser, msgid);
 699       return false;
 700     }
 701 }
 702
 703 /* Like c_parser_require, except that tokens will be skipped until the
 704    desired token is found.  An error message is still produced if the
 705    next token is not as expected.  If MSGID is NULL then a message has
 706    already been produced and no message will be produced this
 707    time.  */
 708
 709 static void
 710 c_parser_skip_until_found (c_parser *parser,
 711                            enum cpp_ttype type,
 712                            const char *msgid)
 713 {
 714   unsigned nesting_depth = 0;
 715
 716   if (c_parser_require (parser, type, msgid))
 717     return;
 718
 719   /* Skip tokens until the desired token is found.  */
 720   while (true)
 721     {
 722       /* Peek at the next token.  */
 723       c_token *token = c_parser_peek_token (parser);
 724       /* If we've reached the token we want, consume it and stop.  */
 725       if (token->type == type && !nesting_depth)
 726         {
 727           c_parser_consume_token (parser);
 728           break;
 729         }
 730
 731       /* If we've run out of tokens, stop.  */
 732       if (token->type == CPP_EOF)
 733         return;
 734       if (token->type == CPP_PRAGMA_EOL && parser->in_pragma)
 735         return;
 736       if (token->type == CPP_OPEN_BRACE
 737           || token->type == CPP_OPEN_PAREN
 738           || token->type == CPP_OPEN_SQUARE)
 739         ++nesting_depth;
 740       else if (token->type == CPP_CLOSE_BRACE
 741                || token->type == CPP_CLOSE_PAREN
 742                || token->type == CPP_CLOSE_SQUARE)
 743         {
 744           if (nesting_depth-- == 0)
 745             break;
 746         }
 747       /* Consume this token.  */
 748       c_parser_consume_token (parser);
 749     }
 750   parser->error = false;
 751 }
 752
 753 /* Skip tokens until the end of a parameter is found, but do not
 754    consume the comma, semicolon or closing delimiter.  */
 755
 756 static void
 757 c_parser_skip_to_end_of_parameter (c_parser *parser)
 758 {
 759   unsigned nesting_depth = 0;
 760
 761   while (true)
 762     {
 763       c_token *token = c_parser_peek_token (parser);
 764       if ((token->type == CPP_COMMA || token->type == CPP_SEMICOLON)
 765           && !nesting_depth)
 766         break;
 767       /* If we've run out of tokens, stop.  */
 768       if (token->type == CPP_EOF)
 769         return;
 770       if (token->type == CPP_PRAGMA_EOL && parser->in_pragma)
 771         return;
 772       if (token->type == CPP_OPEN_BRACE
 773           || token->type == CPP_OPEN_PAREN
 774           || token->type == CPP_OPEN_SQUARE)
 775         ++nesting_depth;
 776       else if (token->type == CPP_CLOSE_BRACE
 777                || token->type == CPP_CLOSE_PAREN
 778                || token->type == CPP_CLOSE_SQUARE)
 779         {
 780           if (nesting_depth-- == 0)
 781             break;
 782         }
 783       /* Consume this token.  */
 784       c_parser_consume_token (parser);
 785     }
 786   parser->error = false;
 787 }
 788
 789 /* Expect to be at the end of the pragma directive and consume an
 790    end of line marker.  */
 791
 792 static void
 793 c_parser_skip_to_pragma_eol (c_parser *parser)
 794 {
 795   gcc_assert (parser->in_pragma);
 796   parser->in_pragma = false;
 797
 798   if (!c_parser_require (parser, CPP_PRAGMA_EOL, "expected end of line"))
 799     while (true)
 800       {
 801         c_token *token = c_parser_peek_token (parser);
 802         if (token->type == CPP_EOF)
 803           break;
 804         if (token->type == CPP_PRAGMA_EOL)
 805           {
 806             c_parser_consume_token (parser);
 807             break;
 808           }
 809         c_parser_consume_token (parser);
 810       }
 811
 812   parser->error = false;
 813 }
 814
 815 /* Skip tokens until we have consumed an entire block, or until we
 816    have consumed a non-nested ';'.  */
 817
 818 static void
 819 c_parser_skip_to_end_of_block_or_statement (c_parser *parser)
 820 {
 821   unsigned nesting_depth = 0;
 822   bool save_error = parser->error;
 823
 824   while (true)
 825     {
 826       c_token *token;
 827
 828       /* Peek at the next token.  */
 829       token = c_parser_peek_token (parser);
 830
 831       switch (token->type)
 832         {
 833         case CPP_EOF:
 834           return;
 835
 836         case CPP_PRAGMA_EOL:
 837           if (parser->in_pragma)
 838             return;
 839           break;
 840
 841         case CPP_SEMICOLON:
 842           /* If the next token is a ';', we have reached the
 843              end of the statement.  */
 844           if (!nesting_depth)
 845             {
 846               /* Consume the ';'.  */
 847               c_parser_consume_token (parser);
 848               goto finished;
 849             }
 850           break;
 851
 852         case CPP_CLOSE_BRACE:
 853           /* If the next token is a non-nested '}', then we have
 854              reached the end of the current block.  */
 855           if (nesting_depth == 0 || --nesting_depth == 0)
 856             {
 857               c_parser_consume_token (parser);
 858               goto finished;
 859             }
 860           break;
 861
 862         case CPP_OPEN_BRACE:
 863           /* If it the next token is a '{', then we are entering a new
 864              block.  Consume the entire block.  */
 865           ++nesting_depth;
 866           break;
 867
 868         case CPP_PRAGMA:
 869           /* If we see a pragma, consume the whole thing at once.  We
 870              have some safeguards against consuming pragmas willy-nilly.
 871              Normally, we'd expect to be here with parser->error set,
 872              which disables these safeguards.  But it's possible to get
 873              here for secondary error recovery, after parser->error has
 874              been cleared.  */
 875           c_parser_consume_pragma (parser);
 876           c_parser_skip_to_pragma_eol (parser);
 877           parser->error = save_error;
 878           continue;
 879
 880         default:
 881           break;
 882         }
 883
 884       c_parser_consume_token (parser);
 885     }
 886
 887  finished:
 888   parser->error = false;
 889 }
 890
 891 /* CPP's options (initialized by c-opts.c).  */
 892 extern cpp_options *cpp_opts;
 893
 894 /* Save the warning flags which are controlled by __extension__.  */
 895
 896 static inline int
 897 disable_extension_diagnostics (void)
 898 {
 899   int ret = (pedantic
 900              | (warn_pointer_arith << 1)
 901              | (warn_traditional << 2)
 902              | (flag_iso << 3)
 903              | (warn_long_long << 4)
 904              | (warn_cxx_compat << 5));
 905   cpp_opts->cpp_pedantic = pedantic = 0;
 906   warn_pointer_arith = 0;
 907   cpp_opts->cpp_warn_traditional = warn_traditional = 0;
 908   flag_iso = 0;
 909   cpp_opts->cpp_warn_long_long = warn_long_long = 0;
 910   warn_cxx_compat = 0;
 911   return ret;
 912 }
 913
 914 /* Restore the warning flags which are controlled by __extension__.
 915    FLAGS is the return value from disable_extension_diagnostics.  */
 916
 917 static inline void
 918 restore_extension_diagnostics (int flags)
 919 {
 920   cpp_opts->cpp_pedantic = pedantic = flags & 1;
 921   warn_pointer_arith = (flags >> 1) & 1;
 922   cpp_opts->cpp_warn_traditional = warn_traditional = (flags >> 2) & 1;
 923   flag_iso = (flags >> 3) & 1;
 924   cpp_opts->cpp_warn_long_long = warn_long_long = (flags >> 4) & 1;
 925   warn_cxx_compat = (flags >> 5) & 1;
 926 }
 927
 928 /* Possibly kinds of declarator to parse.  */
 929 typedef enum c_dtr_syn {
 930   /* A normal declarator with an identifier.  */
 931   C_DTR_NORMAL,
 932   /* An abstract declarator (maybe empty).  */
 933   C_DTR_ABSTRACT,
 934   /* A parameter declarator: may be either, but after a type name does
 935      not redeclare a typedef name as an identifier if it can
 936      alternatively be interpreted as a typedef name; see DR#009,
 937      applied in C90 TC1, omitted from C99 and reapplied in C99 TC2
 938      following DR#249.  For example, given a typedef T, "int T" and
 939      "int *T" are valid parameter declarations redeclaring T, while
 940      "int (T)" and "int * (T)" and "int (T[])" and "int (T (int))" are
 941      abstract declarators rather than involving redundant parentheses;
 942      the same applies with attributes inside the parentheses before
 943      "T".  */
 944   C_DTR_PARM
 945 } c_dtr_syn;
 946
 947 static void c_parser_external_declaration (c_parser *);
 948 static void c_parser_asm_definition (c_parser *);
 949 static void c_parser_declaration_or_fndef (c_parser *, bool, bool, bool,
 950                                            bool, bool);
 951 static void c_parser_static_assert_declaration_no_semi (c_parser *);
 952 static void c_parser_static_assert_declaration (c_parser *);
 953 static void c_parser_declspecs (c_parser *, struct c_declspecs *, bool, bool,
 954                                 bool);
 955 static struct c_typespec c_parser_enum_specifier (c_parser *);
 956 static struct c_typespec c_parser_struct_or_union_specifier (c_parser *);
 957 static tree c_parser_struct_declaration (c_parser *);
 958 static struct c_typespec c_parser_typeof_specifier (c_parser *);
 959 static struct c_declarator *c_parser_declarator (c_parser *, bool, c_dtr_syn,
 960                                                  bool *);
 961 static struct c_declarator *c_parser_direct_declarator (c_parser *, bool,
 962                                                         c_dtr_syn, bool *);
 963 static struct c_declarator *c_parser_direct_declarator_inner (c_parser *,
 964                                                               bool,
 965                                                               struct c_declarator *);
 966 static struct c_arg_info *c_parser_parms_declarator (c_parser *, bool, tree);
 967 static struct c_arg_info *c_parser_parms_list_declarator (c_parser *, tree);
 968 static struct c_parm *c_parser_parameter_declaration (c_parser *, tree);
 969 static tree c_parser_simple_asm_expr (c_parser *);
 970 static tree c_parser_attributes (c_parser *);
 971 static struct c_type_name *c_parser_type_name (c_parser *);
 972 static struct c_expr c_parser_initializer (c_parser *);
 973 static struct c_expr c_parser_braced_init (c_parser *, tree, bool);
 974 static void c_parser_initelt (c_parser *, struct obstack *);
 975 static void c_parser_initval (c_parser *, struct c_expr *,
 976                               struct obstack *);
 977 static tree c_parser_compound_statement (c_parser *);
 978 static void c_parser_compound_statement_nostart (c_parser *);
 979 static void c_parser_label (c_parser *);
 980 static void c_parser_statement (c_parser *);
 981 static void c_parser_statement_after_labels (c_parser *);
 982 static void c_parser_if_statement (c_parser *);
 983 static void c_parser_switch_statement (c_parser *);
 984 static void c_parser_while_statement (c_parser *);
 985 static void c_parser_do_statement (c_parser *);
 986 static void c_parser_for_statement (c_parser *);
 987 static tree c_parser_asm_statement (c_parser *);
 988 static tree c_parser_asm_operands (c_parser *, bool);
 989 static tree c_parser_asm_goto_operands (c_parser *);
 990 static tree c_parser_asm_clobbers (c_parser *);
 991 static struct c_expr c_parser_expr_no_commas (c_parser *, struct c_expr *);
 992 static struct c_expr c_parser_conditional_expression (c_parser *,
 993                                                       struct c_expr *);
 994 static struct c_expr c_parser_binary_expression (c_parser *, struct c_expr *);
 995 static struct c_expr c_parser_cast_expression (c_parser *, struct c_expr *);
 996 static struct c_expr c_parser_unary_expression (c_parser *);
 997 static struct c_expr c_parser_sizeof_expression (c_parser *);
 998 static struct c_expr c_parser_alignof_expression (c_parser *);
 999 static struct c_expr c_parser_postfix_expression (c_parser *);
1000 static struct c_expr c_parser_postfix_expression_after_paren_type (c_parser *,
1001                                                                    struct c_type_name *,
1002                                                                    location_t);
1003 static struct c_expr c_parser_postfix_expression_after_primary (c_parser *,
1004                                                                 location_t loc,
1005                                                                 struct c_expr);
1006 static struct c_expr c_parser_expression (c_parser *);
1007 static struct c_expr c_parser_expression_conv (c_parser *);
1008 static VEC(tree,gc) *c_parser_expr_list (c_parser *, bool, bool,
1009                                          VEC(tree,gc) **);
1010 static void c_parser_omp_construct (c_parser *);
1011 static void c_parser_omp_threadprivate (c_parser *);
1012 static void c_parser_omp_barrier (c_parser *);
1013 static void c_parser_omp_flush (c_parser *);
1014 static void c_parser_omp_taskwait (c_parser *);
1015
1016 enum pragma_context { pragma_external, pragma_stmt, pragma_compound };
1017 static bool c_parser_pragma (c_parser *, enum pragma_context);
1018
1019 /* These Objective-C parser functions are only ever called when
1020    compiling Objective-C.  */
1021 static void c_parser_objc_class_definition (c_parser *, tree);
1022 static void c_parser_objc_class_instance_variables (c_parser *);
1023 static void c_parser_objc_class_declaration (c_parser *);
1024 static void c_parser_objc_alias_declaration (c_parser *);
1025 static void c_parser_objc_protocol_definition (c_parser *, tree);
1026 static enum tree_code c_parser_objc_method_type (c_parser *);
1027 static void c_parser_objc_method_definition (c_parser *);
1028 static void c_parser_objc_methodprotolist (c_parser *);
1029 static void c_parser_objc_methodproto (c_parser *);
1030 static tree c_parser_objc_method_decl (c_parser *, tree *);
1031 static tree c_parser_objc_type_name (c_parser *);
1032 static tree c_parser_objc_protocol_refs (c_parser *);
1033 static void c_parser_objc_try_catch_statement (c_parser *);
1034 static void c_parser_objc_synchronized_statement (c_parser *);
1035 static tree c_parser_objc_selector (c_parser *);
1036 static tree c_parser_objc_selector_arg (c_parser *);
1037 static tree c_parser_objc_receiver (c_parser *);
1038 static tree c_parser_objc_message_args (c_parser *);
1039 static tree c_parser_objc_keywordexpr (c_parser *);
1040 static bool c_parser_objc_diagnose_bad_element_prefix
1041   (c_parser *, struct c_declspecs *);
1042
1043 /* Parse a translation unit (C90 6.7, C99 6.9).
1044
1045    translation-unit:
1046      external-declarations
1047
1048    external-declarations:
1049      external-declaration
1050      external-declarations external-declaration
1051
1052    GNU extensions:
1053
1054    translation-unit:
1055      empty
1056 */
1057
1058 static void
1059 c_parser_translation_unit (c_parser *parser)
1060 {
1061   if (c_parser_next_token_is (parser, CPP_EOF))
1062     {
1063       pedwarn (c_parser_peek_token (parser)->location, OPT_pedantic,
1064                "ISO C forbids an empty translation unit");
1065     }
1066   else
1067     {
1068       void *obstack_position = obstack_alloc (&parser_obstack, 0);
1069       mark_valid_location_for_stdc_pragma (false);
1070       do
1071         {
1072           ggc_collect ();
1073           c_parser_external_declaration (parser);
1074           obstack_free (&parser_obstack, obstack_position);
1075         }
1076       while (c_parser_next_token_is_not (parser, CPP_EOF));
1077     }
1078 }
1079
1080 /* Parse an external declaration (C90 6.7, C99 6.9).
1081
1082    external-declaration:
1083      function-definition
1084      declaration
1085
1086    GNU extensions:
1087
1088    external-declaration:
1089      asm-definition
1090      ;
1091      __extension__ external-declaration
1092
1093    Objective-C:
1094
1095    external-declaration:
1096      objc-class-definition
1097      objc-class-declaration
1098      objc-alias-declaration
1099      objc-protocol-definition
1100      objc-method-definition
1101      @end
1102 */
1103
1104 static void
1105 c_parser_external_declaration (c_parser *parser)
1106 {
1107   int ext;
1108   switch (c_parser_peek_token (parser)->type)
1109     {
1110     case CPP_KEYWORD:
1111       switch (c_parser_peek_token (parser)->keyword)
1112         {
1113         case RID_EXTENSION:
1114           ext = disable_extension_diagnostics ();
1115           c_parser_consume_token (parser);
1116           c_parser_external_declaration (parser);
1117           restore_extension_diagnostics (ext);
1118           break;
1119         case RID_ASM:
1120           c_parser_asm_definition (parser);
1121           break;
1122         case RID_AT_INTERFACE:
1123         case RID_AT_IMPLEMENTATION:
1124           gcc_assert (c_dialect_objc ());
1125           c_parser_objc_class_definition (parser, NULL_TREE);
1126           break;
1127         case RID_AT_CLASS:
1128           gcc_assert (c_dialect_objc ());
1129           c_parser_objc_class_declaration (parser);
1130           break;
1131         case RID_AT_ALIAS:
1132           gcc_assert (c_dialect_objc ());
1133           c_parser_objc_alias_declaration (parser);
1134           break;
1135         case RID_AT_PROTOCOL:
1136           gcc_assert (c_dialect_objc ());
1137           c_parser_objc_protocol_definition (parser, NULL_TREE);
1138           break;
1139         case RID_AT_END:
1140           gcc_assert (c_dialect_objc ());
1141           c_parser_consume_token (parser);
1142           objc_finish_implementation ();
1143           break;
1144         default:
1145           goto decl_or_fndef;
1146         }
1147       break;
1148     case CPP_SEMICOLON:
1149       pedwarn (c_parser_peek_token (parser)->location, OPT_pedantic,
1150                "ISO C does not allow extra %<;%> outside of a function");
1151       c_parser_consume_token (parser);
1152       break;
1153     case CPP_PRAGMA:
1154       mark_valid_location_for_stdc_pragma (true);
1155       c_parser_pragma (parser, pragma_external);
1156       mark_valid_location_for_stdc_pragma (false);
1157       break;
1158     case CPP_PLUS:
1159     case CPP_MINUS:
1160       if (c_dialect_objc ())
1161         {
1162           c_parser_objc_method_definition (parser);
1163           break;
1164         }
1165       /* Else fall through, and yield a syntax error trying to parse
1166          as a declaration or function definition.  */
1167     default:
1168     decl_or_fndef:
1169       /* A declaration or a function definition (or, in Objective-C,
1170          an @interface or @protocol with prefix attributes).  We can
1171          only tell which after parsing the declaration specifiers, if
1172          any, and the first declarator.  */
1173       c_parser_declaration_or_fndef (parser, true, true, true, false, true);
1174       break;
1175     }
1176 }
1177
1178 /* Parse a declaration or function definition (C90 6.5, 6.7.1, C99
1179    6.7, 6.9.1).  If FNDEF_OK is true, a function definition is
1180    accepted; otherwise (old-style parameter declarations) only other
1181    declarations are accepted.  If STATIC_ASSERT_OK is true, a static
1182    assertion is accepted; otherwise (old-style parameter declarations)
1183    it is not.  If NESTED is true, we are inside a function or parsing
1184    old-style parameter declarations; any functions encountered are
1185    nested functions and declaration specifiers are required; otherwise
1186    we are at top level and functions are normal functions and
1187    declaration specifiers may be optional.  If EMPTY_OK is true, empty
1188    declarations are OK (subject to all other constraints); otherwise
1189    (old-style parameter declarations) they are diagnosed.  If
1190    START_ATTR_OK is true, the declaration specifiers may start with
1191    attributes; otherwise they may not.
1192
1193    declaration:
1194      declaration-specifiers init-declarator-list[opt] ;
1195      static_assert-declaration
1196
1197    function-definition:
1198      declaration-specifiers[opt] declarator declaration-list[opt]
1199        compound-statement
1200
1201    declaration-list:
1202      declaration
1203      declaration-list declaration
1204
1205    init-declarator-list:
1206      init-declarator
1207      init-declarator-list , init-declarator
1208
1209    init-declarator:
1210      declarator simple-asm-expr[opt] attributes[opt]
1211      declarator simple-asm-expr[opt] attributes[opt] = initializer
1212
1213    GNU extensions:
1214
1215    nested-function-definition:
1216      declaration-specifiers declarator declaration-list[opt]
1217        compound-statement
1218
1219    Objective-C:
1220      attributes objc-class-definition
1221      attributes objc-category-definition
1222      attributes objc-protocol-definition
1223
1224    The simple-asm-expr and attributes are GNU extensions.
1225
1226    This function does not handle __extension__; that is handled in its
1227    callers.  ??? Following the old parser, __extension__ may start
1228    external declarations, declarations in functions and declarations
1229    at the start of "for" loops, but not old-style parameter
1230    declarations.
1231
1232    C99 requires declaration specifiers in a function definition; the
1233    absence is diagnosed through the diagnosis of implicit int.  In GNU
1234    C we also allow but diagnose declarations without declaration
1235    specifiers, but only at top level (elsewhere they conflict with
1236    other syntax).
1237
1238    OpenMP:
1239
1240    declaration:
1241      threadprivate-directive  */
1242
1243 static void
1244 c_parser_declaration_or_fndef (c_parser *parser, bool fndef_ok,
1245                                bool static_assert_ok, bool empty_ok,
1246                                bool nested, bool start_attr_ok)
1247 {
1248   struct c_declspecs *specs;
1249   tree prefix_attrs;
1250   tree all_prefix_attrs;
1251   bool diagnosed_no_specs = false;
1252   location_t here = c_parser_peek_token (parser)->location;
1253
1254   if (static_assert_ok
1255       && c_parser_next_token_is_keyword (parser, RID_STATIC_ASSERT))
1256     {
1257       c_parser_static_assert_declaration (parser);
1258       return;
1259     }
1260   specs = build_null_declspecs ();
1261   c_parser_declspecs (parser, specs, true, true, start_attr_ok);
1262   if (parser->error)
1263     {
1264       c_parser_skip_to_end_of_block_or_statement (parser);
1265       return;
1266     }
1267   if (nested && !specs->declspecs_seen_p)
1268     {
1269       c_parser_error (parser, "expected declaration specifiers");
1270       c_parser_skip_to_end_of_block_or_statement (parser);
1271       return;
1272     }
1273   finish_declspecs (specs);
1274   if (c_parser_next_token_is (parser, CPP_SEMICOLON))
1275     {
1276       if (empty_ok)
1277         shadow_tag (specs);
1278       else
1279         {
1280           shadow_tag_warned (specs, 1);
1281           pedwarn (here, 0, "empty declaration");
1282         }
1283       c_parser_consume_token (parser);
1284       return;
1285     }
1286   else if (c_dialect_objc ())
1287     {
1288       /* Prefix attributes are an error on method decls.  */
1289       switch (c_parser_peek_token (parser)->type)
1290         {
1291           case CPP_PLUS:
1292           case CPP_MINUS:
1293             if (c_parser_objc_diagnose_bad_element_prefix (parser, specs))
1294               return;
1295             if (specs->attrs)
1296               {
1297                 warning_at (c_parser_peek_token (parser)->location,
1298                             OPT_Wattributes,
1299                             "prefix attributes are ignored for methods");
1300                 specs->attrs = NULL_TREE;
1301               }
1302             if (fndef_ok)
1303               c_parser_objc_method_definition (parser);
1304             else
1305               c_parser_objc_methodproto (parser);
1306             return;
1307             break;
1308           default:
1309             break;
1310         }
1311       /* This is where we parse 'attributes @interface ...',
1312          'attributes @implementation ...', 'attributes @protocol ...'
1313          (where attributes could be, for example, __attribute__
1314          ((deprecated)).
1315       */
1316       switch (c_parser_peek_token (parser)->keyword)
1317         {
1318         case RID_AT_INTERFACE:
1319           {
1320             if (c_parser_objc_diagnose_bad_element_prefix (parser, specs))
1321               return;
1322             c_parser_objc_class_definition (parser, specs->attrs);
1323             return;
1324           }
1325           break;
1326         case RID_AT_IMPLEMENTATION:
1327           {
1328             if (c_parser_objc_diagnose_bad_element_prefix (parser, specs))
1329               return;
1330             if (specs->attrs)
1331               {
1332                 warning_at (c_parser_peek_token (parser)->location,
1333                         OPT_Wattributes,
1334                         "prefix attributes are ignored for implementations");
1335                 specs->attrs = NULL_TREE;
1336               }
1337             c_parser_objc_class_definition (parser, NULL_TREE);
1338             return;
1339           }
1340           break;
1341         case RID_AT_PROTOCOL:
1342           {
1343             if (c_parser_objc_diagnose_bad_element_prefix (parser, specs))
1344               return;
1345             c_parser_objc_protocol_definition (parser, specs->attrs);
1346             return;
1347           }
1348           break;
1349         default:
1350           break;
1351         }
1352     }
1353
1354   pending_xref_error ();
1355   prefix_attrs = specs->attrs;
1356   all_prefix_attrs = prefix_attrs;
1357   specs->attrs = NULL_TREE;
1358   while (true)
1359     {
1360       struct c_declarator *declarator;
1361       bool dummy = false;
1362       tree fnbody;
1363       /* Declaring either one or more declarators (in which case we
1364          should diagnose if there were no declaration specifiers) or a
1365          function definition (in which case the diagnostic for
1366          implicit int suffices).  */
1367       declarator = c_parser_declarator (parser, specs->type_seen_p,
1368                                         C_DTR_NORMAL, &dummy);
1369       if (declarator == NULL)
1370         {
1371           c_parser_skip_to_end_of_block_or_statement (parser);
1372           return;
1373         }
1374       if (c_parser_next_token_is (parser, CPP_EQ)
1375           || c_parser_next_token_is (parser, CPP_COMMA)
1376           || c_parser_next_token_is (parser, CPP_SEMICOLON)
1377           || c_parser_next_token_is_keyword (parser, RID_ASM)
1378           || c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
1379         {
1380           tree asm_name = NULL_TREE;
1381           tree postfix_attrs = NULL_TREE;
1382           if (!diagnosed_no_specs && !specs->declspecs_seen_p)
1383             {
1384               diagnosed_no_specs = true;
1385               pedwarn (here, 0, "data definition has no type or storage class");
1386             }
1387           /* Having seen a data definition, there cannot now be a
1388              function definition.  */
1389           fndef_ok = false;
1390           if (c_parser_next_token_is_keyword (parser, RID_ASM))
1391             asm_name = c_parser_simple_asm_expr (parser);
1392           if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
1393             postfix_attrs = c_parser_attributes (parser);
1394           if (c_parser_next_token_is (parser, CPP_EQ))
1395             {
1396               tree d;
1397               struct c_expr init;
1398               location_t init_loc;
1399               c_parser_consume_token (parser);
1400               /* The declaration of the variable is in effect while
1401                  its initializer is parsed.  */
1402               d = start_decl (declarator, specs, true,
1403                               chainon (postfix_attrs, all_prefix_attrs));
1404               if (!d)
1405                 d = error_mark_node;
1406               start_init (d, asm_name, global_bindings_p ());
1407               init_loc = c_parser_peek_token (parser)->location;
1408               init = c_parser_initializer (parser);
1409               finish_init ();
1410               if (d != error_mark_node)
1411                 {
1412                   maybe_warn_string_init (TREE_TYPE (d), init);
1413                   finish_decl (d, init_loc, init.value,
1414                                init.original_type, asm_name);
1415                 }
1416             }
1417           else
1418             {
1419               tree d = start_decl (declarator, specs, false,
1420                                    chainon (postfix_attrs,
1421                                             all_prefix_attrs));
1422               if (d)
1423                 finish_decl (d, UNKNOWN_LOCATION, NULL_TREE,
1424                              NULL_TREE, asm_name);
1425             }
1426           if (c_parser_next_token_is (parser, CPP_COMMA))
1427             {
1428               c_parser_consume_token (parser);
1429               if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
1430                 all_prefix_attrs = chainon (c_parser_attributes (parser),
1431                                             prefix_attrs);
1432               else
1433                 all_prefix_attrs = prefix_attrs;
1434               continue;
1435             }
1436           else if (c_parser_next_token_is (parser, CPP_SEMICOLON))
1437             {
1438               c_parser_consume_token (parser);
1439               return;
1440             }
1441           else
1442             {
1443               c_parser_error (parser, "expected %<,%> or %<;%>");
1444               c_parser_skip_to_end_of_block_or_statement (parser);
1445               return;
1446             }
1447         }
1448       else if (!fndef_ok)
1449         {
1450           c_parser_error (parser, "expected %<=%>, %<,%>, %<;%>, "
1451                           "%<asm%> or %<__attribute__%>");
1452           c_parser_skip_to_end_of_block_or_statement (parser);
1453           return;
1454         }
1455       /* Function definition (nested or otherwise).  */
1456       if (nested)
1457         {
1458           pedwarn (here, OPT_pedantic, "ISO C forbids nested functions");
1459           c_push_function_context ();
1460         }
1461       if (!start_function (specs, declarator, all_prefix_attrs))
1462         {
1463           /* This can appear in many cases looking nothing like a
1464              function definition, so we don't give a more specific
1465              error suggesting there was one.  */
1466           c_parser_error (parser, "expected %<=%>, %<,%>, %<;%>, %<asm%> "
1467                           "or %<__attribute__%>");
1468           if (nested)
1469             c_pop_function_context ();
1470           break;
1471         }
1472       /* Parse old-style parameter declarations.  ??? Attributes are
1473          not allowed to start declaration specifiers here because of a
1474          syntax conflict between a function declaration with attribute
1475          suffix and a function definition with an attribute prefix on
1476          first old-style parameter declaration.  Following the old
1477          parser, they are not accepted on subsequent old-style
1478          parameter declarations either.  However, there is no
1479          ambiguity after the first declaration, nor indeed on the
1480          first as long as we don't allow postfix attributes after a
1481          declarator with a nonempty identifier list in a definition;
1482          and postfix attributes have never been accepted here in
1483          function definitions either.  */
1484       while (c_parser_next_token_is_not (parser, CPP_EOF)
1485              && c_parser_next_token_is_not (parser, CPP_OPEN_BRACE))
1486         c_parser_declaration_or_fndef (parser, false, false, false,
1487                                        true, false);
1488       store_parm_decls ();
1489       DECL_STRUCT_FUNCTION (current_function_decl)->function_start_locus
1490         = c_parser_peek_token (parser)->location;
1491       fnbody = c_parser_compound_statement (parser);
1492       if (nested)
1493         {
1494           tree decl = current_function_decl;
1495           /* Mark nested functions as needing static-chain initially.
1496              lower_nested_functions will recompute it but the
1497              DECL_STATIC_CHAIN flag is also used before that happens,
1498              by initializer_constant_valid_p.  See gcc.dg/nested-fn-2.c.  */
1499           DECL_STATIC_CHAIN (decl) = 1;
1500           add_stmt (fnbody);
1501           finish_function ();
1502           c_pop_function_context ();
1503           add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl), DECL_EXPR, decl));
1504         }
1505       else
1506         {
1507           add_stmt (fnbody);
1508           finish_function ();
1509         }
1510       break;
1511     }
1512 }
1513
1514 /* Parse an asm-definition (asm() outside a function body).  This is a
1515    GNU extension.
1516
1517    asm-definition:
1518      simple-asm-expr ;
1519 */
1520
1521 static void
1522 c_parser_asm_definition (c_parser *parser)
1523 {
1524   tree asm_str = c_parser_simple_asm_expr (parser);
1525   if (asm_str)
1526     cgraph_add_asm_node (asm_str);
1527   c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
1528 }
1529
1530 /* Parse a static assertion (C1X N1425 6.7.10).
1531
1532    static_assert-declaration:
1533      static_assert-declaration-no-semi ;
1534 */
1535
1536 static void
1537 c_parser_static_assert_declaration (c_parser *parser)
1538 {
1539   c_parser_static_assert_declaration_no_semi (parser);
1540   if (parser->error
1541       || !c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>"))
1542     c_parser_skip_to_end_of_block_or_statement (parser);
1543 }
1544
1545 /* Parse a static assertion (C1X N1425 6.7.10), without the trailing
1546    semicolon.
1547
1548    static_assert-declaration-no-semi:
1549      _Static_assert ( constant-expression , string-literal )
1550 */
1551
1552 static void
1553 c_parser_static_assert_declaration_no_semi (c_parser *parser)
1554 {
1555   location_t assert_loc, value_loc;
1556   tree value;
1557   tree string;
1558
1559   gcc_assert (c_parser_next_token_is_keyword (parser, RID_STATIC_ASSERT));
1560   assert_loc = c_parser_peek_token (parser)->location;
1561   if (!flag_isoc1x)
1562     {
1563       if (flag_isoc99)
1564         pedwarn (assert_loc, OPT_pedantic,
1565                  "ISO C99 does not support %<_Static_assert%>");
1566       else
1567         pedwarn (assert_loc, OPT_pedantic,
1568                  "ISO C90 does not support %<_Static_assert%>");
1569     }
1570   c_parser_consume_token (parser);
1571   if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
1572     return;
1573   value_loc = c_parser_peek_token (parser)->location;
1574   value = c_parser_expr_no_commas (parser, NULL).value;
1575   parser->lex_untranslated_string = true;
1576   if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>"))
1577     {
1578       parser->lex_untranslated_string = false;
1579       return;
1580     }
1581   switch (c_parser_peek_token (parser)->type)
1582     {
1583     case CPP_STRING:
1584     case CPP_STRING16:
1585     case CPP_STRING32:
1586     case CPP_WSTRING:
1587     case CPP_UTF8STRING:
1588       string = c_parser_peek_token (parser)->value;
1589       c_parser_consume_token (parser);
1590       parser->lex_untranslated_string = false;
1591       break;
1592     default:
1593       c_parser_error (parser, "expected string literal");
1594       parser->lex_untranslated_string = false;
1595       return;
1596     }
1597   c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>");
1598
1599   if (!INTEGRAL_TYPE_P (TREE_TYPE (value)))
1600     {
1601       error_at (value_loc, "expression in static assertion is not an integer");
1602       return;
1603     }
1604   if (TREE_CODE (value) != INTEGER_CST)
1605     {
1606       value = c_fully_fold (value, false, NULL);
1607       if (TREE_CODE (value) == INTEGER_CST)
1608         pedwarn (value_loc, OPT_pedantic, "expression in static assertion "
1609                  "is not an integer constant expression");
1610     }
1611   if (TREE_CODE (value) != INTEGER_CST)
1612     {
1613       error_at (value_loc, "expression in static assertion is not constant");
1614       return;
1615     }
1616   constant_expression_warning (value);
1617   if (integer_zerop (value))
1618     error_at (assert_loc, "static assertion failed: %E", string);
1619 }
1620
1621 /* Parse some declaration specifiers (possibly none) (C90 6.5, C99
1622    6.7), adding them to SPECS (which may already include some).
1623    Storage class specifiers are accepted iff SCSPEC_OK; type
1624    specifiers are accepted iff TYPESPEC_OK; attributes are accepted at
1625    the start iff START_ATTR_OK.
1626
1627    declaration-specifiers:
1628      storage-class-specifier declaration-specifiers[opt]
1629      type-specifier declaration-specifiers[opt]
1630      type-qualifier declaration-specifiers[opt]
1631      function-specifier declaration-specifiers[opt]
1632
1633    Function specifiers (inline) are from C99, and are currently
1634    handled as storage class specifiers, as is __thread.
1635
1636    C90 6.5.1, C99 6.7.1:
1637    storage-class-specifier:
1638      typedef
1639      extern
1640      static
1641      auto
1642      register
1643
1644    C99 6.7.4:
1645    function-specifier:
1646      inline
1647
1648    C90 6.5.2, C99 6.7.2:
1649    type-specifier:
1650      void
1651      char
1652      short
1653      int
1654      long
1655      float
1656      double
1657      signed
1658      unsigned
1659      _Bool
1660      _Complex
1661      [_Imaginary removed in C99 TC2]
1662      struct-or-union-specifier
1663      enum-specifier
1664      typedef-name
1665
1666    (_Bool and _Complex are new in C99.)
1667
1668    C90 6.5.3, C99 6.7.3:
1669
1670    type-qualifier:
1671      const
1672      restrict
1673      volatile
1674      address-space-qualifier
1675
1676    (restrict is new in C99.)
1677
1678    GNU extensions:
1679
1680    declaration-specifiers:
1681      attributes declaration-specifiers[opt]
1682
1683    type-qualifier:
1684      address-space
1685
1686    address-space:
1687      identifier recognized by the target
1688
1689    storage-class-specifier:
1690      __thread
1691
1692    type-specifier:
1693      typeof-specifier
1694      __int128
1695      _Decimal32
1696      _Decimal64
1697      _Decimal128
1698      _Fract
1699      _Accum
1700      _Sat
1701
1702   (_Fract, _Accum, and _Sat are new from ISO/IEC DTR 18037:
1703    http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1169.pdf)
1704
1705    Objective-C:
1706
1707    type-specifier:
1708      class-name objc-protocol-refs[opt]
1709      typedef-name objc-protocol-refs
1710      objc-protocol-refs
1711 */
1712
1713 static void
1714 c_parser_declspecs (c_parser *parser, struct c_declspecs *specs,
1715                     bool scspec_ok, bool typespec_ok, bool start_attr_ok)
1716 {
1717   bool attrs_ok = start_attr_ok;
1718   bool seen_type = specs->type_seen_p;
1719   while (c_parser_next_token_is (parser, CPP_NAME)
1720          || c_parser_next_token_is (parser, CPP_KEYWORD)
1721          || (c_dialect_objc () && c_parser_next_token_is (parser, CPP_LESS)))
1722     {
1723       struct c_typespec t;
1724       tree attrs;
1725       location_t loc = c_parser_peek_token (parser)->location;
1726       if (c_parser_next_token_is (parser, CPP_NAME))
1727         {
1728           tree value = c_parser_peek_token (parser)->value;
1729           c_id_kind kind = c_parser_peek_token (parser)->id_kind;
1730
1731           if (kind == C_ID_ADDRSPACE)
1732             {
1733               addr_space_t as
1734                 = c_parser_peek_token (parser)->keyword - RID_FIRST_ADDR_SPACE;
1735               declspecs_add_addrspace (specs, as);
1736               c_parser_consume_token (parser);
1737               attrs_ok = true;
1738               continue;
1739             }
1740
1741           /* This finishes the specifiers unless a type name is OK, it
1742              is declared as a type name and a type name hasn't yet
1743              been seen.  */
1744           if (!typespec_ok || seen_type
1745               || (kind != C_ID_TYPENAME && kind != C_ID_CLASSNAME))
1746             break;
1747           c_parser_consume_token (parser);
1748           seen_type = true;
1749           attrs_ok = true;
1750           if (kind == C_ID_TYPENAME
1751               && (!c_dialect_objc ()
1752                   || c_parser_next_token_is_not (parser, CPP_LESS)))
1753             {
1754               t.kind = ctsk_typedef;
1755               /* For a typedef name, record the meaning, not the name.
1756                  In case of 'foo foo, bar;'.  */
1757               t.spec = lookup_name (value);
1758               t.expr = NULL_TREE;
1759               t.expr_const_operands = true;
1760             }
1761           else
1762             {
1763               tree proto = NULL_TREE;
1764               gcc_assert (c_dialect_objc ());
1765               t.kind = ctsk_objc;
1766               if (c_parser_next_token_is (parser, CPP_LESS))
1767                 proto = c_parser_objc_protocol_refs (parser);
1768               t.spec = objc_get_protocol_qualified_type (value, proto);
1769               t.expr = NULL_TREE;
1770               t.expr_const_operands = true;
1771             }
1772           declspecs_add_type (loc, specs, t);
1773           continue;
1774         }
1775       if (c_parser_next_token_is (parser, CPP_LESS))
1776         {
1777           /* Make "<SomeProtocol>" equivalent to "id <SomeProtocol>" -
1778              nisse@lysator.liu.se.  */
1779           tree proto;
1780           gcc_assert (c_dialect_objc ());
1781           if (!typespec_ok || seen_type)
1782             break;
1783           proto = c_parser_objc_protocol_refs (parser);
1784           t.kind = ctsk_objc;
1785           t.spec = objc_get_protocol_qualified_type (NULL_TREE, proto);
1786           t.expr = NULL_TREE;
1787           t.expr_const_operands = true;
1788           declspecs_add_type (loc, specs, t);
1789           continue;
1790         }
1791       gcc_assert (c_parser_next_token_is (parser, CPP_KEYWORD));
1792       switch (c_parser_peek_token (parser)->keyword)
1793         {
1794         case RID_STATIC:
1795         case RID_EXTERN:
1796         case RID_REGISTER:
1797         case RID_TYPEDEF:
1798         case RID_INLINE:
1799         case RID_AUTO:
1800         case RID_THREAD:
1801           if (!scspec_ok)
1802             goto out;
1803           attrs_ok = true;
1804           /* TODO: Distinguish between function specifiers (inline)
1805              and storage class specifiers, either here or in
1806              declspecs_add_scspec.  */
1807           declspecs_add_scspec (specs, c_parser_peek_token (parser)->value);
1808           c_parser_consume_token (parser);
1809           break;
1810         case RID_UNSIGNED:
1811         case RID_LONG:
1812         case RID_INT128:
1813         case RID_SHORT:
1814         case RID_SIGNED:
1815         case RID_COMPLEX:
1816         case RID_INT:
1817         case RID_CHAR:
1818         case RID_FLOAT:
1819         case RID_DOUBLE:
1820         case RID_VOID:
1821         case RID_DFLOAT32:
1822         case RID_DFLOAT64:
1823         case RID_DFLOAT128:
1824         case RID_BOOL:
1825         case RID_FRACT:
1826         case RID_ACCUM:
1827         case RID_SAT:
1828           if (!typespec_ok)
1829             goto out;
1830           attrs_ok = true;
1831           seen_type = true;
1832           if (c_dialect_objc ())
1833             parser->objc_need_raw_identifier = true;
1834           t.kind = ctsk_resword;
1835           t.spec = c_parser_peek_token (parser)->value;
1836           t.expr = NULL_TREE;
1837           t.expr_const_operands = true;
1838           declspecs_add_type (loc, specs, t);
1839           c_parser_consume_token (parser);
1840           break;
1841         case RID_ENUM:
1842           if (!typespec_ok)
1843             goto out;
1844           attrs_ok = true;
1845           seen_type = true;
1846           t = c_parser_enum_specifier (parser);
1847           declspecs_add_type (loc, specs, t);
1848           break;
1849         case RID_STRUCT:
1850         case RID_UNION:
1851           if (!typespec_ok)
1852             goto out;
1853           attrs_ok = true;
1854           seen_type = true;
1855           t = c_parser_struct_or_union_specifier (parser);
1856           invoke_plugin_callbacks (PLUGIN_FINISH_TYPE, t.spec);
1857           declspecs_add_type (loc, specs, t);
1858           break;
1859         case RID_TYPEOF:
1860           /* ??? The old parser rejected typeof after other type
1861              specifiers, but is a syntax error the best way of
1862              handling this?  */
1863           if (!typespec_ok || seen_type)
1864             goto out;
1865           attrs_ok = true;
1866           seen_type = true;
1867           t = c_parser_typeof_specifier (parser);
1868           declspecs_add_type (loc, specs, t);
1869           break;
1870         case RID_CONST:
1871         case RID_VOLATILE:
1872         case RID_RESTRICT:
1873           attrs_ok = true;
1874           declspecs_add_qual (specs, c_parser_peek_token (parser)->value);
1875           c_parser_consume_token (parser);
1876           break;
1877         case RID_ATTRIBUTE:
1878           if (!attrs_ok)
1879             goto out;
1880           attrs = c_parser_attributes (parser);
1881           declspecs_add_attrs (specs, attrs);
1882           break;
1883         default:
1884           goto out;
1885         }
1886     }
1887  out: ;
1888 }
1889
1890 /* Parse an enum specifier (C90 6.5.2.2, C99 6.7.2.2).
1891
1892    enum-specifier:
1893      enum attributes[opt] identifier[opt] { enumerator-list } attributes[opt]
1894      enum attributes[opt] identifier[opt] { enumerator-list , } attributes[opt]
1895      enum attributes[opt] identifier
1896
1897    The form with trailing comma is new in C99.  The forms with
1898    attributes are GNU extensions.  In GNU C, we accept any expression
1899    without commas in the syntax (assignment expressions, not just
1900    conditional expressions); assignment expressions will be diagnosed
1901    as non-constant.
1902
1903    enumerator-list:
1904      enumerator
1905      enumerator-list , enumerator
1906
1907    enumerator:
1908      enumeration-constant
1909      enumeration-constant = constant-expression
1910 */
1911
1912 static struct c_typespec
1913 c_parser_enum_specifier (c_parser *parser)
1914 {
1915   struct c_typespec ret;
1916   tree attrs;
1917   tree ident = NULL_TREE;
1918   location_t enum_loc;
1919   location_t ident_loc = UNKNOWN_LOCATION;  /* Quiet warning.  */
1920   gcc_assert (c_parser_next_token_is_keyword (parser, RID_ENUM));
1921   enum_loc = c_parser_peek_token (parser)->location;
1922   c_parser_consume_token (parser);
1923   attrs = c_parser_attributes (parser);
1924   enum_loc = c_parser_peek_token (parser)->location;
1925   /* Set the location in case we create a decl now.  */
1926   c_parser_set_source_position_from_token (c_parser_peek_token (parser));
1927   if (c_parser_next_token_is (parser, CPP_NAME))
1928     {
1929       ident = c_parser_peek_token (parser)->value;
1930       ident_loc = c_parser_peek_token (parser)->location;
1931       enum_loc = ident_loc;
1932       c_parser_consume_token (parser);
1933     }
1934   if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
1935     {
1936       /* Parse an enum definition.  */
1937       struct c_enum_contents the_enum;
1938       tree type = start_enum (enum_loc, &the_enum, ident);
1939       tree postfix_attrs;
1940       /* We chain the enumerators in reverse order, then put them in
1941          forward order at the end.  */
1942       tree values = NULL_TREE;
1943       c_parser_consume_token (parser);
1944       while (true)
1945         {
1946           tree enum_id;
1947           tree enum_value;
1948           tree enum_decl;
1949           bool seen_comma;
1950           c_token *token;
1951           location_t comma_loc = UNKNOWN_LOCATION;  /* Quiet warning.  */
1952           location_t decl_loc, value_loc;
1953           if (c_parser_next_token_is_not (parser, CPP_NAME))
1954             {
1955               c_parser_error (parser, "expected identifier");
1956               c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL);
1957               values = error_mark_node;
1958               break;
1959             }
1960           token = c_parser_peek_token (parser);
1961           enum_id = token->value;
1962           /* Set the location in case we create a decl now.  */
1963           c_parser_set_source_position_from_token (token);
1964           decl_loc = value_loc = token->location;
1965           c_parser_consume_token (parser);
1966           if (c_parser_next_token_is (parser, CPP_EQ))
1967             {
1968               c_parser_consume_token (parser);
1969               value_loc = c_parser_peek_token (parser)->location;
1970               enum_value = c_parser_expr_no_commas (parser, NULL).value;
1971             }
1972           else
1973             enum_value = NULL_TREE;
1974           enum_decl = build_enumerator (decl_loc, value_loc,
1975                                         &the_enum, enum_id, enum_value);
1976           TREE_CHAIN (enum_decl) = values;
1977           values = enum_decl;
1978           seen_comma = false;
1979           if (c_parser_next_token_is (parser, CPP_COMMA))
1980             {
1981               comma_loc = c_parser_peek_token (parser)->location;
1982               seen_comma = true;
1983               c_parser_consume_token (parser);
1984             }
1985           if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
1986             {
1987               if (seen_comma && !flag_isoc99)
1988                 pedwarn (comma_loc, OPT_pedantic, "comma at end of enumerator list");
1989               c_parser_consume_token (parser);
1990               break;
1991             }
1992           if (!seen_comma)
1993             {
1994               c_parser_error (parser, "expected %<,%> or %<}%>");
1995               c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL);
1996               values = error_mark_node;
1997               break;
1998             }
1999         }
2000       postfix_attrs = c_parser_attributes (parser);
2001       ret.spec = finish_enum (type, nreverse (values),
2002                               chainon (attrs, postfix_attrs));
2003       ret.kind = ctsk_tagdef;
2004       ret.expr = NULL_TREE;
2005       ret.expr_const_operands = true;
2006       return ret;
2007     }
2008   else if (!ident)
2009     {
2010       c_parser_error (parser, "expected %<{%>");
2011       ret.spec = error_mark_node;
2012       ret.kind = ctsk_tagref;
2013       ret.expr = NULL_TREE;
2014       ret.expr_const_operands = true;
2015       return ret;
2016     }
2017   ret = parser_xref_tag (ident_loc, ENUMERAL_TYPE, ident);
2018   /* In ISO C, enumerated types can be referred to only if already
2019      defined.  */
2020   if (pedantic && !COMPLETE_TYPE_P (ret.spec))
2021     {
2022       gcc_assert (ident);
2023       pedwarn (enum_loc, OPT_pedantic,
2024                "ISO C forbids forward references to %<enum%> types");
2025     }
2026   return ret;
2027 }
2028
2029 /* Parse a struct or union specifier (C90 6.5.2.1, C99 6.7.2.1).
2030
2031    struct-or-union-specifier:
2032      struct-or-union attributes[opt] identifier[opt]
2033        { struct-contents } attributes[opt]
2034      struct-or-union attributes[opt] identifier
2035
2036    struct-contents:
2037      struct-declaration-list
2038
2039    struct-declaration-list:
2040      struct-declaration ;
2041      struct-declaration-list struct-declaration ;
2042
2043    GNU extensions:
2044
2045    struct-contents:
2046      empty
2047      struct-declaration
2048      struct-declaration-list struct-declaration
2049
2050    struct-declaration-list:
2051      struct-declaration-list ;
2052      ;
2053
2054    (Note that in the syntax here, unlike that in ISO C, the semicolons
2055    are included here rather than in struct-declaration, in order to
2056    describe the syntax with extra semicolons and missing semicolon at
2057    end.)
2058
2059    Objective-C:
2060
2061    struct-declaration-list:
2062      @defs ( class-name )
2063
2064    (Note this does not include a trailing semicolon, but can be
2065    followed by further declarations, and gets a pedwarn-if-pedantic
2066    when followed by a semicolon.)  */
2067
2068 static struct c_typespec
2069 c_parser_struct_or_union_specifier (c_parser *parser)
2070 {
2071   struct c_typespec ret;
2072   tree attrs;
2073   tree ident = NULL_TREE;
2074   location_t struct_loc;
2075   location_t ident_loc = UNKNOWN_LOCATION;
2076   enum tree_code code;
2077   switch (c_parser_peek_token (parser)->keyword)
2078     {
2079     case RID_STRUCT:
2080       code = RECORD_TYPE;
2081       break;
2082     case RID_UNION:
2083       code = UNION_TYPE;
2084       break;
2085     default:
2086       gcc_unreachable ();
2087     }
2088   struct_loc = c_parser_peek_token (parser)->location;
2089   c_parser_consume_token (parser);
2090   attrs = c_parser_attributes (parser);
2091
2092   /* Set the location in case we create a decl now.  */
2093   c_parser_set_source_position_from_token (c_parser_peek_token (parser));
2094
2095   if (c_parser_next_token_is (parser, CPP_NAME))
2096     {
2097       ident = c_parser_peek_token (parser)->value;
2098       ident_loc = c_parser_peek_token (parser)->location;
2099       struct_loc = ident_loc;
2100       c_parser_consume_token (parser);
2101     }
2102   if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
2103     {
2104       /* Parse a struct or union definition.  Start the scope of the
2105          tag before parsing components.  */
2106       struct c_struct_parse_info *struct_info;
2107       tree type = start_struct (struct_loc, code, ident, &struct_info);
2108       tree postfix_attrs;
2109       /* We chain the components in reverse order, then put them in
2110          forward order at the end.  Each struct-declaration may
2111          declare multiple components (comma-separated), so we must use
2112          chainon to join them, although when parsing each
2113          struct-declaration we can use TREE_CHAIN directly.
2114
2115          The theory behind all this is that there will be more
2116          semicolon separated fields than comma separated fields, and
2117          so we'll be minimizing the number of node traversals required
2118          by chainon.  */
2119       tree contents = NULL_TREE;
2120       c_parser_consume_token (parser);
2121       /* Handle the Objective-C @defs construct,
2122          e.g. foo(sizeof(struct{ @defs(ClassName) }));.  */
2123       if (c_parser_next_token_is_keyword (parser, RID_AT_DEFS))
2124         {
2125           tree name;
2126           gcc_assert (c_dialect_objc ());
2127           c_parser_consume_token (parser);
2128           if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
2129             goto end_at_defs;
2130           if (c_parser_next_token_is (parser, CPP_NAME)
2131               && c_parser_peek_token (parser)->id_kind == C_ID_CLASSNAME)
2132             {
2133               name = c_parser_peek_token (parser)->value;
2134               c_parser_consume_token (parser);
2135             }
2136           else
2137             {
2138               c_parser_error (parser, "expected class name");
2139               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
2140               goto end_at_defs;
2141             }
2142           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2143                                      "expected %<)%>");
2144           contents = nreverse (objc_get_class_ivars (name));
2145         }
2146     end_at_defs:
2147       /* Parse the struct-declarations and semicolons.  Problems with
2148          semicolons are diagnosed here; empty structures are diagnosed
2149          elsewhere.  */
2150       while (true)
2151         {
2152           tree decls;
2153           /* Parse any stray semicolon.  */
2154           if (c_parser_next_token_is (parser, CPP_SEMICOLON))
2155             {
2156               pedwarn (c_parser_peek_token (parser)->location, OPT_pedantic,
2157                        "extra semicolon in struct or union specified");
2158               c_parser_consume_token (parser);
2159               continue;
2160             }
2161           /* Stop if at the end of the struct or union contents.  */
2162           if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
2163             {
2164               c_parser_consume_token (parser);
2165               break;
2166             }
2167           /* Accept #pragmas at struct scope.  */
2168           if (c_parser_next_token_is (parser, CPP_PRAGMA))
2169             {
2170               c_parser_pragma (parser, pragma_external);
2171               continue;
2172             }
2173           /* Parse some comma-separated declarations, but not the
2174              trailing semicolon if any.  */
2175           decls = c_parser_struct_declaration (parser);
2176           contents = chainon (decls, contents);
2177           /* If no semicolon follows, either we have a parse error or
2178              are at the end of the struct or union and should
2179              pedwarn.  */
2180           if (c_parser_next_token_is (parser, CPP_SEMICOLON))
2181             c_parser_consume_token (parser);
2182           else
2183             {
2184               if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
2185                 pedwarn (c_parser_peek_token (parser)->location, 0,
2186                          "no semicolon at end of struct or union");
2187               else
2188                 {
2189                   c_parser_error (parser, "expected %<;%>");
2190                   c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL);
2191                   break;
2192                 }
2193             }
2194         }
2195       postfix_attrs = c_parser_attributes (parser);
2196       ret.spec = finish_struct (struct_loc, type, nreverse (contents),
2197                                 chainon (attrs, postfix_attrs), struct_info);
2198       ret.kind = ctsk_tagdef;
2199       ret.expr = NULL_TREE;
2200       ret.expr_const_operands = true;
2201       return ret;
2202     }
2203   else if (!ident)
2204     {
2205       c_parser_error (parser, "expected %<{%>");
2206       ret.spec = error_mark_node;
2207       ret.kind = ctsk_tagref;
2208       ret.expr = NULL_TREE;
2209       ret.expr_const_operands = true;
2210       return ret;
2211     }
2212   ret = parser_xref_tag (ident_loc, code, ident);
2213   return ret;
2214 }
2215
2216 /* Parse a struct-declaration (C90 6.5.2.1, C99 6.7.2.1), *without*
2217    the trailing semicolon.
2218
2219    struct-declaration:
2220      specifier-qualifier-list struct-declarator-list
2221      static_assert-declaration-no-semi
2222
2223    specifier-qualifier-list:
2224      type-specifier specifier-qualifier-list[opt]
2225      type-qualifier specifier-qualifier-list[opt]
2226      attributes specifier-qualifier-list[opt]
2227
2228    struct-declarator-list:
2229      struct-declarator
2230      struct-declarator-list , attributes[opt] struct-declarator
2231
2232    struct-declarator:
2233      declarator attributes[opt]
2234      declarator[opt] : constant-expression attributes[opt]
2235
2236    GNU extensions:
2237
2238    struct-declaration:
2239      __extension__ struct-declaration
2240      specifier-qualifier-list
2241
2242    Unlike the ISO C syntax, semicolons are handled elsewhere.  The use
2243    of attributes where shown is a GNU extension.  In GNU C, we accept
2244    any expression without commas in the syntax (assignment
2245    expressions, not just conditional expressions); assignment
2246    expressions will be diagnosed as non-constant.  */
2247
2248 static tree
2249 c_parser_struct_declaration (c_parser *parser)
2250 {
2251   struct c_declspecs *specs;
2252   tree prefix_attrs;
2253   tree all_prefix_attrs;
2254   tree decls;
2255   location_t decl_loc;
2256   if (c_parser_next_token_is_keyword (parser, RID_EXTENSION))
2257     {
2258       int ext;
2259       tree decl;
2260       ext = disable_extension_diagnostics ();
2261       c_parser_consume_token (parser);
2262       decl = c_parser_struct_declaration (parser);
2263       restore_extension_diagnostics (ext);
2264       return decl;
2265     }
2266   if (c_parser_next_token_is_keyword (parser, RID_STATIC_ASSERT))
2267     {
2268       c_parser_static_assert_declaration_no_semi (parser);
2269       return NULL_TREE;
2270     }
2271   specs = build_null_declspecs ();
2272   decl_loc = c_parser_peek_token (parser)->location;
2273   c_parser_declspecs (parser, specs, false, true, true);
2274   if (parser->error)
2275     return NULL_TREE;
2276   if (!specs->declspecs_seen_p)
2277     {
2278       c_parser_error (parser, "expected specifier-qualifier-list");
2279       return NULL_TREE;
2280     }
2281   finish_declspecs (specs);
2282   if (c_parser_next_token_is (parser, CPP_SEMICOLON))
2283     {
2284       tree ret;
2285       if (!specs->type_seen_p)
2286         {
2287           pedwarn (decl_loc, OPT_pedantic,
2288                    "ISO C forbids member declarations with no members");
2289           shadow_tag_warned (specs, pedantic);
2290           ret = NULL_TREE;
2291         }
2292       else
2293         {
2294           /* Support for unnamed structs or unions as members of
2295              structs or unions (which is [a] useful and [b] supports
2296              MS P-SDK).  */
2297           tree attrs = NULL;
2298
2299           ret = grokfield (c_parser_peek_token (parser)->location,
2300                            build_id_declarator (NULL_TREE), specs,
2301                            NULL_TREE, &attrs);
2302           if (ret)
2303             decl_attributes (&ret, attrs, 0);
2304         }
2305       return ret;
2306     }
2307   pending_xref_error ();
2308   prefix_attrs = specs->attrs;
2309   all_prefix_attrs = prefix_attrs;
2310   specs->attrs = NULL_TREE;
2311   decls = NULL_TREE;
2312   while (true)
2313     {
2314       /* Declaring one or more declarators or un-named bit-fields.  */
2315       struct c_declarator *declarator;
2316       bool dummy = false;
2317       if (c_parser_next_token_is (parser, CPP_COLON))
2318         declarator = build_id_declarator (NULL_TREE);
2319       else
2320         declarator = c_parser_declarator (parser, specs->type_seen_p,
2321                                           C_DTR_NORMAL, &dummy);
2322       if (declarator == NULL)
2323         {
2324           c_parser_skip_to_end_of_block_or_statement (parser);
2325           break;
2326         }
2327       if (c_parser_next_token_is (parser, CPP_COLON)
2328           || c_parser_next_token_is (parser, CPP_COMMA)
2329           || c_parser_next_token_is (parser, CPP_SEMICOLON)
2330           || c_parser_next_token_is (parser, CPP_CLOSE_BRACE)
2331           || c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
2332         {
2333           tree postfix_attrs = NULL_TREE;
2334           tree width = NULL_TREE;
2335           tree d;
2336           if (c_parser_next_token_is (parser, CPP_COLON))
2337             {
2338               c_parser_consume_token (parser);
2339               width = c_parser_expr_no_commas (parser, NULL).value;
2340             }
2341           if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
2342             postfix_attrs = c_parser_attributes (parser);
2343           d = grokfield (c_parser_peek_token (parser)->location,
2344                          declarator, specs, width, &all_prefix_attrs);
2345           decl_attributes (&d, chainon (postfix_attrs,
2346                                         all_prefix_attrs), 0);
2347           DECL_CHAIN (d) = decls;
2348           decls = d;
2349           if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
2350             all_prefix_attrs = chainon (c_parser_attributes (parser),
2351                                         prefix_attrs);
2352           else
2353             all_prefix_attrs = prefix_attrs;
2354           if (c_parser_next_token_is (parser, CPP_COMMA))
2355             c_parser_consume_token (parser);
2356           else if (c_parser_next_token_is (parser, CPP_SEMICOLON)
2357                    || c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
2358             {
2359               /* Semicolon consumed in caller.  */
2360               break;
2361             }
2362           else
2363             {
2364               c_parser_error (parser, "expected %<,%>, %<;%> or %<}%>");
2365               break;
2366             }
2367         }
2368       else
2369         {
2370           c_parser_error (parser,
2371                           "expected %<:%>, %<,%>, %<;%>, %<}%> or "
2372                           "%<__attribute__%>");
2373           break;
2374         }
2375     }
2376   return decls;
2377 }
2378
2379 /* Parse a typeof specifier (a GNU extension).
2380
2381    typeof-specifier:
2382      typeof ( expression )
2383      typeof ( type-name )
2384 */
2385
2386 static struct c_typespec
2387 c_parser_typeof_specifier (c_parser *parser)
2388 {
2389   struct c_typespec ret;
2390   ret.kind = ctsk_typeof;
2391   ret.spec = error_mark_node;
2392   ret.expr = NULL_TREE;
2393   ret.expr_const_operands = true;
2394   gcc_assert (c_parser_next_token_is_keyword (parser, RID_TYPEOF));
2395   c_parser_consume_token (parser);
2396   c_inhibit_evaluation_warnings++;
2397   in_typeof++;
2398   if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
2399     {
2400       c_inhibit_evaluation_warnings--;
2401       in_typeof--;
2402       return ret;
2403     }
2404   if (c_parser_next_token_starts_typename (parser))
2405     {
2406       struct c_type_name *type = c_parser_type_name (parser);
2407       c_inhibit_evaluation_warnings--;
2408       in_typeof--;
2409       if (type != NULL)
2410         {
2411           ret.spec = groktypename (type, &ret.expr, &ret.expr_const_operands);
2412           pop_maybe_used (variably_modified_type_p (ret.spec, NULL_TREE));
2413         }
2414     }
2415   else
2416     {
2417       bool was_vm;
2418       location_t here = c_parser_peek_token (parser)->location;
2419       struct c_expr expr = c_parser_expression (parser);
2420       c_inhibit_evaluation_warnings--;
2421       in_typeof--;
2422       if (TREE_CODE (expr.value) == COMPONENT_REF
2423           && DECL_C_BIT_FIELD (TREE_OPERAND (expr.value, 1)))
2424         error_at (here, "%<typeof%> applied to a bit-field");
2425       mark_exp_read (expr.value);
2426       ret.spec = TREE_TYPE (expr.value);
2427       was_vm = variably_modified_type_p (ret.spec, NULL_TREE);
2428       /* This is returned with the type so that when the type is
2429          evaluated, this can be evaluated.  */
2430       if (was_vm)
2431         ret.expr = c_fully_fold (expr.value, false, &ret.expr_const_operands);
2432       pop_maybe_used (was_vm);
2433     }
2434   c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
2435   return ret;
2436 }
2437
2438 /* Parse a declarator, possibly an abstract declarator (C90 6.5.4,
2439    6.5.5, C99 6.7.5, 6.7.6).  If TYPE_SEEN_P then a typedef name may
2440    be redeclared; otherwise it may not.  KIND indicates which kind of
2441    declarator is wanted.  Returns a valid declarator except in the
2442    case of a syntax error in which case NULL is returned.  *SEEN_ID is
2443    set to true if an identifier being declared is seen; this is used
2444    to diagnose bad forms of abstract array declarators and to
2445    determine whether an identifier list is syntactically permitted.
2446
2447    declarator:
2448      pointer[opt] direct-declarator
2449
2450    direct-declarator:
2451      identifier
2452      ( attributes[opt] declarator )
2453      direct-declarator array-declarator
2454      direct-declarator ( parameter-type-list )
2455      direct-declarator ( identifier-list[opt] )
2456
2457    pointer:
2458      * type-qualifier-list[opt]
2459      * type-qualifier-list[opt] pointer
2460
2461    type-qualifier-list:
2462      type-qualifier
2463      attributes
2464      type-qualifier-list type-qualifier
2465      type-qualifier-list attributes
2466
2467    parameter-type-list:
2468      parameter-list
2469      parameter-list , ...
2470
2471    parameter-list:
2472      parameter-declaration
2473      parameter-list , parameter-declaration
2474
2475    parameter-declaration:
2476      declaration-specifiers declarator attributes[opt]
2477      declaration-specifiers abstract-declarator[opt] attributes[opt]
2478
2479    identifier-list:
2480      identifier
2481      identifier-list , identifier
2482
2483    abstract-declarator:
2484      pointer
2485      pointer[opt] direct-abstract-declarator
2486
2487    direct-abstract-declarator:
2488      ( attributes[opt] abstract-declarator )
2489      direct-abstract-declarator[opt] array-declarator
2490      direct-abstract-declarator[opt] ( parameter-type-list[opt] )
2491
2492    GNU extensions:
2493
2494    direct-declarator:
2495      direct-declarator ( parameter-forward-declarations
2496                          parameter-type-list[opt] )
2497
2498    direct-abstract-declarator:
2499      direct-abstract-declarator[opt] ( parameter-forward-declarations
2500                                        parameter-type-list[opt] )
2501
2502    parameter-forward-declarations:
2503      parameter-list ;
2504      parameter-forward-declarations parameter-list ;
2505
2506    The uses of attributes shown above are GNU extensions.
2507
2508    Some forms of array declarator are not included in C99 in the
2509    syntax for abstract declarators; these are disallowed elsewhere.
2510    This may be a defect (DR#289).
2511
2512    This function also accepts an omitted abstract declarator as being
2513    an abstract declarator, although not part of the formal syntax.  */
2514
2515 static struct c_declarator *
2516 c_parser_declarator (c_parser *parser, bool type_seen_p, c_dtr_syn kind,
2517                      bool *seen_id)
2518 {
2519   /* Parse any initial pointer part.  */
2520   if (c_parser_next_token_is (parser, CPP_MULT))
2521     {
2522       struct c_declspecs *quals_attrs = build_null_declspecs ();
2523       struct c_declarator *inner;
2524       c_parser_consume_token (parser);
2525       c_parser_declspecs (parser, quals_attrs, false, false, true);
2526       inner = c_parser_declarator (parser, type_seen_p, kind, seen_id);
2527       if (inner == NULL)
2528         return NULL;
2529       else
2530         return make_pointer_declarator (quals_attrs, inner);
2531     }
2532   /* Now we have a direct declarator, direct abstract declarator or
2533      nothing (which counts as a direct abstract declarator here).  */
2534   return c_parser_direct_declarator (parser, type_seen_p, kind, seen_id);
2535 }
2536
2537 /* Parse a direct declarator or direct abstract declarator; arguments
2538    as c_parser_declarator.  */
2539
2540 static struct c_declarator *
2541 c_parser_direct_declarator (c_parser *parser, bool type_seen_p, c_dtr_syn kind,
2542                             bool *seen_id)
2543 {
2544   /* The direct declarator must start with an identifier (possibly
2545      omitted) or a parenthesized declarator (possibly abstract).  In
2546      an ordinary declarator, initial parentheses must start a
2547      parenthesized declarator.  In an abstract declarator or parameter
2548      declarator, they could start a parenthesized declarator or a
2549      parameter list.  To tell which, the open parenthesis and any
2550      following attributes must be read.  If a declaration specifier
2551      follows, then it is a parameter list; if the specifier is a
2552      typedef name, there might be an ambiguity about redeclaring it,
2553      which is resolved in the direction of treating it as a typedef
2554      name.  If a close parenthesis follows, it is also an empty
2555      parameter list, as the syntax does not permit empty abstract
2556      declarators.  Otherwise, it is a parenthesized declarator (in
2557      which case the analysis may be repeated inside it, recursively).
2558
2559      ??? There is an ambiguity in a parameter declaration "int
2560      (__attribute__((foo)) x)", where x is not a typedef name: it
2561      could be an abstract declarator for a function, or declare x with
2562      parentheses.  The proper resolution of this ambiguity needs
2563      documenting.  At present we follow an accident of the old
2564      parser's implementation, whereby the first parameter must have
2565      some declaration specifiers other than just attributes.  Thus as
2566      a parameter declaration it is treated as a parenthesized
2567      parameter named x, and as an abstract declarator it is
2568      rejected.
2569
2570      ??? Also following the old parser, attributes inside an empty
2571      parameter list are ignored, making it a list not yielding a
2572      prototype, rather than giving an error or making it have one
2573      parameter with implicit type int.
2574
2575      ??? Also following the old parser, typedef names may be
2576      redeclared in declarators, but not Objective-C class names.  */
2577
2578   if (kind != C_DTR_ABSTRACT
2579       && c_parser_next_token_is (parser, CPP_NAME)
2580       && ((type_seen_p
2581            && (c_parser_peek_token (parser)->id_kind == C_ID_TYPENAME
2582                || c_parser_peek_token (parser)->id_kind == C_ID_CLASSNAME))
2583           || c_parser_peek_token (parser)->id_kind == C_ID_ID))
2584     {
2585       struct c_declarator *inner
2586         = build_id_declarator (c_parser_peek_token (parser)->value);
2587       *seen_id = true;
2588       inner->id_loc = c_parser_peek_token (parser)->location;
2589       c_parser_consume_token (parser);
2590       return c_parser_direct_declarator_inner (parser, *seen_id, inner);
2591     }
2592
2593   if (kind != C_DTR_NORMAL
2594       && c_parser_next_token_is (parser, CPP_OPEN_SQUARE))
2595     {
2596       struct c_declarator *inner = build_id_declarator (NULL_TREE);
2597       return c_parser_direct_declarator_inner (parser, *seen_id, inner);
2598     }
2599
2600   /* Either we are at the end of an abstract declarator, or we have
2601      parentheses.  */
2602
2603   if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
2604     {
2605       tree attrs;
2606       struct c_declarator *inner;
2607       c_parser_consume_token (parser);
2608       attrs = c_parser_attributes (parser);
2609       if (kind != C_DTR_NORMAL
2610           && (c_parser_next_token_starts_declspecs (parser)
2611               || c_parser_next_token_is (parser, CPP_CLOSE_PAREN)))
2612         {
2613           struct c_arg_info *args
2614             = c_parser_parms_declarator (parser, kind == C_DTR_NORMAL,
2615                                          attrs);
2616           if (args == NULL)
2617             return NULL;
2618           else
2619             {
2620               inner
2621                 = build_function_declarator (args,
2622                                              build_id_declarator (NULL_TREE));
2623               return c_parser_direct_declarator_inner (parser, *seen_id,
2624                                                        inner);
2625             }
2626         }
2627       /* A parenthesized declarator.  */
2628       inner = c_parser_declarator (parser, type_seen_p, kind, seen_id);
2629       if (inner != NULL && attrs != NULL)
2630         inner = build_attrs_declarator (attrs, inner);
2631       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2632         {
2633           c_parser_consume_token (parser);
2634           if (inner == NULL)
2635             return NULL;
2636           else
2637             return c_parser_direct_declarator_inner (parser, *seen_id, inner);
2638         }
2639       else
2640         {
2641           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2642                                      "expected %<)%>");
2643           return NULL;
2644         }
2645     }
2646   else
2647     {
2648       if (kind == C_DTR_NORMAL)
2649         {
2650           c_parser_error (parser, "expected identifier or %<(%>");
2651           return NULL;
2652         }
2653       else
2654         return build_id_declarator (NULL_TREE);
2655     }
2656 }
2657
2658 /* Parse part of a direct declarator or direct abstract declarator,
2659    given that some (in INNER) has already been parsed; ID_PRESENT is
2660    true if an identifier is present, false for an abstract
2661    declarator.  */
2662
2663 static struct c_declarator *
2664 c_parser_direct_declarator_inner (c_parser *parser, bool id_present,
2665                                   struct c_declarator *inner)
2666 {
2667   /* Parse a sequence of array declarators and parameter lists.  */
2668   if (c_parser_next_token_is (parser, CPP_OPEN_SQUARE))
2669     {
2670       location_t brace_loc = c_parser_peek_token (parser)->location;
2671       struct c_declarator *declarator;
2672       struct c_declspecs *quals_attrs = build_null_declspecs ();
2673       bool static_seen;
2674       bool star_seen;
2675       tree dimen;
2676       c_parser_consume_token (parser);
2677       c_parser_declspecs (parser, quals_attrs, false, false, true);
2678       static_seen = c_parser_next_token_is_keyword (parser, RID_STATIC);
2679       if (static_seen)
2680         c_parser_consume_token (parser);
2681       if (static_seen && !quals_attrs->declspecs_seen_p)
2682         c_parser_declspecs (parser, quals_attrs, false, false, true);
2683       if (!quals_attrs->declspecs_seen_p)
2684         quals_attrs = NULL;
2685       /* If "static" is present, there must be an array dimension.
2686          Otherwise, there may be a dimension, "*", or no
2687          dimension.  */
2688       if (static_seen)
2689         {
2690           star_seen = false;
2691           dimen = c_parser_expr_no_commas (parser, NULL).value;
2692         }
2693       else
2694         {
2695           if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
2696             {
2697               dimen = NULL_TREE;
2698               star_seen = false;
2699             }
2700           else if (c_parser_next_token_is (parser, CPP_MULT))
2701             {
2702               if (c_parser_peek_2nd_token (parser)->type == CPP_CLOSE_SQUARE)
2703                 {
2704                   dimen = NULL_TREE;
2705                   star_seen = true;
2706                   c_parser_consume_token (parser);
2707                 }
2708               else
2709                 {
2710                   star_seen = false;
2711                   dimen = c_parser_expr_no_commas (parser, NULL).value;
2712                 }
2713             }
2714           else
2715             {
2716               star_seen = false;
2717               dimen = c_parser_expr_no_commas (parser, NULL).value;
2718             }
2719         }
2720       if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
2721         c_parser_consume_token (parser);
2722       else
2723         {
2724           c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
2725                                      "expected %<]%>");
2726           return NULL;
2727         }
2728       if (dimen)
2729         mark_exp_read (dimen);
2730       declarator = build_array_declarator (brace_loc, dimen, quals_attrs,
2731                                            static_seen, star_seen);
2732       if (declarator == NULL)
2733         return NULL;
2734       inner = set_array_declarator_inner (declarator, inner);
2735       return c_parser_direct_declarator_inner (parser, id_present, inner);
2736     }
2737   else if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
2738     {
2739       tree attrs;
2740       struct c_arg_info *args;
2741       c_parser_consume_token (parser);
2742       attrs = c_parser_attributes (parser);
2743       args = c_parser_parms_declarator (parser, id_present, attrs);
2744       if (args == NULL)
2745         return NULL;
2746       else
2747         {
2748           inner = build_function_declarator (args, inner);
2749           return c_parser_direct_declarator_inner (parser, id_present, inner);
2750         }
2751     }
2752   return inner;
2753 }
2754
2755 /* Parse a parameter list or identifier list, including the closing
2756    parenthesis but not the opening one.  ATTRS are the attributes at
2757    the start of the list.  ID_LIST_OK is true if an identifier list is
2758    acceptable; such a list must not have attributes at the start.  */
2759
2760 static struct c_arg_info *
2761 c_parser_parms_declarator (c_parser *parser, bool id_list_ok, tree attrs)
2762 {
2763   push_scope ();
2764   declare_parm_level ();
2765   /* If the list starts with an identifier, it is an identifier list.
2766      Otherwise, it is either a prototype list or an empty list.  */
2767   if (id_list_ok
2768       && !attrs
2769       && c_parser_next_token_is (parser, CPP_NAME)
2770       && c_parser_peek_token (parser)->id_kind == C_ID_ID)
2771     {
2772       tree list = NULL_TREE, *nextp = &list;
2773       while (c_parser_next_token_is (parser, CPP_NAME)
2774              && c_parser_peek_token (parser)->id_kind == C_ID_ID)
2775         {
2776           *nextp = build_tree_list (NULL_TREE,
2777                                     c_parser_peek_token (parser)->value);
2778           nextp = & TREE_CHAIN (*nextp);
2779           c_parser_consume_token (parser);
2780           if (c_parser_next_token_is_not (parser, CPP_COMMA))
2781             break;
2782           c_parser_consume_token (parser);
2783           if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2784             {
2785               c_parser_error (parser, "expected identifier");
2786               break;
2787             }
2788         }
2789       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2790         {
2791           struct c_arg_info *ret = build_arg_info ();
2792           ret->types = list;
2793           c_parser_consume_token (parser);
2794           pop_scope ();
2795           return ret;
2796         }
2797       else
2798         {
2799           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2800                                      "expected %<)%>");
2801           pop_scope ();
2802           return NULL;
2803         }
2804     }
2805   else
2806     {
2807       struct c_arg_info *ret = c_parser_parms_list_declarator (parser, attrs);
2808       pop_scope ();
2809       return ret;
2810     }
2811 }
2812
2813 /* Parse a parameter list (possibly empty), including the closing
2814    parenthesis but not the opening one.  ATTRS are the attributes at
2815    the start of the list.  */
2816
2817 static struct c_arg_info *
2818 c_parser_parms_list_declarator (c_parser *parser, tree attrs)
2819 {
2820   bool bad_parm = false;
2821   /* ??? Following the old parser, forward parameter declarations may
2822      use abstract declarators, and if no real parameter declarations
2823      follow the forward declarations then this is not diagnosed.  Also
2824      note as above that attributes are ignored as the only contents of
2825      the parentheses, or as the only contents after forward
2826      declarations.  */
2827   if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2828     {
2829       struct c_arg_info *ret = build_arg_info ();
2830       c_parser_consume_token (parser);
2831       return ret;
2832     }
2833   if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
2834     {
2835       struct c_arg_info *ret = build_arg_info ();
2836       /* Suppress -Wold-style-definition for this case.  */
2837       ret->types = error_mark_node;
2838       error_at (c_parser_peek_token (parser)->location,
2839                 "ISO C requires a named argument before %<...%>");
2840       c_parser_consume_token (parser);
2841       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2842         {
2843           c_parser_consume_token (parser);
2844           return ret;
2845         }
2846       else
2847         {
2848           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2849                                      "expected %<)%>");
2850           return NULL;
2851         }
2852     }
2853   /* Nonempty list of parameters, either terminated with semicolon
2854      (forward declarations; recurse) or with close parenthesis (normal
2855      function) or with ", ... )" (variadic function).  */
2856   while (true)
2857     {
2858       /* Parse a parameter.  */
2859       struct c_parm *parm = c_parser_parameter_declaration (parser, attrs);
2860       attrs = NULL_TREE;
2861       if (parm == NULL)
2862         bad_parm = true;
2863       else
2864         push_parm_decl (parm);
2865       if (c_parser_next_token_is (parser, CPP_SEMICOLON))
2866         {
2867           tree new_attrs;
2868           c_parser_consume_token (parser);
2869           mark_forward_parm_decls ();
2870           new_attrs = c_parser_attributes (parser);
2871           return c_parser_parms_list_declarator (parser, new_attrs);
2872         }
2873       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2874         {
2875           c_parser_consume_token (parser);
2876           if (bad_parm)
2877             {
2878               get_pending_sizes ();
2879               return NULL;
2880             }
2881           else
2882             return get_parm_info (false);
2883         }
2884       if (!c_parser_require (parser, CPP_COMMA,
2885                              "expected %<;%>, %<,%> or %<)%>"))
2886         {
2887           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
2888           get_pending_sizes ();
2889           return NULL;
2890         }
2891       if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
2892         {
2893           c_parser_consume_token (parser);
2894           if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2895             {
2896               c_parser_consume_token (parser);
2897               if (bad_parm)
2898                 {
2899                   get_pending_sizes ();
2900                   return NULL;
2901                 }
2902               else
2903                 return get_parm_info (true);
2904             }
2905           else
2906             {
2907               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2908                                          "expected %<)%>");
2909               get_pending_sizes ();
2910               return NULL;
2911             }
2912         }
2913     }
2914 }
2915
2916 /* Parse a parameter declaration.  ATTRS are the attributes at the
2917    start of the declaration if it is the first parameter.  */
2918
2919 static struct c_parm *
2920 c_parser_parameter_declaration (c_parser *parser, tree attrs)
2921 {
2922   struct c_declspecs *specs;
2923   struct c_declarator *declarator;
2924   tree prefix_attrs;
2925   tree postfix_attrs = NULL_TREE;
2926   bool dummy = false;
2927   if (!c_parser_next_token_starts_declspecs (parser))
2928     {
2929       c_token *token = c_parser_peek_token (parser);
2930       if (parser->error)
2931         return NULL;
2932       c_parser_set_source_position_from_token (token);
2933       if (token->type == CPP_NAME
2934           && c_parser_peek_2nd_token (parser)->type != CPP_COMMA
2935           && c_parser_peek_2nd_token (parser)->type != CPP_CLOSE_PAREN)
2936         {
2937           error ("unknown type name %qE", token->value);
2938           parser->error = true;
2939         }
2940       /* ??? In some Objective-C cases '...' isn't applicable so there
2941          should be a different message.  */
2942       else
2943         c_parser_error (parser,
2944                         "expected declaration specifiers or %<...%>");
2945       c_parser_skip_to_end_of_parameter (parser);
2946       return NULL;
2947     }
2948   specs = build_null_declspecs ();
2949   if (attrs)
2950     {
2951       declspecs_add_attrs (specs, attrs);
2952       attrs = NULL_TREE;
2953     }
2954   c_parser_declspecs (parser, specs, true, true, true);
2955   finish_declspecs (specs);
2956   pending_xref_error ();
2957   prefix_attrs = specs->attrs;
2958   specs->attrs = NULL_TREE;
2959   declarator = c_parser_declarator (parser, specs->type_seen_p,
2960                                     C_DTR_PARM, &dummy);
2961   if (declarator == NULL)
2962     {
2963       c_parser_skip_until_found (parser, CPP_COMMA, NULL);
2964       return NULL;
2965     }
2966   if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
2967     postfix_attrs = c_parser_attributes (parser);
2968   return build_c_parm (specs, chainon (postfix_attrs, prefix_attrs),
2969                        declarator);
2970 }
2971
2972 /* Parse a string literal in an asm expression.  It should not be
2973    translated, and wide string literals are an error although
2974    permitted by the syntax.  This is a GNU extension.
2975
2976    asm-string-literal:
2977      string-literal
2978
2979    ??? At present, following the old parser, the caller needs to have
2980    set lex_untranslated_string to 1.  It would be better to follow the
2981    C++ parser rather than using this kludge.  */
2982
2983 static tree
2984 c_parser_asm_string_literal (c_parser *parser)
2985 {
2986   tree str;
2987   if (c_parser_next_token_is (parser, CPP_STRING))
2988     {
2989       str = c_parser_peek_token (parser)->value;
2990       c_parser_consume_token (parser);
2991     }
2992   else if (c_parser_next_token_is (parser, CPP_WSTRING))
2993     {
2994       error_at (c_parser_peek_token (parser)->location,
2995                 "wide string literal in %<asm%>");
2996       str = build_string (1, "");
2997       c_parser_consume_token (parser);
2998     }
2999   else
3000     {
3001       c_parser_error (parser, "expected string literal");
3002       str = NULL_TREE;
3003     }
3004   return str;
3005 }
3006
3007 /* Parse a simple asm expression.  This is used in restricted
3008    contexts, where a full expression with inputs and outputs does not
3009    make sense.  This is a GNU extension.
3010
3011    simple-asm-expr:
3012      asm ( asm-string-literal )
3013 */
3014
3015 static tree
3016 c_parser_simple_asm_expr (c_parser *parser)
3017 {
3018   tree str;
3019   gcc_assert (c_parser_next_token_is_keyword (parser, RID_ASM));
3020   /* ??? Follow the C++ parser rather than using the
3021      lex_untranslated_string kludge.  */
3022   parser->lex_untranslated_string = true;
3023   c_parser_consume_token (parser);
3024   if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
3025     {
3026       parser->lex_untranslated_string = false;
3027       return NULL_TREE;
3028     }
3029   str = c_parser_asm_string_literal (parser);
3030   parser->lex_untranslated_string = false;
3031   if (!c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
3032     {
3033       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
3034       return NULL_TREE;
3035     }
3036   return str;
3037 }
3038
3039 /* Parse (possibly empty) attributes.  This is a GNU extension.
3040
3041    attributes:
3042      empty
3043      attributes attribute
3044
3045    attribute:
3046      __attribute__ ( ( attribute-list ) )
3047
3048    attribute-list:
3049      attrib
3050      attribute_list , attrib
3051
3052    attrib:
3053      empty
3054      any-word
3055      any-word ( identifier )
3056      any-word ( identifier , nonempty-expr-list )
3057      any-word ( expr-list )
3058
3059    where the "identifier" must not be declared as a type, and
3060    "any-word" may be any identifier (including one declared as a
3061    type), a reserved word storage class specifier, type specifier or
3062    type qualifier.  ??? This still leaves out most reserved keywords
3063    (following the old parser), shouldn't we include them, and why not
3064    allow identifiers declared as types to start the arguments?  */
3065
3066 static tree
3067 c_parser_attributes (c_parser *parser)
3068 {
3069   tree attrs = NULL_TREE;
3070   while (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
3071     {
3072       /* ??? Follow the C++ parser rather than using the
3073          lex_untranslated_string kludge.  */
3074       parser->lex_untranslated_string = true;
3075       c_parser_consume_token (parser);
3076       if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
3077         {
3078           parser->lex_untranslated_string = false;
3079           return attrs;
3080         }
3081       if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
3082         {
3083           parser->lex_untranslated_string = false;
3084           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
3085           return attrs;
3086         }
3087       /* Parse the attribute list.  */
3088       while (c_parser_next_token_is (parser, CPP_COMMA)
3089              || c_parser_next_token_is (parser, CPP_NAME)
3090              || c_parser_next_token_is (parser, CPP_KEYWORD))
3091         {
3092           tree attr, attr_name, attr_args;
3093           VEC(tree,gc) *expr_list;
3094           if (c_parser_next_token_is (parser, CPP_COMMA))
3095             {
3096               c_parser_consume_token (parser);
3097               continue;
3098             }
3099           if (c_parser_next_token_is (parser, CPP_KEYWORD))
3100             {
3101               /* ??? See comment above about what keywords are
3102                  accepted here.  */
3103               bool ok;
3104               switch (c_parser_peek_token (parser)->keyword)
3105                 {
3106                 case RID_STATIC:
3107                 case RID_UNSIGNED:
3108                 case RID_LONG:
3109                 case RID_INT128:
3110                 case RID_CONST:
3111                 case RID_EXTERN:
3112                 case RID_REGISTER:
3113                 case RID_TYPEDEF:
3114                 case RID_SHORT:
3115                 case RID_INLINE:
3116                 case RID_VOLATILE:
3117                 case RID_SIGNED:
3118                 case RID_AUTO:
3119                 case RID_RESTRICT:
3120                 case RID_COMPLEX:
3121                 case RID_THREAD:
3122                 case RID_INT:
3123                 case RID_CHAR:
3124                 case RID_FLOAT:
3125                 case RID_DOUBLE:
3126                 case RID_VOID:
3127                 case RID_DFLOAT32:
3128                 case RID_DFLOAT64:
3129                 case RID_DFLOAT128:
3130                 case RID_BOOL:
3131                 case RID_FRACT:
3132                 case RID_ACCUM:
3133                 case RID_SAT:
3134                   ok = true;
3135                   break;
3136                 default:
3137                   ok = false;
3138                   break;
3139                 }
3140               if (!ok)
3141                 break;
3142               /* Accept __attribute__((__const)) as __attribute__((const))
3143                  etc.  */
3144               attr_name
3145                 = ridpointers[(int) c_parser_peek_token (parser)->keyword];
3146             }
3147           else
3148             attr_name = c_parser_peek_token (parser)->value;
3149           c_parser_consume_token (parser);
3150           if (c_parser_next_token_is_not (parser, CPP_OPEN_PAREN))
3151             {
3152               attr = build_tree_list (attr_name, NULL_TREE);
3153               attrs = chainon (attrs, attr);
3154               continue;
3155             }
3156           c_parser_consume_token (parser);
3157           /* Parse the attribute contents.  If they start with an
3158              identifier which is followed by a comma or close
3159              parenthesis, then the arguments start with that
3160              identifier; otherwise they are an expression list.  */
3161           if (c_parser_next_token_is (parser, CPP_NAME)
3162               && c_parser_peek_token (parser)->id_kind == C_ID_ID
3163               && ((c_parser_peek_2nd_token (parser)->type == CPP_COMMA)
3164                   || (c_parser_peek_2nd_token (parser)->type
3165                       == CPP_CLOSE_PAREN)))
3166             {
3167               tree arg1 = c_parser_peek_token (parser)->value;
3168               c_parser_consume_token (parser);
3169               if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
3170                 attr_args = build_tree_list (NULL_TREE, arg1);
3171               else
3172                 {
3173                   tree tree_list;
3174                   c_parser_consume_token (parser);
3175                   expr_list = c_parser_expr_list (parser, false, true, NULL);
3176                   tree_list = build_tree_list_vec (expr_list);
3177                   attr_args = tree_cons (NULL_TREE, arg1, tree_list);
3178                   release_tree_vector (expr_list);
3179                 }
3180             }
3181           else
3182             {
3183               if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
3184                 attr_args = NULL_TREE;
3185               else
3186                 {
3187                   expr_list = c_parser_expr_list (parser, false, true, NULL);
3188                   attr_args = build_tree_list_vec (expr_list);
3189                   release_tree_vector (expr_list);
3190                 }
3191             }
3192           attr = build_tree_list (attr_name, attr_args);
3193           if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
3194             c_parser_consume_token (parser);
3195           else
3196             {
3197               parser->lex_untranslated_string = false;
3198               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
3199                                          "expected %<)%>");
3200               return attrs;
3201             }
3202           attrs = chainon (attrs, attr);
3203         }
3204       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
3205         c_parser_consume_token (parser);
3206       else
3207         {
3208           parser->lex_untranslated_string = false;
3209           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
3210                                      "expected %<)%>");
3211           return attrs;
3212         }
3213       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
3214         c_parser_consume_token (parser);
3215       else
3216         {
3217           parser->lex_untranslated_string = false;
3218           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
3219                                      "expected %<)%>");
3220           return attrs;
3221         }
3222       parser->lex_untranslated_string = false;
3223     }
3224   return attrs;
3225 }
3226
3227 /* Parse a type name (C90 6.5.5, C99 6.7.6).
3228
3229    type-name:
3230      specifier-qualifier-list abstract-declarator[opt]
3231 */
3232
3233 static struct c_type_name *
3234 c_parser_type_name (c_parser *parser)
3235 {
3236   struct c_declspecs *specs = build_null_declspecs ();
3237   struct c_declarator *declarator;
3238   struct c_type_name *ret;
3239   bool dummy = false;
3240   c_parser_declspecs (parser, specs, false, true, true);
3241   if (!specs->declspecs_seen_p)
3242     {
3243       c_parser_error (parser, "expected specifier-qualifier-list");
3244       return NULL;
3245     }
3246   pending_xref_error ();
3247   finish_declspecs (specs);
3248   declarator = c_parser_declarator (parser, specs->type_seen_p,
3249                                     C_DTR_ABSTRACT, &dummy);
3250   if (declarator == NULL)
3251     return NULL;
3252   ret = XOBNEW (&parser_obstack, struct c_type_name);
3253   ret->specs = specs;
3254   ret->declarator = declarator;
3255   return ret;
3256 }
3257
3258 /* Parse an initializer (C90 6.5.7, C99 6.7.8).
3259
3260    initializer:
3261      assignment-expression
3262      { initializer-list }
3263      { initializer-list , }
3264
3265    initializer-list:
3266      designation[opt] initializer
3267      initializer-list , designation[opt] initializer
3268
3269    designation:
3270      designator-list =
3271
3272    designator-list:
3273      designator
3274      designator-list designator
3275
3276    designator:
3277      array-designator
3278      . identifier
3279
3280    array-designator:
3281      [ constant-expression ]
3282
3283    GNU extensions:
3284
3285    initializer:
3286      { }
3287
3288    designation:
3289      array-designator
3290      identifier :
3291
3292    array-designator:
3293      [ constant-expression ... constant-expression ]
3294
3295    Any expression without commas is accepted in the syntax for the
3296    constant-expressions, with non-constant expressions rejected later.
3297
3298    This function is only used for top-level initializers; for nested
3299    ones, see c_parser_initval.  */
3300
3301 static struct c_expr
3302 c_parser_initializer (c_parser *parser)
3303 {
3304   if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
3305     return c_parser_braced_init (parser, NULL_TREE, false);
3306   else
3307     {
3308       struct c_expr ret;
3309       location_t loc = c_parser_peek_token (parser)->location;
3310       ret = c_parser_expr_no_commas (parser, NULL);
3311       if (TREE_CODE (ret.value) != STRING_CST
3312           && TREE_CODE (ret.value) != COMPOUND_LITERAL_EXPR)
3313         ret = default_function_array_read_conversion (loc, ret);
3314       return ret;
3315     }
3316 }
3317
3318 /* Parse a braced initializer list.  TYPE is the type specified for a
3319    compound literal, and NULL_TREE for other initializers and for
3320    nested braced lists.  NESTED_P is true for nested braced lists,
3321    false for the list of a compound literal or the list that is the
3322    top-level initializer in a declaration.  */
3323
3324 static struct c_expr
3325 c_parser_braced_init (c_parser *parser, tree type, bool nested_p)
3326 {
3327   struct c_expr ret;
3328   struct obstack braced_init_obstack;
3329   location_t brace_loc = c_parser_peek_token (parser)->location;
3330   gcc_obstack_init (&braced_init_obstack);
3331   gcc_assert (c_parser_next_token_is (parser, CPP_OPEN_BRACE));
3332   c_parser_consume_token (parser);
3333   if (nested_p)
3334     push_init_level (0, &braced_init_obstack);
3335   else
3336     really_start_incremental_init (type);
3337   if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
3338     {
3339       pedwarn (brace_loc, OPT_pedantic, "ISO C forbids empty initializer braces");
3340     }
3341   else
3342     {
3343       /* Parse a non-empty initializer list, possibly with a trailing
3344          comma.  */
3345       while (true)
3346         {
3347           c_parser_initelt (parser, &braced_init_obstack);
3348           if (parser->error)
3349             break;
3350           if (c_parser_next_token_is (parser, CPP_COMMA))
3351             c_parser_consume_token (parser);
3352           else
3353             break;
3354           if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
3355             break;
3356         }
3357     }
3358   if (c_parser_next_token_is_not (parser, CPP_CLOSE_BRACE))
3359     {
3360       ret.value = error_mark_node;
3361       ret.original_code = ERROR_MARK;
3362       ret.original_type = NULL;
3363       c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, "expected %<}%>");
3364       pop_init_level (0, &braced_init_obstack);
3365       obstack_free (&braced_init_obstack, NULL);
3366       return ret;
3367     }
3368   c_parser_consume_token (parser);
3369   ret = pop_init_level (0, &braced_init_obstack);
3370   obstack_free (&braced_init_obstack, NULL);
3371   return ret;
3372 }
3373
3374 /* Parse a nested initializer, including designators.  */
3375
3376 static void
3377 c_parser_initelt (c_parser *parser, struct obstack * braced_init_obstack)
3378 {
3379   /* Parse any designator or designator list.  A single array
3380      designator may have the subsequent "=" omitted in GNU C, but a
3381      longer list or a structure member designator may not.  */
3382   if (c_parser_next_token_is (parser, CPP_NAME)
3383       && c_parser_peek_2nd_token (parser)->type == CPP_COLON)
3384     {
3385       /* Old-style structure member designator.  */
3386       set_init_label (c_parser_peek_token (parser)->value,
3387                       braced_init_obstack);
3388       /* Use the colon as the error location.  */
3389       pedwarn (c_parser_peek_2nd_token (parser)->location, OPT_pedantic,
3390                "obsolete use of designated initializer with %<:%>");
3391       c_parser_consume_token (parser);
3392       c_parser_consume_token (parser);
3393     }
3394   else
3395     {
3396       /* des_seen is 0 if there have been no designators, 1 if there
3397          has been a single array designator and 2 otherwise.  */
3398       int des_seen = 0;
3399       /* Location of a designator.  */
3400       location_t des_loc = UNKNOWN_LOCATION;  /* Quiet warning.  */
3401       while (c_parser_next_token_is (parser, CPP_OPEN_SQUARE)
3402              || c_parser_next_token_is (parser, CPP_DOT))
3403         {
3404           int des_prev = des_seen;
3405           if (!des_seen)
3406             des_loc = c_parser_peek_token (parser)->location;
3407           if (des_seen < 2)
3408             des_seen++;
3409           if (c_parser_next_token_is (parser, CPP_DOT))
3410             {
3411               des_seen = 2;
3412               c_parser_consume_token (parser);
3413               if (c_parser_next_token_is (parser, CPP_NAME))
3414                 {
3415                   set_init_label (c_parser_peek_token (parser)->value,
3416                                   braced_init_obstack);
3417                   c_parser_consume_token (parser);
3418                 }
3419               else
3420                 {
3421                   struct c_expr init;
3422                   init.value = error_mark_node;
3423                   init.original_code = ERROR_MARK;
3424                   init.original_type = NULL;
3425                   c_parser_error (parser, "expected identifier");
3426                   c_parser_skip_until_found (parser, CPP_COMMA, NULL);
3427                   process_init_element (init, false, braced_init_obstack);
3428                   return;
3429                 }
3430             }
3431           else
3432             {
3433               tree first, second;
3434               location_t ellipsis_loc = UNKNOWN_LOCATION;  /* Quiet warning.  */
3435               /* ??? Following the old parser, [ objc-receiver
3436                  objc-message-args ] is accepted as an initializer,
3437                  being distinguished from a designator by what follows
3438                  the first assignment expression inside the square
3439                  brackets, but after a first array designator a
3440                  subsequent square bracket is for Objective-C taken to
3441                  start an expression, using the obsolete form of
3442                  designated initializer without '=', rather than
3443                  possibly being a second level of designation: in LALR
3444                  terms, the '[' is shifted rather than reducing
3445                  designator to designator-list.  */
3446               if (des_prev == 1 && c_dialect_objc ())
3447                 {
3448                   des_seen = des_prev;
3449                   break;
3450                 }
3451               if (des_prev == 0 && c_dialect_objc ())
3452                 {
3453                   /* This might be an array designator or an
3454                      Objective-C message expression.  If the former,
3455                      continue parsing here; if the latter, parse the
3456                      remainder of the initializer given the starting
3457                      primary-expression.  ??? It might make sense to
3458                      distinguish when des_prev == 1 as well; see
3459                      previous comment.  */
3460                   tree rec, args;
3461                   struct c_expr mexpr;
3462                   c_parser_consume_token (parser);
3463                   if (c_parser_peek_token (parser)->type == CPP_NAME
3464                       && ((c_parser_peek_token (parser)->id_kind
3465                            == C_ID_TYPENAME)
3466                           || (c_parser_peek_token (parser)->id_kind
3467                               == C_ID_CLASSNAME)))
3468                     {
3469                       /* Type name receiver.  */
3470                       tree id = c_parser_peek_token (parser)->value;
3471                       c_parser_consume_token (parser);
3472                       rec = objc_get_class_reference (id);
3473                       goto parse_message_args;
3474                     }
3475                   first = c_parser_expr_no_commas (parser, NULL).value;
3476                   mark_exp_read (first);
3477                   if (c_parser_next_token_is (parser, CPP_ELLIPSIS)
3478                       || c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
3479                     goto array_desig_after_first;
3480                   /* Expression receiver.  So far only one part
3481                      without commas has been parsed; there might be
3482                      more of the expression.  */
3483                   rec = first;
3484                   while (c_parser_next_token_is (parser, CPP_COMMA))
3485                     {
3486                       struct c_expr next;
3487                       location_t comma_loc, exp_loc;
3488                       comma_loc = c_parser_peek_token (parser)->location;
3489                       c_parser_consume_token (parser);
3490                       exp_loc = c_parser_peek_token (parser)->location;
3491                       next = c_parser_expr_no_commas (parser, NULL);
3492                       next = default_function_array_read_conversion (exp_loc,
3493                                                                      next);
3494                       rec = build_compound_expr (comma_loc, rec, next.value);
3495                     }
3496                 parse_message_args:
3497                   /* Now parse the objc-message-args.  */
3498                   args = c_parser_objc_message_args (parser);
3499                   c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
3500                                              "expected %<]%>");
3501                   mexpr.value
3502                     = objc_build_message_expr (build_tree_list (rec, args));
3503                   mexpr.original_code = ERROR_MARK;
3504                   mexpr.original_type = NULL;
3505                   /* Now parse and process the remainder of the
3506                      initializer, starting with this message
3507                      expression as a primary-expression.  */
3508                   c_parser_initval (parser, &mexpr, braced_init_obstack);
3509                   return;
3510                 }
3511               c_parser_consume_token (parser);
3512               first = c_parser_expr_no_commas (parser, NULL).value;
3513               mark_exp_read (first);
3514             array_desig_after_first:
3515               if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
3516                 {
3517                   ellipsis_loc = c_parser_peek_token (parser)->location;
3518                   c_parser_consume_token (parser);
3519                   second = c_parser_expr_no_commas (parser, NULL).value;
3520                   mark_exp_read (second);
3521                 }
3522               else
3523                 second = NULL_TREE;
3524               if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
3525                 {
3526                   c_parser_consume_token (parser);
3527                   set_init_index (first, second, braced_init_obstack);
3528                   if (second)
3529                     pedwarn (ellipsis_loc, OPT_pedantic,
3530                              "ISO C forbids specifying range of elements to initialize");
3531                 }
3532               else
3533                 c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
3534                                            "expected %<]%>");
3535             }
3536         }
3537       if (des_seen >= 1)
3538         {
3539           if (c_parser_next_token_is (parser, CPP_EQ))
3540             {
3541               if (!flag_isoc99)
3542                 pedwarn (des_loc, OPT_pedantic,
3543                          "ISO C90 forbids specifying subobject to initialize");
3544               c_parser_consume_token (parser);
3545             }
3546           else
3547             {
3548               if (des_seen == 1)
3549                 pedwarn (c_parser_peek_token (parser)->location, OPT_pedantic,
3550                          "obsolete use of designated initializer without %<=%>");
3551               else
3552                 {
3553                   struct c_expr init;
3554                   init.value = error_mark_node;
3555                   init.original_code = ERROR_MARK;
3556                   init.original_type = NULL;
3557                   c_parser_error (parser, "expected %<=%>");
3558                   c_parser_skip_until_found (parser, CPP_COMMA, NULL);
3559                   process_init_element (init, false, braced_init_obstack);
3560                   return;
3561                 }
3562             }
3563         }
3564     }
3565   c_parser_initval (parser, NULL, braced_init_obstack);
3566 }
3567
3568 /* Parse a nested initializer; as c_parser_initializer but parses
3569    initializers within braced lists, after any designators have been
3570    applied.  If AFTER is not NULL then it is an Objective-C message
3571    expression which is the primary-expression starting the
3572    initializer.  */
3573
3574 static void
3575 c_parser_initval (c_parser *parser, struct c_expr *after,
3576                   struct obstack * braced_init_obstack)
3577 {
3578   struct c_expr init;
3579   gcc_assert (!after || c_dialect_objc ());
3580   if (c_parser_next_token_is (parser, CPP_OPEN_BRACE) && !after)
3581     init = c_parser_braced_init (parser, NULL_TREE, true);
3582   else
3583     {
3584       location_t loc = c_parser_peek_token (parser)->location;
3585       init = c_parser_expr_no_commas (parser, after);
3586       if (init.value != NULL_TREE
3587           && TREE_CODE (init.value) != STRING_CST
3588           && TREE_CODE (init.value) != COMPOUND_LITERAL_EXPR)
3589         init = default_function_array_read_conversion (loc, init);
3590     }
3591   process_init_element (init, false, braced_init_obstack);
3592 }
3593
3594 /* Parse a compound statement (possibly a function body) (C90 6.6.2,
3595    C99 6.8.2).
3596
3597    compound-statement:
3598      { block-item-list[opt] }
3599      { label-declarations block-item-list }
3600
3601    block-item-list:
3602      block-item
3603      block-item-list block-item
3604
3605    block-item:
3606      nested-declaration
3607      statement
3608
3609    nested-declaration:
3610      declaration
3611
3612    GNU extensions:
3613
3614    compound-statement:
3615      { label-declarations block-item-list }
3616
3617    nested-declaration:
3618      __extension__ nested-declaration
3619      nested-function-definition
3620
3621    label-declarations:
3622      label-declaration
3623      label-declarations label-declaration
3624
3625    label-declaration:
3626      __label__ identifier-list ;
3627
3628    Allowing the mixing of declarations and code is new in C99.  The
3629    GNU syntax also permits (not shown above) labels at the end of
3630    compound statements, which yield an error.  We don't allow labels
3631    on declarations; this might seem like a natural extension, but
3632    there would be a conflict between attributes on the label and
3633    prefix attributes on the declaration.  ??? The syntax follows the
3634    old parser in requiring something after label declarations.
3635    Although they are erroneous if the labels declared aren't defined,
3636    is it useful for the syntax to be this way?
3637
3638    OpenMP:
3639
3640    block-item:
3641      openmp-directive
3642
3643    openmp-directive:
3644      barrier-directive
3645      flush-directive  */
3646
3647 static tree
3648 c_parser_compound_statement (c_parser *parser)
3649 {
3650   tree stmt;
3651   location_t brace_loc;
3652   brace_loc = c_parser_peek_token (parser)->location;
3653   if (!c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>"))
3654     {
3655       /* Ensure a scope is entered and left anyway to avoid confusion
3656          if we have just prepared to enter a function body.  */
3657       stmt = c_begin_compound_stmt (true);
3658       c_end_compound_stmt (brace_loc, stmt, true);
3659       return error_mark_node;
3660     }
3661   stmt = c_begin_compound_stmt (true);
3662   c_parser_compound_statement_nostart (parser);
3663   return c_end_compound_stmt (brace_loc, stmt, true);
3664 }
3665
3666 /* Parse a compound statement except for the opening brace.  This is
3667    used for parsing both compound statements and statement expressions
3668    (which follow different paths to handling the opening).  */
3669
3670 static void
3671 c_parser_compound_statement_nostart (c_parser *parser)
3672 {
3673   bool last_stmt = false;
3674   bool last_label = false;
3675   bool save_valid_for_pragma = valid_location_for_stdc_pragma_p ();
3676   location_t label_loc = UNKNOWN_LOCATION;  /* Quiet warning.  */
3677   if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
3678     {
3679       c_parser_consume_token (parser);
3680       return;
3681     }
3682   mark_valid_location_for_stdc_pragma (true);
3683   if (c_parser_next_token_is_keyword (parser, RID_LABEL))
3684     {
3685       /* Read zero or more forward-declarations for labels that nested
3686          functions can jump to.  */
3687       mark_valid_location_for_stdc_pragma (false);
3688       while (c_parser_next_token_is_keyword (parser, RID_LABEL))
3689         {
3690           label_loc = c_parser_peek_token (parser)->location;
3691           c_parser_consume_token (parser);
3692           /* Any identifiers, including those declared as type names,
3693              are OK here.  */
3694           while (true)
3695             {
3696               tree label;
3697               if (c_parser_next_token_is_not (parser, CPP_NAME))
3698                 {
3699                   c_parser_error (parser, "expected identifier");
3700                   break;
3701                 }
3702               label
3703                 = declare_label (c_parser_peek_token (parser)->value);
3704               C_DECLARED_LABEL_FLAG (label) = 1;
3705               add_stmt (build_stmt (label_loc, DECL_EXPR, label));
3706               c_parser_consume_token (parser);
3707               if (c_parser_next_token_is (parser, CPP_COMMA))
3708                 c_parser_consume_token (parser);
3709               else
3710                 break;
3711             }
3712           c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
3713         }
3714       pedwarn (label_loc, OPT_pedantic, "ISO C forbids label declarations");
3715     }
3716   /* We must now have at least one statement, label or declaration.  */
3717   if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
3718     {
3719       mark_valid_location_for_stdc_pragma (save_valid_for_pragma);
3720       c_parser_error (parser, "expected declaration or statement");
3721       c_parser_consume_token (parser);
3722       return;
3723     }
3724   while (c_parser_next_token_is_not (parser, CPP_CLOSE_BRACE))
3725     {
3726       location_t loc = c_parser_peek_token (parser)->location;
3727       if (c_parser_next_token_is_keyword (parser, RID_CASE)
3728           || c_parser_next_token_is_keyword (parser, RID_DEFAULT)
3729           || (c_parser_next_token_is (parser, CPP_NAME)
3730               && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
3731         {
3732           if (c_parser_next_token_is_keyword (parser, RID_CASE))
3733             label_loc = c_parser_peek_2nd_token (parser)->location;
3734           else
3735             label_loc = c_parser_peek_token (parser)->location;
3736           last_label = true;
3737           last_stmt = false;
3738           mark_valid_location_for_stdc_pragma (false);
3739           c_parser_label (parser);
3740         }
3741       else if (!last_label
3742                && c_parser_next_token_starts_declaration (parser))
3743         {
3744           last_label = false;
3745           mark_valid_location_for_stdc_pragma (false);
3746           c_parser_declaration_or_fndef (parser, true, true, true, true, true);
3747           if (last_stmt)
3748             pedwarn_c90 (loc,
3749                          (pedantic && !flag_isoc99)
3750                          ? OPT_pedantic
3751                          : OPT_Wdeclaration_after_statement,
3752                          "ISO C90 forbids mixed declarations and code");
3753           last_stmt = false;
3754         }
3755       else if (!last_label
3756                && c_parser_next_token_is_keyword (parser, RID_EXTENSION))
3757         {
3758           /* __extension__ can start a declaration, but is also an
3759              unary operator that can start an expression.  Consume all
3760              but the last of a possible series of __extension__ to
3761              determine which.  */
3762           while (c_parser_peek_2nd_token (parser)->type == CPP_KEYWORD
3763                  && (c_parser_peek_2nd_token (parser)->keyword
3764                      == RID_EXTENSION))
3765             c_parser_consume_token (parser);
3766           if (c_token_starts_declaration (c_parser_peek_2nd_token (parser)))
3767             {
3768               int ext;
3769               ext = disable_extension_diagnostics ();
3770               c_parser_consume_token (parser);
3771               last_label = false;
3772               mark_valid_location_for_stdc_pragma (false);
3773               c_parser_declaration_or_fndef (parser, true, true, true, true,
3774                                              true);
3775               /* Following the old parser, __extension__ does not
3776                  disable this diagnostic.  */
3777               restore_extension_diagnostics (ext);
3778               if (last_stmt)
3779                 pedwarn_c90 (loc, (pedantic && !flag_isoc99)
3780                              ? OPT_pedantic
3781                              : OPT_Wdeclaration_after_statement,
3782                              "ISO C90 forbids mixed declarations and code");
3783               last_stmt = false;
3784             }
3785           else
3786             goto statement;
3787         }
3788       else if (c_parser_next_token_is (parser, CPP_PRAGMA))
3789         {
3790           /* External pragmas, and some omp pragmas, are not associated
3791              with regular c code, and so are not to be considered statements
3792              syntactically.  This ensures that the user doesn't put them
3793              places that would turn into syntax errors if the directive
3794              were ignored.  */
3795           if (c_parser_pragma (parser, pragma_compound))
3796             last_label = false, last_stmt = true;
3797         }
3798       else if (c_parser_next_token_is (parser, CPP_EOF))
3799         {
3800           mark_valid_location_for_stdc_pragma (save_valid_for_pragma);
3801           c_parser_error (parser, "expected declaration or statement");
3802           return;
3803         }
3804       else if (c_parser_next_token_is_keyword (parser, RID_ELSE))
3805         {
3806           if (parser->in_if_block)
3807             {
3808               mark_valid_location_for_stdc_pragma (save_valid_for_pragma);
3809               error_at (loc, """expected %<}%> before %<else%>");
3810               return;
3811             }
3812           else
3813             {
3814               error_at (loc, "%<else%> without a previous %<if%>");
3815               c_parser_consume_token (parser);
3816               continue;
3817             }
3818         }
3819       else
3820         {
3821         statement:
3822           last_label = false;
3823           last_stmt = true;
3824           mark_valid_location_for_stdc_pragma (false);
3825           c_parser_statement_after_labels (parser);
3826         }
3827
3828       parser->error = false;
3829     }
3830   if (last_label)
3831     error_at (label_loc, "label at end of compound statement");
3832   c_parser_consume_token (parser);
3833   /* Restore the value we started with.  */
3834   mark_valid_location_for_stdc_pragma (save_valid_for_pragma);
3835 }
3836
3837 /* Parse a label (C90 6.6.1, C99 6.8.1).
3838
3839    label:
3840      identifier : attributes[opt]
3841      case constant-expression :
3842      default :
3843
3844    GNU extensions:
3845
3846    label:
3847      case constant-expression ... constant-expression :
3848
3849    The use of attributes on labels is a GNU extension.  The syntax in
3850    GNU C accepts any expressions without commas, non-constant
3851    expressions being rejected later.  */
3852
3853 static void
3854 c_parser_label (c_parser *parser)
3855 {
3856   location_t loc1 = c_parser_peek_token (parser)->location;
3857   tree label = NULL_TREE;
3858   if (c_parser_next_token_is_keyword (parser, RID_CASE))
3859     {
3860       tree exp1, exp2;
3861       c_parser_consume_token (parser);
3862       exp1 = c_parser_expr_no_commas (parser, NULL).value;
3863       if (c_parser_next_token_is (parser, CPP_COLON))
3864         {
3865           c_parser_consume_token (parser);
3866           label = do_case (loc1, exp1, NULL_TREE);
3867         }
3868       else if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
3869         {
3870           c_parser_consume_token (parser);
3871           exp2 = c_parser_expr_no_commas (parser, NULL).value;
3872           if (c_parser_require (parser, CPP_COLON, "expected %<:%>"))
3873             label = do_case (loc1, exp1, exp2);
3874         }
3875       else
3876         c_parser_error (parser, "expected %<:%> or %<...%>");
3877     }
3878   else if (c_parser_next_token_is_keyword (parser, RID_DEFAULT))
3879     {
3880       c_parser_consume_token (parser);
3881       if (c_parser_require (parser, CPP_COLON, "expected %<:%>"))
3882         label = do_case (loc1, NULL_TREE, NULL_TREE);
3883     }
3884   else
3885     {
3886       tree name = c_parser_peek_token (parser)->value;
3887       tree tlab;
3888       tree attrs;
3889       location_t loc2 = c_parser_peek_token (parser)->location;
3890       gcc_assert (c_parser_next_token_is (parser, CPP_NAME));
3891       c_parser_consume_token (parser);
3892       gcc_assert (c_parser_next_token_is (parser, CPP_COLON));
3893       c_parser_consume_token (parser);
3894       attrs = c_parser_attributes (parser);
3895       tlab = define_label (loc2, name);
3896       if (tlab)
3897         {
3898           decl_attributes (&tlab, attrs, 0);
3899           label = add_stmt (build_stmt (loc1, LABEL_EXPR, tlab));
3900         }
3901     }
3902   if (label)
3903     {
3904       if (c_parser_next_token_starts_declaration (parser)
3905           && !(c_parser_next_token_is (parser, CPP_NAME)
3906                && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
3907         {
3908           error_at (c_parser_peek_token (parser)->location,
3909                     "a label can only be part of a statement and "
3910                     "a declaration is not a statement");
3911           c_parser_declaration_or_fndef (parser, /*fndef_ok*/ false,
3912                                          /*static_assert_ok*/ true,
3913                                          /*nested*/ true, /*empty_ok*/ false,
3914                                          /*start_attr_ok*/ true);
3915         }
3916     }
3917 }
3918
3919 /* Parse a statement (C90 6.6, C99 6.8).
3920
3921    statement:
3922      labeled-statement
3923      compound-statement
3924      expression-statement
3925      selection-statement
3926      iteration-statement
3927      jump-statement
3928
3929    labeled-statement:
3930      label statement
3931
3932    expression-statement:
3933      expression[opt] ;
3934
3935    selection-statement:
3936      if-statement
3937      switch-statement
3938
3939    iteration-statement:
3940      while-statement
3941      do-statement
3942      for-statement
3943
3944    jump-statement:
3945      goto identifier ;
3946      continue ;
3947      break ;
3948      return expression[opt] ;
3949
3950    GNU extensions:
3951
3952    statement:
3953      asm-statement
3954
3955    jump-statement:
3956      goto * expression ;
3957
3958    Objective-C:
3959
3960    statement:
3961      objc-throw-statement
3962      objc-try-catch-statement
3963      objc-synchronized-statement
3964
3965    objc-throw-statement:
3966      @throw expression ;
3967      @throw ;
3968
3969    OpenMP:
3970
3971    statement:
3972      openmp-construct
3973
3974    openmp-construct:
3975      parallel-construct
3976      for-construct
3977      sections-construct
3978      single-construct
3979      parallel-for-construct
3980      parallel-sections-construct
3981      master-construct
3982      critical-construct
3983      atomic-construct
3984      ordered-construct
3985
3986    parallel-construct:
3987      parallel-directive structured-block
3988
3989    for-construct:
3990      for-directive iteration-statement
3991
3992    sections-construct:
3993      sections-directive section-scope
3994
3995    single-construct:
3996      single-directive structured-block
3997
3998    parallel-for-construct:
3999      parallel-for-directive iteration-statement
4000
4001    parallel-sections-construct:
4002      parallel-sections-directive section-scope
4003
4004    master-construct:
4005      master-directive structured-block
4006
4007    critical-construct:
4008      critical-directive structured-block
4009
4010    atomic-construct:
4011      atomic-directive expression-statement
4012
4013    ordered-construct:
4014      ordered-directive structured-block  */
4015
4016 static void
4017 c_parser_statement (c_parser *parser)
4018 {
4019   while (c_parser_next_token_is_keyword (parser, RID_CASE)
4020          || c_parser_next_token_is_keyword (parser, RID_DEFAULT)
4021          || (c_parser_next_token_is (parser, CPP_NAME)
4022              && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
4023     c_parser_label (parser);
4024   c_parser_statement_after_labels (parser);
4025 }
4026
4027 /* Parse a statement, other than a labeled statement.  */
4028
4029 static void
4030 c_parser_statement_after_labels (c_parser *parser)
4031 {
4032   location_t loc = c_parser_peek_token (parser)->location;
4033   tree stmt = NULL_TREE;
4034   bool in_if_block = parser->in_if_block;
4035   parser->in_if_block = false;
4036   switch (c_parser_peek_token (parser)->type)
4037     {
4038     case CPP_OPEN_BRACE:
4039       add_stmt (c_parser_compound_statement (parser));
4040       break;
4041     case CPP_KEYWORD:
4042       switch (c_parser_peek_token (parser)->keyword)
4043         {
4044         case RID_IF:
4045           c_parser_if_statement (parser);
4046           break;
4047         case RID_SWITCH:
4048           c_parser_switch_statement (parser);
4049           break;
4050         case RID_WHILE:
4051           c_parser_while_statement (parser);
4052           break;
4053         case RID_DO:
4054           c_parser_do_statement (parser);
4055           break;
4056         case RID_FOR:
4057           c_parser_for_statement (parser);
4058           break;
4059         case RID_GOTO:
4060           c_parser_consume_token (parser);
4061           if (c_parser_next_token_is (parser, CPP_NAME))
4062             {
4063               stmt = c_finish_goto_label (loc,
4064                                           c_parser_peek_token (parser)->value);
4065               c_parser_consume_token (parser);
4066             }
4067           else if (c_parser_next_token_is (parser, CPP_MULT))
4068             {
4069               c_parser_consume_token (parser);
4070               stmt = c_finish_goto_ptr (loc,
4071                                         c_parser_expression (parser).value);
4072             }
4073           else
4074             c_parser_error (parser, "expected identifier or %<*%>");
4075           goto expect_semicolon;
4076         case RID_CONTINUE:
4077           c_parser_consume_token (parser);
4078           stmt = c_finish_bc_stmt (loc, &c_cont_label, false);
4079           goto expect_semicolon;
4080         case RID_BREAK:
4081           c_parser_consume_token (parser);
4082           stmt = c_finish_bc_stmt (loc, &c_break_label, true);
4083           goto expect_semicolon;
4084         case RID_RETURN:
4085           c_parser_consume_token (parser);
4086           if (c_parser_next_token_is (parser, CPP_SEMICOLON))
4087             {
4088               stmt = c_finish_return (loc, NULL_TREE, NULL_TREE);
4089               c_parser_consume_token (parser);
4090             }
4091           else
4092             {
4093               struct c_expr expr = c_parser_expression_conv (parser);
4094               mark_exp_read (expr.value);
4095               stmt = c_finish_return (loc, expr.value, expr.original_type);
4096               goto expect_semicolon;
4097             }
4098           break;
4099         case RID_ASM:
4100           stmt = c_parser_asm_statement (parser);
4101           break;
4102         case RID_AT_THROW:
4103           gcc_assert (c_dialect_objc ());
4104           c_parser_consume_token (parser);
4105           if (c_parser_next_token_is (parser, CPP_SEMICOLON))
4106             {
4107               stmt = objc_build_throw_stmt (loc, NULL_TREE);
4108               c_parser_consume_token (parser);
4109             }
4110           else
4111             {
4112               tree expr = c_parser_expression (parser).value;
4113               expr = c_fully_fold (expr, false, NULL);
4114               stmt = objc_build_throw_stmt (loc, expr);
4115               goto expect_semicolon;
4116             }
4117           break;
4118         case RID_AT_TRY:
4119           gcc_assert (c_dialect_objc ());
4120           c_parser_objc_try_catch_statement (parser);
4121           break;
4122         case RID_AT_SYNCHRONIZED:
4123           gcc_assert (c_dialect_objc ());
4124           c_parser_objc_synchronized_statement (parser);
4125           break;
4126         default:
4127           goto expr_stmt;
4128         }
4129       break;
4130     case CPP_SEMICOLON:
4131       c_parser_consume_token (parser);
4132       break;
4133     case CPP_CLOSE_PAREN:
4134     case CPP_CLOSE_SQUARE:
4135       /* Avoid infinite loop in error recovery:
4136          c_parser_skip_until_found stops at a closing nesting
4137          delimiter without consuming it, but here we need to consume
4138          it to proceed further.  */
4139       c_parser_error (parser, "expected statement");
4140       c_parser_consume_token (parser);
4141       break;
4142     case CPP_PRAGMA:
4143       c_parser_pragma (parser, pragma_stmt);
4144       break;
4145     default:
4146     expr_stmt:
4147       stmt = c_finish_expr_stmt (loc, c_parser_expression_conv (parser).value);
4148     expect_semicolon:
4149       c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
4150       break;
4151     }
4152   /* Two cases cannot and do not have line numbers associated: If stmt
4153      is degenerate, such as "2;", then stmt is an INTEGER_CST, which
4154      cannot hold line numbers.  But that's OK because the statement
4155      will either be changed to a MODIFY_EXPR during gimplification of
4156      the statement expr, or discarded.  If stmt was compound, but
4157      without new variables, we will have skipped the creation of a
4158      BIND and will have a bare STATEMENT_LIST.  But that's OK because
4159      (recursively) all of the component statements should already have
4160      line numbers assigned.  ??? Can we discard no-op statements
4161      earlier?  */
4162   if (CAN_HAVE_LOCATION_P (stmt)
4163       && EXPR_LOCATION (stmt) == UNKNOWN_LOCATION)
4164     SET_EXPR_LOCATION (stmt, loc);
4165
4166   parser->in_if_block = in_if_block;
4167 }
4168
4169 /* Parse the condition from an if, do, while or for statements.  */
4170
4171 static tree
4172 c_parser_condition (c_parser *parser)
4173 {
4174   location_t loc = c_parser_peek_token (parser)->location;
4175   tree cond;
4176   cond = c_parser_expression_conv (parser).value;
4177   cond = c_objc_common_truthvalue_conversion (loc, cond);
4178   cond = c_fully_fold (cond, false, NULL);
4179   if (warn_sequence_point)
4180     verify_sequence_points (cond);
4181   return cond;
4182 }
4183
4184 /* Parse a parenthesized condition from an if, do or while statement.
4185
4186    condition:
4187      ( expression )
4188 */
4189 static tree
4190 c_parser_paren_condition (c_parser *parser)
4191 {
4192   tree cond;
4193   if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
4194     return error_mark_node;
4195   cond = c_parser_condition (parser);
4196   c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
4197   return cond;
4198 }
4199
4200 /* Parse a statement which is a block in C99.  */
4201
4202 static tree
4203 c_parser_c99_block_statement (c_parser *parser)
4204 {
4205   tree block = c_begin_compound_stmt (flag_isoc99);
4206   location_t loc = c_parser_peek_token (parser)->location;
4207   c_parser_statement (parser);
4208   return c_end_compound_stmt (loc, block, flag_isoc99);
4209 }
4210
4211 /* Parse the body of an if statement.  This is just parsing a
4212    statement but (a) it is a block in C99, (b) we track whether the
4213    body is an if statement for the sake of -Wparentheses warnings, (c)
4214    we handle an empty body specially for the sake of -Wempty-body
4215    warnings, and (d) we call parser_compound_statement directly
4216    because c_parser_statement_after_labels resets
4217    parser->in_if_block.  */
4218
4219 static tree
4220 c_parser_if_body (c_parser *parser, bool *if_p)
4221 {
4222   tree block = c_begin_compound_stmt (flag_isoc99);
4223   location_t body_loc = c_parser_peek_token (parser)->location;
4224   while (c_parser_next_token_is_keyword (parser, RID_CASE)
4225          || c_parser_next_token_is_keyword (parser, RID_DEFAULT)
4226          || (c_parser_next_token_is (parser, CPP_NAME)
4227              && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
4228     c_parser_label (parser);
4229   *if_p = c_parser_next_token_is_keyword (parser, RID_IF);
4230   if (c_parser_next_token_is (parser, CPP_SEMICOLON))
4231     {
4232       location_t loc = c_parser_peek_token (parser)->location;
4233       add_stmt (build_empty_stmt (loc));
4234       c_parser_consume_token (parser);
4235       if (!c_parser_next_token_is_keyword (parser, RID_ELSE))
4236         warning_at (loc, OPT_Wempty_body,
4237                     "suggest braces around empty body in an %<if%> statement");
4238     }
4239   else if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
4240     add_stmt (c_parser_compound_statement (parser));
4241   else
4242     c_parser_statement_after_labels (parser);
4243   return c_end_compound_stmt (body_loc, block, flag_isoc99);
4244 }
4245
4246 /* Parse the else body of an if statement.  This is just parsing a
4247    statement but (a) it is a block in C99, (b) we handle an empty body
4248    specially for the sake of -Wempty-body warnings.  */
4249
4250 static tree
4251 c_parser_else_body (c_parser *parser)
4252 {
4253   location_t else_loc = c_parser_peek_token (parser)->location;
4254   tree block = c_begin_compound_stmt (flag_isoc99);
4255   while (c_parser_next_token_is_keyword (parser, RID_CASE)
4256          || c_parser_next_token_is_keyword (parser, RID_DEFAULT)
4257          || (c_parser_next_token_is (parser, CPP_NAME)
4258              && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
4259     c_parser_label (parser);
4260   if (c_parser_next_token_is (parser, CPP_SEMICOLON))
4261     {
4262       location_t loc = c_parser_peek_token (parser)->location;
4263       warning_at (loc,
4264                   OPT_Wempty_body,
4265                  "suggest braces around empty body in an %<else%> statement");
4266       add_stmt (build_empty_stmt (loc));
4267       c_parser_consume_token (parser);
4268     }
4269   else
4270     c_parser_statement_after_labels (parser);
4271   return c_end_compound_stmt (else_loc, block, flag_isoc99);
4272 }
4273
4274 /* Parse an if statement (C90 6.6.4, C99 6.8.4).
4275
4276    if-statement:
4277      if ( expression ) statement
4278      if ( expression ) statement else statement
4279 */
4280
4281 static void
4282 c_parser_if_statement (c_parser *parser)
4283 {
4284   tree block;
4285   location_t loc;
4286   tree cond;
4287   bool first_if = false;
4288   tree first_body, second_body;
4289   bool in_if_block;
4290
4291   gcc_assert (c_parser_next_token_is_keyword (parser, RID_IF));
4292   c_parser_consume_token (parser);
4293   block = c_begin_compound_stmt (flag_isoc99);
4294   loc = c_parser_peek_token (parser)->location;
4295   cond = c_parser_paren_condition (parser);
4296   in_if_block = parser->in_if_block;
4297   parser->in_if_block = true;
4298   first_body = c_parser_if_body (parser, &first_if);
4299   parser->in_if_block = in_if_block;
4300   if (c_parser_next_token_is_keyword (parser, RID_ELSE))
4301     {
4302       c_parser_consume_token (parser);
4303       second_body = c_parser_else_body (parser);
4304     }
4305   else
4306     second_body = NULL_TREE;
4307   c_finish_if_stmt (loc, cond, first_body, second_body, first_if);
4308   add_stmt (c_end_compound_stmt (loc, block, flag_isoc99));
4309 }
4310
4311 /* Parse a switch statement (C90 6.6.4, C99 6.8.4).
4312
4313    switch-statement:
4314      switch (expression) statement
4315 */
4316
4317 static void
4318 c_parser_switch_statement (c_parser *parser)
4319 {
4320   tree block, expr, body, save_break;
4321   location_t switch_loc = c_parser_peek_token (parser)->location;
4322   location_t switch_cond_loc;
4323   gcc_assert (c_parser_next_token_is_keyword (parser, RID_SWITCH));
4324   c_parser_consume_token (parser);
4325   block = c_begin_compound_stmt (flag_isoc99);
4326   if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
4327     {
4328       switch_cond_loc = c_parser_peek_token (parser)->location;
4329       expr = c_parser_expression (parser).value;
4330       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
4331     }
4332   else
4333     {
4334       switch_cond_loc = UNKNOWN_LOCATION;
4335       expr = error_mark_node;
4336     }
4337   c_start_case (switch_loc, switch_cond_loc, expr);
4338   save_break = c_break_label;
4339   c_break_label = NULL_TREE;
4340   body = c_parser_c99_block_statement (parser);
4341   c_finish_case (body);
4342   if (c_break_label)
4343     {
4344       location_t here = c_parser_peek_token (parser)->location;
4345       tree t = build1 (LABEL_EXPR, void_type_node, c_break_label);
4346       SET_EXPR_LOCATION (t, here);
4347       add_stmt (t);
4348     }
4349   c_break_label = save_break;
4350   add_stmt (c_end_compound_stmt (switch_loc, block, flag_isoc99));
4351 }
4352
4353 /* Parse a while statement (C90 6.6.5, C99 6.8.5).
4354
4355    while-statement:
4356       while (expression) statement
4357 */
4358
4359 static void
4360 c_parser_while_statement (c_parser *parser)
4361 {
4362   tree block, cond, body, save_break, save_cont;
4363   location_t loc;
4364   gcc_assert (c_parser_next_token_is_keyword (parser, RID_WHILE));
4365   c_parser_consume_token (parser);
4366   block = c_begin_compound_stmt (flag_isoc99);
4367   loc = c_parser_peek_token (parser)->location;
4368   cond = c_parser_paren_condition (parser);
4369   save_break = c_break_label;
4370   c_break_label = NULL_TREE;
4371   save_cont = c_cont_label;
4372   c_cont_label = NULL_TREE;
4373   body = c_parser_c99_block_statement (parser);
4374   c_finish_loop (loc, cond, NULL, body, c_break_label, c_cont_label, true);
4375   add_stmt (c_end_compound_stmt (loc, block, flag_isoc99));
4376   c_break_label = save_break;
4377   c_cont_label = save_cont;
4378 }
4379
4380 /* Parse a do statement (C90 6.6.5, C99 6.8.5).
4381
4382    do-statement:
4383      do statement while ( expression ) ;
4384 */
4385
4386 static void
4387 c_parser_do_statement (c_parser *parser)
4388 {
4389   tree block, cond, body, save_break, save_cont, new_break, new_cont;
4390   location_t loc;
4391   gcc_assert (c_parser_next_token_is_keyword (parser, RID_DO));
4392   c_parser_consume_token (parser);
4393   if (c_parser_next_token_is (parser, CPP_SEMICOLON))
4394     warning_at (c_parser_peek_token (parser)->location,
4395                 OPT_Wempty_body,
4396                 "suggest braces around empty body in %<do%> statement");
4397   block = c_begin_compound_stmt (flag_isoc99);
4398   loc = c_parser_peek_token (parser)->location;
4399   save_break = c_break_label;
4400   c_break_label = NULL_TREE;
4401   save_cont = c_cont_label;
4402   c_cont_label = NULL_TREE;
4403   body = c_parser_c99_block_statement (parser);
4404   c_parser_require_keyword (parser, RID_WHILE, "expected %<while%>");
4405   new_break = c_break_label;
4406   c_break_label = save_break;
4407   new_cont = c_cont_label;
4408   c_cont_label = save_cont;
4409   cond = c_parser_paren_condition (parser);
4410   if (!c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>"))
4411     c_parser_skip_to_end_of_block_or_statement (parser);
4412   c_finish_loop (loc, cond, NULL, body, new_break, new_cont, false);
4413   add_stmt (c_end_compound_stmt (loc, block, flag_isoc99));
4414 }
4415
4416 /* Parse a for statement (C90 6.6.5, C99 6.8.5).
4417
4418    for-statement:
4419      for ( expression[opt] ; expression[opt] ; expression[opt] ) statement
4420      for ( nested-declaration expression[opt] ; expression[opt] ) statement
4421
4422    The form with a declaration is new in C99.
4423
4424    ??? In accordance with the old parser, the declaration may be a
4425    nested function, which is then rejected in check_for_loop_decls,
4426    but does it make any sense for this to be included in the grammar?
4427    Note in particular that the nested function does not include a
4428    trailing ';', whereas the "declaration" production includes one.
4429    Also, can we reject bad declarations earlier and cheaper than
4430    check_for_loop_decls?  */
4431
4432 static void
4433 c_parser_for_statement (c_parser *parser)
4434 {
4435   tree block, cond, incr, save_break, save_cont, body;
4436   location_t loc = c_parser_peek_token (parser)->location;
4437   location_t for_loc = c_parser_peek_token (parser)->location;
4438   gcc_assert (c_parser_next_token_is_keyword (parser, RID_FOR));
4439   c_parser_consume_token (parser);
4440   block = c_begin_compound_stmt (flag_isoc99);
4441   if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
4442     {
4443       /* Parse the initialization declaration or expression.  */
4444       if (c_parser_next_token_is (parser, CPP_SEMICOLON))
4445         {
4446           c_parser_consume_token (parser);
4447           c_finish_expr_stmt (loc, NULL_TREE);
4448         }
4449       else if (c_parser_next_token_starts_declaration (parser))
4450         {
4451           c_parser_declaration_or_fndef (parser, true, true, true, true, true);
4452           check_for_loop_decls (for_loc);
4453         }
4454       else if (c_parser_next_token_is_keyword (parser, RID_EXTENSION))
4455         {
4456           /* __extension__ can start a declaration, but is also an
4457              unary operator that can start an expression.  Consume all
4458              but the last of a possible series of __extension__ to
4459              determine which.  */
4460           while (c_parser_peek_2nd_token (parser)->type == CPP_KEYWORD
4461                  && (c_parser_peek_2nd_token (parser)->keyword
4462                      == RID_EXTENSION))
4463             c_parser_consume_token (parser);
4464           if (c_token_starts_declaration (c_parser_peek_2nd_token (parser)))
4465             {
4466               int ext;
4467               ext = disable_extension_diagnostics ();
4468               c_parser_consume_token (parser);
4469               c_parser_declaration_or_fndef (parser, true, true, true, true,
4470                                              true);
4471               restore_extension_diagnostics (ext);
4472               check_for_loop_decls (for_loc);
4473             }
4474           else
4475             goto init_expr;
4476         }
4477       else
4478         {
4479         init_expr:
4480           c_finish_expr_stmt (loc, c_parser_expression (parser).value);
4481           c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
4482         }
4483       /* Parse the loop condition.  */
4484       if (c_parser_next_token_is (parser, CPP_SEMICOLON))
4485         {
4486           c_parser_consume_token (parser);
4487           cond = NULL_TREE;
4488         }
4489       else
4490         {
4491           cond = c_parser_condition (parser);
4492           c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
4493         }
4494       /* Parse the increment expression.  */
4495       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
4496         incr = c_process_expr_stmt (loc, NULL_TREE);
4497       else
4498         incr = c_process_expr_stmt (loc, c_parser_expression (parser).value);
4499       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
4500     }
4501   else
4502     {
4503       cond = error_mark_node;
4504       incr = error_mark_node;
4505     }
4506   save_break = c_break_label;
4507   c_break_label = NULL_TREE;
4508   save_cont = c_cont_label;
4509   c_cont_label = NULL_TREE;
4510   body = c_parser_c99_block_statement (parser);
4511   c_finish_loop (loc, cond, incr, body, c_break_label, c_cont_label, true);
4512   add_stmt (c_end_compound_stmt (loc, block, flag_isoc99));
4513   c_break_label = save_break;
4514   c_cont_label = save_cont;
4515 }
4516
4517 /* Parse an asm statement, a GNU extension.  This is a full-blown asm
4518    statement with inputs, outputs, clobbers, and volatile tag
4519    allowed.
4520
4521    asm-statement:
4522      asm type-qualifier[opt] ( asm-argument ) ;
4523      asm type-qualifier[opt] goto ( asm-goto-argument ) ;
4524
4525    asm-argument:
4526      asm-string-literal
4527      asm-string-literal : asm-operands[opt]
4528      asm-string-literal : asm-operands[opt] : asm-operands[opt]
4529      asm-string-literal : asm-operands[opt] : asm-operands[opt] : asm-clobbers[opt]
4530
4531    asm-goto-argument:
4532      asm-string-literal : : asm-operands[opt] : asm-clobbers[opt] \
4533        : asm-goto-operands
4534
4535    Qualifiers other than volatile are accepted in the syntax but
4536    warned for.  */
4537
4538 static tree
4539 c_parser_asm_statement (c_parser *parser)
4540 {
4541   tree quals, str, outputs, inputs, clobbers, labels, ret;
4542   bool simple, is_goto;
4543   location_t asm_loc = c_parser_peek_token (parser)->location;
4544   int section, nsections;
4545
4546   gcc_assert (c_parser_next_token_is_keyword (parser, RID_ASM));
4547   c_parser_consume_token (parser);
4548   if (c_parser_next_token_is_keyword (parser, RID_VOLATILE))
4549     {
4550       quals = c_parser_peek_token (parser)->value;
4551       c_parser_consume_token (parser);
4552     }
4553   else if (c_parser_next_token_is_keyword (parser, RID_CONST)
4554            || c_parser_next_token_is_keyword (parser, RID_RESTRICT))
4555     {
4556       warning_at (c_parser_peek_token (parser)->location,
4557                   0,
4558                   "%E qualifier ignored on asm",
4559                   c_parser_peek_token (parser)->value);
4560       quals = NULL_TREE;
4561       c_parser_consume_token (parser);
4562     }
4563   else
4564     quals = NULL_TREE;
4565
4566   is_goto = false;
4567   if (c_parser_next_token_is_keyword (parser, RID_GOTO))
4568     {
4569       c_parser_consume_token (parser);
4570       is_goto = true;
4571     }
4572
4573   /* ??? Follow the C++ parser rather than using the
4574      lex_untranslated_string kludge.  */
4575   parser->lex_untranslated_string = true;
4576   ret = NULL;
4577
4578   if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
4579     goto error;
4580
4581   str = c_parser_asm_string_literal (parser);
4582   if (str == NULL_TREE)
4583     goto error_close_paren;
4584
4585   simple = true;
4586   outputs = NULL_TREE;
4587   inputs = NULL_TREE;
4588   clobbers = NULL_TREE;
4589   labels = NULL_TREE;
4590
4591   if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN) && !is_goto)
4592     goto done_asm;
4593
4594   /* Parse each colon-delimited section of operands.  */
4595   nsections = 3 + is_goto;
4596   for (section = 0; section < nsections; ++section)
4597     {
4598       if (!c_parser_require (parser, CPP_COLON,
4599                              is_goto
4600                              ? "expected %<:%>"
4601                              : "expected %<:%> or %<)%>"))
4602         goto error_close_paren;
4603
4604       /* Once past any colon, we're no longer a simple asm.  */
4605       simple = false;
4606
4607       if ((!c_parser_next_token_is (parser, CPP_COLON)
4608            && !c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
4609           || section == 3)
4610         switch (section)
4611           {
4612           case 0:
4613             /* For asm goto, we don't allow output operands, but reserve
4614                the slot for a future extension that does allow them.  */
4615             if (!is_goto)
4616               outputs = c_parser_asm_operands (parser, false);
4617             break;
4618           case 1:
4619             inputs = c_parser_asm_operands (parser, true);
4620             break;
4621           case 2:
4622             clobbers = c_parser_asm_clobbers (parser);
4623             break;
4624           case 3:
4625             labels = c_parser_asm_goto_operands (parser);
4626             break;
4627           default:
4628             gcc_unreachable ();
4629           }
4630
4631       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN) && !is_goto)
4632         goto done_asm;
4633     }
4634
4635  done_asm:
4636   if (!c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
4637     {
4638       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
4639       goto error;
4640     }
4641
4642   if (!c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>"))
4643     c_parser_skip_to_end_of_block_or_statement (parser);
4644
4645   ret = build_asm_stmt (quals, build_asm_expr (asm_loc, str, outputs, inputs,
4646                                                clobbers, labels, simple));
4647
4648  error:
4649   parser->lex_untranslated_string = false;
4650   return ret;
4651
4652  error_close_paren:
4653   c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
4654   goto error;
4655 }
4656
4657 /* Parse asm operands, a GNU extension.  If CONVERT_P (for inputs but
4658    not outputs), apply the default conversion of functions and arrays
4659    to pointers.
4660
4661    asm-operands:
4662      asm-operand
4663      asm-operands , asm-operand
4664
4665    asm-operand:
4666      asm-string-literal ( expression )
4667      [ identifier ] asm-string-literal ( expression )
4668 */
4669
4670 static tree
4671 c_parser_asm_operands (c_parser *parser, bool convert_p)
4672 {
4673   tree list = NULL_TREE;
4674   location_t loc;
4675   while (true)
4676     {
4677       tree name, str;
4678       struct c_expr expr;
4679       if (c_parser_next_token_is (parser, CPP_OPEN_SQUARE))
4680         {
4681           c_parser_consume_token (parser);
4682           if (c_parser_next_token_is (parser, CPP_NAME))
4683             {
4684               tree id = c_parser_peek_token (parser)->value;
4685               c_parser_consume_token (parser);
4686               name = build_string (IDENTIFIER_LENGTH (id),
4687                                    IDENTIFIER_POINTER (id));
4688             }
4689           else
4690             {
4691               c_parser_error (parser, "expected identifier");
4692               c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, NULL);
4693               return NULL_TREE;
4694             }
4695           c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
4696                                      "expected %<]%>");
4697         }
4698       else
4699         name = NULL_TREE;
4700       str = c_parser_asm_string_literal (parser);
4701       if (str == NULL_TREE)
4702         return NULL_TREE;
4703       parser->lex_untranslated_string = false;
4704       if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
4705         {
4706           parser->lex_untranslated_string = true;
4707           return NULL_TREE;
4708         }
4709       loc = c_parser_peek_token (parser)->location;
4710       expr = c_parser_expression (parser);
4711       mark_exp_read (expr.value);
4712       if (convert_p)
4713         expr = default_function_array_conversion (loc, expr);
4714       expr.value = c_fully_fold (expr.value, false, NULL);
4715       parser->lex_untranslated_string = true;
4716       if (!c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
4717         {
4718           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
4719           return NULL_TREE;
4720         }
4721       list = chainon (list, build_tree_list (build_tree_list (name, str),
4722                                              expr.value));
4723       if (c_parser_next_token_is (parser, CPP_COMMA))
4724         c_parser_consume_token (parser);
4725       else
4726         break;
4727     }
4728   return list;
4729 }
4730
4731 /* Parse asm clobbers, a GNU extension.
4732
4733    asm-clobbers:
4734      asm-string-literal
4735      asm-clobbers , asm-string-literal
4736 */
4737
4738 static tree
4739 c_parser_asm_clobbers (c_parser *parser)
4740 {
4741   tree list = NULL_TREE;
4742   while (true)
4743     {
4744       tree str = c_parser_asm_string_literal (parser);
4745       if (str)
4746         list = tree_cons (NULL_TREE, str, list);
4747       else
4748         return NULL_TREE;
4749       if (c_parser_next_token_is (parser, CPP_COMMA))
4750         c_parser_consume_token (parser);
4751       else
4752         break;
4753     }
4754   return list;
4755 }
4756
4757 /* Parse asm goto labels, a GNU extension.
4758
4759    asm-goto-operands:
4760      identifier
4761      asm-goto-operands , identifier
4762 */
4763
4764 static tree
4765 c_parser_asm_goto_operands (c_parser *parser)
4766 {
4767   tree list = NULL_TREE;
4768   while (true)
4769     {
4770       tree name, label;
4771
4772       if (c_parser_next_token_is (parser, CPP_NAME))
4773         {
4774           c_token *tok = c_parser_peek_token (parser);
4775           name = tok->value;
4776           label = lookup_label_for_goto (tok->location, name);
4777           c_parser_consume_token (parser);
4778           TREE_USED (label) = 1;
4779         }
4780       else
4781         {
4782           c_parser_error (parser, "expected identifier");
4783           return NULL_TREE;
4784         }
4785
4786       name = build_string (IDENTIFIER_LENGTH (name),
4787                            IDENTIFIER_POINTER (name));
4788       list = tree_cons (name, label, list);
4789       if (c_parser_next_token_is (parser, CPP_COMMA))
4790         c_parser_consume_token (parser);
4791       else
4792         return nreverse (list);
4793     }
4794 }
4795
4796 /* Parse an expression other than a compound expression; that is, an
4797    assignment expression (C90 6.3.16, C99 6.5.16).  If AFTER is not
4798    NULL then it is an Objective-C message expression which is the
4799    primary-expression starting the expression as an initializer.
4800
4801    assignment-expression:
4802      conditional-expression
4803      unary-expression assignment-operator assignment-expression
4804
4805    assignment-operator: one of
4806      = *= /= %= += -= <<= >>= &= ^= |=
4807
4808    In GNU C we accept any conditional expression on the LHS and
4809    diagnose the invalid lvalue rather than producing a syntax
4810    error.  */
4811
4812 static struct c_expr
4813 c_parser_expr_no_commas (c_parser *parser, struct c_expr *after)
4814 {
4815   struct c_expr lhs, rhs, ret;
4816   enum tree_code code;
4817   location_t op_location, exp_location;
4818   gcc_assert (!after || c_dialect_objc ());
4819   lhs = c_parser_conditional_expression (parser, after);
4820   op_location = c_parser_peek_token (parser)->location;
4821   switch (c_parser_peek_token (parser)->type)
4822     {
4823     case CPP_EQ:
4824       code = NOP_EXPR;
4825       break;
4826     case CPP_MULT_EQ:
4827       code = MULT_EXPR;
4828       break;
4829     case CPP_DIV_EQ:
4830       code = TRUNC_DIV_EXPR;
4831       break;
4832     case CPP_MOD_EQ:
4833       code = TRUNC_MOD_EXPR;
4834       break;
4835     case CPP_PLUS_EQ:
4836       code = PLUS_EXPR;
4837       break;
4838     case CPP_MINUS_EQ:
4839       code = MINUS_EXPR;
4840       break;
4841     case CPP_LSHIFT_EQ:
4842       code = LSHIFT_EXPR;
4843       break;
4844     case CPP_RSHIFT_EQ:
4845       code = RSHIFT_EXPR;
4846       break;
4847     case CPP_AND_EQ:
4848       code = BIT_AND_EXPR;
4849       break;
4850     case CPP_XOR_EQ:
4851       code = BIT_XOR_EXPR;
4852       break;
4853     case CPP_OR_EQ:
4854       code = BIT_IOR_EXPR;
4855       break;
4856     default:
4857       return lhs;
4858     }
4859   c_parser_consume_token (parser);
4860   exp_location = c_parser_peek_token (parser)->location;
4861   rhs = c_parser_expr_no_commas (parser, NULL);
4862   rhs = default_function_array_read_conversion (exp_location, rhs);
4863   ret.value = build_modify_expr (op_location, lhs.value, lhs.original_type,
4864                                  code, exp_location, rhs.value,
4865                                  rhs.original_type);
4866   if (code == NOP_EXPR)
4867     ret.original_code = MODIFY_EXPR;
4868   else
4869     {
4870       TREE_NO_WARNING (ret.value) = 1;
4871       ret.original_code = ERROR_MARK;
4872     }
4873   ret.original_type = NULL;
4874   return ret;
4875 }
4876
4877 /* Parse a conditional expression (C90 6.3.15, C99 6.5.15).  If AFTER
4878    is not NULL then it is an Objective-C message expression which is
4879    the primary-expression starting the expression as an initializer.
4880
4881    conditional-expression:
4882      logical-OR-expression
4883      logical-OR-expression ? expression : conditional-expression
4884
4885    GNU extensions:
4886
4887    conditional-expression:
4888      logical-OR-expression ? : conditional-expression
4889 */
4890
4891 static struct c_expr
4892 c_parser_conditional_expression (c_parser *parser, struct c_expr *after)
4893 {
4894   struct c_expr cond, exp1, exp2, ret;
4895   location_t cond_loc, colon_loc, middle_loc;
4896
4897   gcc_assert (!after || c_dialect_objc ());
4898
4899   cond = c_parser_binary_expression (parser, after);
4900
4901   if (c_parser_next_token_is_not (parser, CPP_QUERY))
4902     return cond;
4903   cond_loc = c_parser_peek_token (parser)->location;
4904   cond = default_function_array_read_conversion (cond_loc, cond);
4905   c_parser_consume_token (parser);
4906   if (c_parser_next_token_is (parser, CPP_COLON))
4907     {
4908       tree eptype = NULL_TREE;
4909
4910       middle_loc = c_parser_peek_token (parser)->location;
4911       pedwarn (middle_loc, OPT_pedantic,
4912                "ISO C forbids omitting the middle term of a ?: expression");
4913       warn_for_omitted_condop (middle_loc, cond.value);
4914       if (TREE_CODE (cond.value) == EXCESS_PRECISION_EXPR)
4915         {
4916           eptype = TREE_TYPE (cond.value);
4917           cond.value = TREE_OPERAND (cond.value, 0);
4918         }
4919       /* Make sure first operand is calculated only once.  */
4920       exp1.value = c_save_expr (default_conversion (cond.value));
4921       if (eptype)
4922         exp1.value = build1 (EXCESS_PRECISION_EXPR, eptype, exp1.value);
4923       exp1.original_type = NULL;
4924       cond.value = c_objc_common_truthvalue_conversion (cond_loc, exp1.value);
4925       c_inhibit_evaluation_warnings += cond.value == truthvalue_true_node;
4926     }
4927   else
4928     {
4929       cond.value
4930         = c_objc_common_truthvalue_conversion
4931         (cond_loc, default_conversion (cond.value));
4932       c_inhibit_evaluation_warnings += cond.value == truthvalue_false_node;
4933       exp1 = c_parser_expression_conv (parser);
4934       mark_exp_read (exp1.value);
4935       c_inhibit_evaluation_warnings +=
4936         ((cond.value == truthvalue_true_node)
4937          - (cond.value == truthvalue_false_node));
4938     }
4939
4940   colon_loc = c_parser_peek_token (parser)->location;
4941   if (!c_parser_require (parser, CPP_COLON, "expected %<:%>"))
4942     {
4943       c_inhibit_evaluation_warnings -= cond.value == truthvalue_true_node;
4944       ret.value = error_mark_node;
4945       ret.original_code = ERROR_MARK;
4946       ret.original_type = NULL;
4947       return ret;
4948     }
4949   {
4950     location_t exp2_loc = c_parser_peek_token (parser)->location;
4951     exp2 = c_parser_conditional_expression (parser, NULL);
4952     exp2 = default_function_array_read_conversion (exp2_loc, exp2);
4953   }
4954   c_inhibit_evaluation_warnings -= cond.value == truthvalue_true_node;
4955   ret.value = build_conditional_expr (colon_loc, cond.value,
4956                                       cond.original_code == C_MAYBE_CONST_EXPR,
4957                                       exp1.value, exp1.original_type,
4958                                       exp2.value, exp2.original_type);
4959   ret.original_code = ERROR_MARK;
4960   if (exp1.value == error_mark_node || exp2.value == error_mark_node)
4961     ret.original_type = NULL;
4962   else
4963     {
4964       tree t1, t2;
4965
4966       /* If both sides are enum type, the default conversion will have
4967          made the type of the result be an integer type.  We want to
4968          remember the enum types we started with.  */
4969       t1 = exp1.original_type ? exp1.original_type : TREE_TYPE (exp1.value);
4970       t2 = exp2.original_type ? exp2.original_type : TREE_TYPE (exp2.value);
4971       ret.original_type = ((t1 != error_mark_node
4972                             && t2 != error_mark_node
4973                             && (TYPE_MAIN_VARIANT (t1)
4974                                 == TYPE_MAIN_VARIANT (t2)))
4975                            ? t1
4976                            : NULL);
4977     }
4978   return ret;
4979 }
4980
4981 /* Parse a binary expression; that is, a logical-OR-expression (C90
4982    6.3.5-6.3.14, C99 6.5.5-6.5.14).  If AFTER is not NULL then it is
4983    an Objective-C message expression which is the primary-expression
4984    starting the expression as an initializer.
4985
4986    multiplicative-expression:
4987      cast-expression
4988      multiplicative-expression * cast-expression
4989      multiplicative-expression / cast-expression
4990      multiplicative-expression % cast-expression
4991
4992    additive-expression:
4993      multiplicative-expression
4994      additive-expression + multiplicative-expression
4995      additive-expression - multiplicative-expression
4996
4997    shift-expression:
4998      additive-expression
4999      shift-expression << additive-expression
5000      shift-expression >> additive-expression
5001
5002    relational-expression:
5003      shift-expression
5004      relational-expression < shift-expression
5005      relational-expression > shift-expression
5006      relational-expression <= shift-expression
5007      relational-expression >= shift-expression
5008
5009    equality-expression:
5010      relational-expression
5011      equality-expression == relational-expression
5012      equality-expression != relational-expression
5013
5014    AND-expression:
5015      equality-expression
5016      AND-expression & equality-expression
5017
5018    exclusive-OR-expression:
5019      AND-expression
5020      exclusive-OR-expression ^ AND-expression
5021
5022    inclusive-OR-expression:
5023      exclusive-OR-expression
5024      inclusive-OR-expression | exclusive-OR-expression
5025
5026    logical-AND-expression:
5027      inclusive-OR-expression
5028      logical-AND-expression && inclusive-OR-expression
5029
5030    logical-OR-expression:
5031      logical-AND-expression
5032      logical-OR-expression || logical-AND-expression
5033 */
5034
5035 static struct c_expr
5036 c_parser_binary_expression (c_parser *parser, struct c_expr *after)
5037 {
5038   /* A binary expression is parsed using operator-precedence parsing,
5039      with the operands being cast expressions.  All the binary
5040      operators are left-associative.  Thus a binary expression is of
5041      form:
5042
5043      E0 op1 E1 op2 E2 ...
5044
5045      which we represent on a stack.  On the stack, the precedence
5046      levels are strictly increasing.  When a new operator is
5047      encountered of higher precedence than that at the top of the
5048      stack, it is pushed; its LHS is the top expression, and its RHS
5049      is everything parsed until it is popped.  When a new operator is
5050      encountered with precedence less than or equal to that at the top
5051      of the stack, triples E[i-1] op[i] E[i] are popped and replaced
5052      by the result of the operation until the operator at the top of
5053      the stack has lower precedence than the new operator or there is
5054      only one element on the stack; then the top expression is the LHS
5055      of the new operator.  In the case of logical AND and OR
5056      expressions, we also need to adjust c_inhibit_evaluation_warnings
5057      as appropriate when the operators are pushed and popped.  */
5058
5059   /* The precedence levels, where 0 is a dummy lowest level used for
5060      the bottom of the stack.  */
5061   enum prec {
5062     PREC_NONE,
5063     PREC_LOGOR,
5064     PREC_LOGAND,
5065     PREC_BITOR,
5066     PREC_BITXOR,
5067     PREC_BITAND,
5068     PREC_EQ,
5069     PREC_REL,
5070     PREC_SHIFT,
5071     PREC_ADD,
5072     PREC_MULT,
5073     NUM_PRECS
5074   };
5075   struct {
5076     /* The expression at this stack level.  */
5077     struct c_expr expr;
5078     /* The precedence of the operator on its left, PREC_NONE at the
5079        bottom of the stack.  */
5080     enum prec prec;
5081     /* The operation on its left.  */
5082     enum tree_code op;
5083     /* The source location of this operation.  */
5084     location_t loc;
5085   } stack[NUM_PRECS];
5086   int sp;
5087   /* Location of the binary operator.  */
5088   location_t binary_loc = UNKNOWN_LOCATION;  /* Quiet warning.  */
5089 #define POP                                                                   \
5090   do {                                                                        \
5091     switch (stack[sp].op)                                                     \
5092       {                                                                       \
5093       case TRUTH_ANDIF_EXPR:                                                  \
5094         c_inhibit_evaluation_warnings -= (stack[sp - 1].expr.value            \
5095                                           == truthvalue_false_node);          \
5096         break;                                                                \
5097       case TRUTH_ORIF_EXPR:                                                   \
5098         c_inhibit_evaluation_warnings -= (stack[sp - 1].expr.value            \
5099                                           == truthvalue_true_node);           \
5100         break;                                                                \
5101       default:                                                                \
5102         break;                                                                \
5103       }                                                                       \
5104     stack[sp - 1].expr                                                        \
5105       = default_function_array_read_conversion (stack[sp - 1].loc,            \
5106                                                 stack[sp - 1].expr);          \
5107     stack[sp].expr                                                            \
5108       = default_function_array_read_conversion (stack[sp].loc,                \
5109                                                 stack[sp].expr);              \
5110     stack[sp - 1].expr = parser_build_binary_op (stack[sp].loc,               \
5111                                                  stack[sp].op,                \
5112                                                  stack[sp - 1].expr,          \
5113                                                  stack[sp].expr);             \
5114     sp--;                                                                     \
5115   } while (0)
5116   gcc_assert (!after || c_dialect_objc ());
5117   stack[0].loc = c_parser_peek_token (parser)->location;
5118   stack[0].expr = c_parser_cast_expression (parser, after);
5119   stack[0].prec = PREC_NONE;
5120   sp = 0;
5121   while (true)
5122     {
5123       enum prec oprec;
5124       enum tree_code ocode;
5125       if (parser->error)
5126         goto out;
5127       switch (c_parser_peek_token (parser)->type)
5128         {
5129         case CPP_MULT:
5130           oprec = PREC_MULT;
5131           ocode = MULT_EXPR;
5132           break;
5133         case CPP_DIV:
5134           oprec = PREC_MULT;
5135           ocode = TRUNC_DIV_EXPR;
5136           break;
5137         case CPP_MOD:
5138           oprec = PREC_MULT;
5139           ocode = TRUNC_MOD_EXPR;
5140           break;
5141         case CPP_PLUS:
5142           oprec = PREC_ADD;
5143           ocode = PLUS_EXPR;
5144           break;
5145         case CPP_MINUS:
5146           oprec = PREC_ADD;
5147           ocode = MINUS_EXPR;
5148           break;
5149         case CPP_LSHIFT:
5150           oprec = PREC_SHIFT;
5151           ocode = LSHIFT_EXPR;
5152           break;
5153         case CPP_RSHIFT:
5154           oprec = PREC_SHIFT;
5155           ocode = RSHIFT_EXPR;
5156           break;
5157         case CPP_LESS:
5158           oprec = PREC_REL;
5159           ocode = LT_EXPR;
5160           break;
5161         case CPP_GREATER:
5162           oprec = PREC_REL;
5163           ocode = GT_EXPR;
5164           break;
5165         case CPP_LESS_EQ:
5166           oprec = PREC_REL;
5167           ocode = LE_EXPR;
5168           break;
5169         case CPP_GREATER_EQ:
5170           oprec = PREC_REL;
5171           ocode = GE_EXPR;
5172           break;
5173         case CPP_EQ_EQ:
5174           oprec = PREC_EQ;
5175           ocode = EQ_EXPR;
5176           break;
5177         case CPP_NOT_EQ:
5178           oprec = PREC_EQ;
5179           ocode = NE_EXPR;
5180           break;
5181         case CPP_AND:
5182           oprec = PREC_BITAND;
5183           ocode = BIT_AND_EXPR;
5184           break;
5185         case CPP_XOR:
5186           oprec = PREC_BITXOR;
5187           ocode = BIT_XOR_EXPR;
5188           break;
5189         case CPP_OR:
5190           oprec = PREC_BITOR;
5191           ocode = BIT_IOR_EXPR;
5192           break;
5193         case CPP_AND_AND:
5194           oprec = PREC_LOGAND;
5195           ocode = TRUTH_ANDIF_EXPR;
5196           break;
5197         case CPP_OR_OR:
5198           oprec = PREC_LOGOR;
5199           ocode = TRUTH_ORIF_EXPR;
5200           break;
5201         default:
5202           /* Not a binary operator, so end of the binary
5203              expression.  */
5204           goto out;
5205         }
5206       binary_loc = c_parser_peek_token (parser)->location;
5207       c_parser_consume_token (parser);
5208       while (oprec <= stack[sp].prec)
5209         POP;
5210       switch (ocode)
5211         {
5212         case TRUTH_ANDIF_EXPR:
5213           stack[sp].expr
5214             = default_function_array_read_conversion (stack[sp].loc,
5215                                                       stack[sp].expr);
5216           stack[sp].expr.value = c_objc_common_truthvalue_conversion
5217             (stack[sp].loc, default_conversion (stack[sp].expr.value));
5218           c_inhibit_evaluation_warnings += (stack[sp].expr.value
5219                                             == truthvalue_false_node);
5220           break;
5221         case TRUTH_ORIF_EXPR:
5222           stack[sp].expr
5223             = default_function_array_read_conversion (stack[sp].loc,
5224                                                       stack[sp].expr);
5225           stack[sp].expr.value = c_objc_common_truthvalue_conversion
5226             (stack[sp].loc, default_conversion (stack[sp].expr.value));
5227           c_inhibit_evaluation_warnings += (stack[sp].expr.value
5228                                             == truthvalue_true_node);
5229           break;
5230         default:
5231           break;
5232         }
5233       sp++;
5234       stack[sp].loc = binary_loc;
5235       stack[sp].expr = c_parser_cast_expression (parser, NULL);
5236       stack[sp].prec = oprec;
5237       stack[sp].op = ocode;
5238       stack[sp].loc = binary_loc;
5239     }
5240  out:
5241   while (sp > 0)
5242     POP;
5243   return stack[0].expr;
5244 #undef POP
5245 }
5246
5247 /* Parse a cast expression (C90 6.3.4, C99 6.5.4).  If AFTER is not
5248    NULL then it is an Objective-C message expression which is the
5249    primary-expression starting the expression as an initializer.
5250
5251    cast-expression:
5252      unary-expression
5253      ( type-name ) unary-expression
5254 */
5255
5256 static struct c_expr
5257 c_parser_cast_expression (c_parser *parser, struct c_expr *after)
5258 {
5259   location_t cast_loc = c_parser_peek_token (parser)->location;
5260   gcc_assert (!after || c_dialect_objc ());
5261   if (after)
5262     return c_parser_postfix_expression_after_primary (parser,
5263                                                       cast_loc, *after);
5264   /* If the expression begins with a parenthesized type name, it may
5265      be either a cast or a compound literal; we need to see whether
5266      the next character is '{' to tell the difference.  If not, it is
5267      an unary expression.  */
5268   if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)
5269       && c_token_starts_typename (c_parser_peek_2nd_token (parser)))
5270     {
5271       struct c_type_name *type_name;
5272       struct c_expr ret;
5273       struct c_expr expr;
5274       c_parser_consume_token (parser);
5275       type_name = c_parser_type_name (parser);
5276       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
5277       if (type_name == NULL)
5278         {
5279           ret.value = error_mark_node;
5280           ret.original_code = ERROR_MARK;
5281           ret.original_type = NULL;
5282           return ret;
5283         }
5284
5285       /* Save casted types in the function's used types hash table.  */
5286       used_types_insert (type_name->specs->type);
5287
5288       if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
5289         return c_parser_postfix_expression_after_paren_type (parser, type_name,
5290                                                              cast_loc);
5291       {
5292         location_t expr_loc = c_parser_peek_token (parser)->location;
5293         expr = c_parser_cast_expression (parser, NULL);
5294         expr = default_function_array_read_conversion (expr_loc, expr);
5295       }
5296       ret.value = c_cast_expr (cast_loc, type_name, expr.value);
5297       ret.original_code = ERROR_MARK;
5298       ret.original_type = NULL;
5299       return ret;
5300     }
5301   else
5302     return c_parser_unary_expression (parser);
5303 }
5304
5305 /* Parse an unary expression (C90 6.3.3, C99 6.5.3).
5306
5307    unary-expression:
5308      postfix-expression
5309      ++ unary-expression
5310      -- unary-expression
5311      unary-operator cast-expression
5312      sizeof unary-expression
5313      sizeof ( type-name )
5314
5315    unary-operator: one of
5316      & * + - ~ !
5317
5318    GNU extensions:
5319
5320    unary-expression:
5321      __alignof__ unary-expression
5322      __alignof__ ( type-name )
5323      && identifier
5324
5325    unary-operator: one of
5326      __extension__ __real__ __imag__
5327
5328    In addition, the GNU syntax treats ++ and -- as unary operators, so
5329    they may be applied to cast expressions with errors for non-lvalues
5330    given later.  */
5331
5332 static struct c_expr
5333 c_parser_unary_expression (c_parser *parser)
5334 {
5335   int ext;
5336   struct c_expr ret, op;
5337   location_t op_loc = c_parser_peek_token (parser)->location;
5338   location_t exp_loc;
5339   ret.original_code = ERROR_MARK;
5340   ret.original_type = NULL;
5341   switch (c_parser_peek_token (parser)->type)
5342     {
5343     case CPP_PLUS_PLUS:
5344       c_parser_consume_token (parser);
5345       exp_loc = c_parser_peek_token (parser)->location;
5346       op = c_parser_cast_expression (parser, NULL);
5347       op = default_function_array_read_conversion (exp_loc, op);
5348       return parser_build_unary_op (op_loc, PREINCREMENT_EXPR, op);
5349     case CPP_MINUS_MINUS:
5350       c_parser_consume_token (parser);
5351       exp_loc = c_parser_peek_token (parser)->location;
5352       op = c_parser_cast_expression (parser, NULL);
5353       op = default_function_array_read_conversion (exp_loc, op);
5354       return parser_build_unary_op (op_loc, PREDECREMENT_EXPR, op);
5355     case CPP_AND:
5356       c_parser_consume_token (parser);
5357       op = c_parser_cast_expression (parser, NULL);
5358       mark_exp_read (op.value);
5359       return parser_build_unary_op (op_loc, ADDR_EXPR, op);
5360     case CPP_MULT:
5361       c_parser_consume_token (parser);
5362       exp_loc = c_parser_peek_token (parser)->location;
5363       op = c_parser_cast_expression (parser, NULL);
5364       op = default_function_array_read_conversion (exp_loc, op);
5365       ret.value = build_indirect_ref (op_loc, op.value, RO_UNARY_STAR);
5366       return ret;
5367     case CPP_PLUS:
5368       if (!c_dialect_objc () && !in_system_header)
5369         warning_at (op_loc,
5370                     OPT_Wtraditional,
5371                     "traditional C rejects the unary plus operator");
5372       c_parser_consume_token (parser);
5373       exp_loc = c_parser_peek_token (parser)->location;
5374       op = c_parser_cast_expression (parser, NULL);
5375       op = default_function_array_read_conversion (exp_loc, op);
5376       return parser_build_unary_op (op_loc, CONVERT_EXPR, op);
5377     case CPP_MINUS:
5378       c_parser_consume_token (parser);
5379       exp_loc = c_parser_peek_token (parser)->location;
5380       op = c_parser_cast_expression (parser, NULL);
5381       op = default_function_array_read_conversion (exp_loc, op);
5382       return parser_build_unary_op (op_loc, NEGATE_EXPR, op);
5383     case CPP_COMPL:
5384       c_parser_consume_token (parser);
5385       exp_loc = c_parser_peek_token (parser)->location;
5386       op = c_parser_cast_expression (parser, NULL);
5387       op = default_function_array_read_conversion (exp_loc, op);
5388       return parser_build_unary_op (op_loc, BIT_NOT_EXPR, op);
5389     case CPP_NOT:
5390       c_parser_consume_token (parser);
5391       exp_loc = c_parser_peek_token (parser)->location;
5392       op = c_parser_cast_expression (parser, NULL);
5393       op = default_function_array_read_conversion (exp_loc, op);
5394       return parser_build_unary_op (op_loc, TRUTH_NOT_EXPR, op);
5395     case CPP_AND_AND:
5396       /* Refer to the address of a label as a pointer.  */
5397       c_parser_consume_token (parser);
5398       if (c_parser_next_token_is (parser, CPP_NAME))
5399         {
5400           ret.value = finish_label_address_expr
5401             (c_parser_peek_token (parser)->value, op_loc);
5402           c_parser_consume_token (parser);
5403         }
5404       else
5405         {
5406           c_parser_error (parser, "expected identifier");
5407           ret.value = error_mark_node;
5408         }
5409         return ret;
5410     case CPP_KEYWORD:
5411       switch (c_parser_peek_token (parser)->keyword)
5412         {
5413         case RID_SIZEOF:
5414           return c_parser_sizeof_expression (parser);
5415         case RID_ALIGNOF:
5416           return c_parser_alignof_expression (parser);
5417         case RID_EXTENSION:
5418           c_parser_consume_token (parser);
5419           ext = disable_extension_diagnostics ();
5420           ret = c_parser_cast_expression (parser, NULL);
5421           restore_extension_diagnostics (ext);
5422           return ret;
5423         case RID_REALPART:
5424           c_parser_consume_token (parser);
5425           exp_loc = c_parser_peek_token (parser)->location;
5426           op = c_parser_cast_expression (parser, NULL);
5427           op = default_function_array_conversion (exp_loc, op);
5428           return parser_build_unary_op (op_loc, REALPART_EXPR, op);
5429         case RID_IMAGPART:
5430           c_parser_consume_token (parser);
5431           exp_loc = c_parser_peek_token (parser)->location;
5432           op = c_parser_cast_expression (parser, NULL);
5433           op = default_function_array_conversion (exp_loc, op);
5434           return parser_build_unary_op (op_loc, IMAGPART_EXPR, op);
5435         default:
5436           return c_parser_postfix_expression (parser);
5437         }
5438     default:
5439       return c_parser_postfix_expression (parser);
5440     }
5441 }
5442
5443 /* Parse a sizeof expression.  */
5444
5445 static struct c_expr
5446 c_parser_sizeof_expression (c_parser *parser)
5447 {
5448   struct c_expr expr;
5449   location_t expr_loc;
5450   gcc_assert (c_parser_next_token_is_keyword (parser, RID_SIZEOF));
5451   c_parser_consume_token (parser);
5452   c_inhibit_evaluation_warnings++;
5453   in_sizeof++;
5454   if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)
5455       && c_token_starts_typename (c_parser_peek_2nd_token (parser)))
5456     {
5457       /* Either sizeof ( type-name ) or sizeof unary-expression
5458          starting with a compound literal.  */
5459       struct c_type_name *type_name;
5460       c_parser_consume_token (parser);
5461       expr_loc = c_parser_peek_token (parser)->location;
5462       type_name = c_parser_type_name (parser);
5463       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
5464       if (type_name == NULL)
5465         {
5466           struct c_expr ret;
5467           c_inhibit_evaluation_warnings--;
5468           in_sizeof--;
5469           ret.value = error_mark_node;
5470           ret.original_code = ERROR_MARK;
5471           ret.original_type = NULL;
5472           return ret;
5473         }
5474       if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
5475         {
5476           expr = c_parser_postfix_expression_after_paren_type (parser,
5477                                                                type_name,
5478                                                                expr_loc);
5479           goto sizeof_expr;
5480         }
5481       /* sizeof ( type-name ).  */
5482       c_inhibit_evaluation_warnings--;
5483       in_sizeof--;
5484       return c_expr_sizeof_type (expr_loc, type_name);
5485     }
5486   else
5487     {
5488       expr_loc = c_parser_peek_token (parser)->location;
5489       expr = c_parser_unary_expression (parser);
5490     sizeof_expr:
5491       c_inhibit_evaluation_warnings--;
5492       in_sizeof--;
5493       mark_exp_read (expr.value);
5494       if (TREE_CODE (expr.value) == COMPONENT_REF
5495           && DECL_C_BIT_FIELD (TREE_OPERAND (expr.value, 1)))
5496         error_at (expr_loc, "%<sizeof%> applied to a bit-field");
5497       return c_expr_sizeof_expr (expr_loc, expr);
5498     }
5499 }
5500
5501 /* Parse an alignof expression.  */
5502
5503 static struct c_expr
5504 c_parser_alignof_expression (c_parser *parser)
5505 {
5506   struct c_expr expr;
5507   location_t loc = c_parser_peek_token (parser)->location;
5508   gcc_assert (c_parser_next_token_is_keyword (parser, RID_ALIGNOF));
5509   c_parser_consume_token (parser);
5510   c_inhibit_evaluation_warnings++;
5511   in_alignof++;
5512   if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)
5513       && c_token_starts_typename (c_parser_peek_2nd_token (parser)))
5514     {
5515       /* Either __alignof__ ( type-name ) or __alignof__
5516          unary-expression starting with a compound literal.  */
5517       location_t loc;
5518       struct c_type_name *type_name;
5519       struct c_expr ret;
5520       c_parser_consume_token (parser);
5521       loc = c_parser_peek_token (parser)->location;
5522       type_name = c_parser_type_name (parser);
5523       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
5524       if (type_name == NULL)
5525         {
5526           struct c_expr ret;
5527           c_inhibit_evaluation_warnings--;
5528           in_alignof--;
5529           ret.value = error_mark_node;
5530           ret.original_code = ERROR_MARK;
5531           ret.original_type = NULL;
5532           return ret;
5533         }
5534       if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
5535         {
5536           expr = c_parser_postfix_expression_after_paren_type (parser,
5537                                                                type_name,
5538                                                                loc);
5539           goto alignof_expr;
5540         }
5541       /* alignof ( type-name ).  */
5542       c_inhibit_evaluation_warnings--;
5543       in_alignof--;
5544       ret.value = c_alignof (loc, groktypename (type_name, NULL, NULL));
5545       ret.original_code = ERROR_MARK;
5546       ret.original_type = NULL;
5547       return ret;
5548     }
5549   else
5550     {
5551       struct c_expr ret;
5552       expr = c_parser_unary_expression (parser);
5553     alignof_expr:
5554       mark_exp_read (expr.value);
5555       c_inhibit_evaluation_warnings--;
5556       in_alignof--;
5557       ret.value = c_alignof_expr (loc, expr.value);
5558       ret.original_code = ERROR_MARK;
5559       ret.original_type = NULL;
5560       return ret;
5561     }
5562 }
5563
5564 /* Parse a postfix expression (C90 6.3.1-6.3.2, C99 6.5.1-6.5.2).
5565
5566    postfix-expression:
5567      primary-expression
5568      postfix-expression [ expression ]
5569      postfix-expression ( argument-expression-list[opt] )
5570      postfix-expression . identifier
5571      postfix-expression -> identifier
5572      postfix-expression ++
5573      postfix-expression --
5574      ( type-name ) { initializer-list }
5575      ( type-name ) { initializer-list , }
5576
5577    argument-expression-list:
5578      argument-expression
5579      argument-expression-list , argument-expression
5580
5581    primary-expression:
5582      identifier
5583      constant
5584      string-literal
5585      ( expression )
5586
5587    GNU extensions:
5588
5589    primary-expression:
5590      __func__
5591        (treated as a keyword in GNU C)
5592      __FUNCTION__
5593      __PRETTY_FUNCTION__
5594      ( compound-statement )
5595      __builtin_va_arg ( assignment-expression , type-name )
5596      __builtin_offsetof ( type-name , offsetof-member-designator )
5597      __builtin_choose_expr ( assignment-expression ,
5598                              assignment-expression ,
5599                              assignment-expression )
5600      __builtin_types_compatible_p ( type-name , type-name )
5601
5602    offsetof-member-designator:
5603      identifier
5604      offsetof-member-designator . identifier
5605      offsetof-member-designator [ expression ]
5606
5607    Objective-C:
5608
5609    primary-expression:
5610      [ objc-receiver objc-message-args ]
5611      @selector ( objc-selector-arg )
5612      @protocol ( identifier )
5613      @encode ( type-name )
5614      objc-string-literal
5615 */
5616
5617 static struct c_expr
5618 c_parser_postfix_expression (c_parser *parser)
5619 {
5620   struct c_expr expr, e1, e2, e3;
5621   struct c_type_name *t1, *t2;
5622   location_t loc = c_parser_peek_token (parser)->location;;
5623   expr.original_code = ERROR_MARK;
5624   expr.original_type = NULL;
5625   switch (c_parser_peek_token (parser)->type)
5626     {
5627     case CPP_NUMBER:
5628       expr.value = c_parser_peek_token (parser)->value;
5629       loc = c_parser_peek_token (parser)->location;
5630       c_parser_consume_token (parser);
5631       if (TREE_CODE (expr.value) == FIXED_CST
5632           && !targetm.fixed_point_supported_p ())
5633         {
5634           error_at (loc, "fixed-point types not supported for this target");
5635           expr.value = error_mark_node;
5636         }
5637       break;
5638     case CPP_CHAR:
5639     case CPP_CHAR16:
5640     case CPP_CHAR32:
5641     case CPP_WCHAR:
5642       expr.value = c_parser_peek_token (parser)->value;
5643       c_parser_consume_token (parser);
5644       break;
5645     case CPP_STRING:
5646     case CPP_STRING16:
5647     case CPP_STRING32:
5648     case CPP_WSTRING:
5649     case CPP_UTF8STRING:
5650       expr.value = c_parser_peek_token (parser)->value;
5651       expr.original_code = STRING_CST;
5652       c_parser_consume_token (parser);
5653       break;
5654     case CPP_OBJC_STRING:
5655       gcc_assert (c_dialect_objc ());
5656       expr.value
5657         = objc_build_string_object (c_parser_peek_token (parser)->value);
5658       c_parser_consume_token (parser);
5659       break;
5660     case CPP_NAME:
5661       if (c_parser_peek_token (parser)->id_kind != C_ID_ID)
5662         {
5663           c_parser_error (parser, "expected expression");
5664           expr.value = error_mark_node;
5665           break;
5666         }
5667       {
5668         tree id = c_parser_peek_token (parser)->value;
5669         c_parser_consume_token (parser);
5670         expr.value = build_external_ref (loc, id,
5671                                          (c_parser_peek_token (parser)->type
5672                                           == CPP_OPEN_PAREN),
5673                                          &expr.original_type);
5674       }
5675       break;
5676     case CPP_OPEN_PAREN:
5677       /* A parenthesized expression, statement expression or compound
5678          literal.  */
5679       if (c_parser_peek_2nd_token (parser)->type == CPP_OPEN_BRACE)
5680         {
5681           /* A statement expression.  */
5682           tree stmt;
5683           location_t brace_loc;
5684           c_parser_consume_token (parser);
5685           brace_loc = c_parser_peek_token (parser)->location;
5686           c_parser_consume_token (parser);
5687           if (cur_stmt_list == NULL)
5688             {
5689               error_at (loc, "braced-group within expression allowed "
5690                         "only inside a function");
5691               parser->error = true;
5692               c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL);
5693               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
5694               expr.value = error_mark_node;
5695               break;
5696             }
5697           stmt = c_begin_stmt_expr ();
5698           c_parser_compound_statement_nostart (parser);
5699           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
5700                                      "expected %<)%>");
5701           pedwarn (loc, OPT_pedantic,
5702                    "ISO C forbids braced-groups within expressions");
5703           expr.value = c_finish_stmt_expr (brace_loc, stmt);
5704           mark_exp_read (expr.value);
5705         }
5706       else if (c_token_starts_typename (c_parser_peek_2nd_token (parser)))
5707         {
5708           /* A compound literal.  ??? Can we actually get here rather
5709              than going directly to
5710              c_parser_postfix_expression_after_paren_type from
5711              elsewhere?  */
5712           location_t loc;
5713           struct c_type_name *type_name;
5714           c_parser_consume_token (parser);
5715           loc = c_parser_peek_token (parser)->location;
5716           type_name = c_parser_type_name (parser);
5717           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
5718                                      "expected %<)%>");
5719           if (type_name == NULL)
5720             {
5721               expr.value = error_mark_node;
5722             }
5723           else
5724             expr = c_parser_postfix_expression_after_paren_type (parser,
5725                                                                  type_name,
5726                                                                  loc);
5727         }
5728       else
5729         {
5730           /* A parenthesized expression.  */
5731           c_parser_consume_token (parser);
5732           expr = c_parser_expression (parser);
5733           if (TREE_CODE (expr.value) == MODIFY_EXPR)
5734             TREE_NO_WARNING (expr.value) = 1;
5735           if (expr.original_code != C_MAYBE_CONST_EXPR)
5736             expr.original_code = ERROR_MARK;
5737           /* Don't change EXPR.ORIGINAL_TYPE.  */
5738           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
5739                                      "expected %<)%>");
5740         }
5741       break;
5742     case CPP_KEYWORD:
5743       switch (c_parser_peek_token (parser)->keyword)
5744         {
5745         case RID_FUNCTION_NAME:
5746         case RID_PRETTY_FUNCTION_NAME:
5747         case RID_C99_FUNCTION_NAME:
5748           expr.value = fname_decl (loc,
5749                                    c_parser_peek_token (parser)->keyword,
5750                                    c_parser_peek_token (parser)->value);
5751           c_parser_consume_token (parser);
5752           break;
5753         case RID_VA_ARG:
5754           c_parser_consume_token (parser);
5755           if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
5756             {
5757               expr.value = error_mark_node;
5758               break;
5759             }
5760           e1 = c_parser_expr_no_commas (parser, NULL);
5761           mark_exp_read (e1.value);
5762           e1.value = c_fully_fold (e1.value, false, NULL);
5763           if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>"))
5764             {
5765               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
5766               expr.value = error_mark_node;
5767               break;
5768             }
5769           loc = c_parser_peek_token (parser)->location;
5770           t1 = c_parser_type_name (parser);
5771           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
5772                                      "expected %<)%>");
5773           if (t1 == NULL)
5774             {
5775               expr.value = error_mark_node;
5776             }
5777           else
5778             {
5779               tree type_expr = NULL_TREE;
5780               expr.value = c_build_va_arg (loc, e1.value,
5781                                            groktypename (t1, &type_expr, NULL));
5782               if (type_expr)
5783                 {
5784                   expr.value = build2 (C_MAYBE_CONST_EXPR,
5785                                        TREE_TYPE (expr.value), type_expr,
5786                                        expr.value);
5787                   C_MAYBE_CONST_EXPR_NON_CONST (expr.value) = true;
5788                 }
5789             }
5790           break;
5791         case RID_OFFSETOF:
5792           c_parser_consume_token (parser);
5793           if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
5794             {
5795               expr.value = error_mark_node;
5796               break;
5797             }
5798           t1 = c_parser_type_name (parser);
5799           if (t1 == NULL)
5800             {
5801               expr.value = error_mark_node;
5802               break;
5803             }
5804           if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>"))
5805             {
5806               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
5807               expr.value = error_mark_node;
5808               break;
5809             }
5810           {
5811             tree type = groktypename (t1, NULL, NULL);
5812             tree offsetof_ref;
5813             if (type == error_mark_node)
5814               offsetof_ref = error_mark_node;
5815             else
5816               {
5817                 offsetof_ref = build1 (INDIRECT_REF, type, null_pointer_node);
5818                 SET_EXPR_LOCATION (offsetof_ref, loc);
5819               }
5820             /* Parse the second argument to __builtin_offsetof.  We
5821                must have one identifier, and beyond that we want to
5822                accept sub structure and sub array references.  */
5823             if (c_parser_next_token_is (parser, CPP_NAME))
5824               {
5825                 offsetof_ref = build_component_ref
5826                   (loc, offsetof_ref, c_parser_peek_token (parser)->value);
5827                 c_parser_consume_token (parser);
5828                 while (c_parser_next_token_is (parser, CPP_DOT)
5829                        || c_parser_next_token_is (parser,
5830                                                   CPP_OPEN_SQUARE)
5831                        || c_parser_next_token_is (parser,
5832                                                   CPP_DEREF))
5833                   {
5834                     if (c_parser_next_token_is (parser, CPP_DEREF))
5835                       {
5836                         loc = c_parser_peek_token (parser)->location;
5837                         offsetof_ref = build_array_ref (loc,
5838                                                         offsetof_ref,
5839                                                         integer_zero_node);
5840                         goto do_dot;
5841                       }
5842                     else if (c_parser_next_token_is (parser, CPP_DOT))
5843                       {
5844                       do_dot:
5845                         c_parser_consume_token (parser);
5846                         if (c_parser_next_token_is_not (parser,
5847                                                         CPP_NAME))
5848                           {
5849                             c_parser_error (parser, "expected identifier");
5850                             break;
5851                           }
5852                         offsetof_ref = build_component_ref
5853                           (loc, offsetof_ref,
5854                            c_parser_peek_token (parser)->value);
5855                         c_parser_consume_token (parser);
5856                       }
5857                     else
5858                       {
5859                         tree idx;
5860                         loc = c_parser_peek_token (parser)->location;
5861                         c_parser_consume_token (parser);
5862                         idx = c_parser_expression (parser).value;
5863                         idx = c_fully_fold (idx, false, NULL);
5864                         c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
5865                                                    "expected %<]%>");
5866                         offsetof_ref = build_array_ref (loc, offsetof_ref, idx);
5867                       }
5868                   }
5869               }
5870             else
5871               c_parser_error (parser, "expected identifier");
5872             c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
5873                                        "expected %<)%>");
5874             expr.value = fold_offsetof (offsetof_ref, NULL_TREE);
5875           }
5876           break;
5877         case RID_CHOOSE_EXPR:
5878           c_parser_consume_token (parser);
5879           if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
5880             {
5881               expr.value = error_mark_node;
5882               break;
5883             }
5884           loc = c_parser_peek_token (parser)->location;
5885           e1 = c_parser_expr_no_commas (parser, NULL);
5886           if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>"))
5887             {
5888               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
5889               expr.value = error_mark_node;
5890               break;
5891             }
5892           e2 = c_parser_expr_no_commas (parser, NULL);
5893           if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>"))
5894             {
5895               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
5896               expr.value = error_mark_node;
5897               break;
5898             }
5899           e3 = c_parser_expr_no_commas (parser, NULL);
5900           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
5901                                      "expected %<)%>");
5902           {
5903             tree c;
5904
5905             c = e1.value;
5906             mark_exp_read (e2.value);
5907             mark_exp_read (e3.value);
5908             if (TREE_CODE (c) != INTEGER_CST
5909                 || !INTEGRAL_TYPE_P (TREE_TYPE (c)))
5910               error_at (loc,
5911                         "first argument to %<__builtin_choose_expr%> not"
5912                         " a constant");
5913             constant_expression_warning (c);
5914             expr = integer_zerop (c) ? e3 : e2;
5915           }
5916           break;
5917         case RID_TYPES_COMPATIBLE_P:
5918           c_parser_consume_token (parser);
5919           if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
5920             {
5921               expr.value = error_mark_node;
5922               break;
5923             }
5924           t1 = c_parser_type_name (parser);
5925           if (t1 == NULL)
5926             {
5927               expr.value = error_mark_node;
5928               break;
5929             }
5930           if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>"))
5931             {
5932               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
5933               expr.value = error_mark_node;
5934               break;
5935             }
5936           t2 = c_parser_type_name (parser);
5937           if (t2 == NULL)
5938             {
5939               expr.value = error_mark_node;
5940               break;
5941             }
5942           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
5943                                      "expected %<)%>");
5944           {
5945             tree e1, e2;
5946
5947             e1 = TYPE_MAIN_VARIANT (groktypename (t1, NULL, NULL));
5948             e2 = TYPE_MAIN_VARIANT (groktypename (t2, NULL, NULL));
5949
5950             expr.value
5951               = comptypes (e1, e2) ? integer_one_node : integer_zero_node;
5952           }
5953           break;
5954         case RID_AT_SELECTOR:
5955           gcc_assert (c_dialect_objc ());
5956           c_parser_consume_token (parser);
5957           if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
5958             {
5959               expr.value = error_mark_node;
5960               break;
5961             }
5962           {
5963             tree sel = c_parser_objc_selector_arg (parser);
5964             c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
5965                                        "expected %<)%>");
5966             expr.value = objc_build_selector_expr (loc, sel);
5967           }
5968           break;
5969         case RID_AT_PROTOCOL:
5970           gcc_assert (c_dialect_objc ());
5971           c_parser_consume_token (parser);
5972           if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
5973             {
5974               expr.value = error_mark_node;
5975               break;
5976             }
5977           if (c_parser_next_token_is_not (parser, CPP_NAME))
5978             {
5979               c_parser_error (parser, "expected identifier");
5980               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
5981               expr.value = error_mark_node;
5982               break;
5983             }
5984           {
5985             tree id = c_parser_peek_token (parser)->value;
5986             c_parser_consume_token (parser);
5987             c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
5988                                        "expected %<)%>");
5989             expr.value = objc_build_protocol_expr (id);
5990           }
5991           break;
5992         case RID_AT_ENCODE:
5993           /* Extension to support C-structures in the archiver.  */
5994           gcc_assert (c_dialect_objc ());
5995           c_parser_consume_token (parser);
5996           if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
5997             {
5998               expr.value = error_mark_node;
5999               break;
6000             }
6001           t1 = c_parser_type_name (parser);
6002           if (t1 == NULL)
6003             {
6004               expr.value = error_mark_node;
6005               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
6006               break;
6007             }
6008           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
6009                                      "expected %<)%>");
6010           {
6011             tree type = groktypename (t1, NULL, NULL);
6012             expr.value = objc_build_encode_expr (type);
6013           }
6014           break;
6015         default:
6016           c_parser_error (parser, "expected expression");
6017           expr.value = error_mark_node;
6018           break;
6019         }
6020       break;
6021     case CPP_OPEN_SQUARE:
6022       if (c_dialect_objc ())
6023         {
6024           tree receiver, args;
6025           c_parser_consume_token (parser);
6026           receiver = c_parser_objc_receiver (parser);
6027           args = c_parser_objc_message_args (parser);
6028           c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
6029                                      "expected %<]%>");
6030           expr.value = objc_build_message_expr (build_tree_list (receiver,
6031                                                                  args));
6032           break;
6033         }
6034       /* Else fall through to report error.  */
6035     default:
6036       c_parser_error (parser, "expected expression");
6037       expr.value = error_mark_node;
6038       break;
6039     }
6040   return c_parser_postfix_expression_after_primary (parser, loc, expr);
6041 }
6042
6043 /* Parse a postfix expression after a parenthesized type name: the
6044    brace-enclosed initializer of a compound literal, possibly followed
6045    by some postfix operators.  This is separate because it is not
6046    possible to tell until after the type name whether a cast
6047    expression has a cast or a compound literal, or whether the operand
6048    of sizeof is a parenthesized type name or starts with a compound
6049    literal.  TYPE_LOC is the location where TYPE_NAME starts--the
6050    location of the first token after the parentheses around the type
6051    name.  */
6052
6053 static struct c_expr
6054 c_parser_postfix_expression_after_paren_type (c_parser *parser,
6055                                               struct c_type_name *type_name,
6056                                               location_t type_loc)
6057 {
6058   tree type;
6059   struct c_expr init;
6060   bool non_const;
6061   struct c_expr expr;
6062   location_t start_loc;
6063   tree type_expr = NULL_TREE;
6064   bool type_expr_const = true;
6065   check_compound_literal_type (type_loc, type_name);
6066   start_init (NULL_TREE, NULL, 0);
6067   type = groktypename (type_name, &type_expr, &type_expr_const);
6068   start_loc = c_parser_peek_token (parser)->location;
6069   if (type != error_mark_node && C_TYPE_VARIABLE_SIZE (type))
6070     {
6071       error_at (type_loc, "compound literal has variable size");
6072       type = error_mark_node;
6073     }
6074   init = c_parser_braced_init (parser, type, false);
6075   finish_init ();
6076   maybe_warn_string_init (type, init);
6077
6078   if (type != error_mark_node
6079       && !ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (type))
6080       && current_function_decl)
6081     {
6082       error ("compound literal qualified by address-space qualifier");
6083       type = error_mark_node;
6084     }
6085
6086   if (!flag_isoc99)
6087     pedwarn (start_loc, OPT_pedantic, "ISO C90 forbids compound literals");
6088   non_const = ((init.value && TREE_CODE (init.value) == CONSTRUCTOR)
6089                ? CONSTRUCTOR_NON_CONST (init.value)
6090                : init.original_code == C_MAYBE_CONST_EXPR);
6091   non_const |= !type_expr_const;
6092   expr.value = build_compound_literal (start_loc, type, init.value, non_const);
6093   expr.original_code = ERROR_MARK;
6094   expr.original_type = NULL;
6095   if (type_expr)
6096     {
6097       if (TREE_CODE (expr.value) == C_MAYBE_CONST_EXPR)
6098         {
6099           gcc_assert (C_MAYBE_CONST_EXPR_PRE (expr.value) == NULL_TREE);
6100           C_MAYBE_CONST_EXPR_PRE (expr.value) = type_expr;
6101         }
6102       else
6103         {
6104           gcc_assert (!non_const);
6105           expr.value = build2 (C_MAYBE_CONST_EXPR, type,
6106                                type_expr, expr.value);
6107         }
6108     }
6109   return c_parser_postfix_expression_after_primary (parser, start_loc, expr);
6110 }
6111
6112 /* Parse a postfix expression after the initial primary or compound
6113    literal; that is, parse a series of postfix operators.
6114
6115    EXPR_LOC is the location of the primary expression.  */
6116
6117 static struct c_expr
6118 c_parser_postfix_expression_after_primary (c_parser *parser,
6119                                            location_t expr_loc,
6120                                            struct c_expr expr)
6121 {
6122   struct c_expr orig_expr;
6123   tree ident, idx;
6124   VEC(tree,gc) *exprlist;
6125   VEC(tree,gc) *origtypes;
6126   while (true)
6127     {
6128       location_t op_loc = c_parser_peek_token (parser)->location;
6129       switch (c_parser_peek_token (parser)->type)
6130         {
6131         case CPP_OPEN_SQUARE:
6132           /* Array reference.  */
6133           c_parser_consume_token (parser);
6134           idx = c_parser_expression (parser).value;
6135           c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
6136                                      "expected %<]%>");
6137           expr.value = build_array_ref (op_loc, expr.value, idx);
6138           expr.original_code = ERROR_MARK;
6139           expr.original_type = NULL;
6140           break;
6141         case CPP_OPEN_PAREN:
6142           /* Function call.  */
6143           c_parser_consume_token (parser);
6144           if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
6145             exprlist = NULL;
6146           else
6147             exprlist = c_parser_expr_list (parser, true, false, &origtypes);
6148           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
6149                                      "expected %<)%>");
6150           orig_expr = expr;
6151           mark_exp_read (expr.value);
6152           /* FIXME diagnostics: Ideally we want the FUNCNAME, not the
6153              "(" after the FUNCNAME, which is what we have now.    */
6154           expr.value = build_function_call_vec (op_loc, expr.value, exprlist,
6155                                                 origtypes);
6156           expr.original_code = ERROR_MARK;
6157           if (TREE_CODE (expr.value) == INTEGER_CST
6158               && TREE_CODE (orig_expr.value) == FUNCTION_DECL
6159               && DECL_BUILT_IN_CLASS (orig_expr.value) == BUILT_IN_NORMAL
6160               && DECL_FUNCTION_CODE (orig_expr.value) == BUILT_IN_CONSTANT_P)
6161             expr.original_code = C_MAYBE_CONST_EXPR;
6162           expr.original_type = NULL;
6163           if (exprlist != NULL)
6164             {
6165               release_tree_vector (exprlist);
6166               release_tree_vector (origtypes);
6167             }
6168           break;
6169         case CPP_DOT:
6170           /* Structure element reference.  */
6171           c_parser_consume_token (parser);
6172           expr = default_function_array_conversion (expr_loc, expr);
6173           if (c_parser_next_token_is (parser, CPP_NAME))
6174             ident = c_parser_peek_token (parser)->value;
6175           else
6176             {
6177               c_parser_error (parser, "expected identifier");
6178               expr.value = error_mark_node;
6179               expr.original_code = ERROR_MARK;
6180               expr.original_type = NULL;
6181               return expr;
6182             }
6183           c_parser_consume_token (parser);
6184           expr.value = build_component_ref (op_loc, expr.value, ident);
6185           expr.original_code = ERROR_MARK;
6186           if (TREE_CODE (expr.value) != COMPONENT_REF)
6187             expr.original_type = NULL;
6188           else
6189             {
6190               /* Remember the original type of a bitfield.  */
6191               tree field = TREE_OPERAND (expr.value, 1);
6192               if (TREE_CODE (field) != FIELD_DECL)
6193                 expr.original_type = NULL;
6194               else
6195                 expr.original_type = DECL_BIT_FIELD_TYPE (field);
6196             }
6197           break;
6198         case CPP_DEREF:
6199           /* Structure element reference.  */
6200           c_parser_consume_token (parser);
6201           expr = default_function_array_conversion (expr_loc, expr);
6202           if (c_parser_next_token_is (parser, CPP_NAME))
6203             ident = c_parser_peek_token (parser)->value;
6204           else
6205             {
6206               c_parser_error (parser, "expected identifier");
6207               expr.value = error_mark_node;
6208               expr.original_code = ERROR_MARK;
6209               expr.original_type = NULL;
6210               return expr;
6211             }
6212           c_parser_consume_token (parser);
6213           expr.value = build_component_ref (op_loc,
6214                                             build_indirect_ref (op_loc,
6215                                                                 expr.value,
6216                                                                 RO_ARROW),
6217                                             ident);
6218           expr.original_code = ERROR_MARK;
6219           if (TREE_CODE (expr.value) != COMPONENT_REF)
6220             expr.original_type = NULL;
6221           else
6222             {
6223               /* Remember the original type of a bitfield.  */
6224               tree field = TREE_OPERAND (expr.value, 1);
6225               if (TREE_CODE (field) != FIELD_DECL)
6226                 expr.original_type = NULL;
6227               else
6228                 expr.original_type = DECL_BIT_FIELD_TYPE (field);
6229             }
6230           break;
6231         case CPP_PLUS_PLUS:
6232           /* Postincrement.  */
6233           c_parser_consume_token (parser);
6234           expr = default_function_array_read_conversion (expr_loc, expr);
6235           expr.value = build_unary_op (op_loc,
6236                                        POSTINCREMENT_EXPR, expr.value, 0);
6237           expr.original_code = ERROR_MARK;
6238           expr.original_type = NULL;
6239           break;
6240         case CPP_MINUS_MINUS:
6241           /* Postdecrement.  */
6242           c_parser_consume_token (parser);
6243           expr = default_function_array_read_conversion (expr_loc, expr);
6244           expr.value = build_unary_op (op_loc,
6245                                        POSTDECREMENT_EXPR, expr.value, 0);
6246           expr.original_code = ERROR_MARK;
6247           expr.original_type = NULL;
6248           break;
6249         default:
6250           return expr;
6251         }
6252     }
6253 }
6254
6255 /* Parse an expression (C90 6.3.17, C99 6.5.17).
6256
6257    expression:
6258      assignment-expression
6259      expression , assignment-expression
6260 */
6261
6262 static struct c_expr
6263 c_parser_expression (c_parser *parser)
6264 {
6265   struct c_expr expr;
6266   expr = c_parser_expr_no_commas (parser, NULL);
6267   while (c_parser_next_token_is (parser, CPP_COMMA))
6268     {
6269       struct c_expr next;
6270       tree lhsval;
6271       location_t loc = c_parser_peek_token (parser)->location;
6272       location_t expr_loc;
6273       c_parser_consume_token (parser);
6274       expr_loc = c_parser_peek_token (parser)->location;
6275       lhsval = expr.value;
6276       while (TREE_CODE (lhsval) == COMPOUND_EXPR)
6277         lhsval = TREE_OPERAND (lhsval, 1);
6278       if (DECL_P (lhsval) || handled_component_p (lhsval))
6279         mark_exp_read (lhsval);
6280       next = c_parser_expr_no_commas (parser, NULL);
6281       next = default_function_array_conversion (expr_loc, next);
6282       expr.value = build_compound_expr (loc, expr.value, next.value);
6283       expr.original_code = COMPOUND_EXPR;
6284       expr.original_type = next.original_type;
6285     }
6286   return expr;
6287 }
6288
6289 /* Parse an expression and convert functions or arrays to
6290    pointers.  */
6291
6292 static struct c_expr
6293 c_parser_expression_conv (c_parser *parser)
6294 {
6295   struct c_expr expr;
6296   location_t loc = c_parser_peek_token (parser)->location;
6297   expr = c_parser_expression (parser);
6298   expr = default_function_array_conversion (loc, expr);
6299   return expr;
6300 }
6301
6302 /* Parse a non-empty list of expressions.  If CONVERT_P, convert
6303    functions and arrays to pointers.  If FOLD_P, fold the expressions.
6304
6305    nonempty-expr-list:
6306      assignment-expression
6307      nonempty-expr-list , assignment-expression
6308 */
6309
6310 static VEC(tree,gc) *
6311 c_parser_expr_list (c_parser *parser, bool convert_p, bool fold_p,
6312                     VEC(tree,gc) **p_orig_types)
6313 {
6314   VEC(tree,gc) *ret;
6315   VEC(tree,gc) *orig_types;
6316   struct c_expr expr;
6317   location_t loc = c_parser_peek_token (parser)->location;
6318
6319   ret = make_tree_vector ();
6320   if (p_orig_types == NULL)
6321     orig_types = NULL;
6322   else
6323     orig_types = make_tree_vector ();
6324
6325   expr = c_parser_expr_no_commas (parser, NULL);
6326   if (convert_p)
6327     expr = default_function_array_read_conversion (loc, expr);
6328   if (fold_p)
6329     expr.value = c_fully_fold (expr.value, false, NULL);
6330   VEC_quick_push (tree, ret, expr.value);
6331   if (orig_types != NULL)
6332     VEC_quick_push (tree, orig_types, expr.original_type);
6333   while (c_parser_next_token_is (parser, CPP_COMMA))
6334     {
6335       c_parser_consume_token (parser);
6336       loc = c_parser_peek_token (parser)->location;
6337       expr = c_parser_expr_no_commas (parser, NULL);
6338       if (convert_p)
6339         expr = default_function_array_read_conversion (loc, expr);
6340       if (fold_p)
6341         expr.value = c_fully_fold (expr.value, false, NULL);
6342       VEC_safe_push (tree, gc, ret, expr.value);
6343       if (orig_types != NULL)
6344         VEC_safe_push (tree, gc, orig_types, expr.original_type);
6345     }
6346   if (orig_types != NULL)
6347     *p_orig_types = orig_types;
6348   return ret;
6349 }
6350 \f
6351 /* Parse Objective-C-specific constructs.  */
6352
6353 /* Parse an objc-class-definition.
6354
6355    objc-class-definition:
6356      @interface identifier objc-superclass[opt] objc-protocol-refs[opt]
6357        objc-class-instance-variables[opt] objc-methodprotolist @end
6358      @implementation identifier objc-superclass[opt]
6359        objc-class-instance-variables[opt]
6360      @interface identifier ( identifier ) objc-protocol-refs[opt]
6361        objc-methodprotolist @end
6362      @implementation identifier ( identifier )
6363
6364    objc-superclass:
6365      : identifier
6366
6367    "@interface identifier (" must start "@interface identifier (
6368    identifier ) ...": objc-methodprotolist in the first production may
6369    not start with a parenthesized identifier as a declarator of a data
6370    definition with no declaration specifiers if the objc-superclass,
6371    objc-protocol-refs and objc-class-instance-variables are omitted.  */
6372
6373 static void
6374 c_parser_objc_class_definition (c_parser *parser, tree attributes)
6375 {
6376   bool iface_p;
6377   tree id1;
6378   tree superclass;
6379   if (c_parser_next_token_is_keyword (parser, RID_AT_INTERFACE))
6380     iface_p = true;
6381   else if (c_parser_next_token_is_keyword (parser, RID_AT_IMPLEMENTATION))
6382     iface_p = false;
6383   else
6384     gcc_unreachable ();
6385
6386   c_parser_consume_token (parser);
6387   if (c_parser_next_token_is_not (parser, CPP_NAME))
6388     {
6389       c_parser_error (parser, "expected identifier");
6390       return;
6391     }
6392   id1 = c_parser_peek_token (parser)->value;
6393   c_parser_consume_token (parser);
6394   if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
6395     {
6396       tree id2;
6397       tree proto = NULL_TREE;
6398       c_parser_consume_token (parser);
6399       if (c_parser_next_token_is_not (parser, CPP_NAME))
6400         {
6401           c_parser_error (parser, "expected identifier");
6402           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
6403           return;
6404         }
6405       id2 = c_parser_peek_token (parser)->value;
6406       c_parser_consume_token (parser);
6407       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
6408       if (!iface_p)
6409         {
6410           objc_start_category_implementation (id1, id2);
6411           return;
6412         }
6413       if (c_parser_next_token_is (parser, CPP_LESS))
6414         proto = c_parser_objc_protocol_refs (parser);
6415       objc_start_category_interface (id1, id2, proto, attributes);
6416       c_parser_objc_methodprotolist (parser);
6417       c_parser_require_keyword (parser, RID_AT_END, "expected %<@end%>");
6418       objc_finish_interface ();
6419       return;
6420     }
6421   if (c_parser_next_token_is (parser, CPP_COLON))
6422     {
6423       c_parser_consume_token (parser);
6424       if (c_parser_next_token_is_not (parser, CPP_NAME))
6425         {
6426           c_parser_error (parser, "expected identifier");
6427           return;
6428         }
6429       superclass = c_parser_peek_token (parser)->value;
6430       c_parser_consume_token (parser);
6431     }
6432   else
6433     superclass = NULL_TREE;
6434   if (iface_p)
6435     {
6436       tree proto = NULL_TREE;
6437       if (c_parser_next_token_is (parser, CPP_LESS))
6438         proto = c_parser_objc_protocol_refs (parser);
6439       objc_start_class_interface (id1, superclass, proto, attributes);
6440     }
6441   else
6442     objc_start_class_implementation (id1, superclass);
6443   if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
6444     c_parser_objc_class_instance_variables (parser);
6445   if (iface_p)
6446     {
6447       objc_continue_interface ();
6448       c_parser_objc_methodprotolist (parser);
6449       c_parser_require_keyword (parser, RID_AT_END, "expected %<@end%>");
6450       objc_finish_interface ();
6451     }
6452   else
6453     {
6454       objc_continue_implementation ();
6455       return;
6456     }
6457 }
6458
6459 /* Parse objc-class-instance-variables.
6460
6461    objc-class-instance-variables:
6462      { objc-instance-variable-decl-list[opt] }
6463
6464    objc-instance-variable-decl-list:
6465      objc-visibility-spec
6466      objc-instance-variable-decl ;
6467      ;
6468      objc-instance-variable-decl-list objc-visibility-spec
6469      objc-instance-variable-decl-list objc-instance-variable-decl ;
6470      objc-instance-variable-decl-list ;
6471
6472    objc-visibility-spec:
6473      @private
6474      @protected
6475      @public
6476
6477    objc-instance-variable-decl:
6478      struct-declaration
6479 */
6480
6481 static void
6482 c_parser_objc_class_instance_variables (c_parser *parser)
6483 {
6484   gcc_assert (c_parser_next_token_is (parser, CPP_OPEN_BRACE));
6485   c_parser_consume_token (parser);
6486   while (c_parser_next_token_is_not (parser, CPP_EOF))
6487     {
6488       tree decls;
6489       /* Parse any stray semicolon.  */
6490       if (c_parser_next_token_is (parser, CPP_SEMICOLON))
6491         {
6492           pedwarn (c_parser_peek_token (parser)->location, OPT_pedantic,
6493                    "extra semicolon in struct or union specified");
6494           c_parser_consume_token (parser);
6495           continue;
6496         }
6497       /* Stop if at the end of the instance variables.  */
6498       if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
6499         {
6500           c_parser_consume_token (parser);
6501           break;
6502         }
6503       /* Parse any objc-visibility-spec.  */
6504       if (c_parser_next_token_is_keyword (parser, RID_AT_PRIVATE))
6505         {
6506           c_parser_consume_token (parser);
6507           objc_set_visibility (2);
6508           continue;
6509         }
6510       else if (c_parser_next_token_is_keyword (parser, RID_AT_PROTECTED))
6511         {
6512           c_parser_consume_token (parser);
6513           objc_set_visibility (0);
6514           continue;
6515         }
6516       else if (c_parser_next_token_is_keyword (parser, RID_AT_PUBLIC))
6517         {
6518           c_parser_consume_token (parser);
6519           objc_set_visibility (1);
6520           continue;
6521         }
6522       else if (c_parser_next_token_is (parser, CPP_PRAGMA))
6523         {
6524           c_parser_pragma (parser, pragma_external);
6525           continue;
6526         }
6527
6528       /* Parse some comma-separated declarations.  */
6529       decls = c_parser_struct_declaration (parser);
6530       {
6531         /* Comma-separated instance variables are chained together in
6532            reverse order; add them one by one.  */
6533         tree ivar = nreverse (decls);
6534         for (; ivar; ivar = DECL_CHAIN (ivar))
6535           objc_add_instance_variable (copy_node (ivar));
6536       }
6537       c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
6538     }
6539 }
6540
6541 /* Parse an objc-class-declaration.
6542
6543    objc-class-declaration:
6544      @class identifier-list ;
6545 */
6546
6547 static void
6548 c_parser_objc_class_declaration (c_parser *parser)
6549 {
6550   tree list = NULL_TREE;
6551   gcc_assert (c_parser_next_token_is_keyword (parser, RID_AT_CLASS));
6552   c_parser_consume_token (parser);
6553   /* Any identifiers, including those declared as type names, are OK
6554      here.  */
6555   while (true)
6556     {
6557       tree id;
6558       if (c_parser_next_token_is_not (parser, CPP_NAME))
6559         {
6560           c_parser_error (parser, "expected identifier");
6561           break;
6562         }
6563       id = c_parser_peek_token (parser)->value;
6564       list = chainon (list, build_tree_list (NULL_TREE, id));
6565       c_parser_consume_token (parser);
6566       if (c_parser_next_token_is (parser, CPP_COMMA))
6567         c_parser_consume_token (parser);
6568       else
6569         break;
6570     }
6571   c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
6572   objc_declare_class (list);
6573 }
6574
6575 /* Parse an objc-alias-declaration.
6576
6577    objc-alias-declaration:
6578      @compatibility_alias identifier identifier ;
6579 */
6580
6581 static void
6582 c_parser_objc_alias_declaration (c_parser *parser)
6583 {
6584   tree id1, id2;
6585   gcc_assert (c_parser_next_token_is_keyword (parser, RID_AT_ALIAS));
6586   c_parser_consume_token (parser);
6587   if (c_parser_next_token_is_not (parser, CPP_NAME))
6588     {
6589       c_parser_error (parser, "expected identifier");
6590       c_parser_skip_until_found (parser, CPP_SEMICOLON, NULL);
6591       return;
6592     }
6593   id1 = c_parser_peek_token (parser)->value;
6594   c_parser_consume_token (parser);
6595   if (c_parser_next_token_is_not (parser, CPP_NAME))
6596     {
6597       c_parser_error (parser, "expected identifier");
6598       c_parser_skip_until_found (parser, CPP_SEMICOLON, NULL);
6599       return;
6600     }
6601   id2 = c_parser_peek_token (parser)->value;
6602   c_parser_consume_token (parser);
6603   c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
6604   objc_declare_alias (id1, id2);
6605 }
6606
6607 /* Parse an objc-protocol-definition.
6608
6609    objc-protocol-definition:
6610      @protocol identifier objc-protocol-refs[opt] objc-methodprotolist @end
6611      @protocol identifier-list ;
6612
6613    "@protocol identifier ;" should be resolved as "@protocol
6614    identifier-list ;": objc-methodprotolist may not start with a
6615    semicolon in the first alternative if objc-protocol-refs are
6616    omitted.  */
6617
6618 static void
6619 c_parser_objc_protocol_definition (c_parser *parser, tree attributes)
6620 {
6621   gcc_assert (c_parser_next_token_is_keyword (parser, RID_AT_PROTOCOL));
6622
6623   c_parser_consume_token (parser);
6624   if (c_parser_next_token_is_not (parser, CPP_NAME))
6625     {
6626       c_parser_error (parser, "expected identifier");
6627       return;
6628     }
6629   if (c_parser_peek_2nd_token (parser)->type == CPP_COMMA
6630       || c_parser_peek_2nd_token (parser)->type == CPP_SEMICOLON)
6631     {
6632       tree list = NULL_TREE;
6633       /* Any identifiers, including those declared as type names, are
6634          OK here.  */
6635       while (true)
6636         {
6637           tree id;
6638           if (c_parser_next_token_is_not (parser, CPP_NAME))
6639             {
6640               c_parser_error (parser, "expected identifier");
6641               break;
6642             }
6643           id = c_parser_peek_token (parser)->value;
6644           list = chainon (list, build_tree_list (NULL_TREE, id));
6645           c_parser_consume_token (parser);
6646           if (c_parser_next_token_is (parser, CPP_COMMA))
6647             c_parser_consume_token (parser);
6648           else
6649             break;
6650         }
6651       c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
6652       objc_declare_protocols (list);
6653     }
6654   else
6655     {
6656       tree id = c_parser_peek_token (parser)->value;
6657       tree proto = NULL_TREE;
6658       c_parser_consume_token (parser);
6659       if (c_parser_next_token_is (parser, CPP_LESS))
6660         proto = c_parser_objc_protocol_refs (parser);
6661       parser->objc_pq_context = true;
6662       objc_start_protocol (id, proto, attributes);
6663       c_parser_objc_methodprotolist (parser);
6664       c_parser_require_keyword (parser, RID_AT_END, "expected %<@end%>");
6665       parser->objc_pq_context = false;
6666       objc_finish_interface ();
6667     }
6668 }
6669
6670 /* Parse an objc-method-type.
6671
6672    objc-method-type:
6673      +
6674      -
6675 */
6676
6677 static enum tree_code
6678 c_parser_objc_method_type (c_parser *parser)
6679 {
6680   switch (c_parser_peek_token (parser)->type)
6681     {
6682     case CPP_PLUS:
6683       c_parser_consume_token (parser);
6684       return PLUS_EXPR;
6685     case CPP_MINUS:
6686       c_parser_consume_token (parser);
6687       return MINUS_EXPR;
6688     default:
6689       gcc_unreachable ();
6690     }
6691 }
6692
6693 /* Parse an objc-method-definition.
6694
6695    objc-method-definition:
6696      objc-method-type objc-method-decl ;[opt] compound-statement
6697 */
6698
6699 static void
6700 c_parser_objc_method_definition (c_parser *parser)
6701 {
6702   enum tree_code type = c_parser_objc_method_type (parser);
6703   tree decl, attributes = NULL_TREE;
6704   objc_set_method_type (type);
6705   parser->objc_pq_context = true;
6706   decl = c_parser_objc_method_decl (parser, &attributes);
6707   if (decl == error_mark_node)
6708     return;  /* Bail here. */
6709
6710   if (c_parser_next_token_is (parser, CPP_SEMICOLON))
6711     {
6712       c_parser_consume_token (parser);
6713       pedwarn (c_parser_peek_token (parser)->location, OPT_pedantic,
6714                "extra semicolon in method definition specified");
6715     }
6716
6717   if (!c_parser_next_token_is (parser, CPP_OPEN_BRACE))
6718     {
6719       c_parser_error (parser, "expected %<{%>");
6720       return;
6721     }
6722
6723   parser->objc_pq_context = false;
6724   if (objc_start_method_definition (decl, attributes))
6725     {
6726       add_stmt (c_parser_compound_statement (parser));
6727       objc_finish_method_definition (current_function_decl);
6728     }
6729   else
6730     {
6731       /* This code is executed when we find a method definition
6732          outside of an @implementation context.  Parse the method (to
6733          keep going) but do not emit any code.
6734       */
6735       c_parser_compound_statement (parser);
6736     }
6737 }
6738
6739 /* Parse an objc-methodprotolist.
6740
6741    objc-methodprotolist:
6742      empty
6743      objc-methodprotolist objc-methodproto
6744      objc-methodprotolist declaration
6745      objc-methodprotolist ;
6746
6747    The declaration is a data definition, which may be missing
6748    declaration specifiers under the same rules and diagnostics as
6749    other data definitions outside functions, and the stray semicolon
6750    is diagnosed the same way as a stray semicolon outside a
6751    function.  */
6752
6753 static void
6754 c_parser_objc_methodprotolist (c_parser *parser)
6755 {
6756   while (true)
6757     {
6758       /* The list is terminated by @end.  */
6759       switch (c_parser_peek_token (parser)->type)
6760         {
6761         case CPP_SEMICOLON:
6762           pedwarn (c_parser_peek_token (parser)->location, OPT_pedantic,
6763                    "ISO C does not allow extra %<;%> outside of a function");
6764           c_parser_consume_token (parser);
6765           break;
6766         case CPP_PLUS:
6767         case CPP_MINUS:
6768           c_parser_objc_methodproto (parser);
6769           break;
6770         case CPP_PRAGMA:
6771           c_parser_pragma (parser, pragma_external);
6772           break;
6773         case CPP_EOF:
6774           return;
6775         default:
6776           if (c_parser_next_token_is_keyword (parser, RID_AT_END))
6777             return;
6778           c_parser_declaration_or_fndef (parser, false, false, true,
6779                                          false, true);
6780           break;
6781         }
6782     }
6783 }
6784
6785 /* Parse an objc-methodproto.
6786
6787    objc-methodproto:
6788      objc-method-type objc-method-decl ;
6789 */
6790
6791 static void
6792 c_parser_objc_methodproto (c_parser *parser)
6793 {
6794   enum tree_code type = c_parser_objc_method_type (parser);
6795   tree decl, attributes = NULL_TREE;
6796   objc_set_method_type (type);
6797   /* Remember protocol qualifiers in prototypes.  */
6798   parser->objc_pq_context = true;
6799   decl = c_parser_objc_method_decl (parser, &attributes);
6800   /* Forget protocol qualifiers now.  */
6801   parser->objc_pq_context = false;
6802
6803   /* Do not allow the presence of attributes to hide an erroneous
6804      method implementation in the interface section.  */
6805   if (!c_parser_next_token_is (parser, CPP_SEMICOLON))
6806     {
6807       c_parser_error (parser, "expected %<;%>");
6808       return;
6809     }
6810
6811   if (decl != error_mark_node)
6812     objc_add_method_declaration (decl, attributes);
6813
6814   c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
6815 }
6816
6817 /* If we are at a position that method attributes may be present, check that
6818    there are not any parsed already (a syntax error) and then collect any
6819    specified at the current location.  Finally, if new attributes were present,
6820    check that the next token is legal ( ';' for decls and '{' for defs).  */
6821
6822 static bool
6823 c_parser_objc_maybe_method_attributes (c_parser* parser, tree* attributes)
6824 {
6825   bool bad = false;
6826   if (*attributes)
6827     {
6828       c_parser_error (parser,
6829                     "method attributes must be specified at the end only");
6830       *attributes = NULL_TREE;
6831       bad = true;
6832     }
6833
6834   if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
6835     *attributes = c_parser_attributes (parser);
6836
6837   /* If there were no attributes here, just report any earlier error.  */
6838   if (*attributes == NULL_TREE || bad)
6839     return bad;
6840
6841   /* If the attributes are followed by a ; or {, then just report any earlier
6842      error.  */
6843   if (c_parser_next_token_is (parser, CPP_SEMICOLON)
6844       || c_parser_next_token_is (parser, CPP_OPEN_BRACE))
6845     return bad;
6846
6847   /* We've got attributes, but not at the end.  */
6848   c_parser_error (parser,
6849                   "expected %<;%> or %<{%> after method attribute definition");
6850   return true;
6851 }
6852
6853 /* Parse an objc-method-decl.
6854
6855    objc-method-decl:
6856      ( objc-type-name ) objc-selector
6857      objc-selector
6858      ( objc-type-name ) objc-keyword-selector objc-optparmlist
6859      objc-keyword-selector objc-optparmlist
6860      attributes
6861
6862    objc-keyword-selector:
6863      objc-keyword-decl
6864      objc-keyword-selector objc-keyword-decl
6865
6866    objc-keyword-decl:
6867      objc-selector : ( objc-type-name ) identifier
6868      objc-selector : identifier
6869      : ( objc-type-name ) identifier
6870      : identifier
6871
6872    objc-optparmlist:
6873      objc-optparms objc-optellipsis
6874
6875    objc-optparms:
6876      empty
6877      objc-opt-parms , parameter-declaration
6878
6879    objc-optellipsis:
6880      empty
6881      , ...
6882 */
6883
6884 static tree
6885 c_parser_objc_method_decl (c_parser *parser, tree *attributes)
6886 {
6887   tree type = NULL_TREE;
6888   tree sel;
6889   tree parms = NULL_TREE;
6890   bool ellipsis = false;
6891   bool attr_err = false;
6892
6893   *attributes = NULL_TREE;
6894   if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
6895     {
6896       c_parser_consume_token (parser);
6897       type = c_parser_objc_type_name (parser);
6898       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
6899     }
6900   sel = c_parser_objc_selector (parser);
6901   /* If there is no selector, or a colon follows, we have an
6902      objc-keyword-selector.  If there is a selector, and a colon does
6903      not follow, that selector ends the objc-method-decl.  */
6904   if (!sel || c_parser_next_token_is (parser, CPP_COLON))
6905     {
6906       tree tsel = sel;
6907       tree list = NULL_TREE;
6908       while (true)
6909         {
6910           tree atype = NULL_TREE, id, keyworddecl;
6911           tree param_attr = NULL_TREE;
6912           if (!c_parser_require (parser, CPP_COLON, "expected %<:%>"))
6913             break;
6914           if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
6915             {
6916               c_parser_consume_token (parser);
6917               atype = c_parser_objc_type_name (parser);
6918               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
6919                                          "expected %<)%>");
6920             }
6921           /* New ObjC allows attributes on method parameters.  */
6922           if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
6923             param_attr = c_parser_attributes (parser);
6924           if (c_parser_next_token_is_not (parser, CPP_NAME))
6925             {
6926               c_parser_error (parser, "expected identifier");
6927               return error_mark_node;
6928             }
6929           id = c_parser_peek_token (parser)->value;
6930           c_parser_consume_token (parser);
6931           keyworddecl = objc_build_keyword_decl (tsel, atype, id, param_attr);
6932           list = chainon (list, keyworddecl);
6933           tsel = c_parser_objc_selector (parser);
6934           if (!tsel && c_parser_next_token_is_not (parser, CPP_COLON))
6935             break;
6936         }
6937
6938       attr_err |= c_parser_objc_maybe_method_attributes (parser, attributes) ;
6939
6940       /* Parse the optional parameter list.  Optional Objective-C
6941          method parameters follow the C syntax, and may include '...'
6942          to denote a variable number of arguments.  */
6943       parms = make_node (TREE_LIST);
6944       while (c_parser_next_token_is (parser, CPP_COMMA))
6945         {
6946           struct c_parm *parm;
6947           c_parser_consume_token (parser);
6948           if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
6949             {
6950               ellipsis = true;
6951               c_parser_consume_token (parser);
6952               attr_err |= c_parser_objc_maybe_method_attributes
6953                                                 (parser, attributes) ;
6954               break;
6955             }
6956           parm = c_parser_parameter_declaration (parser, NULL_TREE);
6957           if (parm == NULL)
6958             break;
6959           parms = chainon (parms,
6960                            build_tree_list (NULL_TREE, grokparm (parm)));
6961         }
6962       sel = list;
6963     }
6964   else
6965     attr_err |= c_parser_objc_maybe_method_attributes (parser, attributes) ;
6966
6967   if (sel == NULL)
6968     {
6969       c_parser_error (parser, "objective-c method declaration is expected");
6970       return error_mark_node;
6971     }
6972
6973   if (attr_err)
6974     return error_mark_node;
6975
6976   return objc_build_method_signature (type, sel, parms, ellipsis);
6977 }
6978
6979 /* Parse an objc-type-name.
6980
6981    objc-type-name:
6982      objc-type-qualifiers[opt] type-name
6983      objc-type-qualifiers[opt]
6984
6985    objc-type-qualifiers:
6986      objc-type-qualifier
6987      objc-type-qualifiers objc-type-qualifier
6988
6989    objc-type-qualifier: one of
6990      in out inout bycopy byref oneway
6991 */
6992
6993 static tree
6994 c_parser_objc_type_name (c_parser *parser)
6995 {
6996   tree quals = NULL_TREE;
6997   struct c_type_name *type_name = NULL;
6998   tree type = NULL_TREE;
6999   while (true)
7000     {
7001       c_token *token = c_parser_peek_token (parser);
7002       if (token->type == CPP_KEYWORD
7003           && (token->keyword == RID_IN
7004               || token->keyword == RID_OUT
7005               || token->keyword == RID_INOUT
7006               || token->keyword == RID_BYCOPY
7007               || token->keyword == RID_BYREF
7008               || token->keyword == RID_ONEWAY))
7009         {
7010           quals = chainon (quals, build_tree_list (NULL_TREE, token->value));
7011           c_parser_consume_token (parser);
7012         }
7013       else
7014         break;
7015     }
7016   if (c_parser_next_token_starts_typename (parser))
7017     type_name = c_parser_type_name (parser);
7018   if (type_name)
7019     type = groktypename (type_name, NULL, NULL);
7020   return build_tree_list (quals, type);
7021 }
7022
7023 /* Parse objc-protocol-refs.
7024
7025    objc-protocol-refs:
7026      < identifier-list >
7027 */
7028
7029 static tree
7030 c_parser_objc_protocol_refs (c_parser *parser)
7031 {
7032   tree list = NULL_TREE;
7033   gcc_assert (c_parser_next_token_is (parser, CPP_LESS));
7034   c_parser_consume_token (parser);
7035   /* Any identifiers, including those declared as type names, are OK
7036      here.  */
7037   while (true)
7038     {
7039       tree id;
7040       if (c_parser_next_token_is_not (parser, CPP_NAME))
7041         {
7042           c_parser_error (parser, "expected identifier");
7043           break;
7044         }
7045       id = c_parser_peek_token (parser)->value;
7046       list = chainon (list, build_tree_list (NULL_TREE, id));
7047       c_parser_consume_token (parser);
7048       if (c_parser_next_token_is (parser, CPP_COMMA))
7049         c_parser_consume_token (parser);
7050       else
7051         break;
7052     }
7053   c_parser_require (parser, CPP_GREATER, "expected %<>%>");
7054   return list;
7055 }
7056
7057 /* Parse an objc-try-catch-statement.
7058
7059    objc-try-catch-statement:
7060      @try compound-statement objc-catch-list[opt]
7061      @try compound-statement objc-catch-list[opt] @finally compound-statement
7062
7063    objc-catch-list:
7064      @catch ( parameter-declaration ) compound-statement
7065      objc-catch-list @catch ( parameter-declaration ) compound-statement
7066 */
7067
7068 static void
7069 c_parser_objc_try_catch_statement (c_parser *parser)
7070 {
7071   location_t loc;
7072   tree stmt;
7073   gcc_assert (c_parser_next_token_is_keyword (parser, RID_AT_TRY));
7074   c_parser_consume_token (parser);
7075   loc = c_parser_peek_token (parser)->location;
7076   stmt = c_parser_compound_statement (parser);
7077   objc_begin_try_stmt (loc, stmt);
7078   while (c_parser_next_token_is_keyword (parser, RID_AT_CATCH))
7079     {
7080       struct c_parm *parm;
7081       c_parser_consume_token (parser);
7082       if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
7083         break;
7084       parm = c_parser_parameter_declaration (parser, NULL_TREE);
7085       if (parm == NULL)
7086         {
7087           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
7088           break;
7089         }
7090       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
7091       objc_begin_catch_clause (grokparm (parm));
7092       if (c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>"))
7093         c_parser_compound_statement_nostart (parser);
7094       objc_finish_catch_clause ();
7095     }
7096   if (c_parser_next_token_is_keyword (parser, RID_AT_FINALLY))
7097     {
7098       location_t finloc;
7099       tree finstmt;
7100       c_parser_consume_token (parser);
7101       finloc = c_parser_peek_token (parser)->location;
7102       finstmt = c_parser_compound_statement (parser);
7103       objc_build_finally_clause (finloc, finstmt);
7104     }
7105   objc_finish_try_stmt ();
7106 }
7107
7108 /* Parse an objc-synchronized-statement.
7109
7110    objc-synchronized-statement:
7111      @synchronized ( expression ) compound-statement
7112 */
7113
7114 static void
7115 c_parser_objc_synchronized_statement (c_parser *parser)
7116 {
7117   location_t loc;
7118   tree expr, stmt;
7119   gcc_assert (c_parser_next_token_is_keyword (parser, RID_AT_SYNCHRONIZED));
7120   c_parser_consume_token (parser);
7121   loc = c_parser_peek_token (parser)->location;
7122   if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
7123     {
7124       expr = c_parser_expression (parser).value;
7125       expr = c_fully_fold (expr, false, NULL);
7126       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
7127     }
7128   else
7129     expr = error_mark_node;
7130   stmt = c_parser_compound_statement (parser);
7131   objc_build_synchronized (loc, expr, stmt);
7132 }
7133
7134 /* Parse an objc-selector; return NULL_TREE without an error if the
7135    next token is not an objc-selector.
7136
7137    objc-selector:
7138      identifier
7139      one of
7140        enum struct union if else while do for switch case default
7141        break continue return goto asm sizeof typeof __alignof
7142        unsigned long const short volatile signed restrict _Complex
7143        in out inout bycopy byref oneway int char float double void _Bool
7144
7145    ??? Why this selection of keywords but not, for example, storage
7146    class specifiers?  */
7147
7148 static tree
7149 c_parser_objc_selector (c_parser *parser)
7150 {
7151   c_token *token = c_parser_peek_token (parser);
7152   tree value = token->value;
7153   if (token->type == CPP_NAME)
7154     {
7155       c_parser_consume_token (parser);
7156       return value;
7157     }
7158   if (token->type != CPP_KEYWORD)
7159     return NULL_TREE;
7160   switch (token->keyword)
7161     {
7162     case RID_ENUM:
7163     case RID_STRUCT:
7164     case RID_UNION:
7165     case RID_IF:
7166     case RID_ELSE:
7167     case RID_WHILE:
7168     case RID_DO:
7169     case RID_FOR:
7170     case RID_SWITCH:
7171     case RID_CASE:
7172     case RID_DEFAULT:
7173     case RID_BREAK:
7174     case RID_CONTINUE:
7175     case RID_RETURN:
7176     case RID_GOTO:
7177     case RID_ASM:
7178     case RID_SIZEOF:
7179     case RID_TYPEOF:
7180     case RID_ALIGNOF:
7181     case RID_UNSIGNED:
7182     case RID_LONG:
7183     case RID_INT128:
7184     case RID_CONST:
7185     case RID_SHORT:
7186     case RID_VOLATILE:
7187     case RID_SIGNED:
7188     case RID_RESTRICT:
7189     case RID_COMPLEX:
7190     case RID_IN:
7191     case RID_OUT:
7192     case RID_INOUT:
7193     case RID_BYCOPY:
7194     case RID_BYREF:
7195     case RID_ONEWAY:
7196     case RID_INT:
7197     case RID_CHAR:
7198     case RID_FLOAT:
7199     case RID_DOUBLE:
7200     case RID_VOID:
7201     case RID_BOOL:
7202       c_parser_consume_token (parser);
7203       return value;
7204     default:
7205       return NULL_TREE;
7206     }
7207 }
7208
7209 /* Parse an objc-selector-arg.
7210
7211    objc-selector-arg:
7212      objc-selector
7213      objc-keywordname-list
7214
7215    objc-keywordname-list:
7216      objc-keywordname
7217      objc-keywordname-list objc-keywordname
7218
7219    objc-keywordname:
7220      objc-selector :
7221      :
7222 */
7223
7224 static tree
7225 c_parser_objc_selector_arg (c_parser *parser)
7226 {
7227   tree sel = c_parser_objc_selector (parser);
7228   tree list = NULL_TREE;
7229   if (sel && c_parser_next_token_is_not (parser, CPP_COLON))
7230     return sel;
7231   while (true)
7232     {
7233       if (!c_parser_require (parser, CPP_COLON, "expected %<:%>"))
7234         return list;
7235       list = chainon (list, build_tree_list (sel, NULL_TREE));
7236       sel = c_parser_objc_selector (parser);
7237       if (!sel && c_parser_next_token_is_not (parser, CPP_COLON))
7238         break;
7239     }
7240   return list;
7241 }
7242
7243 /* Parse an objc-receiver.
7244
7245    objc-receiver:
7246      expression
7247      class-name
7248      type-name
7249 */
7250
7251 static tree
7252 c_parser_objc_receiver (c_parser *parser)
7253 {
7254   if (c_parser_peek_token (parser)->type == CPP_NAME
7255       && (c_parser_peek_token (parser)->id_kind == C_ID_TYPENAME
7256           || c_parser_peek_token (parser)->id_kind == C_ID_CLASSNAME))
7257     {
7258       tree id = c_parser_peek_token (parser)->value;
7259       c_parser_consume_token (parser);
7260       return objc_get_class_reference (id);
7261     }
7262   return c_fully_fold (c_parser_expression (parser).value, false, NULL);
7263 }
7264
7265 /* Parse objc-message-args.
7266
7267    objc-message-args:
7268      objc-selector
7269      objc-keywordarg-list
7270
7271    objc-keywordarg-list:
7272      objc-keywordarg
7273      objc-keywordarg-list objc-keywordarg
7274
7275    objc-keywordarg:
7276      objc-selector : objc-keywordexpr
7277      : objc-keywordexpr
7278 */
7279
7280 static tree
7281 c_parser_objc_message_args (c_parser *parser)
7282 {
7283   tree sel = c_parser_objc_selector (parser);
7284   tree list = NULL_TREE;
7285   if (sel && c_parser_next_token_is_not (parser, CPP_COLON))
7286     return sel;
7287   while (true)
7288     {
7289       tree keywordexpr;
7290       if (!c_parser_require (parser, CPP_COLON, "expected %<:%>"))
7291         return error_mark_node;
7292       keywordexpr = c_parser_objc_keywordexpr (parser);
7293       list = chainon (list, build_tree_list (sel, keywordexpr));
7294       sel = c_parser_objc_selector (parser);
7295       if (!sel && c_parser_next_token_is_not (parser, CPP_COLON))
7296         break;
7297     }
7298   return list;
7299 }
7300
7301 /* Parse an objc-keywordexpr.
7302
7303    objc-keywordexpr:
7304      nonempty-expr-list
7305 */
7306
7307 static tree
7308 c_parser_objc_keywordexpr (c_parser *parser)
7309 {
7310   tree ret;
7311   VEC(tree,gc) *expr_list = c_parser_expr_list (parser, true, true, NULL);
7312   if (VEC_length (tree, expr_list) == 1)
7313     {
7314       /* Just return the expression, remove a level of
7315          indirection.  */
7316       ret = VEC_index (tree, expr_list, 0);
7317     }
7318   else
7319     {
7320       /* We have a comma expression, we will collapse later.  */
7321       ret = build_tree_list_vec (expr_list);
7322     }
7323   release_tree_vector (expr_list);
7324   return ret;
7325 }
7326
7327 /* A check, needed in several places, that ObjC interface, implementation or
7328    method definitions are not prefixed by incorrect items.  */
7329 static bool
7330 c_parser_objc_diagnose_bad_element_prefix (c_parser *parser,
7331                                            struct c_declspecs *specs)
7332 {
7333   if (!specs->declspecs_seen_p || specs->type_seen_p || specs->non_sc_seen_p)
7334     {
7335       c_parser_error (parser,
7336                       "no type or storage class may be specified here,");
7337       c_parser_skip_to_end_of_block_or_statement (parser);
7338       return true;
7339     }
7340   return false;
7341 }
7342 \f
7343 /* Handle pragmas.  Some OpenMP pragmas are associated with, and therefore
7344    should be considered, statements.  ALLOW_STMT is true if we're within
7345    the context of a function and such pragmas are to be allowed.  Returns
7346    true if we actually parsed such a pragma.  */
7347
7348 static bool
7349 c_parser_pragma (c_parser *parser, enum pragma_context context)
7350 {
7351   unsigned int id;
7352
7353   id = c_parser_peek_token (parser)->pragma_kind;
7354   gcc_assert (id != PRAGMA_NONE);
7355
7356   switch (id)
7357     {
7358     case PRAGMA_OMP_BARRIER:
7359       if (context != pragma_compound)
7360         {
7361           if (context == pragma_stmt)
7362             c_parser_error (parser, "%<#pragma omp barrier%> may only be "
7363                             "used in compound statements");
7364           goto bad_stmt;
7365         }
7366       c_parser_omp_barrier (parser);
7367       return false;
7368
7369     case PRAGMA_OMP_FLUSH:
7370       if (context != pragma_compound)
7371         {
7372           if (context == pragma_stmt)
7373             c_parser_error (parser, "%<#pragma omp flush%> may only be "
7374                             "used in compound statements");
7375           goto bad_stmt;
7376         }
7377       c_parser_omp_flush (parser);
7378       return false;
7379
7380     case PRAGMA_OMP_TASKWAIT:
7381       if (context != pragma_compound)
7382         {
7383           if (context == pragma_stmt)
7384             c_parser_error (parser, "%<#pragma omp taskwait%> may only be "
7385                             "used in compound statements");
7386           goto bad_stmt;
7387         }
7388       c_parser_omp_taskwait (parser);
7389       return false;
7390
7391     case PRAGMA_OMP_THREADPRIVATE:
7392       c_parser_omp_threadprivate (parser);
7393       return false;
7394
7395     case PRAGMA_OMP_SECTION:
7396       error_at (c_parser_peek_token (parser)->location,
7397                 "%<#pragma omp section%> may only be used in "
7398                 "%<#pragma omp sections%> construct");
7399       c_parser_skip_until_found (parser, CPP_PRAGMA_EOL, NULL);
7400       return false;
7401
7402     case PRAGMA_GCC_PCH_PREPROCESS:
7403       c_parser_error (parser, "%<#pragma GCC pch_preprocess%> must be first");
7404       c_parser_skip_until_found (parser, CPP_PRAGMA_EOL, NULL);
7405       return false;
7406
7407     default:
7408       if (id < PRAGMA_FIRST_EXTERNAL)
7409         {
7410           if (context == pragma_external)
7411             {
7412             bad_stmt:
7413               c_parser_error (parser, "expected declaration specifiers");
7414               c_parser_skip_until_found (parser, CPP_PRAGMA_EOL, NULL);
7415               return false;
7416             }
7417           c_parser_omp_construct (parser);
7418           return true;
7419         }
7420       break;
7421     }
7422
7423   c_parser_consume_pragma (parser);
7424   c_invoke_pragma_handler (id);
7425
7426   /* Skip to EOL, but suppress any error message.  Those will have been
7427      generated by the handler routine through calling error, as opposed
7428      to calling c_parser_error.  */
7429   parser->error = true;
7430   c_parser_skip_to_pragma_eol (parser);
7431
7432   return false;
7433 }
7434
7435 /* The interface the pragma parsers have to the lexer.  */
7436
7437 enum cpp_ttype
7438 pragma_lex (tree *value)
7439 {
7440   c_token *tok = c_parser_peek_token (the_parser);
7441   enum cpp_ttype ret = tok->type;
7442
7443   *value = tok->value;
7444   if (ret == CPP_PRAGMA_EOL || ret == CPP_EOF)
7445     ret = CPP_EOF;
7446   else
7447     {
7448       if (ret == CPP_KEYWORD)
7449         ret = CPP_NAME;
7450       c_parser_consume_token (the_parser);
7451     }
7452
7453   return ret;
7454 }
7455
7456 static void
7457 c_parser_pragma_pch_preprocess (c_parser *parser)
7458 {
7459   tree name = NULL;
7460
7461   c_parser_consume_pragma (parser);
7462   if (c_parser_next_token_is (parser, CPP_STRING))
7463     {
7464       name = c_parser_peek_token (parser)->value;
7465       c_parser_consume_token (parser);
7466     }
7467   else
7468     c_parser_error (parser, "expected string literal");
7469   c_parser_skip_to_pragma_eol (parser);
7470
7471   if (name)
7472     c_common_pch_pragma (parse_in, TREE_STRING_POINTER (name));
7473 }
7474 \f
7475 /* OpenMP 2.5 parsing routines.  */
7476
7477 /* Returns name of the next clause.
7478    If the clause is not recognized PRAGMA_OMP_CLAUSE_NONE is returned and
7479    the token is not consumed.  Otherwise appropriate pragma_omp_clause is
7480    returned and the token is consumed.  */
7481
7482 static pragma_omp_clause
7483 c_parser_omp_clause_name (c_parser *parser)
7484 {
7485   pragma_omp_clause result = PRAGMA_OMP_CLAUSE_NONE;
7486
7487   if (c_parser_next_token_is_keyword (parser, RID_IF))
7488     result = PRAGMA_OMP_CLAUSE_IF;
7489   else if (c_parser_next_token_is_keyword (parser, RID_DEFAULT))
7490     result = PRAGMA_OMP_CLAUSE_DEFAULT;
7491   else if (c_parser_next_token_is (parser, CPP_NAME))
7492     {
7493       const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
7494
7495       switch (p[0])
7496         {
7497         case 'c':
7498           if (!strcmp ("collapse", p))
7499             result = PRAGMA_OMP_CLAUSE_COLLAPSE;
7500           else if (!strcmp ("copyin", p))
7501             result = PRAGMA_OMP_CLAUSE_COPYIN;
7502           else if (!strcmp ("copyprivate", p))
7503             result = PRAGMA_OMP_CLAUSE_COPYPRIVATE;
7504           break;
7505         case 'f':
7506           if (!strcmp ("firstprivate", p))
7507             result = PRAGMA_OMP_CLAUSE_FIRSTPRIVATE;
7508           break;
7509         case 'l':
7510           if (!strcmp ("lastprivate", p))
7511             result = PRAGMA_OMP_CLAUSE_LASTPRIVATE;
7512           break;
7513         case 'n':
7514           if (!strcmp ("nowait", p))
7515             result = PRAGMA_OMP_CLAUSE_NOWAIT;
7516           else if (!strcmp ("num_threads", p))
7517             result = PRAGMA_OMP_CLAUSE_NUM_THREADS;
7518           break;
7519         case 'o':
7520           if (!strcmp ("ordered", p))
7521             result = PRAGMA_OMP_CLAUSE_ORDERED;
7522           break;
7523         case 'p':
7524           if (!strcmp ("private", p))
7525             result = PRAGMA_OMP_CLAUSE_PRIVATE;
7526           break;
7527         case 'r':
7528           if (!strcmp ("reduction", p))
7529             result = PRAGMA_OMP_CLAUSE_REDUCTION;
7530           break;
7531         case 's':
7532           if (!strcmp ("schedule", p))
7533             result = PRAGMA_OMP_CLAUSE_SCHEDULE;
7534           else if (!strcmp ("shared", p))
7535             result = PRAGMA_OMP_CLAUSE_SHARED;
7536           break;
7537         case 'u':
7538           if (!strcmp ("untied", p))
7539             result = PRAGMA_OMP_CLAUSE_UNTIED;
7540           break;
7541         }
7542     }
7543
7544   if (result != PRAGMA_OMP_CLAUSE_NONE)
7545     c_parser_consume_token (parser);
7546
7547   return result;
7548 }
7549
7550 /* Validate that a clause of the given type does not already exist.  */
7551
7552 static void
7553 check_no_duplicate_clause (tree clauses, enum omp_clause_code code,
7554                            const char *name)
7555 {
7556   tree c;
7557
7558   for (c = clauses; c ; c = OMP_CLAUSE_CHAIN (c))
7559     if (OMP_CLAUSE_CODE (c) == code)
7560       {
7561         location_t loc = OMP_CLAUSE_LOCATION (c);
7562         error_at (loc, "too many %qs clauses", name);
7563         break;
7564       }
7565 }
7566
7567 /* OpenMP 2.5:
7568    variable-list:
7569      identifier
7570      variable-list , identifier
7571
7572    If KIND is nonzero, create the appropriate node and install the
7573    decl in OMP_CLAUSE_DECL and add the node to the head of the list.
7574    If KIND is nonzero, CLAUSE_LOC is the location of the clause.
7575
7576    If KIND is zero, create a TREE_LIST with the decl in TREE_PURPOSE;
7577    return the list created.  */
7578
7579 static tree
7580 c_parser_omp_variable_list (c_parser *parser,
7581                             location_t clause_loc,
7582                             enum omp_clause_code kind,
7583                             tree list)
7584 {
7585   if (c_parser_next_token_is_not (parser, CPP_NAME)
7586       || c_parser_peek_token (parser)->id_kind != C_ID_ID)
7587     c_parser_error (parser, "expected identifier");
7588
7589   while (c_parser_next_token_is (parser, CPP_NAME)
7590          && c_parser_peek_token (parser)->id_kind == C_ID_ID)
7591     {
7592       tree t = lookup_name (c_parser_peek_token (parser)->value);
7593
7594       if (t == NULL_TREE)
7595         undeclared_variable (c_parser_peek_token (parser)->location,
7596                              c_parser_peek_token (parser)->value);
7597       else if (t == error_mark_node)
7598         ;
7599       else if (kind != 0)
7600         {
7601           tree u = build_omp_clause (clause_loc, kind);
7602           OMP_CLAUSE_DECL (u) = t;
7603           OMP_CLAUSE_CHAIN (u) = list;
7604           list = u;
7605         }
7606       else
7607         list = tree_cons (t, NULL_TREE, list);
7608
7609       c_parser_consume_token (parser);
7610
7611       if (c_parser_next_token_is_not (parser, CPP_COMMA))
7612         break;
7613
7614       c_parser_consume_token (parser);
7615     }
7616
7617   return list;
7618 }
7619
7620 /* Similarly, but expect leading and trailing parenthesis.  This is a very
7621    common case for omp clauses.  */
7622
7623 static tree
7624 c_parser_omp_var_list_parens (c_parser *parser, enum omp_clause_code kind,
7625                               tree list)
7626 {
7627   /* The clauses location.  */
7628   location_t loc = c_parser_peek_token (parser)->location;
7629
7630   if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
7631     {
7632       list = c_parser_omp_variable_list (parser, loc, kind, list);
7633       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
7634     }
7635   return list;
7636 }
7637
7638 /* OpenMP 3.0:
7639    collapse ( constant-expression ) */
7640
7641 static tree
7642 c_parser_omp_clause_collapse (c_parser *parser, tree list)
7643 {
7644   tree c, num = error_mark_node;
7645   HOST_WIDE_INT n;
7646   location_t loc;
7647
7648   check_no_duplicate_clause (list, OMP_CLAUSE_COLLAPSE, "collapse");
7649
7650   loc = c_parser_peek_token (parser)->location;
7651   if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
7652     {
7653       num = c_parser_expr_no_commas (parser, NULL).value;
7654       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
7655     }
7656   if (num == error_mark_node)
7657     return list;
7658   if (!INTEGRAL_TYPE_P (TREE_TYPE (num))
7659       || !host_integerp (num, 0)
7660       || (n = tree_low_cst (num, 0)) <= 0
7661       || (int) n != n)
7662     {
7663       error_at (loc,
7664                 "collapse argument needs positive constant integer expression");
7665       return list;
7666     }
7667   c = build_omp_clause (loc, OMP_CLAUSE_COLLAPSE);
7668   OMP_CLAUSE_COLLAPSE_EXPR (c) = num;
7669   OMP_CLAUSE_CHAIN (c) = list;
7670   return c;
7671 }
7672
7673 /* OpenMP 2.5:
7674    copyin ( variable-list ) */
7675
7676 static tree
7677 c_parser_omp_clause_copyin (c_parser *parser, tree list)
7678 {
7679   return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_COPYIN, list);
7680 }
7681
7682 /* OpenMP 2.5:
7683    copyprivate ( variable-list ) */
7684
7685 static tree
7686 c_parser_omp_clause_copyprivate (c_parser *parser, tree list)
7687 {
7688   return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_COPYPRIVATE, list);
7689 }
7690
7691 /* OpenMP 2.5:
7692    default ( shared | none ) */
7693
7694 static tree
7695 c_parser_omp_clause_default (c_parser *parser, tree list)
7696 {
7697   enum omp_clause_default_kind kind = OMP_CLAUSE_DEFAULT_UNSPECIFIED;
7698   location_t loc = c_parser_peek_token (parser)->location;
7699   tree c;
7700
7701   if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
7702     return list;
7703   if (c_parser_next_token_is (parser, CPP_NAME))
7704     {
7705       const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
7706
7707       switch (p[0])
7708         {
7709         case 'n':
7710           if (strcmp ("none", p) != 0)
7711             goto invalid_kind;
7712           kind = OMP_CLAUSE_DEFAULT_NONE;
7713           break;
7714
7715         case 's':
7716           if (strcmp ("shared", p) != 0)
7717             goto invalid_kind;
7718           kind = OMP_CLAUSE_DEFAULT_SHARED;
7719           break;
7720
7721         default:
7722           goto invalid_kind;
7723         }
7724
7725       c_parser_consume_token (parser);
7726     }
7727   else
7728     {
7729     invalid_kind:
7730       c_parser_error (parser, "expected %<none%> or %<shared%>");
7731     }
7732   c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
7733
7734   if (kind == OMP_CLAUSE_DEFAULT_UNSPECIFIED)
7735     return list;
7736
7737   check_no_duplicate_clause (list, OMP_CLAUSE_DEFAULT, "default");
7738   c = build_omp_clause (loc, OMP_CLAUSE_DEFAULT);
7739   OMP_CLAUSE_CHAIN (c) = list;
7740   OMP_CLAUSE_DEFAULT_KIND (c) = kind;
7741
7742   return c;
7743 }
7744
7745 /* OpenMP 2.5:
7746    firstprivate ( variable-list ) */
7747
7748 static tree
7749 c_parser_omp_clause_firstprivate (c_parser *parser, tree list)
7750 {
7751   return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_FIRSTPRIVATE, list);
7752 }
7753
7754 /* OpenMP 2.5:
7755    if ( expression ) */
7756
7757 static tree
7758 c_parser_omp_clause_if (c_parser *parser, tree list)
7759 {
7760   location_t loc = c_parser_peek_token (parser)->location;
7761   if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
7762     {
7763       tree t = c_parser_paren_condition (parser);
7764       tree c;
7765
7766       check_no_duplicate_clause (list, OMP_CLAUSE_IF, "if");
7767
7768       c = build_omp_clause (loc, OMP_CLAUSE_IF);
7769       OMP_CLAUSE_IF_EXPR (c) = t;
7770       OMP_CLAUSE_CHAIN (c) = list;
7771       list = c;
7772     }
7773   else
7774     c_parser_error (parser, "expected %<(%>");
7775
7776   return list;
7777 }
7778
7779 /* OpenMP 2.5:
7780    lastprivate ( variable-list ) */
7781
7782 static tree
7783 c_parser_omp_clause_lastprivate (c_parser *parser, tree list)
7784 {
7785   return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_LASTPRIVATE, list);
7786 }
7787
7788 /* OpenMP 2.5:
7789    nowait */
7790
7791 static tree
7792 c_parser_omp_clause_nowait (c_parser *parser ATTRIBUTE_UNUSED, tree list)
7793 {
7794   tree c;
7795   location_t loc = c_parser_peek_token (parser)->location;
7796
7797   check_no_duplicate_clause (list, OMP_CLAUSE_NOWAIT, "nowait");
7798
7799   c = build_omp_clause (loc, OMP_CLAUSE_NOWAIT);
7800   OMP_CLAUSE_CHAIN (c) = list;
7801   return c;
7802 }
7803
7804 /* OpenMP 2.5:
7805    num_threads ( expression ) */
7806
7807 static tree
7808 c_parser_omp_clause_num_threads (c_parser *parser, tree list)
7809 {
7810   location_t num_threads_loc = c_parser_peek_token (parser)->location;
7811   if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
7812     {
7813       location_t expr_loc = c_parser_peek_token (parser)->location;
7814       tree c, t = c_parser_expression (parser).value;
7815       t = c_fully_fold (t, false, NULL);
7816
7817       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
7818
7819       if (!INTEGRAL_TYPE_P (TREE_TYPE (t)))
7820         {
7821           c_parser_error (parser, "expected integer expression");
7822           return list;
7823         }
7824
7825       /* Attempt to statically determine when the number isn't positive.  */
7826       c = fold_build2_loc (expr_loc, LE_EXPR, boolean_type_node, t,
7827                        build_int_cst (TREE_TYPE (t), 0));
7828       if (CAN_HAVE_LOCATION_P (c))
7829         SET_EXPR_LOCATION (c, expr_loc);
7830       if (c == boolean_true_node)
7831         {
7832           warning_at (expr_loc, 0,
7833                       "%<num_threads%> value must be positive");
7834           t = integer_one_node;
7835         }
7836
7837       check_no_duplicate_clause (list, OMP_CLAUSE_NUM_THREADS, "num_threads");
7838
7839       c = build_omp_clause (num_threads_loc, OMP_CLAUSE_NUM_THREADS);
7840       OMP_CLAUSE_NUM_THREADS_EXPR (c) = t;
7841       OMP_CLAUSE_CHAIN (c) = list;
7842       list = c;
7843     }
7844
7845   return list;
7846 }
7847
7848 /* OpenMP 2.5:
7849    ordered */
7850
7851 static tree
7852 c_parser_omp_clause_ordered (c_parser *parser, tree list)
7853 {
7854   tree c;
7855
7856   check_no_duplicate_clause (list, OMP_CLAUSE_ORDERED, "ordered");
7857
7858   c = build_omp_clause (c_parser_peek_token (parser)->location,
7859                         OMP_CLAUSE_ORDERED);
7860   OMP_CLAUSE_CHAIN (c) = list;
7861
7862   return c;
7863 }
7864
7865 /* OpenMP 2.5:
7866    private ( variable-list ) */
7867
7868 static tree
7869 c_parser_omp_clause_private (c_parser *parser, tree list)
7870 {
7871   return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_PRIVATE, list);
7872 }
7873
7874 /* OpenMP 2.5:
7875    reduction ( reduction-operator : variable-list )
7876
7877    reduction-operator:
7878      One of: + * - & ^ | && || */
7879
7880 static tree
7881 c_parser_omp_clause_reduction (c_parser *parser, tree list)
7882 {
7883   location_t clause_loc = c_parser_peek_token (parser)->location;
7884   if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
7885     {
7886       enum tree_code code;
7887
7888       switch (c_parser_peek_token (parser)->type)
7889         {
7890         case CPP_PLUS:
7891           code = PLUS_EXPR;
7892           break;
7893         case CPP_MULT:
7894           code = MULT_EXPR;
7895           break;
7896         case CPP_MINUS:
7897           code = MINUS_EXPR;
7898           break;
7899         case CPP_AND:
7900           code = BIT_AND_EXPR;
7901           break;
7902         case CPP_XOR:
7903           code = BIT_XOR_EXPR;
7904           break;
7905         case CPP_OR:
7906           code = BIT_IOR_EXPR;
7907           break;
7908         case CPP_AND_AND:
7909           code = TRUTH_ANDIF_EXPR;
7910           break;
7911         case CPP_OR_OR:
7912           code = TRUTH_ORIF_EXPR;
7913           break;
7914         default:
7915           c_parser_error (parser,
7916                           "expected %<+%>, %<*%>, %<-%>, %<&%>, "
7917                           "%<^%>, %<|%>, %<&&%>, or %<||%>");
7918           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 0);
7919           return list;
7920         }
7921       c_parser_consume_token (parser);
7922       if (c_parser_require (parser, CPP_COLON, "expected %<:%>"))
7923         {
7924           tree nl, c;
7925
7926           nl = c_parser_omp_variable_list (parser, clause_loc,
7927                                            OMP_CLAUSE_REDUCTION, list);
7928           for (c = nl; c != list; c = OMP_CLAUSE_CHAIN (c))
7929             OMP_CLAUSE_REDUCTION_CODE (c) = code;
7930
7931           list = nl;
7932         }
7933       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
7934     }
7935   return list;
7936 }
7937
7938 /* OpenMP 2.5:
7939    schedule ( schedule-kind )
7940    schedule ( schedule-kind , expression )
7941
7942    schedule-kind:
7943      static | dynamic | guided | runtime | auto
7944 */
7945
7946 static tree
7947 c_parser_omp_clause_schedule (c_parser *parser, tree list)
7948 {
7949   tree c, t;
7950   location_t loc = c_parser_peek_token (parser)->location;
7951
7952   if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
7953     return list;
7954
7955   c = build_omp_clause (loc, OMP_CLAUSE_SCHEDULE);
7956
7957   if (c_parser_next_token_is (parser, CPP_NAME))
7958     {
7959       tree kind = c_parser_peek_token (parser)->value;
7960       const char *p = IDENTIFIER_POINTER (kind);
7961
7962       switch (p[0])
7963         {
7964         case 'd':
7965           if (strcmp ("dynamic", p) != 0)
7966             goto invalid_kind;
7967           OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_DYNAMIC;
7968           break;
7969
7970         case 'g':
7971           if (strcmp ("guided", p) != 0)
7972             goto invalid_kind;
7973           OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_GUIDED;
7974           break;
7975
7976         case 'r':
7977           if (strcmp ("runtime", p) != 0)
7978             goto invalid_kind;
7979           OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_RUNTIME;
7980           break;
7981
7982         default:
7983           goto invalid_kind;
7984         }
7985     }
7986   else if (c_parser_next_token_is_keyword (parser, RID_STATIC))
7987     OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_STATIC;
7988   else if (c_parser_next_token_is_keyword (parser, RID_AUTO))
7989     OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_AUTO;
7990   else
7991     goto invalid_kind;
7992
7993   c_parser_consume_token (parser);
7994   if (c_parser_next_token_is (parser, CPP_COMMA))
7995     {
7996       location_t here;
7997       c_parser_consume_token (parser);
7998
7999       here = c_parser_peek_token (parser)->location;
8000       t = c_parser_expr_no_commas (parser, NULL).value;
8001       t = c_fully_fold (t, false, NULL);
8002
8003       if (OMP_CLAUSE_SCHEDULE_KIND (c) == OMP_CLAUSE_SCHEDULE_RUNTIME)
8004         error_at (here, "schedule %<runtime%> does not take "
8005                   "a %<chunk_size%> parameter");
8006       else if (OMP_CLAUSE_SCHEDULE_KIND (c) == OMP_CLAUSE_SCHEDULE_AUTO)
8007         error_at (here,
8008                   "schedule %<auto%> does not take "
8009                   "a %<chunk_size%> parameter");
8010       else if (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE)
8011         OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c) = t;
8012       else
8013         c_parser_error (parser, "expected integer expression");
8014
8015       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
8016     }
8017   else
8018     c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
8019                                "expected %<,%> or %<)%>");
8020
8021   check_no_duplicate_clause (list, OMP_CLAUSE_SCHEDULE, "schedule");
8022   OMP_CLAUSE_CHAIN (c) = list;
8023   return c;
8024
8025  invalid_kind:
8026   c_parser_error (parser, "invalid schedule kind");
8027   c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 0);
8028   return list;
8029 }
8030
8031 /* OpenMP 2.5:
8032    shared ( variable-list ) */
8033
8034 static tree
8035 c_parser_omp_clause_shared (c_parser *parser, tree list)
8036 {
8037   return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_SHARED, list);
8038 }
8039
8040 /* OpenMP 3.0:
8041    untied */
8042
8043 static tree
8044 c_parser_omp_clause_untied (c_parser *parser ATTRIBUTE_UNUSED, tree list)
8045 {
8046   tree c;
8047
8048   /* FIXME: Should we allow duplicates?  */
8049   check_no_duplicate_clause (list, OMP_CLAUSE_UNTIED, "untied");
8050
8051   c = build_omp_clause (c_parser_peek_token (parser)->location,
8052                         OMP_CLAUSE_UNTIED);
8053   OMP_CLAUSE_CHAIN (c) = list;
8054
8055   return c;
8056 }
8057
8058 /* Parse all OpenMP clauses.  The set clauses allowed by the directive
8059    is a bitmask in MASK.  Return the list of clauses found; the result
8060    of clause default goes in *pdefault.  */
8061
8062 static tree
8063 c_parser_omp_all_clauses (c_parser *parser, unsigned int mask,
8064                           const char *where)
8065 {
8066   tree clauses = NULL;
8067   bool first = true;
8068
8069   while (c_parser_next_token_is_not (parser, CPP_PRAGMA_EOL))
8070     {
8071       location_t here;
8072       pragma_omp_clause c_kind;
8073       const char *c_name;
8074       tree prev = clauses;
8075
8076       if (!first && c_parser_next_token_is (parser, CPP_COMMA))
8077         c_parser_consume_token (parser);
8078
8079       first = false;
8080       here = c_parser_peek_token (parser)->location;
8081       c_kind = c_parser_omp_clause_name (parser);
8082
8083       switch (c_kind)
8084         {
8085         case PRAGMA_OMP_CLAUSE_COLLAPSE:
8086           clauses = c_parser_omp_clause_collapse (parser, clauses);
8087           c_name = "collapse";
8088           break;
8089         case PRAGMA_OMP_CLAUSE_COPYIN:
8090           clauses = c_parser_omp_clause_copyin (parser, clauses);
8091           c_name = "copyin";
8092           break;
8093         case PRAGMA_OMP_CLAUSE_COPYPRIVATE:
8094           clauses = c_parser_omp_clause_copyprivate (parser, clauses);
8095           c_name = "copyprivate";
8096           break;
8097         case PRAGMA_OMP_CLAUSE_DEFAULT:
8098           clauses = c_parser_omp_clause_default (parser, clauses);
8099           c_name = "default";
8100           break;
8101         case PRAGMA_OMP_CLAUSE_FIRSTPRIVATE:
8102           clauses = c_parser_omp_clause_firstprivate (parser, clauses);
8103           c_name = "firstprivate";
8104           break;
8105         case PRAGMA_OMP_CLAUSE_IF:
8106           clauses = c_parser_omp_clause_if (parser, clauses);
8107           c_name = "if";
8108           break;
8109         case PRAGMA_OMP_CLAUSE_LASTPRIVATE:
8110           clauses = c_parser_omp_clause_lastprivate (parser, clauses);
8111           c_name = "lastprivate";
8112           break;
8113         case PRAGMA_OMP_CLAUSE_NOWAIT:
8114           clauses = c_parser_omp_clause_nowait (parser, clauses);
8115           c_name = "nowait";
8116           break;
8117         case PRAGMA_OMP_CLAUSE_NUM_THREADS:
8118           clauses = c_parser_omp_clause_num_threads (parser, clauses);
8119           c_name = "num_threads";
8120           break;
8121         case PRAGMA_OMP_CLAUSE_ORDERED:
8122           clauses = c_parser_omp_clause_ordered (parser, clauses);
8123           c_name = "ordered";
8124           break;
8125         case PRAGMA_OMP_CLAUSE_PRIVATE:
8126           clauses = c_parser_omp_clause_private (parser, clauses);
8127           c_name = "private";
8128           break;
8129         case PRAGMA_OMP_CLAUSE_REDUCTION:
8130           clauses = c_parser_omp_clause_reduction (parser, clauses);
8131           c_name = "reduction";
8132           break;
8133         case PRAGMA_OMP_CLAUSE_SCHEDULE:
8134           clauses = c_parser_omp_clause_schedule (parser, clauses);
8135           c_name = "schedule";
8136           break;
8137         case PRAGMA_OMP_CLAUSE_SHARED:
8138           clauses = c_parser_omp_clause_shared (parser, clauses);
8139           c_name = "shared";
8140           break;
8141         case PRAGMA_OMP_CLAUSE_UNTIED:
8142           clauses = c_parser_omp_clause_untied (parser, clauses);
8143           c_name = "untied";
8144           break;
8145         default:
8146           c_parser_error (parser, "expected %<#pragma omp%> clause");
8147           goto saw_error;
8148         }
8149
8150       if (((mask >> c_kind) & 1) == 0 && !parser->error)
8151         {
8152           /* Remove the invalid clause(s) from the list to avoid
8153              confusing the rest of the compiler.  */
8154           clauses = prev;
8155           error_at (here, "%qs is not valid for %qs", c_name, where);
8156         }
8157     }
8158
8159  saw_error:
8160   c_parser_skip_to_pragma_eol (parser);
8161
8162   return c_finish_omp_clauses (clauses);
8163 }
8164
8165 /* OpenMP 2.5:
8166    structured-block:
8167      statement
8168
8169    In practice, we're also interested in adding the statement to an
8170    outer node.  So it is convenient if we work around the fact that
8171    c_parser_statement calls add_stmt.  */
8172
8173 static tree
8174 c_parser_omp_structured_block (c_parser *parser)
8175 {
8176   tree stmt = push_stmt_list ();
8177   c_parser_statement (parser);
8178   return pop_stmt_list (stmt);
8179 }
8180
8181 /* OpenMP 2.5:
8182    # pragma omp atomic new-line
8183      expression-stmt
8184
8185    expression-stmt:
8186      x binop= expr | x++ | ++x | x-- | --x
8187    binop:
8188      +, *, -, /, &, ^, |, <<, >>
8189
8190   where x is an lvalue expression with scalar type.
8191
8192   LOC is the location of the #pragma token.  */
8193
8194 static void
8195 c_parser_omp_atomic (location_t loc, c_parser *parser)
8196 {
8197   tree lhs, rhs;
8198   tree stmt;
8199   enum tree_code code;
8200   struct c_expr rhs_expr;
8201
8202   c_parser_skip_to_pragma_eol (parser);
8203
8204   lhs = c_parser_unary_expression (parser).value;
8205   lhs = c_fully_fold (lhs, false, NULL);
8206   switch (TREE_CODE (lhs))
8207     {
8208     case ERROR_MARK:
8209     saw_error:
8210       c_parser_skip_to_end_of_block_or_statement (parser);
8211       return;
8212
8213     case PREINCREMENT_EXPR:
8214     case POSTINCREMENT_EXPR:
8215       lhs = TREE_OPERAND (lhs, 0);
8216       code = PLUS_EXPR;
8217       rhs = integer_one_node;
8218       break;
8219
8220     case PREDECREMENT_EXPR:
8221     case POSTDECREMENT_EXPR:
8222       lhs = TREE_OPERAND (lhs, 0);
8223       code = MINUS_EXPR;
8224       rhs = integer_one_node;
8225       break;
8226
8227     case COMPOUND_EXPR:
8228       if (TREE_CODE (TREE_OPERAND (lhs, 0)) == SAVE_EXPR
8229           && TREE_CODE (TREE_OPERAND (lhs, 1)) == COMPOUND_EXPR
8230           && TREE_CODE (TREE_OPERAND (TREE_OPERAND (lhs, 1), 0)) == MODIFY_EXPR
8231           && TREE_OPERAND (TREE_OPERAND (lhs, 1), 1) == TREE_OPERAND (lhs, 0)
8232           && TREE_CODE (TREE_TYPE (TREE_OPERAND (TREE_OPERAND
8233                                               (TREE_OPERAND (lhs, 1), 0), 0)))
8234              == BOOLEAN_TYPE)
8235         /* Undo effects of boolean_increment for post {in,de}crement.  */
8236         lhs = TREE_OPERAND (TREE_OPERAND (lhs, 1), 0);
8237       /* FALLTHRU */
8238     case MODIFY_EXPR:
8239       if (TREE_CODE (lhs) == MODIFY_EXPR
8240           && TREE_CODE (TREE_TYPE (TREE_OPERAND (lhs, 0))) == BOOLEAN_TYPE)
8241         {
8242           /* Undo effects of boolean_increment.  */
8243           if (integer_onep (TREE_OPERAND (lhs, 1)))
8244             {
8245               /* This is pre or post increment.  */
8246               rhs = TREE_OPERAND (lhs, 1);
8247               lhs = TREE_OPERAND (lhs, 0);
8248               code = NOP_EXPR;
8249               break;
8250             }
8251           if (TREE_CODE (TREE_OPERAND (lhs, 1)) == TRUTH_NOT_EXPR
8252               && TREE_OPERAND (lhs, 0)
8253                  == TREE_OPERAND (TREE_OPERAND (lhs, 1), 0))
8254             {
8255               /* This is pre or post decrement.  */
8256               rhs = TREE_OPERAND (lhs, 1);
8257               lhs = TREE_OPERAND (lhs, 0);
8258               code = NOP_EXPR;
8259               break;
8260             }
8261         }
8262       /* FALLTHRU */
8263     default:
8264       switch (c_parser_peek_token (parser)->type)
8265         {
8266         case CPP_MULT_EQ:
8267           code = MULT_EXPR;
8268           break;
8269         case CPP_DIV_EQ:
8270           code = TRUNC_DIV_EXPR;
8271           break;
8272         case CPP_PLUS_EQ:
8273           code = PLUS_EXPR;
8274           break;
8275         case CPP_MINUS_EQ:
8276           code = MINUS_EXPR;
8277           break;
8278         case CPP_LSHIFT_EQ:
8279           code = LSHIFT_EXPR;
8280           break;
8281         case CPP_RSHIFT_EQ:
8282           code = RSHIFT_EXPR;
8283           break;
8284         case CPP_AND_EQ:
8285           code = BIT_AND_EXPR;
8286           break;
8287         case CPP_OR_EQ:
8288           code = BIT_IOR_EXPR;
8289           break;
8290         case CPP_XOR_EQ:
8291           code = BIT_XOR_EXPR;
8292           break;
8293         default:
8294           c_parser_error (parser,
8295                           "invalid operator for %<#pragma omp atomic%>");
8296           goto saw_error;
8297         }
8298
8299       c_parser_consume_token (parser);
8300       {
8301         location_t rhs_loc = c_parser_peek_token (parser)->location;
8302         rhs_expr = c_parser_expression (parser);
8303         rhs_expr = default_function_array_read_conversion (rhs_loc, rhs_expr);
8304       }
8305       rhs = rhs_expr.value;
8306       rhs = c_fully_fold (rhs, false, NULL);
8307       break;
8308     }
8309   stmt = c_finish_omp_atomic (loc, code, lhs, rhs);
8310   if (stmt != error_mark_node)
8311     add_stmt (stmt);
8312   c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
8313 }
8314
8315
8316 /* OpenMP 2.5:
8317    # pragma omp barrier new-line
8318 */
8319
8320 static void
8321 c_parser_omp_barrier (c_parser *parser)
8322 {
8323   location_t loc = c_parser_peek_token (parser)->location;
8324   c_parser_consume_pragma (parser);
8325   c_parser_skip_to_pragma_eol (parser);
8326
8327   c_finish_omp_barrier (loc);
8328 }
8329
8330 /* OpenMP 2.5:
8331    # pragma omp critical [(name)] new-line
8332      structured-block
8333
8334   LOC is the location of the #pragma itself.  */
8335
8336 static tree
8337 c_parser_omp_critical (location_t loc, c_parser *parser)
8338 {
8339   tree stmt, name = NULL;
8340
8341   if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
8342     {
8343       c_parser_consume_token (parser);
8344       if (c_parser_next_token_is (parser, CPP_NAME))
8345         {
8346           name = c_parser_peek_token (parser)->value;
8347           c_parser_consume_token (parser);
8348           c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>");
8349         }
8350       else
8351         c_parser_error (parser, "expected identifier");
8352     }
8353   else if (c_parser_next_token_is_not (parser, CPP_PRAGMA_EOL))
8354     c_parser_error (parser, "expected %<(%> or end of line");
8355   c_parser_skip_to_pragma_eol (parser);
8356
8357   stmt = c_parser_omp_structured_block (parser);
8358   return c_finish_omp_critical (loc, stmt, name);
8359 }
8360
8361 /* OpenMP 2.5:
8362    # pragma omp flush flush-vars[opt] new-line
8363
8364    flush-vars:
8365      ( variable-list ) */
8366
8367 static void
8368 c_parser_omp_flush (c_parser *parser)
8369 {
8370   location_t loc = c_parser_peek_token (parser)->location;
8371   c_parser_consume_pragma (parser);
8372   if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
8373     c_parser_omp_var_list_parens (parser, OMP_CLAUSE_ERROR, NULL);
8374   else if (c_parser_next_token_is_not (parser, CPP_PRAGMA_EOL))
8375     c_parser_error (parser, "expected %<(%> or end of line");
8376   c_parser_skip_to_pragma_eol (parser);
8377
8378   c_finish_omp_flush (loc);
8379 }
8380
8381 /* Parse the restricted form of the for statement allowed by OpenMP.
8382    The real trick here is to determine the loop control variable early
8383    so that we can push a new decl if necessary to make it private.
8384    LOC is the location of the OMP in "#pragma omp".  */
8385
8386 static tree
8387 c_parser_omp_for_loop (location_t loc,
8388                        c_parser *parser, tree clauses, tree *par_clauses)
8389 {
8390   tree decl, cond, incr, save_break, save_cont, body, init, stmt, cl;
8391   tree declv, condv, incrv, initv, ret = NULL;
8392   bool fail = false, open_brace_parsed = false;
8393   int i, collapse = 1, nbraces = 0;
8394   location_t for_loc;
8395   VEC(tree,gc) *for_block = make_tree_vector ();
8396
8397   for (cl = clauses; cl; cl = OMP_CLAUSE_CHAIN (cl))
8398     if (OMP_CLAUSE_CODE (cl) == OMP_CLAUSE_COLLAPSE)
8399       collapse = tree_low_cst (OMP_CLAUSE_COLLAPSE_EXPR (cl), 0);
8400
8401   gcc_assert (collapse >= 1);
8402
8403   declv = make_tree_vec (collapse);
8404   initv = make_tree_vec (collapse);
8405   condv = make_tree_vec (collapse);
8406   incrv = make_tree_vec (collapse);
8407
8408   if (!c_parser_next_token_is_keyword (parser, RID_FOR))
8409     {
8410       c_parser_error (parser, "for statement expected");
8411       return NULL;
8412     }
8413   for_loc = c_parser_peek_token (parser)->location;
8414   c_parser_consume_token (parser);
8415
8416   for (i = 0; i < collapse; i++)
8417     {
8418       int bracecount = 0;
8419
8420       if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
8421         goto pop_scopes;
8422
8423       /* Parse the initialization declaration or expression.  */
8424       if (c_parser_next_token_starts_declaration (parser))
8425         {
8426           if (i > 0)
8427             VEC_safe_push (tree, gc, for_block, c_begin_compound_stmt (true));
8428           c_parser_declaration_or_fndef (parser, true, true, true, true, true);
8429           decl = check_for_loop_decls (for_loc);
8430           if (decl == NULL)
8431             goto error_init;
8432           if (DECL_INITIAL (decl) == error_mark_node)
8433             decl = error_mark_node;
8434           init = decl;
8435         }
8436       else if (c_parser_next_token_is (parser, CPP_NAME)
8437                && c_parser_peek_2nd_token (parser)->type == CPP_EQ)
8438         {
8439           struct c_expr decl_exp;
8440           struct c_expr init_exp;
8441           location_t init_loc;
8442
8443           decl_exp = c_parser_postfix_expression (parser);
8444           decl = decl_exp.value;
8445
8446           c_parser_require (parser, CPP_EQ, "expected %<=%>");
8447
8448           init_loc = c_parser_peek_token (parser)->location;
8449           init_exp = c_parser_expr_no_commas (parser, NULL);
8450           init_exp = default_function_array_read_conversion (init_loc,
8451                                                              init_exp);
8452           init = build_modify_expr (init_loc, decl, decl_exp.original_type,
8453                                     NOP_EXPR, init_loc, init_exp.value,
8454                                     init_exp.original_type);
8455           init = c_process_expr_stmt (init_loc, init);
8456
8457           c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
8458         }
8459       else
8460         {
8461         error_init:
8462           c_parser_error (parser,
8463                           "expected iteration declaration or initialization");
8464           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
8465                                      "expected %<)%>");
8466           fail = true;
8467           goto parse_next;
8468         }
8469
8470       /* Parse the loop condition.  */
8471       cond = NULL_TREE;
8472       if (c_parser_next_token_is_not (parser, CPP_SEMICOLON))
8473         {
8474           location_t cond_loc = c_parser_peek_token (parser)->location;
8475           struct c_expr cond_expr = c_parser_binary_expression (parser, NULL);
8476
8477           cond = cond_expr.value;
8478           cond = c_objc_common_truthvalue_conversion (cond_loc, cond);
8479           cond = c_fully_fold (cond, false, NULL);
8480           switch (cond_expr.original_code)
8481             {
8482             case GT_EXPR:
8483             case GE_EXPR:
8484             case LT_EXPR:
8485             case LE_EXPR:
8486               break;
8487             default:
8488               /* Can't be cond = error_mark_node, because we want to preserve
8489                  the location until c_finish_omp_for.  */
8490               cond = build1 (NOP_EXPR, boolean_type_node, error_mark_node);
8491               break;
8492             }
8493           protected_set_expr_location (cond, cond_loc);
8494         }
8495       c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
8496
8497       /* Parse the increment expression.  */
8498       incr = NULL_TREE;
8499       if (c_parser_next_token_is_not (parser, CPP_CLOSE_PAREN))
8500         {
8501           location_t incr_loc = c_parser_peek_token (parser)->location;
8502
8503           incr = c_process_expr_stmt (incr_loc,
8504                                       c_parser_expression (parser).value);
8505         }
8506       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
8507
8508       if (decl == NULL || decl == error_mark_node || init == error_mark_node)
8509         fail = true;
8510       else
8511         {
8512           TREE_VEC_ELT (declv, i) = decl;
8513           TREE_VEC_ELT (initv, i) = init;
8514           TREE_VEC_ELT (condv, i) = cond;
8515           TREE_VEC_ELT (incrv, i) = incr;
8516         }
8517
8518     parse_next:
8519       if (i == collapse - 1)
8520         break;
8521
8522       /* FIXME: OpenMP 3.0 draft isn't very clear on what exactly is allowed
8523          in between the collapsed for loops to be still considered perfectly
8524          nested.  Hopefully the final version clarifies this.
8525          For now handle (multiple) {'s and empty statements.  */
8526       do
8527         {
8528           if (c_parser_next_token_is_keyword (parser, RID_FOR))
8529             {
8530               c_parser_consume_token (parser);
8531               break;
8532             }
8533           else if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
8534             {
8535               c_parser_consume_token (parser);
8536               bracecount++;
8537             }
8538           else if (bracecount
8539                    && c_parser_next_token_is (parser, CPP_SEMICOLON))
8540             c_parser_consume_token (parser);
8541           else
8542             {
8543               c_parser_error (parser, "not enough perfectly nested loops");
8544               if (bracecount)
8545                 {
8546                   open_brace_parsed = true;
8547                   bracecount--;
8548                 }
8549               fail = true;
8550               collapse = 0;
8551               break;
8552             }
8553         }
8554       while (1);
8555
8556       nbraces += bracecount;
8557     }
8558
8559   save_break = c_break_label;
8560   c_break_label = size_one_node;
8561   save_cont = c_cont_label;
8562   c_cont_label = NULL_TREE;
8563   body = push_stmt_list ();
8564
8565   if (open_brace_parsed)
8566     {
8567       location_t here = c_parser_peek_token (parser)->location;
8568       stmt = c_begin_compound_stmt (true);
8569       c_parser_compound_statement_nostart (parser);
8570       add_stmt (c_end_compound_stmt (here, stmt, true));
8571     }
8572   else
8573     add_stmt (c_parser_c99_block_statement (parser));
8574   if (c_cont_label)
8575     {
8576       tree t = build1 (LABEL_EXPR, void_type_node, c_cont_label);
8577       SET_EXPR_LOCATION (t, loc);
8578       add_stmt (t);
8579     }
8580
8581   body = pop_stmt_list (body);
8582   c_break_label = save_break;
8583   c_cont_label = save_cont;
8584
8585   while (nbraces)
8586     {
8587       if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
8588         {
8589           c_parser_consume_token (parser);
8590           nbraces--;
8591         }
8592       else if (c_parser_next_token_is (parser, CPP_SEMICOLON))
8593         c_parser_consume_token (parser);
8594       else
8595         {
8596           c_parser_error (parser, "collapsed loops not perfectly nested");
8597           while (nbraces)
8598             {
8599               location_t here = c_parser_peek_token (parser)->location;
8600               stmt = c_begin_compound_stmt (true);
8601               add_stmt (body);
8602               c_parser_compound_statement_nostart (parser);
8603               body = c_end_compound_stmt (here, stmt, true);
8604               nbraces--;
8605             }
8606           goto pop_scopes;
8607         }
8608     }
8609
8610   /* Only bother calling c_finish_omp_for if we haven't already generated
8611      an error from the initialization parsing.  */
8612   if (!fail)
8613     {
8614       stmt = c_finish_omp_for (loc, declv, initv, condv, incrv, body, NULL);
8615       if (stmt)
8616         {
8617           if (par_clauses != NULL)
8618             {
8619               tree *c;
8620               for (c = par_clauses; *c ; )
8621                 if (OMP_CLAUSE_CODE (*c) != OMP_CLAUSE_FIRSTPRIVATE
8622                     && OMP_CLAUSE_CODE (*c) != OMP_CLAUSE_LASTPRIVATE)
8623                   c = &OMP_CLAUSE_CHAIN (*c);
8624                 else
8625                   {
8626                     for (i = 0; i < collapse; i++)
8627                       if (TREE_VEC_ELT (declv, i) == OMP_CLAUSE_DECL (*c))
8628                         break;
8629                     if (i == collapse)
8630                       c = &OMP_CLAUSE_CHAIN (*c);
8631                     else if (OMP_CLAUSE_CODE (*c) == OMP_CLAUSE_FIRSTPRIVATE)
8632                       {
8633                         error_at (loc,
8634                                   "iteration variable %qD should not be firstprivate",
8635                                   OMP_CLAUSE_DECL (*c));
8636                         *c = OMP_CLAUSE_CHAIN (*c);
8637                       }
8638                     else
8639                       {
8640                         /* Copy lastprivate (decl) clause to OMP_FOR_CLAUSES,
8641                            change it to shared (decl) in
8642                            OMP_PARALLEL_CLAUSES.  */
8643                         tree l = build_omp_clause (OMP_CLAUSE_LOCATION (*c),
8644                                                    OMP_CLAUSE_LASTPRIVATE);
8645                         OMP_CLAUSE_DECL (l) = OMP_CLAUSE_DECL (*c);
8646                         OMP_CLAUSE_CHAIN (l) = clauses;
8647                         clauses = l;
8648                         OMP_CLAUSE_SET_CODE (*c, OMP_CLAUSE_SHARED);
8649                       }
8650                   }
8651             }
8652           OMP_FOR_CLAUSES (stmt) = clauses;
8653         }
8654       ret = stmt;
8655     }
8656 pop_scopes:
8657   while (!VEC_empty (tree, for_block))
8658     {
8659       /* FIXME diagnostics: LOC below should be the actual location of
8660          this particular for block.  We need to build a list of
8661          locations to go along with FOR_BLOCK.  */
8662       stmt = c_end_compound_stmt (loc, VEC_pop (tree, for_block), true);
8663       add_stmt (stmt);
8664     }
8665   release_tree_vector (for_block);
8666   return ret;
8667 }
8668
8669 /* OpenMP 2.5:
8670    #pragma omp for for-clause[optseq] new-line
8671      for-loop
8672
8673    LOC is the location of the #pragma token.
8674 */
8675
8676 #define OMP_FOR_CLAUSE_MASK                             \
8677         ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE)             \
8678         | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE)        \
8679         | (1u << PRAGMA_OMP_CLAUSE_LASTPRIVATE)         \
8680         | (1u << PRAGMA_OMP_CLAUSE_REDUCTION)           \
8681         | (1u << PRAGMA_OMP_CLAUSE_ORDERED)             \
8682         | (1u << PRAGMA_OMP_CLAUSE_SCHEDULE)            \
8683         | (1u << PRAGMA_OMP_CLAUSE_COLLAPSE)            \
8684         | (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
8685
8686 static tree
8687 c_parser_omp_for (location_t loc, c_parser *parser)
8688 {
8689   tree block, clauses, ret;
8690
8691   clauses = c_parser_omp_all_clauses (parser, OMP_FOR_CLAUSE_MASK,
8692                                       "#pragma omp for");
8693
8694   block = c_begin_compound_stmt (true);
8695   ret = c_parser_omp_for_loop (loc, parser, clauses, NULL);
8696   block = c_end_compound_stmt (loc, block, true);
8697   add_stmt (block);
8698
8699   return ret;
8700 }
8701
8702 /* OpenMP 2.5:
8703    # pragma omp master new-line
8704      structured-block
8705
8706    LOC is the location of the #pragma token.
8707 */
8708
8709 static tree
8710 c_parser_omp_master (location_t loc, c_parser *parser)
8711 {
8712   c_parser_skip_to_pragma_eol (parser);
8713   return c_finish_omp_master (loc, c_parser_omp_structured_block (parser));
8714 }
8715
8716 /* OpenMP 2.5:
8717    # pragma omp ordered new-line
8718      structured-block
8719
8720    LOC is the location of the #pragma itself.
8721 */
8722
8723 static tree
8724 c_parser_omp_ordered (location_t loc, c_parser *parser)
8725 {
8726   c_parser_skip_to_pragma_eol (parser);
8727   return c_finish_omp_ordered (loc, c_parser_omp_structured_block (parser));
8728 }
8729
8730 /* OpenMP 2.5:
8731
8732    section-scope:
8733      { section-sequence }
8734
8735    section-sequence:
8736      section-directive[opt] structured-block
8737      section-sequence section-directive structured-block
8738
8739     SECTIONS_LOC is the location of the #pragma omp sections.  */
8740
8741 static tree
8742 c_parser_omp_sections_scope (location_t sections_loc, c_parser *parser)
8743 {
8744   tree stmt, substmt;
8745   bool error_suppress = false;
8746   location_t loc;
8747
8748   loc = c_parser_peek_token (parser)->location;
8749   if (!c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>"))
8750     {
8751       /* Avoid skipping until the end of the block.  */
8752       parser->error = false;
8753       return NULL_TREE;
8754     }
8755
8756   stmt = push_stmt_list ();
8757
8758   if (c_parser_peek_token (parser)->pragma_kind != PRAGMA_OMP_SECTION)
8759     {
8760       substmt = push_stmt_list ();
8761
8762       while (1)
8763         {
8764           c_parser_statement (parser);
8765
8766           if (c_parser_peek_token (parser)->pragma_kind == PRAGMA_OMP_SECTION)
8767             break;
8768           if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
8769             break;
8770           if (c_parser_next_token_is (parser, CPP_EOF))
8771             break;
8772         }
8773
8774       substmt = pop_stmt_list (substmt);
8775       substmt = build1 (OMP_SECTION, void_type_node, substmt);
8776       SET_EXPR_LOCATION (substmt, loc);
8777       add_stmt (substmt);
8778     }
8779
8780   while (1)
8781     {
8782       if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
8783         break;
8784       if (c_parser_next_token_is (parser, CPP_EOF))
8785         break;
8786
8787       loc = c_parser_peek_token (parser)->location;
8788       if (c_parser_peek_token (parser)->pragma_kind == PRAGMA_OMP_SECTION)
8789         {
8790           c_parser_consume_pragma (parser);
8791           c_parser_skip_to_pragma_eol (parser);
8792           error_suppress = false;
8793         }
8794       else if (!error_suppress)
8795         {
8796           error_at (loc, "expected %<#pragma omp section%> or %<}%>");
8797           error_suppress = true;
8798         }
8799
8800       substmt = c_parser_omp_structured_block (parser);
8801       substmt = build1 (OMP_SECTION, void_type_node, substmt);
8802       SET_EXPR_LOCATION (substmt, loc);
8803       add_stmt (substmt);
8804     }
8805   c_parser_skip_until_found (parser, CPP_CLOSE_BRACE,
8806                              "expected %<#pragma omp section%> or %<}%>");
8807
8808   substmt = pop_stmt_list (stmt);
8809
8810   stmt = make_node (OMP_SECTIONS);
8811   SET_EXPR_LOCATION (stmt, sections_loc);
8812   TREE_TYPE (stmt) = void_type_node;
8813   OMP_SECTIONS_BODY (stmt) = substmt;
8814
8815   return add_stmt (stmt);
8816 }
8817
8818 /* OpenMP 2.5:
8819    # pragma omp sections sections-clause[optseq] newline
8820      sections-scope
8821
8822    LOC is the location of the #pragma token.
8823 */
8824
8825 #define OMP_SECTIONS_CLAUSE_MASK                        \
8826         ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE)             \
8827         | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE)        \
8828         | (1u << PRAGMA_OMP_CLAUSE_LASTPRIVATE)         \
8829         | (1u << PRAGMA_OMP_CLAUSE_REDUCTION)           \
8830         | (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
8831
8832 static tree
8833 c_parser_omp_sections (location_t loc, c_parser *parser)
8834 {
8835   tree block, clauses, ret;
8836
8837   clauses = c_parser_omp_all_clauses (parser, OMP_SECTIONS_CLAUSE_MASK,
8838                                       "#pragma omp sections");
8839
8840   block = c_begin_compound_stmt (true);
8841   ret = c_parser_omp_sections_scope (loc, parser);
8842   if (ret)
8843     OMP_SECTIONS_CLAUSES (ret) = clauses;
8844   block = c_end_compound_stmt (loc, block, true);
8845   add_stmt (block);
8846
8847   return ret;
8848 }
8849
8850 /* OpenMP 2.5:
8851    # pragma parallel parallel-clause new-line
8852    # pragma parallel for parallel-for-clause new-line
8853    # pragma parallel sections parallel-sections-clause new-line
8854
8855    LOC is the location of the #pragma token.
8856 */
8857
8858 #define OMP_PARALLEL_CLAUSE_MASK                        \
8859         ( (1u << PRAGMA_OMP_CLAUSE_IF)                  \
8860         | (1u << PRAGMA_OMP_CLAUSE_PRIVATE)             \
8861         | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE)        \
8862         | (1u << PRAGMA_OMP_CLAUSE_DEFAULT)             \
8863         | (1u << PRAGMA_OMP_CLAUSE_SHARED)              \
8864         | (1u << PRAGMA_OMP_CLAUSE_COPYIN)              \
8865         | (1u << PRAGMA_OMP_CLAUSE_REDUCTION)           \
8866         | (1u << PRAGMA_OMP_CLAUSE_NUM_THREADS))
8867
8868 static tree
8869 c_parser_omp_parallel (location_t loc, c_parser *parser)
8870 {
8871   enum pragma_kind p_kind = PRAGMA_OMP_PARALLEL;
8872   const char *p_name = "#pragma omp parallel";
8873   tree stmt, clauses, par_clause, ws_clause, block;
8874   unsigned int mask = OMP_PARALLEL_CLAUSE_MASK;
8875
8876   if (c_parser_next_token_is_keyword (parser, RID_FOR))
8877     {
8878       c_parser_consume_token (parser);
8879       p_kind = PRAGMA_OMP_PARALLEL_FOR;
8880       p_name = "#pragma omp parallel for";
8881       mask |= OMP_FOR_CLAUSE_MASK;
8882       mask &= ~(1u << PRAGMA_OMP_CLAUSE_NOWAIT);
8883     }
8884   else if (c_parser_next_token_is (parser, CPP_NAME))
8885     {
8886       const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
8887       if (strcmp (p, "sections") == 0)
8888         {
8889           c_parser_consume_token (parser);
8890           p_kind = PRAGMA_OMP_PARALLEL_SECTIONS;
8891           p_name = "#pragma omp parallel sections";
8892           mask |= OMP_SECTIONS_CLAUSE_MASK;
8893           mask &= ~(1u << PRAGMA_OMP_CLAUSE_NOWAIT);
8894         }
8895     }
8896
8897   clauses = c_parser_omp_all_clauses (parser, mask, p_name);
8898
8899   switch (p_kind)
8900     {
8901     case PRAGMA_OMP_PARALLEL:
8902       block = c_begin_omp_parallel ();
8903       c_parser_statement (parser);
8904       stmt = c_finish_omp_parallel (loc, clauses, block);
8905       break;
8906
8907     case PRAGMA_OMP_PARALLEL_FOR:
8908       block = c_begin_omp_parallel ();
8909       c_split_parallel_clauses (loc, clauses, &par_clause, &ws_clause);
8910       c_parser_omp_for_loop (loc, parser, ws_clause, &par_clause);
8911       stmt = c_finish_omp_parallel (loc, par_clause, block);
8912       OMP_PARALLEL_COMBINED (stmt) = 1;
8913       break;
8914
8915     case PRAGMA_OMP_PARALLEL_SECTIONS:
8916       block = c_begin_omp_parallel ();
8917       c_split_parallel_clauses (loc, clauses, &par_clause, &ws_clause);
8918       stmt = c_parser_omp_sections_scope (loc, parser);
8919       if (stmt)
8920         OMP_SECTIONS_CLAUSES (stmt) = ws_clause;
8921       stmt = c_finish_omp_parallel (loc, par_clause, block);
8922       OMP_PARALLEL_COMBINED (stmt) = 1;
8923       break;
8924
8925     default:
8926       gcc_unreachable ();
8927     }
8928
8929   return stmt;
8930 }
8931
8932 /* OpenMP 2.5:
8933    # pragma omp single single-clause[optseq] new-line
8934      structured-block
8935
8936    LOC is the location of the #pragma.
8937 */
8938
8939 #define OMP_SINGLE_CLAUSE_MASK                          \
8940         ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE)             \
8941         | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE)        \
8942         | (1u << PRAGMA_OMP_CLAUSE_COPYPRIVATE)         \
8943         | (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
8944
8945 static tree
8946 c_parser_omp_single (location_t loc, c_parser *parser)
8947 {
8948   tree stmt = make_node (OMP_SINGLE);
8949   SET_EXPR_LOCATION (stmt, loc);
8950   TREE_TYPE (stmt) = void_type_node;
8951
8952   OMP_SINGLE_CLAUSES (stmt)
8953     = c_parser_omp_all_clauses (parser, OMP_SINGLE_CLAUSE_MASK,
8954                                 "#pragma omp single");
8955   OMP_SINGLE_BODY (stmt) = c_parser_omp_structured_block (parser);
8956
8957   return add_stmt (stmt);
8958 }
8959
8960 /* OpenMP 3.0:
8961    # pragma omp task task-clause[optseq] new-line
8962
8963    LOC is the location of the #pragma.
8964 */
8965
8966 #define OMP_TASK_CLAUSE_MASK                            \
8967         ( (1u << PRAGMA_OMP_CLAUSE_IF)                  \
8968         | (1u << PRAGMA_OMP_CLAUSE_UNTIED)              \
8969         | (1u << PRAGMA_OMP_CLAUSE_DEFAULT)             \
8970         | (1u << PRAGMA_OMP_CLAUSE_PRIVATE)             \
8971         | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE)        \
8972         | (1u << PRAGMA_OMP_CLAUSE_SHARED))
8973
8974 static tree
8975 c_parser_omp_task (location_t loc, c_parser *parser)
8976 {
8977   tree clauses, block;
8978
8979   clauses = c_parser_omp_all_clauses (parser, OMP_TASK_CLAUSE_MASK,
8980                                       "#pragma omp task");
8981
8982   block = c_begin_omp_task ();
8983   c_parser_statement (parser);
8984   return c_finish_omp_task (loc, clauses, block);
8985 }
8986
8987 /* OpenMP 3.0:
8988    # pragma omp taskwait new-line
8989 */
8990
8991 static void
8992 c_parser_omp_taskwait (c_parser *parser)
8993 {
8994   location_t loc = c_parser_peek_token (parser)->location;
8995   c_parser_consume_pragma (parser);
8996   c_parser_skip_to_pragma_eol (parser);
8997
8998   c_finish_omp_taskwait (loc);
8999 }
9000
9001 /* Main entry point to parsing most OpenMP pragmas.  */
9002
9003 static void
9004 c_parser_omp_construct (c_parser *parser)
9005 {
9006   enum pragma_kind p_kind;
9007   location_t loc;
9008   tree stmt;
9009
9010   loc = c_parser_peek_token (parser)->location;
9011   p_kind = c_parser_peek_token (parser)->pragma_kind;
9012   c_parser_consume_pragma (parser);
9013
9014   switch (p_kind)
9015     {
9016     case PRAGMA_OMP_ATOMIC:
9017       c_parser_omp_atomic (loc, parser);
9018       return;
9019     case PRAGMA_OMP_CRITICAL:
9020       stmt = c_parser_omp_critical (loc, parser);
9021       break;
9022     case PRAGMA_OMP_FOR:
9023       stmt = c_parser_omp_for (loc, parser);
9024       break;
9025     case PRAGMA_OMP_MASTER:
9026       stmt = c_parser_omp_master (loc, parser);
9027       break;
9028     case PRAGMA_OMP_ORDERED:
9029       stmt = c_parser_omp_ordered (loc, parser);
9030       break;
9031     case PRAGMA_OMP_PARALLEL:
9032       stmt = c_parser_omp_parallel (loc, parser);
9033       break;
9034     case PRAGMA_OMP_SECTIONS:
9035       stmt = c_parser_omp_sections (loc, parser);
9036       break;
9037     case PRAGMA_OMP_SINGLE:
9038       stmt = c_parser_omp_single (loc, parser);
9039       break;
9040     case PRAGMA_OMP_TASK:
9041       stmt = c_parser_omp_task (loc, parser);
9042       break;
9043     default:
9044       gcc_unreachable ();
9045     }
9046
9047   if (stmt)
9048     gcc_assert (EXPR_LOCATION (stmt) != UNKNOWN_LOCATION);
9049 }
9050
9051
9052 /* OpenMP 2.5:
9053    # pragma omp threadprivate (variable-list) */
9054
9055 static void
9056 c_parser_omp_threadprivate (c_parser *parser)
9057 {
9058   tree vars, t;
9059   location_t loc;
9060
9061   c_parser_consume_pragma (parser);
9062   loc = c_parser_peek_token (parser)->location;
9063   vars = c_parser_omp_var_list_parens (parser, OMP_CLAUSE_ERROR, NULL);
9064
9065   /* Mark every variable in VARS to be assigned thread local storage.  */
9066   for (t = vars; t; t = TREE_CHAIN (t))
9067     {
9068       tree v = TREE_PURPOSE (t);
9069
9070       /* FIXME diagnostics: Ideally we should keep individual
9071          locations for all the variables in the var list to make the
9072          following errors more precise.  Perhaps
9073          c_parser_omp_var_list_parens() should construct a list of
9074          locations to go along with the var list.  */
9075
9076       /* If V had already been marked threadprivate, it doesn't matter
9077          whether it had been used prior to this point.  */
9078       if (TREE_CODE (v) != VAR_DECL)
9079         error_at (loc, "%qD is not a variable", v);
9080       else if (TREE_USED (v) && !C_DECL_THREADPRIVATE_P (v))
9081         error_at (loc, "%qE declared %<threadprivate%> after first use", v);
9082       else if (! TREE_STATIC (v) && ! DECL_EXTERNAL (v))
9083         error_at (loc, "automatic variable %qE cannot be %<threadprivate%>", v);
9084       else if (TREE_TYPE (v) == error_mark_node)
9085         ;
9086       else if (! COMPLETE_TYPE_P (TREE_TYPE (v)))
9087         error_at (loc, "%<threadprivate%> %qE has incomplete type", v);
9088       else
9089         {
9090           if (! DECL_THREAD_LOCAL_P (v))
9091             {
9092               DECL_TLS_MODEL (v) = decl_default_tls_model (v);
9093               /* If rtl has been already set for this var, call
9094                  make_decl_rtl once again, so that encode_section_info
9095                  has a chance to look at the new decl flags.  */
9096               if (DECL_RTL_SET_P (v))
9097                 make_decl_rtl (v);
9098             }
9099           C_DECL_THREADPRIVATE_P (v) = 1;
9100         }
9101     }
9102
9103   c_parser_skip_to_pragma_eol (parser);
9104 }
9105
9106 \f
9107 /* Parse a single source file.  */
9108
9109 void
9110 c_parse_file (void)
9111 {
9112   /* Use local storage to begin.  If the first token is a pragma, parse it.
9113      If it is #pragma GCC pch_preprocess, then this will load a PCH file
9114      which will cause garbage collection.  */
9115   c_parser tparser;
9116
9117   memset (&tparser, 0, sizeof tparser);
9118   the_parser = &tparser;
9119
9120   if (c_parser_peek_token (&tparser)->pragma_kind == PRAGMA_GCC_PCH_PREPROCESS)
9121     c_parser_pragma_pch_preprocess (&tparser);
9122
9123   the_parser = ggc_alloc_c_parser ();
9124   *the_parser = tparser;
9125
9126   /* Initialize EH, if we've been told to do so.  */
9127   if (flag_exceptions)
9128     using_eh_for_cleanups ();
9129
9130   c_parser_translation_unit (the_parser);
9131   the_parser = NULL;
9132 }
9133
9134 #include "gt-c-parser.h"