OSDN Git Service

2bd91ec96561bb99d571da6a94ade16dc61fa1a9
[pf3gnuchains/gcc-fork.git] / gcc / cp / parser.c
1 /* C++ Parser.
2    Copyright (C) 2000, 2001, 2002, 2003, 2004,
3    2005, 2007, 2008, 2009, 2010, 2011  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 void cp_parser_parse_tentatively
2253   (cp_parser *);
2254 static void cp_parser_commit_to_tentative_parse
2255   (cp_parser *);
2256 static void cp_parser_abort_tentative_parse
2257   (cp_parser *);
2258 static bool cp_parser_parse_definitely
2259   (cp_parser *);
2260 static inline bool cp_parser_parsing_tentatively
2261   (cp_parser *);
2262 static bool cp_parser_uncommitted_to_tentative_parse_p
2263   (cp_parser *);
2264 static void cp_parser_error
2265   (cp_parser *, const char *);
2266 static void cp_parser_name_lookup_error
2267   (cp_parser *, tree, tree, name_lookup_error, location_t);
2268 static bool cp_parser_simulate_error
2269   (cp_parser *);
2270 static bool cp_parser_check_type_definition
2271   (cp_parser *);
2272 static void cp_parser_check_for_definition_in_return_type
2273   (cp_declarator *, tree, location_t type_location);
2274 static void cp_parser_check_for_invalid_template_id
2275   (cp_parser *, tree, location_t location);
2276 static bool cp_parser_non_integral_constant_expression
2277   (cp_parser *, non_integral_constant);
2278 static void cp_parser_diagnose_invalid_type_name
2279   (cp_parser *, tree, tree, location_t);
2280 static bool cp_parser_parse_and_diagnose_invalid_type_name
2281   (cp_parser *);
2282 static int cp_parser_skip_to_closing_parenthesis
2283   (cp_parser *, bool, bool, bool);
2284 static void cp_parser_skip_to_end_of_statement
2285   (cp_parser *);
2286 static void cp_parser_consume_semicolon_at_end_of_statement
2287   (cp_parser *);
2288 static void cp_parser_skip_to_end_of_block_or_statement
2289   (cp_parser *);
2290 static bool cp_parser_skip_to_closing_brace
2291   (cp_parser *);
2292 static void cp_parser_skip_to_end_of_template_parameter_list
2293   (cp_parser *);
2294 static void cp_parser_skip_to_pragma_eol
2295   (cp_parser*, cp_token *);
2296 static bool cp_parser_error_occurred
2297   (cp_parser *);
2298 static bool cp_parser_allow_gnu_extensions_p
2299   (cp_parser *);
2300 static bool cp_parser_is_pure_string_literal
2301   (cp_token *);
2302 static bool cp_parser_is_string_literal
2303   (cp_token *);
2304 static bool cp_parser_is_keyword
2305   (cp_token *, enum rid);
2306 static tree cp_parser_make_typename_type
2307   (cp_parser *, tree, tree, location_t location);
2308 static cp_declarator * cp_parser_make_indirect_declarator
2309   (enum tree_code, tree, cp_cv_quals, cp_declarator *);
2310
2311 /* Returns nonzero if we are parsing tentatively.  */
2312
2313 static inline bool
2314 cp_parser_parsing_tentatively (cp_parser* parser)
2315 {
2316   return parser->context->next != NULL;
2317 }
2318
2319 /* Returns nonzero if TOKEN is a string literal.  */
2320
2321 static bool
2322 cp_parser_is_pure_string_literal (cp_token* token)
2323 {
2324   return (token->type == CPP_STRING ||
2325           token->type == CPP_STRING16 ||
2326           token->type == CPP_STRING32 ||
2327           token->type == CPP_WSTRING ||
2328           token->type == CPP_UTF8STRING);
2329 }
2330
2331 /* Returns nonzero if TOKEN is a string literal
2332    of a user-defined string literal.  */
2333
2334 static bool
2335 cp_parser_is_string_literal (cp_token* token)
2336 {
2337   return (cp_parser_is_pure_string_literal (token) ||
2338           token->type == CPP_STRING_USERDEF ||
2339           token->type == CPP_STRING16_USERDEF ||
2340           token->type == CPP_STRING32_USERDEF ||
2341           token->type == CPP_WSTRING_USERDEF ||
2342           token->type == CPP_UTF8STRING_USERDEF);
2343 }
2344
2345 /* Returns nonzero if TOKEN is the indicated KEYWORD.  */
2346
2347 static bool
2348 cp_parser_is_keyword (cp_token* token, enum rid keyword)
2349 {
2350   return token->keyword == keyword;
2351 }
2352
2353 /* If not parsing tentatively, issue a diagnostic of the form
2354       FILE:LINE: MESSAGE before TOKEN
2355    where TOKEN is the next token in the input stream.  MESSAGE
2356    (specified by the caller) is usually of the form "expected
2357    OTHER-TOKEN".  */
2358
2359 static void
2360 cp_parser_error (cp_parser* parser, const char* gmsgid)
2361 {
2362   if (!cp_parser_simulate_error (parser))
2363     {
2364       cp_token *token = cp_lexer_peek_token (parser->lexer);
2365       /* This diagnostic makes more sense if it is tagged to the line
2366          of the token we just peeked at.  */
2367       cp_lexer_set_source_position_from_token (token);
2368
2369       if (token->type == CPP_PRAGMA)
2370         {
2371           error_at (token->location,
2372                     "%<#pragma%> is not allowed here");
2373           cp_parser_skip_to_pragma_eol (parser, token);
2374           return;
2375         }
2376
2377       c_parse_error (gmsgid,
2378                      /* Because c_parser_error does not understand
2379                         CPP_KEYWORD, keywords are treated like
2380                         identifiers.  */
2381                      (token->type == CPP_KEYWORD ? CPP_NAME : token->type),
2382                      token->u.value, token->flags);
2383     }
2384 }
2385
2386 /* Issue an error about name-lookup failing.  NAME is the
2387    IDENTIFIER_NODE DECL is the result of
2388    the lookup (as returned from cp_parser_lookup_name).  DESIRED is
2389    the thing that we hoped to find.  */
2390
2391 static void
2392 cp_parser_name_lookup_error (cp_parser* parser,
2393                              tree name,
2394                              tree decl,
2395                              name_lookup_error desired,
2396                              location_t location)
2397 {
2398   /* If name lookup completely failed, tell the user that NAME was not
2399      declared.  */
2400   if (decl == error_mark_node)
2401     {
2402       if (parser->scope && parser->scope != global_namespace)
2403         error_at (location, "%<%E::%E%> has not been declared",
2404                   parser->scope, name);
2405       else if (parser->scope == global_namespace)
2406         error_at (location, "%<::%E%> has not been declared", name);
2407       else if (parser->object_scope
2408                && !CLASS_TYPE_P (parser->object_scope))
2409         error_at (location, "request for member %qE in non-class type %qT",
2410                   name, parser->object_scope);
2411       else if (parser->object_scope)
2412         error_at (location, "%<%T::%E%> has not been declared",
2413                   parser->object_scope, name);
2414       else
2415         error_at (location, "%qE has not been declared", name);
2416     }
2417   else if (parser->scope && parser->scope != global_namespace)
2418     {
2419       switch (desired)
2420         {
2421           case NLE_TYPE:
2422             error_at (location, "%<%E::%E%> is not a type",
2423                                 parser->scope, name);
2424             break;
2425           case NLE_CXX98:
2426             error_at (location, "%<%E::%E%> is not a class or namespace",
2427                                 parser->scope, name);
2428             break;
2429           case NLE_NOT_CXX98:
2430             error_at (location,
2431                       "%<%E::%E%> is not a class, namespace, or enumeration",
2432                       parser->scope, name);
2433             break;
2434           default:
2435             gcc_unreachable ();
2436             
2437         }
2438     }
2439   else if (parser->scope == global_namespace)
2440     {
2441       switch (desired)
2442         {
2443           case NLE_TYPE:
2444             error_at (location, "%<::%E%> is not a type", name);
2445             break;
2446           case NLE_CXX98:
2447             error_at (location, "%<::%E%> is not a class or namespace", name);
2448             break;
2449           case NLE_NOT_CXX98:
2450             error_at (location,
2451                       "%<::%E%> is not a class, namespace, or enumeration",
2452                       name);
2453             break;
2454           default:
2455             gcc_unreachable ();
2456         }
2457     }
2458   else
2459     {
2460       switch (desired)
2461         {
2462           case NLE_TYPE:
2463             error_at (location, "%qE is not a type", name);
2464             break;
2465           case NLE_CXX98:
2466             error_at (location, "%qE is not a class or namespace", name);
2467             break;
2468           case NLE_NOT_CXX98:
2469             error_at (location,
2470                       "%qE is not a class, namespace, or enumeration", name);
2471             break;
2472           default:
2473             gcc_unreachable ();
2474         }
2475     }
2476 }
2477
2478 /* If we are parsing tentatively, remember that an error has occurred
2479    during this tentative parse.  Returns true if the error was
2480    simulated; false if a message should be issued by the caller.  */
2481
2482 static bool
2483 cp_parser_simulate_error (cp_parser* parser)
2484 {
2485   if (cp_parser_uncommitted_to_tentative_parse_p (parser))
2486     {
2487       parser->context->status = CP_PARSER_STATUS_KIND_ERROR;
2488       return true;
2489     }
2490   return false;
2491 }
2492
2493 /* Check for repeated decl-specifiers.  */
2494
2495 static void
2496 cp_parser_check_decl_spec (cp_decl_specifier_seq *decl_specs,
2497                            location_t location)
2498 {
2499   int ds;
2500
2501   for (ds = ds_first; ds != ds_last; ++ds)
2502     {
2503       unsigned count = decl_specs->specs[ds];
2504       if (count < 2)
2505         continue;
2506       /* The "long" specifier is a special case because of "long long".  */
2507       if (ds == ds_long)
2508         {
2509           if (count > 2)
2510             error_at (location, "%<long long long%> is too long for GCC");
2511           else 
2512             pedwarn_cxx98 (location, OPT_Wlong_long, 
2513                            "ISO C++ 1998 does not support %<long long%>");
2514         }
2515       else if (count > 1)
2516         {
2517           static const char *const decl_spec_names[] = {
2518             "signed",
2519             "unsigned",
2520             "short",
2521             "long",
2522             "const",
2523             "volatile",
2524             "restrict",
2525             "inline",
2526             "virtual",
2527             "explicit",
2528             "friend",
2529             "typedef",
2530             "using",
2531             "constexpr",
2532             "__complex",
2533             "__thread"
2534           };
2535           error_at (location, "duplicate %qs", decl_spec_names[ds]);
2536         }
2537     }
2538 }
2539
2540 /* This function is called when a type is defined.  If type
2541    definitions are forbidden at this point, an error message is
2542    issued.  */
2543
2544 static bool
2545 cp_parser_check_type_definition (cp_parser* parser)
2546 {
2547   /* If types are forbidden here, issue a message.  */
2548   if (parser->type_definition_forbidden_message)
2549     {
2550       /* Don't use `%s' to print the string, because quotations (`%<', `%>')
2551          in the message need to be interpreted.  */
2552       error (parser->type_definition_forbidden_message);
2553       return false;
2554     }
2555   return true;
2556 }
2557
2558 /* This function is called when the DECLARATOR is processed.  The TYPE
2559    was a type defined in the decl-specifiers.  If it is invalid to
2560    define a type in the decl-specifiers for DECLARATOR, an error is
2561    issued. TYPE_LOCATION is the location of TYPE and is used
2562    for error reporting.  */
2563
2564 static void
2565 cp_parser_check_for_definition_in_return_type (cp_declarator *declarator,
2566                                                tree type, location_t type_location)
2567 {
2568   /* [dcl.fct] forbids type definitions in return types.
2569      Unfortunately, it's not easy to know whether or not we are
2570      processing a return type until after the fact.  */
2571   while (declarator
2572          && (declarator->kind == cdk_pointer
2573              || declarator->kind == cdk_reference
2574              || declarator->kind == cdk_ptrmem))
2575     declarator = declarator->declarator;
2576   if (declarator
2577       && declarator->kind == cdk_function)
2578     {
2579       error_at (type_location,
2580                 "new types may not be defined in a return type");
2581       inform (type_location, 
2582               "(perhaps a semicolon is missing after the definition of %qT)",
2583               type);
2584     }
2585 }
2586
2587 /* A type-specifier (TYPE) has been parsed which cannot be followed by
2588    "<" in any valid C++ program.  If the next token is indeed "<",
2589    issue a message warning the user about what appears to be an
2590    invalid attempt to form a template-id. LOCATION is the location
2591    of the type-specifier (TYPE) */
2592
2593 static void
2594 cp_parser_check_for_invalid_template_id (cp_parser* parser,
2595                                          tree type, location_t location)
2596 {
2597   cp_token_position start = 0;
2598
2599   if (cp_lexer_next_token_is (parser->lexer, CPP_LESS))
2600     {
2601       if (TYPE_P (type))
2602         error_at (location, "%qT is not a template", type);
2603       else if (TREE_CODE (type) == IDENTIFIER_NODE)
2604         error_at (location, "%qE is not a template", type);
2605       else
2606         error_at (location, "invalid template-id");
2607       /* Remember the location of the invalid "<".  */
2608       if (cp_parser_uncommitted_to_tentative_parse_p (parser))
2609         start = cp_lexer_token_position (parser->lexer, true);
2610       /* Consume the "<".  */
2611       cp_lexer_consume_token (parser->lexer);
2612       /* Parse the template arguments.  */
2613       cp_parser_enclosed_template_argument_list (parser);
2614       /* Permanently remove the invalid template arguments so that
2615          this error message is not issued again.  */
2616       if (start)
2617         cp_lexer_purge_tokens_after (parser->lexer, start);
2618     }
2619 }
2620
2621 /* If parsing an integral constant-expression, issue an error message
2622    about the fact that THING appeared and return true.  Otherwise,
2623    return false.  In either case, set
2624    PARSER->NON_INTEGRAL_CONSTANT_EXPRESSION_P.  */
2625
2626 static bool
2627 cp_parser_non_integral_constant_expression (cp_parser  *parser,
2628                                             non_integral_constant thing)
2629 {
2630   parser->non_integral_constant_expression_p = true;
2631   if (parser->integral_constant_expression_p)
2632     {
2633       if (!parser->allow_non_integral_constant_expression_p)
2634         {
2635           const char *msg = NULL;
2636           switch (thing)
2637             {
2638               case NIC_FLOAT:
2639                 error ("floating-point literal "
2640                        "cannot appear in a constant-expression");
2641                 return true;
2642               case NIC_CAST:
2643                 error ("a cast to a type other than an integral or "
2644                        "enumeration type cannot appear in a "
2645                        "constant-expression");
2646                 return true;
2647               case NIC_TYPEID:
2648                 error ("%<typeid%> operator "
2649                        "cannot appear in a constant-expression");
2650                 return true;
2651               case NIC_NCC:
2652                 error ("non-constant compound literals "
2653                        "cannot appear in a constant-expression");
2654                 return true;
2655               case NIC_FUNC_CALL:
2656                 error ("a function call "
2657                        "cannot appear in a constant-expression");
2658                 return true;
2659               case NIC_INC:
2660                 error ("an increment "
2661                        "cannot appear in a constant-expression");
2662                 return true;
2663               case NIC_DEC:
2664                 error ("an decrement "
2665                        "cannot appear in a constant-expression");
2666                 return true;
2667               case NIC_ARRAY_REF:
2668                 error ("an array reference "
2669                        "cannot appear in a constant-expression");
2670                 return true;
2671               case NIC_ADDR_LABEL:
2672                 error ("the address of a label "
2673                        "cannot appear in a constant-expression");
2674                 return true;
2675               case NIC_OVERLOADED:
2676                 error ("calls to overloaded operators "
2677                        "cannot appear in a constant-expression");
2678                 return true;
2679               case NIC_ASSIGNMENT:
2680                 error ("an assignment cannot appear in a constant-expression");
2681                 return true;
2682               case NIC_COMMA:
2683                 error ("a comma operator "
2684                        "cannot appear in a constant-expression");
2685                 return true;
2686               case NIC_CONSTRUCTOR:
2687                 error ("a call to a constructor "
2688                        "cannot appear in a constant-expression");
2689                 return true;
2690               case NIC_TRANSACTION:
2691                 error ("a transaction expression "
2692                        "cannot appear in a constant-expression");
2693                 return true;
2694               case NIC_THIS:
2695                 msg = "this";
2696                 break;
2697               case NIC_FUNC_NAME:
2698                 msg = "__FUNCTION__";
2699                 break;
2700               case NIC_PRETTY_FUNC:
2701                 msg = "__PRETTY_FUNCTION__";
2702                 break;
2703               case NIC_C99_FUNC:
2704                 msg = "__func__";
2705                 break;
2706               case NIC_VA_ARG:
2707                 msg = "va_arg";
2708                 break;
2709               case NIC_ARROW:
2710                 msg = "->";
2711                 break;
2712               case NIC_POINT:
2713                 msg = ".";
2714                 break;
2715               case NIC_STAR:
2716                 msg = "*";
2717                 break;
2718               case NIC_ADDR:
2719                 msg = "&";
2720                 break;
2721               case NIC_PREINCREMENT:
2722                 msg = "++";
2723                 break;
2724               case NIC_PREDECREMENT:
2725                 msg = "--";
2726                 break;
2727               case NIC_NEW:
2728                 msg = "new";
2729                 break;
2730               case NIC_DEL:
2731                 msg = "delete";
2732                 break;
2733               default:
2734                 gcc_unreachable ();
2735             }
2736           if (msg)
2737             error ("%qs cannot appear in a constant-expression", msg);
2738           return true;
2739         }
2740     }
2741   return false;
2742 }
2743
2744 /* Emit a diagnostic for an invalid type name.  SCOPE is the
2745    qualifying scope (or NULL, if none) for ID.  This function commits
2746    to the current active tentative parse, if any.  (Otherwise, the
2747    problematic construct might be encountered again later, resulting
2748    in duplicate error messages.) LOCATION is the location of ID.  */
2749
2750 static void
2751 cp_parser_diagnose_invalid_type_name (cp_parser *parser,
2752                                       tree scope, tree id,
2753                                       location_t location)
2754 {
2755   tree decl, old_scope;
2756   cp_parser_commit_to_tentative_parse (parser);
2757   /* Try to lookup the identifier.  */
2758   old_scope = parser->scope;
2759   parser->scope = scope;
2760   decl = cp_parser_lookup_name_simple (parser, id, location);
2761   parser->scope = old_scope;
2762   /* If the lookup found a template-name, it means that the user forgot
2763   to specify an argument list. Emit a useful error message.  */
2764   if (TREE_CODE (decl) == TEMPLATE_DECL)
2765     error_at (location,
2766               "invalid use of template-name %qE without an argument list",
2767               decl);
2768   else if (TREE_CODE (id) == BIT_NOT_EXPR)
2769     error_at (location, "invalid use of destructor %qD as a type", id);
2770   else if (TREE_CODE (decl) == TYPE_DECL)
2771     /* Something like 'unsigned A a;'  */
2772     error_at (location, "invalid combination of multiple type-specifiers");
2773   else if (!parser->scope)
2774     {
2775       /* Issue an error message.  */
2776       error_at (location, "%qE does not name a type", id);
2777       /* If we're in a template class, it's possible that the user was
2778          referring to a type from a base class.  For example:
2779
2780            template <typename T> struct A { typedef T X; };
2781            template <typename T> struct B : public A<T> { X x; };
2782
2783          The user should have said "typename A<T>::X".  */
2784       if (cxx_dialect < cxx0x && id == ridpointers[(int)RID_CONSTEXPR])
2785         inform (location, "C++11 %<constexpr%> only available with "
2786                 "-std=c++11 or -std=gnu++11");
2787       else if (processing_template_decl && current_class_type
2788                && TYPE_BINFO (current_class_type))
2789         {
2790           tree b;
2791
2792           for (b = TREE_CHAIN (TYPE_BINFO (current_class_type));
2793                b;
2794                b = TREE_CHAIN (b))
2795             {
2796               tree base_type = BINFO_TYPE (b);
2797               if (CLASS_TYPE_P (base_type)
2798                   && dependent_type_p (base_type))
2799                 {
2800                   tree field;
2801                   /* Go from a particular instantiation of the
2802                      template (which will have an empty TYPE_FIELDs),
2803                      to the main version.  */
2804                   base_type = CLASSTYPE_PRIMARY_TEMPLATE_TYPE (base_type);
2805                   for (field = TYPE_FIELDS (base_type);
2806                        field;
2807                        field = DECL_CHAIN (field))
2808                     if (TREE_CODE (field) == TYPE_DECL
2809                         && DECL_NAME (field) == id)
2810                       {
2811                         inform (location, 
2812                                 "(perhaps %<typename %T::%E%> was intended)",
2813                                 BINFO_TYPE (b), id);
2814                         break;
2815                       }
2816                   if (field)
2817                     break;
2818                 }
2819             }
2820         }
2821     }
2822   /* Here we diagnose qualified-ids where the scope is actually correct,
2823      but the identifier does not resolve to a valid type name.  */
2824   else if (parser->scope != error_mark_node)
2825     {
2826       if (TREE_CODE (parser->scope) == NAMESPACE_DECL)
2827         error_at (location, "%qE in namespace %qE does not name a type",
2828                   id, parser->scope);
2829       else if (CLASS_TYPE_P (parser->scope)
2830                && constructor_name_p (id, parser->scope))
2831         {
2832           /* A<T>::A<T>() */
2833           error_at (location, "%<%T::%E%> names the constructor, not"
2834                     " the type", parser->scope, id);
2835           if (cp_lexer_next_token_is (parser->lexer, CPP_LESS))
2836             error_at (location, "and %qT has no template constructors",
2837                       parser->scope);
2838         }
2839       else if (TYPE_P (parser->scope)
2840                && dependent_scope_p (parser->scope))
2841         error_at (location, "need %<typename%> before %<%T::%E%> because "
2842                   "%qT is a dependent scope",
2843                   parser->scope, id, parser->scope);
2844       else if (TYPE_P (parser->scope))
2845         error_at (location, "%qE in %q#T does not name a type",
2846                   id, parser->scope);
2847       else
2848         gcc_unreachable ();
2849     }
2850 }
2851
2852 /* Check for a common situation where a type-name should be present,
2853    but is not, and issue a sensible error message.  Returns true if an
2854    invalid type-name was detected.
2855
2856    The situation handled by this function are variable declarations of the
2857    form `ID a', where `ID' is an id-expression and `a' is a plain identifier.
2858    Usually, `ID' should name a type, but if we got here it means that it
2859    does not. We try to emit the best possible error message depending on
2860    how exactly the id-expression looks like.  */
2861
2862 static bool
2863 cp_parser_parse_and_diagnose_invalid_type_name (cp_parser *parser)
2864 {
2865   tree id;
2866   cp_token *token = cp_lexer_peek_token (parser->lexer);
2867
2868   /* Avoid duplicate error about ambiguous lookup.  */
2869   if (token->type == CPP_NESTED_NAME_SPECIFIER)
2870     {
2871       cp_token *next = cp_lexer_peek_nth_token (parser->lexer, 2);
2872       if (next->type == CPP_NAME && next->ambiguous_p)
2873         goto out;
2874     }
2875
2876   cp_parser_parse_tentatively (parser);
2877   id = cp_parser_id_expression (parser,
2878                                 /*template_keyword_p=*/false,
2879                                 /*check_dependency_p=*/true,
2880                                 /*template_p=*/NULL,
2881                                 /*declarator_p=*/true,
2882                                 /*optional_p=*/false);
2883   /* If the next token is a (, this is a function with no explicit return
2884      type, i.e. constructor, destructor or conversion op.  */
2885   if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN)
2886       || TREE_CODE (id) == TYPE_DECL)
2887     {
2888       cp_parser_abort_tentative_parse (parser);
2889       return false;
2890     }
2891   if (!cp_parser_parse_definitely (parser))
2892     return false;
2893
2894   /* Emit a diagnostic for the invalid type.  */
2895   cp_parser_diagnose_invalid_type_name (parser, parser->scope,
2896                                         id, token->location);
2897  out:
2898   /* If we aren't in the middle of a declarator (i.e. in a
2899      parameter-declaration-clause), skip to the end of the declaration;
2900      there's no point in trying to process it.  */
2901   if (!parser->in_declarator_p)
2902     cp_parser_skip_to_end_of_block_or_statement (parser);
2903   return true;
2904 }
2905
2906 /* Consume tokens up to, and including, the next non-nested closing `)'.
2907    Returns 1 iff we found a closing `)'.  RECOVERING is true, if we
2908    are doing error recovery. Returns -1 if OR_COMMA is true and we
2909    found an unnested comma.  */
2910
2911 static int
2912 cp_parser_skip_to_closing_parenthesis (cp_parser *parser,
2913                                        bool recovering,
2914                                        bool or_comma,
2915                                        bool consume_paren)
2916 {
2917   unsigned paren_depth = 0;
2918   unsigned brace_depth = 0;
2919   unsigned square_depth = 0;
2920
2921   if (recovering && !or_comma
2922       && cp_parser_uncommitted_to_tentative_parse_p (parser))
2923     return 0;
2924
2925   while (true)
2926     {
2927       cp_token * token = cp_lexer_peek_token (parser->lexer);
2928
2929       switch (token->type)
2930         {
2931         case CPP_EOF:
2932         case CPP_PRAGMA_EOL:
2933           /* If we've run out of tokens, then there is no closing `)'.  */
2934           return 0;
2935
2936         /* This is good for lambda expression capture-lists.  */
2937         case CPP_OPEN_SQUARE:
2938           ++square_depth;
2939           break;
2940         case CPP_CLOSE_SQUARE:
2941           if (!square_depth--)
2942             return 0;
2943           break;
2944
2945         case CPP_SEMICOLON:
2946           /* This matches the processing in skip_to_end_of_statement.  */
2947           if (!brace_depth)
2948             return 0;
2949           break;
2950
2951         case CPP_OPEN_BRACE:
2952           ++brace_depth;
2953           break;
2954         case CPP_CLOSE_BRACE:
2955           if (!brace_depth--)
2956             return 0;
2957           break;
2958
2959         case CPP_COMMA:
2960           if (recovering && or_comma && !brace_depth && !paren_depth
2961               && !square_depth)
2962             return -1;
2963           break;
2964
2965         case CPP_OPEN_PAREN:
2966           if (!brace_depth)
2967             ++paren_depth;
2968           break;
2969
2970         case CPP_CLOSE_PAREN:
2971           if (!brace_depth && !paren_depth--)
2972             {
2973               if (consume_paren)
2974                 cp_lexer_consume_token (parser->lexer);
2975               return 1;
2976             }
2977           break;
2978
2979         default:
2980           break;
2981         }
2982
2983       /* Consume the token.  */
2984       cp_lexer_consume_token (parser->lexer);
2985     }
2986 }
2987
2988 /* Consume tokens until we reach the end of the current statement.
2989    Normally, that will be just before consuming a `;'.  However, if a
2990    non-nested `}' comes first, then we stop before consuming that.  */
2991
2992 static void
2993 cp_parser_skip_to_end_of_statement (cp_parser* parser)
2994 {
2995   unsigned nesting_depth = 0;
2996
2997   while (true)
2998     {
2999       cp_token *token = cp_lexer_peek_token (parser->lexer);
3000
3001       switch (token->type)
3002         {
3003         case CPP_EOF:
3004         case CPP_PRAGMA_EOL:
3005           /* If we've run out of tokens, stop.  */
3006           return;
3007
3008         case CPP_SEMICOLON:
3009           /* If the next token is a `;', we have reached the end of the
3010              statement.  */
3011           if (!nesting_depth)
3012             return;
3013           break;
3014
3015         case CPP_CLOSE_BRACE:
3016           /* If this is a non-nested '}', stop before consuming it.
3017              That way, when confronted with something like:
3018
3019                { 3 + }
3020
3021              we stop before consuming the closing '}', even though we
3022              have not yet reached a `;'.  */
3023           if (nesting_depth == 0)
3024             return;
3025
3026           /* If it is the closing '}' for a block that we have
3027              scanned, stop -- but only after consuming the token.
3028              That way given:
3029
3030                 void f g () { ... }
3031                 typedef int I;
3032
3033              we will stop after the body of the erroneously declared
3034              function, but before consuming the following `typedef'
3035              declaration.  */
3036           if (--nesting_depth == 0)
3037             {
3038               cp_lexer_consume_token (parser->lexer);
3039               return;
3040             }
3041
3042         case CPP_OPEN_BRACE:
3043           ++nesting_depth;
3044           break;
3045
3046         default:
3047           break;
3048         }
3049
3050       /* Consume the token.  */
3051       cp_lexer_consume_token (parser->lexer);
3052     }
3053 }
3054
3055 /* This function is called at the end of a statement or declaration.
3056    If the next token is a semicolon, it is consumed; otherwise, error
3057    recovery is attempted.  */
3058
3059 static void
3060 cp_parser_consume_semicolon_at_end_of_statement (cp_parser *parser)
3061 {
3062   /* Look for the trailing `;'.  */
3063   if (!cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON))
3064     {
3065       /* If there is additional (erroneous) input, skip to the end of
3066          the statement.  */
3067       cp_parser_skip_to_end_of_statement (parser);
3068       /* If the next token is now a `;', consume it.  */
3069       if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
3070         cp_lexer_consume_token (parser->lexer);
3071     }
3072 }
3073
3074 /* Skip tokens until we have consumed an entire block, or until we
3075    have consumed a non-nested `;'.  */
3076
3077 static void
3078 cp_parser_skip_to_end_of_block_or_statement (cp_parser* parser)
3079 {
3080   int nesting_depth = 0;
3081
3082   while (nesting_depth >= 0)
3083     {
3084       cp_token *token = cp_lexer_peek_token (parser->lexer);
3085
3086       switch (token->type)
3087         {
3088         case CPP_EOF:
3089         case CPP_PRAGMA_EOL:
3090           /* If we've run out of tokens, stop.  */
3091           return;
3092
3093         case CPP_SEMICOLON:
3094           /* Stop if this is an unnested ';'. */
3095           if (!nesting_depth)
3096             nesting_depth = -1;
3097           break;
3098
3099         case CPP_CLOSE_BRACE:
3100           /* Stop if this is an unnested '}', or closes the outermost
3101              nesting level.  */
3102           nesting_depth--;
3103           if (nesting_depth < 0)
3104             return;
3105           if (!nesting_depth)
3106             nesting_depth = -1;
3107           break;
3108
3109         case CPP_OPEN_BRACE:
3110           /* Nest. */
3111           nesting_depth++;
3112           break;
3113
3114         default:
3115           break;
3116         }
3117
3118       /* Consume the token.  */
3119       cp_lexer_consume_token (parser->lexer);
3120     }
3121 }
3122
3123 /* Skip tokens until a non-nested closing curly brace is the next
3124    token, or there are no more tokens. Return true in the first case,
3125    false otherwise.  */
3126
3127 static bool
3128 cp_parser_skip_to_closing_brace (cp_parser *parser)
3129 {
3130   unsigned nesting_depth = 0;
3131
3132   while (true)
3133     {
3134       cp_token *token = cp_lexer_peek_token (parser->lexer);
3135
3136       switch (token->type)
3137         {
3138         case CPP_EOF:
3139         case CPP_PRAGMA_EOL:
3140           /* If we've run out of tokens, stop.  */
3141           return false;
3142
3143         case CPP_CLOSE_BRACE:
3144           /* If the next token is a non-nested `}', then we have reached
3145              the end of the current block.  */
3146           if (nesting_depth-- == 0)
3147             return true;
3148           break;
3149
3150         case CPP_OPEN_BRACE:
3151           /* If it the next token is a `{', then we are entering a new
3152              block.  Consume the entire block.  */
3153           ++nesting_depth;
3154           break;
3155
3156         default:
3157           break;
3158         }
3159
3160       /* Consume the token.  */
3161       cp_lexer_consume_token (parser->lexer);
3162     }
3163 }
3164
3165 /* Consume tokens until we reach the end of the pragma.  The PRAGMA_TOK
3166    parameter is the PRAGMA token, allowing us to purge the entire pragma
3167    sequence.  */
3168
3169 static void
3170 cp_parser_skip_to_pragma_eol (cp_parser* parser, cp_token *pragma_tok)
3171 {
3172   cp_token *token;
3173
3174   parser->lexer->in_pragma = false;
3175
3176   do
3177     token = cp_lexer_consume_token (parser->lexer);
3178   while (token->type != CPP_PRAGMA_EOL && token->type != CPP_EOF);
3179
3180   /* Ensure that the pragma is not parsed again.  */
3181   cp_lexer_purge_tokens_after (parser->lexer, pragma_tok);
3182 }
3183
3184 /* Require pragma end of line, resyncing with it as necessary.  The
3185    arguments are as for cp_parser_skip_to_pragma_eol.  */
3186
3187 static void
3188 cp_parser_require_pragma_eol (cp_parser *parser, cp_token *pragma_tok)
3189 {
3190   parser->lexer->in_pragma = false;
3191   if (!cp_parser_require (parser, CPP_PRAGMA_EOL, RT_PRAGMA_EOL))
3192     cp_parser_skip_to_pragma_eol (parser, pragma_tok);
3193 }
3194
3195 /* This is a simple wrapper around make_typename_type. When the id is
3196    an unresolved identifier node, we can provide a superior diagnostic
3197    using cp_parser_diagnose_invalid_type_name.  */
3198
3199 static tree
3200 cp_parser_make_typename_type (cp_parser *parser, tree scope,
3201                               tree id, location_t id_location)
3202 {
3203   tree result;
3204   if (TREE_CODE (id) == IDENTIFIER_NODE)
3205     {
3206       result = make_typename_type (scope, id, typename_type,
3207                                    /*complain=*/tf_none);
3208       if (result == error_mark_node)
3209         cp_parser_diagnose_invalid_type_name (parser, scope, id, id_location);
3210       return result;
3211     }
3212   return make_typename_type (scope, id, typename_type, tf_error);
3213 }
3214
3215 /* This is a wrapper around the
3216    make_{pointer,ptrmem,reference}_declarator functions that decides
3217    which one to call based on the CODE and CLASS_TYPE arguments. The
3218    CODE argument should be one of the values returned by
3219    cp_parser_ptr_operator. */
3220 static cp_declarator *
3221 cp_parser_make_indirect_declarator (enum tree_code code, tree class_type,
3222                                     cp_cv_quals cv_qualifiers,
3223                                     cp_declarator *target)
3224 {
3225   if (code == ERROR_MARK)
3226     return cp_error_declarator;
3227
3228   if (code == INDIRECT_REF)
3229     if (class_type == NULL_TREE)
3230       return make_pointer_declarator (cv_qualifiers, target);
3231     else
3232       return make_ptrmem_declarator (cv_qualifiers, class_type, target);
3233   else if (code == ADDR_EXPR && class_type == NULL_TREE)
3234     return make_reference_declarator (cv_qualifiers, target, false);
3235   else if (code == NON_LVALUE_EXPR && class_type == NULL_TREE)
3236     return make_reference_declarator (cv_qualifiers, target, true);
3237   gcc_unreachable ();
3238 }
3239
3240 /* Create a new C++ parser.  */
3241
3242 static cp_parser *
3243 cp_parser_new (void)
3244 {
3245   cp_parser *parser;
3246   cp_lexer *lexer;
3247   unsigned i;
3248
3249   /* cp_lexer_new_main is called before doing GC allocation because
3250      cp_lexer_new_main might load a PCH file.  */
3251   lexer = cp_lexer_new_main ();
3252
3253   /* Initialize the binops_by_token so that we can get the tree
3254      directly from the token.  */
3255   for (i = 0; i < sizeof (binops) / sizeof (binops[0]); i++)
3256     binops_by_token[binops[i].token_type] = binops[i];
3257
3258   parser = ggc_alloc_cleared_cp_parser ();
3259   parser->lexer = lexer;
3260   parser->context = cp_parser_context_new (NULL);
3261
3262   /* For now, we always accept GNU extensions.  */
3263   parser->allow_gnu_extensions_p = 1;
3264
3265   /* The `>' token is a greater-than operator, not the end of a
3266      template-id.  */
3267   parser->greater_than_is_operator_p = true;
3268
3269   parser->default_arg_ok_p = true;
3270
3271   /* We are not parsing a constant-expression.  */
3272   parser->integral_constant_expression_p = false;
3273   parser->allow_non_integral_constant_expression_p = false;
3274   parser->non_integral_constant_expression_p = false;
3275
3276   /* Local variable names are not forbidden.  */
3277   parser->local_variables_forbidden_p = false;
3278
3279   /* We are not processing an `extern "C"' declaration.  */
3280   parser->in_unbraced_linkage_specification_p = false;
3281
3282   /* We are not processing a declarator.  */
3283   parser->in_declarator_p = false;
3284
3285   /* We are not processing a template-argument-list.  */
3286   parser->in_template_argument_list_p = false;
3287
3288   /* We are not in an iteration statement.  */
3289   parser->in_statement = 0;
3290
3291   /* We are not in a switch statement.  */
3292   parser->in_switch_statement_p = false;
3293
3294   /* We are not parsing a type-id inside an expression.  */
3295   parser->in_type_id_in_expr_p = false;
3296
3297   /* Declarations aren't implicitly extern "C".  */
3298   parser->implicit_extern_c = false;
3299
3300   /* String literals should be translated to the execution character set.  */
3301   parser->translate_strings_p = true;
3302
3303   /* We are not parsing a function body.  */
3304   parser->in_function_body = false;
3305
3306   /* We can correct until told otherwise.  */
3307   parser->colon_corrects_to_scope_p = true;
3308
3309   /* The unparsed function queue is empty.  */
3310   push_unparsed_function_queues (parser);
3311
3312   /* There are no classes being defined.  */
3313   parser->num_classes_being_defined = 0;
3314
3315   /* No template parameters apply.  */
3316   parser->num_template_parameter_lists = 0;
3317
3318   return parser;
3319 }
3320
3321 /* Create a cp_lexer structure which will emit the tokens in CACHE
3322    and push it onto the parser's lexer stack.  This is used for delayed
3323    parsing of in-class method bodies and default arguments, and should
3324    not be confused with tentative parsing.  */
3325 static void
3326 cp_parser_push_lexer_for_tokens (cp_parser *parser, cp_token_cache *cache)
3327 {
3328   cp_lexer *lexer = cp_lexer_new_from_tokens (cache);
3329   lexer->next = parser->lexer;
3330   parser->lexer = lexer;
3331
3332   /* Move the current source position to that of the first token in the
3333      new lexer.  */
3334   cp_lexer_set_source_position_from_token (lexer->next_token);
3335 }
3336
3337 /* Pop the top lexer off the parser stack.  This is never used for the
3338    "main" lexer, only for those pushed by cp_parser_push_lexer_for_tokens.  */
3339 static void
3340 cp_parser_pop_lexer (cp_parser *parser)
3341 {
3342   cp_lexer *lexer = parser->lexer;
3343   parser->lexer = lexer->next;
3344   cp_lexer_destroy (lexer);
3345
3346   /* Put the current source position back where it was before this
3347      lexer was pushed.  */
3348   cp_lexer_set_source_position_from_token (parser->lexer->next_token);
3349 }
3350
3351 /* Lexical conventions [gram.lex]  */
3352
3353 /* Parse an identifier.  Returns an IDENTIFIER_NODE representing the
3354    identifier.  */
3355
3356 static tree
3357 cp_parser_identifier (cp_parser* parser)
3358 {
3359   cp_token *token;
3360
3361   /* Look for the identifier.  */
3362   token = cp_parser_require (parser, CPP_NAME, RT_NAME);
3363   /* Return the value.  */
3364   return token ? token->u.value : error_mark_node;
3365 }
3366
3367 /* Parse a sequence of adjacent string constants.  Returns a
3368    TREE_STRING representing the combined, nul-terminated string
3369    constant.  If TRANSLATE is true, translate the string to the
3370    execution character set.  If WIDE_OK is true, a wide string is
3371    invalid here.
3372
3373    C++98 [lex.string] says that if a narrow string literal token is
3374    adjacent to a wide string literal token, the behavior is undefined.
3375    However, C99 6.4.5p4 says that this results in a wide string literal.
3376    We follow C99 here, for consistency with the C front end.
3377
3378    This code is largely lifted from lex_string() in c-lex.c.
3379
3380    FUTURE: ObjC++ will need to handle @-strings here.  */
3381 static tree
3382 cp_parser_string_literal (cp_parser *parser, bool translate, bool wide_ok)
3383 {
3384   tree value;
3385   size_t count;
3386   struct obstack str_ob;
3387   cpp_string str, istr, *strs;
3388   cp_token *tok;
3389   enum cpp_ttype type, curr_type;
3390   int have_suffix_p = 0;
3391   tree string_tree;
3392   tree suffix_id = NULL_TREE;
3393   bool curr_tok_is_userdef_p = false;
3394
3395   tok = cp_lexer_peek_token (parser->lexer);
3396   if (!cp_parser_is_string_literal (tok))
3397     {
3398       cp_parser_error (parser, "expected string-literal");
3399       return error_mark_node;
3400     }
3401
3402   if (cpp_userdef_string_p (tok->type))
3403     {
3404       string_tree = USERDEF_LITERAL_VALUE (tok->u.value);
3405       curr_type = cpp_userdef_string_remove_type (tok->type);
3406       curr_tok_is_userdef_p = true;
3407     }
3408   else
3409     {
3410       string_tree = tok->u.value;
3411       curr_type = tok->type;
3412     }
3413   type = curr_type;
3414
3415   /* Try to avoid the overhead of creating and destroying an obstack
3416      for the common case of just one string.  */
3417   if (!cp_parser_is_string_literal
3418       (cp_lexer_peek_nth_token (parser->lexer, 2)))
3419     {
3420       cp_lexer_consume_token (parser->lexer);
3421
3422       str.text = (const unsigned char *)TREE_STRING_POINTER (string_tree);
3423       str.len = TREE_STRING_LENGTH (string_tree);
3424       count = 1;
3425
3426       if (curr_tok_is_userdef_p)
3427         {
3428           suffix_id = USERDEF_LITERAL_SUFFIX_ID (tok->u.value);
3429           have_suffix_p = 1;
3430           curr_type = cpp_userdef_string_remove_type (tok->type);
3431         }
3432       else
3433         curr_type = tok->type;
3434
3435       strs = &str;
3436     }
3437   else
3438     {
3439       gcc_obstack_init (&str_ob);
3440       count = 0;
3441
3442       do
3443         {
3444           cp_lexer_consume_token (parser->lexer);
3445           count++;
3446           str.text = (const unsigned char *)TREE_STRING_POINTER (string_tree);
3447           str.len = TREE_STRING_LENGTH (string_tree);
3448
3449           if (curr_tok_is_userdef_p)
3450             {
3451               tree curr_suffix_id = USERDEF_LITERAL_SUFFIX_ID (tok->u.value);
3452               if (have_suffix_p == 0)
3453                 {
3454                   suffix_id = curr_suffix_id;
3455                   have_suffix_p = 1;
3456                 }
3457               else if (have_suffix_p == 1
3458                        && curr_suffix_id != suffix_id)
3459                 {
3460                   error ("inconsistent user-defined literal suffixes"
3461                          " %qD and %qD in string literal",
3462                          suffix_id, curr_suffix_id);
3463                   have_suffix_p = -1;
3464                 }
3465               curr_type = cpp_userdef_string_remove_type (tok->type);
3466             }
3467           else
3468             curr_type = tok->type;
3469
3470           if (type != curr_type)
3471             {
3472               if (type == CPP_STRING)
3473                 type = curr_type;
3474               else if (curr_type != CPP_STRING)
3475                 error_at (tok->location,
3476                           "unsupported non-standard concatenation "
3477                           "of string literals");
3478             }
3479
3480           obstack_grow (&str_ob, &str, sizeof (cpp_string));
3481
3482           tok = cp_lexer_peek_token (parser->lexer);
3483           if (cpp_userdef_string_p (tok->type))
3484             {
3485               string_tree = USERDEF_LITERAL_VALUE (tok->u.value);
3486               curr_type = cpp_userdef_string_remove_type (tok->type);
3487               curr_tok_is_userdef_p = true;
3488             }
3489           else
3490             {
3491               string_tree = tok->u.value;
3492               curr_type = tok->type;
3493               curr_tok_is_userdef_p = false;
3494             }
3495         }
3496       while (cp_parser_is_string_literal (tok));
3497
3498       strs = (cpp_string *) obstack_finish (&str_ob);
3499     }
3500
3501   if (type != CPP_STRING && !wide_ok)
3502     {
3503       cp_parser_error (parser, "a wide string is invalid in this context");
3504       type = CPP_STRING;
3505     }
3506
3507   if ((translate ? cpp_interpret_string : cpp_interpret_string_notranslate)
3508       (parse_in, strs, count, &istr, type))
3509     {
3510       value = build_string (istr.len, (const char *)istr.text);
3511       free (CONST_CAST (unsigned char *, istr.text));
3512
3513       switch (type)
3514         {
3515         default:
3516         case CPP_STRING:
3517         case CPP_UTF8STRING:
3518           TREE_TYPE (value) = char_array_type_node;
3519           break;
3520         case CPP_STRING16:
3521           TREE_TYPE (value) = char16_array_type_node;
3522           break;
3523         case CPP_STRING32:
3524           TREE_TYPE (value) = char32_array_type_node;
3525           break;
3526         case CPP_WSTRING:
3527           TREE_TYPE (value) = wchar_array_type_node;
3528           break;
3529         }
3530
3531       value = fix_string_type (value);
3532
3533       if (have_suffix_p)
3534         {
3535           tree literal = build_userdef_literal (suffix_id, value, NULL_TREE);
3536           tok->u.value = literal;
3537           return cp_parser_userdef_string_literal (tok);
3538         }
3539     }
3540   else
3541     /* cpp_interpret_string has issued an error.  */
3542     value = error_mark_node;
3543
3544   if (count > 1)
3545     obstack_free (&str_ob, 0);
3546
3547   return value;
3548 }
3549
3550 /* Look up a literal operator with the name and the exact arguments.  */
3551
3552 static tree
3553 lookup_literal_operator (tree name, VEC(tree,gc) *args)
3554 {
3555   tree decl, fns;
3556   decl = lookup_name (name);
3557   if (!decl || !is_overloaded_fn (decl))
3558     return error_mark_node;
3559
3560   for (fns = decl; fns; fns = OVL_NEXT (fns))
3561     {
3562       unsigned int ix;
3563       bool found = true;
3564       tree fn = OVL_CURRENT (fns);
3565       tree argtypes = NULL_TREE;
3566       argtypes = TYPE_ARG_TYPES (TREE_TYPE (fn));
3567       if (argtypes != NULL_TREE)
3568         {
3569           for (ix = 0; ix < VEC_length (tree, args) && argtypes != NULL_TREE;
3570                ++ix, argtypes = TREE_CHAIN (argtypes))
3571             {
3572               tree targ = TREE_VALUE (argtypes);
3573               tree tparm = TREE_TYPE (VEC_index (tree, args, ix));
3574               bool ptr = TREE_CODE (targ) == POINTER_TYPE;
3575               bool arr = TREE_CODE (tparm) == ARRAY_TYPE;
3576               if ((ptr || arr || !same_type_p (targ, tparm))
3577                   && (!ptr || !arr
3578                       || !same_type_p (TREE_TYPE (targ),
3579                                        TREE_TYPE (tparm))))
3580                 found = false;
3581             }
3582           if (found)
3583             return fn;
3584         }
3585     }
3586
3587   return error_mark_node;
3588 }
3589
3590 /* Parse a user-defined char constant.  Returns a call to a user-defined
3591    literal operator taking the character as an argument.  */
3592
3593 static tree
3594 cp_parser_userdef_char_literal (cp_parser *parser)
3595 {
3596   cp_token *token = cp_lexer_consume_token (parser->lexer);
3597   tree literal = token->u.value;
3598   tree suffix_id = USERDEF_LITERAL_SUFFIX_ID (literal);
3599   tree value = USERDEF_LITERAL_VALUE (literal);
3600   tree name = cp_literal_operator_id (IDENTIFIER_POINTER (suffix_id));
3601   tree decl, result;
3602
3603   /* Build up a call to the user-defined operator  */
3604   /* Lookup the name we got back from the id-expression.  */
3605   VEC(tree,gc) *args = make_tree_vector ();
3606   VEC_safe_push (tree, gc, args, value);
3607   decl = lookup_literal_operator (name, args);
3608   if (!decl || decl == error_mark_node)
3609     {
3610       error ("unable to find character literal operator %qD with %qT argument",
3611              name, TREE_TYPE (value));
3612       release_tree_vector (args);
3613       return error_mark_node;
3614     }
3615   result = finish_call_expr (decl, &args, false, true, tf_warning_or_error);
3616   release_tree_vector (args);
3617   if (result != error_mark_node)
3618     return result;
3619
3620   error ("unable to find character literal operator %qD with %qT argument",
3621          name, TREE_TYPE (value));
3622   return error_mark_node;
3623 }
3624
3625 /* A subroutine of cp_parser_userdef_numeric_literal to
3626    create a char... template parameter pack from a string node.  */
3627
3628 static tree
3629 make_char_string_pack (tree value)
3630 {
3631   tree charvec;
3632   tree argpack = make_node (NONTYPE_ARGUMENT_PACK);
3633   const char *str = TREE_STRING_POINTER (value);
3634   int i, len = TREE_STRING_LENGTH (value) - 1;
3635   tree argvec = make_tree_vec (1);
3636
3637   /* Fill in CHARVEC with all of the parameters.  */
3638   charvec = make_tree_vec (len);
3639   for (i = 0; i < len; ++i)
3640     TREE_VEC_ELT (charvec, i) = build_int_cst (char_type_node, str[i]);
3641
3642   /* Build the argument packs.  */
3643   SET_ARGUMENT_PACK_ARGS (argpack, charvec);
3644   TREE_TYPE (argpack) = char_type_node;
3645
3646   TREE_VEC_ELT (argvec, 0) = argpack;
3647
3648   return argvec;
3649 }
3650
3651 /* Parse a user-defined numeric constant.  returns a call to a user-defined
3652    literal operator.  */
3653
3654 static tree
3655 cp_parser_userdef_numeric_literal (cp_parser *parser)
3656 {
3657   cp_token *token = cp_lexer_consume_token (parser->lexer);
3658   tree literal = token->u.value;
3659   tree suffix_id = USERDEF_LITERAL_SUFFIX_ID (literal);
3660   tree value = USERDEF_LITERAL_VALUE (literal);
3661   tree num_string = USERDEF_LITERAL_NUM_STRING (literal);
3662   tree name = cp_literal_operator_id (IDENTIFIER_POINTER (suffix_id));
3663   tree decl, result;
3664   VEC(tree,gc) *args;
3665
3666   /* Look for a literal operator taking the exact type of numeric argument
3667      as the literal value.  */
3668   args = make_tree_vector ();
3669   VEC_safe_push (tree, gc, args, value);
3670   decl = lookup_literal_operator (name, args);
3671   if (decl && decl != error_mark_node)
3672     {
3673       result = finish_call_expr (decl, &args, false, true, tf_none);
3674       if (result != error_mark_node)
3675         {
3676           release_tree_vector (args);
3677           return result;
3678         }
3679     }
3680   release_tree_vector (args);
3681
3682   /* If the numeric argument didn't work, look for a raw literal
3683      operator taking a const char* argument consisting of the number
3684      in string format.  */
3685   args = make_tree_vector ();
3686   VEC_safe_push (tree, gc, args, num_string);
3687   decl = lookup_literal_operator (name, args);
3688   if (decl && decl != error_mark_node)
3689     {
3690       result = finish_call_expr (decl, &args, false, true, tf_none);
3691       if (result != error_mark_node)
3692         {
3693           release_tree_vector (args);
3694           return result;
3695         }
3696     }
3697   release_tree_vector (args);
3698
3699   /* If the raw literal didn't work, look for a non-type template
3700      function with parameter pack char....  Call the function with
3701      template parameter characters representing the number.  */
3702   args = make_tree_vector ();
3703   decl = lookup_literal_operator (name, args);
3704   if (decl && decl != error_mark_node)
3705     {
3706       tree tmpl_args = make_char_string_pack (num_string);
3707       decl = lookup_template_function (decl, tmpl_args);
3708       result = finish_call_expr (decl, &args, false, true, tf_none);
3709       if (result != error_mark_node)
3710         {
3711           release_tree_vector (args);
3712           return result;
3713         }
3714     }
3715   release_tree_vector (args);
3716
3717   error ("unable to find numeric literal operator %qD", name);
3718   return error_mark_node;
3719 }
3720
3721 /* Parse a user-defined string constant.  Returns a call to a user-defined
3722    literal operator taking a character pointer and the length of the string
3723    as arguments.  */
3724
3725 static tree
3726 cp_parser_userdef_string_literal (cp_token *token)
3727 {
3728   tree literal = token->u.value;
3729   tree suffix_id = USERDEF_LITERAL_SUFFIX_ID (literal);
3730   tree name = cp_literal_operator_id (IDENTIFIER_POINTER (suffix_id));
3731   tree value = USERDEF_LITERAL_VALUE (literal);
3732   int len = TREE_STRING_LENGTH (value)
3733         / TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (value)))) - 1;
3734   tree decl, result;
3735
3736   /* Build up a call to the user-defined operator  */
3737   /* Lookup the name we got back from the id-expression.  */
3738   VEC(tree,gc) *args = make_tree_vector ();
3739   VEC_safe_push (tree, gc, args, value);
3740   VEC_safe_push (tree, gc, args, build_int_cst (size_type_node, len));
3741   decl = lookup_name (name);
3742   if (!decl || decl == error_mark_node)
3743     {
3744       error ("unable to find string literal operator %qD", name);
3745       release_tree_vector (args);
3746       return error_mark_node;
3747     }
3748   result = finish_call_expr (decl, &args, false, true, tf_none);
3749   release_tree_vector (args);
3750   if (result != error_mark_node)
3751     return result;
3752
3753   error ("unable to find string literal operator %qD with %qT, %qT arguments",
3754          name, TREE_TYPE (value), size_type_node);
3755   return error_mark_node;
3756 }
3757
3758
3759 /* Basic concepts [gram.basic]  */
3760
3761 /* Parse a translation-unit.
3762
3763    translation-unit:
3764      declaration-seq [opt]
3765
3766    Returns TRUE if all went well.  */
3767
3768 static bool
3769 cp_parser_translation_unit (cp_parser* parser)
3770 {
3771   /* The address of the first non-permanent object on the declarator
3772      obstack.  */
3773   static void *declarator_obstack_base;
3774
3775   bool success;
3776
3777   /* Create the declarator obstack, if necessary.  */
3778   if (!cp_error_declarator)
3779     {
3780       gcc_obstack_init (&declarator_obstack);
3781       /* Create the error declarator.  */
3782       cp_error_declarator = make_declarator (cdk_error);
3783       /* Create the empty parameter list.  */
3784       no_parameters = make_parameter_declarator (NULL, NULL, NULL_TREE);
3785       /* Remember where the base of the declarator obstack lies.  */
3786       declarator_obstack_base = obstack_next_free (&declarator_obstack);
3787     }
3788
3789   cp_parser_declaration_seq_opt (parser);
3790
3791   /* If there are no tokens left then all went well.  */
3792   if (cp_lexer_next_token_is (parser->lexer, CPP_EOF))
3793     {
3794       /* Get rid of the token array; we don't need it any more.  */
3795       cp_lexer_destroy (parser->lexer);
3796       parser->lexer = NULL;
3797
3798       /* This file might have been a context that's implicitly extern
3799          "C".  If so, pop the lang context.  (Only relevant for PCH.) */
3800       if (parser->implicit_extern_c)
3801         {
3802           pop_lang_context ();
3803           parser->implicit_extern_c = false;
3804         }
3805
3806       /* Finish up.  */
3807       finish_translation_unit ();
3808
3809       success = true;
3810     }
3811   else
3812     {
3813       cp_parser_error (parser, "expected declaration");
3814       success = false;
3815     }
3816
3817   /* Make sure the declarator obstack was fully cleaned up.  */
3818   gcc_assert (obstack_next_free (&declarator_obstack)
3819               == declarator_obstack_base);
3820
3821   /* All went well.  */
3822   return success;
3823 }
3824
3825 /* Expressions [gram.expr] */
3826
3827 /* Parse a primary-expression.
3828
3829    primary-expression:
3830      literal
3831      this
3832      ( expression )
3833      id-expression
3834
3835    GNU Extensions:
3836
3837    primary-expression:
3838      ( compound-statement )
3839      __builtin_va_arg ( assignment-expression , type-id )
3840      __builtin_offsetof ( type-id , offsetof-expression )
3841
3842    C++ Extensions:
3843      __has_nothrow_assign ( type-id )   
3844      __has_nothrow_constructor ( type-id )
3845      __has_nothrow_copy ( type-id )
3846      __has_trivial_assign ( type-id )   
3847      __has_trivial_constructor ( type-id )
3848      __has_trivial_copy ( type-id )
3849      __has_trivial_destructor ( type-id )
3850      __has_virtual_destructor ( type-id )     
3851      __is_abstract ( type-id )
3852      __is_base_of ( type-id , type-id )
3853      __is_class ( type-id )
3854      __is_convertible_to ( type-id , type-id )     
3855      __is_empty ( type-id )
3856      __is_enum ( type-id )
3857      __is_literal_type ( type-id )
3858      __is_pod ( type-id )
3859      __is_polymorphic ( type-id )
3860      __is_std_layout ( type-id )
3861      __is_trivial ( type-id )
3862      __is_union ( type-id )
3863
3864    Objective-C++ Extension:
3865
3866    primary-expression:
3867      objc-expression
3868
3869    literal:
3870      __null
3871
3872    ADDRESS_P is true iff this expression was immediately preceded by
3873    "&" and therefore might denote a pointer-to-member.  CAST_P is true
3874    iff this expression is the target of a cast.  TEMPLATE_ARG_P is
3875    true iff this expression is a template argument.
3876
3877    Returns a representation of the expression.  Upon return, *IDK
3878    indicates what kind of id-expression (if any) was present.  */
3879
3880 static tree
3881 cp_parser_primary_expression (cp_parser *parser,
3882                               bool address_p,
3883                               bool cast_p,
3884                               bool template_arg_p,
3885                               cp_id_kind *idk)
3886 {
3887   cp_token *token = NULL;
3888
3889   /* Assume the primary expression is not an id-expression.  */
3890   *idk = CP_ID_KIND_NONE;
3891
3892   /* Peek at the next token.  */
3893   token = cp_lexer_peek_token (parser->lexer);
3894   switch (token->type)
3895     {
3896       /* literal:
3897            integer-literal
3898            character-literal
3899            floating-literal
3900            string-literal
3901            boolean-literal
3902            pointer-literal
3903            user-defined-literal  */
3904     case CPP_CHAR:
3905     case CPP_CHAR16:
3906     case CPP_CHAR32:
3907     case CPP_WCHAR:
3908     case CPP_NUMBER:
3909       if (TREE_CODE (token->u.value) == USERDEF_LITERAL)
3910         return cp_parser_userdef_numeric_literal (parser);
3911       token = cp_lexer_consume_token (parser->lexer);
3912       if (TREE_CODE (token->u.value) == FIXED_CST)
3913         {
3914           error_at (token->location,
3915                     "fixed-point types not supported in C++");
3916           return error_mark_node;
3917         }
3918       /* Floating-point literals are only allowed in an integral
3919          constant expression if they are cast to an integral or
3920          enumeration type.  */
3921       if (TREE_CODE (token->u.value) == REAL_CST
3922           && parser->integral_constant_expression_p
3923           && pedantic)
3924         {
3925           /* CAST_P will be set even in invalid code like "int(2.7 +
3926              ...)".   Therefore, we have to check that the next token
3927              is sure to end the cast.  */
3928           if (cast_p)
3929             {
3930               cp_token *next_token;
3931
3932               next_token = cp_lexer_peek_token (parser->lexer);
3933               if (/* The comma at the end of an
3934                      enumerator-definition.  */
3935                   next_token->type != CPP_COMMA
3936                   /* The curly brace at the end of an enum-specifier.  */
3937                   && next_token->type != CPP_CLOSE_BRACE
3938                   /* The end of a statement.  */
3939                   && next_token->type != CPP_SEMICOLON
3940                   /* The end of the cast-expression.  */
3941                   && next_token->type != CPP_CLOSE_PAREN
3942                   /* The end of an array bound.  */
3943                   && next_token->type != CPP_CLOSE_SQUARE
3944                   /* The closing ">" in a template-argument-list.  */
3945                   && (next_token->type != CPP_GREATER
3946                       || parser->greater_than_is_operator_p)
3947                   /* C++0x only: A ">>" treated like two ">" tokens,
3948                      in a template-argument-list.  */
3949                   && (next_token->type != CPP_RSHIFT
3950                       || (cxx_dialect == cxx98)
3951                       || parser->greater_than_is_operator_p))
3952                 cast_p = false;
3953             }
3954
3955           /* If we are within a cast, then the constraint that the
3956              cast is to an integral or enumeration type will be
3957              checked at that point.  If we are not within a cast, then
3958              this code is invalid.  */
3959           if (!cast_p)
3960             cp_parser_non_integral_constant_expression (parser, NIC_FLOAT);
3961         }
3962       return token->u.value;
3963
3964     case CPP_CHAR_USERDEF:
3965     case CPP_CHAR16_USERDEF:
3966     case CPP_CHAR32_USERDEF:
3967     case CPP_WCHAR_USERDEF:
3968       return cp_parser_userdef_char_literal (parser);
3969
3970     case CPP_STRING:
3971     case CPP_STRING16:
3972     case CPP_STRING32:
3973     case CPP_WSTRING:
3974     case CPP_UTF8STRING:
3975     case CPP_STRING_USERDEF:
3976     case CPP_STRING16_USERDEF:
3977     case CPP_STRING32_USERDEF:
3978     case CPP_WSTRING_USERDEF:
3979     case CPP_UTF8STRING_USERDEF:
3980       /* ??? Should wide strings be allowed when parser->translate_strings_p
3981          is false (i.e. in attributes)?  If not, we can kill the third
3982          argument to cp_parser_string_literal.  */
3983       return cp_parser_string_literal (parser,
3984                                        parser->translate_strings_p,
3985                                        true);
3986
3987     case CPP_OPEN_PAREN:
3988       {
3989         tree expr;
3990         bool saved_greater_than_is_operator_p;
3991
3992         /* Consume the `('.  */
3993         cp_lexer_consume_token (parser->lexer);
3994         /* Within a parenthesized expression, a `>' token is always
3995            the greater-than operator.  */
3996         saved_greater_than_is_operator_p
3997           = parser->greater_than_is_operator_p;
3998         parser->greater_than_is_operator_p = true;
3999         /* If we see `( { ' then we are looking at the beginning of
4000            a GNU statement-expression.  */
4001         if (cp_parser_allow_gnu_extensions_p (parser)
4002             && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
4003           {
4004             /* Statement-expressions are not allowed by the standard.  */
4005             pedwarn (token->location, OPT_pedantic, 
4006                      "ISO C++ forbids braced-groups within expressions");
4007
4008             /* And they're not allowed outside of a function-body; you
4009                cannot, for example, write:
4010
4011                  int i = ({ int j = 3; j + 1; });
4012
4013                at class or namespace scope.  */
4014             if (!parser->in_function_body
4015                 || parser->in_template_argument_list_p)
4016               {
4017                 error_at (token->location,
4018                           "statement-expressions are not allowed outside "
4019                           "functions nor in template-argument lists");
4020                 cp_parser_skip_to_end_of_block_or_statement (parser);
4021                 expr = error_mark_node;
4022               }
4023             else
4024               {
4025                 /* Start the statement-expression.  */
4026                 expr = begin_stmt_expr ();
4027                 /* Parse the compound-statement.  */
4028                 cp_parser_compound_statement (parser, expr, false, false);
4029                 /* Finish up.  */
4030                 expr = finish_stmt_expr (expr, false);
4031               }
4032           }
4033         else
4034           {
4035             /* Parse the parenthesized expression.  */
4036             expr = cp_parser_expression (parser, cast_p, idk);
4037             /* Let the front end know that this expression was
4038                enclosed in parentheses. This matters in case, for
4039                example, the expression is of the form `A::B', since
4040                `&A::B' might be a pointer-to-member, but `&(A::B)' is
4041                not.  */
4042             finish_parenthesized_expr (expr);
4043             /* DR 705: Wrapping an unqualified name in parentheses
4044                suppresses arg-dependent lookup.  We want to pass back
4045                CP_ID_KIND_QUALIFIED for suppressing vtable lookup
4046                (c++/37862), but none of the others.  */
4047             if (*idk != CP_ID_KIND_QUALIFIED)
4048               *idk = CP_ID_KIND_NONE;
4049           }
4050         /* The `>' token might be the end of a template-id or
4051            template-parameter-list now.  */
4052         parser->greater_than_is_operator_p
4053           = saved_greater_than_is_operator_p;
4054         /* Consume the `)'.  */
4055         if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
4056           cp_parser_skip_to_end_of_statement (parser);
4057
4058         return expr;
4059       }
4060
4061     case CPP_OPEN_SQUARE:
4062       if (c_dialect_objc ())
4063         /* We have an Objective-C++ message. */
4064         return cp_parser_objc_expression (parser);
4065       {
4066         tree lam = cp_parser_lambda_expression (parser);
4067         /* Don't warn about a failed tentative parse.  */
4068         if (cp_parser_error_occurred (parser))
4069           return error_mark_node;
4070         maybe_warn_cpp0x (CPP0X_LAMBDA_EXPR);
4071         return lam;
4072       }
4073
4074     case CPP_OBJC_STRING:
4075       if (c_dialect_objc ())
4076         /* We have an Objective-C++ string literal. */
4077         return cp_parser_objc_expression (parser);
4078       cp_parser_error (parser, "expected primary-expression");
4079       return error_mark_node;
4080
4081     case CPP_KEYWORD:
4082       switch (token->keyword)
4083         {
4084           /* These two are the boolean literals.  */
4085         case RID_TRUE:
4086           cp_lexer_consume_token (parser->lexer);
4087           return boolean_true_node;
4088         case RID_FALSE:
4089           cp_lexer_consume_token (parser->lexer);
4090           return boolean_false_node;
4091
4092           /* The `__null' literal.  */
4093         case RID_NULL:
4094           cp_lexer_consume_token (parser->lexer);
4095           return null_node;
4096
4097           /* The `nullptr' literal.  */
4098         case RID_NULLPTR:
4099           cp_lexer_consume_token (parser->lexer);
4100           return nullptr_node;
4101
4102           /* Recognize the `this' keyword.  */
4103         case RID_THIS:
4104           cp_lexer_consume_token (parser->lexer);
4105           if (parser->local_variables_forbidden_p)
4106             {
4107               error_at (token->location,
4108                         "%<this%> may not be used in this context");
4109               return error_mark_node;
4110             }
4111           /* Pointers cannot appear in constant-expressions.  */
4112           if (cp_parser_non_integral_constant_expression (parser, NIC_THIS))
4113             return error_mark_node;
4114           return finish_this_expr ();
4115
4116           /* The `operator' keyword can be the beginning of an
4117              id-expression.  */
4118         case RID_OPERATOR:
4119           goto id_expression;
4120
4121         case RID_FUNCTION_NAME:
4122         case RID_PRETTY_FUNCTION_NAME:
4123         case RID_C99_FUNCTION_NAME:
4124           {
4125             non_integral_constant name;
4126
4127             /* The symbols __FUNCTION__, __PRETTY_FUNCTION__, and
4128                __func__ are the names of variables -- but they are
4129                treated specially.  Therefore, they are handled here,
4130                rather than relying on the generic id-expression logic
4131                below.  Grammatically, these names are id-expressions.
4132
4133                Consume the token.  */
4134             token = cp_lexer_consume_token (parser->lexer);
4135
4136             switch (token->keyword)
4137               {
4138               case RID_FUNCTION_NAME:
4139                 name = NIC_FUNC_NAME;
4140                 break;
4141               case RID_PRETTY_FUNCTION_NAME:
4142                 name = NIC_PRETTY_FUNC;
4143                 break;
4144               case RID_C99_FUNCTION_NAME:
4145                 name = NIC_C99_FUNC;
4146                 break;
4147               default:
4148                 gcc_unreachable ();
4149               }
4150
4151             if (cp_parser_non_integral_constant_expression (parser, name))
4152               return error_mark_node;
4153
4154             /* Look up the name.  */
4155             return finish_fname (token->u.value);
4156           }
4157
4158         case RID_VA_ARG:
4159           {
4160             tree expression;
4161             tree type;
4162
4163             /* The `__builtin_va_arg' construct is used to handle
4164                `va_arg'.  Consume the `__builtin_va_arg' token.  */
4165             cp_lexer_consume_token (parser->lexer);
4166             /* Look for the opening `('.  */
4167             cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
4168             /* Now, parse the assignment-expression.  */
4169             expression = cp_parser_assignment_expression (parser,
4170                                                           /*cast_p=*/false, NULL);
4171             /* Look for the `,'.  */
4172             cp_parser_require (parser, CPP_COMMA, RT_COMMA);
4173             /* Parse the type-id.  */
4174             type = cp_parser_type_id (parser);
4175             /* Look for the closing `)'.  */
4176             cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
4177             /* Using `va_arg' in a constant-expression is not
4178                allowed.  */
4179             if (cp_parser_non_integral_constant_expression (parser,
4180                                                             NIC_VA_ARG))
4181               return error_mark_node;
4182             return build_x_va_arg (expression, type);
4183           }
4184
4185         case RID_OFFSETOF:
4186           return cp_parser_builtin_offsetof (parser);
4187
4188         case RID_HAS_NOTHROW_ASSIGN:
4189         case RID_HAS_NOTHROW_CONSTRUCTOR:
4190         case RID_HAS_NOTHROW_COPY:        
4191         case RID_HAS_TRIVIAL_ASSIGN:
4192         case RID_HAS_TRIVIAL_CONSTRUCTOR:
4193         case RID_HAS_TRIVIAL_COPY:        
4194         case RID_HAS_TRIVIAL_DESTRUCTOR:
4195         case RID_HAS_VIRTUAL_DESTRUCTOR:
4196         case RID_IS_ABSTRACT:
4197         case RID_IS_BASE_OF:
4198         case RID_IS_CLASS:
4199         case RID_IS_CONVERTIBLE_TO:
4200         case RID_IS_EMPTY:
4201         case RID_IS_ENUM:
4202         case RID_IS_LITERAL_TYPE:
4203         case RID_IS_POD:
4204         case RID_IS_POLYMORPHIC:
4205         case RID_IS_STD_LAYOUT:
4206         case RID_IS_TRIVIAL:
4207         case RID_IS_UNION:
4208           return cp_parser_trait_expr (parser, token->keyword);
4209
4210         /* Objective-C++ expressions.  */
4211         case RID_AT_ENCODE:
4212         case RID_AT_PROTOCOL:
4213         case RID_AT_SELECTOR:
4214           return cp_parser_objc_expression (parser);
4215
4216         case RID_TEMPLATE:
4217           if (parser->in_function_body
4218               && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
4219                   == CPP_LESS))
4220             {
4221               error_at (token->location,
4222                         "a template declaration cannot appear at block scope");
4223               cp_parser_skip_to_end_of_block_or_statement (parser);
4224               return error_mark_node;
4225             }
4226         default:
4227           cp_parser_error (parser, "expected primary-expression");
4228           return error_mark_node;
4229         }
4230
4231       /* An id-expression can start with either an identifier, a
4232          `::' as the beginning of a qualified-id, or the "operator"
4233          keyword.  */
4234     case CPP_NAME:
4235     case CPP_SCOPE:
4236     case CPP_TEMPLATE_ID:
4237     case CPP_NESTED_NAME_SPECIFIER:
4238       {
4239         tree id_expression;
4240         tree decl;
4241         const char *error_msg;
4242         bool template_p;
4243         bool done;
4244         cp_token *id_expr_token;
4245
4246       id_expression:
4247         /* Parse the id-expression.  */
4248         id_expression
4249           = cp_parser_id_expression (parser,
4250                                      /*template_keyword_p=*/false,
4251                                      /*check_dependency_p=*/true,
4252                                      &template_p,
4253                                      /*declarator_p=*/false,
4254                                      /*optional_p=*/false);
4255         if (id_expression == error_mark_node)
4256           return error_mark_node;
4257         id_expr_token = token;
4258         token = cp_lexer_peek_token (parser->lexer);
4259         done = (token->type != CPP_OPEN_SQUARE
4260                 && token->type != CPP_OPEN_PAREN
4261                 && token->type != CPP_DOT
4262                 && token->type != CPP_DEREF
4263                 && token->type != CPP_PLUS_PLUS
4264                 && token->type != CPP_MINUS_MINUS);
4265         /* If we have a template-id, then no further lookup is
4266            required.  If the template-id was for a template-class, we
4267            will sometimes have a TYPE_DECL at this point.  */
4268         if (TREE_CODE (id_expression) == TEMPLATE_ID_EXPR
4269                  || TREE_CODE (id_expression) == TYPE_DECL)
4270           decl = id_expression;
4271         /* Look up the name.  */
4272         else