OSDN Git Service

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