gcc/cp/parser.c

   1 /* C++ Parser.
   2    Copyright (C) 2000, 2001, 2002, 2003, 2004,
   3    2005, 2007, 2008, 2009, 2010, 2011, 2012  Free Software Foundation, Inc.
   4    Written by Mark Mitchell <mark@codesourcery.com>.
   5
   6    This file is part of GCC.
   7
   8    GCC is free software; you can redistribute it and/or modify it
   9    under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3, or (at your option)
  11    any later version.
  12
  13    GCC is distributed in the hope that it will be useful, but
  14    WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16    General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "tm.h"
  26 #include "timevar.h"
  27 #include "cpplib.h"
  28 #include "tree.h"
  29 #include "cp-tree.h"
  30 #include "intl.h"
  31 #include "c-family/c-pragma.h"
  32 #include "decl.h"
  33 #include "flags.h"
  34 #include "diagnostic-core.h"
  35 #include "output.h"
  36 #include "target.h"
  37 #include "cgraph.h"
  38 #include "c-family/c-common.h"
  39 #include "c-family/c-objc.h"
  40 #include "plugin.h"
  41 #include "tree-pretty-print.h"
  42 #include "parser.h"
  43
  44 \f
  45 /* The lexer.  */
  46
  47 /* The cp_lexer_* routines mediate between the lexer proper (in libcpp
  48    and c-lex.c) and the C++ parser.  */
  49
  50 static cp_token eof_token =
  51 {
  52   CPP_EOF, RID_MAX, 0, PRAGMA_NONE, false, false, false, 0, { NULL }
  53 };
  54
  55 /* The various kinds of non integral constant we encounter. */
  56 typedef enum non_integral_constant {
  57   NIC_NONE,
  58   /* floating-point literal */
  59   NIC_FLOAT,
  60   /* %<this%> */
  61   NIC_THIS,
  62   /* %<__FUNCTION__%> */
  63   NIC_FUNC_NAME,
  64   /* %<__PRETTY_FUNCTION__%> */
  65   NIC_PRETTY_FUNC,
  66   /* %<__func__%> */
  67   NIC_C99_FUNC,
  68   /* "%<va_arg%> */
  69   NIC_VA_ARG,
  70   /* a cast */
  71   NIC_CAST,
  72   /* %<typeid%> operator */
  73   NIC_TYPEID,
  74   /* non-constant compound literals */
  75   NIC_NCC,
  76   /* a function call */
  77   NIC_FUNC_CALL,
  78   /* an increment */
  79   NIC_INC,
  80   /* an decrement */
  81   NIC_DEC,
  82   /* an array reference */
  83   NIC_ARRAY_REF,
  84   /* %<->%> */
  85   NIC_ARROW,
  86   /* %<.%> */
  87   NIC_POINT,
  88   /* the address of a label */
  89   NIC_ADDR_LABEL,
  90   /* %<*%> */
  91   NIC_STAR,
  92   /* %<&%> */
  93   NIC_ADDR,
  94   /* %<++%> */
  95   NIC_PREINCREMENT,
  96   /* %<--%> */
  97   NIC_PREDECREMENT,
  98   /* %<new%> */
  99   NIC_NEW,
 100   /* %<delete%> */
 101   NIC_DEL,
 102   /* calls to overloaded operators */
 103   NIC_OVERLOADED,
 104   /* an assignment */
 105   NIC_ASSIGNMENT,
 106   /* a comma operator */
 107   NIC_COMMA,
 108   /* a call to a constructor */
 109   NIC_CONSTRUCTOR,
 110   /* a transaction expression */
 111   NIC_TRANSACTION
 112 } non_integral_constant;
 113
 114 /* The various kinds of errors about name-lookup failing. */
 115 typedef enum name_lookup_error {
 116   /* NULL */
 117   NLE_NULL,
 118   /* is not a type */
 119   NLE_TYPE,
 120   /* is not a class or namespace */
 121   NLE_CXX98,
 122   /* is not a class, namespace, or enumeration */
 123   NLE_NOT_CXX98
 124 } name_lookup_error;
 125
 126 /* The various kinds of required token */
 127 typedef enum required_token {
 128   RT_NONE,
 129   RT_SEMICOLON,  /* ';' */
 130   RT_OPEN_PAREN, /* '(' */
 131   RT_CLOSE_BRACE, /* '}' */
 132   RT_OPEN_BRACE,  /* '{' */
 133   RT_CLOSE_SQUARE, /* ']' */
 134   RT_OPEN_SQUARE,  /* '[' */
 135   RT_COMMA, /* ',' */
 136   RT_SCOPE, /* '::' */
 137   RT_LESS, /* '<' */
 138   RT_GREATER, /* '>' */
 139   RT_EQ, /* '=' */
 140   RT_ELLIPSIS, /* '...' */
 141   RT_MULT, /* '*' */
 142   RT_COMPL, /* '~' */
 143   RT_COLON, /* ':' */
 144   RT_COLON_SCOPE, /* ':' or '::' */
 145   RT_CLOSE_PAREN, /* ')' */
 146   RT_COMMA_CLOSE_PAREN, /* ',' or ')' */
 147   RT_PRAGMA_EOL, /* end of line */
 148   RT_NAME, /* identifier */
 149
 150   /* The type is CPP_KEYWORD */
 151   RT_NEW, /* new */
 152   RT_DELETE, /* delete */
 153   RT_RETURN, /* return */
 154   RT_WHILE, /* while */
 155   RT_EXTERN, /* extern */
 156   RT_STATIC_ASSERT, /* static_assert */
 157   RT_DECLTYPE, /* decltype */
 158   RT_OPERATOR, /* operator */
 159   RT_CLASS, /* class */
 160   RT_TEMPLATE, /* template */
 161   RT_NAMESPACE, /* namespace */
 162   RT_USING, /* using */
 163   RT_ASM, /* asm */
 164   RT_TRY, /* try */
 165   RT_CATCH, /* catch */
 166   RT_THROW, /* throw */
 167   RT_LABEL, /* __label__ */
 168   RT_AT_TRY, /* @try */
 169   RT_AT_SYNCHRONIZED, /* @synchronized */
 170   RT_AT_THROW, /* @throw */
 171
 172   RT_SELECT,  /* selection-statement */
 173   RT_INTERATION, /* iteration-statement */
 174   RT_JUMP, /* jump-statement */
 175   RT_CLASS_KEY, /* class-key */
 176   RT_CLASS_TYPENAME_TEMPLATE, /* class, typename, or template */
 177   RT_TRANSACTION_ATOMIC, /* __transaction_atomic */
 178   RT_TRANSACTION_RELAXED, /* __transaction_relaxed */
 179   RT_TRANSACTION_CANCEL /* __transaction_cancel */
 180 } required_token;
 181
 182 /* Prototypes.  */
 183
 184 static cp_lexer *cp_lexer_new_main
 185   (void);
 186 static cp_lexer *cp_lexer_new_from_tokens
 187   (cp_token_cache *tokens);
 188 static void cp_lexer_destroy
 189   (cp_lexer *);
 190 static int cp_lexer_saving_tokens
 191   (const cp_lexer *);
 192 static cp_token *cp_lexer_token_at
 193   (cp_lexer *, cp_token_position);
 194 static void cp_lexer_get_preprocessor_token
 195   (cp_lexer *, cp_token *);
 196 static inline cp_token *cp_lexer_peek_token
 197   (cp_lexer *);
 198 static cp_token *cp_lexer_peek_nth_token
 199   (cp_lexer *, size_t);
 200 static inline bool cp_lexer_next_token_is
 201   (cp_lexer *, enum cpp_ttype);
 202 static bool cp_lexer_next_token_is_not
 203   (cp_lexer *, enum cpp_ttype);
 204 static bool cp_lexer_next_token_is_keyword
 205   (cp_lexer *, enum rid);
 206 static cp_token *cp_lexer_consume_token
 207   (cp_lexer *);
 208 static void cp_lexer_purge_token
 209   (cp_lexer *);
 210 static void cp_lexer_purge_tokens_after
 211   (cp_lexer *, cp_token_position);
 212 static void cp_lexer_save_tokens
 213   (cp_lexer *);
 214 static void cp_lexer_commit_tokens
 215   (cp_lexer *);
 216 static void cp_lexer_rollback_tokens
 217   (cp_lexer *);
 218 static void cp_lexer_print_token
 219   (FILE *, cp_token *);
 220 static inline bool cp_lexer_debugging_p
 221   (cp_lexer *);
 222 static void cp_lexer_start_debugging
 223   (cp_lexer *) ATTRIBUTE_UNUSED;
 224 static void cp_lexer_stop_debugging
 225   (cp_lexer *) ATTRIBUTE_UNUSED;
 226
 227 static cp_token_cache *cp_token_cache_new
 228   (cp_token *, cp_token *);
 229
 230 static void cp_parser_initial_pragma
 231   (cp_token *);
 232
 233 static tree cp_literal_operator_id
 234   (const char *);
 235
 236 /* Manifest constants.  */
 237 #define CP_LEXER_BUFFER_SIZE ((256 * 1024) / sizeof (cp_token))
 238 #define CP_SAVED_TOKEN_STACK 5
 239
 240 /* Variables.  */
 241
 242 /* The stream to which debugging output should be written.  */
 243 static FILE *cp_lexer_debug_stream;
 244
 245 /* Nonzero if we are parsing an unevaluated operand: an operand to
 246    sizeof, typeof, or alignof.  */
 247 int cp_unevaluated_operand;
 248
 249 /* Dump up to NUM tokens in BUFFER to FILE starting with token
 250    START_TOKEN.  If START_TOKEN is NULL, the dump starts with the
 251    first token in BUFFER.  If NUM is 0, dump all the tokens.  If
 252    CURR_TOKEN is set and it is one of the tokens in BUFFER, it will be
 253    highlighted by surrounding it in [[ ]].  */
 254
 255 static void
 256 cp_lexer_dump_tokens (FILE *file, VEC(cp_token,gc) *buffer,
 257                       cp_token *start_token, unsigned num,
 258                       cp_token *curr_token)
 259 {
 260   unsigned i, nprinted;
 261   cp_token *token;
 262   bool do_print;
 263
 264   fprintf (file, "%u tokens\n", VEC_length (cp_token, buffer));
 265
 266   if (buffer == NULL)
 267     return;
 268
 269   if (num == 0)
 270     num = VEC_length (cp_token, buffer);
 271
 272   if (start_token == NULL)
 273     start_token = VEC_address (cp_token, buffer);
 274
 275   if (start_token > VEC_address (cp_token, buffer))
 276     {
 277       cp_lexer_print_token (file, VEC_index (cp_token, buffer, 0));
 278       fprintf (file, " ... ");
 279     }
 280
 281   do_print = false;
 282   nprinted = 0;
 283   for (i = 0; VEC_iterate (cp_token, buffer, i, token) && nprinted < num; i++)
 284     {
 285       if (token == start_token)
 286         do_print = true;
 287
 288       if (!do_print)
 289         continue;
 290
 291       nprinted++;
 292       if (token == curr_token)
 293         fprintf (file, "[[");
 294
 295       cp_lexer_print_token (file, token);
 296
 297       if (token == curr_token)
 298         fprintf (file, "]]");
 299
 300       switch (token->type)
 301         {
 302           case CPP_SEMICOLON:
 303           case CPP_OPEN_BRACE:
 304           case CPP_CLOSE_BRACE:
 305           case CPP_EOF:
 306             fputc ('\n', file);
 307             break;
 308
 309           default:
 310             fputc (' ', file);
 311         }
 312     }
 313
 314   if (i == num && i < VEC_length (cp_token, buffer))
 315     {
 316       fprintf (file, " ... ");
 317       cp_lexer_print_token (file, VEC_index (cp_token, buffer,
 318                             VEC_length (cp_token, buffer) - 1));
 319     }
 320
 321   fprintf (file, "\n");
 322 }
 323
 324
 325 /* Dump all tokens in BUFFER to stderr.  */
 326
 327 void
 328 cp_lexer_debug_tokens (VEC(cp_token,gc) *buffer)
 329 {
 330   cp_lexer_dump_tokens (stderr, buffer, NULL, 0, NULL);
 331 }
 332
 333
 334 /* Dump the cp_parser tree field T to FILE if T is non-NULL.  DESC is the
 335    description for T.  */
 336
 337 static void
 338 cp_debug_print_tree_if_set (FILE *file, const char *desc, tree t)
 339 {
 340   if (t)
 341     {
 342       fprintf (file, "%s: ", desc);
 343       print_node_brief (file, "", t, 0);
 344     }
 345 }
 346
 347
 348 /* Dump parser context C to FILE.  */
 349
 350 static void
 351 cp_debug_print_context (FILE *file, cp_parser_context *c)
 352 {
 353   const char *status_s[] = { "OK", "ERROR", "COMMITTED" };
 354   fprintf (file, "{ status = %s, scope = ", status_s[c->status]);
 355   print_node_brief (file, "", c->object_type, 0);
 356   fprintf (file, "}\n");
 357 }
 358
 359
 360 /* Print the stack of parsing contexts to FILE starting with FIRST.  */
 361
 362 static void
 363 cp_debug_print_context_stack (FILE *file, cp_parser_context *first)
 364 {
 365   unsigned i;
 366   cp_parser_context *c;
 367
 368   fprintf (file, "Parsing context stack:\n");
 369   for (i = 0, c = first; c; c = c->next, i++)
 370     {
 371       fprintf (file, "\t#%u: ", i);
 372       cp_debug_print_context (file, c);
 373     }
 374 }
 375
 376
 377 /* Print the value of FLAG to FILE.  DESC is a string describing the flag.  */
 378
 379 static void
 380 cp_debug_print_flag (FILE *file, const char *desc, bool flag)
 381 {
 382   if (flag)
 383     fprintf (file, "%s: true\n", desc);
 384 }
 385
 386
 387 /* Print an unparsed function entry UF to FILE.  */
 388
 389 static void
 390 cp_debug_print_unparsed_function (FILE *file, cp_unparsed_functions_entry *uf)
 391 {
 392   unsigned i;
 393   cp_default_arg_entry *default_arg_fn;
 394   tree fn;
 395
 396   fprintf (file, "\tFunctions with default args:\n");
 397   for (i = 0;
 398        VEC_iterate (cp_default_arg_entry, uf->funs_with_default_args, i,
 399                     default_arg_fn);
 400        i++)
 401     {
 402       fprintf (file, "\t\tClass type: ");
 403       print_node_brief (file, "", default_arg_fn->class_type, 0);
 404       fprintf (file, "\t\tDeclaration: ");
 405       print_node_brief (file, "", default_arg_fn->decl, 0);
 406       fprintf (file, "\n");
 407     }
 408
 409   fprintf (file, "\n\tFunctions with definitions that require "
 410            "post-processing\n\t\t");
 411   for (i = 0; VEC_iterate (tree, uf->funs_with_definitions, i, fn); i++)
 412     {
 413       print_node_brief (file, "", fn, 0);
 414       fprintf (file, " ");
 415     }
 416   fprintf (file, "\n");
 417
 418   fprintf (file, "\n\tNon-static data members with initializers that require "
 419            "post-processing\n\t\t");
 420   for (i = 0; VEC_iterate (tree, uf->nsdmis, i, fn); i++)
 421     {
 422       print_node_brief (file, "", fn, 0);
 423       fprintf (file, " ");
 424     }
 425   fprintf (file, "\n");
 426 }
 427
 428
 429 /* Print the stack of unparsed member functions S to FILE.  */
 430
 431 static void
 432 cp_debug_print_unparsed_queues (FILE *file,
 433                                 VEC(cp_unparsed_functions_entry, gc) *s)
 434 {
 435   unsigned i;
 436   cp_unparsed_functions_entry *uf;
 437
 438   fprintf (file, "Unparsed functions\n");
 439   for (i = 0; VEC_iterate (cp_unparsed_functions_entry, s, i, uf); i++)
 440     {
 441       fprintf (file, "#%u:\n", i);
 442       cp_debug_print_unparsed_function (file, uf);
 443     }
 444 }
 445
 446
 447 /* Dump the tokens in a window of size WINDOW_SIZE around the next_token for
 448    the given PARSER.  If FILE is NULL, the output is printed on stderr. */
 449
 450 static void
 451 cp_debug_parser_tokens (FILE *file, cp_parser *parser, int window_size)
 452 {
 453   cp_token *next_token, *first_token, *start_token;
 454
 455   if (file == NULL)
 456     file = stderr;
 457
 458   next_token = parser->lexer->next_token;
 459   first_token = VEC_address (cp_token, parser->lexer->buffer);
 460   start_token = (next_token > first_token + window_size / 2)
 461                 ? next_token - window_size / 2
 462                 : first_token;
 463   cp_lexer_dump_tokens (file, parser->lexer->buffer, start_token, window_size,
 464                         next_token);
 465 }
 466
 467
 468 /* Dump debugging information for the given PARSER.  If FILE is NULL,
 469    the output is printed on stderr.  */
 470
 471 void
 472 cp_debug_parser (FILE *file, cp_parser *parser)
 473 {
 474   const size_t window_size = 20;
 475   cp_token *token;
 476   expanded_location eloc;
 477
 478   if (file == NULL)
 479     file = stderr;
 480
 481   fprintf (file, "Parser state\n\n");
 482   fprintf (file, "Number of tokens: %u\n",
 483            VEC_length (cp_token, parser->lexer->buffer));
 484   cp_debug_print_tree_if_set (file, "Lookup scope", parser->scope);
 485   cp_debug_print_tree_if_set (file, "Object scope",
 486                                      parser->object_scope);
 487   cp_debug_print_tree_if_set (file, "Qualifying scope",
 488                                      parser->qualifying_scope);
 489   cp_debug_print_context_stack (file, parser->context);
 490   cp_debug_print_flag (file, "Allow GNU extensions",
 491                               parser->allow_gnu_extensions_p);
 492   cp_debug_print_flag (file, "'>' token is greater-than",
 493                               parser->greater_than_is_operator_p);
 494   cp_debug_print_flag (file, "Default args allowed in current "
 495                               "parameter list", parser->default_arg_ok_p);
 496   cp_debug_print_flag (file, "Parsing integral constant-expression",
 497                               parser->integral_constant_expression_p);
 498   cp_debug_print_flag (file, "Allow non-constant expression in current "
 499                               "constant-expression",
 500                               parser->allow_non_integral_constant_expression_p);
 501   cp_debug_print_flag (file, "Seen non-constant expression",
 502                               parser->non_integral_constant_expression_p);
 503   cp_debug_print_flag (file, "Local names and 'this' forbidden in "
 504                               "current context",
 505                               parser->local_variables_forbidden_p);
 506   cp_debug_print_flag (file, "In unbraced linkage specification",
 507                               parser->in_unbraced_linkage_specification_p);
 508   cp_debug_print_flag (file, "Parsing a declarator",
 509                               parser->in_declarator_p);
 510   cp_debug_print_flag (file, "In template argument list",
 511                               parser->in_template_argument_list_p);
 512   cp_debug_print_flag (file, "Parsing an iteration statement",
 513                               parser->in_statement & IN_ITERATION_STMT);
 514   cp_debug_print_flag (file, "Parsing a switch statement",
 515                               parser->in_statement & IN_SWITCH_STMT);
 516   cp_debug_print_flag (file, "Parsing a structured OpenMP block",
 517                               parser->in_statement & IN_OMP_BLOCK);
 518   cp_debug_print_flag (file, "Parsing a an OpenMP loop",
 519                               parser->in_statement & IN_OMP_FOR);
 520   cp_debug_print_flag (file, "Parsing an if statement",
 521                               parser->in_statement & IN_IF_STMT);
 522   cp_debug_print_flag (file, "Parsing a type-id in an expression "
 523                               "context", parser->in_type_id_in_expr_p);
 524   cp_debug_print_flag (file, "Declarations are implicitly extern \"C\"",
 525                               parser->implicit_extern_c);
 526   cp_debug_print_flag (file, "String expressions should be translated "
 527                               "to execution character set",
 528                               parser->translate_strings_p);
 529   cp_debug_print_flag (file, "Parsing function body outside of a "
 530                               "local class", parser->in_function_body);
 531   cp_debug_print_flag (file, "Auto correct a colon to a scope operator",
 532                               parser->colon_corrects_to_scope_p);
 533   if (parser->type_definition_forbidden_message)
 534     fprintf (file, "Error message for forbidden type definitions: %s\n",
 535              parser->type_definition_forbidden_message);
 536   cp_debug_print_unparsed_queues (file, parser->unparsed_queues);
 537   fprintf (file, "Number of class definitions in progress: %u\n",
 538            parser->num_classes_being_defined);
 539   fprintf (file, "Number of template parameter lists for the current "
 540            "declaration: %u\n", parser->num_template_parameter_lists);
 541   cp_debug_parser_tokens (file, parser, window_size);
 542   token = parser->lexer->next_token;
 543   fprintf (file, "Next token to parse:\n");
 544   fprintf (file, "\tToken:  ");
 545   cp_lexer_print_token (file, token);
 546   eloc = expand_location (token->location);
 547   fprintf (file, "\n\tFile:   %s\n", eloc.file);
 548   fprintf (file, "\tLine:   %d\n", eloc.line);
 549   fprintf (file, "\tColumn: %d\n", eloc.column);
 550 }
 551
 552
 553 /* Allocate memory for a new lexer object and return it.  */
 554
 555 static cp_lexer *
 556 cp_lexer_alloc (void)
 557 {
 558   cp_lexer *lexer;
 559
 560   c_common_no_more_pch ();
 561
 562   /* Allocate the memory.  */
 563   lexer = ggc_alloc_cleared_cp_lexer ();
 564
 565   /* Initially we are not debugging.  */
 566   lexer->debugging_p = false;
 567
 568   lexer->saved_tokens = VEC_alloc (cp_token_position, heap,
 569                                    CP_SAVED_TOKEN_STACK);
 570
 571   /* Create the buffer.  */
 572   lexer->buffer = VEC_alloc (cp_token, gc, CP_LEXER_BUFFER_SIZE);
 573
 574   return lexer;
 575 }
 576
 577
 578 /* Create a new main C++ lexer, the lexer that gets tokens from the
 579    preprocessor.  */
 580
 581 static cp_lexer *
 582 cp_lexer_new_main (void)
 583 {
 584   cp_lexer *lexer;
 585   cp_token token;
 586
 587   /* It's possible that parsing the first pragma will load a PCH file,
 588      which is a GC collection point.  So we have to do that before
 589      allocating any memory.  */
 590   cp_parser_initial_pragma (&token);
 591
 592   lexer = cp_lexer_alloc ();
 593
 594   /* Put the first token in the buffer.  */
 595   VEC_quick_push (cp_token, lexer->buffer, &token);
 596
 597   /* Get the remaining tokens from the preprocessor.  */
 598   while (token.type != CPP_EOF)
 599     {
 600       cp_lexer_get_preprocessor_token (lexer, &token);
 601       VEC_safe_push (cp_token, gc, lexer->buffer, &token);
 602     }
 603
 604   lexer->last_token = VEC_address (cp_token, lexer->buffer)
 605                       + VEC_length (cp_token, lexer->buffer)
 606                       - 1;
 607   lexer->next_token = VEC_length (cp_token, lexer->buffer)
 608                       ? VEC_address (cp_token, lexer->buffer)
 609                       : &eof_token;
 610
 611   /* Subsequent preprocessor diagnostics should use compiler
 612      diagnostic functions to get the compiler source location.  */
 613   done_lexing = true;
 614
 615   gcc_assert (!lexer->next_token->purged_p);
 616   return lexer;
 617 }
 618
 619 /* Create a new lexer whose token stream is primed with the tokens in
 620    CACHE.  When these tokens are exhausted, no new tokens will be read.  */
 621
 622 static cp_lexer *
 623 cp_lexer_new_from_tokens (cp_token_cache *cache)
 624 {
 625   cp_token *first = cache->first;
 626   cp_token *last = cache->last;
 627   cp_lexer *lexer = ggc_alloc_cleared_cp_lexer ();
 628
 629   /* We do not own the buffer.  */
 630   lexer->buffer = NULL;
 631   lexer->next_token = first == last ? &eof_token : first;
 632   lexer->last_token = last;
 633
 634   lexer->saved_tokens = VEC_alloc (cp_token_position, heap,
 635                                    CP_SAVED_TOKEN_STACK);
 636
 637   /* Initially we are not debugging.  */
 638   lexer->debugging_p = false;
 639
 640   gcc_assert (!lexer->next_token->purged_p);
 641   return lexer;
 642 }
 643
 644 /* Frees all resources associated with LEXER.  */
 645
 646 static void
 647 cp_lexer_destroy (cp_lexer *lexer)
 648 {
 649   VEC_free (cp_token, gc, lexer->buffer);
 650   VEC_free (cp_token_position, heap, lexer->saved_tokens);
 651   ggc_free (lexer);
 652 }
 653
 654 /* Returns nonzero if debugging information should be output.  */
 655
 656 static inline bool
 657 cp_lexer_debugging_p (cp_lexer *lexer)
 658 {
 659   return lexer->debugging_p;
 660 }
 661
 662
 663 static inline cp_token_position
 664 cp_lexer_token_position (cp_lexer *lexer, bool previous_p)
 665 {
 666   gcc_assert (!previous_p || lexer->next_token != &eof_token);
 667
 668   return lexer->next_token - previous_p;
 669 }
 670
 671 static inline cp_token *
 672 cp_lexer_token_at (cp_lexer *lexer ATTRIBUTE_UNUSED, cp_token_position pos)
 673 {
 674   return pos;
 675 }
 676
 677 static inline void
 678 cp_lexer_set_token_position (cp_lexer *lexer, cp_token_position pos)
 679 {
 680   lexer->next_token = cp_lexer_token_at (lexer, pos);
 681 }
 682
 683 static inline cp_token_position
 684 cp_lexer_previous_token_position (cp_lexer *lexer)
 685 {
 686   if (lexer->next_token == &eof_token)
 687     return lexer->last_token - 1;
 688   else
 689     return cp_lexer_token_position (lexer, true);
 690 }
 691
 692 static inline cp_token *
 693 cp_lexer_previous_token (cp_lexer *lexer)
 694 {
 695   cp_token_position tp = cp_lexer_previous_token_position (lexer);
 696
 697   return cp_lexer_token_at (lexer, tp);
 698 }
 699
 700 /* nonzero if we are presently saving tokens.  */
 701
 702 static inline int
 703 cp_lexer_saving_tokens (const cp_lexer* lexer)
 704 {
 705   return VEC_length (cp_token_position, lexer->saved_tokens) != 0;
 706 }
 707
 708 /* Store the next token from the preprocessor in *TOKEN.  Return true
 709    if we reach EOF.  If LEXER is NULL, assume we are handling an
 710    initial #pragma pch_preprocess, and thus want the lexer to return
 711    processed strings.  */
 712
 713 static void
 714 cp_lexer_get_preprocessor_token (cp_lexer *lexer, cp_token *token)
 715 {
 716   static int is_extern_c = 0;
 717
 718    /* Get a new token from the preprocessor.  */
 719   token->type
 720     = c_lex_with_flags (&token->u.value, &token->location, &token->flags,
 721                         lexer == NULL ? 0 : C_LEX_STRING_NO_JOIN);
 722   token->keyword = RID_MAX;
 723   token->pragma_kind = PRAGMA_NONE;
 724   token->purged_p = false;
 725
 726   /* On some systems, some header files are surrounded by an
 727      implicit extern "C" block.  Set a flag in the token if it
 728      comes from such a header.  */
 729   is_extern_c += pending_lang_change;
 730   pending_lang_change = 0;
 731   token->implicit_extern_c = is_extern_c > 0;
 732
 733   /* Check to see if this token is a keyword.  */
 734   if (token->type == CPP_NAME)
 735     {
 736       if (C_IS_RESERVED_WORD (token->u.value))
 737         {
 738           /* Mark this token as a keyword.  */
 739           token->type = CPP_KEYWORD;
 740           /* Record which keyword.  */
 741           token->keyword = C_RID_CODE (token->u.value);
 742         }
 743       else
 744         {
 745           if (warn_cxx0x_compat
 746               && C_RID_CODE (token->u.value) >= RID_FIRST_CXX0X
 747               && C_RID_CODE (token->u.value) <= RID_LAST_CXX0X)
 748             {
 749               /* Warn about the C++0x keyword (but still treat it as
 750                  an identifier).  */
 751               warning (OPT_Wc__0x_compat,
 752                        "identifier %qE is a keyword in C++11",
 753                        token->u.value);
 754
 755               /* Clear out the C_RID_CODE so we don't warn about this
 756                  particular identifier-turned-keyword again.  */
 757               C_SET_RID_CODE (token->u.value, RID_MAX);
 758             }
 759
 760           token->ambiguous_p = false;
 761           token->keyword = RID_MAX;
 762         }
 763     }
 764   else if (token->type == CPP_AT_NAME)
 765     {
 766       /* This only happens in Objective-C++; it must be a keyword.  */
 767       token->type = CPP_KEYWORD;
 768       switch (C_RID_CODE (token->u.value))
 769         {
 770           /* Replace 'class' with '@class', 'private' with '@private',
 771              etc.  This prevents confusion with the C++ keyword
 772              'class', and makes the tokens consistent with other
 773              Objective-C 'AT' keywords.  For example '@class' is
 774              reported as RID_AT_CLASS which is consistent with
 775              '@synchronized', which is reported as
 776              RID_AT_SYNCHRONIZED.
 777           */
 778         case RID_CLASS:     token->keyword = RID_AT_CLASS; break;
 779         case RID_PRIVATE:   token->keyword = RID_AT_PRIVATE; break;
 780         case RID_PROTECTED: token->keyword = RID_AT_PROTECTED; break;
 781         case RID_PUBLIC:    token->keyword = RID_AT_PUBLIC; break;
 782         case RID_THROW:     token->keyword = RID_AT_THROW; break;
 783         case RID_TRY:       token->keyword = RID_AT_TRY; break;
 784         case RID_CATCH:     token->keyword = RID_AT_CATCH; break;
 785         default:            token->keyword = C_RID_CODE (token->u.value);
 786         }
 787     }
 788   else if (token->type == CPP_PRAGMA)
 789     {
 790       /* We smuggled the cpp_token->u.pragma value in an INTEGER_CST.  */
 791       token->pragma_kind = ((enum pragma_kind)
 792                             TREE_INT_CST_LOW (token->u.value));
 793       token->u.value = NULL_TREE;
 794     }
 795 }
 796
 797 /* Update the globals input_location and the input file stack from TOKEN.  */
 798 static inline void
 799 cp_lexer_set_source_position_from_token (cp_token *token)
 800 {
 801   if (token->type != CPP_EOF)
 802     {
 803       input_location = token->location;
 804     }
 805 }
 806
 807 /* Return a pointer to the next token in the token stream, but do not
 808    consume it.  */
 809
 810 static inline cp_token *
 811 cp_lexer_peek_token (cp_lexer *lexer)
 812 {
 813   if (cp_lexer_debugging_p (lexer))
 814     {
 815       fputs ("cp_lexer: peeking at token: ", cp_lexer_debug_stream);
 816       cp_lexer_print_token (cp_lexer_debug_stream, lexer->next_token);
 817       putc ('\n', cp_lexer_debug_stream);
 818     }
 819   return lexer->next_token;
 820 }
 821
 822 /* Return true if the next token has the indicated TYPE.  */
 823
 824 static inline bool
 825 cp_lexer_next_token_is (cp_lexer* lexer, enum cpp_ttype type)
 826 {
 827   return cp_lexer_peek_token (lexer)->type == type;
 828 }
 829
 830 /* Return true if the next token does not have the indicated TYPE.  */
 831
 832 static inline bool
 833 cp_lexer_next_token_is_not (cp_lexer* lexer, enum cpp_ttype type)
 834 {
 835   return !cp_lexer_next_token_is (lexer, type);
 836 }
 837
 838 /* Return true if the next token is the indicated KEYWORD.  */
 839
 840 static inline bool
 841 cp_lexer_next_token_is_keyword (cp_lexer* lexer, enum rid keyword)
 842 {
 843   return cp_lexer_peek_token (lexer)->keyword == keyword;
 844 }
 845
 846 /* Return true if the next token is not the indicated KEYWORD.  */
 847
 848 static inline bool
 849 cp_lexer_next_token_is_not_keyword (cp_lexer* lexer, enum rid keyword)
 850 {
 851   return cp_lexer_peek_token (lexer)->keyword != keyword;
 852 }
 853
 854 /* Return true if the next token is a keyword for a decl-specifier.  */
 855
 856 static bool
 857 cp_lexer_next_token_is_decl_specifier_keyword (cp_lexer *lexer)
 858 {
 859   cp_token *token;
 860
 861   token = cp_lexer_peek_token (lexer);
 862   switch (token->keyword)
 863     {
 864       /* auto specifier: storage-class-specifier in C++,
 865          simple-type-specifier in C++0x.  */
 866     case RID_AUTO:
 867       /* Storage classes.  */
 868     case RID_REGISTER:
 869     case RID_STATIC:
 870     case RID_EXTERN:
 871     case RID_MUTABLE:
 872     case RID_THREAD:
 873       /* Elaborated type specifiers.  */
 874     case RID_ENUM:
 875     case RID_CLASS:
 876     case RID_STRUCT:
 877     case RID_UNION:
 878     case RID_TYPENAME:
 879       /* Simple type specifiers.  */
 880     case RID_CHAR:
 881     case RID_CHAR16:
 882     case RID_CHAR32:
 883     case RID_WCHAR:
 884     case RID_BOOL:
 885     case RID_SHORT:
 886     case RID_INT:
 887     case RID_LONG:
 888     case RID_INT128:
 889     case RID_SIGNED:
 890     case RID_UNSIGNED:
 891     case RID_FLOAT:
 892     case RID_DOUBLE:
 893     case RID_VOID:
 894       /* GNU extensions.  */
 895     case RID_ATTRIBUTE:
 896     case RID_TYPEOF:
 897       /* C++0x extensions.  */
 898     case RID_DECLTYPE:
 899     case RID_UNDERLYING_TYPE:
 900       return true;
 901
 902     default:
 903       return false;
 904     }
 905 }
 906
 907 /* Returns TRUE iff the token T begins a decltype type.  */
 908
 909 static bool
 910 token_is_decltype (cp_token *t)
 911 {
 912   return (t->keyword == RID_DECLTYPE
 913           || t->type == CPP_DECLTYPE);
 914 }
 915
 916 /* Returns TRUE iff the next token begins a decltype type.  */
 917
 918 static bool
 919 cp_lexer_next_token_is_decltype (cp_lexer *lexer)
 920 {
 921   cp_token *t = cp_lexer_peek_token (lexer);
 922   return token_is_decltype (t);
 923 }
 924
 925 /* Return a pointer to the Nth token in the token stream.  If N is 1,
 926    then this is precisely equivalent to cp_lexer_peek_token (except
 927    that it is not inline).  One would like to disallow that case, but
 928    there is one case (cp_parser_nth_token_starts_template_id) where
 929    the caller passes a variable for N and it might be 1.  */
 930
 931 static cp_token *
 932 cp_lexer_peek_nth_token (cp_lexer* lexer, size_t n)
 933 {
 934   cp_token *token;
 935
 936   /* N is 1-based, not zero-based.  */
 937   gcc_assert (n > 0);
 938
 939   if (cp_lexer_debugging_p (lexer))
 940     fprintf (cp_lexer_debug_stream,
 941              "cp_lexer: peeking ahead %ld at token: ", (long)n);
 942
 943   --n;
 944   token = lexer->next_token;
 945   gcc_assert (!n || token != &eof_token);
 946   while (n != 0)
 947     {
 948       ++token;
 949       if (token == lexer->last_token)
 950         {
 951           token = &eof_token;
 952           break;
 953         }
 954
 955       if (!token->purged_p)
 956         --n;
 957     }
 958
 959   if (cp_lexer_debugging_p (lexer))
 960     {
 961       cp_lexer_print_token (cp_lexer_debug_stream, token);
 962       putc ('\n', cp_lexer_debug_stream);
 963     }
 964
 965   return token;
 966 }
 967
 968 /* Return the next token, and advance the lexer's next_token pointer
 969    to point to the next non-purged token.  */
 970
 971 static cp_token *
 972 cp_lexer_consume_token (cp_lexer* lexer)
 973 {
 974   cp_token *token = lexer->next_token;
 975
 976   gcc_assert (token != &eof_token);
 977   gcc_assert (!lexer->in_pragma || token->type != CPP_PRAGMA_EOL);
 978
 979   do
 980     {
 981       lexer->next_token++;
 982       if (lexer->next_token == lexer->last_token)
 983         {
 984           lexer->next_token = &eof_token;
 985           break;
 986         }
 987
 988     }
 989   while (lexer->next_token->purged_p);
 990
 991   cp_lexer_set_source_position_from_token (token);
 992
 993   /* Provide debugging output.  */
 994   if (cp_lexer_debugging_p (lexer))
 995     {
 996       fputs ("cp_lexer: consuming token: ", cp_lexer_debug_stream);
 997       cp_lexer_print_token (cp_lexer_debug_stream, token);
 998       putc ('\n', cp_lexer_debug_stream);
 999     }
1000
1001   return token;
1002 }
1003
1004 /* Permanently remove the next token from the token stream, and
1005    advance the next_token pointer to refer to the next non-purged
1006    token.  */
1007
1008 static void
1009 cp_lexer_purge_token (cp_lexer *lexer)
1010 {
1011   cp_token *tok = lexer->next_token;
1012
1013   gcc_assert (tok != &eof_token);
1014   tok->purged_p = true;
1015   tok->location = UNKNOWN_LOCATION;
1016   tok->u.value = NULL_TREE;
1017   tok->keyword = RID_MAX;
1018
1019   do
1020     {
1021       tok++;
1022       if (tok == lexer->last_token)
1023         {
1024           tok = &eof_token;
1025           break;
1026         }
1027     }
1028   while (tok->purged_p);
1029   lexer->next_token = tok;
1030 }
1031
1032 /* Permanently remove all tokens after TOK, up to, but not
1033    including, the token that will be returned next by
1034    cp_lexer_peek_token.  */
1035
1036 static void
1037 cp_lexer_purge_tokens_after (cp_lexer *lexer, cp_token *tok)
1038 {
1039   cp_token *peek = lexer->next_token;
1040
1041   if (peek == &eof_token)
1042     peek = lexer->last_token;
1043
1044   gcc_assert (tok < peek);
1045
1046   for ( tok += 1; tok != peek; tok += 1)
1047     {
1048       tok->purged_p = true;
1049       tok->location = UNKNOWN_LOCATION;
1050       tok->u.value = NULL_TREE;
1051       tok->keyword = RID_MAX;
1052     }
1053 }
1054
1055 /* Begin saving tokens.  All tokens consumed after this point will be
1056    preserved.  */
1057
1058 static void
1059 cp_lexer_save_tokens (cp_lexer* lexer)
1060 {
1061   /* Provide debugging output.  */
1062   if (cp_lexer_debugging_p (lexer))
1063     fprintf (cp_lexer_debug_stream, "cp_lexer: saving tokens\n");
1064
1065   VEC_safe_push (cp_token_position, heap,
1066                  lexer->saved_tokens, lexer->next_token);
1067 }
1068
1069 /* Commit to the portion of the token stream most recently saved.  */
1070
1071 static void
1072 cp_lexer_commit_tokens (cp_lexer* lexer)
1073 {
1074   /* Provide debugging output.  */
1075   if (cp_lexer_debugging_p (lexer))
1076     fprintf (cp_lexer_debug_stream, "cp_lexer: committing tokens\n");
1077
1078   VEC_pop (cp_token_position, lexer->saved_tokens);
1079 }
1080
1081 /* Return all tokens saved since the last call to cp_lexer_save_tokens
1082    to the token stream.  Stop saving tokens.  */
1083
1084 static void
1085 cp_lexer_rollback_tokens (cp_lexer* lexer)
1086 {
1087   /* Provide debugging output.  */
1088   if (cp_lexer_debugging_p (lexer))
1089     fprintf (cp_lexer_debug_stream, "cp_lexer: restoring tokens\n");
1090
1091   lexer->next_token = VEC_pop (cp_token_position, lexer->saved_tokens);
1092 }
1093
1094 /* Print a representation of the TOKEN on the STREAM.  */
1095
1096 static void
1097 cp_lexer_print_token (FILE * stream, cp_token *token)
1098 {
1099   /* We don't use cpp_type2name here because the parser defines
1100      a few tokens of its own.  */
1101   static const char *const token_names[] = {
1102     /* cpplib-defined token types */
1103 #define OP(e, s) #e,
1104 #define TK(e, s) #e,
1105     TTYPE_TABLE
1106 #undef OP
1107 #undef TK
1108     /* C++ parser token types - see "Manifest constants", above.  */
1109     "KEYWORD",
1110     "TEMPLATE_ID",
1111     "NESTED_NAME_SPECIFIER",
1112   };
1113
1114   /* For some tokens, print the associated data.  */
1115   switch (token->type)
1116     {
1117     case CPP_KEYWORD:
1118       /* Some keywords have a value that is not an IDENTIFIER_NODE.
1119          For example, `struct' is mapped to an INTEGER_CST.  */
1120       if (TREE_CODE (token->u.value) != IDENTIFIER_NODE)
1121         break;
1122       /* else fall through */
1123     case CPP_NAME:
1124       fputs (IDENTIFIER_POINTER (token->u.value), stream);
1125       break;
1126
1127     case CPP_STRING:
1128     case CPP_STRING16:
1129     case CPP_STRING32:
1130     case CPP_WSTRING:
1131     case CPP_UTF8STRING:
1132       fprintf (stream, " \"%s\"", TREE_STRING_POINTER (token->u.value));
1133       break;
1134
1135     case CPP_NUMBER:
1136       print_generic_expr (stream, token->u.value, 0);
1137       break;
1138
1139     default:
1140       /* If we have a name for the token, print it out.  Otherwise, we
1141          simply give the numeric code.  */
1142       if (token->type < ARRAY_SIZE(token_names))
1143         fputs (token_names[token->type], stream);
1144       else
1145         fprintf (stream, "[%d]", token->type);
1146       break;
1147     }
1148 }
1149
1150 /* Start emitting debugging information.  */
1151
1152 static void
1153 cp_lexer_start_debugging (cp_lexer* lexer)
1154 {
1155   lexer->debugging_p = true;
1156   cp_lexer_debug_stream = stderr;
1157 }
1158
1159 /* Stop emitting debugging information.  */
1160
1161 static void
1162 cp_lexer_stop_debugging (cp_lexer* lexer)
1163 {
1164   lexer->debugging_p = false;
1165   cp_lexer_debug_stream = NULL;
1166 }
1167
1168 /* Create a new cp_token_cache, representing a range of tokens.  */
1169
1170 static cp_token_cache *
1171 cp_token_cache_new (cp_token *first, cp_token *last)
1172 {
1173   cp_token_cache *cache = ggc_alloc_cp_token_cache ();
1174   cache->first = first;
1175   cache->last = last;
1176   return cache;
1177 }
1178
1179 \f
1180 /* Decl-specifiers.  */
1181
1182 /* Set *DECL_SPECS to represent an empty decl-specifier-seq.  */
1183
1184 static void
1185 clear_decl_specs (cp_decl_specifier_seq *decl_specs)
1186 {
1187   memset (decl_specs, 0, sizeof (cp_decl_specifier_seq));
1188 }
1189
1190 /* Declarators.  */
1191
1192 /* Nothing other than the parser should be creating declarators;
1193    declarators are a semi-syntactic representation of C++ entities.
1194    Other parts of the front end that need to create entities (like
1195    VAR_DECLs or FUNCTION_DECLs) should do that directly.  */
1196
1197 static cp_declarator *make_call_declarator
1198   (cp_declarator *, tree, cp_cv_quals, cp_virt_specifiers, tree, tree);
1199 static cp_declarator *make_array_declarator
1200   (cp_declarator *, tree);
1201 static cp_declarator *make_pointer_declarator
1202   (cp_cv_quals, cp_declarator *);
1203 static cp_declarator *make_reference_declarator
1204   (cp_cv_quals, cp_declarator *, bool);
1205 static cp_parameter_declarator *make_parameter_declarator
1206   (cp_decl_specifier_seq *, cp_declarator *, tree);
1207 static cp_declarator *make_ptrmem_declarator
1208   (cp_cv_quals, tree, cp_declarator *);
1209
1210 /* An erroneous declarator.  */
1211 static cp_declarator *cp_error_declarator;
1212
1213 /* The obstack on which declarators and related data structures are
1214    allocated.  */
1215 static struct obstack declarator_obstack;
1216
1217 /* Alloc BYTES from the declarator memory pool.  */
1218
1219 static inline void *
1220 alloc_declarator (size_t bytes)
1221 {
1222   return obstack_alloc (&declarator_obstack, bytes);
1223 }
1224
1225 /* Allocate a declarator of the indicated KIND.  Clear fields that are
1226    common to all declarators.  */
1227
1228 static cp_declarator *
1229 make_declarator (cp_declarator_kind kind)
1230 {
1231   cp_declarator *declarator;
1232
1233   declarator = (cp_declarator *) alloc_declarator (sizeof (cp_declarator));
1234   declarator->kind = kind;
1235   declarator->attributes = NULL_TREE;
1236   declarator->declarator = NULL;
1237   declarator->parameter_pack_p = false;
1238   declarator->id_loc = UNKNOWN_LOCATION;
1239
1240   return declarator;
1241 }
1242
1243 /* Make a declarator for a generalized identifier.  If
1244    QUALIFYING_SCOPE is non-NULL, the identifier is
1245    QUALIFYING_SCOPE::UNQUALIFIED_NAME; otherwise, it is just
1246    UNQUALIFIED_NAME.  SFK indicates the kind of special function this
1247    is, if any.   */
1248
1249 static cp_declarator *
1250 make_id_declarator (tree qualifying_scope, tree unqualified_name,
1251                     special_function_kind sfk)
1252 {
1253   cp_declarator *declarator;
1254
1255   /* It is valid to write:
1256
1257        class C { void f(); };
1258        typedef C D;
1259        void D::f();
1260
1261      The standard is not clear about whether `typedef const C D' is
1262      legal; as of 2002-09-15 the committee is considering that
1263      question.  EDG 3.0 allows that syntax.  Therefore, we do as
1264      well.  */
1265   if (qualifying_scope && TYPE_P (qualifying_scope))
1266     qualifying_scope = TYPE_MAIN_VARIANT (qualifying_scope);
1267
1268   gcc_assert (TREE_CODE (unqualified_name) == IDENTIFIER_NODE
1269               || TREE_CODE (unqualified_name) == BIT_NOT_EXPR
1270               || TREE_CODE (unqualified_name) == TEMPLATE_ID_EXPR);
1271
1272   declarator = make_declarator (cdk_id);
1273   declarator->u.id.qualifying_scope = qualifying_scope;
1274   declarator->u.id.unqualified_name = unqualified_name;
1275   declarator->u.id.sfk = sfk;
1276
1277   return declarator;
1278 }
1279
1280 /* Make a declarator for a pointer to TARGET.  CV_QUALIFIERS is a list
1281    of modifiers such as const or volatile to apply to the pointer
1282    type, represented as identifiers.  */
1283
1284 cp_declarator *
1285 make_pointer_declarator (cp_cv_quals cv_qualifiers, cp_declarator *target)
1286 {
1287   cp_declarator *declarator;
1288
1289   declarator = make_declarator (cdk_pointer);
1290   declarator->declarator = target;
1291   declarator->u.pointer.qualifiers = cv_qualifiers;
1292   declarator->u.pointer.class_type = NULL_TREE;
1293   if (target)
1294     {
1295       declarator->id_loc = target->id_loc;
1296       declarator->parameter_pack_p = target->parameter_pack_p;
1297       target->parameter_pack_p = false;
1298     }
1299   else
1300     declarator->parameter_pack_p = false;
1301
1302   return declarator;
1303 }
1304
1305 /* Like make_pointer_declarator -- but for references.  */
1306
1307 cp_declarator *
1308 make_reference_declarator (cp_cv_quals cv_qualifiers, cp_declarator *target,
1309                            bool rvalue_ref)
1310 {
1311   cp_declarator *declarator;
1312
1313   declarator = make_declarator (cdk_reference);
1314   declarator->declarator = target;
1315   declarator->u.reference.qualifiers = cv_qualifiers;
1316   declarator->u.reference.rvalue_ref = rvalue_ref;
1317   if (target)
1318     {
1319       declarator->id_loc = target->id_loc;
1320       declarator->parameter_pack_p = target->parameter_pack_p;
1321       target->parameter_pack_p = false;
1322     }
1323   else
1324     declarator->parameter_pack_p = false;
1325
1326   return declarator;
1327 }
1328
1329 /* Like make_pointer_declarator -- but for a pointer to a non-static
1330    member of CLASS_TYPE.  */
1331
1332 cp_declarator *
1333 make_ptrmem_declarator (cp_cv_quals cv_qualifiers, tree class_type,
1334                         cp_declarator *pointee)
1335 {
1336   cp_declarator *declarator;
1337
1338   declarator = make_declarator (cdk_ptrmem);
1339   declarator->declarator = pointee;
1340   declarator->u.pointer.qualifiers = cv_qualifiers;
1341   declarator->u.pointer.class_type = class_type;
1342
1343   if (pointee)
1344     {
1345       declarator->parameter_pack_p = pointee->parameter_pack_p;
1346       pointee->parameter_pack_p = false;
1347     }
1348   else
1349     declarator->parameter_pack_p = false;
1350
1351   return declarator;
1352 }
1353
1354 /* Make a declarator for the function given by TARGET, with the
1355    indicated PARMS.  The CV_QUALIFIERS aply to the function, as in
1356    "const"-qualified member function.  The EXCEPTION_SPECIFICATION
1357    indicates what exceptions can be thrown.  */
1358
1359 cp_declarator *
1360 make_call_declarator (cp_declarator *target,
1361                       tree parms,
1362                       cp_cv_quals cv_qualifiers,
1363                       cp_virt_specifiers virt_specifiers,
1364                       tree exception_specification,
1365                       tree late_return_type)
1366 {
1367   cp_declarator *declarator;
1368
1369   declarator = make_declarator (cdk_function);
1370   declarator->declarator = target;
1371   declarator->u.function.parameters = parms;
1372   declarator->u.function.qualifiers = cv_qualifiers;
1373   declarator->u.function.virt_specifiers = virt_specifiers;
1374   declarator->u.function.exception_specification = exception_specification;
1375   declarator->u.function.late_return_type = late_return_type;
1376   if (target)
1377     {
1378       declarator->id_loc = target->id_loc;
1379       declarator->parameter_pack_p = target->parameter_pack_p;
1380       target->parameter_pack_p = false;
1381     }
1382   else
1383     declarator->parameter_pack_p = false;
1384
1385   return declarator;
1386 }
1387
1388 /* Make a declarator for an array of BOUNDS elements, each of which is
1389    defined by ELEMENT.  */
1390
1391 cp_declarator *
1392 make_array_declarator (cp_declarator *element, tree bounds)
1393 {
1394   cp_declarator *declarator;
1395
1396   declarator = make_declarator (cdk_array);
1397   declarator->declarator = element;
1398   declarator->u.array.bounds = bounds;
1399   if (element)
1400     {
1401       declarator->id_loc = element->id_loc;
1402       declarator->parameter_pack_p = element->parameter_pack_p;
1403       element->parameter_pack_p = false;
1404     }
1405   else
1406     declarator->parameter_pack_p = false;
1407
1408   return declarator;
1409 }
1410
1411 /* Determine whether the declarator we've seen so far can be a
1412    parameter pack, when followed by an ellipsis.  */
1413 static bool
1414 declarator_can_be_parameter_pack (cp_declarator *declarator)
1415 {
1416   /* Search for a declarator name, or any other declarator that goes
1417      after the point where the ellipsis could appear in a parameter
1418      pack. If we find any of these, then this declarator can not be
1419      made into a parameter pack.  */
1420   bool found = false;
1421   while (declarator && !found)
1422     {
1423       switch ((int)declarator->kind)
1424         {
1425         case cdk_id:
1426         case cdk_array:
1427           found = true;
1428           break;
1429
1430         case cdk_error:
1431           return true;
1432
1433         default:
1434           declarator = declarator->declarator;
1435           break;
1436         }
1437     }
1438
1439   return !found;
1440 }
1441
1442 cp_parameter_declarator *no_parameters;
1443
1444 /* Create a parameter declarator with the indicated DECL_SPECIFIERS,
1445    DECLARATOR and DEFAULT_ARGUMENT.  */
1446
1447 cp_parameter_declarator *
1448 make_parameter_declarator (cp_decl_specifier_seq *decl_specifiers,
1449                            cp_declarator *declarator,
1450                            tree default_argument)
1451 {
1452   cp_parameter_declarator *parameter;
1453
1454   parameter = ((cp_parameter_declarator *)
1455                alloc_declarator (sizeof (cp_parameter_declarator)));
1456   parameter->next = NULL;
1457   if (decl_specifiers)
1458     parameter->decl_specifiers = *decl_specifiers;
1459   else
1460     clear_decl_specs (&parameter->decl_specifiers);
1461   parameter->declarator = declarator;
1462   parameter->default_argument = default_argument;
1463   parameter->ellipsis_p = false;
1464
1465   return parameter;
1466 }
1467
1468 /* Returns true iff DECLARATOR  is a declaration for a function.  */
1469
1470 static bool
1471 function_declarator_p (const cp_declarator *declarator)
1472 {
1473   while (declarator)
1474     {
1475       if (declarator->kind == cdk_function
1476           && declarator->declarator->kind == cdk_id)
1477         return true;
1478       if (declarator->kind == cdk_id
1479           || declarator->kind == cdk_error)
1480         return false;
1481       declarator = declarator->declarator;
1482     }
1483   return false;
1484 }
1485
1486 /* The parser.  */
1487
1488 /* Overview
1489    --------
1490
1491    A cp_parser parses the token stream as specified by the C++
1492    grammar.  Its job is purely parsing, not semantic analysis.  For
1493    example, the parser breaks the token stream into declarators,
1494    expressions, statements, and other similar syntactic constructs.
1495    It does not check that the types of the expressions on either side
1496    of an assignment-statement are compatible, or that a function is
1497    not declared with a parameter of type `void'.
1498
1499    The parser invokes routines elsewhere in the compiler to perform
1500    semantic analysis and to build up the abstract syntax tree for the
1501    code processed.
1502
1503    The parser (and the template instantiation code, which is, in a
1504    way, a close relative of parsing) are the only parts of the
1505    compiler that should be calling push_scope and pop_scope, or
1506    related functions.  The parser (and template instantiation code)
1507    keeps track of what scope is presently active; everything else
1508    should simply honor that.  (The code that generates static
1509    initializers may also need to set the scope, in order to check
1510    access control correctly when emitting the initializers.)
1511
1512    Methodology
1513    -----------
1514
1515    The parser is of the standard recursive-descent variety.  Upcoming
1516    tokens in the token stream are examined in order to determine which
1517    production to use when parsing a non-terminal.  Some C++ constructs
1518    require arbitrary look ahead to disambiguate.  For example, it is
1519    impossible, in the general case, to tell whether a statement is an
1520    expression or declaration without scanning the entire statement.
1521    Therefore, the parser is capable of "parsing tentatively."  When the
1522    parser is not sure what construct comes next, it enters this mode.
1523    Then, while we attempt to parse the construct, the parser queues up
1524    error messages, rather than issuing them immediately, and saves the
1525    tokens it consumes.  If the construct is parsed successfully, the
1526    parser "commits", i.e., it issues any queued error messages and
1527    the tokens that were being preserved are permanently discarded.
1528    If, however, the construct is not parsed successfully, the parser
1529    rolls back its state completely so that it can resume parsing using
1530    a different alternative.
1531
1532    Future Improvements
1533    -------------------
1534
1535    The performance of the parser could probably be improved substantially.
1536    We could often eliminate the need to parse tentatively by looking ahead
1537    a little bit.  In some places, this approach might not entirely eliminate
1538    the need to parse tentatively, but it might still speed up the average
1539    case.  */
1540
1541 /* Flags that are passed to some parsing functions.  These values can
1542    be bitwise-ored together.  */
1543
1544 enum
1545 {
1546   /* No flags.  */
1547   CP_PARSER_FLAGS_NONE = 0x0,
1548   /* The construct is optional.  If it is not present, then no error
1549      should be issued.  */
1550   CP_PARSER_FLAGS_OPTIONAL = 0x1,
1551   /* When parsing a type-specifier, treat user-defined type-names
1552      as non-type identifiers.  */
1553   CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES = 0x2,
1554   /* When parsing a type-specifier, do not try to parse a class-specifier
1555      or enum-specifier.  */
1556   CP_PARSER_FLAGS_NO_TYPE_DEFINITIONS = 0x4,
1557   /* When parsing a decl-specifier-seq, only allow type-specifier or
1558      constexpr.  */
1559   CP_PARSER_FLAGS_ONLY_TYPE_OR_CONSTEXPR = 0x8
1560 };
1561
1562 /* This type is used for parameters and variables which hold
1563    combinations of the above flags.  */
1564 typedef int cp_parser_flags;
1565
1566 /* The different kinds of declarators we want to parse.  */
1567
1568 typedef enum cp_parser_declarator_kind
1569 {
1570   /* We want an abstract declarator.  */
1571   CP_PARSER_DECLARATOR_ABSTRACT,
1572   /* We want a named declarator.  */
1573   CP_PARSER_DECLARATOR_NAMED,
1574   /* We don't mind, but the name must be an unqualified-id.  */
1575   CP_PARSER_DECLARATOR_EITHER
1576 } cp_parser_declarator_kind;
1577
1578 /* The precedence values used to parse binary expressions.  The minimum value
1579    of PREC must be 1, because zero is reserved to quickly discriminate
1580    binary operators from other tokens.  */
1581
1582 enum cp_parser_prec
1583 {
1584   PREC_NOT_OPERATOR,
1585   PREC_LOGICAL_OR_EXPRESSION,
1586   PREC_LOGICAL_AND_EXPRESSION,
1587   PREC_INCLUSIVE_OR_EXPRESSION,
1588   PREC_EXCLUSIVE_OR_EXPRESSION,
1589   PREC_AND_EXPRESSION,
1590   PREC_EQUALITY_EXPRESSION,
1591   PREC_RELATIONAL_EXPRESSION,
1592   PREC_SHIFT_EXPRESSION,
1593   PREC_ADDITIVE_EXPRESSION,
1594   PREC_MULTIPLICATIVE_EXPRESSION,
1595   PREC_PM_EXPRESSION,
1596   NUM_PREC_VALUES = PREC_PM_EXPRESSION
1597 };
1598
1599 /* A mapping from a token type to a corresponding tree node type, with a
1600    precedence value.  */
1601
1602 typedef struct cp_parser_binary_operations_map_node
1603 {
1604   /* The token type.  */
1605   enum cpp_ttype token_type;
1606   /* The corresponding tree code.  */
1607   enum tree_code tree_type;
1608   /* The precedence of this operator.  */
1609   enum cp_parser_prec prec;
1610 } cp_parser_binary_operations_map_node;
1611
1612 typedef struct cp_parser_expression_stack_entry
1613 {
1614   /* Left hand side of the binary operation we are currently
1615      parsing.  */
1616   tree lhs;
1617   /* Original tree code for left hand side, if it was a binary
1618      expression itself (used for -Wparentheses).  */
1619   enum tree_code lhs_type;
1620   /* Tree code for the binary operation we are parsing.  */
1621   enum tree_code tree_type;
1622   /* Precedence of the binary operation we are parsing.  */
1623   enum cp_parser_prec prec;
1624 } cp_parser_expression_stack_entry;
1625
1626 /* The stack for storing partial expressions.  We only need NUM_PREC_VALUES
1627    entries because precedence levels on the stack are monotonically
1628    increasing.  */
1629 typedef struct cp_parser_expression_stack_entry
1630   cp_parser_expression_stack[NUM_PREC_VALUES];
1631
1632 /* Prototypes.  */
1633
1634 /* Constructors and destructors.  */
1635
1636 static cp_parser_context *cp_parser_context_new
1637   (cp_parser_context *);
1638
1639 /* Class variables.  */
1640
1641 static GTY((deletable)) cp_parser_context* cp_parser_context_free_list;
1642
1643 /* The operator-precedence table used by cp_parser_binary_expression.
1644    Transformed into an associative array (binops_by_token) by
1645    cp_parser_new.  */
1646
1647 static const cp_parser_binary_operations_map_node binops[] = {
1648   { CPP_DEREF_STAR, MEMBER_REF, PREC_PM_EXPRESSION },
1649   { CPP_DOT_STAR, DOTSTAR_EXPR, PREC_PM_EXPRESSION },
1650
1651   { CPP_MULT, MULT_EXPR, PREC_MULTIPLICATIVE_EXPRESSION },
1652   { CPP_DIV, TRUNC_DIV_EXPR, PREC_MULTIPLICATIVE_EXPRESSION },
1653   { CPP_MOD, TRUNC_MOD_EXPR, PREC_MULTIPLICATIVE_EXPRESSION },
1654
1655   { CPP_PLUS, PLUS_EXPR, PREC_ADDITIVE_EXPRESSION },
1656   { CPP_MINUS, MINUS_EXPR, PREC_ADDITIVE_EXPRESSION },
1657
1658   { CPP_LSHIFT, LSHIFT_EXPR, PREC_SHIFT_EXPRESSION },
1659   { CPP_RSHIFT, RSHIFT_EXPR, PREC_SHIFT_EXPRESSION },
1660
1661   { CPP_LESS, LT_EXPR, PREC_RELATIONAL_EXPRESSION },
1662   { CPP_GREATER, GT_EXPR, PREC_RELATIONAL_EXPRESSION },
1663   { CPP_LESS_EQ, LE_EXPR, PREC_RELATIONAL_EXPRESSION },
1664   { CPP_GREATER_EQ, GE_EXPR, PREC_RELATIONAL_EXPRESSION },
1665
1666   { CPP_EQ_EQ, EQ_EXPR, PREC_EQUALITY_EXPRESSION },
1667   { CPP_NOT_EQ, NE_EXPR, PREC_EQUALITY_EXPRESSION },
1668
1669   { CPP_AND, BIT_AND_EXPR, PREC_AND_EXPRESSION },
1670
1671   { CPP_XOR, BIT_XOR_EXPR, PREC_EXCLUSIVE_OR_EXPRESSION },
1672
1673   { CPP_OR, BIT_IOR_EXPR, PREC_INCLUSIVE_OR_EXPRESSION },
1674
1675   { CPP_AND_AND, TRUTH_ANDIF_EXPR, PREC_LOGICAL_AND_EXPRESSION },
1676
1677   { CPP_OR_OR, TRUTH_ORIF_EXPR, PREC_LOGICAL_OR_EXPRESSION }
1678 };
1679
1680 /* The same as binops, but initialized by cp_parser_new so that
1681    binops_by_token[N].token_type == N.  Used in cp_parser_binary_expression
1682    for speed.  */
1683 static cp_parser_binary_operations_map_node binops_by_token[N_CP_TTYPES];
1684
1685 /* Constructors and destructors.  */
1686
1687 /* Construct a new context.  The context below this one on the stack
1688    is given by NEXT.  */
1689
1690 static cp_parser_context *
1691 cp_parser_context_new (cp_parser_context* next)
1692 {
1693   cp_parser_context *context;
1694
1695   /* Allocate the storage.  */
1696   if (cp_parser_context_free_list != NULL)
1697     {
1698       /* Pull the first entry from the free list.  */
1699       context = cp_parser_context_free_list;
1700       cp_parser_context_free_list = context->next;
1701       memset (context, 0, sizeof (*context));
1702     }
1703   else
1704     context = ggc_alloc_cleared_cp_parser_context ();
1705
1706   /* No errors have occurred yet in this context.  */
1707   context->status = CP_PARSER_STATUS_KIND_NO_ERROR;
1708   /* If this is not the bottommost context, copy information that we
1709      need from the previous context.  */
1710   if (next)
1711     {
1712       /* If, in the NEXT context, we are parsing an `x->' or `x.'
1713          expression, then we are parsing one in this context, too.  */
1714       context->object_type = next->object_type;
1715       /* Thread the stack.  */
1716       context->next = next;
1717     }
1718
1719   return context;
1720 }
1721
1722 /* Managing the unparsed function queues.  */
1723
1724 #define unparsed_funs_with_default_args \
1725   VEC_last (cp_unparsed_functions_entry, parser->unparsed_queues)->funs_with_default_args
1726 #define unparsed_funs_with_definitions \
1727   VEC_last (cp_unparsed_functions_entry, parser->unparsed_queues)->funs_with_definitions
1728 #define unparsed_nsdmis \
1729   VEC_last (cp_unparsed_functions_entry, parser->unparsed_queues)->nsdmis
1730
1731 static void
1732 push_unparsed_function_queues (cp_parser *parser)
1733 {
1734   VEC_safe_push (cp_unparsed_functions_entry, gc,
1735                  parser->unparsed_queues, NULL);
1736   unparsed_funs_with_default_args = NULL;
1737   unparsed_funs_with_definitions = make_tree_vector ();
1738   unparsed_nsdmis = NULL;
1739 }
1740
1741 static void
1742 pop_unparsed_function_queues (cp_parser *parser)
1743 {
1744   release_tree_vector (unparsed_funs_with_definitions);
1745   VEC_pop (cp_unparsed_functions_entry, parser->unparsed_queues);
1746 }
1747
1748 /* Prototypes.  */
1749
1750 /* Constructors and destructors.  */
1751
1752 static cp_parser *cp_parser_new
1753   (void);
1754
1755 /* Routines to parse various constructs.
1756
1757    Those that return `tree' will return the error_mark_node (rather
1758    than NULL_TREE) if a parse error occurs, unless otherwise noted.
1759    Sometimes, they will return an ordinary node if error-recovery was
1760    attempted, even though a parse error occurred.  So, to check
1761    whether or not a parse error occurred, you should always use
1762    cp_parser_error_occurred.  If the construct is optional (indicated
1763    either by an `_opt' in the name of the function that does the
1764    parsing or via a FLAGS parameter), then NULL_TREE is returned if
1765    the construct is not present.  */
1766
1767 /* Lexical conventions [gram.lex]  */
1768
1769 static tree cp_parser_identifier
1770   (cp_parser *);
1771 static tree cp_parser_string_literal
1772   (cp_parser *, bool, bool);
1773 static tree cp_parser_userdef_char_literal
1774   (cp_parser *);
1775 static tree cp_parser_userdef_string_literal
1776   (cp_token *);
1777 static tree cp_parser_userdef_numeric_literal
1778   (cp_parser *);
1779
1780 /* Basic concepts [gram.basic]  */
1781
1782 static bool cp_parser_translation_unit
1783   (cp_parser *);
1784
1785 /* Expressions [gram.expr]  */
1786
1787 static tree cp_parser_primary_expression
1788   (cp_parser *, bool, bool, bool, cp_id_kind *);
1789 static tree cp_parser_id_expression
1790   (cp_parser *, bool, bool, bool *, bool, bool);
1791 static tree cp_parser_unqualified_id
1792   (cp_parser *, bool, bool, bool, bool);
1793 static tree cp_parser_nested_name_specifier_opt
1794   (cp_parser *, bool, bool, bool, bool);
1795 static tree cp_parser_nested_name_specifier
1796   (cp_parser *, bool, bool, bool, bool);
1797 static tree cp_parser_qualifying_entity
1798   (cp_parser *, bool, bool, bool, bool, bool);
1799 static tree cp_parser_postfix_expression
1800   (cp_parser *, bool, bool, bool, cp_id_kind *);
1801 static tree cp_parser_postfix_open_square_expression
1802   (cp_parser *, tree, bool);
1803 static tree cp_parser_postfix_dot_deref_expression
1804   (cp_parser *, enum cpp_ttype, tree, bool, cp_id_kind *, location_t);
1805 static VEC(tree,gc) *cp_parser_parenthesized_expression_list
1806   (cp_parser *, int, bool, bool, bool *);
1807 /* Values for the second parameter of cp_parser_parenthesized_expression_list.  */
1808 enum { non_attr = 0, normal_attr = 1, id_attr = 2 };
1809 static void cp_parser_pseudo_destructor_name
1810   (cp_parser *, tree *, tree *);
1811 static tree cp_parser_unary_expression
1812   (cp_parser *, bool, bool, cp_id_kind *);
1813 static enum tree_code cp_parser_unary_operator
1814   (cp_token *);
1815 static tree cp_parser_new_expression
1816   (cp_parser *);
1817 static VEC(tree,gc) *cp_parser_new_placement
1818   (cp_parser *);
1819 static tree cp_parser_new_type_id
1820   (cp_parser *, tree *);
1821 static cp_declarator *cp_parser_new_declarator_opt
1822   (cp_parser *);
1823 static cp_declarator *cp_parser_direct_new_declarator
1824   (cp_parser *);
1825 static VEC(tree,gc) *cp_parser_new_initializer
1826   (cp_parser *);
1827 static tree cp_parser_delete_expression
1828   (cp_parser *);
1829 static tree cp_parser_cast_expression
1830   (cp_parser *, bool, bool, cp_id_kind *);
1831 static tree cp_parser_binary_expression
1832   (cp_parser *, bool, bool, enum cp_parser_prec, cp_id_kind *);
1833 static tree cp_parser_question_colon_clause
1834   (cp_parser *, tree);
1835 static tree cp_parser_assignment_expression
1836   (cp_parser *, bool, cp_id_kind *);
1837 static enum tree_code cp_parser_assignment_operator_opt
1838   (cp_parser *);
1839 static tree cp_parser_expression
1840   (cp_parser *, bool, cp_id_kind *);
1841 static tree cp_parser_constant_expression
1842   (cp_parser *, bool, bool *);
1843 static tree cp_parser_builtin_offsetof
1844   (cp_parser *);
1845 static tree cp_parser_lambda_expression
1846   (cp_parser *);
1847 static void cp_parser_lambda_introducer
1848   (cp_parser *, tree);
1849 static bool cp_parser_lambda_declarator_opt
1850   (cp_parser *, tree);
1851 static void cp_parser_lambda_body
1852   (cp_parser *, tree);
1853
1854 /* Statements [gram.stmt.stmt]  */
1855
1856 static void cp_parser_statement
1857   (cp_parser *, tree, bool, bool *);
1858 static void cp_parser_label_for_labeled_statement
1859   (cp_parser *);
1860 static tree cp_parser_expression_statement
1861   (cp_parser *, tree);
1862 static tree cp_parser_compound_statement
1863   (cp_parser *, tree, bool, bool);
1864 static void cp_parser_statement_seq_opt
1865   (cp_parser *, tree);
1866 static tree cp_parser_selection_statement
1867   (cp_parser *, bool *);
1868 static tree cp_parser_condition
1869   (cp_parser *);
1870 static tree cp_parser_iteration_statement
1871   (cp_parser *);
1872 static bool cp_parser_for_init_statement
1873   (cp_parser *, tree *decl);
1874 static tree cp_parser_for
1875   (cp_parser *);
1876 static tree cp_parser_c_for
1877   (cp_parser *, tree, tree);
1878 static tree cp_parser_range_for
1879   (cp_parser *, tree, tree, tree);
1880 static void do_range_for_auto_deduction
1881   (tree, tree);
1882 static tree cp_parser_perform_range_for_lookup
1883   (tree, tree *, tree *);
1884 static tree cp_parser_range_for_member_function
1885   (tree, tree);
1886 static tree cp_parser_jump_statement
1887   (cp_parser *);
1888 static void cp_parser_declaration_statement
1889   (cp_parser *);
1890
1891 static tree cp_parser_implicitly_scoped_statement
1892   (cp_parser *, bool *);
1893 static void cp_parser_already_scoped_statement
1894   (cp_parser *);
1895
1896 /* Declarations [gram.dcl.dcl] */
1897
1898 static void cp_parser_declaration_seq_opt
1899   (cp_parser *);
1900 static void cp_parser_declaration
1901   (cp_parser *);
1902 static void cp_parser_block_declaration
1903   (cp_parser *, bool);
1904 static void cp_parser_simple_declaration
1905   (cp_parser *, bool, tree *);
1906 static void cp_parser_decl_specifier_seq
1907   (cp_parser *, cp_parser_flags, cp_decl_specifier_seq *, int *);
1908 static tree cp_parser_storage_class_specifier_opt
1909   (cp_parser *);
1910 static tree cp_parser_function_specifier_opt
1911   (cp_parser *, cp_decl_specifier_seq *);
1912 static tree cp_parser_type_specifier
1913   (cp_parser *, cp_parser_flags, cp_decl_specifier_seq *, bool,
1914    int *, bool *);
1915 static tree cp_parser_simple_type_specifier
1916   (cp_parser *, cp_decl_specifier_seq *, cp_parser_flags);
1917 static tree cp_parser_type_name
1918   (cp_parser *);
1919 static tree cp_parser_nonclass_name
1920   (cp_parser* parser);
1921 static tree cp_parser_elaborated_type_specifier
1922   (cp_parser *, bool, bool);
1923 static tree cp_parser_enum_specifier
1924   (cp_parser *);
1925 static void cp_parser_enumerator_list
1926   (cp_parser *, tree);
1927 static void cp_parser_enumerator_definition
1928   (cp_parser *, tree);
1929 static tree cp_parser_namespace_name
1930   (cp_parser *);
1931 static void cp_parser_namespace_definition
1932   (cp_parser *);
1933 static void cp_parser_namespace_body
1934   (cp_parser *);
1935 static tree cp_parser_qualified_namespace_specifier
1936   (cp_parser *);
1937 static void cp_parser_namespace_alias_definition
1938   (cp_parser *);
1939 static bool cp_parser_using_declaration
1940   (cp_parser *, bool);
1941 static void cp_parser_using_directive
1942   (cp_parser *);
1943 static tree cp_parser_alias_declaration
1944   (cp_parser *);
1945 static void cp_parser_asm_definition
1946   (cp_parser *);
1947 static void cp_parser_linkage_specification
1948   (cp_parser *);
1949 static void cp_parser_static_assert
1950   (cp_parser *, bool);
1951 static tree cp_parser_decltype
1952   (cp_parser *);
1953
1954 /* Declarators [gram.dcl.decl] */
1955
1956 static tree cp_parser_init_declarator
1957   (cp_parser *, cp_decl_specifier_seq *, VEC (deferred_access_check,gc)*, bool, bool, int, bool *, tree *);
1958 static cp_declarator *cp_parser_declarator
1959   (cp_parser *, cp_parser_declarator_kind, int *, bool *, bool);
1960 static cp_declarator *cp_parser_direct_declarator
1961   (cp_parser *, cp_parser_declarator_kind, int *, bool);
1962 static enum tree_code cp_parser_ptr_operator
1963   (cp_parser *, tree *, cp_cv_quals *);
1964 static cp_cv_quals cp_parser_cv_qualifier_seq_opt
1965   (cp_parser *);
1966 static cp_virt_specifiers cp_parser_virt_specifier_seq_opt
1967   (cp_parser *);
1968 static tree cp_parser_late_return_type_opt
1969   (cp_parser *, cp_cv_quals);
1970 static tree cp_parser_declarator_id
1971   (cp_parser *, bool);
1972 static tree cp_parser_type_id
1973   (cp_parser *);
1974 static tree cp_parser_template_type_arg
1975   (cp_parser *);
1976 static tree cp_parser_trailing_type_id (cp_parser *);
1977 static tree cp_parser_type_id_1
1978   (cp_parser *, bool, bool);
1979 static void cp_parser_type_specifier_seq
1980   (cp_parser *, bool, bool, cp_decl_specifier_seq *);
1981 static tree cp_parser_parameter_declaration_clause
1982   (cp_parser *);
1983 static tree cp_parser_parameter_declaration_list
1984   (cp_parser *, bool *);
1985 static cp_parameter_declarator *cp_parser_parameter_declaration
1986   (cp_parser *, bool, bool *);
1987 static tree cp_parser_default_argument
1988   (cp_parser *, bool);
1989 static void cp_parser_function_body
1990   (cp_parser *);
1991 static tree cp_parser_initializer
1992   (cp_parser *, bool *, bool *);
1993 static tree cp_parser_initializer_clause
1994   (cp_parser *, bool *);
1995 static tree cp_parser_braced_list
1996   (cp_parser*, bool*);
1997 static VEC(constructor_elt,gc) *cp_parser_initializer_list
1998   (cp_parser *, bool *);
1999
2000 static bool cp_parser_ctor_initializer_opt_and_function_body
2001   (cp_parser *);
2002
2003 /* Classes [gram.class] */
2004
2005 static tree cp_parser_class_name
2006   (cp_parser *, bool, bool, enum tag_types, bool, bool, bool);
2007 static tree cp_parser_class_specifier
2008   (cp_parser *);
2009 static tree cp_parser_class_head
2010   (cp_parser *, bool *, tree *, tree *);
2011 static enum tag_types cp_parser_class_key
2012   (cp_parser *);
2013 static void cp_parser_member_specification_opt
2014   (cp_parser *);
2015 static void cp_parser_member_declaration
2016   (cp_parser *);
2017 static tree cp_parser_pure_specifier
2018   (cp_parser *);
2019 static tree cp_parser_constant_initializer
2020   (cp_parser *);
2021
2022 /* Derived classes [gram.class.derived] */
2023
2024 static tree cp_parser_base_clause
2025   (cp_parser *);
2026 static tree cp_parser_base_specifier
2027   (cp_parser *);
2028
2029 /* Special member functions [gram.special] */
2030
2031 static tree cp_parser_conversion_function_id
2032   (cp_parser *);
2033 static tree cp_parser_conversion_type_id
2034   (cp_parser *);
2035 static cp_declarator *cp_parser_conversion_declarator_opt
2036   (cp_parser *);
2037 static bool cp_parser_ctor_initializer_opt
2038   (cp_parser *);
2039 static void cp_parser_mem_initializer_list
2040   (cp_parser *);
2041 static tree cp_parser_mem_initializer
2042   (cp_parser *);
2043 static tree cp_parser_mem_initializer_id
2044   (cp_parser *);
2045
2046 /* Overloading [gram.over] */
2047
2048 static tree cp_parser_operator_function_id
2049   (cp_parser *);
2050 static tree cp_parser_operator
2051   (cp_parser *);
2052
2053 /* Templates [gram.temp] */
2054
2055 static void cp_parser_template_declaration
2056   (cp_parser *, bool);
2057 static tree cp_parser_template_parameter_list
2058   (cp_parser *);
2059 static tree cp_parser_template_parameter
2060   (cp_parser *, bool *, bool *);
2061 static tree cp_parser_type_parameter
2062   (cp_parser *, bool *);
2063 static tree cp_parser_template_id
2064   (cp_parser *, bool, bool, bool);
2065 static tree cp_parser_template_name
2066   (cp_parser *, bool, bool, bool, bool *);
2067 static tree cp_parser_template_argument_list
2068   (cp_parser *);
2069 static tree cp_parser_template_argument
2070   (cp_parser *);
2071 static void cp_parser_explicit_instantiation
2072   (cp_parser *);
2073 static void cp_parser_explicit_specialization
2074   (cp_parser *);
2075
2076 /* Exception handling [gram.exception] */
2077
2078 static tree cp_parser_try_block
2079   (cp_parser *);
2080 static bool cp_parser_function_try_block
2081   (cp_parser *);
2082 static void cp_parser_handler_seq
2083   (cp_parser *);
2084 static void cp_parser_handler
2085   (cp_parser *);
2086 static tree cp_parser_exception_declaration
2087   (cp_parser *);
2088 static tree cp_parser_throw_expression
2089   (cp_parser *);
2090 static tree cp_parser_exception_specification_opt
2091   (cp_parser *);
2092 static tree cp_parser_type_id_list
2093   (cp_parser *);
2094
2095 /* GNU Extensions */
2096
2097 static tree cp_parser_asm_specification_opt
2098   (cp_parser *);
2099 static tree cp_parser_asm_operand_list
2100   (cp_parser *);
2101 static tree cp_parser_asm_clobber_list
2102   (cp_parser *);
2103 static tree cp_parser_asm_label_list
2104   (cp_parser *);
2105 static tree cp_parser_attributes_opt
2106   (cp_parser *);
2107 static tree cp_parser_attribute_list
2108   (cp_parser *);
2109 static bool cp_parser_extension_opt
2110   (cp_parser *, int *);
2111 static void cp_parser_label_declaration
2112   (cp_parser *);
2113
2114 /* Transactional Memory Extensions */
2115
2116 static tree cp_parser_transaction
2117   (cp_parser *, enum rid);
2118 static tree cp_parser_transaction_expression
2119   (cp_parser *, enum rid);
2120 static bool cp_parser_function_transaction
2121   (cp_parser *, enum rid);
2122 static tree cp_parser_transaction_cancel
2123   (cp_parser *);
2124
2125 enum pragma_context { pragma_external, pragma_stmt, pragma_compound };
2126 static bool cp_parser_pragma
2127   (cp_parser *, enum pragma_context);
2128
2129 /* Objective-C++ Productions */
2130
2131 static tree cp_parser_objc_message_receiver
2132   (cp_parser *);
2133 static tree cp_parser_objc_message_args
2134   (cp_parser *);
2135 static tree cp_parser_objc_message_expression
2136   (cp_parser *);
2137 static tree cp_parser_objc_encode_expression
2138   (cp_parser *);
2139 static tree cp_parser_objc_defs_expression
2140   (cp_parser *);
2141 static tree cp_parser_objc_protocol_expression
2142   (cp_parser *);
2143 static tree cp_parser_objc_selector_expression
2144   (cp_parser *);
2145 static tree cp_parser_objc_expression
2146   (cp_parser *);
2147 static bool cp_parser_objc_selector_p
2148   (enum cpp_ttype);
2149 static tree cp_parser_objc_selector
2150   (cp_parser *);
2151 static tree cp_parser_objc_protocol_refs_opt
2152   (cp_parser *);
2153 static void cp_parser_objc_declaration
2154   (cp_parser *, tree);
2155 static tree cp_parser_objc_statement
2156   (cp_parser *);
2157 static bool cp_parser_objc_valid_prefix_attributes
2158   (cp_parser *, tree *);
2159 static void cp_parser_objc_at_property_declaration
2160   (cp_parser *) ;
2161 static void cp_parser_objc_at_synthesize_declaration
2162   (cp_parser *) ;
2163 static void cp_parser_objc_at_dynamic_declaration
2164   (cp_parser *) ;
2165 static tree cp_parser_objc_struct_declaration
2166   (cp_parser *) ;
2167
2168 /* Utility Routines */
2169
2170 static tree cp_parser_lookup_name
2171   (cp_parser *, tree, enum tag_types, bool, bool, bool, tree *, location_t);
2172 static tree cp_parser_lookup_name_simple
2173   (cp_parser *, tree, location_t);
2174 static tree cp_parser_maybe_treat_template_as_class
2175   (tree, bool);
2176 static bool cp_parser_check_declarator_template_parameters
2177   (cp_parser *, cp_declarator *, location_t);
2178 static bool cp_parser_check_template_parameters
2179   (cp_parser *, unsigned, location_t, cp_declarator *);
2180 static tree cp_parser_simple_cast_expression
2181   (cp_parser *);
2182 static tree cp_parser_global_scope_opt
2183   (cp_parser *, bool);
2184 static bool cp_parser_constructor_declarator_p
2185   (cp_parser *, bool);
2186 static tree cp_parser_function_definition_from_specifiers_and_declarator
2187   (cp_parser *, cp_decl_specifier_seq *, tree, const cp_declarator *);
2188 static tree cp_parser_function_definition_after_declarator
2189   (cp_parser *, bool);
2190 static void cp_parser_template_declaration_after_export
2191   (cp_parser *, bool);
2192 static void cp_parser_perform_template_parameter_access_checks
2193   (VEC (deferred_access_check,gc)*);
2194 static tree cp_parser_single_declaration
2195   (cp_parser *, VEC (deferred_access_check,gc)*, bool, bool, bool *);
2196 static tree cp_parser_functional_cast
2197   (cp_parser *, tree);
2198 static tree cp_parser_save_member_function_body
2199   (cp_parser *, cp_decl_specifier_seq *, cp_declarator *, tree);
2200 static tree cp_parser_save_nsdmi
2201   (cp_parser *);
2202 static tree cp_parser_enclosed_template_argument_list
2203   (cp_parser *);
2204 static void cp_parser_save_default_args
2205   (cp_parser *, tree);
2206 static void cp_parser_late_parsing_for_member
2207   (cp_parser *, tree);
2208 static tree cp_parser_late_parse_one_default_arg
2209   (cp_parser *, tree, tree, tree);
2210 static void cp_parser_late_parsing_nsdmi
2211   (cp_parser *, tree);
2212 static void cp_parser_late_parsing_default_args
2213   (cp_parser *, tree);
2214 static tree cp_parser_sizeof_operand
2215   (cp_parser *, enum rid);
2216 static tree cp_parser_trait_expr
2217   (cp_parser *, enum rid);
2218 static bool cp_parser_declares_only_class_p
2219   (cp_parser *);
2220 static void cp_parser_set_storage_class
2221   (cp_parser *, cp_decl_specifier_seq *, enum rid, location_t);
2222 static void cp_parser_set_decl_spec_type
2223   (cp_decl_specifier_seq *, tree, location_t, bool);
2224 static bool cp_parser_friend_p
2225   (const cp_decl_specifier_seq *);
2226 static void cp_parser_required_error
2227   (cp_parser *, required_token, bool);
2228 static cp_token *cp_parser_require
2229   (cp_parser *, enum cpp_ttype, required_token);
2230 static cp_token *cp_parser_require_keyword
2231   (cp_parser *, enum rid, required_token);
2232 static bool cp_parser_token_starts_function_definition_p
2233   (cp_token *);
2234 static bool cp_parser_next_token_starts_class_definition_p
2235   (cp_parser *);
2236 static bool cp_parser_next_token_ends_template_argument_p
2237   (cp_parser *);
2238 static bool cp_parser_nth_token_starts_template_argument_list_p
2239   (cp_parser *, size_t);
2240 static enum tag_types cp_parser_token_is_class_key
2241   (cp_token *);
2242 static void cp_parser_check_class_key
2243   (enum tag_types, tree type);
2244 static void cp_parser_check_access_in_redeclaration
2245   (tree type, location_t location);
2246 static bool cp_parser_optional_template_keyword
2247   (cp_parser *);
2248 static void cp_parser_pre_parsed_nested_name_specifier
2249   (cp_parser *);
2250 static bool cp_parser_cache_group
2251   (cp_parser *, enum cpp_ttype, unsigned);
2252 static tree cp_parser_cache_defarg
2253   (cp_parser *parser, bool nsdmi);
2254 static void cp_parser_parse_tentatively
2255   (cp_parser *);
2256 static void cp_parser_commit_to_tentative_parse
2257   (cp_parser *);
2258 static void cp_parser_abort_tentative_parse
2259   (cp_parser *);
2260 static bool cp_parser_parse_definitely
2261   (cp_parser *);
2262 static inline bool cp_parser_parsing_tentatively
2263   (cp_parser *);
2264 static bool cp_parser_uncommitted_to_tentative_parse_p
2265   (cp_parser *);
2266 static void cp_parser_error
2267   (cp_parser *, const char *);
2268 static void cp_parser_name_lookup_error
2269   (cp_parser *, tree, tree, name_lookup_error, location_t);
2270 static bool cp_parser_simulate_error
2271   (cp_parser *);
2272 static bool cp_parser_check_type_definition
2273   (cp_parser *);
2274 static void cp_parser_check_for_definition_in_return_type
2275   (cp_declarator *, tree, location_t type_location);
2276 static void cp_parser_check_for_invalid_template_id
2277   (cp_parser *, tree, location_t location);
2278 static bool cp_parser_non_integral_constant_expression
2279   (cp_parser *, non_integral_constant);
2280 static void cp_parser_diagnose_invalid_type_name
2281   (cp_parser *, tree, tree, location_t);
2282 static bool cp_parser_parse_and_diagnose_invalid_type_name
2283   (cp_parser *);
2284 static int cp_parser_skip_to_closing_parenthesis
2285   (cp_parser *, bool, bool, bool);
2286 static void cp_parser_skip_to_end_of_statement
2287   (cp_parser *);
2288 static void cp_parser_consume_semicolon_at_end_of_statement
2289   (cp_parser *);
2290 static void cp_parser_skip_to_end_of_block_or_statement
2291   (cp_parser *);
2292 static bool cp_parser_skip_to_closing_brace
2293   (cp_parser *);
2294 static void cp_parser_skip_to_end_of_template_parameter_list
2295   (cp_parser *);
2296 static void cp_parser_skip_to_pragma_eol
2297   (cp_parser*, cp_token *);
2298 static bool cp_parser_error_occurred
2299   (cp_parser *);
2300 static bool cp_parser_allow_gnu_extensions_p
2301   (cp_parser *);
2302 static bool cp_parser_is_pure_string_literal
2303   (cp_token *);
2304 static bool cp_parser_is_string_literal
2305   (cp_token *);
2306 static bool cp_parser_is_keyword
2307   (cp_token *, enum rid);
2308 static tree cp_parser_make_typename_type
2309   (cp_parser *, tree, tree, location_t location);
2310 static cp_declarator * cp_parser_make_indirect_declarator
2311   (enum tree_code, tree, cp_cv_quals, cp_declarator *);
2312
2313 /* Returns nonzero if we are parsing tentatively.  */
2314
2315 static inline bool
2316 cp_parser_parsing_tentatively (cp_parser* parser)
2317 {
2318   return parser->context->next != NULL;
2319 }
2320
2321 /* Returns nonzero if TOKEN is a string literal.  */
2322
2323 static bool
2324 cp_parser_is_pure_string_literal (cp_token* token)
2325 {
2326   return (token->type == CPP_STRING ||
2327           token->type == CPP_STRING16 ||
2328           token->type == CPP_STRING32 ||
2329           token->type == CPP_WSTRING ||
2330           token->type == CPP_UTF8STRING);
2331 }
2332
2333 /* Returns nonzero if TOKEN is a string literal
2334    of a user-defined string literal.  */
2335
2336 static bool
2337 cp_parser_is_string_literal (cp_token* token)
2338 {
2339   return (cp_parser_is_pure_string_literal (token) ||
2340           token->type == CPP_STRING_USERDEF ||
2341           token->type == CPP_STRING16_USERDEF ||
2342           token->type == CPP_STRING32_USERDEF ||
2343           token->type == CPP_WSTRING_USERDEF ||
2344           token->type == CPP_UTF8STRING_USERDEF);
2345 }
2346
2347 /* Returns nonzero if TOKEN is the indicated KEYWORD.  */
2348
2349 static bool
2350 cp_parser_is_keyword (cp_token* token, enum rid keyword)
2351 {
2352   return token->keyword == keyword;
2353 }
2354
2355 /* If not parsing tentatively, issue a diagnostic of the form
2356       FILE:LINE: MESSAGE before TOKEN
2357    where TOKEN is the next token in the input stream.  MESSAGE
2358    (specified by the caller) is usually of the form "expected
2359    OTHER-TOKEN".  */
2360
2361 static void
2362 cp_parser_error (cp_parser* parser, const char* gmsgid)
2363 {
2364   if (!cp_parser_simulate_error (parser))
2365     {
2366       cp_token *token = cp_lexer_peek_token (parser->lexer);
2367       /* This diagnostic makes more sense if it is tagged to the line
2368          of the token we just peeked at.  */
2369       cp_lexer_set_source_position_from_token (token);
2370
2371       if (token->type == CPP_PRAGMA)
2372         {
2373           error_at (token->location,
2374                     "%<#pragma%> is not allowed here");
2375           cp_parser_skip_to_pragma_eol (parser, token);
2376           return;
2377         }
2378
2379       c_parse_error (gmsgid,
2380                      /* Because c_parser_error does not understand
2381                         CPP_KEYWORD, keywords are treated like
2382                         identifiers.  */
2383                      (token->type == CPP_KEYWORD ? CPP_NAME : token->type),
2384                      token->u.value, token->flags);
2385     }
2386 }
2387
2388 /* Issue an error about name-lookup failing.  NAME is the
2389    IDENTIFIER_NODE DECL is the result of
2390    the lookup (as returned from cp_parser_lookup_name).  DESIRED is
2391    the thing that we hoped to find.  */
2392
2393 static void
2394 cp_parser_name_lookup_error (cp_parser* parser,
2395                              tree name,
2396                              tree decl,
2397                              name_lookup_error desired,
2398                              location_t location)
2399 {
2400   /* If name lookup completely failed, tell the user that NAME was not
2401      declared.  */
2402   if (decl == error_mark_node)
2403     {
2404       if (parser->scope && parser->scope != global_namespace)
2405         error_at (location, "%<%E::%E%> has not been declared",
2406                   parser->scope, name);
2407       else if (parser->scope == global_namespace)
2408         error_at (location, "%<::%E%> has not been declared", name);
2409       else if (parser->object_scope
2410                && !CLASS_TYPE_P (parser->object_scope))
2411         error_at (location, "request for member %qE in non-class type %qT",
2412                   name, parser->object_scope);
2413       else if (parser->object_scope)
2414         error_at (location, "%<%T::%E%> has not been declared",
2415                   parser->object_scope, name);
2416       else
2417         error_at (location, "%qE has not been declared", name);
2418     }
2419   else if (parser->scope && parser->scope != global_namespace)
2420     {
2421       switch (desired)
2422         {
2423           case NLE_TYPE:
2424             error_at (location, "%<%E::%E%> is not a type",
2425                                 parser->scope, name);
2426             break;
2427           case NLE_CXX98:
2428             error_at (location, "%<%E::%E%> is not a class or namespace",
2429                                 parser->scope, name);
2430             break;
2431           case NLE_NOT_CXX98:
2432             error_at (location,
2433                       "%<%E::%E%> is not a class, namespace, or enumeration",
2434                       parser->scope, name);
2435             break;
2436           default:
2437             gcc_unreachable ();
2438
2439         }
2440     }
2441   else if (parser->scope == global_namespace)
2442     {
2443       switch (desired)
2444         {
2445           case NLE_TYPE:
2446             error_at (location, "%<::%E%> is not a type", name);
2447             break;
2448           case NLE_CXX98:
2449             error_at (location, "%<::%E%> is not a class or namespace", name);
2450             break;
2451           case NLE_NOT_CXX98:
2452             error_at (location,
2453                       "%<::%E%> is not a class, namespace, or enumeration",
2454                       name);
2455             break;
2456           default:
2457             gcc_unreachable ();
2458         }
2459     }
2460   else
2461     {
2462       switch (desired)
2463         {
2464           case NLE_TYPE:
2465             error_at (location, "%qE is not a type", name);
2466             break;
2467           case NLE_CXX98:
2468             error_at (location, "%qE is not a class or namespace", name);
2469             break;
2470           case NLE_NOT_CXX98:
2471             error_at (location,
2472                       "%qE is not a class, namespace, or enumeration", name);
2473             break;
2474           default:
2475             gcc_unreachable ();
2476         }
2477     }
2478 }
2479
2480 /* If we are parsing tentatively, remember that an error has occurred
2481    during this tentative parse.  Returns true if the error was
2482    simulated; false if a message should be issued by the caller.  */
2483
2484 static bool
2485 cp_parser_simulate_error (cp_parser* parser)
2486 {
2487   if (cp_parser_uncommitted_to_tentative_parse_p (parser))
2488     {
2489       parser->context->status = CP_PARSER_STATUS_KIND_ERROR;
2490       return true;
2491     }
2492   return false;
2493 }
2494
2495 /* Check for repeated decl-specifiers.  */
2496
2497 static void
2498 cp_parser_check_decl_spec (cp_decl_specifier_seq *decl_specs,
2499                            location_t location)
2500 {
2501   int ds;
2502
2503   for (ds = ds_first; ds != ds_last; ++ds)
2504     {
2505       unsigned count = decl_specs->specs[ds];
2506       if (count < 2)
2507         continue;
2508       /* The "long" specifier is a special case because of "long long".  */
2509       if (ds == ds_long)
2510         {
2511           if (count > 2)
2512             error_at (location, "%<long long long%> is too long for GCC");
2513           else
2514             pedwarn_cxx98 (location, OPT_Wlong_long,
2515                            "ISO C++ 1998 does not support %<long long%>");
2516         }
2517       else if (count > 1)
2518         {
2519           static const char *const decl_spec_names[] = {
2520             "signed",
2521             "unsigned",
2522             "short",
2523             "long",
2524             "const",
2525             "volatile",
2526             "restrict",
2527             "inline",
2528             "virtual",
2529             "explicit",
2530             "friend",
2531             "typedef",
2532             "using",
2533             "constexpr",
2534             "__complex",
2535             "__thread"
2536           };
2537           error_at (location, "duplicate %qs", decl_spec_names[ds]);
2538         }
2539     }
2540 }
2541
2542 /* This function is called when a type is defined.  If type
2543    definitions are forbidden at this point, an error message is
2544    issued.  */
2545
2546 static bool
2547 cp_parser_check_type_definition (cp_parser* parser)
2548 {
2549   /* If types are forbidden here, issue a message.  */
2550   if (parser->type_definition_forbidden_message)
2551     {
2552       /* Don't use `%s' to print the string, because quotations (`%<', `%>')
2553          in the message need to be interpreted.  */
2554       error (parser->type_definition_forbidden_message);
2555       return false;
2556     }
2557   return true;
2558 }
2559
2560 /* This function is called when the DECLARATOR is processed.  The TYPE
2561    was a type defined in the decl-specifiers.  If it is invalid to
2562    define a type in the decl-specifiers for DECLARATOR, an error is
2563    issued. TYPE_LOCATION is the location of TYPE and is used
2564    for error reporting.  */
2565
2566 static void
2567 cp_parser_check_for_definition_in_return_type (cp_declarator *declarator,
2568                                                tree type, location_t type_location)
2569 {
2570   /* [dcl.fct] forbids type definitions in return types.
2571      Unfortunately, it's not easy to know whether or not we are
2572      processing a return type until after the fact.  */
2573   while (declarator
2574          && (declarator->kind == cdk_pointer
2575              || declarator->kind == cdk_reference
2576              || declarator->kind == cdk_ptrmem))
2577     declarator = declarator->declarator;
2578   if (declarator
2579       && declarator->kind == cdk_function)
2580     {
2581       error_at (type_location,
2582                 "new types may not be defined in a return type");
2583       inform (type_location,
2584               "(perhaps a semicolon is missing after the definition of %qT)",
2585               type);
2586     }
2587 }
2588
2589 /* A type-specifier (TYPE) has been parsed which cannot be followed by
2590    "<" in any valid C++ program.  If the next token is indeed "<",
2591    issue a message warning the user about what appears to be an
2592    invalid attempt to form a template-id. LOCATION is the location
2593    of the type-specifier (TYPE) */
2594
2595 static void
2596 cp_parser_check_for_invalid_template_id (cp_parser* parser,
2597                                          tree type, location_t location)
2598 {
2599   cp_token_position start = 0;
2600
2601   if (cp_lexer_next_token_is (parser->lexer, CPP_LESS))
2602     {
2603       if (TYPE_P (type))
2604         error_at (location, "%qT is not a template", type);
2605       else if (TREE_CODE (type) == IDENTIFIER_NODE)
2606         error_at (location, "%qE is not a template", type);
2607       else
2608         error_at (location, "invalid template-id");
2609       /* Remember the location of the invalid "<".  */
2610       if (cp_parser_uncommitted_to_tentative_parse_p (parser))
2611         start = cp_lexer_token_position (parser->lexer, true);
2612       /* Consume the "<".  */
2613       cp_lexer_consume_token (parser->lexer);
2614       /* Parse the template arguments.  */
2615       cp_parser_enclosed_template_argument_list (parser);
2616       /* Permanently remove the invalid template arguments so that
2617          this error message is not issued again.  */
2618       if (start)
2619         cp_lexer_purge_tokens_after (parser->lexer, start);
2620     }
2621 }
2622
2623 /* If parsing an integral constant-expression, issue an error message
2624    about the fact that THING appeared and return true.  Otherwise,
2625    return false.  In either case, set
2626    PARSER->NON_INTEGRAL_CONSTANT_EXPRESSION_P.  */
2627
2628 static bool
2629 cp_parser_non_integral_constant_expression (cp_parser  *parser,
2630                                             non_integral_constant thing)
2631 {
2632   parser->non_integral_constant_expression_p = true;
2633   if (parser->integral_constant_expression_p)
2634     {
2635       if (!parser->allow_non_integral_constant_expression_p)
2636         {
2637           const char *msg = NULL;
2638           switch (thing)
2639             {
2640               case NIC_FLOAT:
2641                 error ("floating-point literal "
2642                        "cannot appear in a constant-expression");
2643                 return true;
2644               case NIC_CAST:
2645                 error ("a cast to a type other than an integral or "
2646                        "enumeration type cannot appear in a "
2647                        "constant-expression");
2648                 return true;
2649               case NIC_TYPEID:
2650                 error ("%<typeid%> operator "
2651                        "cannot appear in a constant-expression");
2652                 return true;
2653               case NIC_NCC:
2654                 error ("non-constant compound literals "
2655                        "cannot appear in a constant-expression");
2656                 return true;
2657               case NIC_FUNC_CALL:
2658                 error ("a function call "
2659                        "cannot appear in a constant-expression");
2660                 return true;
2661               case NIC_INC:
2662                 error ("an increment "
2663                        "cannot appear in a constant-expression");
2664                 return true;
2665               case NIC_DEC:
2666                 error ("an decrement "
2667                        "cannot appear in a constant-expression");
2668                 return true;
2669               case NIC_ARRAY_REF:
2670                 error ("an array reference "
2671                        "cannot appear in a constant-expression");
2672                 return true;
2673               case NIC_ADDR_LABEL:
2674                 error ("the address of a label "
2675                        "cannot appear in a constant-expression");
2676                 return true;
2677               case NIC_OVERLOADED:
2678                 error ("calls to overloaded operators "
2679                        "cannot appear in a constant-expression");
2680                 return true;
2681               case NIC_ASSIGNMENT:
2682                 error ("an assignment cannot appear in a constant-expression");
2683                 return true;
2684               case NIC_COMMA:
2685                 error ("a comma operator "
2686                        "cannot appear in a constant-expression");
2687                 return true;
2688               case NIC_CONSTRUCTOR:
2689                 error ("a call to a constructor "
2690                        "cannot appear in a constant-expression");
2691                 return true;
2692               case NIC_TRANSACTION:
2693                 error ("a transaction expression "
2694                        "cannot appear in a constant-expression");
2695                 return true;
2696               case NIC_THIS:
2697                 msg = "this";
2698                 break;
2699               case NIC_FUNC_NAME:
2700                 msg = "__FUNCTION__";
2701                 break;
2702               case NIC_PRETTY_FUNC:
2703                 msg = "__PRETTY_FUNCTION__";
2704                 break;
2705               case NIC_C99_FUNC:
2706                 msg = "__func__";
2707                 break;
2708               case NIC_VA_ARG:
2709                 msg = "va_arg";
2710                 break;
2711               case NIC_ARROW:
2712                 msg = "->";
2713                 break;
2714               case NIC_POINT:
2715                 msg = ".";
2716                 break;
2717               case NIC_STAR:
2718                 msg = "*";
2719                 break;
2720               case NIC_ADDR:
2721                 msg = "&";
2722                 break;
2723               case NIC_PREINCREMENT:
2724                 msg = "++";
2725                 break;
2726               case NIC_PREDECREMENT:
2727                 msg = "--";
2728                 break;
2729               case NIC_NEW:
2730                 msg = "new";
2731                 break;
2732               case NIC_DEL:
2733                 msg = "delete";
2734                 break;
2735               default:
2736                 gcc_unreachable ();
2737             }
2738           if (msg)
2739             error ("%qs cannot appear in a constant-expression", msg);
2740           return true;
2741         }
2742     }
2743   return false;
2744 }
2745
2746 /* Emit a diagnostic for an invalid type name.  SCOPE is the
2747    qualifying scope (or NULL, if none) for ID.  This function commits
2748    to the current active tentative parse, if any.  (Otherwise, the
2749    problematic construct might be encountered again later, resulting
2750    in duplicate error messages.) LOCATION is the location of ID.  */
2751
2752 static void
2753 cp_parser_diagnose_invalid_type_name (cp_parser *parser,
2754                                       tree scope, tree id,
2755                                       location_t location)
2756 {
2757   tree decl, old_scope;
2758   cp_parser_commit_to_tentative_parse (parser);
2759   /* Try to lookup the identifier.  */
2760   old_scope = parser->scope;
2761   parser->scope = scope;
2762   decl = cp_parser_lookup_name_simple (parser, id, location);
2763   parser->scope = old_scope;
2764   /* If the lookup found a template-name, it means that the user forgot
2765   to specify an argument list. Emit a useful error message.  */
2766   if (TREE_CODE (decl) == TEMPLATE_DECL)
2767     error_at (location,
2768               "invalid use of template-name %qE without an argument list",
2769               decl);
2770   else if (TREE_CODE (id) == BIT_NOT_EXPR)
2771     error_at (location, "invalid use of destructor %qD as a type", id);
2772   else if (TREE_CODE (decl) == TYPE_DECL)
2773     /* Something like 'unsigned A a;'  */
2774     error_at (location, "invalid combination of multiple type-specifiers");
2775   else if (!parser->scope)
2776     {
2777       /* Issue an error message.  */
2778       error_at (location, "%qE does not name a type", id);
2779       /* If we're in a template class, it's possible that the user was
2780          referring to a type from a base class.  For example:
2781
2782            template <typename T> struct A { typedef T X; };
2783            template <typename T> struct B : public A<T> { X x; };
2784
2785          The user should have said "typename A<T>::X".  */
2786       if (cxx_dialect < cxx0x && id == ridpointers[(int)RID_CONSTEXPR])
2787         inform (location, "C++11 %<constexpr%> only available with "
2788                 "-std=c++11 or -std=gnu++11");
2789       else if (processing_template_decl && current_class_type
2790                && TYPE_BINFO (current_class_type))
2791         {
2792           tree b;
2793
2794           for (b = TREE_CHAIN (TYPE_BINFO (current_class_type));
2795                b;
2796                b = TREE_CHAIN (b))
2797             {
2798               tree base_type = BINFO_TYPE (b);
2799               if (CLASS_TYPE_P (base_type)
2800                   && dependent_type_p (base_type))
2801                 {
2802                   tree field;
2803                   /* Go from a particular instantiation of the
2804                      template (which will have an empty TYPE_FIELDs),
2805                      to the main version.  */
2806                   base_type = CLASSTYPE_PRIMARY_TEMPLATE_TYPE (base_type);
2807                   for (field = TYPE_FIELDS (base_type);
2808                        field;
2809                        field = DECL_CHAIN (field))
2810                     if (TREE_CODE (field) == TYPE_DECL
2811                         && DECL_NAME (field) == id)
2812                       {
2813                         inform (location,
2814                                 "(perhaps %<typename %T::%E%> was intended)",
2815                                 BINFO_TYPE (b), id);
2816                         break;
2817                       }
2818                   if (field)
2819                     break;
2820                 }
2821             }
2822         }
2823     }
2824   /* Here we diagnose qualified-ids where the scope is actually correct,
2825      but the identifier does not resolve to a valid type name.  */
2826   else if (parser->scope != error_mark_node)
2827     {
2828       if (TREE_CODE (parser->scope) == NAMESPACE_DECL)
2829         error_at (location, "%qE in namespace %qE does not name a type",
2830                   id, parser->scope);
2831       else if (CLASS_TYPE_P (parser->scope)
2832                && constructor_name_p (id, parser->scope))
2833         {
2834           /* A<T>::A<T>() */
2835           error_at (location, "%<%T::%E%> names the constructor, not"
2836                     " the type", parser->scope, id);
2837           if (cp_lexer_next_token_is (parser->lexer, CPP_LESS))
2838             error_at (location, "and %qT has no template constructors",
2839                       parser->scope);
2840         }
2841       else if (TYPE_P (parser->scope)
2842                && dependent_scope_p (parser->scope))
2843         error_at (location, "need %<typename%> before %<%T::%E%> because "
2844                   "%qT is a dependent scope",
2845                   parser->scope, id, parser->scope);
2846       else if (TYPE_P (parser->scope))
2847         error_at (location, "%qE in %q#T does not name a type",
2848                   id, parser->scope);
2849       else
2850         gcc_unreachable ();
2851     }
2852 }
2853
2854 /* Check for a common situation where a type-name should be present,
2855    but is not, and issue a sensible error message.  Returns true if an
2856    invalid type-name was detected.
2857
2858    The situation handled by this function are variable declarations of the
2859    form `ID a', where `ID' is an id-expression and `a' is a plain identifier.
2860    Usually, `ID' should name a type, but if we got here it means that it
2861    does not. We try to emit the best possible error message depending on
2862    how exactly the id-expression looks like.  */
2863
2864 static bool
2865 cp_parser_parse_and_diagnose_invalid_type_name (cp_parser *parser)
2866 {
2867   tree id;
2868   cp_token *token = cp_lexer_peek_token (parser->lexer);
2869
2870   /* Avoid duplicate error about ambiguous lookup.  */
2871   if (token->type == CPP_NESTED_NAME_SPECIFIER)
2872     {
2873       cp_token *next = cp_lexer_peek_nth_token (parser->lexer, 2);
2874       if (next->type == CPP_NAME && next->ambiguous_p)
2875         goto out;
2876     }
2877
2878   cp_parser_parse_tentatively (parser);
2879   id = cp_parser_id_expression (parser,
2880                                 /*template_keyword_p=*/false,
2881                                 /*check_dependency_p=*/true,
2882                                 /*template_p=*/NULL,
2883                                 /*declarator_p=*/true,
2884                                 /*optional_p=*/false);
2885   /* If the next token is a (, this is a function with no explicit return
2886      type, i.e. constructor, destructor or conversion op.  */
2887   if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN)
2888       || TREE_CODE (id) == TYPE_DECL)
2889     {
2890       cp_parser_abort_tentative_parse (parser);
2891       return false;
2892     }
2893   if (!cp_parser_parse_definitely (parser))
2894     return false;
2895
2896   /* Emit a diagnostic for the invalid type.  */
2897   cp_parser_diagnose_invalid_type_name (parser, parser->scope,
2898                                         id, token->location);
2899  out:
2900   /* If we aren't in the middle of a declarator (i.e. in a
2901      parameter-declaration-clause), skip to the end of the declaration;
2902      there's no point in trying to process it.  */
2903   if (!parser->in_declarator_p)
2904     cp_parser_skip_to_end_of_block_or_statement (parser);
2905   return true;
2906 }
2907
2908 /* Consume tokens up to, and including, the next non-nested closing `)'.
2909    Returns 1 iff we found a closing `)'.  RECOVERING is true, if we
2910    are doing error recovery. Returns -1 if OR_COMMA is true and we
2911    found an unnested comma.  */
2912
2913 static int
2914 cp_parser_skip_to_closing_parenthesis (cp_parser *parser,
2915                                        bool recovering,
2916                                        bool or_comma,
2917                                        bool consume_paren)
2918 {
2919   unsigned paren_depth = 0;
2920   unsigned brace_depth = 0;
2921   unsigned square_depth = 0;
2922
2923   if (recovering && !or_comma
2924       && cp_parser_uncommitted_to_tentative_parse_p (parser))
2925     return 0;
2926
2927   while (true)
2928     {
2929       cp_token * token = cp_lexer_peek_token (parser->lexer);
2930
2931       switch (token->type)
2932         {
2933         case CPP_EOF:
2934         case CPP_PRAGMA_EOL:
2935           /* If we've run out of tokens, then there is no closing `)'.  */
2936           return 0;
2937
2938         /* This is good for lambda expression capture-lists.  */
2939         case CPP_OPEN_SQUARE:
2940           ++square_depth;
2941           break;
2942         case CPP_CLOSE_SQUARE:
2943           if (!square_depth--)
2944             return 0;
2945           break;
2946
2947         case CPP_SEMICOLON:
2948           /* This matches the processing in skip_to_end_of_statement.  */
2949           if (!brace_depth)
2950             return 0;
2951           break;
2952
2953         case CPP_OPEN_BRACE:
2954           ++brace_depth;
2955           break;
2956         case CPP_CLOSE_BRACE:
2957           if (!brace_depth--)
2958             return 0;
2959           break;
2960
2961         case CPP_COMMA:
2962           if (recovering && or_comma && !brace_depth && !paren_depth
2963               && !square_depth)
2964             return -1;
2965           break;
2966
2967         case CPP_OPEN_PAREN:
2968           if (!brace_depth)
2969             ++paren_depth;
2970           break;
2971
2972         case CPP_CLOSE_PAREN:
2973           if (!brace_depth && !paren_depth--)
2974             {
2975               if (consume_paren)
2976                 cp_lexer_consume_token (parser->lexer);
2977               return 1;
2978             }
2979           break;
2980
2981         default:
2982           break;
2983         }
2984
2985       /* Consume the token.  */
2986       cp_lexer_consume_token (parser->lexer);
2987     }
2988 }
2989
2990 /* Consume tokens until we reach the end of the current statement.
2991    Normally, that will be just before consuming a `;'.  However, if a
2992    non-nested `}' comes first, then we stop before consuming that.  */
2993
2994 static void
2995 cp_parser_skip_to_end_of_statement (cp_parser* parser)
2996 {
2997   unsigned nesting_depth = 0;
2998
2999   while (true)
3000     {
3001       cp_token *token = cp_lexer_peek_token (parser->lexer);
3002
3003       switch (token->type)
3004         {
3005         case CPP_EOF:
3006         case CPP_PRAGMA_EOL:
3007           /* If we've run out of tokens, stop.  */
3008           return;
3009
3010         case CPP_SEMICOLON:
3011           /* If the next token is a `;', we have reached the end of the
3012              statement.  */
3013           if (!nesting_depth)
3014             return;
3015           break;
3016
3017         case CPP_CLOSE_BRACE:
3018           /* If this is a non-nested '}', stop before consuming it.
3019              That way, when confronted with something like:
3020
3021                { 3 + }
3022
3023              we stop before consuming the closing '}', even though we
3024              have not yet reached a `;'.  */
3025           if (nesting_depth == 0)
3026             return;
3027
3028           /* If it is the closing '}' for a block that we have
3029              scanned, stop -- but only after consuming the token.
3030              That way given:
3031
3032                 void f g () { ... }
3033                 typedef int I;
3034
3035              we will stop after the body of the erroneously declared
3036              function, but before consuming the following `typedef'
3037              declaration.  */
3038           if (--nesting_depth == 0)
3039             {
3040               cp_lexer_consume_token (parser->lexer);
3041               return;
3042             }
3043
3044         case CPP_OPEN_BRACE:
3045           ++nesting_depth;
3046           break;
3047
3048         default:
3049           break;
3050         }
3051
3052       /* Consume the token.  */
3053       cp_lexer_consume_token (parser->lexer);
3054     }
3055 }
3056
3057 /* This function is called at the end of a statement or declaration.
3058    If the next token is a semicolon, it is consumed; otherwise, error
3059    recovery is attempted.  */
3060
3061 static void
3062 cp_parser_consume_semicolon_at_end_of_statement (cp_parser *parser)
3063 {
3064   /* Look for the trailing `;'.  */
3065   if (!cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON))
3066     {
3067       /* If there is additional (erroneous) input, skip to the end of
3068          the statement.  */
3069       cp_parser_skip_to_end_of_statement (parser);
3070       /* If the next token is now a `;', consume it.  */
3071       if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
3072         cp_lexer_consume_token (parser->lexer);
3073     }
3074 }
3075
3076 /* Skip tokens until we have consumed an entire block, or until we
3077    have consumed a non-nested `;'.  */
3078
3079 static void
3080 cp_parser_skip_to_end_of_block_or_statement (cp_parser* parser)
3081 {
3082   int nesting_depth = 0;
3083
3084   while (nesting_depth >= 0)
3085     {
3086       cp_token *token = cp_lexer_peek_token (parser->lexer);
3087
3088       switch (token->type)
3089         {
3090         case CPP_EOF:
3091         case CPP_PRAGMA_EOL:
3092           /* If we've run out of tokens, stop.  */
3093           return;
3094
3095         case CPP_SEMICOLON:
3096           /* Stop if this is an unnested ';'. */
3097           if (!nesting_depth)
3098             nesting_depth = -1;
3099           break;
3100
3101         case CPP_CLOSE_BRACE:
3102           /* Stop if this is an unnested '}', or closes the outermost
3103              nesting level.  */
3104           nesting_depth--;
3105           if (nesting_depth < 0)
3106             return;
3107           if (!nesting_depth)
3108             nesting_depth = -1;
3109           break;
3110
3111         case CPP_OPEN_BRACE:
3112           /* Nest. */
3113           nesting_depth++;
3114           break;
3115
3116         default:
3117           break;
3118         }
3119
3120       /* Consume the token.  */
3121       cp_lexer_consume_token (parser->lexer);
3122     }
3123 }
3124
3125 /* Skip tokens until a non-nested closing curly brace is the next
3126    token, or there are no more tokens. Return true in the first case,
3127    false otherwise.  */
3128
3129 static bool
3130 cp_parser_skip_to_closing_brace (cp_parser *parser)
3131 {
3132   unsigned nesting_depth = 0;
3133
3134   while (true)
3135     {
3136       cp_token *token = cp_lexer_peek_token (parser->lexer);
3137
3138       switch (token->type)
3139         {
3140         case CPP_EOF:
3141         case CPP_PRAGMA_EOL:
3142           /* If we've run out of tokens, stop.  */
3143           return false;
3144
3145         case CPP_CLOSE_BRACE:
3146           /* If the next token is a non-nested `}', then we have reached
3147              the end of the current block.  */
3148           if (nesting_depth-- == 0)
3149             return true;
3150           break;
3151
3152         case CPP_OPEN_BRACE:
3153           /* If it the next token is a `{', then we are entering a new
3154              block.  Consume the entire block.  */
3155           ++nesting_depth;
3156           break;
3157
3158         default:
3159           break;
3160         }
3161
3162       /* Consume the token.  */
3163       cp_lexer_consume_token (parser->lexer);
3164     }
3165 }
3166
3167 /* Consume tokens until we reach the end of the pragma.  The PRAGMA_TOK
3168    parameter is the PRAGMA token, allowing us to purge the entire pragma
3169    sequence.  */
3170
3171 static void
3172 cp_parser_skip_to_pragma_eol (cp_parser* parser, cp_token *pragma_tok)
3173 {
3174   cp_token *token;
3175
3176   parser->lexer->in_pragma = false;
3177
3178   do
3179     token = cp_lexer_consume_token (parser->lexer);
3180   while (token->type != CPP_PRAGMA_EOL && token->type != CPP_EOF);
3181
3182   /* Ensure that the pragma is not parsed again.  */
3183   cp_lexer_purge_tokens_after (parser->lexer, pragma_tok);
3184 }
3185
3186 /* Require pragma end of line, resyncing with it as necessary.  The
3187    arguments are as for cp_parser_skip_to_pragma_eol.  */
3188
3189 static void
3190 cp_parser_require_pragma_eol (cp_parser *parser, cp_token *pragma_tok)
3191 {
3192   parser->lexer->in_pragma = false;
3193   if (!cp_parser_require (parser, CPP_PRAGMA_EOL, RT_PRAGMA_EOL))
3194     cp_parser_skip_to_pragma_eol (parser, pragma_tok);
3195 }
3196
3197 /* This is a simple wrapper around make_typename_type. When the id is
3198    an unresolved identifier node, we can provide a superior diagnostic
3199    using cp_parser_diagnose_invalid_type_name.  */
3200
3201 static tree
3202 cp_parser_make_typename_type (cp_parser *parser, tree scope,
3203                               tree id, location_t id_location)
3204 {
3205   tree result;
3206   if (TREE_CODE (id) == IDENTIFIER_NODE)
3207     {
3208       result = make_typename_type (scope, id, typename_type,
3209                                    /*complain=*/tf_none);
3210       if (result == error_mark_node)
3211         cp_parser_diagnose_invalid_type_name (parser, scope, id, id_location);
3212       return result;
3213     }
3214   return make_typename_type (scope, id, typename_type, tf_error);
3215 }
3216
3217 /* This is a wrapper around the
3218    make_{pointer,ptrmem,reference}_declarator functions that decides
3219    which one to call based on the CODE and CLASS_TYPE arguments. The
3220    CODE argument should be one of the values returned by
3221    cp_parser_ptr_operator. */
3222 static cp_declarator *
3223 cp_parser_make_indirect_declarator (enum tree_code code, tree class_type,
3224                                     cp_cv_quals cv_qualifiers,
3225                                     cp_declarator *target)
3226 {
3227   if (code == ERROR_MARK)
3228     return cp_error_declarator;
3229
3230   if (code == INDIRECT_REF)
3231     if (class_type == NULL_TREE)
3232       return make_pointer_declarator (cv_qualifiers, target);
3233     else
3234       return make_ptrmem_declarator (cv_qualifiers, class_type, target);
3235   else if (code == ADDR_EXPR && class_type == NULL_TREE)
3236     return make_reference_declarator (cv_qualifiers, target, false);
3237   else if (code == NON_LVALUE_EXPR && class_type == NULL_TREE)
3238     return make_reference_declarator (cv_qualifiers, target, true);
3239   gcc_unreachable ();
3240 }
3241
3242 /* Create a new C++ parser.  */
3243
3244 static cp_parser *
3245 cp_parser_new (void)
3246 {
3247   cp_parser *parser;
3248   cp_lexer *lexer;
3249   unsigned i;
3250
3251   /* cp_lexer_new_main is called before doing GC allocation because
3252      cp_lexer_new_main might load a PCH file.  */
3253   lexer = cp_lexer_new_main ();
3254
3255   /* Initialize the binops_by_token so that we can get the tree
3256      directly from the token.  */
3257   for (i = 0; i < sizeof (binops) / sizeof (binops[0]); i++)
3258     binops_by_token[binops[i].token_type] = binops[i];
3259
3260   parser = ggc_alloc_cleared_cp_parser ();
3261   parser->lexer = lexer;
3262   parser->context = cp_parser_context_new (NULL);
3263
3264   /* For now, we always accept GNU extensions.  */
3265   parser->allow_gnu_extensions_p = 1;
3266
3267   /* The `>' token is a greater-than operator, not the end of a
3268      template-id.  */
3269   parser->greater_than_is_operator_p = true;
3270
3271   parser->default_arg_ok_p = true;
3272
3273   /* We are not parsing a constant-expression.  */
3274   parser->integral_constant_expression_p = false;
3275   parser->allow_non_integral_constant_expression_p = false;
3276   parser->non_integral_constant_expression_p = false;
3277
3278   /* Local variable names are not forbidden.  */
3279   parser->local_variables_forbidden_p = false;
3280
3281   /* We are not processing an `extern "C"' declaration.  */
3282   parser->in_unbraced_linkage_specification_p = false;
3283
3284   /* We are not processing a declarator.  */
3285   parser->in_declarator_p = false;
3286
3287   /* We are not processing a template-argument-list.  */
3288   parser->in_template_argument_list_p = false;
3289
3290   /* We are not in an iteration statement.  */
3291   parser->in_statement = 0;
3292
3293   /* We are not in a switch statement.  */
3294   parser->in_switch_statement_p = false;
3295
3296   /* We are not parsing a type-id inside an expression.  */
3297   parser->in_type_id_in_expr_p = false;
3298
3299   /* Declarations aren't implicitly extern "C".  */
3300   parser->implicit_extern_c = false;
3301
3302   /* String literals should be translated to the execution character set.  */
3303   parser->translate_strings_p = true;
3304
3305   /* We are not parsing a function body.  */
3306   parser->in_function_body = false;
3307
3308   /* We can correct until told otherwise.  */
3309   parser->colon_corrects_to_scope_p = true;
3310
3311   /* The unparsed function queue is empty.  */
3312   push_unparsed_function_queues (parser);
3313
3314   /* There are no classes being defined.  */
3315   parser->num_classes_being_defined = 0;
3316
3317   /* No template parameters apply.  */
3318   parser->num_template_parameter_lists = 0;
3319
3320   return parser;
3321 }
3322
3323 /* Create a cp_lexer structure which will emit the tokens in CACHE
3324    and push it onto the parser's lexer stack.  This is used for delayed
3325    parsing of in-class method bodies and default arguments, and should
3326    not be confused with tentative parsing.  */
3327 static void
3328 cp_parser_push_lexer_for_tokens (cp_parser *parser, cp_token_cache *cache)
3329 {
3330   cp_lexer *lexer = cp_lexer_new_from_tokens (cache);
3331   lexer->next = parser->lexer;
3332   parser->lexer = lexer;
3333
3334   /* Move the current source position to that of the first token in the
3335      new lexer.  */
3336   cp_lexer_set_source_position_from_token (lexer->next_token);
3337 }
3338
3339 /* Pop the top lexer off the parser stack.  This is never used for the
3340    "main" lexer, only for those pushed by cp_parser_push_lexer_for_tokens.  */
3341 static void
3342 cp_parser_pop_lexer (cp_parser *parser)
3343 {
3344   cp_lexer *lexer = parser->lexer;
3345   parser->lexer = lexer->next;
3346   cp_lexer_destroy (lexer);
3347
3348   /* Put the current source position back where it was before this
3349      lexer was pushed.  */
3350   cp_lexer_set_source_position_from_token (parser->lexer->next_token);
3351 }
3352
3353 /* Lexical conventions [gram.lex]  */
3354
3355 /* Parse an identifier.  Returns an IDENTIFIER_NODE representing the
3356    identifier.  */
3357
3358 static tree
3359 cp_parser_identifier (cp_parser* parser)
3360 {
3361   cp_token *token;
3362
3363   /* Look for the identifier.  */
3364   token = cp_parser_require (parser, CPP_NAME, RT_NAME);
3365   /* Return the value.  */
3366   return token ? token->u.value : error_mark_node;
3367 }
3368
3369 /* Parse a sequence of adjacent string constants.  Returns a
3370    TREE_STRING representing the combined, nul-terminated string
3371    constant.  If TRANSLATE is true, translate the string to the
3372    execution character set.  If WIDE_OK is true, a wide string is
3373    invalid here.
3374
3375    C++98 [lex.string] says that if a narrow string literal token is
3376    adjacent to a wide string literal token, the behavior is undefined.
3377    However, C99 6.4.5p4 says that this results in a wide string literal.
3378    We follow C99 here, for consistency with the C front end.
3379
3380    This code is largely lifted from lex_string() in c-lex.c.
3381
3382    FUTURE: ObjC++ will need to handle @-strings here.  */
3383 static tree
3384 cp_parser_string_literal (cp_parser *parser, bool translate, bool wide_ok)
3385 {
3386   tree value;
3387   size_t count;
3388   struct obstack str_ob;
3389   cpp_string str, istr, *strs;
3390   cp_token *tok;
3391   enum cpp_ttype type, curr_type;
3392   int have_suffix_p = 0;
3393   tree string_tree;
3394   tree suffix_id = NULL_TREE;
3395   bool curr_tok_is_userdef_p = false;
3396
3397   tok = cp_lexer_peek_token (parser->lexer);
3398   if (!cp_parser_is_string_literal (tok))
3399     {
3400       cp_parser_error (parser, "expected string-literal");
3401       return error_mark_node;
3402     }
3403
3404   if (cpp_userdef_string_p (tok->type))
3405     {
3406       string_tree = USERDEF_LITERAL_VALUE (tok->u.value);
3407       curr_type = cpp_userdef_string_remove_type (tok->type);
3408       curr_tok_is_userdef_p = true;
3409     }
3410   else
3411     {
3412       string_tree = tok->u.value;
3413       curr_type = tok->type;
3414     }
3415   type = curr_type;
3416
3417   /* Try to avoid the overhead of creating and destroying an obstack
3418      for the common case of just one string.  */
3419   if (!cp_parser_is_string_literal
3420       (cp_lexer_peek_nth_token (parser->lexer, 2)))
3421     {
3422       cp_lexer_consume_token (parser->lexer);
3423
3424       str.text = (const unsigned char *)TREE_STRING_POINTER (string_tree);
3425       str.len = TREE_STRING_LENGTH (string_tree);
3426       count = 1;
3427
3428       if (curr_tok_is_userdef_p)
3429         {
3430           suffix_id = USERDEF_LITERAL_SUFFIX_ID (tok->u.value);
3431           have_suffix_p = 1;
3432           curr_type = cpp_userdef_string_remove_type (tok->type);
3433         }
3434       else
3435         curr_type = tok->type;
3436
3437       strs = &str;
3438     }
3439   else
3440     {
3441       gcc_obstack_init (&str_ob);
3442       count = 0;
3443
3444       do
3445         {
3446           cp_lexer_consume_token (parser->lexer);
3447           count++;
3448           str.text = (const unsigned char *)TREE_STRING_POINTER (string_tree);
3449           str.len = TREE_STRING_LENGTH (string_tree);
3450
3451           if (curr_tok_is_userdef_p)
3452             {
3453               tree curr_suffix_id = USERDEF_LITERAL_SUFFIX_ID (tok->u.value);
3454               if (have_suffix_p == 0)
3455                 {
3456                   suffix_id = curr_suffix_id;
3457                   have_suffix_p = 1;
3458                 }
3459               else if (have_suffix_p == 1
3460                        && curr_suffix_id != suffix_id)
3461                 {
3462                   error ("inconsistent user-defined literal suffixes"
3463                          " %qD and %qD in string literal",
3464                          suffix_id, curr_suffix_id);
3465                   have_suffix_p = -1;
3466                 }
3467               curr_type = cpp_userdef_string_remove_type (tok->type);
3468             }
3469           else
3470             curr_type = tok->type;
3471
3472           if (type != curr_type)
3473             {
3474               if (type == CPP_STRING)
3475                 type = curr_type;
3476               else if (curr_type != CPP_STRING)
3477                 error_at (tok->location,
3478                           "unsupported non-standard concatenation "
3479                           "of string literals");
3480             }
3481
3482           obstack_grow (&str_ob, &str, sizeof (cpp_string));
3483
3484           tok = cp_lexer_peek_token (parser->lexer);
3485           if (cpp_userdef_string_p (tok->type))
3486             {
3487               string_tree = USERDEF_LITERAL_VALUE (tok->u.value);
3488               curr_type = cpp_userdef_string_remove_type (tok->type);
3489               curr_tok_is_userdef_p = true;
3490             }
3491           else
3492             {
3493               string_tree = tok->u.value;
3494               curr_type = tok->type;
3495               curr_tok_is_userdef_p = false;
3496             }
3497         }
3498       while (cp_parser_is_string_literal (tok));
3499
3500       strs = (cpp_string *) obstack_finish (&str_ob);
3501     }
3502
3503   if (type != CPP_STRING && !wide_ok)
3504     {
3505       cp_parser_error (parser, "a wide string is invalid in this context");
3506       type = CPP_STRING;
3507     }
3508
3509   if ((translate ? cpp_interpret_string : cpp_interpret_string_notranslate)
3510       (parse_in, strs, count, &istr, type))
3511     {
3512       value = build_string (istr.len, (const char *)istr.text);
3513       free (CONST_CAST (unsigned char *, istr.text));
3514
3515       switch (type)
3516         {
3517         default:
3518         case CPP_STRING:
3519         case CPP_UTF8STRING:
3520           TREE_TYPE (value) = char_array_type_node;
3521           break;
3522         case CPP_STRING16:
3523           TREE_TYPE (value) = char16_array_type_node;
3524           break;
3525         case CPP_STRING32:
3526           TREE_TYPE (value) = char32_array_type_node;
3527           break;
3528         case CPP_WSTRING:
3529           TREE_TYPE (value) = wchar_array_type_node;
3530           break;
3531         }
3532
3533       value = fix_string_type (value);
3534
3535       if (have_suffix_p)
3536         {
3537           tree literal = build_userdef_literal (suffix_id, value, NULL_TREE);
3538           tok->u.value = literal;
3539           return cp_parser_userdef_string_literal (tok);
3540         }
3541     }
3542   else
3543     /* cpp_interpret_string has issued an error.  */
3544     value = error_mark_node;
3545
3546   if (count > 1)
3547     obstack_free (&str_ob, 0);
3548
3549   return value;
3550 }
3551
3552 /* Look up a literal operator with the name and the exact arguments.  */
3553
3554 static tree
3555 lookup_literal_operator (tree name, VEC(tree,gc) *args)
3556 {
3557   tree decl, fns;
3558   decl = lookup_name (name);
3559   if (!decl || !is_overloaded_fn (decl))
3560     return error_mark_node;
3561
3562   for (fns = decl; fns; fns = OVL_NEXT (fns))
3563     {
3564       unsigned int ix;
3565       bool found = true;
3566       tree fn = OVL_CURRENT (fns);
3567       tree argtypes = NULL_TREE;
3568       argtypes = TYPE_ARG_TYPES (TREE_TYPE (fn));
3569       if (argtypes != NULL_TREE)
3570         {
3571           for (ix = 0; ix < VEC_length (tree, args) && argtypes != NULL_TREE;
3572                ++ix, argtypes = TREE_CHAIN (argtypes))
3573             {
3574               tree targ = TREE_VALUE (argtypes);
3575               tree tparm = TREE_TYPE (VEC_index (tree, args, ix));
3576               bool ptr = TREE_CODE (targ) == POINTER_TYPE;
3577               bool arr = TREE_CODE (tparm) == ARRAY_TYPE;
3578               if ((ptr || arr || !same_type_p (targ, tparm))
3579                   && (!ptr || !arr
3580                       || !same_type_p (TREE_TYPE (targ),
3581                                        TREE_TYPE (tparm))))
3582                 found = false;
3583             }
3584           if (found
3585               && ix == VEC_length (tree, args)
3586               /* May be this should be sufficient_parms_p instead,
3587                  depending on how exactly should user-defined literals
3588                  work in presence of default arguments on the literal
3589                  operator parameters.  */
3590               && argtypes == void_list_node)
3591             return fn;
3592         }
3593     }
3594
3595   return error_mark_node;
3596 }
3597
3598 /* Parse a user-defined char constant.  Returns a call to a user-defined
3599    literal operator taking the character as an argument.  */
3600
3601 static tree
3602 cp_parser_userdef_char_literal (cp_parser *parser)
3603 {
3604   cp_token *token = cp_lexer_consume_token (parser->lexer);
3605   tree literal = token->u.value;
3606   tree suffix_id = USERDEF_LITERAL_SUFFIX_ID (literal);
3607   tree value = USERDEF_LITERAL_VALUE (literal);
3608   tree name = cp_literal_operator_id (IDENTIFIER_POINTER (suffix_id));
3609   tree decl, result;
3610
3611   /* Build up a call to the user-defined operator  */
3612   /* Lookup the name we got back from the id-expression.  */
3613   VEC(tree,gc) *args = make_tree_vector ();
3614   VEC_safe_push (tree, gc, args, value);
3615   decl = lookup_literal_operator (name, args);
3616   if (!decl || decl == error_mark_node)
3617     {
3618       error ("unable to find character literal operator %qD with %qT argument",
3619              name, TREE_TYPE (value));
3620       release_tree_vector (args);
3621       return error_mark_node;
3622     }
3623   result = finish_call_expr (decl, &args, false, true, tf_warning_or_error);
3624   release_tree_vector (args);
3625   if (result != error_mark_node)
3626     return result;
3627
3628   error ("unable to find character literal operator %qD with %qT argument",
3629          name, TREE_TYPE (value));
3630   return error_mark_node;
3631 }
3632
3633 /* A subroutine of cp_parser_userdef_numeric_literal to
3634    create a char... template parameter pack from a string node.  */
3635
3636 static tree
3637 make_char_string_pack (tree value)
3638 {
3639   tree charvec;
3640   tree argpack = make_node (NONTYPE_ARGUMENT_PACK);
3641   const char *str = TREE_STRING_POINTER (value);
3642   int i, len = TREE_STRING_LENGTH (value) - 1;
3643   tree argvec = make_tree_vec (1);
3644
3645   /* Fill in CHARVEC with all of the parameters.  */
3646   charvec = make_tree_vec (len);
3647   for (i = 0; i < len; ++i)
3648     TREE_VEC_ELT (charvec, i) = build_int_cst (char_type_node, str[i]);
3649
3650   /* Build the argument packs.  */
3651   SET_ARGUMENT_PACK_ARGS (argpack, charvec);
3652   TREE_TYPE (argpack) = char_type_node;
3653
3654   TREE_VEC_ELT (argvec, 0) = argpack;
3655
3656   return argvec;
3657 }
3658
3659 /* Parse a user-defined numeric constant.  returns a call to a user-defined
3660    literal operator.  */
3661
3662 static tree
3663 cp_parser_userdef_numeric_literal (cp_parser *parser)
3664 {
3665   cp_token *token = cp_lexer_consume_token (parser->lexer);
3666   tree literal = token->u.value;
3667   tree suffix_id = USERDEF_LITERAL_SUFFIX_ID (literal);
3668   tree value = USERDEF_LITERAL_VALUE (literal);
3669   tree num_string = USERDEF_LITERAL_NUM_STRING (literal);
3670   tree name = cp_literal_operator_id (IDENTIFIER_POINTER (suffix_id));
3671   tree decl, result;
3672   VEC(tree,gc) *args;
3673
3674   /* Look for a literal operator taking the exact type of numeric argument
3675      as the literal value.  */
3676   args = make_tree_vector ();
3677   VEC_safe_push (tree, gc, args, value);
3678   decl = lookup_literal_operator (name, args);
3679   if (decl && decl != error_mark_node)
3680     {
3681       result = finish_call_expr (decl, &args, false, true, tf_none);
3682       if (result != error_mark_node)
3683         {
3684           release_tree_vector (args);
3685           return result;
3686         }
3687     }
3688   release_tree_vector (args);
3689
3690   /* If the numeric argument didn't work, look for a raw literal
3691      operator taking a const char* argument consisting of the number
3692      in string format.  */
3693   args = make_tree_vector ();
3694   VEC_safe_push (tree, gc, args, num_string);
3695   decl = lookup_literal_operator (name, args);
3696   if (decl && decl != error_mark_node)
3697     {
3698       result = finish_call_expr (decl, &args, false, true, tf_none);
3699       if (result != error_mark_node)
3700         {
3701           release_tree_vector (args);
3702           return result;
3703         }
3704     }
3705   release_tree_vector (args);
3706
3707   /* If the raw literal didn't work, look for a non-type template
3708      function with parameter pack char....  Call the function with
3709      template parameter characters representing the number.  */
3710   args = make_tree_vector ();
3711   decl = lookup_literal_operator (name, args);
3712   if (decl && decl != error_mark_node)
3713     {
3714       tree tmpl_args = make_char_string_pack (num_string);
3715       decl = lookup_template_function (decl, tmpl_args);
3716       result = finish_call_expr (decl, &args, false, true, tf_none);
3717       if (result != error_mark_node)
3718         {
3719           release_tree_vector (args);
3720           return result;
3721         }
3722     }
3723   release_tree_vector (args);
3724
3725   error ("unable to find numeric literal operator %qD", name);
3726   return error_mark_node;
3727 }
3728
3729 /* Parse a user-defined string constant.  Returns a call to a user-defined
3730    literal operator taking a character pointer and the length of the string
3731    as arguments.  */
3732
3733 static tree
3734 cp_parser_userdef_string_literal (cp_token *token)
3735 {
3736   tree literal = token->u.value;
3737   tree suffix_id = USERDEF_LITERAL_SUFFIX_ID (literal);
3738   tree name = cp_literal_operator_id (IDENTIFIER_POINTER (suffix_id));
3739   tree value = USERDEF_LITERAL_VALUE (literal);
3740   int len = TREE_STRING_LENGTH (value)
3741         / TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (value)))) - 1;
3742   tree decl, result;
3743
3744   /* Build up a call to the user-defined operator  */
3745   /* Lookup the name we got back from the id-expression.  */
3746   VEC(tree,gc) *args = make_tree_vector ();
3747   VEC_safe_push (tree, gc, args, value);
3748   VEC_safe_push (tree, gc, args, build_int_cst (size_type_node, len));
3749   decl = lookup_name (name);
3750   if (!decl || decl == error_mark_node)
3751     {
3752       error ("unable to find string literal operator %qD", name);
3753       release_tree_vector (args);
3754       return error_mark_node;
3755     }
3756   result = finish_call_expr (decl, &args, false, true, tf_none);
3757   release_tree_vector (args);
3758   if (result != error_mark_node)
3759     return result;
3760
3761   error ("unable to find string literal operator %qD with %qT, %qT arguments",
3762          name, TREE_TYPE (value), size_type_node);
3763   return error_mark_node;
3764 }
3765
3766
3767 /* Basic concepts [gram.basic]  */
3768
3769 /* Parse a translation-unit.
3770
3771    translation-unit:
3772      declaration-seq [opt]
3773
3774    Returns TRUE if all went well.  */
3775
3776 static bool
3777 cp_parser_translation_unit (cp_parser* parser)
3778 {
3779   /* The address of the first non-permanent object on the declarator
3780      obstack.  */
3781   static void *declarator_obstack_base;
3782
3783   bool success;
3784
3785   /* Create the declarator obstack, if necessary.  */
3786   if (!cp_error_declarator)
3787     {
3788       gcc_obstack_init (&declarator_obstack);
3789       /* Create the error declarator.  */
3790       cp_error_declarator = make_declarator (cdk_error);
3791       /* Create the empty parameter list.  */
3792       no_parameters = make_parameter_declarator (NULL, NULL, NULL_TREE);
3793       /* Remember where the base of the declarator obstack lies.  */
3794       declarator_obstack_base = obstack_next_free (&declarator_obstack);
3795     }
3796
3797   cp_parser_declaration_seq_opt (parser);
3798
3799   /* If there are no tokens left then all went well.  */
3800   if (cp_lexer_next_token_is (parser->lexer, CPP_EOF))
3801     {
3802       /* Get rid of the token array; we don't need it any more.  */
3803       cp_lexer_destroy (parser->lexer);
3804       parser->lexer = NULL;
3805
3806       /* This file might have been a context that's implicitly extern
3807          "C".  If so, pop the lang context.  (Only relevant for PCH.) */
3808       if (parser->implicit_extern_c)
3809         {
3810           pop_lang_context ();
3811           parser->implicit_extern_c = false;
3812         }
3813
3814       /* Finish up.  */
3815       finish_translation_unit ();
3816
3817       success = true;
3818     }
3819   else
3820     {
3821       cp_parser_error (parser, "expected declaration");
3822       success = false;
3823     }
3824
3825   /* Make sure the declarator obstack was fully cleaned up.  */
3826   gcc_assert (obstack_next_free (&declarator_obstack)
3827               == declarator_obstack_base);
3828
3829   /* All went well.  */
3830   return success;
3831 }
3832
3833 /* Expressions [gram.expr] */
3834
3835 /* Parse a primary-expression.
3836
3837    primary-expression:
3838      literal
3839      this
3840      ( expression )
3841      id-expression
3842
3843    GNU Extensions:
3844
3845    primary-expression:
3846      ( compound-statement )
3847      __builtin_va_arg ( assignment-expression , type-id )
3848      __builtin_offsetof ( type-id , offsetof-expression )
3849
3850    C++ Extensions:
3851      __has_nothrow_assign ( type-id )
3852      __has_nothrow_constructor ( type-id )
3853      __has_nothrow_copy ( type-id )
3854      __has_trivial_assign ( type-id )
3855      __has_trivial_constructor ( type-id )
3856      __has_trivial_copy ( type-id )
3857      __has_trivial_destructor ( type-id )
3858      __has_virtual_destructor ( type-id )
3859      __is_abstract ( type-id )
3860      __is_base_of ( type-id , type-id )
3861      __is_class ( type-id )
3862      __is_convertible_to ( type-id , type-id )
3863      __is_empty ( type-id )
3864      __is_enum ( type-id )
3865      __is_final ( type-id )
3866      __is_literal_type ( type-id )
3867      __is_pod ( type-id )
3868      __is_polymorphic ( type-id )
3869      __is_std_layout ( type-id )
3870      __is_trivial ( type-id )
3871      __is_union ( type-id )
3872
3873    Objective-C++ Extension:
3874
3875    primary-expression:
3876      objc-expression
3877
3878    literal:
3879      __null
3880
3881    ADDRESS_P is true iff this expression was immediately preceded by
3882    "&" and therefore might denote a pointer-to-member.  CAST_P is true
3883    iff this expression is the target of a cast.  TEMPLATE_ARG_P is
3884    true iff this expression is a template argument.
3885
3886    Returns a representation of the expression.  Upon return, *IDK
3887    indicates what kind of id-expression (if any) was present.  */
3888
3889 static tree
3890 cp_parser_primary_expression (cp_parser *parser,
3891                               bool address_p,
3892                               bool cast_p,
3893                               bool template_arg_p,
3894                               cp_id_kind *idk)
3895 {
3896   cp_token *token = NULL;
3897
3898   /* Assume the primary expression is not an id-expression.  */
3899   *idk = CP_ID_KIND_NONE;
3900
3901   /* Peek at the next token.  */
3902   token = cp_lexer_peek_token (parser->lexer);
3903   switch (token->type)
3904     {
3905       /* literal:
3906            integer-literal
3907            character-literal
3908            floating-literal
3909            string-literal
3910            boolean-literal
3911            pointer-literal
3912            user-defined-literal  */
3913     case CPP_CHAR:
3914     case CPP_CHAR16:
3915     case CPP_CHAR32:
3916     case CPP_WCHAR:
3917     case CPP_NUMBER:
3918       if (TREE_CODE (token->u.value) == USERDEF_LITERAL)
3919         return cp_parser_userdef_numeric_literal (parser);
3920       token = cp_lexer_consume_token (parser->lexer);
3921       if (TREE_CODE (token->u.value) == FIXED_CST)
3922         {
3923           error_at (token->location,
3924                     "fixed-point types not supported in C++");
3925           return error_mark_node;
3926         }
3927       /* Floating-point literals are only allowed in an integral
3928          constant expression if they are cast to an integral or
3929          enumeration type.  */
3930       if (TREE_CODE (token->u.value) == REAL_CST
3931           && parser->integral_constant_expression_p
3932           && pedantic)
3933         {
3934           /* CAST_P will be set even in invalid code like "int(2.7 +
3935              ...)".   Therefore, we have to check that the next token
3936              is sure to end the cast.  */
3937           if (cast_p)
3938             {
3939               cp_token *next_token;
3940
3941               next_token = cp_lexer_peek_token (parser->lexer);
3942               if (/* The comma at the end of an
3943                      enumerator-definition.  */
3944                   next_token->type != CPP_COMMA
3945                   /* The curly brace at the end of an enum-specifier.  */
3946                   && next_token->type != CPP_CLOSE_BRACE
3947                   /* The end of a statement.  */
3948                   && next_token->type != CPP_SEMICOLON
3949                   /* The end of the cast-expression.  */
3950                   && next_token->type != CPP_CLOSE_PAREN
3951                   /* The end of an array bound.  */
3952                   && next_token->type != CPP_CLOSE_SQUARE
3953                   /* The closing ">" in a template-argument-list.  */
3954                   && (next_token->type != CPP_GREATER
3955                       || parser->greater_than_is_operator_p)
3956                   /* C++0x only: A ">>" treated like two ">" tokens,
3957                      in a template-argument-list.  */
3958                   && (next_token->type != CPP_RSHIFT
3959                       || (cxx_dialect == cxx98)
3960                       || parser->greater_than_is_operator_p))
3961                 cast_p = false;
3962             }
3963
3964           /* If we are within a cast, then the constraint that the
3965              cast is to an integral or enumeration type will be
3966              checked at that point.  If we are not within a cast, then
3967              this code is invalid.  */
3968           if (!cast_p)
3969             cp_parser_non_integral_constant_expression (parser, NIC_FLOAT);
3970         }
3971       return token->u.value;
3972
3973     case CPP_CHAR_USERDEF:
3974     case CPP_CHAR16_USERDEF:
3975     case CPP_CHAR32_USERDEF:
3976     case CPP_WCHAR_USERDEF:
3977       return cp_parser_userdef_char_literal (parser);
3978
3979     case CPP_STRING:
3980     case CPP_STRING16:
3981     case CPP_STRING32:
3982     case CPP_WSTRING:
3983     case CPP_UTF8STRING:
3984     case CPP_STRING_USERDEF:
3985     case CPP_STRING16_USERDEF:
3986     case CPP_STRING32_USERDEF:
3987     case CPP_WSTRING_USERDEF:
3988     case CPP_UTF8STRING_USERDEF:
3989       /* ??? Should wide strings be allowed when parser->translate_strings_p
3990          is false (i.e. in attributes)?  If not, we can kill the third
3991          argument to cp_parser_string_literal.  */
3992       return cp_parser_string_literal (parser,
3993                                        parser->translate_strings_p,
3994                                        true);
3995
3996     case CPP_OPEN_PAREN:
3997       {
3998         tree expr;
3999         bool saved_greater_than_is_operator_p;
4000
4001         /* Consume the `('.  */
4002         cp_lexer_consume_token (parser->lexer);
4003         /* Within a parenthesized expression, a `>' token is always
4004            the greater-than operator.  */
4005         saved_greater_than_is_operator_p
4006           = parser->greater_than_is_operator_p;
4007         parser->greater_than_is_operator_p = true;
4008         /* If we see `( { ' then we are looking at the beginning of
4009            a GNU statement-expression.  */
4010         if (cp_parser_allow_gnu_extensions_p (parser)
4011             && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
4012           {
4013             /* Statement-expressions are not allowed by the standard.  */
4014             pedwarn (token->location, OPT_pedantic,
4015                      "ISO C++ forbids braced-groups within expressions");
4016
4017             /* And they're not allowed outside of a function-body; you
4018                cannot, for example, write:
4019
4020                  int i = ({ int j = 3; j + 1; });
4021
4022                at class or namespace scope.  */
4023             if (!parser->in_function_body
4024                 || parser->in_template_argument_list_p)
4025               {
4026                 error_at (token->location,
4027                           "statement-expressions are not allowed outside "
4028                           "functions nor in template-argument lists");
4029                 cp_parser_skip_to_end_of_block_or_statement (parser);
4030                 expr = error_mark_node;
4031               }
4032             else
4033               {
4034                 /* Start the statement-expression.  */
4035                 expr = begin_stmt_expr ();
4036                 /* Parse the compound-statement.  */
4037                 cp_parser_compound_statement (parser, expr, false, false);
4038                 /* Finish up.  */
4039                 expr = finish_stmt_expr (expr, false);
4040               }
4041           }
4042         else
4043           {
4044             /* Parse the parenthesized expression.  */
4045             expr = cp_parser_expression (parser, cast_p, idk);
4046             /* Let the front end know that this expression was
4047                enclosed in parentheses. This matters in case, for
4048                example, the expression is of the form `A::B', since
4049                `&A::B' might be a pointer-to-member, but `&(A::B)' is
4050                not.  */
4051             finish_parenthesized_expr (expr);
4052             /* DR 705: Wrapping an unqualified name in parentheses
4053                suppresses arg-dependent lookup.  We want to pass back
4054                CP_ID_KIND_QUALIFIED for suppressing vtable lookup
4055                (c++/37862), but none of the others.  */
4056             if (*idk != CP_ID_KIND_QUALIFIED)
4057               *idk = CP_ID_KIND_NONE;
4058           }
4059         /* The `>' token might be the end of a template-id or
4060            template-parameter-list now.  */
4061         parser->greater_than_is_operator_p
4062           = saved_greater_than_is_operator_p;
4063         /* Consume the `)'.  */
4064         if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
4065           cp_parser_skip_to_end_of_statement (parser);
4066
4067         return expr;
4068       }
4069
4070     case CPP_OPEN_SQUARE:
4071       if (c_dialect_objc ())
4072         /* We have an Objective-C++ message. */
4073         return cp_parser_objc_expression (parser);
4074       {
4075         tree lam = cp_parser_lambda_expression (parser);
4076         /* Don't warn about a failed tentative parse.  */
4077         if (cp_parser_error_occurred (parser))
4078           return error_mark_node;
4079         maybe_warn_cpp0x (CPP0X_LAMBDA_EXPR);
4080         return lam;
4081       }
4082
4083     case CPP_OBJC_STRING:
4084       if (c_dialect_objc ())
4085         /* We have an Objective-C++ string literal. */
4086         return cp_parser_objc_expression (parser);
4087       cp_parser_error (parser, "expected primary-expression");
4088       return error_mark_node;
4089
4090     case CPP_KEYWORD:
4091       switch (token->keyword)
4092         {
4093           /* These two are the boolean literals.  */
4094         case RID_TRUE:
4095           cp_lexer_consume_token (parser->lexer);
4096           return boolean_true_node;
4097         case RID_FALSE:
4098           cp_lexer_consume_token (parser->lexer);
4099           return boolean_false_node;
4100
4101           /* The `__null' literal.  */
4102         case RID_NULL:
4103           cp_lexer_consume_token (parser->lexer);
4104           return null_node;
4105
4106           /* The `nullptr' literal.  */
4107         case RID_NULLPTR:
4108           cp_lexer_consume_token (parser->lexer);
4109           return nullptr_node;
4110
4111           /* Recognize the `this' keyword.  */
4112         case RID_THIS:
4113           cp_lexer_consume_token (parser->lexer);
4114           if (parser->local_variables_forbidden_p)
4115             {
4116               error_at (token->location,
4117                         "%<this%> may not be used in this context");
4118               return error_mark_node;
4119             }
4120           /* Pointers cannot appear in constant-expressions.  */
4121           if (cp_parser_non_integral_constant_expression (parser, NIC_THIS))
4122             return error_mark_node;
4123           return finish_this_expr ();
4124
4125           /* The `operator' keyword can be the beginning of an
4126              id-expression.  */
4127         case RID_OPERATOR:
4128           goto id_expression;
4129
4130         case RID_FUNCTION_NAME:
4131         case RID_PRETTY_FUNCTION_NAME:
4132         case RID_C99_FUNCTION_NAME:
4133           {
4134             non_integral_constant name;
4135
4136             /* The symbols __FUNCTION__, __PRETTY_FUNCTION__, and
4137                __func__ are the names of variables -- but they are
4138                treated specially.  Therefore, they are handled here,
4139                rather than relying on the generic id-expression logic
4140                below.  Grammatically, these names are id-expressions.
4141
4142                Consume the token.  */
4143             token = cp_lexer_consume_token (parser->lexer);
4144
4145             switch (token->keyword)
4146               {
4147               case RID_FUNCTION_NAME:
4148                 name = NIC_FUNC_NAME;
4149                 break;
4150               case RID_PRETTY_FUNCTION_NAME:
4151                 name = NIC_PRETTY_FUNC;
4152                 break;
4153               case RID_C99_FUNCTION_NAME:
4154                 name = NIC_C99_FUNC;
4155                 break;
4156               default:
4157                 gcc_unreachable ();
4158               }
4159
4160             if (cp_parser_non_integral_constant_expression (parser, name))
4161               return error_mark_node;
4162
4163             /* Look up the name.  */
4164             return finish_fname (token->u.value);
4165           }
4166
4167         case RID_VA_ARG:
4168           {
4169             tree expression;
4170             tree type;
4171
4172             /* The `__builtin_va_arg' construct is used to handle
4173                `va_arg'.  Consume the `__builtin_va_arg' token.  */
4174             cp_lexer_consume_token (parser->lexer);
4175             /* Look for the opening `('.  */
4176             cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
4177             /* Now, parse the assignment-expression.  */
4178             expression = cp_parser_assignment_expression (parser,
4179                                                           /*cast_p=*/false, NULL);
4180             /* Look for the `,'.  */
4181             cp_parser_require (parser, CPP_COMMA, RT_COMMA);
4182             /* Parse the type-id.  */
4183             type = cp_parser_type_id (parser);
4184             /* Look for the closing `)'.  */
4185             cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
4186             /* Using `va_arg' in a constant-expression is not
4187                allowed.  */
4188             if (cp_parser_non_integral_constant_expression (parser,
4189                                                             NIC_VA_ARG))
4190               return error_mark_node;
4191             return build_x_va_arg (expression, type);
4192           }
4193
4194         case RID_OFFSETOF:
4195           return cp_parser_builtin_offsetof (parser);
4196
4197         case RID_HAS_NOTHROW_ASSIGN:
4198         case RID_HAS_NOTHROW_CONSTRUCTOR:
4199         case RID_HAS_NOTHROW_COPY:
4200         case RID_HAS_TRIVIAL_ASSIGN:
4201         case RID_HAS_TRIVIAL_CONSTRUCTOR:
4202         case RID_HAS_TRIVIAL_COPY:
4203         case RID_HAS_TRIVIAL_DESTRUCTOR:
4204         case RID_HAS_VIRTUAL_DESTRUCTOR:
4205         case RID_IS_ABSTRACT:
4206         case RID_IS_BASE_OF:
4207         case RID_IS_CLASS:
4208         case RID_IS_CONVERTIBLE_TO:
4209         case RID_IS_EMPTY:
4210         case RID_IS_ENUM:
4211         case RID_IS_FINAL:
4212         case RID_IS_LITERAL_TYPE:
4213         case RID_IS_POD:
4214         case RID_IS_POLYMORPHIC:
4215         case RID_IS_STD_LAYOUT:
4216         case RID_IS_TRIVIAL:
4217         case RID_IS_UNION:
4218           return cp_parser_trait_expr (parser, token->keyword);
4219
4220         /* Objective-C++ expressions.  */
4221         case RID_AT_ENCODE:
4222         case RID_AT_PROTOCOL:
4223         case RID_AT_SELECTOR:
4224           return cp_parser_objc_expression (parser);
4225
4226         case RID_TEMPLATE:
4227           if (parser->in_function_body
4228               && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
4229                   == CPP_LESS))
4230             {
4231               error_at (token->location,
4232                         "a template declaration cannot appear at block scope");
4233               cp_parser_skip_to_end_of_block_or_statement (parser);
4234               return error_mark_node;
4235             }
4236         default:
4237           cp_parser_error (parser, "expected primary-expression");
4238           return error_mark_node;
4239         }
4240
4241       /* An id-expression can start with either an identifier, a
4242          `::' as the beginning of a qualified-id, or the "operator"
4243          keyword.  */
4244     case CPP_NAME:
4245     case CPP_SCOPE:
4246     case CPP_TEMPLATE_ID:
4247     case CPP_NESTED_NAME_SPECIFIER:
4248       {
4249         tree id_expression;
4250         tree decl;
4251         const char *error_msg;
4252         bool template_p;
4253         bool done;
4254         cp_token *id_expr_token;
4255
4256       id_expression:
4257         /* Parse the id-expression.  */
4258         id_expression
4259           = cp_parser_id_expression (parser,
4260                                      /*template_keyword_p=*/false,
4261                                      /*check_dependency_p=*/true,
4262                                      &template_p,
4263                                      /*declarator_p=*/false,
4264                                      /*optional_p=*/false);
4265         if (id_expression == error_mark_node)
4266           return error_mark_node;
4267         id_expr_token = token;
4268         token = cp_lexer_peek_token (parser->lexer);
4269         done = (token->type != CPP_OPEN_SQUARE
4270                 && token->type != CPP_OPEN_PAREN
4271                 && token->type != CPP_DOT
4272                 && token->type != CPP_DEREF