gcc/c-parser.c

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