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