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