contrib/gcc-4.4/gcc/c-parser.c

   1 /* Parser for C and Objective-C.
   2    Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
   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 : 8;
 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_at (token->location,
 225                             OPT_Wc___compat,
 226                             "identifier %qs conflicts with C++ keyword",
 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 = UNKNOWN_LOCATION;  /* Quiet warning.  */
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 = UNKNOWN_LOCATION;  /* Quiet warning.  */
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               enum_value = c_parser_expr_no_commas (parser, NULL).value;
1657             }
1658           else
1659             enum_value = NULL_TREE;
1660           enum_decl = build_enumerator (&the_enum, enum_id, enum_value,
1661                                         value_loc);
1662           TREE_CHAIN (enum_decl) = values;
1663           values = enum_decl;
1664           seen_comma = false;
1665           if (c_parser_next_token_is (parser, CPP_COMMA))
1666             {
1667               comma_loc = c_parser_peek_token (parser)->location;
1668               seen_comma = true;
1669               c_parser_consume_token (parser);
1670             }
1671           if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
1672             {
1673               if (seen_comma && !flag_isoc99)
1674                 pedwarn (comma_loc, OPT_pedantic, "comma at end of enumerator list");
1675               c_parser_consume_token (parser);
1676               break;
1677             }
1678           if (!seen_comma)
1679             {
1680               c_parser_error (parser, "expected %<,%> or %<}%>");
1681               c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL);
1682               values = error_mark_node;
1683               break;
1684             }
1685         }
1686       postfix_attrs = c_parser_attributes (parser);
1687       ret.spec = finish_enum (type, nreverse (values),
1688                               chainon (attrs, postfix_attrs));
1689       ret.kind = ctsk_tagdef;
1690       return ret;
1691     }
1692   else if (!ident)
1693     {
1694       c_parser_error (parser, "expected %<{%>");
1695       ret.spec = error_mark_node;
1696       ret.kind = ctsk_tagref;
1697       return ret;
1698     }
1699   ret = parser_xref_tag (ENUMERAL_TYPE, ident);
1700   /* In ISO C, enumerated types can be referred to only if already
1701      defined.  */
1702   if (pedantic && !COMPLETE_TYPE_P (ret.spec))
1703     {
1704       gcc_assert (ident);
1705       pedwarn (ident_loc, OPT_pedantic,
1706                "ISO C forbids forward references to %<enum%> types");
1707     }
1708   return ret;
1709 }
1710
1711 /* Parse a struct or union specifier (C90 6.5.2.1, C99 6.7.2.1).
1712
1713    struct-or-union-specifier:
1714      struct-or-union attributes[opt] identifier[opt]
1715        { struct-contents } attributes[opt]
1716      struct-or-union attributes[opt] identifier
1717
1718    struct-contents:
1719      struct-declaration-list
1720
1721    struct-declaration-list:
1722      struct-declaration ;
1723      struct-declaration-list struct-declaration ;
1724
1725    GNU extensions:
1726
1727    struct-contents:
1728      empty
1729      struct-declaration
1730      struct-declaration-list struct-declaration
1731
1732    struct-declaration-list:
1733      struct-declaration-list ;
1734      ;
1735
1736    (Note that in the syntax here, unlike that in ISO C, the semicolons
1737    are included here rather than in struct-declaration, in order to
1738    describe the syntax with extra semicolons and missing semicolon at
1739    end.)
1740
1741    Objective-C:
1742
1743    struct-declaration-list:
1744      @defs ( class-name )
1745
1746    (Note this does not include a trailing semicolon, but can be
1747    followed by further declarations, and gets a pedwarn-if-pedantic
1748    when followed by a semicolon.)  */
1749
1750 static struct c_typespec
1751 c_parser_struct_or_union_specifier (c_parser *parser)
1752 {
1753   struct c_typespec ret;
1754   tree attrs;
1755   tree ident = NULL_TREE;
1756   enum tree_code code;
1757   switch (c_parser_peek_token (parser)->keyword)
1758     {
1759     case RID_STRUCT:
1760       code = RECORD_TYPE;
1761       break;
1762     case RID_UNION:
1763       code = UNION_TYPE;
1764       break;
1765     default:
1766       gcc_unreachable ();
1767     }
1768   c_parser_consume_token (parser);
1769   attrs = c_parser_attributes (parser);
1770   /* Set the location in case we create a decl now.  */
1771   c_parser_set_source_position_from_token (c_parser_peek_token (parser));
1772   if (c_parser_next_token_is (parser, CPP_NAME))
1773     {
1774       ident = c_parser_peek_token (parser)->value;
1775       c_parser_consume_token (parser);
1776     }
1777   if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
1778     {
1779       /* Parse a struct or union definition.  Start the scope of the
1780          tag before parsing components.  */
1781       tree type = start_struct (code, ident);
1782       tree postfix_attrs;
1783       /* We chain the components in reverse order, then put them in
1784          forward order at the end.  Each struct-declaration may
1785          declare multiple components (comma-separated), so we must use
1786          chainon to join them, although when parsing each
1787          struct-declaration we can use TREE_CHAIN directly.
1788
1789          The theory behind all this is that there will be more
1790          semicolon separated fields than comma separated fields, and
1791          so we'll be minimizing the number of node traversals required
1792          by chainon.  */
1793       tree contents = NULL_TREE;
1794       c_parser_consume_token (parser);
1795       /* Handle the Objective-C @defs construct,
1796          e.g. foo(sizeof(struct{ @defs(ClassName) }));.  */
1797       if (c_parser_next_token_is_keyword (parser, RID_AT_DEFS))
1798         {
1799           tree name;
1800           gcc_assert (c_dialect_objc ());
1801           c_parser_consume_token (parser);
1802           if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
1803             goto end_at_defs;
1804           if (c_parser_next_token_is (parser, CPP_NAME)
1805               && c_parser_peek_token (parser)->id_kind == C_ID_CLASSNAME)
1806             {
1807               name = c_parser_peek_token (parser)->value;
1808               c_parser_consume_token (parser);
1809             }
1810           else
1811             {
1812               c_parser_error (parser, "expected class name");
1813               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
1814               goto end_at_defs;
1815             }
1816           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
1817                                      "expected %<)%>");
1818           contents = nreverse (objc_get_class_ivars (name));
1819         }
1820     end_at_defs:
1821       /* Parse the struct-declarations and semicolons.  Problems with
1822          semicolons are diagnosed here; empty structures are diagnosed
1823          elsewhere.  */
1824       while (true)
1825         {
1826           tree decls;
1827           /* Parse any stray semicolon.  */
1828           if (c_parser_next_token_is (parser, CPP_SEMICOLON))
1829             {
1830               pedwarn (c_parser_peek_token (parser)->location, OPT_pedantic,
1831                        "extra semicolon in struct or union specified");
1832               c_parser_consume_token (parser);
1833               continue;
1834             }
1835           /* Stop if at the end of the struct or union contents.  */
1836           if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
1837             {
1838               c_parser_consume_token (parser);
1839               break;
1840             }
1841           /* Accept #pragmas at struct scope.  */
1842           if (c_parser_next_token_is (parser, CPP_PRAGMA))
1843             {
1844               c_parser_pragma (parser, pragma_external);
1845               continue;
1846             }
1847           /* Parse some comma-separated declarations, but not the
1848              trailing semicolon if any.  */
1849           decls = c_parser_struct_declaration (parser);
1850           contents = chainon (decls, contents);
1851           /* If no semicolon follows, either we have a parse error or
1852              are at the end of the struct or union and should
1853              pedwarn.  */
1854           if (c_parser_next_token_is (parser, CPP_SEMICOLON))
1855             c_parser_consume_token (parser);
1856           else
1857             {
1858               if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
1859                 pedwarn (c_parser_peek_token (parser)->location, 0,
1860                          "no semicolon at end of struct or union");
1861               else
1862                 {
1863                   c_parser_error (parser, "expected %<;%>");
1864                   c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL);
1865                   break;
1866                 }
1867             }
1868         }
1869       postfix_attrs = c_parser_attributes (parser);
1870       ret.spec = finish_struct (type, nreverse (contents),
1871                                 chainon (attrs, postfix_attrs));
1872       ret.kind = ctsk_tagdef;
1873       return ret;
1874     }
1875   else if (!ident)
1876     {
1877       c_parser_error (parser, "expected %<{%>");
1878       ret.spec = error_mark_node;
1879       ret.kind = ctsk_tagref;
1880       return ret;
1881     }
1882   ret = parser_xref_tag (code, ident);
1883   return ret;
1884 }
1885
1886 /* Parse a struct-declaration (C90 6.5.2.1, C99 6.7.2.1), *without*
1887    the trailing semicolon.
1888
1889    struct-declaration:
1890      specifier-qualifier-list struct-declarator-list
1891
1892    specifier-qualifier-list:
1893      type-specifier specifier-qualifier-list[opt]
1894      type-qualifier specifier-qualifier-list[opt]
1895      attributes specifier-qualifier-list[opt]
1896
1897    struct-declarator-list:
1898      struct-declarator
1899      struct-declarator-list , attributes[opt] struct-declarator
1900
1901    struct-declarator:
1902      declarator attributes[opt]
1903      declarator[opt] : constant-expression attributes[opt]
1904
1905    GNU extensions:
1906
1907    struct-declaration:
1908      __extension__ struct-declaration
1909      specifier-qualifier-list
1910
1911    Unlike the ISO C syntax, semicolons are handled elsewhere.  The use
1912    of attributes where shown is a GNU extension.  In GNU C, we accept
1913    any expression without commas in the syntax (assignment
1914    expressions, not just conditional expressions); assignment
1915    expressions will be diagnosed as non-constant.  */
1916
1917 static tree
1918 c_parser_struct_declaration (c_parser *parser)
1919 {
1920   struct c_declspecs *specs;
1921   tree prefix_attrs;
1922   tree all_prefix_attrs;
1923   tree decls;
1924   location_t decl_loc;
1925   if (c_parser_next_token_is_keyword (parser, RID_EXTENSION))
1926     {
1927       int ext;
1928       tree decl;
1929       ext = disable_extension_diagnostics ();
1930       c_parser_consume_token (parser);
1931       decl = c_parser_struct_declaration (parser);
1932       restore_extension_diagnostics (ext);
1933       return decl;
1934     }
1935   specs = build_null_declspecs ();
1936   decl_loc = c_parser_peek_token (parser)->location;
1937   c_parser_declspecs (parser, specs, false, true, true);
1938   if (parser->error)
1939     return NULL_TREE;
1940   if (!specs->declspecs_seen_p)
1941     {
1942       c_parser_error (parser, "expected specifier-qualifier-list");
1943       return NULL_TREE;
1944     }
1945   finish_declspecs (specs);
1946   if (c_parser_next_token_is (parser, CPP_SEMICOLON))
1947     {
1948       tree ret;
1949       if (!specs->type_seen_p)
1950         {
1951           pedwarn (decl_loc, OPT_pedantic,
1952                    "ISO C forbids member declarations with no members");
1953           shadow_tag_warned (specs, pedantic);
1954           ret = NULL_TREE;
1955         }
1956       else
1957         {
1958           /* Support for unnamed structs or unions as members of
1959              structs or unions (which is [a] useful and [b] supports
1960              MS P-SDK).  */
1961           tree attrs = NULL;
1962
1963           ret = grokfield (c_parser_peek_token (parser)->location,
1964                            build_id_declarator (NULL_TREE), specs,
1965                            NULL_TREE, &attrs);
1966           if (ret)
1967             decl_attributes (&ret, attrs, 0);
1968         }
1969       return ret;
1970     }
1971   pending_xref_error ();
1972   prefix_attrs = specs->attrs;
1973   all_prefix_attrs = prefix_attrs;
1974   specs->attrs = NULL_TREE;
1975   decls = NULL_TREE;
1976   while (true)
1977     {
1978       /* Declaring one or more declarators or un-named bit-fields.  */
1979       struct c_declarator *declarator;
1980       bool dummy = false;
1981       if (c_parser_next_token_is (parser, CPP_COLON))
1982         declarator = build_id_declarator (NULL_TREE);
1983       else
1984         declarator = c_parser_declarator (parser, specs->type_seen_p,
1985                                           C_DTR_NORMAL, &dummy);
1986       if (declarator == NULL)
1987         {
1988           c_parser_skip_to_end_of_block_or_statement (parser);
1989           break;
1990         }
1991       if (c_parser_next_token_is (parser, CPP_COLON)
1992           || c_parser_next_token_is (parser, CPP_COMMA)
1993           || c_parser_next_token_is (parser, CPP_SEMICOLON)
1994           || c_parser_next_token_is (parser, CPP_CLOSE_BRACE)
1995           || c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
1996         {
1997           tree postfix_attrs = NULL_TREE;
1998           tree width = NULL_TREE;
1999           tree d;
2000           if (c_parser_next_token_is (parser, CPP_COLON))
2001             {
2002               c_parser_consume_token (parser);
2003               width = c_parser_expr_no_commas (parser, NULL).value;
2004             }
2005           if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
2006             postfix_attrs = c_parser_attributes (parser);
2007           d = grokfield (c_parser_peek_token (parser)->location,
2008                          declarator, specs, width, &all_prefix_attrs);
2009           decl_attributes (&d, chainon (postfix_attrs,
2010                                         all_prefix_attrs), 0);
2011           TREE_CHAIN (d) = decls;
2012           decls = d;
2013           if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
2014             all_prefix_attrs = chainon (c_parser_attributes (parser),
2015                                         prefix_attrs);
2016           else
2017             all_prefix_attrs = prefix_attrs;
2018           if (c_parser_next_token_is (parser, CPP_COMMA))
2019             c_parser_consume_token (parser);
2020           else if (c_parser_next_token_is (parser, CPP_SEMICOLON)
2021                    || c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
2022             {
2023               /* Semicolon consumed in caller.  */
2024               break;
2025             }
2026           else
2027             {
2028               c_parser_error (parser, "expected %<,%>, %<;%> or %<}%>");
2029               break;
2030             }
2031         }
2032       else
2033         {
2034           c_parser_error (parser,
2035                           "expected %<:%>, %<,%>, %<;%>, %<}%> or "
2036                           "%<__attribute__%>");
2037           break;
2038         }
2039     }
2040   return decls;
2041 }
2042
2043 /* Parse a typeof specifier (a GNU extension).
2044
2045    typeof-specifier:
2046      typeof ( expression )
2047      typeof ( type-name )
2048 */
2049
2050 static struct c_typespec
2051 c_parser_typeof_specifier (c_parser *parser)
2052 {
2053   struct c_typespec ret;
2054   ret.kind = ctsk_typeof;
2055   ret.spec = error_mark_node;
2056   gcc_assert (c_parser_next_token_is_keyword (parser, RID_TYPEOF));
2057   c_parser_consume_token (parser);
2058   skip_evaluation++;
2059   in_typeof++;
2060   if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
2061     {
2062       skip_evaluation--;
2063       in_typeof--;
2064       return ret;
2065     }
2066   if (c_parser_next_token_starts_typename (parser))
2067     {
2068       struct c_type_name *type = c_parser_type_name (parser);
2069       skip_evaluation--;
2070       in_typeof--;
2071       if (type != NULL)
2072         {
2073           ret.spec = groktypename (type);
2074           pop_maybe_used (variably_modified_type_p (ret.spec, NULL_TREE));
2075         }
2076     }
2077   else
2078     {
2079       bool was_vm;
2080       location_t here = c_parser_peek_token (parser)->location;
2081       struct c_expr expr = c_parser_expression (parser);
2082       skip_evaluation--;
2083       in_typeof--;
2084       if (TREE_CODE (expr.value) == COMPONENT_REF
2085           && DECL_C_BIT_FIELD (TREE_OPERAND (expr.value, 1)))
2086         error_at (here, "%<typeof%> applied to a bit-field");
2087       ret.spec = TREE_TYPE (expr.value);
2088       was_vm = variably_modified_type_p (ret.spec, NULL_TREE);
2089       /* This should be returned with the type so that when the type
2090          is evaluated, this can be evaluated.  For now, we avoid
2091          evaluation when the context might.  */
2092       if (!skip_evaluation && was_vm)
2093         {
2094           tree e = expr.value;
2095
2096           /* If the expression is not of a type to which we cannot assign a line
2097              number, wrap the thing in a no-op NOP_EXPR.  */
2098           if (DECL_P (e) || CONSTANT_CLASS_P (e))
2099             e = build1 (NOP_EXPR, void_type_node, e);
2100
2101           protected_set_expr_location (e, here);
2102
2103           add_stmt (e);
2104         }
2105       pop_maybe_used (was_vm);
2106     }
2107   c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
2108   return ret;
2109 }
2110
2111 /* Parse a declarator, possibly an abstract declarator (C90 6.5.4,
2112    6.5.5, C99 6.7.5, 6.7.6).  If TYPE_SEEN_P then a typedef name may
2113    be redeclared; otherwise it may not.  KIND indicates which kind of
2114    declarator is wanted.  Returns a valid declarator except in the
2115    case of a syntax error in which case NULL is returned.  *SEEN_ID is
2116    set to true if an identifier being declared is seen; this is used
2117    to diagnose bad forms of abstract array declarators and to
2118    determine whether an identifier list is syntactically permitted.
2119
2120    declarator:
2121      pointer[opt] direct-declarator
2122
2123    direct-declarator:
2124      identifier
2125      ( attributes[opt] declarator )
2126      direct-declarator array-declarator
2127      direct-declarator ( parameter-type-list )
2128      direct-declarator ( identifier-list[opt] )
2129
2130    pointer:
2131      * type-qualifier-list[opt]
2132      * type-qualifier-list[opt] pointer
2133
2134    type-qualifier-list:
2135      type-qualifier
2136      attributes
2137      type-qualifier-list type-qualifier
2138      type-qualifier-list attributes
2139
2140    parameter-type-list:
2141      parameter-list
2142      parameter-list , ...
2143
2144    parameter-list:
2145      parameter-declaration
2146      parameter-list , parameter-declaration
2147
2148    parameter-declaration:
2149      declaration-specifiers declarator attributes[opt]
2150      declaration-specifiers abstract-declarator[opt] attributes[opt]
2151
2152    identifier-list:
2153      identifier
2154      identifier-list , identifier
2155
2156    abstract-declarator:
2157      pointer
2158      pointer[opt] direct-abstract-declarator
2159
2160    direct-abstract-declarator:
2161      ( attributes[opt] abstract-declarator )
2162      direct-abstract-declarator[opt] array-declarator
2163      direct-abstract-declarator[opt] ( parameter-type-list[opt] )
2164
2165    GNU extensions:
2166
2167    direct-declarator:
2168      direct-declarator ( parameter-forward-declarations
2169                          parameter-type-list[opt] )
2170
2171    direct-abstract-declarator:
2172      direct-abstract-declarator[opt] ( parameter-forward-declarations
2173                                        parameter-type-list[opt] )
2174
2175    parameter-forward-declarations:
2176      parameter-list ;
2177      parameter-forward-declarations parameter-list ;
2178
2179    The uses of attributes shown above are GNU extensions.
2180
2181    Some forms of array declarator are not included in C99 in the
2182    syntax for abstract declarators; these are disallowed elsewhere.
2183    This may be a defect (DR#289).
2184
2185    This function also accepts an omitted abstract declarator as being
2186    an abstract declarator, although not part of the formal syntax.  */
2187
2188 static struct c_declarator *
2189 c_parser_declarator (c_parser *parser, bool type_seen_p, c_dtr_syn kind,
2190                      bool *seen_id)
2191 {
2192   /* Parse any initial pointer part.  */
2193   if (c_parser_next_token_is (parser, CPP_MULT))
2194     {
2195       struct c_declspecs *quals_attrs = build_null_declspecs ();
2196       struct c_declarator *inner;
2197       c_parser_consume_token (parser);
2198       c_parser_declspecs (parser, quals_attrs, false, false, true);
2199       inner = c_parser_declarator (parser, type_seen_p, kind, seen_id);
2200       if (inner == NULL)
2201         return NULL;
2202       else
2203         return make_pointer_declarator (quals_attrs, inner);
2204     }
2205   /* Now we have a direct declarator, direct abstract declarator or
2206      nothing (which counts as a direct abstract declarator here).  */
2207   return c_parser_direct_declarator (parser, type_seen_p, kind, seen_id);
2208 }
2209
2210 /* Parse a direct declarator or direct abstract declarator; arguments
2211    as c_parser_declarator.  */
2212
2213 static struct c_declarator *
2214 c_parser_direct_declarator (c_parser *parser, bool type_seen_p, c_dtr_syn kind,
2215                             bool *seen_id)
2216 {
2217   /* The direct declarator must start with an identifier (possibly
2218      omitted) or a parenthesized declarator (possibly abstract).  In
2219      an ordinary declarator, initial parentheses must start a
2220      parenthesized declarator.  In an abstract declarator or parameter
2221      declarator, they could start a parenthesized declarator or a
2222      parameter list.  To tell which, the open parenthesis and any
2223      following attributes must be read.  If a declaration specifier
2224      follows, then it is a parameter list; if the specifier is a
2225      typedef name, there might be an ambiguity about redeclaring it,
2226      which is resolved in the direction of treating it as a typedef
2227      name.  If a close parenthesis follows, it is also an empty
2228      parameter list, as the syntax does not permit empty abstract
2229      declarators.  Otherwise, it is a parenthesized declarator (in
2230      which case the analysis may be repeated inside it, recursively).
2231
2232      ??? There is an ambiguity in a parameter declaration "int
2233      (__attribute__((foo)) x)", where x is not a typedef name: it
2234      could be an abstract declarator for a function, or declare x with
2235      parentheses.  The proper resolution of this ambiguity needs
2236      documenting.  At present we follow an accident of the old
2237      parser's implementation, whereby the first parameter must have
2238      some declaration specifiers other than just attributes.  Thus as
2239      a parameter declaration it is treated as a parenthesized
2240      parameter named x, and as an abstract declarator it is
2241      rejected.
2242
2243      ??? Also following the old parser, attributes inside an empty
2244      parameter list are ignored, making it a list not yielding a
2245      prototype, rather than giving an error or making it have one
2246      parameter with implicit type int.
2247
2248      ??? Also following the old parser, typedef names may be
2249      redeclared in declarators, but not Objective-C class names.  */
2250
2251   if (kind != C_DTR_ABSTRACT
2252       && c_parser_next_token_is (parser, CPP_NAME)
2253       && ((type_seen_p
2254            && c_parser_peek_token (parser)->id_kind == C_ID_TYPENAME)
2255           || c_parser_peek_token (parser)->id_kind == C_ID_ID))
2256     {
2257       struct c_declarator *inner
2258         = build_id_declarator (c_parser_peek_token (parser)->value);
2259       *seen_id = true;
2260       inner->id_loc = c_parser_peek_token (parser)->location;
2261       c_parser_consume_token (parser);
2262       return c_parser_direct_declarator_inner (parser, *seen_id, inner);
2263     }
2264
2265   if (kind != C_DTR_NORMAL
2266       && c_parser_next_token_is (parser, CPP_OPEN_SQUARE))
2267     {
2268       struct c_declarator *inner = build_id_declarator (NULL_TREE);
2269       return c_parser_direct_declarator_inner (parser, *seen_id, inner);
2270     }
2271
2272   /* Either we are at the end of an abstract declarator, or we have
2273      parentheses.  */
2274
2275   if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
2276     {
2277       tree attrs;
2278       struct c_declarator *inner;
2279       c_parser_consume_token (parser);
2280       attrs = c_parser_attributes (parser);
2281       if (kind != C_DTR_NORMAL
2282           && (c_parser_next_token_starts_declspecs (parser)
2283               || c_parser_next_token_is (parser, CPP_CLOSE_PAREN)))
2284         {
2285           struct c_arg_info *args
2286             = c_parser_parms_declarator (parser, kind == C_DTR_NORMAL,
2287                                          attrs);
2288           if (args == NULL)
2289             return NULL;
2290           else
2291             {
2292               inner
2293                 = build_function_declarator (args,
2294                                              build_id_declarator (NULL_TREE));
2295               return c_parser_direct_declarator_inner (parser, *seen_id,
2296                                                        inner);
2297             }
2298         }
2299       /* A parenthesized declarator.  */
2300       inner = c_parser_declarator (parser, type_seen_p, kind, seen_id);
2301       if (inner != NULL && attrs != NULL)
2302         inner = build_attrs_declarator (attrs, inner);
2303       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2304         {
2305           c_parser_consume_token (parser);
2306           if (inner == NULL)
2307             return NULL;
2308           else
2309             return c_parser_direct_declarator_inner (parser, *seen_id, inner);
2310         }
2311       else
2312         {
2313           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2314                                      "expected %<)%>");
2315           return NULL;
2316         }
2317     }
2318   else
2319     {
2320       if (kind == C_DTR_NORMAL)
2321         {
2322           c_parser_error (parser, "expected identifier or %<(%>");
2323           return NULL;
2324         }
2325       else
2326         return build_id_declarator (NULL_TREE);
2327     }
2328 }
2329
2330 /* Parse part of a direct declarator or direct abstract declarator,
2331    given that some (in INNER) has already been parsed; ID_PRESENT is
2332    true if an identifier is present, false for an abstract
2333    declarator.  */
2334
2335 static struct c_declarator *
2336 c_parser_direct_declarator_inner (c_parser *parser, bool id_present,
2337                                   struct c_declarator *inner)
2338 {
2339   /* Parse a sequence of array declarators and parameter lists.  */
2340   if (c_parser_next_token_is (parser, CPP_OPEN_SQUARE))
2341     {
2342       struct c_declarator *declarator;
2343       struct c_declspecs *quals_attrs = build_null_declspecs ();
2344       bool static_seen;
2345       bool star_seen;
2346       tree dimen;
2347       c_parser_consume_token (parser);
2348       c_parser_declspecs (parser, quals_attrs, false, false, true);
2349       static_seen = c_parser_next_token_is_keyword (parser, RID_STATIC);
2350       if (static_seen)
2351         c_parser_consume_token (parser);
2352       if (static_seen && !quals_attrs->declspecs_seen_p)
2353         c_parser_declspecs (parser, quals_attrs, false, false, true);
2354       if (!quals_attrs->declspecs_seen_p)
2355         quals_attrs = NULL;
2356       /* If "static" is present, there must be an array dimension.
2357          Otherwise, there may be a dimension, "*", or no
2358          dimension.  */
2359       if (static_seen)
2360         {
2361           star_seen = false;
2362           dimen = c_parser_expr_no_commas (parser, NULL).value;
2363         }
2364       else
2365         {
2366           if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
2367             {
2368               dimen = NULL_TREE;
2369               star_seen = false;
2370             }
2371           else if (c_parser_next_token_is (parser, CPP_MULT))
2372             {
2373               if (c_parser_peek_2nd_token (parser)->type == CPP_CLOSE_SQUARE)
2374                 {
2375                   dimen = NULL_TREE;
2376                   star_seen = true;
2377                   c_parser_consume_token (parser);
2378                 }
2379               else
2380                 {
2381                   star_seen = false;
2382                   dimen = c_parser_expr_no_commas (parser, NULL).value;
2383                 }
2384             }
2385           else
2386             {
2387               star_seen = false;
2388               dimen = c_parser_expr_no_commas (parser, NULL).value;
2389             }
2390         }
2391       if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
2392         c_parser_consume_token (parser);
2393       else
2394         {
2395           c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
2396                                      "expected %<]%>");
2397           return NULL;
2398         }
2399       declarator = build_array_declarator (dimen, quals_attrs, static_seen,
2400                                            star_seen);
2401       if (declarator == NULL)
2402         return NULL;
2403       inner = set_array_declarator_inner (declarator, inner);
2404       return c_parser_direct_declarator_inner (parser, id_present, inner);
2405     }
2406   else if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
2407     {
2408       tree attrs;
2409       struct c_arg_info *args;
2410       c_parser_consume_token (parser);
2411       attrs = c_parser_attributes (parser);
2412       args = c_parser_parms_declarator (parser, id_present, attrs);
2413       if (args == NULL)
2414         return NULL;
2415       else
2416         {
2417           inner = build_function_declarator (args, inner);
2418           return c_parser_direct_declarator_inner (parser, id_present, inner);
2419         }
2420     }
2421   return inner;
2422 }
2423
2424 /* Parse a parameter list or identifier list, including the closing
2425    parenthesis but not the opening one.  ATTRS are the attributes at
2426    the start of the list.  ID_LIST_OK is true if an identifier list is
2427    acceptable; such a list must not have attributes at the start.  */
2428
2429 static struct c_arg_info *
2430 c_parser_parms_declarator (c_parser *parser, bool id_list_ok, tree attrs)
2431 {
2432   push_scope ();
2433   declare_parm_level ();
2434   /* If the list starts with an identifier, it is an identifier list.
2435      Otherwise, it is either a prototype list or an empty list.  */
2436   if (id_list_ok
2437       && !attrs
2438       && c_parser_next_token_is (parser, CPP_NAME)
2439       && c_parser_peek_token (parser)->id_kind == C_ID_ID)
2440     {
2441       tree list = NULL_TREE, *nextp = &list;
2442       while (c_parser_next_token_is (parser, CPP_NAME)
2443              && c_parser_peek_token (parser)->id_kind == C_ID_ID)
2444         {
2445           *nextp = build_tree_list (NULL_TREE,
2446                                     c_parser_peek_token (parser)->value);
2447           nextp = & TREE_CHAIN (*nextp);
2448           c_parser_consume_token (parser);
2449           if (c_parser_next_token_is_not (parser, CPP_COMMA))
2450             break;
2451           c_parser_consume_token (parser);
2452           if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2453             {
2454               c_parser_error (parser, "expected identifier");
2455               break;
2456             }
2457         }
2458       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2459         {
2460           struct c_arg_info *ret = XOBNEW (&parser_obstack, struct c_arg_info);
2461           ret->parms = 0;
2462           ret->tags = 0;
2463           ret->types = list;
2464           ret->others = 0;
2465           ret->pending_sizes = 0;
2466           ret->had_vla_unspec = 0;
2467           c_parser_consume_token (parser);
2468           pop_scope ();
2469           return ret;
2470         }
2471       else
2472         {
2473           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2474                                      "expected %<)%>");
2475           pop_scope ();
2476           return NULL;
2477         }
2478     }
2479   else
2480     {
2481       struct c_arg_info *ret = c_parser_parms_list_declarator (parser, attrs);
2482       pop_scope ();
2483       return ret;
2484     }
2485 }
2486
2487 /* Parse a parameter list (possibly empty), including the closing
2488    parenthesis but not the opening one.  ATTRS are the attributes at
2489    the start of the list.  */
2490
2491 static struct c_arg_info *
2492 c_parser_parms_list_declarator (c_parser *parser, tree attrs)
2493 {
2494   bool good_parm = false;
2495   /* ??? Following the old parser, forward parameter declarations may
2496      use abstract declarators, and if no real parameter declarations
2497      follow the forward declarations then this is not diagnosed.  Also
2498      note as above that attributes are ignored as the only contents of
2499      the parentheses, or as the only contents after forward
2500      declarations.  */
2501   if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2502     {
2503       struct c_arg_info *ret = XOBNEW (&parser_obstack, struct c_arg_info);
2504       ret->parms = 0;
2505       ret->tags = 0;
2506       ret->types = 0;
2507       ret->others = 0;
2508       ret->pending_sizes = 0;
2509       ret->had_vla_unspec = 0;
2510       c_parser_consume_token (parser);
2511       return ret;
2512     }
2513   if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
2514     {
2515       struct c_arg_info *ret = XOBNEW (&parser_obstack, struct c_arg_info);
2516       ret->parms = 0;
2517       ret->tags = 0;
2518       ret->others = 0;
2519       ret->pending_sizes = 0;
2520       ret->had_vla_unspec = 0;
2521       /* Suppress -Wold-style-definition for this case.  */
2522       ret->types = error_mark_node;
2523       error_at (c_parser_peek_token (parser)->location,
2524                 "ISO C requires a named argument before %<...%>");
2525       c_parser_consume_token (parser);
2526       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2527         {
2528           c_parser_consume_token (parser);
2529           return ret;
2530         }
2531       else
2532         {
2533           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2534                                      "expected %<)%>");
2535           return NULL;
2536         }
2537     }
2538   /* Nonempty list of parameters, either terminated with semicolon
2539      (forward declarations; recurse) or with close parenthesis (normal
2540      function) or with ", ... )" (variadic function).  */
2541   while (true)
2542     {
2543       /* Parse a parameter.  */
2544       struct c_parm *parm = c_parser_parameter_declaration (parser, attrs);
2545       attrs = NULL_TREE;
2546       if (parm != NULL)
2547         {
2548           good_parm = true;
2549           push_parm_decl (parm);
2550         }
2551       if (c_parser_next_token_is (parser, CPP_SEMICOLON))
2552         {
2553           tree new_attrs;
2554           c_parser_consume_token (parser);
2555           mark_forward_parm_decls ();
2556           new_attrs = c_parser_attributes (parser);
2557           return c_parser_parms_list_declarator (parser, new_attrs);
2558         }
2559       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2560         {
2561           c_parser_consume_token (parser);
2562           if (good_parm)
2563             return get_parm_info (false);
2564           else
2565             {
2566               struct c_arg_info *ret
2567                 = XOBNEW (&parser_obstack, struct c_arg_info);
2568               ret->parms = 0;
2569               ret->tags = 0;
2570               ret->types = 0;
2571               ret->others = 0;
2572               ret->pending_sizes = 0;
2573               ret->had_vla_unspec = 0;
2574               return ret;
2575             }
2576         }
2577       if (!c_parser_require (parser, CPP_COMMA,
2578                              "expected %<;%>, %<,%> or %<)%>"))
2579         {
2580           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
2581           get_pending_sizes ();
2582           return NULL;
2583         }
2584       if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
2585         {
2586           c_parser_consume_token (parser);
2587           if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2588             {
2589               c_parser_consume_token (parser);
2590               if (good_parm)
2591                 return get_parm_info (true);
2592               else
2593                 {
2594                   struct c_arg_info *ret
2595                     = XOBNEW (&parser_obstack, struct c_arg_info);
2596                   ret->parms = 0;
2597                   ret->tags = 0;
2598                   ret->types = 0;
2599                   ret->others = 0;
2600                   ret->pending_sizes = 0;
2601                   ret->had_vla_unspec = 0;
2602                   return ret;
2603                 }
2604             }
2605           else
2606             {
2607               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2608                                          "expected %<)%>");
2609               get_pending_sizes ();
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_at (c_parser_peek_token (parser)->location,
2683                 "wide string literal in %<asm%>");
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       pop_init_level (0);
3040       return ret;
3041     }
3042   c_parser_consume_token (parser);
3043   return pop_init_level (0);
3044 }
3045
3046 /* Parse a nested initializer, including designators.  */
3047
3048 static void
3049 c_parser_initelt (c_parser *parser)
3050 {
3051   /* Parse any designator or designator list.  A single array
3052      designator may have the subsequent "=" omitted in GNU C, but a
3053      longer list or a structure member designator may not.  */
3054   if (c_parser_next_token_is (parser, CPP_NAME)
3055       && c_parser_peek_2nd_token (parser)->type == CPP_COLON)
3056     {
3057       /* Old-style structure member designator.  */
3058       set_init_label (c_parser_peek_token (parser)->value);
3059       /* Use the colon as the error location.  */
3060       pedwarn (c_parser_peek_2nd_token (parser)->location, OPT_pedantic,
3061                "obsolete use of designated initializer with %<:%>");
3062       c_parser_consume_token (parser);
3063       c_parser_consume_token (parser);
3064     }
3065   else
3066     {
3067       /* des_seen is 0 if there have been no designators, 1 if there
3068          has been a single array designator and 2 otherwise.  */
3069       int des_seen = 0;
3070       /* Location of a designator.  */
3071       location_t des_loc = UNKNOWN_LOCATION;  /* Quiet warning.  */
3072       while (c_parser_next_token_is (parser, CPP_OPEN_SQUARE)
3073              || c_parser_next_token_is (parser, CPP_DOT))
3074         {
3075           int des_prev = des_seen;
3076           if (!des_seen)
3077             des_loc = c_parser_peek_token (parser)->location;
3078           if (des_seen < 2)
3079             des_seen++;
3080           if (c_parser_next_token_is (parser, CPP_DOT))
3081             {
3082               des_seen = 2;
3083               c_parser_consume_token (parser);
3084               if (c_parser_next_token_is (parser, CPP_NAME))
3085                 {
3086                   set_init_label (c_parser_peek_token (parser)->value);
3087                   c_parser_consume_token (parser);
3088                 }
3089               else
3090                 {
3091                   struct c_expr init;
3092                   init.value = error_mark_node;
3093                   init.original_code = ERROR_MARK;
3094                   c_parser_error (parser, "expected identifier");
3095                   c_parser_skip_until_found (parser, CPP_COMMA, NULL);
3096                   process_init_element (init, false);
3097                   return;
3098                 }
3099             }
3100           else
3101             {
3102               tree first, second;
3103               location_t ellipsis_loc = UNKNOWN_LOCATION;  /* Quiet warning.  */
3104               /* ??? Following the old parser, [ objc-receiver
3105                  objc-message-args ] is accepted as an initializer,
3106                  being distinguished from a designator by what follows
3107                  the first assignment expression inside the square
3108                  brackets, but after a first array designator a
3109                  subsequent square bracket is for Objective-C taken to
3110                  start an expression, using the obsolete form of
3111                  designated initializer without '=', rather than
3112                  possibly being a second level of designation: in LALR
3113                  terms, the '[' is shifted rather than reducing
3114                  designator to designator-list.  */
3115               if (des_prev == 1 && c_dialect_objc ())
3116                 {
3117                   des_seen = des_prev;
3118                   break;
3119                 }
3120               if (des_prev == 0 && c_dialect_objc ())
3121                 {
3122                   /* This might be an array designator or an
3123                      Objective-C message expression.  If the former,
3124                      continue parsing here; if the latter, parse the
3125                      remainder of the initializer given the starting
3126                      primary-expression.  ??? It might make sense to
3127                      distinguish when des_prev == 1 as well; see
3128                      previous comment.  */
3129                   tree rec, args;
3130                   struct c_expr mexpr;
3131                   c_parser_consume_token (parser);
3132                   if (c_parser_peek_token (parser)->type == CPP_NAME
3133                       && ((c_parser_peek_token (parser)->id_kind
3134                            == C_ID_TYPENAME)
3135                           || (c_parser_peek_token (parser)->id_kind
3136                               == C_ID_CLASSNAME)))
3137                     {
3138                       /* Type name receiver.  */
3139                       tree id = c_parser_peek_token (parser)->value;
3140                       c_parser_consume_token (parser);
3141                       rec = objc_get_class_reference (id);
3142                       goto parse_message_args;
3143                     }
3144                   first = c_parser_expr_no_commas (parser, NULL).value;
3145                   if (c_parser_next_token_is (parser, CPP_ELLIPSIS)
3146                       || c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
3147                     goto array_desig_after_first;
3148                   /* Expression receiver.  So far only one part
3149                      without commas has been parsed; there might be
3150                      more of the expression.  */
3151                   rec = first;
3152                   while (c_parser_next_token_is (parser, CPP_COMMA))
3153                     {
3154                       struct c_expr next;
3155                       c_parser_consume_token (parser);
3156                       next = c_parser_expr_no_commas (parser, NULL);
3157                       next = default_function_array_conversion (next);
3158                       rec = build_compound_expr (rec, next.value);
3159                     }
3160                 parse_message_args:
3161                   /* Now parse the objc-message-args.  */
3162                   args = c_parser_objc_message_args (parser);
3163                   c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
3164                                              "expected %<]%>");
3165                   mexpr.value
3166                     = objc_build_message_expr (build_tree_list (rec, args));
3167                   mexpr.original_code = ERROR_MARK;
3168                   /* Now parse and process the remainder of the
3169                      initializer, starting with this message
3170                      expression as a primary-expression.  */
3171                   c_parser_initval (parser, &mexpr);
3172                   return;
3173                 }
3174               c_parser_consume_token (parser);
3175               first = c_parser_expr_no_commas (parser, NULL).value;
3176             array_desig_after_first:
3177               if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
3178                 {
3179                   ellipsis_loc = c_parser_peek_token (parser)->location;
3180                   c_parser_consume_token (parser);
3181                   second = c_parser_expr_no_commas (parser, NULL).value;
3182                 }
3183               else
3184                 second = NULL_TREE;
3185               if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
3186                 {
3187                   c_parser_consume_token (parser);
3188                   set_init_index (first, second);
3189                   if (second)
3190                     pedwarn (ellipsis_loc, OPT_pedantic,
3191                              "ISO C forbids specifying range of elements to initialize");
3192                 }
3193               else
3194                 c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
3195                                            "expected %<]%>");
3196             }
3197         }
3198       if (des_seen >= 1)
3199         {
3200           if (c_parser_next_token_is (parser, CPP_EQ))
3201             {
3202               if (!flag_isoc99)
3203                 pedwarn (des_loc, OPT_pedantic,
3204                          "ISO C90 forbids specifying subobject to initialize");
3205               c_parser_consume_token (parser);
3206             }
3207           else
3208             {
3209               if (des_seen == 1)
3210                 pedwarn (c_parser_peek_token (parser)->location, OPT_pedantic,
3211                          "obsolete use of designated initializer without %<=%>");
3212               else
3213                 {
3214                   struct c_expr init;
3215                   init.value = error_mark_node;
3216                   init.original_code = ERROR_MARK;
3217                   c_parser_error (parser, "expected %<=%>");
3218                   c_parser_skip_until_found (parser, CPP_COMMA, NULL);
3219                   process_init_element (init, false);
3220                   return;
3221                 }
3222             }
3223         }
3224     }
3225   c_parser_initval (parser, NULL);
3226 }
3227
3228 /* Parse a nested initializer; as c_parser_initializer but parses
3229    initializers within braced lists, after any designators have been
3230    applied.  If AFTER is not NULL then it is an Objective-C message
3231    expression which is the primary-expression starting the
3232    initializer.  */
3233
3234 static void
3235 c_parser_initval (c_parser *parser, struct c_expr *after)
3236 {
3237   struct c_expr init;
3238   gcc_assert (!after || c_dialect_objc ());
3239   if (c_parser_next_token_is (parser, CPP_OPEN_BRACE) && !after)
3240     init = c_parser_braced_init (parser, NULL_TREE, true);
3241   else
3242     {
3243       init = c_parser_expr_no_commas (parser, after);
3244       if (init.value != NULL_TREE
3245           && TREE_CODE (init.value) != STRING_CST
3246           && TREE_CODE (init.value) != COMPOUND_LITERAL_EXPR)
3247         init = default_function_array_conversion (init);
3248     }
3249   process_init_element (init, false);
3250 }
3251
3252 /* Parse a compound statement (possibly a function body) (C90 6.6.2,
3253    C99 6.8.2).
3254
3255    compound-statement:
3256      { block-item-list[opt] }
3257      { label-declarations block-item-list }
3258
3259    block-item-list:
3260      block-item
3261      block-item-list block-item
3262
3263    block-item:
3264      nested-declaration
3265      statement
3266
3267    nested-declaration:
3268      declaration
3269
3270    GNU extensions:
3271
3272    compound-statement:
3273      { label-declarations block-item-list }
3274
3275    nested-declaration:
3276      __extension__ nested-declaration
3277      nested-function-definition
3278
3279    label-declarations:
3280      label-declaration
3281      label-declarations label-declaration
3282
3283    label-declaration:
3284      __label__ identifier-list ;
3285
3286    Allowing the mixing of declarations and code is new in C99.  The
3287    GNU syntax also permits (not shown above) labels at the end of
3288    compound statements, which yield an error.  We don't allow labels
3289    on declarations; this might seem like a natural extension, but
3290    there would be a conflict between attributes on the label and
3291    prefix attributes on the declaration.  ??? The syntax follows the
3292    old parser in requiring something after label declarations.
3293    Although they are erroneous if the labels declared aren't defined,
3294    is it useful for the syntax to be this way?
3295
3296    OpenMP:
3297
3298    block-item:
3299      openmp-directive
3300
3301    openmp-directive:
3302      barrier-directive
3303      flush-directive  */
3304
3305 static tree
3306 c_parser_compound_statement (c_parser *parser)
3307 {
3308   tree stmt;
3309   if (!c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>"))
3310     {
3311       /* Ensure a scope is entered and left anyway to avoid confusion
3312          if we have just prepared to enter a function body.  */
3313       stmt = c_begin_compound_stmt (true);
3314       c_end_compound_stmt (stmt, true);
3315       return error_mark_node;
3316     }
3317   stmt = c_begin_compound_stmt (true);
3318   c_parser_compound_statement_nostart (parser);
3319   return c_end_compound_stmt (stmt, true);
3320 }
3321
3322 /* Parse a compound statement except for the opening brace.  This is
3323    used for parsing both compound statements and statement expressions
3324    (which follow different paths to handling the opening).  */
3325
3326 static void
3327 c_parser_compound_statement_nostart (c_parser *parser)
3328 {
3329   bool last_stmt = false;
3330   bool last_label = false;
3331   location_t label_loc = UNKNOWN_LOCATION;  /* Quiet warning.  */
3332   if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
3333     {
3334       c_parser_consume_token (parser);
3335       return;
3336     }
3337   if (c_parser_next_token_is_keyword (parser, RID_LABEL))
3338     {
3339       location_t err_loc = c_parser_peek_token (parser)->location;
3340       /* Read zero or more forward-declarations for labels that nested
3341          functions can jump to.  */
3342       while (c_parser_next_token_is_keyword (parser, RID_LABEL))
3343         {
3344           c_parser_consume_token (parser);
3345           /* Any identifiers, including those declared as type names,
3346              are OK here.  */
3347           while (true)
3348             {
3349               tree label;
3350               if (c_parser_next_token_is_not (parser, CPP_NAME))
3351                 {
3352                   c_parser_error (parser, "expected identifier");
3353                   break;
3354                 }
3355               label
3356                 = declare_label (c_parser_peek_token (parser)->value);
3357               C_DECLARED_LABEL_FLAG (label) = 1;
3358               add_stmt (build_stmt (DECL_EXPR, label));
3359               c_parser_consume_token (parser);
3360               if (c_parser_next_token_is (parser, CPP_COMMA))
3361                 c_parser_consume_token (parser);
3362               else
3363                 break;
3364             }
3365           c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
3366         }
3367       pedwarn (err_loc, OPT_pedantic, "ISO C forbids label declarations");
3368     }
3369   /* We must now have at least one statement, label or declaration.  */
3370   if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
3371     {
3372       c_parser_error (parser, "expected declaration or statement");
3373       c_parser_consume_token (parser);
3374       return;
3375     }
3376   while (c_parser_next_token_is_not (parser, CPP_CLOSE_BRACE))
3377     {
3378       location_t loc = c_parser_peek_token (parser)->location;
3379       if (c_parser_next_token_is_keyword (parser, RID_CASE)
3380           || c_parser_next_token_is_keyword (parser, RID_DEFAULT)
3381           || (c_parser_next_token_is (parser, CPP_NAME)
3382               && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
3383         {
3384           if (c_parser_next_token_is_keyword (parser, RID_CASE))
3385             label_loc = c_parser_peek_2nd_token (parser)->location;
3386           else
3387             label_loc = c_parser_peek_token (parser)->location;
3388           last_label = true;
3389           last_stmt = false;
3390           c_parser_label (parser);
3391         }
3392       else if (!last_label
3393                && c_parser_next_token_starts_declspecs (parser))
3394         {
3395           last_label = false;
3396           c_parser_declaration_or_fndef (parser, true, true, true, true);
3397           if (last_stmt)
3398             pedwarn_c90 (loc,
3399                          (pedantic && !flag_isoc99)
3400                          ? OPT_pedantic
3401                          : OPT_Wdeclaration_after_statement,
3402                          "ISO C90 forbids mixed declarations and code");
3403           last_stmt = false;
3404         }
3405       else if (!last_label
3406                && c_parser_next_token_is_keyword (parser, RID_EXTENSION))
3407         {
3408           /* __extension__ can start a declaration, but is also an
3409              unary operator that can start an expression.  Consume all
3410              but the last of a possible series of __extension__ to
3411              determine which.  */
3412           while (c_parser_peek_2nd_token (parser)->type == CPP_KEYWORD
3413                  && (c_parser_peek_2nd_token (parser)->keyword
3414                      == RID_EXTENSION))
3415             c_parser_consume_token (parser);
3416           if (c_token_starts_declspecs (c_parser_peek_2nd_token (parser)))
3417             {
3418               int ext;
3419               ext = disable_extension_diagnostics ();
3420               c_parser_consume_token (parser);
3421               last_label = false;
3422               c_parser_declaration_or_fndef (parser, true, true, true, true);
3423               /* Following the old parser, __extension__ does not
3424                  disable this diagnostic.  */
3425               restore_extension_diagnostics (ext);
3426               if (last_stmt)
3427                 pedwarn_c90 (loc, (pedantic && !flag_isoc99)
3428                              ? OPT_pedantic
3429                              : OPT_Wdeclaration_after_statement,
3430                              "ISO C90 forbids mixed declarations and code");
3431               last_stmt = false;
3432             }
3433           else
3434             goto statement;
3435         }
3436       else if (c_parser_next_token_is (parser, CPP_PRAGMA))
3437         {
3438           /* External pragmas, and some omp pragmas, are not associated
3439              with regular c code, and so are not to be considered statements
3440              syntactically.  This ensures that the user doesn't put them
3441              places that would turn into syntax errors if the directive
3442              were ignored.  */
3443           if (c_parser_pragma (parser, pragma_compound))
3444             last_label = false, last_stmt = true;
3445         }
3446       else if (c_parser_next_token_is (parser, CPP_EOF))
3447         {
3448           c_parser_error (parser, "expected declaration or statement");
3449           return;
3450         }
3451       else if (c_parser_next_token_is_keyword (parser, RID_ELSE))
3452         {
3453           if (parser->in_if_block)
3454             {
3455               error_at (loc, """expected %<}%> before %<else%>");
3456               return;
3457             }
3458           else
3459             {
3460               error_at (loc, "%<else%> without a previous %<if%>");
3461               c_parser_consume_token (parser);
3462               continue;
3463             }
3464         }
3465       else
3466         {
3467         statement:
3468           last_label = false;
3469           last_stmt = true;
3470           c_parser_statement_after_labels (parser);
3471         }
3472
3473       parser->error = false;
3474     }
3475   if (last_label)
3476     error_at (label_loc, "label at end of compound statement");
3477   c_parser_consume_token (parser);
3478 }
3479
3480 /* Parse a label (C90 6.6.1, C99 6.8.1).
3481
3482    label:
3483      identifier : attributes[opt]
3484      case constant-expression :
3485      default :
3486
3487    GNU extensions:
3488
3489    label:
3490      case constant-expression ... constant-expression :
3491
3492    The use of attributes on labels is a GNU extension.  The syntax in
3493    GNU C accepts any expressions without commas, non-constant
3494    expressions being rejected later.  */
3495
3496 static void
3497 c_parser_label (c_parser *parser)
3498 {
3499   location_t loc1 = c_parser_peek_token (parser)->location;
3500   tree label = NULL_TREE;
3501   if (c_parser_next_token_is_keyword (parser, RID_CASE))
3502     {
3503       tree exp1, exp2;
3504       c_parser_consume_token (parser);
3505       exp1 = c_parser_expr_no_commas (parser, NULL).value;
3506       if (c_parser_next_token_is (parser, CPP_COLON))
3507         {
3508           c_parser_consume_token (parser);
3509           label = do_case (exp1, NULL_TREE);
3510         }
3511       else if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
3512         {
3513           c_parser_consume_token (parser);
3514           exp2 = c_parser_expr_no_commas (parser, NULL).value;
3515           if (c_parser_require (parser, CPP_COLON, "expected %<:%>"))
3516             label = do_case (exp1, exp2);
3517         }
3518       else
3519         c_parser_error (parser, "expected %<:%> or %<...%>");
3520     }
3521   else if (c_parser_next_token_is_keyword (parser, RID_DEFAULT))
3522     {
3523       c_parser_consume_token (parser);
3524       if (c_parser_require (parser, CPP_COLON, "expected %<:%>"))
3525         label = do_case (NULL_TREE, NULL_TREE);
3526     }
3527   else
3528     {
3529       tree name = c_parser_peek_token (parser)->value;
3530       tree tlab;
3531       tree attrs;
3532       location_t loc2 = c_parser_peek_token (parser)->location;
3533       gcc_assert (c_parser_next_token_is (parser, CPP_NAME));
3534       c_parser_consume_token (parser);
3535       gcc_assert (c_parser_next_token_is (parser, CPP_COLON));
3536       c_parser_consume_token (parser);
3537       attrs = c_parser_attributes (parser);
3538       tlab = define_label (loc2, name);
3539       if (tlab)
3540         {
3541           decl_attributes (&tlab, attrs, 0);
3542           label = add_stmt (build_stmt (LABEL_EXPR, tlab));
3543         }
3544     }
3545   if (label)
3546     {
3547       SET_EXPR_LOCATION (label, loc1);
3548       if (c_parser_next_token_starts_declspecs (parser)
3549           && !(c_parser_next_token_is (parser, CPP_NAME)
3550                && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
3551         {
3552           error_at (c_parser_peek_token (parser)->location,
3553                     "a label can only be part of a statement and "
3554                     "a declaration is not a statement");
3555           c_parser_declaration_or_fndef (parser, /*fndef_ok*/ false,
3556                                          /*nested*/ true, /*empty_ok*/ false,
3557                                          /*start_attr_ok*/ true);
3558         }
3559     }
3560 }
3561
3562 /* Parse a statement (C90 6.6, C99 6.8).
3563
3564    statement:
3565      labeled-statement
3566      compound-statement
3567      expression-statement
3568      selection-statement
3569      iteration-statement
3570      jump-statement
3571
3572    labeled-statement:
3573      label statement
3574
3575    expression-statement:
3576      expression[opt] ;
3577
3578    selection-statement:
3579      if-statement
3580      switch-statement
3581
3582    iteration-statement:
3583      while-statement
3584      do-statement
3585      for-statement
3586
3587    jump-statement:
3588      goto identifier ;
3589      continue ;
3590      break ;
3591      return expression[opt] ;
3592
3593    GNU extensions:
3594
3595    statement:
3596      asm-statement
3597
3598    jump-statement:
3599      goto * expression ;
3600
3601    Objective-C:
3602
3603    statement:
3604      objc-throw-statement
3605      objc-try-catch-statement
3606      objc-synchronized-statement
3607
3608    objc-throw-statement:
3609      @throw expression ;
3610      @throw ;
3611
3612    OpenMP:
3613
3614    statement:
3615      openmp-construct
3616
3617    openmp-construct:
3618      parallel-construct
3619      for-construct
3620      sections-construct
3621      single-construct
3622      parallel-for-construct
3623      parallel-sections-construct
3624      master-construct
3625      critical-construct
3626      atomic-construct
3627      ordered-construct
3628
3629    parallel-construct:
3630      parallel-directive structured-block
3631
3632    for-construct:
3633      for-directive iteration-statement
3634
3635    sections-construct:
3636      sections-directive section-scope
3637
3638    single-construct:
3639      single-directive structured-block
3640
3641    parallel-for-construct:
3642      parallel-for-directive iteration-statement
3643
3644    parallel-sections-construct:
3645      parallel-sections-directive section-scope
3646
3647    master-construct:
3648      master-directive structured-block
3649
3650    critical-construct:
3651      critical-directive structured-block
3652
3653    atomic-construct:
3654      atomic-directive expression-statement
3655
3656    ordered-construct:
3657      ordered-directive structured-block  */
3658
3659 static void
3660 c_parser_statement (c_parser *parser)
3661 {
3662   while (c_parser_next_token_is_keyword (parser, RID_CASE)
3663          || c_parser_next_token_is_keyword (parser, RID_DEFAULT)
3664          || (c_parser_next_token_is (parser, CPP_NAME)
3665              && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
3666     c_parser_label (parser);
3667   c_parser_statement_after_labels (parser);
3668 }
3669
3670 /* Parse a statement, other than a labeled statement.  */
3671
3672 static void
3673 c_parser_statement_after_labels (c_parser *parser)
3674 {
3675   location_t loc = c_parser_peek_token (parser)->location;
3676   tree stmt = NULL_TREE;
3677   bool in_if_block = parser->in_if_block;
3678   parser->in_if_block = false;
3679   switch (c_parser_peek_token (parser)->type)
3680     {
3681     case CPP_OPEN_BRACE:
3682       add_stmt (c_parser_compound_statement (parser));
3683       break;
3684     case CPP_KEYWORD:
3685       switch (c_parser_peek_token (parser)->keyword)
3686         {
3687         case RID_IF:
3688           c_parser_if_statement (parser);
3689           break;
3690         case RID_SWITCH:
3691           c_parser_switch_statement (parser);
3692           break;
3693         case RID_WHILE:
3694           c_parser_while_statement (parser);
3695           break;
3696         case RID_DO:
3697           c_parser_do_statement (parser);
3698           break;
3699         case RID_FOR:
3700           c_parser_for_statement (parser);
3701           break;
3702         case RID_GOTO:
3703           c_parser_consume_token (parser);
3704           if (c_parser_next_token_is (parser, CPP_NAME))
3705             {
3706               stmt = c_finish_goto_label (c_parser_peek_token (parser)->value);
3707               c_parser_consume_token (parser);
3708             }
3709           else if (c_parser_next_token_is (parser, CPP_MULT))
3710             {
3711               c_parser_consume_token (parser);
3712               stmt = c_finish_goto_ptr (c_parser_expression (parser).value);
3713             }
3714           else
3715             c_parser_error (parser, "expected identifier or %<*%>");
3716           goto expect_semicolon;
3717         case RID_CONTINUE:
3718           c_parser_consume_token (parser);
3719           stmt = c_finish_bc_stmt (&c_cont_label, false);
3720           goto expect_semicolon;
3721         case RID_BREAK:
3722           c_parser_consume_token (parser);
3723           stmt = c_finish_bc_stmt (&c_break_label, true);
3724           goto expect_semicolon;
3725         case RID_RETURN:
3726           c_parser_consume_token (parser);
3727           if (c_parser_next_token_is (parser, CPP_SEMICOLON))
3728             {
3729               stmt = c_finish_return (NULL_TREE);
3730               c_parser_consume_token (parser);
3731             }
3732           else
3733             {
3734               stmt = c_finish_return (c_parser_expression_conv (parser).value);
3735               goto expect_semicolon;
3736             }
3737           break;
3738         case RID_ASM:
3739           stmt = c_parser_asm_statement (parser);
3740           break;
3741         case RID_THROW:
3742           gcc_assert (c_dialect_objc ());
3743           c_parser_consume_token (parser);
3744           if (c_parser_next_token_is (parser, CPP_SEMICOLON))
3745             {
3746               stmt = objc_build_throw_stmt (NULL_TREE);
3747               c_parser_consume_token (parser);
3748             }
3749           else
3750             {
3751               stmt
3752                 = objc_build_throw_stmt (c_parser_expression (parser).value);
3753               goto expect_semicolon;
3754             }
3755           break;
3756         case RID_TRY:
3757           gcc_assert (c_dialect_objc ());
3758           c_parser_objc_try_catch_statement (parser);
3759           break;
3760         case RID_AT_SYNCHRONIZED:
3761           gcc_assert (c_dialect_objc ());
3762           c_parser_objc_synchronized_statement (parser);
3763           break;
3764         default:
3765           goto expr_stmt;
3766         }
3767       break;
3768     case CPP_SEMICOLON:
3769       c_parser_consume_token (parser);
3770       break;
3771     case CPP_CLOSE_PAREN:
3772     case CPP_CLOSE_SQUARE:
3773       /* Avoid infinite loop in error recovery:
3774          c_parser_skip_until_found stops at a closing nesting
3775          delimiter without consuming it, but here we need to consume
3776          it to proceed further.  */
3777       c_parser_error (parser, "expected statement");
3778       c_parser_consume_token (parser);
3779       break;
3780     case CPP_PRAGMA:
3781       c_parser_pragma (parser, pragma_stmt);
3782       break;
3783     default:
3784     expr_stmt:
3785       stmt = c_finish_expr_stmt (c_parser_expression_conv (parser).value);
3786     expect_semicolon:
3787       c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
3788       break;
3789     }
3790   /* Two cases cannot and do not have line numbers associated: If stmt
3791      is degenerate, such as "2;", then stmt is an INTEGER_CST, which
3792      cannot hold line numbers.  But that's OK because the statement
3793      will either be changed to a MODIFY_EXPR during gimplification of
3794      the statement expr, or discarded.  If stmt was compound, but
3795      without new variables, we will have skipped the creation of a
3796      BIND and will have a bare STATEMENT_LIST.  But that's OK because
3797      (recursively) all of the component statements should already have
3798      line numbers assigned.  ??? Can we discard no-op statements
3799      earlier?  */
3800   protected_set_expr_location (stmt, loc);
3801
3802   parser->in_if_block = in_if_block;
3803 }
3804
3805 /* Parse the condition from an if, do, while or for statements.  */
3806
3807 static tree
3808 c_parser_condition (c_parser *parser)
3809 {
3810   location_t loc;
3811   tree cond;
3812   loc = c_parser_peek_token (parser)->location;
3813   cond = c_objc_common_truthvalue_conversion
3814     (loc, c_parser_expression_conv (parser).value);
3815   protected_set_expr_location (cond, loc);
3816   if (warn_sequence_point)
3817     verify_sequence_points (cond);
3818   return cond;
3819 }
3820
3821 /* Parse a parenthesized condition from an if, do or while statement.
3822
3823    condition:
3824      ( expression )
3825 */
3826 static tree
3827 c_parser_paren_condition (c_parser *parser)
3828 {
3829   tree cond;
3830   if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
3831     return error_mark_node;
3832   cond = c_parser_condition (parser);
3833   c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
3834   return cond;
3835 }
3836
3837 /* Parse a statement which is a block in C99.  */
3838
3839 static tree
3840 c_parser_c99_block_statement (c_parser *parser)
3841 {
3842   tree block = c_begin_compound_stmt (flag_isoc99);
3843   c_parser_statement (parser);
3844   return c_end_compound_stmt (block, flag_isoc99);
3845 }
3846
3847 /* Parse the body of an if statement.  This is just parsing a
3848    statement but (a) it is a block in C99, (b) we track whether the
3849    body is an if statement for the sake of -Wparentheses warnings, (c)
3850    we handle an empty body specially for the sake of -Wempty-body
3851    warnings, and (d) we call parser_compound_statement directly
3852    because c_parser_statement_after_labels resets
3853    parser->in_if_block.  */
3854
3855 static tree
3856 c_parser_if_body (c_parser *parser, bool *if_p)
3857 {
3858   tree block = c_begin_compound_stmt (flag_isoc99);
3859   while (c_parser_next_token_is_keyword (parser, RID_CASE)
3860          || c_parser_next_token_is_keyword (parser, RID_DEFAULT)
3861          || (c_parser_next_token_is (parser, CPP_NAME)
3862              && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
3863     c_parser_label (parser);
3864   *if_p = c_parser_next_token_is_keyword (parser, RID_IF);
3865   if (c_parser_next_token_is (parser, CPP_SEMICOLON))
3866     {
3867       location_t loc = c_parser_peek_token (parser)->location;
3868       add_stmt (build_empty_stmt ());
3869       c_parser_consume_token (parser);
3870       if (!c_parser_next_token_is_keyword (parser, RID_ELSE))
3871         warning_at (loc, OPT_Wempty_body,
3872                     "suggest braces around empty body in an %<if%> statement");
3873     }
3874   else if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
3875     add_stmt (c_parser_compound_statement (parser));
3876   else
3877     c_parser_statement_after_labels (parser);
3878   return c_end_compound_stmt (block, flag_isoc99);
3879 }
3880
3881 /* Parse the else body of an if statement.  This is just parsing a
3882    statement but (a) it is a block in C99, (b) we handle an empty body
3883    specially for the sake of -Wempty-body warnings.  */
3884
3885 static tree
3886 c_parser_else_body (c_parser *parser)
3887 {
3888   tree block = c_begin_compound_stmt (flag_isoc99);
3889   while (c_parser_next_token_is_keyword (parser, RID_CASE)
3890          || c_parser_next_token_is_keyword (parser, RID_DEFAULT)
3891          || (c_parser_next_token_is (parser, CPP_NAME)
3892              && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
3893     c_parser_label (parser);
3894   if (c_parser_next_token_is (parser, CPP_SEMICOLON))
3895     {
3896       warning_at (c_parser_peek_token (parser)->location,
3897                   OPT_Wempty_body,
3898                  "suggest braces around empty body in an %<else%> statement");
3899       add_stmt (build_empty_stmt ());
3900       c_parser_consume_token (parser);
3901     }
3902   else
3903     c_parser_statement_after_labels (parser);
3904   return c_end_compound_stmt (block, flag_isoc99);
3905 }
3906
3907 /* Parse an if statement (C90 6.6.4, C99 6.8.4).
3908
3909    if-statement:
3910      if ( expression ) statement
3911      if ( expression ) statement else statement
3912 */
3913
3914 static void
3915 c_parser_if_statement (c_parser *parser)
3916 {
3917   tree block;
3918   location_t loc;
3919   tree cond;
3920   bool first_if = false;
3921   tree first_body, second_body;
3922   bool in_if_block;
3923
3924   gcc_assert (c_parser_next_token_is_keyword (parser, RID_IF));
3925   c_parser_consume_token (parser);
3926   block = c_begin_compound_stmt (flag_isoc99);
3927   loc = c_parser_peek_token (parser)->location;
3928   cond = c_parser_paren_condition (parser);
3929   in_if_block = parser->in_if_block;
3930   parser->in_if_block = true;
3931   first_body = c_parser_if_body (parser, &first_if);
3932   parser->in_if_block = in_if_block;
3933   if (c_parser_next_token_is_keyword (parser, RID_ELSE))
3934     {
3935       c_parser_consume_token (parser);
3936       second_body = c_parser_else_body (parser);
3937     }
3938   else
3939     second_body = NULL_TREE;
3940   c_finish_if_stmt (loc, cond, first_body, second_body, first_if);
3941   add_stmt (c_end_compound_stmt (block, flag_isoc99));
3942 }
3943
3944 /* Parse a switch statement (C90 6.6.4, C99 6.8.4).
3945
3946    switch-statement:
3947      switch (expression) statement
3948 */
3949
3950 static void
3951 c_parser_switch_statement (c_parser *parser)
3952 {
3953   tree block, expr, body, save_break;
3954   gcc_assert (c_parser_next_token_is_keyword (parser, RID_SWITCH));
3955   c_parser_consume_token (parser);
3956   block = c_begin_compound_stmt (flag_isoc99);
3957   if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
3958     {
3959       expr = c_parser_expression (parser).value;
3960       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
3961     }
3962   else
3963     expr = error_mark_node;
3964   c_start_case (expr);
3965   save_break = c_break_label;
3966   c_break_label = NULL_TREE;
3967   body = c_parser_c99_block_statement (parser);
3968   c_finish_case (body);
3969   if (c_break_label)
3970     add_stmt (build1 (LABEL_EXPR, void_type_node, c_break_label));
3971   c_break_label = save_break;
3972   add_stmt (c_end_compound_stmt (block, flag_isoc99));
3973 }
3974
3975 /* Parse a while statement (C90 6.6.5, C99 6.8.5).
3976
3977    while-statement:
3978       while (expression) statement
3979 */
3980
3981 static void
3982 c_parser_while_statement (c_parser *parser)
3983 {
3984   tree block, cond, body, save_break, save_cont;
3985   location_t loc;
3986   gcc_assert (c_parser_next_token_is_keyword (parser, RID_WHILE));
3987   c_parser_consume_token (parser);
3988   block = c_begin_compound_stmt (flag_isoc99);
3989   loc = c_parser_peek_token (parser)->location;
3990   cond = c_parser_paren_condition (parser);
3991   save_break = c_break_label;
3992   c_break_label = NULL_TREE;
3993   save_cont = c_cont_label;
3994   c_cont_label = NULL_TREE;
3995   body = c_parser_c99_block_statement (parser);
3996   c_finish_loop (loc, cond, NULL, body, c_break_label, c_cont_label, true);
3997   add_stmt (c_end_compound_stmt (block, flag_isoc99));
3998   c_break_label = save_break;
3999   c_cont_label = save_cont;
4000 }
4001
4002 /* Parse a do statement (C90 6.6.5, C99 6.8.5).
4003
4004    do-statement:
4005      do statement while ( expression ) ;
4006 */
4007
4008 static void
4009 c_parser_do_statement (c_parser *parser)
4010 {
4011   tree block, cond, body, save_break, save_cont, new_break, new_cont;
4012   location_t loc;
4013   gcc_assert (c_parser_next_token_is_keyword (parser, RID_DO));
4014   c_parser_consume_token (parser);
4015   if (c_parser_next_token_is (parser, CPP_SEMICOLON))
4016     warning_at (c_parser_peek_token (parser)->location,
4017                 OPT_Wempty_body,
4018                 "suggest braces around empty body in %<do%> statement");
4019   block = c_begin_compound_stmt (flag_isoc99);
4020   loc = c_parser_peek_token (parser)->location;
4021   save_break = c_break_label;
4022   c_break_label = NULL_TREE;
4023   save_cont = c_cont_label;
4024   c_cont_label = NULL_TREE;
4025   body = c_parser_c99_block_statement (parser);
4026   c_parser_require_keyword (parser, RID_WHILE, "expected %<while%>");
4027   new_break = c_break_label;
4028   c_break_label = save_break;
4029   new_cont = c_cont_label;
4030   c_cont_label = save_cont;
4031   cond = c_parser_paren_condition (parser);
4032   if (!c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>"))
4033     c_parser_skip_to_end_of_block_or_statement (parser);
4034   c_finish_loop (loc, cond, NULL, body, new_break, new_cont, false);
4035   add_stmt (c_end_compound_stmt (block, flag_isoc99));
4036 }
4037
4038 /* Parse a for statement (C90 6.6.5, C99 6.8.5).
4039
4040    for-statement:
4041      for ( expression[opt] ; expression[opt] ; expression[opt] ) statement
4042      for ( nested-declaration expression[opt] ; expression[opt] ) statement
4043
4044    The form with a declaration is new in C99.
4045
4046    ??? In accordance with the old parser, the declaration may be a
4047    nested function, which is then rejected in check_for_loop_decls,
4048    but does it make any sense for this to be included in the grammar?
4049    Note in particular that the nested function does not include a
4050    trailing ';', whereas the "declaration" production includes one.
4051    Also, can we reject bad declarations earlier and cheaper than
4052    check_for_loop_decls?  */
4053
4054 static void
4055 c_parser_for_statement (c_parser *parser)
4056 {
4057   tree block, cond, incr, save_break, save_cont, body;
4058   location_t loc;
4059   gcc_assert (c_parser_next_token_is_keyword (parser, RID_FOR));
4060   loc = c_parser_peek_token (parser)->location;
4061   c_parser_consume_token (parser);
4062   block = c_begin_compound_stmt (flag_isoc99);
4063   if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
4064     {
4065       /* Parse the initialization declaration or expression.  */
4066       if (c_parser_next_token_is (parser, CPP_SEMICOLON))
4067         {
4068           c_parser_consume_token (parser);
4069           c_finish_expr_stmt (NULL_TREE);
4070         }
4071       else if (c_parser_next_token_starts_declspecs (parser))
4072         {
4073           c_parser_declaration_or_fndef (parser, true, true, true, true);
4074           check_for_loop_decls ();
4075         }
4076       else if (c_parser_next_token_is_keyword (parser, RID_EXTENSION))
4077         {
4078           /* __extension__ can start a declaration, but is also an
4079              unary operator that can start an expression.  Consume all
4080              but the last of a possible series of __extension__ to
4081              determine which.  */
4082           while (c_parser_peek_2nd_token (parser)->type == CPP_KEYWORD
4083                  && (c_parser_peek_2nd_token (parser)->keyword
4084                      == RID_EXTENSION))
4085             c_parser_consume_token (parser);
4086           if (c_token_starts_declspecs (c_parser_peek_2nd_token (parser)))
4087             {
4088               int ext;
4089               ext = disable_extension_diagnostics ();
4090               c_parser_consume_token (parser);
4091               c_parser_declaration_or_fndef (parser, true, true, true, true);
4092               restore_extension_diagnostics (ext);
4093               check_for_loop_decls ();
4094             }
4095           else
4096             goto init_expr;
4097         }
4098       else
4099         {
4100         init_expr:
4101           c_finish_expr_stmt (c_parser_expression (parser).value);
4102           c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
4103         }
4104       /* Parse the loop condition.  */
4105       if (c_parser_next_token_is (parser, CPP_SEMICOLON))
4106         {
4107           c_parser_consume_token (parser);
4108           cond = NULL_TREE;
4109         }
4110       else
4111         {
4112           cond = c_parser_condition (parser);
4113           c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
4114         }
4115       /* Parse the increment expression.  */
4116       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
4117         incr = c_process_expr_stmt (NULL_TREE);
4118       else
4119         incr = c_process_expr_stmt (c_parser_expression (parser).value);
4120       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
4121     }
4122   else
4123     {
4124       cond = error_mark_node;
4125       incr = error_mark_node;
4126     }
4127   save_break = c_break_label;
4128   c_break_label = NULL_TREE;
4129   save_cont = c_cont_label;
4130   c_cont_label = NULL_TREE;
4131   body = c_parser_c99_block_statement (parser);
4132   c_finish_loop (loc, cond, incr, body, c_break_label, c_cont_label, true);
4133   add_stmt (c_end_compound_stmt (block, flag_isoc99));
4134   c_break_label = save_break;
4135   c_cont_label = save_cont;
4136 }
4137
4138 /* Parse an asm statement, a GNU extension.  This is a full-blown asm
4139    statement with inputs, outputs, clobbers, and volatile tag
4140    allowed.
4141
4142    asm-statement:
4143      asm type-qualifier[opt] ( asm-argument ) ;
4144
4145    asm-argument:
4146      asm-string-literal
4147      asm-string-literal : asm-operands[opt]
4148      asm-string-literal : asm-operands[opt] : asm-operands[opt]
4149      asm-string-literal : asm-operands[opt] : asm-operands[opt] : asm-clobbers
4150
4151    Qualifiers other than volatile are accepted in the syntax but
4152    warned for.  */
4153
4154 static tree
4155 c_parser_asm_statement (c_parser *parser)
4156 {
4157   tree quals, str, outputs, inputs, clobbers, ret;
4158   bool simple;
4159   gcc_assert (c_parser_next_token_is_keyword (parser, RID_ASM));
4160   c_parser_consume_token (parser);
4161   if (c_parser_next_token_is_keyword (parser, RID_VOLATILE))
4162     {
4163       quals = c_parser_peek_token (parser)->value;
4164       c_parser_consume_token (parser);
4165     }
4166   else if (c_parser_next_token_is_keyword (parser, RID_CONST)
4167            || c_parser_next_token_is_keyword (parser, RID_RESTRICT))
4168     {
4169       warning_at (c_parser_peek_token (parser)->location,
4170                   0,
4171                   "%E qualifier ignored on asm",
4172                   c_parser_peek_token (parser)->value);
4173       quals = NULL_TREE;
4174       c_parser_consume_token (parser);
4175     }
4176   else
4177     quals = NULL_TREE;
4178   /* ??? Follow the C++ parser rather than using the
4179      lex_untranslated_string kludge.  */
4180   parser->lex_untranslated_string = true;
4181   if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
4182     {
4183       parser->lex_untranslated_string = false;
4184       return NULL_TREE;
4185     }
4186   str = c_parser_asm_string_literal (parser);
4187   if (str == NULL_TREE)
4188     {
4189       parser->lex_untranslated_string = false;
4190       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
4191       return NULL_TREE;
4192     }
4193   if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
4194     {
4195       simple = true;
4196       outputs = NULL_TREE;
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   simple = false;
4208   /* Parse outputs.  */
4209   if (c_parser_next_token_is (parser, CPP_COLON)
4210       || c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
4211     outputs = NULL_TREE;
4212   else
4213     outputs = c_parser_asm_operands (parser, false);
4214   if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
4215     {
4216       inputs = NULL_TREE;
4217       clobbers = NULL_TREE;
4218       goto done_asm;
4219     }
4220   if (!c_parser_require (parser, CPP_COLON, "expected %<:%> or %<)%>"))
4221     {
4222       parser->lex_untranslated_string = false;
4223       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
4224       return NULL_TREE;
4225     }
4226   /* Parse inputs.  */
4227   if (c_parser_next_token_is (parser, CPP_COLON)
4228       || c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
4229     inputs = NULL_TREE;
4230   else
4231     inputs = c_parser_asm_operands (parser, true);
4232   if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
4233     {
4234       clobbers = NULL_TREE;
4235       goto done_asm;
4236     }
4237   if (!c_parser_require (parser, CPP_COLON, "expected %<:%> or %<)%>"))
4238     {
4239       parser->lex_untranslated_string = false;
4240       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
4241       return NULL_TREE;
4242     }
4243   /* Parse clobbers.  */
4244   clobbers = c_parser_asm_clobbers (parser);
4245  done_asm:
4246   parser->lex_untranslated_string = false;
4247   if (!c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
4248     {
4249       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
4250       return NULL_TREE;
4251     }
4252   if (!c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>"))
4253     c_parser_skip_to_end_of_block_or_statement (parser);
4254   ret = build_asm_stmt (quals, build_asm_expr (str, outputs, inputs,
4255                                                clobbers, simple));
4256   return ret;
4257 }
4258
4259 /* Parse asm operands, a GNU extension.  If CONVERT_P (for inputs but
4260    not outputs), apply the default conversion of functions and arrays
4261    to pointers.
4262
4263    asm-operands:
4264      asm-operand
4265      asm-operands , asm-operand
4266
4267    asm-operand:
4268      asm-string-literal ( expression )
4269      [ identifier ] asm-string-literal ( expression )
4270 */
4271
4272 static tree
4273 c_parser_asm_operands (c_parser *parser, bool convert_p)
4274 {
4275   tree list = NULL_TREE;
4276   while (true)
4277     {
4278       tree name, str;
4279       struct c_expr expr;
4280       if (c_parser_next_token_is (parser, CPP_OPEN_SQUARE))
4281         {
4282           c_parser_consume_token (parser);
4283           if (c_parser_next_token_is (parser, CPP_NAME))
4284             {
4285               tree id = c_parser_peek_token (parser)->value;
4286               c_parser_consume_token (parser);
4287               name = build_string (IDENTIFIER_LENGTH (id),
4288                                    IDENTIFIER_POINTER (id));
4289             }
4290           else
4291             {
4292               c_parser_error (parser, "expected identifier");
4293               c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, NULL);
4294               return NULL_TREE;
4295             }
4296           c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
4297                                      "expected %<]%>");
4298         }
4299       else
4300         name = NULL_TREE;
4301       str = c_parser_asm_string_literal (parser);
4302       if (str == NULL_TREE)
4303         return NULL_TREE;
4304       parser->lex_untranslated_string = false;
4305       if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
4306         {
4307           parser->lex_untranslated_string = true;
4308           return NULL_TREE;
4309         }
4310       expr = c_parser_expression (parser);
4311       if (convert_p)
4312         expr = default_function_array_conversion (expr);
4313       parser->lex_untranslated_string = true;
4314       if (!c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
4315         {
4316           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
4317           return NULL_TREE;
4318         }
4319       list = chainon (list, build_tree_list (build_tree_list (name, str),
4320                                              expr.value));
4321       if (c_parser_next_token_is (parser, CPP_COMMA))
4322         c_parser_consume_token (parser);
4323       else
4324         break;
4325     }
4326   return list;
4327 }
4328
4329 /* Parse asm clobbers, a GNU extension.
4330
4331    asm-clobbers:
4332      asm-string-literal
4333      asm-clobbers , asm-string-literal
4334 */
4335
4336 static tree
4337 c_parser_asm_clobbers (c_parser *parser)
4338 {
4339   tree list = NULL_TREE;
4340   while (true)
4341     {
4342       tree str = c_parser_asm_string_literal (parser);
4343       if (str)
4344         list = tree_cons (NULL_TREE, str, list);
4345       else
4346         return NULL_TREE;
4347       if (c_parser_next_token_is (parser, CPP_COMMA))
4348         c_parser_consume_token (parser);
4349       else
4350         break;
4351     }
4352   return list;
4353 }
4354
4355 /* Parse an expression other than a compound expression; that is, an
4356    assignment expression (C90 6.3.16, C99 6.5.16).  If AFTER is not
4357    NULL then it is an Objective-C message expression which is the
4358    primary-expression starting the expression as an initializer.
4359
4360    assignment-expression:
4361      conditional-expression
4362      unary-expression assignment-operator assignment-expression
4363
4364    assignment-operator: one of
4365      = *= /= %= += -= <<= >>= &= ^= |=
4366
4367    In GNU C we accept any conditional expression on the LHS and
4368    diagnose the invalid lvalue rather than producing a syntax
4369    error.  */
4370
4371 static struct c_expr
4372 c_parser_expr_no_commas (c_parser *parser, struct c_expr *after)
4373 {
4374   struct c_expr lhs, rhs, ret;
4375   enum tree_code code;
4376   location_t op_location;
4377   gcc_assert (!after || c_dialect_objc ());
4378   lhs = c_parser_conditional_expression (parser, after);
4379   op_location = c_parser_peek_token (parser)->location;
4380   switch (c_parser_peek_token (parser)->type)
4381     {
4382     case CPP_EQ:
4383       code = NOP_EXPR;
4384       break;
4385     case CPP_MULT_EQ:
4386       code = MULT_EXPR;
4387       break;
4388     case CPP_DIV_EQ:
4389       code = TRUNC_DIV_EXPR;
4390       break;
4391     case CPP_MOD_EQ:
4392       code = TRUNC_MOD_EXPR;
4393       break;
4394     case CPP_PLUS_EQ:
4395       code = PLUS_EXPR;
4396       break;
4397     case CPP_MINUS_EQ:
4398       code = MINUS_EXPR;
4399       break;
4400     case CPP_LSHIFT_EQ:
4401       code = LSHIFT_EXPR;
4402       break;
4403     case CPP_RSHIFT_EQ:
4404       code = RSHIFT_EXPR;
4405       break;
4406     case CPP_AND_EQ:
4407       code = BIT_AND_EXPR;
4408       break;
4409     case CPP_XOR_EQ:
4410       code = BIT_XOR_EXPR;
4411       break;
4412     case CPP_OR_EQ:
4413       code = BIT_IOR_EXPR;
4414       break;
4415     default:
4416       return lhs;
4417     }
4418   c_parser_consume_token (parser);
4419   rhs = c_parser_expr_no_commas (parser, NULL);
4420   rhs = default_function_array_conversion (rhs);
4421   ret.value = build_modify_expr (op_location, lhs.value, code, rhs.value);
4422   if (code == NOP_EXPR)
4423     ret.original_code = MODIFY_EXPR;
4424   else
4425     {
4426       TREE_NO_WARNING (ret.value) = 1;
4427       ret.original_code = ERROR_MARK;
4428     }
4429   return ret;
4430 }
4431
4432 /* Parse a conditional expression (C90 6.3.15, C99 6.5.15).  If AFTER
4433    is not NULL then it is an Objective-C message expression which is
4434    the primary-expression starting the expression as an initializer.
4435
4436    conditional-expression:
4437      logical-OR-expression
4438      logical-OR-expression ? expression : conditional-expression
4439
4440    GNU extensions:
4441
4442    conditional-expression:
4443      logical-OR-expression ? : conditional-expression
4444 */
4445
4446 static struct c_expr
4447 c_parser_conditional_expression (c_parser *parser, struct c_expr *after)
4448 {
4449   struct c_expr cond, exp1, exp2, ret;
4450   location_t cond_loc;
4451
4452   gcc_assert (!after || c_dialect_objc ());
4453
4454   cond_loc = c_parser_peek_token (parser)->location;
4455   cond = c_parser_binary_expression (parser, after);
4456   protected_set_expr_location (cond.value, cond_loc);
4457
4458   if (c_parser_next_token_is_not (parser, CPP_QUERY))
4459     return cond;
4460   cond = default_function_array_conversion (cond);
4461   c_parser_consume_token (parser);
4462   if (c_parser_next_token_is (parser, CPP_COLON))
4463     {
4464       pedwarn (c_parser_peek_token (parser)->location, OPT_pedantic,
4465                "ISO C forbids omitting the middle term of a ?: expression");
4466       /* Make sure first operand is calculated only once.  */
4467       exp1.value = save_expr (default_conversion (cond.value));
4468       cond.value = c_objc_common_truthvalue_conversion (cond_loc, exp1.value);
4469       skip_evaluation += cond.value == truthvalue_true_node;
4470     }
4471   else
4472     {
4473       cond.value
4474         = c_objc_common_truthvalue_conversion
4475         (cond_loc, default_conversion (cond.value));
4476       skip_evaluation += cond.value == truthvalue_false_node;
4477       exp1 = c_parser_expression_conv (parser);
4478       skip_evaluation += ((cond.value == truthvalue_true_node)
4479                           - (cond.value == truthvalue_false_node));
4480     }
4481   if (!c_parser_require (parser, CPP_COLON, "expected %<:%>"))
4482     {
4483       skip_evaluation -= cond.value == truthvalue_true_node;
4484       ret.value = error_mark_node;
4485       ret.original_code = ERROR_MARK;
4486       return ret;
4487     }
4488   exp2 = c_parser_conditional_expression (parser, NULL);
4489   exp2 = default_function_array_conversion (exp2);
4490   skip_evaluation -= cond.value == truthvalue_true_node;
4491   ret.value = build_conditional_expr (cond.value, exp1.value, exp2.value);
4492   ret.original_code = ERROR_MARK;
4493   return ret;
4494 }
4495
4496 /* Parse a binary expression; that is, a logical-OR-expression (C90
4497    6.3.5-6.3.14, C99 6.5.5-6.5.14).  If AFTER is not NULL then it is
4498    an Objective-C message expression which is the primary-expression
4499    starting the expression as an initializer.
4500
4501    multiplicative-expression:
4502      cast-expression
4503      multiplicative-expression * cast-expression
4504      multiplicative-expression / cast-expression
4505      multiplicative-expression % cast-expression
4506
4507    additive-expression:
4508      multiplicative-expression
4509      additive-expression + multiplicative-expression
4510      additive-expression - multiplicative-expression
4511
4512    shift-expression:
4513      additive-expression
4514      shift-expression << additive-expression
4515      shift-expression >> additive-expression
4516
4517    relational-expression:
4518      shift-expression
4519      relational-expression < shift-expression
4520      relational-expression > shift-expression
4521      relational-expression <= shift-expression
4522      relational-expression >= shift-expression
4523
4524    equality-expression:
4525      relational-expression
4526      equality-expression == relational-expression
4527      equality-expression != relational-expression
4528
4529    AND-expression:
4530      equality-expression
4531      AND-expression & equality-expression
4532
4533    exclusive-OR-expression:
4534      AND-expression
4535      exclusive-OR-expression ^ AND-expression
4536
4537    inclusive-OR-expression:
4538      exclusive-OR-expression
4539      inclusive-OR-expression | exclusive-OR-expression
4540
4541    logical-AND-expression:
4542      inclusive-OR-expression
4543      logical-AND-expression && inclusive-OR-expression
4544
4545    logical-OR-expression:
4546      logical-AND-expression
4547      logical-OR-expression || logical-AND-expression
4548 */
4549
4550 static struct c_expr
4551 c_parser_binary_expression (c_parser *parser, struct c_expr *after)
4552 {
4553   /* A binary expression is parsed using operator-precedence parsing,
4554      with the operands being cast expressions.  All the binary
4555      operators are left-associative.  Thus a binary expression is of
4556      form:
4557
4558      E0 op1 E1 op2 E2 ...
4559
4560      which we represent on a stack.  On the stack, the precedence
4561      levels are strictly increasing.  When a new operator is
4562      encountered of higher precedence than that at the top of the
4563      stack, it is pushed; its LHS is the top expression, and its RHS
4564      is everything parsed until it is popped.  When a new operator is
4565      encountered with precedence less than or equal to that at the top
4566      of the stack, triples E[i-1] op[i] E[i] are popped and replaced
4567      by the result of the operation until the operator at the top of
4568      the stack has lower precedence than the new operator or there is
4569      only one element on the stack; then the top expression is the LHS
4570      of the new operator.  In the case of logical AND and OR
4571      expressions, we also need to adjust skip_evaluation as
4572      appropriate when the operators are pushed and popped.  */
4573
4574   /* The precedence levels, where 0 is a dummy lowest level used for
4575      the bottom of the stack.  */
4576   enum prec {
4577     PREC_NONE,
4578     PREC_LOGOR,
4579     PREC_LOGAND,
4580     PREC_BITOR,
4581     PREC_BITXOR,
4582     PREC_BITAND,
4583     PREC_EQ,
4584     PREC_REL,
4585     PREC_SHIFT,
4586     PREC_ADD,
4587     PREC_MULT,
4588     NUM_PRECS
4589   };
4590   struct {
4591     /* The expression at this stack level.  */
4592     struct c_expr expr;
4593     /* The precedence of the operator on its left, PREC_NONE at the
4594        bottom of the stack.  */
4595     enum prec prec;
4596     /* The operation on its left.  */
4597     enum tree_code op;
4598   } stack[NUM_PRECS];
4599   int sp;
4600   /* Location of the binary operator.  */
4601   location_t binary_loc = UNKNOWN_LOCATION;  /* Quiet warning.  */
4602 #define POP                                                                   \
4603   do {                                                                        \
4604     switch (stack[sp].op)                                                     \
4605       {                                                                       \
4606       case TRUTH_ANDIF_EXPR:                                                  \
4607         skip_evaluation -= stack[sp - 1].expr.value == truthvalue_false_node; \
4608         break;                                                                \
4609       case TRUTH_ORIF_EXPR:                                                   \
4610         skip_evaluation -= stack[sp - 1].expr.value == truthvalue_true_node;  \
4611         break;                                                                \
4612       default:                                                                \
4613         break;                                                                \
4614       }                                                                       \
4615     stack[sp - 1].expr                                                        \
4616       = default_function_array_conversion (stack[sp - 1].expr);               \
4617     stack[sp].expr                                                            \
4618       = default_function_array_conversion (stack[sp].expr);                   \
4619     stack[sp - 1].expr = parser_build_binary_op (binary_loc,                  \
4620                                                  stack[sp].op,                \
4621                                                  stack[sp - 1].expr,          \
4622                                                  stack[sp].expr);             \
4623     sp--;                                                                     \
4624   } while (0)
4625   gcc_assert (!after || c_dialect_objc ());
4626   stack[0].expr = c_parser_cast_expression (parser, after);
4627   stack[0].prec = PREC_NONE;
4628   sp = 0;
4629   while (true)
4630     {
4631       enum prec oprec;
4632       enum tree_code ocode;
4633       if (parser->error)
4634         goto out;
4635       switch (c_parser_peek_token (parser)->type)
4636         {
4637         case CPP_MULT:
4638           oprec = PREC_MULT;
4639           ocode = MULT_EXPR;
4640           break;
4641         case CPP_DIV:
4642           oprec = PREC_MULT;
4643           ocode = TRUNC_DIV_EXPR;
4644           break;
4645         case CPP_MOD:
4646           oprec = PREC_MULT;
4647           ocode = TRUNC_MOD_EXPR;
4648           break;
4649         case CPP_PLUS:
4650           oprec = PREC_ADD;
4651           ocode = PLUS_EXPR;
4652           break;
4653         case CPP_MINUS:
4654           oprec = PREC_ADD;
4655           ocode = MINUS_EXPR;
4656           break;
4657         case CPP_LSHIFT:
4658           oprec = PREC_SHIFT;
4659           ocode = LSHIFT_EXPR;
4660           break;
4661         case CPP_RSHIFT:
4662           oprec = PREC_SHIFT;
4663           ocode = RSHIFT_EXPR;
4664           break;
4665         case CPP_LESS:
4666           oprec = PREC_REL;
4667           ocode = LT_EXPR;
4668           break;
4669         case CPP_GREATER:
4670           oprec = PREC_REL;
4671           ocode = GT_EXPR;
4672           break;
4673         case CPP_LESS_EQ:
4674           oprec = PREC_REL;
4675           ocode = LE_EXPR;
4676           break;
4677         case CPP_GREATER_EQ:
4678           oprec = PREC_REL;
4679           ocode = GE_EXPR;
4680           break;
4681         case CPP_EQ_EQ:
4682           oprec = PREC_EQ;
4683           ocode = EQ_EXPR;
4684           break;
4685         case CPP_NOT_EQ:
4686           oprec = PREC_EQ;
4687           ocode = NE_EXPR;
4688           break;
4689         case CPP_AND:
4690           oprec = PREC_BITAND;
4691           ocode = BIT_AND_EXPR;
4692           break;
4693         case CPP_XOR:
4694           oprec = PREC_BITXOR;
4695           ocode = BIT_XOR_EXPR;
4696           break;
4697         case CPP_OR:
4698           oprec = PREC_BITOR;
4699           ocode = BIT_IOR_EXPR;
4700           break;
4701         case CPP_AND_AND:
4702           oprec = PREC_LOGAND;
4703           ocode = TRUTH_ANDIF_EXPR;
4704           break;
4705         case CPP_OR_OR:
4706           oprec = PREC_LOGOR;
4707           ocode = TRUTH_ORIF_EXPR;
4708           break;
4709         default:
4710           /* Not a binary operator, so end of the binary
4711              expression.  */
4712           goto out;
4713         }
4714       binary_loc = c_parser_peek_token (parser)->location;
4715       c_parser_consume_token (parser);
4716       while (oprec <= stack[sp].prec)
4717         POP;
4718       switch (ocode)
4719         {
4720         case TRUTH_ANDIF_EXPR:
4721           stack[sp].expr
4722             = default_function_array_conversion (stack[sp].expr);
4723           stack[sp].expr.value = c_objc_common_truthvalue_conversion
4724             (binary_loc, default_conversion (stack[sp].expr.value));
4725           skip_evaluation += stack[sp].expr.value == truthvalue_false_node;
4726           break;
4727         case TRUTH_ORIF_EXPR:
4728           stack[sp].expr
4729             = default_function_array_conversion (stack[sp].expr);
4730           stack[sp].expr.value = c_objc_common_truthvalue_conversion
4731             (binary_loc, default_conversion (stack[sp].expr.value));
4732           skip_evaluation += stack[sp].expr.value == truthvalue_true_node;
4733           break;
4734         default:
4735           break;
4736         }
4737       sp++;
4738       stack[sp].expr = c_parser_cast_expression (parser, NULL);
4739       stack[sp].prec = oprec;
4740       stack[sp].op = ocode;
4741     }
4742  out:
4743   while (sp > 0)
4744     POP;
4745   return stack[0].expr;
4746 #undef POP
4747 }
4748
4749 /* Parse a cast expression (C90 6.3.4, C99 6.5.4).  If AFTER is not
4750    NULL then it is an Objective-C message expression which is the
4751    primary-expression starting the expression as an initializer.
4752
4753    cast-expression:
4754      unary-expression
4755      ( type-name ) unary-expression
4756 */
4757
4758 static struct c_expr
4759 c_parser_cast_expression (c_parser *parser, struct c_expr *after)
4760 {
4761   gcc_assert (!after || c_dialect_objc ());
4762   if (after)
4763     return c_parser_postfix_expression_after_primary (parser, *after);
4764   /* If the expression begins with a parenthesized type name, it may
4765      be either a cast or a compound literal; we need to see whether
4766      the next character is '{' to tell the difference.  If not, it is
4767      an unary expression.  */
4768   if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)
4769       && c_token_starts_typename (c_parser_peek_2nd_token (parser)))
4770     {
4771       struct c_type_name *type_name;
4772       struct c_expr ret;
4773       struct c_expr expr;
4774       c_parser_consume_token (parser);
4775       type_name = c_parser_type_name (parser);
4776       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
4777       if (type_name == NULL)
4778         {
4779           ret.value = error_mark_node;
4780           ret.original_code = ERROR_MARK;
4781           return ret;
4782         }
4783
4784       /* Save casted types in the function's used types hash table.  */
4785       used_types_insert (type_name->specs->type);
4786
4787       if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
4788         return c_parser_postfix_expression_after_paren_type (parser,
4789                                                              type_name);
4790       expr = c_parser_cast_expression (parser, NULL);
4791       expr = default_function_array_conversion (expr);
4792       ret.value = c_cast_expr (type_name, expr.value);
4793       ret.original_code = ERROR_MARK;
4794       return ret;
4795     }
4796   else
4797     return c_parser_unary_expression (parser);
4798 }
4799
4800 /* Parse an unary expression (C90 6.3.3, C99 6.5.3).
4801
4802    unary-expression:
4803      postfix-expression
4804      ++ unary-expression
4805      -- unary-expression
4806      unary-operator cast-expression
4807      sizeof unary-expression
4808      sizeof ( type-name )
4809
4810    unary-operator: one of
4811      & * + - ~ !
4812
4813    GNU extensions:
4814
4815    unary-expression:
4816      __alignof__ unary-expression
4817      __alignof__ ( type-name )
4818      && identifier
4819
4820    unary-operator: one of
4821      __extension__ __real__ __imag__
4822
4823    In addition, the GNU syntax treats ++ and -- as unary operators, so
4824    they may be applied to cast expressions with errors for non-lvalues
4825    given later.  */
4826
4827 static struct c_expr
4828 c_parser_unary_expression (c_parser *parser)
4829 {
4830   int ext;
4831   struct c_expr ret, op;
4832   location_t loc = c_parser_peek_token (parser)->location;
4833   switch (c_parser_peek_token (parser)->type)
4834     {
4835     case CPP_PLUS_PLUS:
4836       c_parser_consume_token (parser);
4837       op = c_parser_cast_expression (parser, NULL);
4838       op = default_function_array_conversion (op);
4839       return parser_build_unary_op (PREINCREMENT_EXPR, op, loc);
4840     case CPP_MINUS_MINUS:
4841       c_parser_consume_token (parser);
4842       op = c_parser_cast_expression (parser, NULL);
4843       op = default_function_array_conversion (op);
4844       return parser_build_unary_op (PREDECREMENT_EXPR, op, loc);
4845     case CPP_AND:
4846       c_parser_consume_token (parser);
4847       return parser_build_unary_op (ADDR_EXPR,
4848                                     c_parser_cast_expression (parser, NULL),
4849                                     loc);
4850     case CPP_MULT:
4851       c_parser_consume_token (parser);
4852       op = c_parser_cast_expression (parser, NULL);
4853       op = default_function_array_conversion (op);
4854       ret.value = build_indirect_ref (loc, op.value, "unary *");
4855       ret.original_code = ERROR_MARK;
4856       return ret;
4857     case CPP_PLUS:
4858       if (!c_dialect_objc () && !in_system_header)
4859         warning_at (c_parser_peek_token (parser)->location,
4860                     OPT_Wtraditional,
4861                     "traditional C rejects the unary plus operator");
4862       c_parser_consume_token (parser);
4863       op = c_parser_cast_expression (parser, NULL);
4864       op = default_function_array_conversion (op);
4865       return parser_build_unary_op (CONVERT_EXPR, op, loc);
4866     case CPP_MINUS:
4867       c_parser_consume_token (parser);
4868       op = c_parser_cast_expression (parser, NULL);
4869       op = default_function_array_conversion (op);
4870       return parser_build_unary_op (NEGATE_EXPR, op, loc);
4871     case CPP_COMPL:
4872       c_parser_consume_token (parser);
4873       op = c_parser_cast_expression (parser, NULL);
4874       op = default_function_array_conversion (op);
4875       return parser_build_unary_op (BIT_NOT_EXPR, op, loc);
4876     case CPP_NOT:
4877       c_parser_consume_token (parser);
4878       op = c_parser_cast_expression (parser, NULL);
4879       op = default_function_array_conversion (op);
4880       return parser_build_unary_op (TRUTH_NOT_EXPR, op, loc);
4881     case CPP_AND_AND:
4882       /* Refer to the address of a label as a pointer.  */
4883       c_parser_consume_token (parser);
4884       if (c_parser_next_token_is (parser, CPP_NAME))
4885         {
4886           ret.value = finish_label_address_expr
4887             (c_parser_peek_token (parser)->value, loc);
4888           c_parser_consume_token (parser);
4889         }
4890       else
4891         {
4892           c_parser_error (parser, "expected identifier");
4893           ret.value = error_mark_node;
4894         }
4895         ret.original_code = ERROR_MARK;
4896         return ret;
4897     case CPP_KEYWORD:
4898       switch (c_parser_peek_token (parser)->keyword)
4899         {
4900         case RID_SIZEOF:
4901           return c_parser_sizeof_expression (parser);
4902         case RID_ALIGNOF:
4903           return c_parser_alignof_expression (parser);
4904         case RID_EXTENSION:
4905           c_parser_consume_token (parser);
4906           ext = disable_extension_diagnostics ();
4907           ret = c_parser_cast_expression (parser, NULL);
4908           restore_extension_diagnostics (ext);
4909           return ret;
4910         case RID_REALPART:
4911           c_parser_consume_token (parser);
4912           op = c_parser_cast_expression (parser, NULL);
4913           op = default_function_array_conversion (op);
4914           return parser_build_unary_op (REALPART_EXPR, op, loc);
4915         case RID_IMAGPART:
4916           c_parser_consume_token (parser);
4917           op = c_parser_cast_expression (parser, NULL);
4918           op = default_function_array_conversion (op);
4919           return parser_build_unary_op (IMAGPART_EXPR, op, loc);
4920         default:
4921           return c_parser_postfix_expression (parser);
4922         }
4923     default:
4924       return c_parser_postfix_expression (parser);
4925     }
4926 }
4927
4928 /* Parse a sizeof expression.  */
4929
4930 static struct c_expr
4931 c_parser_sizeof_expression (c_parser *parser)
4932 {
4933   struct c_expr expr;
4934   location_t expr_loc;
4935   gcc_assert (c_parser_next_token_is_keyword (parser, RID_SIZEOF));
4936   c_parser_consume_token (parser);
4937   skip_evaluation++;
4938   in_sizeof++;
4939   if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)
4940       && c_token_starts_typename (c_parser_peek_2nd_token (parser)))
4941     {
4942       /* Either sizeof ( type-name ) or sizeof unary-expression
4943          starting with a compound literal.  */
4944       struct c_type_name *type_name;
4945       c_parser_consume_token (parser);
4946       expr_loc = c_parser_peek_token (parser)->location;
4947       type_name = c_parser_type_name (parser);
4948       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
4949       if (type_name == NULL)
4950         {
4951           struct c_expr ret;
4952           skip_evaluation--;
4953           in_sizeof--;
4954           ret.value = error_mark_node;
4955           ret.original_code = ERROR_MARK;
4956           return ret;
4957         }
4958       if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
4959         {
4960           expr = c_parser_postfix_expression_after_paren_type (parser,
4961                                                                type_name);
4962           goto sizeof_expr;
4963         }
4964       /* sizeof ( type-name ).  */
4965       skip_evaluation--;
4966       in_sizeof--;
4967       return c_expr_sizeof_type (type_name);
4968     }
4969   else
4970     {
4971       expr_loc = c_parser_peek_token (parser)->location;
4972       expr = c_parser_unary_expression (parser);
4973     sizeof_expr:
4974       skip_evaluation--;
4975       in_sizeof--;
4976       if (TREE_CODE (expr.value) == COMPONENT_REF
4977           && DECL_C_BIT_FIELD (TREE_OPERAND (expr.value, 1)))
4978         error_at (expr_loc, "%<sizeof%> applied to a bit-field");
4979       return c_expr_sizeof_expr (expr);
4980     }
4981 }
4982
4983 /* Parse an alignof expression.  */
4984
4985 static struct c_expr
4986 c_parser_alignof_expression (c_parser *parser)
4987 {
4988   struct c_expr expr;
4989   gcc_assert (c_parser_next_token_is_keyword (parser, RID_ALIGNOF));
4990   c_parser_consume_token (parser);
4991   skip_evaluation++;
4992   in_alignof++;
4993   if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)
4994       && c_token_starts_typename (c_parser_peek_2nd_token (parser)))
4995     {
4996       /* Either __alignof__ ( type-name ) or __alignof__
4997          unary-expression starting with a compound literal.  */
4998       struct c_type_name *type_name;
4999       struct c_expr ret;
5000       c_parser_consume_token (parser);
5001       type_name = c_parser_type_name (parser);
5002       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
5003       if (type_name == NULL)
5004         {
5005           struct c_expr ret;
5006           skip_evaluation--;
5007           in_alignof--;
5008           ret.value = error_mark_node;
5009           ret.original_code = ERROR_MARK;
5010           return ret;
5011         }
5012       if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
5013         {
5014           expr = c_parser_postfix_expression_after_paren_type (parser,
5015                                                                type_name);
5016           goto alignof_expr;
5017         }
5018       /* alignof ( type-name ).  */
5019       skip_evaluation--;
5020       in_alignof--;
5021       ret.value = c_alignof (groktypename (type_name));
5022       ret.original_code = ERROR_MARK;
5023       return ret;
5024     }
5025   else
5026     {
5027       struct c_expr ret;
5028       expr = c_parser_unary_expression (parser);
5029     alignof_expr:
5030       skip_evaluation--;
5031       in_alignof--;
5032       ret.value = c_alignof_expr (expr.value);
5033       ret.original_code = ERROR_MARK;
5034       return ret;
5035     }
5036 }
5037
5038 /* Parse a postfix expression (C90 6.3.1-6.3.2, C99 6.5.1-6.5.2).
5039
5040    postfix-expression:
5041      primary-expression
5042      postfix-expression [ expression ]
5043      postfix-expression ( argument-expression-list[opt] )
5044      postfix-expression . identifier
5045      postfix-expression -> identifier
5046      postfix-expression ++
5047      postfix-expression --
5048      ( type-name ) { initializer-list }
5049      ( type-name ) { initializer-list , }
5050
5051    argument-expression-list:
5052      argument-expression
5053      argument-expression-list , argument-expression
5054
5055    primary-expression:
5056      identifier
5057      constant
5058      string-literal
5059      ( expression )
5060
5061    GNU extensions:
5062
5063    primary-expression:
5064      __func__
5065        (treated as a keyword in GNU C)
5066      __FUNCTION__
5067      __PRETTY_FUNCTION__
5068      ( compound-statement )
5069      __builtin_va_arg ( assignment-expression , type-name )
5070      __builtin_offsetof ( type-name , offsetof-member-designator )
5071      __builtin_choose_expr ( assignment-expression ,
5072                              assignment-expression ,
5073                              assignment-expression )
5074      __builtin_types_compatible_p ( type-name , type-name )
5075
5076    offsetof-member-designator:
5077      identifier
5078      offsetof-member-designator . identifier
5079      offsetof-member-designator [ expression ]
5080
5081    Objective-C:
5082
5083    primary-expression:
5084      [ objc-receiver objc-message-args ]
5085      @selector ( objc-selector-arg )
5086      @protocol ( identifier )
5087      @encode ( type-name )
5088      objc-string-literal
5089 */
5090
5091 static struct c_expr
5092 c_parser_postfix_expression (c_parser *parser)
5093 {
5094   struct c_expr expr, e1, e2, e3;
5095   struct c_type_name *t1, *t2;
5096   location_t loc;
5097   switch (c_parser_peek_token (parser)->type)
5098     {
5099     case CPP_NUMBER:
5100       expr.value = c_parser_peek_token (parser)->value;
5101       expr.original_code = ERROR_MARK;
5102       loc = c_parser_peek_token (parser)->location;
5103       c_parser_consume_token (parser);
5104       if (TREE_CODE (expr.value) == FIXED_CST
5105           && !targetm.fixed_point_supported_p ())
5106         {
5107           error_at (loc, "fixed-point types not supported for this target");
5108           expr.value = error_mark_node;
5109         }
5110       break;
5111     case CPP_CHAR:
5112     case CPP_CHAR16:
5113     case CPP_CHAR32:
5114     case CPP_WCHAR:
5115       expr.value = c_parser_peek_token (parser)->value;
5116       expr.original_code = ERROR_MARK;
5117       c_parser_consume_token (parser);
5118       break;
5119     case CPP_STRING:
5120     case CPP_STRING16:
5121     case CPP_STRING32:
5122     case CPP_WSTRING:
5123       expr.value = c_parser_peek_token (parser)->value;
5124       expr.original_code = STRING_CST;
5125       c_parser_consume_token (parser);
5126       break;
5127     case CPP_OBJC_STRING:
5128       gcc_assert (c_dialect_objc ());
5129       expr.value
5130         = objc_build_string_object (c_parser_peek_token (parser)->value);
5131       expr.original_code = ERROR_MARK;
5132       c_parser_consume_token (parser);
5133       break;
5134     case CPP_NAME:
5135       if (c_parser_peek_token (parser)->id_kind != C_ID_ID)
5136         {
5137           c_parser_error (parser, "expected expression");
5138           expr.value = error_mark_node;
5139           expr.original_code = ERROR_MARK;
5140           break;
5141         }
5142       {
5143         tree id = c_parser_peek_token (parser)->value;
5144         location_t loc = c_parser_peek_token (parser)->location;
5145         c_parser_consume_token (parser);
5146         expr.value = build_external_ref (id,
5147                                          (c_parser_peek_token (parser)->type
5148                                           == CPP_OPEN_PAREN), loc);
5149         expr.original_code = ERROR_MARK;
5150       }
5151       break;
5152     case CPP_OPEN_PAREN:
5153       /* A parenthesized expression, statement expression or compound
5154          literal.  */
5155       if (c_parser_peek_2nd_token (parser)->type == CPP_OPEN_BRACE)
5156         {
5157           /* A statement expression.  */
5158           tree stmt;
5159           location_t here = c_parser_peek_token (parser)->location;
5160           c_parser_consume_token (parser);
5161           c_parser_consume_token (parser);
5162           if (cur_stmt_list == NULL)
5163             {
5164               error_at (here, "braced-group within expression allowed "
5165                         "only inside a function");
5166               parser->error = true;
5167               c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL);
5168               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
5169               expr.value = error_mark_node;
5170               expr.original_code = ERROR_MARK;
5171               break;
5172             }
5173           stmt = c_begin_stmt_expr ();
5174           c_parser_compound_statement_nostart (parser);
5175           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
5176                                      "expected %<)%>");
5177           pedwarn (here, OPT_pedantic,
5178                    "ISO C forbids braced-groups within expressions");
5179           expr.value = c_finish_stmt_expr (stmt);
5180           expr.original_code = ERROR_MARK;
5181         }
5182       else if (c_token_starts_typename (c_parser_peek_2nd_token (parser)))
5183         {
5184           /* A compound literal.  ??? Can we actually get here rather
5185              than going directly to
5186              c_parser_postfix_expression_after_paren_type from
5187              elsewhere?  */
5188           struct c_type_name *type_name;
5189           c_parser_consume_token (parser);
5190           type_name = c_parser_type_name (parser);
5191           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
5192                                      "expected %<)%>");
5193           if (type_name == NULL)
5194             {
5195               expr.value = error_mark_node;
5196               expr.original_code = ERROR_MARK;
5197             }
5198           else
5199             expr = c_parser_postfix_expression_after_paren_type (parser,
5200                                                                  type_name);
5201         }
5202       else
5203         {
5204           /* A parenthesized expression.  */
5205           c_parser_consume_token (parser);
5206           expr = c_parser_expression (parser);
5207           if (TREE_CODE (expr.value) == MODIFY_EXPR)
5208             TREE_NO_WARNING (expr.value) = 1;
5209           expr.original_code = ERROR_MARK;
5210           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
5211                                      "expected %<)%>");
5212         }
5213       break;
5214     case CPP_KEYWORD:
5215       switch (c_parser_peek_token (parser)->keyword)
5216         {
5217         case RID_FUNCTION_NAME:
5218         case RID_PRETTY_FUNCTION_NAME:
5219         case RID_C99_FUNCTION_NAME:
5220           expr.value = fname_decl (c_parser_peek_token (parser)->location,
5221                                    c_parser_peek_token (parser)->keyword,
5222                                    c_parser_peek_token (parser)->value);
5223           expr.original_code = ERROR_MARK;
5224           c_parser_consume_token (parser);
5225           break;
5226         case RID_VA_ARG:
5227           c_parser_consume_token (parser);
5228           if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
5229             {
5230               expr.value = error_mark_node;
5231               expr.original_code = ERROR_MARK;
5232               break;
5233             }
5234           e1 = c_parser_expr_no_commas (parser, NULL);
5235           if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>"))
5236             {
5237               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
5238               expr.value = error_mark_node;
5239               expr.original_code = ERROR_MARK;
5240               break;
5241             }
5242           t1 = c_parser_type_name (parser);
5243           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
5244                                      "expected %<)%>");
5245           if (t1 == NULL)
5246             {
5247               expr.value = error_mark_node;
5248               expr.original_code = ERROR_MARK;
5249             }
5250           else
5251             {
5252               expr.value = build_va_arg (e1.value, groktypename (t1));
5253               expr.original_code = ERROR_MARK;
5254             }
5255           break;
5256         case RID_OFFSETOF:
5257           c_parser_consume_token (parser);
5258           if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
5259             {
5260               expr.value = error_mark_node;
5261               expr.original_code = ERROR_MARK;
5262               break;
5263             }
5264           t1 = c_parser_type_name (parser);
5265           if (t1 == NULL)
5266             {
5267               expr.value = error_mark_node;
5268               expr.original_code = ERROR_MARK;
5269               break;
5270             }
5271           if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>"))
5272             {
5273               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
5274               expr.value = error_mark_node;
5275               expr.original_code = ERROR_MARK;
5276               break;
5277             }
5278           {
5279             tree type = groktypename (t1);
5280             tree offsetof_ref;
5281             if (type == error_mark_node)
5282               offsetof_ref = error_mark_node;
5283             else
5284               offsetof_ref = build1 (INDIRECT_REF, type, null_pointer_node);
5285             /* Parse the second argument to __builtin_offsetof.  We
5286                must have one identifier, and beyond that we want to
5287                accept sub structure and sub array references.  */
5288             if (c_parser_next_token_is (parser, CPP_NAME))
5289               {
5290                 offsetof_ref = build_component_ref
5291                   (offsetof_ref, c_parser_peek_token (parser)->value);
5292                 c_parser_consume_token (parser);
5293                 while (c_parser_next_token_is (parser, CPP_DOT)
5294                        || c_parser_next_token_is (parser,
5295                                                   CPP_OPEN_SQUARE)
5296                        || c_parser_next_token_is (parser,
5297                                                   CPP_DEREF))
5298                   {
5299                     if (c_parser_next_token_is (parser, CPP_DEREF))
5300                       {
5301                         loc = c_parser_peek_token (parser)->location;
5302                         offsetof_ref = build_array_ref (offsetof_ref,
5303                                                         integer_zero_node,
5304                                                         loc);
5305                         goto do_dot;
5306                       }
5307                     else if (c_parser_next_token_is (parser, CPP_DOT))
5308                       {
5309                       do_dot:
5310                         c_parser_consume_token (parser);
5311                         if (c_parser_next_token_is_not (parser,
5312                                                         CPP_NAME))
5313                           {
5314                             c_parser_error (parser, "expected identifier");
5315                             break;
5316                           }
5317                         offsetof_ref = build_component_ref
5318                           (offsetof_ref,
5319                            c_parser_peek_token (parser)->value);
5320                         c_parser_consume_token (parser);
5321                       }
5322                     else
5323                       {
5324                         tree idx;
5325                         loc = c_parser_peek_token (parser)->location;
5326                         c_parser_consume_token (parser);
5327                         idx = c_parser_expression (parser).value;
5328                         c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
5329                                                    "expected %<]%>");
5330                         offsetof_ref = build_array_ref (offsetof_ref, idx, loc);
5331                       }
5332                   }
5333               }
5334             else
5335               c_parser_error (parser, "expected identifier");
5336             c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
5337                                        "expected %<)%>");
5338             expr.value = fold_offsetof (offsetof_ref, NULL_TREE);
5339             expr.original_code = ERROR_MARK;
5340           }
5341           break;
5342         case RID_CHOOSE_EXPR:
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           loc = c_parser_peek_token (parser)->location;
5351           e1 = c_parser_expr_no_commas (parser, NULL);
5352           if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>"))
5353             {
5354               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
5355               expr.value = error_mark_node;
5356               expr.original_code = ERROR_MARK;
5357               break;
5358             }
5359           e2 = c_parser_expr_no_commas (parser, NULL);
5360           if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>"))
5361             {
5362               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
5363               expr.value = error_mark_node;
5364               expr.original_code = ERROR_MARK;
5365               break;
5366             }
5367           e3 = c_parser_expr_no_commas (parser, NULL);
5368           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
5369                                      "expected %<)%>");
5370           {
5371             tree c;
5372
5373             c = fold (e1.value);
5374             if (TREE_CODE (c) != INTEGER_CST)
5375               error_at (loc,
5376                         "first argument to %<__builtin_choose_expr%> not"
5377                         " a constant");
5378             expr = integer_zerop (c) ? e3 : e2;
5379           }
5380           break;
5381         case RID_TYPES_COMPATIBLE_P:
5382           c_parser_consume_token (parser);
5383           if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
5384             {
5385               expr.value = error_mark_node;
5386               expr.original_code = ERROR_MARK;
5387               break;
5388             }
5389           t1 = c_parser_type_name (parser);
5390           if (t1 == NULL)
5391             {
5392               expr.value = error_mark_node;
5393               expr.original_code = ERROR_MARK;
5394               break;
5395             }
5396           if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>"))
5397             {
5398               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
5399               expr.value = error_mark_node;
5400               expr.original_code = ERROR_MARK;
5401               break;
5402             }
5403           t2 = c_parser_type_name (parser);
5404           if (t2 == NULL)
5405             {
5406               expr.value = error_mark_node;
5407               expr.original_code = ERROR_MARK;
5408               break;
5409             }
5410           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
5411                                      "expected %<)%>");
5412           {
5413             tree e1, e2;
5414
5415             e1 = TYPE_MAIN_VARIANT (groktypename (t1));
5416             e2 = TYPE_MAIN_VARIANT (groktypename (t2));
5417
5418             expr.value = comptypes (e1, e2)
5419               ? build_int_cst (NULL_TREE, 1)
5420               : build_int_cst (NULL_TREE, 0);
5421             expr.original_code = ERROR_MARK;
5422           }
5423           break;
5424         case RID_AT_SELECTOR:
5425           gcc_assert (c_dialect_objc ());
5426           c_parser_consume_token (parser);
5427           if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
5428             {
5429               expr.value = error_mark_node;
5430               expr.original_code = ERROR_MARK;
5431               break;
5432             }
5433           {
5434             tree sel = c_parser_objc_selector_arg (parser);
5435             c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
5436                                        "expected %<)%>");
5437             expr.value = objc_build_selector_expr (sel);
5438             expr.original_code = ERROR_MARK;
5439           }
5440           break;
5441         case RID_AT_PROTOCOL:
5442           gcc_assert (c_dialect_objc ());
5443           c_parser_consume_token (parser);
5444           if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
5445             {
5446               expr.value = error_mark_node;
5447               expr.original_code = ERROR_MARK;
5448               break;
5449             }
5450           if (c_parser_next_token_is_not (parser, CPP_NAME))
5451             {
5452               c_parser_error (parser, "expected identifier");
5453               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
5454               expr.value = error_mark_node;
5455               expr.original_code = ERROR_MARK;
5456               break;
5457             }
5458           {
5459             tree id = c_parser_peek_token (parser)->value;
5460             c_parser_consume_token (parser);
5461             c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
5462                                        "expected %<)%>");
5463             expr.value = objc_build_protocol_expr (id);
5464             expr.original_code = ERROR_MARK;
5465           }
5466           break;
5467         case RID_AT_ENCODE:
5468           /* Extension to support C-structures in the archiver.  */
5469           gcc_assert (c_dialect_objc ());
5470           c_parser_consume_token (parser);
5471           if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
5472             {
5473               expr.value = error_mark_node;
5474               expr.original_code = ERROR_MARK;
5475               break;
5476             }
5477           t1 = c_parser_type_name (parser);
5478           if (t1 == NULL)
5479             {
5480               expr.value = error_mark_node;
5481               expr.original_code = ERROR_MARK;
5482               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
5483               break;
5484             }
5485           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
5486                                      "expected %<)%>");
5487           {
5488             tree type = groktypename (t1);
5489             expr.value = objc_build_encode_expr (type);
5490             expr.original_code = ERROR_MARK;
5491           }
5492           break;
5493         default:
5494           c_parser_error (parser, "expected expression");
5495           expr.value = error_mark_node;
5496           expr.original_code = ERROR_MARK;
5497           break;
5498         }
5499       break;
5500     case CPP_OPEN_SQUARE:
5501       if (c_dialect_objc ())
5502         {
5503           tree receiver, args;
5504           c_parser_consume_token (parser);
5505           receiver = c_parser_objc_receiver (parser);
5506           args = c_parser_objc_message_args (parser);
5507           c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
5508                                      "expected %<]%>");
5509           expr.value = objc_build_message_expr (build_tree_list (receiver,
5510                                                                  args));
5511           expr.original_code = ERROR_MARK;
5512           break;
5513         }
5514       /* Else fall through to report error.  */
5515     default:
5516       c_parser_error (parser, "expected expression");
5517       expr.value = error_mark_node;
5518       expr.original_code = ERROR_MARK;
5519       break;
5520     }
5521   return c_parser_postfix_expression_after_primary (parser, expr);
5522 }
5523
5524 /* Parse a postfix expression after a parenthesized type name: the
5525    brace-enclosed initializer of a compound literal, possibly followed
5526    by some postfix operators.  This is separate because it is not
5527    possible to tell until after the type name whether a cast
5528    expression has a cast or a compound literal, or whether the operand
5529    of sizeof is a parenthesized type name or starts with a compound
5530    literal.  */
5531
5532 static struct c_expr
5533 c_parser_postfix_expression_after_paren_type (c_parser *parser,
5534                                               struct c_type_name *type_name)
5535 {
5536   tree type;
5537   struct c_expr init;
5538   struct c_expr expr;
5539   location_t start_loc;
5540   start_init (NULL_TREE, NULL, 0);
5541   type = groktypename (type_name);
5542   start_loc = c_parser_peek_token (parser)->location;
5543   if (type != error_mark_node && C_TYPE_VARIABLE_SIZE (type))
5544     {
5545       error_at (start_loc, "compound literal has variable size");
5546       type = error_mark_node;
5547     }
5548   init = c_parser_braced_init (parser, type, false);
5549   finish_init ();
5550   maybe_warn_string_init (type, init);
5551
5552   if (!flag_isoc99)
5553     pedwarn (start_loc, OPT_pedantic, "ISO C90 forbids compound literals");
5554   expr.value = build_compound_literal (type, init.value);
5555   expr.original_code = ERROR_MARK;
5556   return c_parser_postfix_expression_after_primary (parser, expr);
5557 }
5558
5559 /* Parse a postfix expression after the initial primary or compound
5560    literal; that is, parse a series of postfix operators.  */
5561
5562 static struct c_expr
5563 c_parser_postfix_expression_after_primary (c_parser *parser,
5564                                            struct c_expr expr)
5565 {
5566   tree ident, idx, exprlist;
5567   location_t loc = c_parser_peek_token (parser)->location;
5568   while (true)
5569     {
5570       switch (c_parser_peek_token (parser)->type)
5571         {
5572         case CPP_OPEN_SQUARE:
5573           /* Array reference.  */
5574           loc = c_parser_peek_token (parser)->location;
5575           c_parser_consume_token (parser);
5576           idx = c_parser_expression (parser).value;
5577           c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
5578                                      "expected %<]%>");
5579           expr.value = build_array_ref (expr.value, idx, loc);
5580           expr.original_code = ERROR_MARK;
5581           break;
5582         case CPP_OPEN_PAREN:
5583           /* Function call.  */
5584           c_parser_consume_token (parser);
5585           if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
5586             exprlist = NULL_TREE;
5587           else
5588             exprlist = c_parser_expr_list (parser, true);
5589           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
5590                                      "expected %<)%>");
5591           expr.value = build_function_call (expr.value, exprlist);
5592           expr.original_code = ERROR_MARK;
5593           break;
5594         case CPP_DOT:
5595           /* Structure element reference.  */
5596           c_parser_consume_token (parser);
5597           expr = default_function_array_conversion (expr);
5598           if (c_parser_next_token_is (parser, CPP_NAME))
5599             ident = c_parser_peek_token (parser)->value;
5600           else
5601             {
5602               c_parser_error (parser, "expected identifier");
5603               expr.value = error_mark_node;
5604               expr.original_code = ERROR_MARK;
5605               return expr;
5606             }
5607           c_parser_consume_token (parser);
5608           expr.value = build_component_ref (expr.value, ident);
5609           expr.original_code = ERROR_MARK;
5610           break;
5611         case CPP_DEREF:
5612           /* Structure element reference.  */
5613           c_parser_consume_token (parser);
5614           expr = default_function_array_conversion (expr);
5615           if (c_parser_next_token_is (parser, CPP_NAME))
5616             ident = c_parser_peek_token (parser)->value;
5617           else
5618             {
5619               c_parser_error (parser, "expected identifier");
5620               expr.value = error_mark_node;
5621               expr.original_code = ERROR_MARK;
5622               return expr;
5623             }
5624           c_parser_consume_token (parser);
5625           expr.value = build_component_ref (build_indirect_ref (loc,
5626                                                                 expr.value,
5627                                                                 "->"),
5628                                             ident);
5629           expr.original_code = ERROR_MARK;
5630           break;
5631         case CPP_PLUS_PLUS:
5632           /* Postincrement.  */
5633           c_parser_consume_token (parser);
5634           expr = default_function_array_conversion (expr);
5635           expr.value = build_unary_op (loc,
5636                                        POSTINCREMENT_EXPR, expr.value, 0);
5637           expr.original_code = ERROR_MARK;
5638           break;
5639         case CPP_MINUS_MINUS:
5640           /* Postdecrement.  */
5641           c_parser_consume_token (parser);
5642           expr = default_function_array_conversion (expr);
5643           expr.value = build_unary_op (loc,
5644                                        POSTDECREMENT_EXPR, expr.value, 0);
5645           expr.original_code = ERROR_MARK;
5646           break;
5647         default:
5648           return expr;
5649         }
5650     }
5651 }
5652
5653 /* Parse an expression (C90 6.3.17, C99 6.5.17).
5654
5655    expression:
5656      assignment-expression
5657      expression , assignment-expression
5658 */
5659
5660 static struct c_expr
5661 c_parser_expression (c_parser *parser)
5662 {
5663   struct c_expr expr;
5664   expr = c_parser_expr_no_commas (parser, NULL);
5665   while (c_parser_next_token_is (parser, CPP_COMMA))
5666     {
5667       struct c_expr next;
5668       c_parser_consume_token (parser);
5669       next = c_parser_expr_no_commas (parser, NULL);
5670       next = default_function_array_conversion (next);
5671       expr.value = build_compound_expr (expr.value, next.value);
5672       expr.original_code = COMPOUND_EXPR;
5673     }
5674   return expr;
5675 }
5676
5677 /* Parse an expression and convert functions or arrays to
5678    pointers.  */
5679
5680 static struct c_expr
5681 c_parser_expression_conv (c_parser *parser)
5682 {
5683   struct c_expr expr;
5684   expr = c_parser_expression (parser);
5685   expr = default_function_array_conversion (expr);
5686   return expr;
5687 }
5688
5689 /* Parse a non-empty list of expressions.  If CONVERT_P, convert
5690    functions and arrays to pointers.
5691
5692    nonempty-expr-list:
5693      assignment-expression
5694      nonempty-expr-list , assignment-expression
5695 */
5696
5697 static tree
5698 c_parser_expr_list (c_parser *parser, bool convert_p)
5699 {
5700   struct c_expr expr;
5701   tree ret, cur;
5702   expr = c_parser_expr_no_commas (parser, NULL);
5703   if (convert_p)
5704     expr = default_function_array_conversion (expr);
5705   ret = cur = build_tree_list (NULL_TREE, expr.value);
5706   while (c_parser_next_token_is (parser, CPP_COMMA))
5707     {
5708       c_parser_consume_token (parser);
5709       expr = c_parser_expr_no_commas (parser, NULL);
5710       if (convert_p)
5711         expr = default_function_array_conversion (expr);
5712       cur = TREE_CHAIN (cur) = build_tree_list (NULL_TREE, expr.value);
5713     }
5714   return ret;
5715 }
5716
5717 \f
5718 /* Parse Objective-C-specific constructs.  */
5719
5720 /* Parse an objc-class-definition.
5721
5722    objc-class-definition:
5723      @interface identifier objc-superclass[opt] objc-protocol-refs[opt]
5724        objc-class-instance-variables[opt] objc-methodprotolist @end
5725      @implementation identifier objc-superclass[opt]
5726        objc-class-instance-variables[opt]
5727      @interface identifier ( identifier ) objc-protocol-refs[opt]
5728        objc-methodprotolist @end
5729      @implementation identifier ( identifier )
5730
5731    objc-superclass:
5732      : identifier
5733
5734    "@interface identifier (" must start "@interface identifier (
5735    identifier ) ...": objc-methodprotolist in the first production may
5736    not start with a parenthesized identifier as a declarator of a data
5737    definition with no declaration specifiers if the objc-superclass,
5738    objc-protocol-refs and objc-class-instance-variables are omitted.  */
5739
5740 static void
5741 c_parser_objc_class_definition (c_parser *parser)
5742 {
5743   bool iface_p;
5744   tree id1;
5745   tree superclass;
5746   if (c_parser_next_token_is_keyword (parser, RID_AT_INTERFACE))
5747     iface_p = true;
5748   else if (c_parser_next_token_is_keyword (parser, RID_AT_IMPLEMENTATION))
5749     iface_p = false;
5750   else
5751     gcc_unreachable ();
5752   c_parser_consume_token (parser);
5753   if (c_parser_next_token_is_not (parser, CPP_NAME))
5754     {
5755       c_parser_error (parser, "expected identifier");
5756       return;
5757     }
5758   id1 = c_parser_peek_token (parser)->value;
5759   c_parser_consume_token (parser);
5760   if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
5761     {
5762       tree id2;
5763       tree proto = NULL_TREE;
5764       c_parser_consume_token (parser);
5765       if (c_parser_next_token_is_not (parser, CPP_NAME))
5766         {
5767           c_parser_error (parser, "expected identifier");
5768           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
5769           return;
5770         }
5771       id2 = c_parser_peek_token (parser)->value;
5772       c_parser_consume_token (parser);
5773       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
5774       if (!iface_p)
5775         {
5776           objc_start_category_implementation (id1, id2);
5777           return;
5778         }
5779       if (c_parser_next_token_is (parser, CPP_LESS))
5780         proto = c_parser_objc_protocol_refs (parser);
5781       objc_start_category_interface (id1, id2, proto);
5782       c_parser_objc_methodprotolist (parser);
5783       c_parser_require_keyword (parser, RID_AT_END, "expected %<@end%>");
5784       objc_finish_interface ();
5785       return;
5786     }
5787   if (c_parser_next_token_is (parser, CPP_COLON))
5788     {
5789       c_parser_consume_token (parser);
5790       if (c_parser_next_token_is_not (parser, CPP_NAME))
5791         {
5792           c_parser_error (parser, "expected identifier");
5793           return;
5794         }
5795       superclass = c_parser_peek_token (parser)->value;
5796       c_parser_consume_token (parser);
5797     }
5798   else
5799     superclass = NULL_TREE;
5800   if (iface_p)
5801     {
5802       tree proto = NULL_TREE;
5803       if (c_parser_next_token_is (parser, CPP_LESS))
5804         proto = c_parser_objc_protocol_refs (parser);
5805       objc_start_class_interface (id1, superclass, proto);
5806     }
5807   else
5808     objc_start_class_implementation (id1, superclass);
5809   if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
5810     c_parser_objc_class_instance_variables (parser);
5811   if (iface_p)
5812     {
5813       objc_continue_interface ();
5814       c_parser_objc_methodprotolist (parser);
5815       c_parser_require_keyword (parser, RID_AT_END, "expected %<@end%>");
5816       objc_finish_interface ();
5817     }
5818   else
5819     {
5820       objc_continue_implementation ();
5821       return;
5822     }
5823 }
5824
5825 /* Parse objc-class-instance-variables.
5826
5827    objc-class-instance-variables:
5828      { objc-instance-variable-decl-list[opt] }
5829
5830    objc-instance-variable-decl-list:
5831      objc-visibility-spec
5832      objc-instance-variable-decl ;
5833      ;
5834      objc-instance-variable-decl-list objc-visibility-spec
5835      objc-instance-variable-decl-list objc-instance-variable-decl ;
5836      objc-instance-variable-decl-list ;
5837
5838    objc-visibility-spec:
5839      @private
5840      @protected
5841      @public
5842
5843    objc-instance-variable-decl:
5844      struct-declaration
5845 */
5846
5847 static void
5848 c_parser_objc_class_instance_variables (c_parser *parser)
5849 {
5850   gcc_assert (c_parser_next_token_is (parser, CPP_OPEN_BRACE));
5851   c_parser_consume_token (parser);
5852   while (c_parser_next_token_is_not (parser, CPP_EOF))
5853     {
5854       tree decls;
5855       /* Parse any stray semicolon.  */
5856       if (c_parser_next_token_is (parser, CPP_SEMICOLON))
5857         {
5858           pedwarn (c_parser_peek_token (parser)->location, OPT_pedantic,
5859                    "extra semicolon in struct or union specified");
5860           c_parser_consume_token (parser);
5861           continue;
5862         }
5863       /* Stop if at the end of the instance variables.  */
5864       if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
5865         {
5866           c_parser_consume_token (parser);
5867           break;
5868         }
5869       /* Parse any objc-visibility-spec.  */
5870       if (c_parser_next_token_is_keyword (parser, RID_PRIVATE))
5871         {
5872           c_parser_consume_token (parser);
5873           objc_set_visibility (2);
5874           continue;
5875         }
5876       else if (c_parser_next_token_is_keyword (parser, RID_PROTECTED))
5877         {
5878           c_parser_consume_token (parser);
5879           objc_set_visibility (0);
5880           continue;
5881         }
5882       else if (c_parser_next_token_is_keyword (parser, RID_PUBLIC))
5883         {
5884           c_parser_consume_token (parser);
5885           objc_set_visibility (1);
5886           continue;
5887         }
5888       else if (c_parser_next_token_is (parser, CPP_PRAGMA))
5889         {
5890           c_parser_pragma (parser, pragma_external);
5891           continue;
5892         }
5893
5894       /* Parse some comma-separated declarations.  */
5895       decls = c_parser_struct_declaration (parser);
5896       {
5897         /* Comma-separated instance variables are chained together in
5898            reverse order; add them one by one.  */
5899         tree ivar = nreverse (decls);
5900         for (; ivar; ivar = TREE_CHAIN (ivar))
5901           objc_add_instance_variable (copy_node (ivar));
5902       }
5903       c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
5904     }
5905 }
5906
5907 /* Parse an objc-class-declaration.
5908
5909    objc-class-declaration:
5910      @class identifier-list ;
5911 */
5912
5913 static void
5914 c_parser_objc_class_declaration (c_parser *parser)
5915 {
5916   tree list = NULL_TREE;
5917   gcc_assert (c_parser_next_token_is_keyword (parser, RID_CLASS));
5918   c_parser_consume_token (parser);
5919   /* Any identifiers, including those declared as type names, are OK
5920      here.  */
5921   while (true)
5922     {
5923       tree id;
5924       if (c_parser_next_token_is_not (parser, CPP_NAME))
5925         {
5926           c_parser_error (parser, "expected identifier");
5927           break;
5928         }
5929       id = c_parser_peek_token (parser)->value;
5930       list = chainon (list, build_tree_list (NULL_TREE, id));
5931       c_parser_consume_token (parser);
5932       if (c_parser_next_token_is (parser, CPP_COMMA))
5933         c_parser_consume_token (parser);
5934       else
5935         break;
5936     }
5937   c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
5938   objc_declare_class (list);
5939 }
5940
5941 /* Parse an objc-alias-declaration.
5942
5943    objc-alias-declaration:
5944      @compatibility_alias identifier identifier ;
5945 */
5946
5947 static void
5948 c_parser_objc_alias_declaration (c_parser *parser)
5949 {
5950   tree id1, id2;
5951   gcc_assert (c_parser_next_token_is_keyword (parser, RID_AT_ALIAS));
5952   c_parser_consume_token (parser);
5953   if (c_parser_next_token_is_not (parser, CPP_NAME))
5954     {
5955       c_parser_error (parser, "expected identifier");
5956       c_parser_skip_until_found (parser, CPP_SEMICOLON, NULL);
5957       return;
5958     }
5959   id1 = c_parser_peek_token (parser)->value;
5960   c_parser_consume_token (parser);
5961   if (c_parser_next_token_is_not (parser, CPP_NAME))
5962     {
5963       c_parser_error (parser, "expected identifier");
5964       c_parser_skip_until_found (parser, CPP_SEMICOLON, NULL);
5965       return;
5966     }
5967   id2 = c_parser_peek_token (parser)->value;
5968   c_parser_consume_token (parser);
5969   c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
5970   objc_declare_alias (id1, id2);
5971 }
5972
5973 /* Parse an objc-protocol-definition.
5974
5975    objc-protocol-definition:
5976      @protocol identifier objc-protocol-refs[opt] objc-methodprotolist @end
5977      @protocol identifier-list ;
5978
5979    "@protocol identifier ;" should be resolved as "@protocol
5980    identifier-list ;": objc-methodprotolist may not start with a
5981    semicolon in the first alternative if objc-protocol-refs are
5982    omitted.  */
5983
5984 static void
5985 c_parser_objc_protocol_definition (c_parser *parser)
5986 {
5987   gcc_assert (c_parser_next_token_is_keyword (parser, RID_AT_PROTOCOL));
5988   c_parser_consume_token (parser);
5989   if (c_parser_next_token_is_not (parser, CPP_NAME))
5990     {
5991       c_parser_error (parser, "expected identifier");
5992       return;
5993     }
5994   if (c_parser_peek_2nd_token (parser)->type == CPP_COMMA
5995       || c_parser_peek_2nd_token (parser)->type == CPP_SEMICOLON)
5996     {
5997       tree list = NULL_TREE;
5998       /* Any identifiers, including those declared as type names, are
5999          OK here.  */
6000       while (true)
6001         {
6002           tree id;
6003           if (c_parser_next_token_is_not (parser, CPP_NAME))
6004             {
6005               c_parser_error (parser, "expected identifier");
6006               break;
6007             }
6008           id = c_parser_peek_token (parser)->value;
6009           list = chainon (list, build_tree_list (NULL_TREE, id));
6010           c_parser_consume_token (parser);
6011           if (c_parser_next_token_is (parser, CPP_COMMA))
6012             c_parser_consume_token (parser);
6013           else
6014             break;
6015         }
6016       c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
6017       objc_declare_protocols (list);
6018     }
6019   else
6020     {
6021       tree id = c_parser_peek_token (parser)->value;
6022       tree proto = NULL_TREE;
6023       c_parser_consume_token (parser);
6024       if (c_parser_next_token_is (parser, CPP_LESS))
6025         proto = c_parser_objc_protocol_refs (parser);
6026       parser->objc_pq_context = true;
6027       objc_start_protocol (id, proto);
6028       c_parser_objc_methodprotolist (parser);
6029       c_parser_require_keyword (parser, RID_AT_END, "expected %<@end%>");
6030       parser->objc_pq_context = false;
6031       objc_finish_interface ();
6032     }
6033 }
6034
6035 /* Parse an objc-method-type.
6036
6037    objc-method-type:
6038      +
6039      -
6040 */
6041
6042 static enum tree_code
6043 c_parser_objc_method_type (c_parser *parser)
6044 {
6045   switch (c_parser_peek_token (parser)->type)
6046     {
6047     case CPP_PLUS:
6048       c_parser_consume_token (parser);
6049       return PLUS_EXPR;
6050     case CPP_MINUS:
6051       c_parser_consume_token (parser);
6052       return MINUS_EXPR;
6053     default:
6054       gcc_unreachable ();
6055     }
6056 }
6057
6058 /* Parse an objc-method-definition.
6059
6060    objc-method-definition:
6061      objc-method-type objc-method-decl ;[opt] compound-statement
6062 */
6063
6064 static void
6065 c_parser_objc_method_definition (c_parser *parser)
6066 {
6067   enum tree_code type = c_parser_objc_method_type (parser);
6068   tree decl;
6069   objc_set_method_type (type);
6070   parser->objc_pq_context = true;
6071   decl = c_parser_objc_method_decl (parser);
6072   if (c_parser_next_token_is (parser, CPP_SEMICOLON))
6073     {
6074       c_parser_consume_token (parser);
6075       pedwarn (c_parser_peek_token (parser)->location, OPT_pedantic,
6076                "extra semicolon in method definition specified");
6077     }
6078   if (!c_parser_next_token_is (parser, CPP_OPEN_BRACE))
6079     {
6080       c_parser_error (parser, "expected %<{%>");
6081       return;
6082     }
6083   parser->objc_pq_context = false;
6084   objc_start_method_definition (decl);
6085   add_stmt (c_parser_compound_statement (parser));
6086   objc_finish_method_definition (current_function_decl);
6087 }
6088
6089 /* Parse an objc-methodprotolist.
6090
6091    objc-methodprotolist:
6092      empty
6093      objc-methodprotolist objc-methodproto
6094      objc-methodprotolist declaration
6095      objc-methodprotolist ;
6096
6097    The declaration is a data definition, which may be missing
6098    declaration specifiers under the same rules and diagnostics as
6099    other data definitions outside functions, and the stray semicolon
6100    is diagnosed the same way as a stray semicolon outside a
6101    function.  */
6102
6103 static void
6104 c_parser_objc_methodprotolist (c_parser *parser)
6105 {
6106   while (true)
6107     {
6108       /* The list is terminated by @end.  */
6109       switch (c_parser_peek_token (parser)->type)
6110         {
6111         case CPP_SEMICOLON:
6112           pedwarn (c_parser_peek_token (parser)->location, OPT_pedantic,
6113                    "ISO C does not allow extra %<;%> outside of a function");
6114           c_parser_consume_token (parser);
6115           break;
6116         case CPP_PLUS:
6117         case CPP_MINUS:
6118           c_parser_objc_methodproto (parser);
6119           break;
6120         case CPP_PRAGMA:
6121           c_parser_pragma (parser, pragma_external);
6122           break;
6123         case CPP_EOF:
6124           return;
6125         default:
6126           if (c_parser_next_token_is_keyword (parser, RID_AT_END))
6127             return;
6128           c_parser_declaration_or_fndef (parser, false, true, false, true);
6129           break;
6130         }
6131     }
6132 }
6133
6134 /* Parse an objc-methodproto.
6135
6136    objc-methodproto:
6137      objc-method-type objc-method-decl ;
6138 */
6139
6140 static void
6141 c_parser_objc_methodproto (c_parser *parser)
6142 {
6143   enum tree_code type = c_parser_objc_method_type (parser);
6144   tree decl;
6145   objc_set_method_type (type);
6146   /* Remember protocol qualifiers in prototypes.  */
6147   parser->objc_pq_context = true;
6148   decl = c_parser_objc_method_decl (parser);
6149   /* Forget protocol qualifiers here.  */
6150   parser->objc_pq_context = false;
6151   objc_add_method_declaration (decl);
6152   c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
6153 }
6154
6155 /* Parse an objc-method-decl.
6156
6157    objc-method-decl:
6158      ( objc-type-name ) objc-selector
6159      objc-selector
6160      ( objc-type-name ) objc-keyword-selector objc-optparmlist
6161      objc-keyword-selector objc-optparmlist
6162
6163    objc-keyword-selector:
6164      objc-keyword-decl
6165      objc-keyword-selector objc-keyword-decl
6166
6167    objc-keyword-decl:
6168      objc-selector : ( objc-type-name ) identifier
6169      objc-selector : identifier
6170      : ( objc-type-name ) identifier
6171      : identifier
6172
6173    objc-optparmlist:
6174      objc-optparms objc-optellipsis
6175
6176    objc-optparms:
6177      empty
6178      objc-opt-parms , parameter-declaration
6179
6180    objc-optellipsis:
6181      empty
6182      , ...
6183 */
6184
6185 static tree
6186 c_parser_objc_method_decl (c_parser *parser)
6187 {
6188   tree type = NULL_TREE;
6189   tree sel;
6190   tree parms = NULL_TREE;
6191   bool ellipsis = false;
6192
6193   if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
6194     {
6195       c_parser_consume_token (parser);
6196       type = c_parser_objc_type_name (parser);
6197       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
6198     }
6199   sel = c_parser_objc_selector (parser);
6200   /* If there is no selector, or a colon follows, we have an
6201      objc-keyword-selector.  If there is a selector, and a colon does
6202      not follow, that selector ends the objc-method-decl.  */
6203   if (!sel || c_parser_next_token_is (parser, CPP_COLON))
6204     {
6205       tree tsel = sel;
6206       tree list = NULL_TREE;
6207       while (true)
6208         {
6209           tree atype = NULL_TREE, id, keyworddecl;
6210           if (!c_parser_require (parser, CPP_COLON, "expected %<:%>"))
6211             break;
6212           if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
6213             {
6214               c_parser_consume_token (parser);
6215               atype = c_parser_objc_type_name (parser);
6216               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
6217                                          "expected %<)%>");
6218             }
6219           if (c_parser_next_token_is_not (parser, CPP_NAME))
6220             {
6221               c_parser_error (parser, "expected identifier");
6222               return error_mark_node;
6223             }
6224           id = c_parser_peek_token (parser)->value;
6225           c_parser_consume_token (parser);
6226           keyworddecl = objc_build_keyword_decl (tsel, atype, id);
6227           list = chainon (list, keyworddecl);
6228           tsel = c_parser_objc_selector (parser);
6229           if (!tsel && c_parser_next_token_is_not (parser, CPP_COLON))
6230             break;
6231         }
6232       /* Parse the optional parameter list.  Optional Objective-C
6233          method parameters follow the C syntax, and may include '...'
6234          to denote a variable number of arguments.  */
6235       parms = make_node (TREE_LIST);
6236       while (c_parser_next_token_is (parser, CPP_COMMA))
6237         {
6238           struct c_parm *parm;
6239           c_parser_consume_token (parser);
6240           if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
6241             {
6242               ellipsis = true;
6243               c_parser_consume_token (parser);
6244               break;
6245             }
6246           parm = c_parser_parameter_declaration (parser, NULL_TREE);
6247           if (parm == NULL)
6248             break;
6249           parms = chainon (parms,
6250                            build_tree_list (NULL_TREE, grokparm (parm)));
6251         }
6252       sel = list;
6253     }
6254   return objc_build_method_signature (type, sel, parms, ellipsis);
6255 }
6256
6257 /* Parse an objc-type-name.
6258
6259    objc-type-name:
6260      objc-type-qualifiers[opt] type-name
6261      objc-type-qualifiers[opt]
6262
6263    objc-type-qualifiers:
6264      objc-type-qualifier
6265      objc-type-qualifiers objc-type-qualifier
6266
6267    objc-type-qualifier: one of
6268      in out inout bycopy byref oneway
6269 */
6270
6271 static tree
6272 c_parser_objc_type_name (c_parser *parser)
6273 {
6274   tree quals = NULL_TREE;
6275   struct c_type_name *type_name = NULL;
6276   tree type = NULL_TREE;
6277   while (true)
6278     {
6279       c_token *token = c_parser_peek_token (parser);
6280       if (token->type == CPP_KEYWORD
6281           && (token->keyword == RID_IN
6282               || token->keyword == RID_OUT
6283               || token->keyword == RID_INOUT
6284               || token->keyword == RID_BYCOPY
6285               || token->keyword == RID_BYREF
6286               || token->keyword == RID_ONEWAY))
6287         {
6288           quals = chainon (quals, build_tree_list (NULL_TREE, token->value));
6289           c_parser_consume_token (parser);
6290         }
6291       else
6292         break;
6293     }
6294   if (c_parser_next_token_starts_typename (parser))
6295     type_name = c_parser_type_name (parser);
6296   if (type_name)
6297     type = groktypename (type_name);
6298   return build_tree_list (quals, type);
6299 }
6300
6301 /* Parse objc-protocol-refs.
6302
6303    objc-protocol-refs:
6304      < identifier-list >
6305 */
6306
6307 static tree
6308 c_parser_objc_protocol_refs (c_parser *parser)
6309 {
6310   tree list = NULL_TREE;
6311   gcc_assert (c_parser_next_token_is (parser, CPP_LESS));
6312   c_parser_consume_token (parser);
6313   /* Any identifiers, including those declared as type names, are OK
6314      here.  */
6315   while (true)
6316     {
6317       tree id;
6318       if (c_parser_next_token_is_not (parser, CPP_NAME))
6319         {
6320           c_parser_error (parser, "expected identifier");
6321           break;
6322         }
6323       id = c_parser_peek_token (parser)->value;
6324       list = chainon (list, build_tree_list (NULL_TREE, id));
6325       c_parser_consume_token (parser);
6326       if (c_parser_next_token_is (parser, CPP_COMMA))
6327         c_parser_consume_token (parser);
6328       else
6329         break;
6330     }
6331   c_parser_require (parser, CPP_GREATER, "expected %<>%>");
6332   return list;
6333 }
6334
6335 /* Parse an objc-try-catch-statement.
6336
6337    objc-try-catch-statement:
6338      @try compound-statement objc-catch-list[opt]
6339      @try compound-statement objc-catch-list[opt] @finally compound-statement
6340
6341    objc-catch-list:
6342      @catch ( parameter-declaration ) compound-statement
6343      objc-catch-list @catch ( parameter-declaration ) compound-statement
6344 */
6345
6346 static void
6347 c_parser_objc_try_catch_statement (c_parser *parser)
6348 {
6349   location_t loc;
6350   tree stmt;
6351   gcc_assert (c_parser_next_token_is_keyword (parser, RID_TRY));
6352   c_parser_consume_token (parser);
6353   loc = c_parser_peek_token (parser)->location;
6354   stmt = c_parser_compound_statement (parser);
6355   objc_begin_try_stmt (loc, stmt);
6356   while (c_parser_next_token_is_keyword (parser, RID_CATCH))
6357     {
6358       struct c_parm *parm;
6359       c_parser_consume_token (parser);
6360       if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
6361         break;
6362       parm = c_parser_parameter_declaration (parser, NULL_TREE);
6363       if (parm == NULL)
6364         {
6365           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
6366           break;
6367         }
6368       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
6369       objc_begin_catch_clause (grokparm (parm));
6370       if (c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>"))
6371         c_parser_compound_statement_nostart (parser);
6372       objc_finish_catch_clause ();
6373     }
6374   if (c_parser_next_token_is_keyword (parser, RID_AT_FINALLY))
6375     {
6376       location_t finloc;
6377       tree finstmt;
6378       c_parser_consume_token (parser);
6379       finloc = c_parser_peek_token (parser)->location;
6380       finstmt = c_parser_compound_statement (parser);
6381       objc_build_finally_clause (finloc, finstmt);
6382     }
6383   objc_finish_try_stmt ();
6384 }
6385
6386 /* Parse an objc-synchronized-statement.
6387
6388    objc-synchronized-statement:
6389      @synchronized ( expression ) compound-statement
6390 */
6391
6392 static void
6393 c_parser_objc_synchronized_statement (c_parser *parser)
6394 {
6395   location_t loc;
6396   tree expr, stmt;
6397   gcc_assert (c_parser_next_token_is_keyword (parser, RID_AT_SYNCHRONIZED));
6398   c_parser_consume_token (parser);
6399   loc = c_parser_peek_token (parser)->location;
6400   if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
6401     {
6402       expr = c_parser_expression (parser).value;
6403       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
6404     }
6405   else
6406     expr = error_mark_node;
6407   stmt = c_parser_compound_statement (parser);
6408   objc_build_synchronized (loc, expr, stmt);
6409 }
6410
6411 /* Parse an objc-selector; return NULL_TREE without an error if the
6412    next token is not an objc-selector.
6413
6414    objc-selector:
6415      identifier
6416      one of
6417        enum struct union if else while do for switch case default
6418        break continue return goto asm sizeof typeof __alignof
6419        unsigned long const short volatile signed restrict _Complex
6420        in out inout bycopy byref oneway int char float double void _Bool
6421
6422    ??? Why this selection of keywords but not, for example, storage
6423    class specifiers?  */
6424
6425 static tree
6426 c_parser_objc_selector (c_parser *parser)
6427 {
6428   c_token *token = c_parser_peek_token (parser);
6429   tree value = token->value;
6430   if (token->type == CPP_NAME)
6431     {
6432       c_parser_consume_token (parser);
6433       return value;
6434     }
6435   if (token->type != CPP_KEYWORD)
6436     return NULL_TREE;
6437   switch (token->keyword)
6438     {
6439     case RID_ENUM:
6440     case RID_STRUCT:
6441     case RID_UNION:
6442     case RID_IF:
6443     case RID_ELSE:
6444     case RID_WHILE:
6445     case RID_DO:
6446     case RID_FOR:
6447     case RID_SWITCH:
6448     case RID_CASE:
6449     case RID_DEFAULT:
6450     case RID_BREAK:
6451     case RID_CONTINUE:
6452     case RID_RETURN:
6453     case RID_GOTO:
6454     case RID_ASM:
6455     case RID_SIZEOF:
6456     case RID_TYPEOF:
6457     case RID_ALIGNOF:
6458     case RID_UNSIGNED:
6459     case RID_LONG:
6460     case RID_CONST:
6461     case RID_SHORT:
6462     case RID_VOLATILE:
6463     case RID_SIGNED:
6464     case RID_RESTRICT:
6465     case RID_COMPLEX:
6466     case RID_IN:
6467     case RID_OUT:
6468     case RID_INOUT:
6469     case RID_BYCOPY:
6470     case RID_BYREF:
6471     case RID_ONEWAY:
6472     case RID_INT:
6473     case RID_CHAR:
6474     case RID_FLOAT:
6475     case RID_DOUBLE:
6476     case RID_VOID:
6477     case RID_BOOL:
6478       c_parser_consume_token (parser);
6479       return value;
6480     default:
6481       return NULL_TREE;
6482     }
6483 }
6484
6485 /* Parse an objc-selector-arg.
6486
6487    objc-selector-arg:
6488      objc-selector
6489      objc-keywordname-list
6490
6491    objc-keywordname-list:
6492      objc-keywordname
6493      objc-keywordname-list objc-keywordname
6494
6495    objc-keywordname:
6496      objc-selector :
6497      :
6498 */
6499
6500 static tree
6501 c_parser_objc_selector_arg (c_parser *parser)
6502 {
6503   tree sel = c_parser_objc_selector (parser);
6504   tree list = NULL_TREE;
6505   if (sel && c_parser_next_token_is_not (parser, CPP_COLON))
6506     return sel;
6507   while (true)
6508     {
6509       if (!c_parser_require (parser, CPP_COLON, "expected %<:%>"))
6510         return list;
6511       list = chainon (list, build_tree_list (sel, NULL_TREE));
6512       sel = c_parser_objc_selector (parser);
6513       if (!sel && c_parser_next_token_is_not (parser, CPP_COLON))
6514         break;
6515     }
6516   return list;
6517 }
6518
6519 /* Parse an objc-receiver.
6520
6521    objc-receiver:
6522      expression
6523      class-name
6524      type-name
6525 */
6526
6527 static tree
6528 c_parser_objc_receiver (c_parser *parser)
6529 {
6530   if (c_parser_peek_token (parser)->type == CPP_NAME
6531       && (c_parser_peek_token (parser)->id_kind == C_ID_TYPENAME
6532           || c_parser_peek_token (parser)->id_kind == C_ID_CLASSNAME))
6533     {
6534       tree id = c_parser_peek_token (parser)->value;
6535       c_parser_consume_token (parser);
6536       return objc_get_class_reference (id);
6537     }
6538   return c_parser_expression (parser).value;
6539 }
6540
6541 /* Parse objc-message-args.
6542
6543    objc-message-args:
6544      objc-selector
6545      objc-keywordarg-list
6546
6547    objc-keywordarg-list:
6548      objc-keywordarg
6549      objc-keywordarg-list objc-keywordarg
6550
6551    objc-keywordarg:
6552      objc-selector : objc-keywordexpr
6553      : objc-keywordexpr
6554 */
6555
6556 static tree
6557 c_parser_objc_message_args (c_parser *parser)
6558 {
6559   tree sel = c_parser_objc_selector (parser);
6560   tree list = NULL_TREE;
6561   if (sel && c_parser_next_token_is_not (parser, CPP_COLON))
6562     return sel;
6563   while (true)
6564     {
6565       tree keywordexpr;
6566       if (!c_parser_require (parser, CPP_COLON, "expected %<:%>"))
6567         return error_mark_node;
6568       keywordexpr = c_parser_objc_keywordexpr (parser);
6569       list = chainon (list, build_tree_list (sel, keywordexpr));
6570       sel = c_parser_objc_selector (parser);
6571       if (!sel && c_parser_next_token_is_not (parser, CPP_COLON))
6572         break;
6573     }
6574   return list;
6575 }
6576
6577 /* Parse an objc-keywordexpr.
6578
6579    objc-keywordexpr:
6580      nonempty-expr-list
6581 */
6582
6583 static tree
6584 c_parser_objc_keywordexpr (c_parser *parser)
6585 {
6586   tree list = c_parser_expr_list (parser, true);
6587   if (TREE_CHAIN (list) == NULL_TREE)
6588     {
6589       /* Just return the expression, remove a level of
6590          indirection.  */
6591       return TREE_VALUE (list);
6592     }
6593   else
6594     {
6595       /* We have a comma expression, we will collapse later.  */
6596       return list;
6597     }
6598 }
6599
6600 \f
6601 /* Handle pragmas.  Some OpenMP pragmas are associated with, and therefore
6602    should be considered, statements.  ALLOW_STMT is true if we're within
6603    the context of a function and such pragmas are to be allowed.  Returns
6604    true if we actually parsed such a pragma.  */
6605
6606 static bool
6607 c_parser_pragma (c_parser *parser, enum pragma_context context)
6608 {
6609   unsigned int id;
6610
6611   id = c_parser_peek_token (parser)->pragma_kind;
6612   gcc_assert (id != PRAGMA_NONE);
6613
6614   switch (id)
6615     {
6616     case PRAGMA_OMP_BARRIER:
6617       if (context != pragma_compound)
6618         {
6619           if (context == pragma_stmt)
6620             c_parser_error (parser, "%<#pragma omp barrier%> may only be "
6621                             "used in compound statements");
6622           goto bad_stmt;
6623         }
6624       c_parser_omp_barrier (parser);
6625       return false;
6626
6627     case PRAGMA_OMP_FLUSH:
6628       if (context != pragma_compound)
6629         {
6630           if (context == pragma_stmt)
6631             c_parser_error (parser, "%<#pragma omp flush%> may only be "
6632                             "used in compound statements");
6633           goto bad_stmt;
6634         }
6635       c_parser_omp_flush (parser);
6636       return false;
6637
6638     case PRAGMA_OMP_TASKWAIT:
6639       if (context != pragma_compound)
6640         {
6641           if (context == pragma_stmt)
6642             c_parser_error (parser, "%<#pragma omp taskwait%> may only be "
6643                             "used in compound statements");
6644           goto bad_stmt;
6645         }
6646       c_parser_omp_taskwait (parser);
6647       return false;
6648
6649     case PRAGMA_OMP_THREADPRIVATE:
6650       c_parser_omp_threadprivate (parser);
6651       return false;
6652
6653     case PRAGMA_OMP_SECTION:
6654       error_at (c_parser_peek_token (parser)->location,
6655                 "%<#pragma omp section%> may only be used in "
6656                 "%<#pragma omp sections%> construct");
6657       c_parser_skip_until_found (parser, CPP_PRAGMA_EOL, NULL);
6658       return false;
6659
6660     case PRAGMA_GCC_PCH_PREPROCESS:
6661       c_parser_error (parser, "%<#pragma GCC pch_preprocess%> must be first");
6662       c_parser_skip_until_found (parser, CPP_PRAGMA_EOL, NULL);
6663       return false;
6664
6665     default:
6666       if (id < PRAGMA_FIRST_EXTERNAL)
6667         {
6668           if (context == pragma_external)
6669             {
6670             bad_stmt:
6671               c_parser_error (parser, "expected declaration specifiers");
6672               c_parser_skip_until_found (parser, CPP_PRAGMA_EOL, NULL);
6673               return false;
6674             }
6675           c_parser_omp_construct (parser);
6676           return true;
6677         }
6678       break;
6679     }
6680
6681   c_parser_consume_pragma (parser);
6682   c_invoke_pragma_handler (id);
6683
6684   /* Skip to EOL, but suppress any error message.  Those will have been
6685      generated by the handler routine through calling error, as opposed
6686      to calling c_parser_error.  */
6687   parser->error = true;
6688   c_parser_skip_to_pragma_eol (parser);
6689
6690   return false;
6691 }
6692
6693 /* The interface the pragma parsers have to the lexer.  */
6694
6695 enum cpp_ttype
6696 pragma_lex (tree *value)
6697 {
6698   c_token *tok = c_parser_peek_token (the_parser);
6699   enum cpp_ttype ret = tok->type;
6700
6701   *value = tok->value;
6702   if (ret == CPP_PRAGMA_EOL || ret == CPP_EOF)
6703     ret = CPP_EOF;
6704   else
6705     {
6706       if (ret == CPP_KEYWORD)
6707         ret = CPP_NAME;
6708       c_parser_consume_token (the_parser);
6709     }
6710
6711   return ret;
6712 }
6713
6714 static void
6715 c_parser_pragma_pch_preprocess (c_parser *parser)
6716 {
6717   tree name = NULL;
6718
6719   c_parser_consume_pragma (parser);
6720   if (c_parser_next_token_is (parser, CPP_STRING))
6721     {
6722       name = c_parser_peek_token (parser)->value;
6723       c_parser_consume_token (parser);
6724     }
6725   else
6726     c_parser_error (parser, "expected string literal");
6727   c_parser_skip_to_pragma_eol (parser);
6728
6729   if (name)
6730     c_common_pch_pragma (parse_in, TREE_STRING_POINTER (name));
6731 }
6732 \f
6733 /* OpenMP 2.5 parsing routines.  */
6734
6735 /* Returns name of the next clause.
6736    If the clause is not recognized PRAGMA_OMP_CLAUSE_NONE is returned and
6737    the token is not consumed.  Otherwise appropriate pragma_omp_clause is
6738    returned and the token is consumed.  */
6739
6740 static pragma_omp_clause
6741 c_parser_omp_clause_name (c_parser *parser)
6742 {
6743   pragma_omp_clause result = PRAGMA_OMP_CLAUSE_NONE;
6744
6745   if (c_parser_next_token_is_keyword (parser, RID_IF))
6746     result = PRAGMA_OMP_CLAUSE_IF;
6747   else if (c_parser_next_token_is_keyword (parser, RID_DEFAULT))
6748     result = PRAGMA_OMP_CLAUSE_DEFAULT;
6749   else if (c_parser_next_token_is (parser, CPP_NAME))
6750     {
6751       const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
6752
6753       switch (p[0])
6754         {
6755         case 'c':
6756           if (!strcmp ("collapse", p))
6757             result = PRAGMA_OMP_CLAUSE_COLLAPSE;
6758           else if (!strcmp ("copyin", p))
6759             result = PRAGMA_OMP_CLAUSE_COPYIN;
6760           else if (!strcmp ("copyprivate", p))
6761             result = PRAGMA_OMP_CLAUSE_COPYPRIVATE;
6762           break;
6763         case 'f':
6764           if (!strcmp ("firstprivate", p))
6765             result = PRAGMA_OMP_CLAUSE_FIRSTPRIVATE;
6766           break;
6767         case 'l':
6768           if (!strcmp ("lastprivate", p))
6769             result = PRAGMA_OMP_CLAUSE_LASTPRIVATE;
6770           break;
6771         case 'n':
6772           if (!strcmp ("nowait", p))
6773             result = PRAGMA_OMP_CLAUSE_NOWAIT;
6774           else if (!strcmp ("num_threads", p))
6775             result = PRAGMA_OMP_CLAUSE_NUM_THREADS;
6776           break;
6777         case 'o':
6778           if (!strcmp ("ordered", p))
6779             result = PRAGMA_OMP_CLAUSE_ORDERED;
6780           break;
6781         case 'p':
6782           if (!strcmp ("private", p))
6783             result = PRAGMA_OMP_CLAUSE_PRIVATE;
6784           break;
6785         case 'r':
6786           if (!strcmp ("reduction", p))
6787             result = PRAGMA_OMP_CLAUSE_REDUCTION;
6788           break;
6789         case 's':
6790           if (!strcmp ("schedule", p))
6791             result = PRAGMA_OMP_CLAUSE_SCHEDULE;
6792           else if (!strcmp ("shared", p))
6793             result = PRAGMA_OMP_CLAUSE_SHARED;
6794           break;
6795         case 'u':
6796           if (!strcmp ("untied", p))
6797             result = PRAGMA_OMP_CLAUSE_UNTIED;
6798           break;
6799         }
6800     }
6801
6802   if (result != PRAGMA_OMP_CLAUSE_NONE)
6803     c_parser_consume_token (parser);
6804
6805   return result;
6806 }
6807
6808 /* Validate that a clause of the given type does not already exist.  */
6809
6810 static void
6811 check_no_duplicate_clause (tree clauses, enum omp_clause_code code,
6812                            const char *name)
6813 {
6814   tree c;
6815
6816   for (c = clauses; c ; c = OMP_CLAUSE_CHAIN (c))
6817     if (OMP_CLAUSE_CODE (c) == code)
6818       {
6819         error ("too many %qs clauses", name);
6820         break;
6821       }
6822 }
6823
6824 /* OpenMP 2.5:
6825    variable-list:
6826      identifier
6827      variable-list , identifier
6828
6829    If KIND is nonzero, create the appropriate node and install the decl
6830    in OMP_CLAUSE_DECL and add the node to the head of the list.
6831
6832    If KIND is zero, create a TREE_LIST with the decl in TREE_PURPOSE;
6833    return the list created.  */
6834
6835 static tree
6836 c_parser_omp_variable_list (c_parser *parser, enum omp_clause_code kind,
6837                             tree list)
6838 {
6839   if (c_parser_next_token_is_not (parser, CPP_NAME)
6840       || c_parser_peek_token (parser)->id_kind != C_ID_ID)
6841     c_parser_error (parser, "expected identifier");
6842
6843   while (c_parser_next_token_is (parser, CPP_NAME)
6844          && c_parser_peek_token (parser)->id_kind == C_ID_ID)
6845     {
6846       tree t = lookup_name (c_parser_peek_token (parser)->value);
6847
6848       if (t == NULL_TREE)
6849         undeclared_variable (c_parser_peek_token (parser)->value,
6850                              c_parser_peek_token (parser)->location);
6851       else if (t == error_mark_node)
6852         ;
6853       else if (kind != 0)
6854         {
6855           tree u = build_omp_clause (kind);
6856           OMP_CLAUSE_DECL (u) = t;
6857           OMP_CLAUSE_CHAIN (u) = list;
6858           list = u;
6859         }
6860       else
6861         list = tree_cons (t, NULL_TREE, list);
6862
6863       c_parser_consume_token (parser);
6864
6865       if (c_parser_next_token_is_not (parser, CPP_COMMA))
6866         break;
6867
6868       c_parser_consume_token (parser);
6869     }
6870
6871   return list;
6872 }
6873
6874 /* Similarly, but expect leading and trailing parenthesis.  This is a very
6875    common case for omp clauses.  */
6876
6877 static tree
6878 c_parser_omp_var_list_parens (c_parser *parser, enum omp_clause_code kind,
6879                               tree list)
6880 {
6881   if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
6882     {
6883       list = c_parser_omp_variable_list (parser, kind, list);
6884       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
6885     }
6886   return list;
6887 }
6888
6889 /* OpenMP 3.0:
6890    collapse ( constant-expression ) */
6891
6892 static tree
6893 c_parser_omp_clause_collapse (c_parser *parser, tree list)
6894 {
6895   tree c, num = error_mark_node;
6896   HOST_WIDE_INT n;
6897   location_t loc;
6898
6899   check_no_duplicate_clause (list, OMP_CLAUSE_COLLAPSE, "collapse");
6900
6901   loc = c_parser_peek_token (parser)->location;
6902   if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
6903     {
6904       num = c_parser_expr_no_commas (parser, NULL).value;
6905       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
6906     }
6907   if (num == error_mark_node)
6908     return list;
6909   if (!INTEGRAL_TYPE_P (TREE_TYPE (num))
6910       || !host_integerp (num, 0)
6911       || (n = tree_low_cst (num, 0)) <= 0
6912       || (int) n != n)
6913     {
6914       error_at (loc,
6915                 "collapse argument needs positive constant integer expression");
6916       return list;
6917     }
6918   c = build_omp_clause (OMP_CLAUSE_COLLAPSE);
6919   OMP_CLAUSE_COLLAPSE_EXPR (c) = num;
6920   OMP_CLAUSE_CHAIN (c) = list;
6921   return c;
6922 }
6923
6924 /* OpenMP 2.5:
6925    copyin ( variable-list ) */
6926
6927 static tree
6928 c_parser_omp_clause_copyin (c_parser *parser, tree list)
6929 {
6930   return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_COPYIN, list);
6931 }
6932
6933 /* OpenMP 2.5:
6934    copyprivate ( variable-list ) */
6935
6936 static tree
6937 c_parser_omp_clause_copyprivate (c_parser *parser, tree list)
6938 {
6939   return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_COPYPRIVATE, list);
6940 }
6941
6942 /* OpenMP 2.5:
6943    default ( shared | none ) */
6944
6945 static tree
6946 c_parser_omp_clause_default (c_parser *parser, tree list)
6947 {
6948   enum omp_clause_default_kind kind = OMP_CLAUSE_DEFAULT_UNSPECIFIED;
6949   tree c;
6950
6951   if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
6952     return list;
6953   if (c_parser_next_token_is (parser, CPP_NAME))
6954     {
6955       const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
6956
6957       switch (p[0])
6958         {
6959         case 'n':
6960           if (strcmp ("none", p) != 0)
6961             goto invalid_kind;
6962           kind = OMP_CLAUSE_DEFAULT_NONE;
6963           break;
6964
6965         case 's':
6966           if (strcmp ("shared", p) != 0)
6967             goto invalid_kind;
6968           kind = OMP_CLAUSE_DEFAULT_SHARED;
6969           break;
6970
6971         default:
6972           goto invalid_kind;
6973         }
6974
6975       c_parser_consume_token (parser);
6976     }
6977   else
6978     {
6979     invalid_kind:
6980       c_parser_error (parser, "expected %<none%> or %<shared%>");
6981     }
6982   c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
6983
6984   if (kind == OMP_CLAUSE_DEFAULT_UNSPECIFIED)
6985     return list;
6986
6987   check_no_duplicate_clause (list, OMP_CLAUSE_DEFAULT, "default");
6988   c = build_omp_clause (OMP_CLAUSE_DEFAULT);
6989   OMP_CLAUSE_CHAIN (c) = list;
6990   OMP_CLAUSE_DEFAULT_KIND (c) = kind;
6991
6992   return c;
6993 }
6994
6995 /* OpenMP 2.5:
6996    firstprivate ( variable-list ) */
6997
6998 static tree
6999 c_parser_omp_clause_firstprivate (c_parser *parser, tree list)
7000 {
7001   return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_FIRSTPRIVATE, list);
7002 }
7003
7004 /* OpenMP 2.5:
7005    if ( expression ) */
7006
7007 static tree
7008 c_parser_omp_clause_if (c_parser *parser, tree list)
7009 {
7010   if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
7011     {
7012       tree t = c_parser_paren_condition (parser);
7013       tree c;
7014
7015       check_no_duplicate_clause (list, OMP_CLAUSE_IF, "if");
7016
7017       c = build_omp_clause (OMP_CLAUSE_IF);
7018       OMP_CLAUSE_IF_EXPR (c) = t;
7019       OMP_CLAUSE_CHAIN (c) = list;
7020       list = c;
7021     }
7022   else
7023     c_parser_error (parser, "expected %<(%>");
7024
7025   return list;
7026 }
7027
7028 /* OpenMP 2.5:
7029    lastprivate ( variable-list ) */
7030
7031 static tree
7032 c_parser_omp_clause_lastprivate (c_parser *parser, tree list)
7033 {
7034   return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_LASTPRIVATE, list);
7035 }
7036
7037 /* OpenMP 2.5:
7038    nowait */
7039
7040 static tree
7041 c_parser_omp_clause_nowait (c_parser *parser ATTRIBUTE_UNUSED, tree list)
7042 {
7043   tree c;
7044
7045   check_no_duplicate_clause (list, OMP_CLAUSE_NOWAIT, "nowait");
7046
7047   c = build_omp_clause (OMP_CLAUSE_NOWAIT);
7048   OMP_CLAUSE_CHAIN (c) = list;
7049   return c;
7050 }
7051
7052 /* OpenMP 2.5:
7053    num_threads ( expression ) */
7054
7055 static tree
7056 c_parser_omp_clause_num_threads (c_parser *parser, tree list)
7057 {
7058   if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
7059     {
7060       location_t expr_loc = c_parser_peek_token (parser)->location;
7061       tree c, t = c_parser_expression (parser).value;
7062
7063       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
7064
7065       if (!INTEGRAL_TYPE_P (TREE_TYPE (t)))
7066         {
7067           c_parser_error (parser, "expected integer expression");
7068           return list;
7069         }
7070
7071       /* Attempt to statically determine when the number isn't positive.  */
7072       c = fold_build2 (LE_EXPR, boolean_type_node, t,
7073                        build_int_cst (TREE_TYPE (t), 0));
7074       if (c == boolean_true_node)
7075         {
7076           warning_at (expr_loc, 0,
7077                       "%<num_threads%> value must be positive");
7078           t = integer_one_node;
7079         }
7080
7081       check_no_duplicate_clause (list, OMP_CLAUSE_NUM_THREADS, "num_threads");
7082
7083       c = build_omp_clause (OMP_CLAUSE_NUM_THREADS);
7084       OMP_CLAUSE_NUM_THREADS_EXPR (c) = t;
7085       OMP_CLAUSE_CHAIN (c) = list;
7086       list = c;
7087     }
7088
7089   return list;
7090 }
7091
7092 /* OpenMP 2.5:
7093    ordered */
7094
7095 static tree
7096 c_parser_omp_clause_ordered (c_parser *parser ATTRIBUTE_UNUSED, tree list)
7097 {
7098   tree c;
7099
7100   check_no_duplicate_clause (list, OMP_CLAUSE_ORDERED, "ordered");
7101
7102   c = build_omp_clause (OMP_CLAUSE_ORDERED);
7103   OMP_CLAUSE_CHAIN (c) = list;
7104   return c;
7105 }
7106
7107 /* OpenMP 2.5:
7108    private ( variable-list ) */
7109
7110 static tree
7111 c_parser_omp_clause_private (c_parser *parser, tree list)
7112 {
7113   return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_PRIVATE, list);
7114 }
7115
7116 /* OpenMP 2.5:
7117    reduction ( reduction-operator : variable-list )
7118
7119    reduction-operator:
7120      One of: + * - & ^ | && || */
7121
7122 static tree
7123 c_parser_omp_clause_reduction (c_parser *parser, tree list)
7124 {
7125   if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
7126     {
7127       enum tree_code code;
7128
7129       switch (c_parser_peek_token (parser)->type)
7130         {
7131         case CPP_PLUS:
7132           code = PLUS_EXPR;
7133           break;
7134         case CPP_MULT:
7135           code = MULT_EXPR;
7136           break;
7137         case CPP_MINUS:
7138           code = MINUS_EXPR;
7139           break;
7140         case CPP_AND:
7141           code = BIT_AND_EXPR;
7142           break;
7143         case CPP_XOR:
7144           code = BIT_XOR_EXPR;
7145           break;
7146         case CPP_OR:
7147           code = BIT_IOR_EXPR;
7148           break;
7149         case CPP_AND_AND:
7150           code = TRUTH_ANDIF_EXPR;
7151           break;
7152         case CPP_OR_OR:
7153           code = TRUTH_ORIF_EXPR;
7154           break;
7155         default:
7156           c_parser_error (parser,
7157                           "expected %<+%>, %<*%>, %<-%>, %<&%>, "
7158                           "%<^%>, %<|%>, %<&&%>, or %<||%>");
7159           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 0);
7160           return list;
7161         }
7162       c_parser_consume_token (parser);
7163       if (c_parser_require (parser, CPP_COLON, "expected %<:%>"))
7164         {
7165           tree nl, c;
7166
7167           nl = c_parser_omp_variable_list (parser, OMP_CLAUSE_REDUCTION, list);
7168           for (c = nl; c != list; c = OMP_CLAUSE_CHAIN (c))
7169             OMP_CLAUSE_REDUCTION_CODE (c) = code;
7170
7171           list = nl;
7172         }
7173       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
7174     }
7175   return list;
7176 }
7177
7178 /* OpenMP 2.5:
7179    schedule ( schedule-kind )
7180    schedule ( schedule-kind , expression )
7181
7182    schedule-kind:
7183      static | dynamic | guided | runtime | auto
7184 */
7185
7186 static tree
7187 c_parser_omp_clause_schedule (c_parser *parser, tree list)
7188 {
7189   tree c, t;
7190
7191   if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
7192     return list;
7193
7194   c = build_omp_clause (OMP_CLAUSE_SCHEDULE);
7195
7196   if (c_parser_next_token_is (parser, CPP_NAME))
7197     {
7198       tree kind = c_parser_peek_token (parser)->value;
7199       const char *p = IDENTIFIER_POINTER (kind);
7200
7201       switch (p[0])
7202         {
7203         case 'd':
7204           if (strcmp ("dynamic", p) != 0)
7205             goto invalid_kind;
7206           OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_DYNAMIC;
7207           break;
7208
7209         case 'g':
7210           if (strcmp ("guided", p) != 0)
7211             goto invalid_kind;
7212           OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_GUIDED;
7213           break;
7214
7215         case 'r':
7216           if (strcmp ("runtime", p) != 0)
7217             goto invalid_kind;
7218           OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_RUNTIME;
7219           break;
7220
7221         default:
7222           goto invalid_kind;
7223         }
7224     }
7225   else if (c_parser_next_token_is_keyword (parser, RID_STATIC))
7226     OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_STATIC;
7227   else if (c_parser_next_token_is_keyword (parser, RID_AUTO))
7228     OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_AUTO;
7229   else
7230     goto invalid_kind;
7231
7232   c_parser_consume_token (parser);
7233   if (c_parser_next_token_is (parser, CPP_COMMA))
7234     {
7235       location_t here;
7236       c_parser_consume_token (parser);
7237
7238       here = c_parser_peek_token (parser)->location;
7239       t = c_parser_expr_no_commas (parser, NULL).value;
7240
7241       if (OMP_CLAUSE_SCHEDULE_KIND (c) == OMP_CLAUSE_SCHEDULE_RUNTIME)
7242         error_at (here, "schedule %<runtime%> does not take "
7243                   "a %<chunk_size%> parameter");
7244       else if (OMP_CLAUSE_SCHEDULE_KIND (c) == OMP_CLAUSE_SCHEDULE_AUTO)
7245         error_at (here,
7246                   "schedule %<auto%> does not take "
7247                   "a %<chunk_size%> parameter");
7248       else if (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE)
7249         OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c) = t;
7250       else
7251         c_parser_error (parser, "expected integer expression");
7252
7253       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
7254     }
7255   else
7256     c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
7257                                "expected %<,%> or %<)%>");
7258
7259   check_no_duplicate_clause (list, OMP_CLAUSE_SCHEDULE, "schedule");
7260   OMP_CLAUSE_CHAIN (c) = list;
7261   return c;
7262
7263  invalid_kind:
7264   c_parser_error (parser, "invalid schedule kind");
7265   c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 0);
7266   return list;
7267 }
7268
7269 /* OpenMP 2.5:
7270    shared ( variable-list ) */
7271
7272 static tree
7273 c_parser_omp_clause_shared (c_parser *parser, tree list)
7274 {
7275   return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_SHARED, list);
7276 }
7277
7278 /* OpenMP 3.0:
7279    untied */
7280
7281 static tree
7282 c_parser_omp_clause_untied (c_parser *parser ATTRIBUTE_UNUSED, tree list)
7283 {
7284   tree c;
7285
7286   /* FIXME: Should we allow duplicates?  */
7287   check_no_duplicate_clause (list, OMP_CLAUSE_UNTIED, "untied");
7288
7289   c = build_omp_clause (OMP_CLAUSE_UNTIED);
7290   OMP_CLAUSE_CHAIN (c) = list;
7291   return c;
7292 }
7293
7294 /* Parse all OpenMP clauses.  The set clauses allowed by the directive
7295    is a bitmask in MASK.  Return the list of clauses found; the result
7296    of clause default goes in *pdefault.  */
7297
7298 static tree
7299 c_parser_omp_all_clauses (c_parser *parser, unsigned int mask,
7300                           const char *where)
7301 {
7302   tree clauses = NULL;
7303   bool first = true;
7304
7305   while (c_parser_next_token_is_not (parser, CPP_PRAGMA_EOL))
7306     {
7307       location_t here;
7308       pragma_omp_clause c_kind;
7309       const char *c_name;
7310       tree prev = clauses;
7311
7312       if (!first && c_parser_next_token_is (parser, CPP_COMMA))
7313         c_parser_consume_token (parser);
7314
7315       first = false;
7316       here = c_parser_peek_token (parser)->location;
7317       c_kind = c_parser_omp_clause_name (parser);
7318
7319       switch (c_kind)
7320         {
7321         case PRAGMA_OMP_CLAUSE_COLLAPSE:
7322           clauses = c_parser_omp_clause_collapse (parser, clauses);
7323           c_name = "collapse";
7324           break;
7325         case PRAGMA_OMP_CLAUSE_COPYIN:
7326           clauses = c_parser_omp_clause_copyin (parser, clauses);
7327           c_name = "copyin";
7328           break;
7329         case PRAGMA_OMP_CLAUSE_COPYPRIVATE:
7330           clauses = c_parser_omp_clause_copyprivate (parser, clauses);
7331           c_name = "copyprivate";
7332           break;
7333         case PRAGMA_OMP_CLAUSE_DEFAULT:
7334           clauses = c_parser_omp_clause_default (parser, clauses);
7335           c_name = "default";
7336           break;
7337         case PRAGMA_OMP_CLAUSE_FIRSTPRIVATE:
7338           clauses = c_parser_omp_clause_firstprivate (parser, clauses);
7339           c_name = "firstprivate";
7340           break;
7341         case PRAGMA_OMP_CLAUSE_IF:
7342           clauses = c_parser_omp_clause_if (parser, clauses);
7343           c_name = "if";
7344           break;
7345         case PRAGMA_OMP_CLAUSE_LASTPRIVATE:
7346           clauses = c_parser_omp_clause_lastprivate (parser, clauses);
7347           c_name = "lastprivate";
7348           break;
7349         case PRAGMA_OMP_CLAUSE_NOWAIT:
7350           clauses = c_parser_omp_clause_nowait (parser, clauses);
7351           c_name = "nowait";
7352           break;
7353         case PRAGMA_OMP_CLAUSE_NUM_THREADS:
7354           clauses = c_parser_omp_clause_num_threads (parser, clauses);
7355           c_name = "num_threads";
7356           break;
7357         case PRAGMA_OMP_CLAUSE_ORDERED:
7358           clauses = c_parser_omp_clause_ordered (parser, clauses);
7359           c_name = "ordered";
7360           break;
7361         case PRAGMA_OMP_CLAUSE_PRIVATE:
7362           clauses = c_parser_omp_clause_private (parser, clauses);
7363           c_name = "private";
7364           break;
7365         case PRAGMA_OMP_CLAUSE_REDUCTION:
7366           clauses = c_parser_omp_clause_reduction (parser, clauses);
7367           c_name = "reduction";
7368           break;
7369         case PRAGMA_OMP_CLAUSE_SCHEDULE:
7370           clauses = c_parser_omp_clause_schedule (parser, clauses);
7371           c_name = "schedule";
7372           break;
7373         case PRAGMA_OMP_CLAUSE_SHARED:
7374           clauses = c_parser_omp_clause_shared (parser, clauses);
7375           c_name = "shared";
7376           break;
7377         case PRAGMA_OMP_CLAUSE_UNTIED:
7378           clauses = c_parser_omp_clause_untied (parser, clauses);
7379           c_name = "untied";
7380           break;
7381         default:
7382           c_parser_error (parser, "expected %<#pragma omp%> clause");
7383           goto saw_error;
7384         }
7385
7386       if (((mask >> c_kind) & 1) == 0 && !parser->error)
7387         {
7388           /* Remove the invalid clause(s) from the list to avoid
7389              confusing the rest of the compiler.  */
7390           clauses = prev;
7391           error_at (here, "%qs is not valid for %qs", c_name, where);
7392         }
7393     }
7394
7395  saw_error:
7396   c_parser_skip_to_pragma_eol (parser);
7397
7398   return c_finish_omp_clauses (clauses);
7399 }
7400
7401 /* OpenMP 2.5:
7402    structured-block:
7403      statement
7404
7405    In practice, we're also interested in adding the statement to an
7406    outer node.  So it is convenient if we work around the fact that
7407    c_parser_statement calls add_stmt.  */
7408
7409 static tree
7410 c_parser_omp_structured_block (c_parser *parser)
7411 {
7412   tree stmt = push_stmt_list ();
7413   c_parser_statement (parser);
7414   return pop_stmt_list (stmt);
7415 }
7416
7417 /* OpenMP 2.5:
7418    # pragma omp atomic new-line
7419      expression-stmt
7420
7421    expression-stmt:
7422      x binop= expr | x++ | ++x | x-- | --x
7423    binop:
7424      +, *, -, /, &, ^, |, <<, >>
7425
7426   where x is an lvalue expression with scalar type.  */
7427
7428 static void
7429 c_parser_omp_atomic (c_parser *parser)
7430 {
7431   tree lhs, rhs;
7432   tree stmt;
7433   enum tree_code code;
7434   struct c_expr rhs_expr;
7435
7436   c_parser_skip_to_pragma_eol (parser);
7437
7438   lhs = c_parser_unary_expression (parser).value;
7439   switch (TREE_CODE (lhs))
7440     {
7441     case ERROR_MARK:
7442     saw_error:
7443       c_parser_skip_to_end_of_block_or_statement (parser);
7444       return;
7445
7446     case PREINCREMENT_EXPR:
7447     case POSTINCREMENT_EXPR:
7448       lhs = TREE_OPERAND (lhs, 0);
7449       code = PLUS_EXPR;
7450       rhs = integer_one_node;
7451       break;
7452
7453     case PREDECREMENT_EXPR:
7454     case POSTDECREMENT_EXPR:
7455       lhs = TREE_OPERAND (lhs, 0);
7456       code = MINUS_EXPR;
7457       rhs = integer_one_node;
7458       break;
7459
7460     default:
7461       switch (c_parser_peek_token (parser)->type)
7462         {
7463         case CPP_MULT_EQ:
7464           code = MULT_EXPR;
7465           break;
7466         case CPP_DIV_EQ:
7467           code = TRUNC_DIV_EXPR;
7468           break;
7469         case CPP_PLUS_EQ:
7470           code = PLUS_EXPR;
7471           break;
7472         case CPP_MINUS_EQ:
7473           code = MINUS_EXPR;
7474           break;
7475         case CPP_LSHIFT_EQ:
7476           code = LSHIFT_EXPR;
7477           break;
7478         case CPP_RSHIFT_EQ:
7479           code = RSHIFT_EXPR;
7480           break;
7481         case CPP_AND_EQ:
7482           code = BIT_AND_EXPR;
7483           break;
7484         case CPP_OR_EQ:
7485           code = BIT_IOR_EXPR;
7486           break;
7487         case CPP_XOR_EQ:
7488           code = BIT_XOR_EXPR;
7489           break;
7490         default:
7491           c_parser_error (parser,
7492                           "invalid operator for %<#pragma omp atomic%>");
7493           goto saw_error;
7494         }
7495
7496       c_parser_consume_token (parser);
7497       rhs_expr = c_parser_expression (parser);
7498       rhs_expr = default_function_array_conversion (rhs_expr);
7499       rhs = rhs_expr.value;
7500       break;
7501     }
7502   stmt = c_finish_omp_atomic (code, lhs, rhs);
7503   if (stmt != error_mark_node)
7504     add_stmt (stmt);
7505   c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
7506 }
7507
7508
7509 /* OpenMP 2.5:
7510    # pragma omp barrier new-line
7511 */
7512
7513 static void
7514 c_parser_omp_barrier (c_parser *parser)
7515 {
7516   c_parser_consume_pragma (parser);
7517   c_parser_skip_to_pragma_eol (parser);
7518
7519   c_finish_omp_barrier ();
7520 }
7521
7522 /* OpenMP 2.5:
7523    # pragma omp critical [(name)] new-line
7524      structured-block
7525 */
7526
7527 static tree
7528 c_parser_omp_critical (c_parser *parser)
7529 {
7530   tree stmt, name = NULL;
7531
7532   if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
7533     {
7534       c_parser_consume_token (parser);
7535       if (c_parser_next_token_is (parser, CPP_NAME))
7536         {
7537           name = c_parser_peek_token (parser)->value;
7538           c_parser_consume_token (parser);
7539           c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>");
7540         }
7541       else
7542         c_parser_error (parser, "expected identifier");
7543     }
7544   else if (c_parser_next_token_is_not (parser, CPP_PRAGMA_EOL))
7545     c_parser_error (parser, "expected %<(%> or end of line");
7546   c_parser_skip_to_pragma_eol (parser);
7547
7548   stmt = c_parser_omp_structured_block (parser);
7549   return c_finish_omp_critical (stmt, name);
7550 }
7551
7552 /* OpenMP 2.5:
7553    # pragma omp flush flush-vars[opt] new-line
7554
7555    flush-vars:
7556      ( variable-list ) */
7557
7558 static void
7559 c_parser_omp_flush (c_parser *parser)
7560 {
7561   c_parser_consume_pragma (parser);
7562   if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
7563     c_parser_omp_var_list_parens (parser, OMP_CLAUSE_ERROR, NULL);
7564   else if (c_parser_next_token_is_not (parser, CPP_PRAGMA_EOL))
7565     c_parser_error (parser, "expected %<(%> or end of line");
7566   c_parser_skip_to_pragma_eol (parser);
7567
7568   c_finish_omp_flush ();
7569 }
7570
7571 /* Parse the restricted form of the for statement allowed by OpenMP.
7572    The real trick here is to determine the loop control variable early
7573    so that we can push a new decl if necessary to make it private.  */
7574
7575 static tree
7576 c_parser_omp_for_loop (c_parser *parser, tree clauses, tree *par_clauses)
7577 {
7578   tree decl, cond, incr, save_break, save_cont, body, init, stmt, cl;
7579   tree declv, condv, incrv, initv, for_block = NULL, ret = NULL;
7580   location_t loc;
7581   bool fail = false, open_brace_parsed = false;
7582   int i, collapse = 1, nbraces = 0;
7583
7584   for (cl = clauses; cl; cl = OMP_CLAUSE_CHAIN (cl))
7585     if (OMP_CLAUSE_CODE (cl) == OMP_CLAUSE_COLLAPSE)
7586       collapse = tree_low_cst (OMP_CLAUSE_COLLAPSE_EXPR (cl), 0);
7587
7588   gcc_assert (collapse >= 1);
7589
7590   declv = make_tree_vec (collapse);
7591   initv = make_tree_vec (collapse);
7592   condv = make_tree_vec (collapse);
7593   incrv = make_tree_vec (collapse);
7594
7595   if (!c_parser_next_token_is_keyword (parser, RID_FOR))
7596     {
7597       c_parser_error (parser, "for statement expected");
7598       return NULL;
7599     }
7600   loc = c_parser_peek_token (parser)->location;
7601   c_parser_consume_token (parser);
7602
7603   for (i = 0; i < collapse; i++)
7604     {
7605       int bracecount = 0;
7606
7607       if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
7608         goto pop_scopes;
7609
7610       /* Parse the initialization declaration or expression.  */
7611       if (c_parser_next_token_starts_declspecs (parser))
7612         {
7613           if (i > 0)
7614             for_block
7615               = tree_cons (NULL, c_begin_compound_stmt (true), for_block);
7616           c_parser_declaration_or_fndef (parser, true, true, true, true);
7617           decl = check_for_loop_decls ();
7618           if (decl == NULL)
7619             goto error_init;
7620           if (DECL_INITIAL (decl) == error_mark_node)
7621             decl = error_mark_node;
7622           init = decl;
7623         }
7624       else if (c_parser_next_token_is (parser, CPP_NAME)
7625                && c_parser_peek_2nd_token (parser)->type == CPP_EQ)
7626         {
7627           struct c_expr init_exp;
7628           location_t init_loc;
7629
7630           decl = c_parser_postfix_expression (parser).value;
7631
7632           c_parser_require (parser, CPP_EQ, "expected %<=%>");
7633           init_loc = c_parser_peek_token (parser)->location;
7634
7635           init_exp = c_parser_expr_no_commas (parser, NULL);
7636           init_exp = default_function_array_conversion (init_exp);
7637           init = build_modify_expr (init_loc,
7638                                     decl, NOP_EXPR, init_exp.value);
7639           init = c_process_expr_stmt (init);
7640
7641           c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
7642         }
7643       else
7644         {
7645         error_init:
7646           c_parser_error (parser,
7647                           "expected iteration declaration or initialization");
7648           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
7649                                      "expected %<)%>");
7650           fail = true;
7651           goto parse_next;
7652         }
7653
7654       /* Parse the loop condition.  */
7655       cond = NULL_TREE;
7656       if (c_parser_next_token_is_not (parser, CPP_SEMICOLON))
7657         {
7658           location_t cond_loc = c_parser_peek_token (parser)->location;
7659           struct c_expr cond_expr = c_parser_binary_expression (parser, NULL);
7660
7661           cond = cond_expr.value;
7662           cond = c_objc_common_truthvalue_conversion (cond_loc, cond);
7663           switch (cond_expr.original_code)
7664             {
7665             case GT_EXPR:
7666             case GE_EXPR:
7667             case LT_EXPR:
7668             case LE_EXPR:
7669               break;
7670             default:
7671               /* Can't be cond = error_mark_node, because we want to preserve
7672                  the location until c_finish_omp_for.  */
7673               cond = build1 (NOP_EXPR, boolean_type_node, error_mark_node);
7674               break;
7675             }
7676           protected_set_expr_location (cond, cond_loc);
7677         }
7678       c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
7679
7680       /* Parse the increment expression.  */
7681       incr = NULL_TREE;
7682       if (c_parser_next_token_is_not (parser, CPP_CLOSE_PAREN))
7683         {
7684           location_t incr_loc = c_parser_peek_token (parser)->location;
7685
7686           incr = c_process_expr_stmt (c_parser_expression (parser).value);
7687           protected_set_expr_location (incr, incr_loc);
7688         }
7689       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
7690
7691       if (decl == NULL || decl == error_mark_node || init == error_mark_node)
7692         fail = true;
7693       else
7694         {
7695           TREE_VEC_ELT (declv, i) = decl;
7696           TREE_VEC_ELT (initv, i) = init;
7697           TREE_VEC_ELT (condv, i) = cond;
7698           TREE_VEC_ELT (incrv, i) = incr;
7699         }
7700
7701     parse_next:
7702       if (i == collapse - 1)
7703         break;
7704
7705       /* FIXME: OpenMP 3.0 draft isn't very clear on what exactly is allowed
7706          in between the collapsed for loops to be still considered perfectly
7707          nested.  Hopefully the final version clarifies this.
7708          For now handle (multiple) {'s and empty statements.  */
7709       do
7710         {
7711           if (c_parser_next_token_is_keyword (parser, RID_FOR))
7712             {
7713               c_parser_consume_token (parser);
7714               break;
7715             }
7716           else if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
7717             {
7718               c_parser_consume_token (parser);
7719               bracecount++;
7720             }
7721           else if (bracecount
7722                    && c_parser_next_token_is (parser, CPP_SEMICOLON))
7723             c_parser_consume_token (parser);
7724           else
7725             {
7726               c_parser_error (parser, "not enough perfectly nested loops");
7727               if (bracecount)
7728                 {
7729                   open_brace_parsed = true;
7730                   bracecount--;
7731                 }
7732               fail = true;
7733               collapse = 0;
7734               break;
7735             }
7736         }
7737       while (1);
7738
7739       nbraces += bracecount;
7740     }
7741
7742   save_break = c_break_label;
7743   c_break_label = size_one_node;
7744   save_cont = c_cont_label;
7745   c_cont_label = NULL_TREE;
7746   body = push_stmt_list ();
7747
7748   if (open_brace_parsed)
7749     {
7750       stmt = c_begin_compound_stmt (true);
7751       c_parser_compound_statement_nostart (parser);
7752       add_stmt (c_end_compound_stmt (stmt, true));
7753     }
7754   else
7755     add_stmt (c_parser_c99_block_statement (parser));
7756   if (c_cont_label)
7757     add_stmt (build1 (LABEL_EXPR, void_type_node, c_cont_label));
7758
7759   body = pop_stmt_list (body);
7760   c_break_label = save_break;
7761   c_cont_label = save_cont;
7762
7763   while (nbraces)
7764     {
7765       if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
7766         {
7767           c_parser_consume_token (parser);
7768           nbraces--;
7769         }
7770       else if (c_parser_next_token_is (parser, CPP_SEMICOLON))
7771         c_parser_consume_token (parser);
7772       else
7773         {
7774           c_parser_error (parser, "collapsed loops not perfectly nested");
7775           while (nbraces)
7776             {
7777               stmt = c_begin_compound_stmt (true);
7778               add_stmt (body);
7779               c_parser_compound_statement_nostart (parser);
7780               body = c_end_compound_stmt (stmt, true);
7781               nbraces--;
7782             }
7783           goto pop_scopes;
7784         }
7785     }
7786
7787   /* Only bother calling c_finish_omp_for if we haven't already generated
7788      an error from the initialization parsing.  */
7789   if (!fail)
7790     {
7791       stmt = c_finish_omp_for (loc, declv, initv, condv, incrv, body, NULL);
7792       if (stmt)
7793         {
7794           if (par_clauses != NULL)
7795             {
7796               tree *c;
7797               for (c = par_clauses; *c ; )
7798                 if (OMP_CLAUSE_CODE (*c) != OMP_CLAUSE_FIRSTPRIVATE
7799                     && OMP_CLAUSE_CODE (*c) != OMP_CLAUSE_LASTPRIVATE)
7800                   c = &OMP_CLAUSE_CHAIN (*c);
7801                 else
7802                   {
7803                     for (i = 0; i < collapse; i++)
7804                       if (TREE_VEC_ELT (declv, i) == OMP_CLAUSE_DECL (*c))
7805                         break;
7806                     if (i == collapse)
7807                       c = &OMP_CLAUSE_CHAIN (*c);
7808                     else if (OMP_CLAUSE_CODE (*c) == OMP_CLAUSE_FIRSTPRIVATE)
7809                       {
7810                         error_at (loc,
7811                                   "iteration variable %qD should not be firstprivate",
7812                                   OMP_CLAUSE_DECL (*c));
7813                         *c = OMP_CLAUSE_CHAIN (*c);
7814                       }
7815                     else
7816                       {
7817                         /* Copy lastprivate (decl) clause to OMP_FOR_CLAUSES,
7818                            change it to shared (decl) in
7819                            OMP_PARALLEL_CLAUSES.  */
7820                         tree l = build_omp_clause (OMP_CLAUSE_LASTPRIVATE);
7821                         OMP_CLAUSE_DECL (l) = OMP_CLAUSE_DECL (*c);
7822                         OMP_CLAUSE_CHAIN (l) = clauses;
7823                         clauses = l;
7824                         OMP_CLAUSE_SET_CODE (*c, OMP_CLAUSE_SHARED);
7825                       }
7826                   }
7827             }
7828           OMP_FOR_CLAUSES (stmt) = clauses;
7829         }
7830       ret = stmt;
7831     }
7832 pop_scopes:
7833   while (for_block)
7834     {
7835       stmt = c_end_compound_stmt (TREE_VALUE (for_block), true);
7836       add_stmt (stmt);
7837       for_block = TREE_CHAIN (for_block);
7838     }
7839   return ret;
7840 }
7841
7842 /* OpenMP 2.5:
7843    #pragma omp for for-clause[optseq] new-line
7844      for-loop
7845 */
7846
7847 #define OMP_FOR_CLAUSE_MASK                             \
7848         ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE)             \
7849         | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE)        \
7850         | (1u << PRAGMA_OMP_CLAUSE_LASTPRIVATE)         \
7851         | (1u << PRAGMA_OMP_CLAUSE_REDUCTION)           \
7852         | (1u << PRAGMA_OMP_CLAUSE_ORDERED)             \
7853         | (1u << PRAGMA_OMP_CLAUSE_SCHEDULE)            \
7854         | (1u << PRAGMA_OMP_CLAUSE_COLLAPSE)            \
7855         | (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
7856
7857 static tree
7858 c_parser_omp_for (c_parser *parser)
7859 {
7860   tree block, clauses, ret;
7861
7862   clauses = c_parser_omp_all_clauses (parser, OMP_FOR_CLAUSE_MASK,
7863                                       "#pragma omp for");
7864
7865   block = c_begin_compound_stmt (true);
7866   ret = c_parser_omp_for_loop (parser, clauses, NULL);
7867   block = c_end_compound_stmt (block, true);
7868   add_stmt (block);
7869
7870   return ret;
7871 }
7872
7873 /* OpenMP 2.5:
7874    # pragma omp master new-line
7875      structured-block
7876 */
7877
7878 static tree
7879 c_parser_omp_master (c_parser *parser)
7880 {
7881   c_parser_skip_to_pragma_eol (parser);
7882   return c_finish_omp_master (c_parser_omp_structured_block (parser));
7883 }
7884
7885 /* OpenMP 2.5:
7886    # pragma omp ordered new-line
7887      structured-block
7888 */
7889
7890 static tree
7891 c_parser_omp_ordered (c_parser *parser)
7892 {
7893   c_parser_skip_to_pragma_eol (parser);
7894   return c_finish_omp_ordered (c_parser_omp_structured_block (parser));
7895 }
7896
7897 /* OpenMP 2.5:
7898
7899    section-scope:
7900      { section-sequence }
7901
7902    section-sequence:
7903      section-directive[opt] structured-block
7904      section-sequence section-directive structured-block  */
7905
7906 static tree
7907 c_parser_omp_sections_scope (c_parser *parser)
7908 {
7909   tree stmt, substmt;
7910   bool error_suppress = false;
7911   location_t loc;
7912
7913   if (!c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>"))
7914     {
7915       /* Avoid skipping until the end of the block.  */
7916       parser->error = false;
7917       return NULL_TREE;
7918     }
7919
7920   stmt = push_stmt_list ();
7921
7922   loc = c_parser_peek_token (parser)->location;
7923   if (c_parser_peek_token (parser)->pragma_kind != PRAGMA_OMP_SECTION)
7924     {
7925       substmt = push_stmt_list ();
7926
7927       while (1)
7928         {
7929           c_parser_statement (parser);
7930
7931           if (c_parser_peek_token (parser)->pragma_kind == PRAGMA_OMP_SECTION)
7932             break;
7933           if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
7934             break;
7935           if (c_parser_next_token_is (parser, CPP_EOF))
7936             break;
7937         }
7938
7939       substmt = pop_stmt_list (substmt);
7940       substmt = build1 (OMP_SECTION, void_type_node, substmt);
7941       SET_EXPR_LOCATION (substmt, loc);
7942       add_stmt (substmt);
7943     }
7944
7945   while (1)
7946     {
7947       if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
7948         break;
7949       if (c_parser_next_token_is (parser, CPP_EOF))
7950         break;
7951
7952       loc = c_parser_peek_token (parser)->location;
7953       if (c_parser_peek_token (parser)->pragma_kind == PRAGMA_OMP_SECTION)
7954         {
7955           c_parser_consume_pragma (parser);
7956           c_parser_skip_to_pragma_eol (parser);
7957           error_suppress = false;
7958         }
7959       else if (!error_suppress)
7960         {
7961           error_at (loc, "expected %<#pragma omp section%> or %<}%>");
7962           error_suppress = true;
7963         }
7964
7965       substmt = c_parser_omp_structured_block (parser);
7966       substmt = build1 (OMP_SECTION, void_type_node, substmt);
7967       SET_EXPR_LOCATION (substmt, loc);
7968       add_stmt (substmt);
7969     }
7970   c_parser_skip_until_found (parser, CPP_CLOSE_BRACE,
7971                              "expected %<#pragma omp section%> or %<}%>");
7972
7973   substmt = pop_stmt_list (stmt);
7974
7975   stmt = make_node (OMP_SECTIONS);
7976   TREE_TYPE (stmt) = void_type_node;
7977   OMP_SECTIONS_BODY (stmt) = substmt;
7978
7979   return add_stmt (stmt);
7980 }
7981
7982 /* OpenMP 2.5:
7983    # pragma omp sections sections-clause[optseq] newline
7984      sections-scope
7985 */
7986
7987 #define OMP_SECTIONS_CLAUSE_MASK                        \
7988         ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE)             \
7989         | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE)        \
7990         | (1u << PRAGMA_OMP_CLAUSE_LASTPRIVATE)         \
7991         | (1u << PRAGMA_OMP_CLAUSE_REDUCTION)           \
7992         | (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
7993
7994 static tree
7995 c_parser_omp_sections (c_parser *parser)
7996 {
7997   tree block, clauses, ret;
7998
7999   clauses = c_parser_omp_all_clauses (parser, OMP_SECTIONS_CLAUSE_MASK,
8000                                       "#pragma omp sections");
8001
8002   block = c_begin_compound_stmt (true);
8003   ret = c_parser_omp_sections_scope (parser);
8004   if (ret)
8005     OMP_SECTIONS_CLAUSES (ret) = clauses;
8006   block = c_end_compound_stmt (block, true);
8007   add_stmt (block);
8008
8009   return ret;
8010 }
8011
8012 /* OpenMP 2.5:
8013    # pragma parallel parallel-clause new-line
8014    # pragma parallel for parallel-for-clause new-line
8015    # pragma parallel sections parallel-sections-clause new-line
8016 */
8017
8018 #define OMP_PARALLEL_CLAUSE_MASK                        \
8019         ( (1u << PRAGMA_OMP_CLAUSE_IF)                  \
8020         | (1u << PRAGMA_OMP_CLAUSE_PRIVATE)             \
8021         | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE)        \
8022         | (1u << PRAGMA_OMP_CLAUSE_DEFAULT)             \
8023         | (1u << PRAGMA_OMP_CLAUSE_SHARED)              \
8024         | (1u << PRAGMA_OMP_CLAUSE_COPYIN)              \
8025         | (1u << PRAGMA_OMP_CLAUSE_REDUCTION)           \
8026         | (1u << PRAGMA_OMP_CLAUSE_NUM_THREADS))
8027
8028 static tree
8029 c_parser_omp_parallel (c_parser *parser)
8030 {
8031   enum pragma_kind p_kind = PRAGMA_OMP_PARALLEL;
8032   const char *p_name = "#pragma omp parallel";
8033   tree stmt, clauses, par_clause, ws_clause, block;
8034   unsigned int mask = OMP_PARALLEL_CLAUSE_MASK;
8035
8036   if (c_parser_next_token_is_keyword (parser, RID_FOR))
8037     {
8038       c_parser_consume_token (parser);
8039       p_kind = PRAGMA_OMP_PARALLEL_FOR;
8040       p_name = "#pragma omp parallel for";
8041       mask |= OMP_FOR_CLAUSE_MASK;
8042       mask &= ~(1u << PRAGMA_OMP_CLAUSE_NOWAIT);
8043     }
8044   else if (c_parser_next_token_is (parser, CPP_NAME))
8045     {
8046       const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
8047       if (strcmp (p, "sections") == 0)
8048         {
8049           c_parser_consume_token (parser);
8050           p_kind = PRAGMA_OMP_PARALLEL_SECTIONS;
8051           p_name = "#pragma omp parallel sections";
8052           mask |= OMP_SECTIONS_CLAUSE_MASK;
8053           mask &= ~(1u << PRAGMA_OMP_CLAUSE_NOWAIT);
8054         }
8055     }
8056
8057   clauses = c_parser_omp_all_clauses (parser, mask, p_name);
8058
8059   switch (p_kind)
8060     {
8061     case PRAGMA_OMP_PARALLEL:
8062       block = c_begin_omp_parallel ();
8063       c_parser_statement (parser);
8064       stmt = c_finish_omp_parallel (clauses, block);
8065       break;
8066
8067     case PRAGMA_OMP_PARALLEL_FOR:
8068       block = c_begin_omp_parallel ();
8069       c_split_parallel_clauses (clauses, &par_clause, &ws_clause);
8070       c_parser_omp_for_loop (parser, ws_clause, &par_clause);
8071       stmt = c_finish_omp_parallel (par_clause, block);
8072       OMP_PARALLEL_COMBINED (stmt) = 1;
8073       break;
8074
8075     case PRAGMA_OMP_PARALLEL_SECTIONS:
8076       block = c_begin_omp_parallel ();
8077       c_split_parallel_clauses (clauses, &par_clause, &ws_clause);
8078       stmt = c_parser_omp_sections_scope (parser);
8079       if (stmt)
8080         OMP_SECTIONS_CLAUSES (stmt) = ws_clause;
8081       stmt = c_finish_omp_parallel (par_clause, block);
8082       OMP_PARALLEL_COMBINED (stmt) = 1;
8083       break;
8084
8085     default:
8086       gcc_unreachable ();
8087     }
8088
8089   return stmt;
8090 }
8091
8092 /* OpenMP 2.5:
8093    # pragma omp single single-clause[optseq] new-line
8094      structured-block
8095 */
8096
8097 #define OMP_SINGLE_CLAUSE_MASK                          \
8098         ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE)             \
8099         | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE)        \
8100         | (1u << PRAGMA_OMP_CLAUSE_COPYPRIVATE)         \
8101         | (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
8102
8103 static tree
8104 c_parser_omp_single (c_parser *parser)
8105 {
8106   tree stmt = make_node (OMP_SINGLE);
8107   TREE_TYPE (stmt) = void_type_node;
8108
8109   OMP_SINGLE_CLAUSES (stmt)
8110     = c_parser_omp_all_clauses (parser, OMP_SINGLE_CLAUSE_MASK,
8111                                 "#pragma omp single");
8112   OMP_SINGLE_BODY (stmt) = c_parser_omp_structured_block (parser);
8113
8114   return add_stmt (stmt);
8115 }
8116
8117 /* OpenMP 3.0:
8118    # pragma omp task task-clause[optseq] new-line
8119 */
8120
8121 #define OMP_TASK_CLAUSE_MASK                            \
8122         ( (1u << PRAGMA_OMP_CLAUSE_IF)                  \
8123         | (1u << PRAGMA_OMP_CLAUSE_UNTIED)              \
8124         | (1u << PRAGMA_OMP_CLAUSE_DEFAULT)             \
8125         | (1u << PRAGMA_OMP_CLAUSE_PRIVATE)             \
8126         | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE)        \
8127         | (1u << PRAGMA_OMP_CLAUSE_SHARED))
8128
8129 static tree
8130 c_parser_omp_task (c_parser *parser)
8131 {
8132   tree clauses, block;
8133
8134   clauses = c_parser_omp_all_clauses (parser, OMP_TASK_CLAUSE_MASK,
8135                                       "#pragma omp task");
8136
8137   block = c_begin_omp_task ();
8138   c_parser_statement (parser);
8139   return c_finish_omp_task (clauses, block);
8140 }
8141
8142 /* OpenMP 3.0:
8143    # pragma omp taskwait new-line
8144 */
8145
8146 static void
8147 c_parser_omp_taskwait (c_parser *parser)
8148 {
8149   c_parser_consume_pragma (parser);
8150   c_parser_skip_to_pragma_eol (parser);
8151
8152   c_finish_omp_taskwait ();
8153 }
8154
8155 /* Main entry point to parsing most OpenMP pragmas.  */
8156
8157 static void
8158 c_parser_omp_construct (c_parser *parser)
8159 {
8160   enum pragma_kind p_kind;
8161   location_t loc;
8162   tree stmt;
8163
8164   loc = c_parser_peek_token (parser)->location;
8165   p_kind = c_parser_peek_token (parser)->pragma_kind;
8166   c_parser_consume_pragma (parser);
8167
8168   /* For all constructs below except #pragma omp atomic
8169      MUST_NOT_THROW catch handlers are needed when exceptions
8170      are enabled.  */
8171   if (p_kind != PRAGMA_OMP_ATOMIC)
8172     c_maybe_initialize_eh ();
8173
8174   switch (p_kind)
8175     {
8176     case PRAGMA_OMP_ATOMIC:
8177       c_parser_omp_atomic (parser);
8178       return;
8179     case PRAGMA_OMP_CRITICAL:
8180       stmt = c_parser_omp_critical (parser);
8181       break;
8182     case PRAGMA_OMP_FOR:
8183       stmt = c_parser_omp_for (parser);
8184       break;
8185     case PRAGMA_OMP_MASTER:
8186       stmt = c_parser_omp_master (parser);
8187       break;
8188     case PRAGMA_OMP_ORDERED:
8189       stmt = c_parser_omp_ordered (parser);
8190       break;
8191     case PRAGMA_OMP_PARALLEL:
8192       stmt = c_parser_omp_parallel (parser);
8193       break;
8194     case PRAGMA_OMP_SECTIONS:
8195       stmt = c_parser_omp_sections (parser);
8196       break;
8197     case PRAGMA_OMP_SINGLE:
8198       stmt = c_parser_omp_single (parser);
8199       break;
8200     case PRAGMA_OMP_TASK:
8201       stmt = c_parser_omp_task (parser);
8202       break;
8203     default:
8204       gcc_unreachable ();
8205     }
8206
8207   if (stmt)
8208     SET_EXPR_LOCATION (stmt, loc);
8209 }
8210
8211
8212 /* OpenMP 2.5:
8213    # pragma omp threadprivate (variable-list) */
8214
8215 static void
8216 c_parser_omp_threadprivate (c_parser *parser)
8217 {
8218   tree vars, t;
8219
8220   c_parser_consume_pragma (parser);
8221   vars = c_parser_omp_var_list_parens (parser, OMP_CLAUSE_ERROR, NULL);
8222
8223   /* Mark every variable in VARS to be assigned thread local storage.  */
8224   for (t = vars; t; t = TREE_CHAIN (t))
8225     {
8226       tree v = TREE_PURPOSE (t);
8227
8228       /* If V had already been marked threadprivate, it doesn't matter
8229          whether it had been used prior to this point.  */
8230       if (TREE_CODE (v) != VAR_DECL)
8231         error ("%qD is not a variable", v);
8232       else if (TREE_USED (v) && !C_DECL_THREADPRIVATE_P (v))
8233         error ("%qE declared %<threadprivate%> after first use", v);
8234       else if (! TREE_STATIC (v) && ! DECL_EXTERNAL (v))
8235         error ("automatic variable %qE cannot be %<threadprivate%>", v);
8236       else if (TREE_TYPE (v) == error_mark_node)
8237         ;
8238       else if (! COMPLETE_TYPE_P (TREE_TYPE (v)))
8239         error ("%<threadprivate%> %qE has incomplete type", v);
8240       else
8241         {
8242           if (! DECL_THREAD_LOCAL_P (v))
8243             {
8244               DECL_TLS_MODEL (v) = decl_default_tls_model (v);
8245               /* If rtl has been already set for this var, call
8246                  make_decl_rtl once again, so that encode_section_info
8247                  has a chance to look at the new decl flags.  */
8248               if (DECL_RTL_SET_P (v))
8249                 make_decl_rtl (v);
8250             }
8251           C_DECL_THREADPRIVATE_P (v) = 1;
8252         }
8253     }
8254
8255   c_parser_skip_to_pragma_eol (parser);
8256 }
8257
8258 \f
8259 /* Parse a single source file.  */
8260
8261 void
8262 c_parse_file (void)
8263 {
8264   /* Use local storage to begin.  If the first token is a pragma, parse it.
8265      If it is #pragma GCC pch_preprocess, then this will load a PCH file
8266      which will cause garbage collection.  */
8267   c_parser tparser;
8268
8269   memset (&tparser, 0, sizeof tparser);
8270   the_parser = &tparser;
8271
8272   if (c_parser_peek_token (&tparser)->pragma_kind == PRAGMA_GCC_PCH_PREPROCESS)
8273     c_parser_pragma_pch_preprocess (&tparser);
8274
8275   the_parser = GGC_NEW (c_parser);
8276   *the_parser = tparser;
8277
8278   c_parser_translation_unit (the_parser);
8279   the_parser = NULL;
8280 }
8281
8282 #include "gt-c-parser.h"