OSDN Git Service

Implement C++11 user-defined literals.
[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 will become a keyword in C++0x",
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 void cp_parser_asm_definition
1939   (cp_parser *);
1940 static void cp_parser_linkage_specification
1941   (cp_parser *);
1942 static void cp_parser_static_assert
1943   (cp_parser *, bool);
1944 static tree cp_parser_decltype
1945   (cp_parser *);
1946
1947 /* Declarators [gram.dcl.decl] */
1948
1949 static tree cp_parser_init_declarator
1950   (cp_parser *, cp_decl_specifier_seq *, VEC (deferred_access_check,gc)*, bool, bool, int, bool *, tree *);
1951 static cp_declarator *cp_parser_declarator
1952   (cp_parser *, cp_parser_declarator_kind, int *, bool *, bool);
1953 static cp_declarator *cp_parser_direct_declarator
1954   (cp_parser *, cp_parser_declarator_kind, int *, bool);
1955 static enum tree_code cp_parser_ptr_operator
1956   (cp_parser *, tree *, cp_cv_quals *);
1957 static cp_cv_quals cp_parser_cv_qualifier_seq_opt
1958   (cp_parser *);
1959 static cp_virt_specifiers cp_parser_virt_specifier_seq_opt
1960   (cp_parser *);
1961 static tree cp_parser_late_return_type_opt
1962   (cp_parser *, cp_cv_quals);
1963 static tree cp_parser_declarator_id
1964   (cp_parser *, bool);
1965 static tree cp_parser_type_id
1966   (cp_parser *);
1967 static tree cp_parser_template_type_arg
1968   (cp_parser *);
1969 static tree cp_parser_trailing_type_id (cp_parser *);
1970 static tree cp_parser_type_id_1
1971   (cp_parser *, bool, bool);
1972 static void cp_parser_type_specifier_seq
1973   (cp_parser *, bool, bool, cp_decl_specifier_seq *);
1974 static tree cp_parser_parameter_declaration_clause
1975   (cp_parser *);
1976 static tree cp_parser_parameter_declaration_list
1977   (cp_parser *, bool *);
1978 static cp_parameter_declarator *cp_parser_parameter_declaration
1979   (cp_parser *, bool, bool *);
1980 static tree cp_parser_default_argument 
1981   (cp_parser *, bool);
1982 static void cp_parser_function_body
1983   (cp_parser *);
1984 static tree cp_parser_initializer
1985   (cp_parser *, bool *, bool *);
1986 static tree cp_parser_initializer_clause
1987   (cp_parser *, bool *);
1988 static tree cp_parser_braced_list
1989   (cp_parser*, bool*);
1990 static VEC(constructor_elt,gc) *cp_parser_initializer_list
1991   (cp_parser *, bool *);
1992
1993 static bool cp_parser_ctor_initializer_opt_and_function_body
1994   (cp_parser *);
1995
1996 /* Classes [gram.class] */
1997
1998 static tree cp_parser_class_name
1999   (cp_parser *, bool, bool, enum tag_types, bool, bool, bool);
2000 static tree cp_parser_class_specifier
2001   (cp_parser *);
2002 static tree cp_parser_class_head
2003   (cp_parser *, bool *, tree *, tree *);
2004 static enum tag_types cp_parser_class_key
2005   (cp_parser *);
2006 static void cp_parser_member_specification_opt
2007   (cp_parser *);
2008 static void cp_parser_member_declaration
2009   (cp_parser *);
2010 static tree cp_parser_pure_specifier
2011   (cp_parser *);
2012 static tree cp_parser_constant_initializer
2013   (cp_parser *);
2014
2015 /* Derived classes [gram.class.derived] */
2016
2017 static tree cp_parser_base_clause
2018   (cp_parser *);
2019 static tree cp_parser_base_specifier
2020   (cp_parser *);
2021
2022 /* Special member functions [gram.special] */
2023
2024 static tree cp_parser_conversion_function_id
2025   (cp_parser *);
2026 static tree cp_parser_conversion_type_id
2027   (cp_parser *);
2028 static cp_declarator *cp_parser_conversion_declarator_opt
2029   (cp_parser *);
2030 static bool cp_parser_ctor_initializer_opt
2031   (cp_parser *);
2032 static void cp_parser_mem_initializer_list
2033   (cp_parser *);
2034 static tree cp_parser_mem_initializer
2035   (cp_parser *);
2036 static tree cp_parser_mem_initializer_id
2037   (cp_parser *);
2038
2039 /* Overloading [gram.over] */
2040
2041 static tree cp_parser_operator_function_id
2042   (cp_parser *);
2043 static tree cp_parser_operator
2044   (cp_parser *);
2045
2046 /* Templates [gram.temp] */
2047
2048 static void cp_parser_template_declaration
2049   (cp_parser *, bool);
2050 static tree cp_parser_template_parameter_list
2051   (cp_parser *);
2052 static tree cp_parser_template_parameter
2053   (cp_parser *, bool *, bool *);
2054 static tree cp_parser_type_parameter
2055   (cp_parser *, bool *);
2056 static tree cp_parser_template_id
2057   (cp_parser *, bool, bool, bool);
2058 static tree cp_parser_template_name
2059   (cp_parser *, bool, bool, bool, bool *);
2060 static tree cp_parser_template_argument_list
2061   (cp_parser *);
2062 static tree cp_parser_template_argument
2063   (cp_parser *);
2064 static void cp_parser_explicit_instantiation
2065   (cp_parser *);
2066 static void cp_parser_explicit_specialization
2067   (cp_parser *);
2068
2069 /* Exception handling [gram.exception] */
2070
2071 static tree cp_parser_try_block
2072   (cp_parser *);
2073 static bool cp_parser_function_try_block
2074   (cp_parser *);
2075 static void cp_parser_handler_seq
2076   (cp_parser *);
2077 static void cp_parser_handler
2078   (cp_parser *);
2079 static tree cp_parser_exception_declaration
2080   (cp_parser *);
2081 static tree cp_parser_throw_expression
2082   (cp_parser *);
2083 static tree cp_parser_exception_specification_opt
2084   (cp_parser *);
2085 static tree cp_parser_type_id_list
2086   (cp_parser *);
2087
2088 /* GNU Extensions */
2089
2090 static tree cp_parser_asm_specification_opt
2091   (cp_parser *);
2092 static tree cp_parser_asm_operand_list
2093   (cp_parser *);
2094 static tree cp_parser_asm_clobber_list
2095   (cp_parser *);
2096 static tree cp_parser_asm_label_list
2097   (cp_parser *);
2098 static tree cp_parser_attributes_opt
2099   (cp_parser *);
2100 static tree cp_parser_attribute_list
2101   (cp_parser *);
2102 static bool cp_parser_extension_opt
2103   (cp_parser *, int *);
2104 static void cp_parser_label_declaration
2105   (cp_parser *);
2106
2107 enum pragma_context { pragma_external, pragma_stmt, pragma_compound };
2108 static bool cp_parser_pragma
2109   (cp_parser *, enum pragma_context);
2110
2111 /* Objective-C++ Productions */
2112
2113 static tree cp_parser_objc_message_receiver
2114   (cp_parser *);
2115 static tree cp_parser_objc_message_args
2116   (cp_parser *);
2117 static tree cp_parser_objc_message_expression
2118   (cp_parser *);
2119 static tree cp_parser_objc_encode_expression
2120   (cp_parser *);
2121 static tree cp_parser_objc_defs_expression
2122   (cp_parser *);
2123 static tree cp_parser_objc_protocol_expression
2124   (cp_parser *);
2125 static tree cp_parser_objc_selector_expression
2126   (cp_parser *);
2127 static tree cp_parser_objc_expression
2128   (cp_parser *);
2129 static bool cp_parser_objc_selector_p
2130   (enum cpp_ttype);
2131 static tree cp_parser_objc_selector
2132   (cp_parser *);
2133 static tree cp_parser_objc_protocol_refs_opt
2134   (cp_parser *);
2135 static void cp_parser_objc_declaration
2136   (cp_parser *, tree);
2137 static tree cp_parser_objc_statement
2138   (cp_parser *);
2139 static bool cp_parser_objc_valid_prefix_attributes
2140   (cp_parser *, tree *);
2141 static void cp_parser_objc_at_property_declaration 
2142   (cp_parser *) ;
2143 static void cp_parser_objc_at_synthesize_declaration 
2144   (cp_parser *) ;
2145 static void cp_parser_objc_at_dynamic_declaration
2146   (cp_parser *) ;
2147 static tree cp_parser_objc_struct_declaration
2148   (cp_parser *) ;
2149
2150 /* Utility Routines */
2151
2152 static tree cp_parser_lookup_name
2153   (cp_parser *, tree, enum tag_types, bool, bool, bool, tree *, location_t);
2154 static tree cp_parser_lookup_name_simple
2155   (cp_parser *, tree, location_t);
2156 static tree cp_parser_maybe_treat_template_as_class
2157   (tree, bool);
2158 static bool cp_parser_check_declarator_template_parameters
2159   (cp_parser *, cp_declarator *, location_t);
2160 static bool cp_parser_check_template_parameters
2161   (cp_parser *, unsigned, location_t, cp_declarator *);
2162 static tree cp_parser_simple_cast_expression
2163   (cp_parser *);
2164 static tree cp_parser_global_scope_opt
2165   (cp_parser *, bool);
2166 static bool cp_parser_constructor_declarator_p
2167   (cp_parser *, bool);
2168 static tree cp_parser_function_definition_from_specifiers_and_declarator
2169   (cp_parser *, cp_decl_specifier_seq *, tree, const cp_declarator *);
2170 static tree cp_parser_function_definition_after_declarator
2171   (cp_parser *, bool);
2172 static void cp_parser_template_declaration_after_export
2173   (cp_parser *, bool);
2174 static void cp_parser_perform_template_parameter_access_checks
2175   (VEC (deferred_access_check,gc)*);
2176 static tree cp_parser_single_declaration
2177   (cp_parser *, VEC (deferred_access_check,gc)*, bool, bool, bool *);
2178 static tree cp_parser_functional_cast
2179   (cp_parser *, tree);
2180 static tree cp_parser_save_member_function_body
2181   (cp_parser *, cp_decl_specifier_seq *, cp_declarator *, tree);
2182 static tree cp_parser_save_nsdmi
2183   (cp_parser *);
2184 static tree cp_parser_enclosed_template_argument_list
2185   (cp_parser *);
2186 static void cp_parser_save_default_args
2187   (cp_parser *, tree);
2188 static void cp_parser_late_parsing_for_member
2189   (cp_parser *, tree);
2190 static tree cp_parser_late_parse_one_default_arg
2191   (cp_parser *, tree, tree, tree);
2192 static void cp_parser_late_parsing_nsdmi
2193   (cp_parser *, tree);
2194 static void cp_parser_late_parsing_default_args
2195   (cp_parser *, tree);
2196 static tree cp_parser_sizeof_operand
2197   (cp_parser *, enum rid);
2198 static tree cp_parser_trait_expr
2199   (cp_parser *, enum rid);
2200 static bool cp_parser_declares_only_class_p
2201   (cp_parser *);
2202 static void cp_parser_set_storage_class
2203   (cp_parser *, cp_decl_specifier_seq *, enum rid, location_t);
2204 static void cp_parser_set_decl_spec_type
2205   (cp_decl_specifier_seq *, tree, location_t, bool);
2206 static bool cp_parser_friend_p
2207   (const cp_decl_specifier_seq *);
2208 static void cp_parser_required_error
2209   (cp_parser *, required_token, bool);
2210 static cp_token *cp_parser_require
2211   (cp_parser *, enum cpp_ttype, required_token);
2212 static cp_token *cp_parser_require_keyword
2213   (cp_parser *, enum rid, required_token);
2214 static bool cp_parser_token_starts_function_definition_p
2215   (cp_token *);
2216 static bool cp_parser_next_token_starts_class_definition_p
2217   (cp_parser *);
2218 static bool cp_parser_next_token_ends_template_argument_p
2219   (cp_parser *);
2220 static bool cp_parser_nth_token_starts_template_argument_list_p
2221   (cp_parser *, size_t);
2222 static enum tag_types cp_parser_token_is_class_key
2223   (cp_token *);
2224 static void cp_parser_check_class_key
2225   (enum tag_types, tree type);
2226 static void cp_parser_check_access_in_redeclaration
2227   (tree type, location_t location);
2228 static bool cp_parser_optional_template_keyword
2229   (cp_parser *);
2230 static void cp_parser_pre_parsed_nested_name_specifier
2231   (cp_parser *);
2232 static bool cp_parser_cache_group
2233   (cp_parser *, enum cpp_ttype, unsigned);
2234 static void cp_parser_parse_tentatively
2235   (cp_parser *);
2236 static void cp_parser_commit_to_tentative_parse
2237   (cp_parser *);
2238 static void cp_parser_abort_tentative_parse
2239   (cp_parser *);
2240 static bool cp_parser_parse_definitely
2241   (cp_parser *);
2242 static inline bool cp_parser_parsing_tentatively
2243   (cp_parser *);
2244 static bool cp_parser_uncommitted_to_tentative_parse_p
2245   (cp_parser *);
2246 static void cp_parser_error
2247   (cp_parser *, const char *);
2248 static void cp_parser_name_lookup_error
2249   (cp_parser *, tree, tree, name_lookup_error, location_t);
2250 static bool cp_parser_simulate_error
2251   (cp_parser *);
2252 static bool cp_parser_check_type_definition
2253   (cp_parser *);
2254 static void cp_parser_check_for_definition_in_return_type
2255   (cp_declarator *, tree, location_t type_location);
2256 static void cp_parser_check_for_invalid_template_id
2257   (cp_parser *, tree, location_t location);
2258 static bool cp_parser_non_integral_constant_expression
2259   (cp_parser *, non_integral_constant);
2260 static void cp_parser_diagnose_invalid_type_name
2261   (cp_parser *, tree, tree, location_t);
2262 static bool cp_parser_parse_and_diagnose_invalid_type_name
2263   (cp_parser *);
2264 static int cp_parser_skip_to_closing_parenthesis
2265   (cp_parser *, bool, bool, bool);
2266 static void cp_parser_skip_to_end_of_statement
2267   (cp_parser *);
2268 static void cp_parser_consume_semicolon_at_end_of_statement
2269   (cp_parser *);
2270 static void cp_parser_skip_to_end_of_block_or_statement
2271   (cp_parser *);
2272 static bool cp_parser_skip_to_closing_brace
2273   (cp_parser *);
2274 static void cp_parser_skip_to_end_of_template_parameter_list
2275   (cp_parser *);
2276 static void cp_parser_skip_to_pragma_eol
2277   (cp_parser*, cp_token *);
2278 static bool cp_parser_error_occurred
2279   (cp_parser *);
2280 static bool cp_parser_allow_gnu_extensions_p
2281   (cp_parser *);
2282 static bool cp_parser_is_pure_string_literal
2283   (cp_token *);
2284 static bool cp_parser_is_string_literal
2285   (cp_token *);
2286 static bool cp_parser_is_keyword
2287   (cp_token *, enum rid);
2288 static tree cp_parser_make_typename_type
2289   (cp_parser *, tree, tree, location_t location);
2290 static cp_declarator * cp_parser_make_indirect_declarator
2291   (enum tree_code, tree, cp_cv_quals, cp_declarator *);
2292
2293 /* Returns nonzero if we are parsing tentatively.  */
2294
2295 static inline bool
2296 cp_parser_parsing_tentatively (cp_parser* parser)
2297 {
2298   return parser->context->next != NULL;
2299 }
2300
2301 /* Returns nonzero if TOKEN is a string literal.  */
2302
2303 static bool
2304 cp_parser_is_pure_string_literal (cp_token* token)
2305 {
2306   return (token->type == CPP_STRING ||
2307           token->type == CPP_STRING16 ||
2308           token->type == CPP_STRING32 ||
2309           token->type == CPP_WSTRING ||
2310           token->type == CPP_UTF8STRING);
2311 }
2312
2313 /* Returns nonzero if TOKEN is a string literal
2314    of a user-defined string literal.  */
2315
2316 static bool
2317 cp_parser_is_string_literal (cp_token* token)
2318 {
2319   return (cp_parser_is_pure_string_literal (token) ||
2320           token->type == CPP_STRING_USERDEF ||
2321           token->type == CPP_STRING16_USERDEF ||
2322           token->type == CPP_STRING32_USERDEF ||
2323           token->type == CPP_WSTRING_USERDEF ||
2324           token->type == CPP_UTF8STRING_USERDEF);
2325 }
2326
2327 /* Returns nonzero if TOKEN is the indicated KEYWORD.  */
2328
2329 static bool
2330 cp_parser_is_keyword (cp_token* token, enum rid keyword)
2331 {
2332   return token->keyword == keyword;
2333 }
2334
2335 /* If not parsing tentatively, issue a diagnostic of the form
2336       FILE:LINE: MESSAGE before TOKEN
2337    where TOKEN is the next token in the input stream.  MESSAGE
2338    (specified by the caller) is usually of the form "expected
2339    OTHER-TOKEN".  */
2340
2341 static void
2342 cp_parser_error (cp_parser* parser, const char* gmsgid)
2343 {
2344   if (!cp_parser_simulate_error (parser))
2345     {
2346       cp_token *token = cp_lexer_peek_token (parser->lexer);
2347       /* This diagnostic makes more sense if it is tagged to the line
2348          of the token we just peeked at.  */
2349       cp_lexer_set_source_position_from_token (token);
2350
2351       if (token->type == CPP_PRAGMA)
2352         {
2353           error_at (token->location,
2354                     "%<#pragma%> is not allowed here");
2355           cp_parser_skip_to_pragma_eol (parser, token);
2356           return;
2357         }
2358
2359       c_parse_error (gmsgid,
2360                      /* Because c_parser_error does not understand
2361                         CPP_KEYWORD, keywords are treated like
2362                         identifiers.  */
2363                      (token->type == CPP_KEYWORD ? CPP_NAME : token->type),
2364                      token->u.value, token->flags);
2365     }
2366 }
2367
2368 /* Issue an error about name-lookup failing.  NAME is the
2369    IDENTIFIER_NODE DECL is the result of
2370    the lookup (as returned from cp_parser_lookup_name).  DESIRED is
2371    the thing that we hoped to find.  */
2372
2373 static void
2374 cp_parser_name_lookup_error (cp_parser* parser,
2375                              tree name,
2376                              tree decl,
2377                              name_lookup_error desired,
2378                              location_t location)
2379 {
2380   /* If name lookup completely failed, tell the user that NAME was not
2381      declared.  */
2382   if (decl == error_mark_node)
2383     {
2384       if (parser->scope && parser->scope != global_namespace)
2385         error_at (location, "%<%E::%E%> has not been declared",
2386                   parser->scope, name);
2387       else if (parser->scope == global_namespace)
2388         error_at (location, "%<::%E%> has not been declared", name);
2389       else if (parser->object_scope
2390                && !CLASS_TYPE_P (parser->object_scope))
2391         error_at (location, "request for member %qE in non-class type %qT",
2392                   name, parser->object_scope);
2393       else if (parser->object_scope)
2394         error_at (location, "%<%T::%E%> has not been declared",
2395                   parser->object_scope, name);
2396       else
2397         error_at (location, "%qE has not been declared", name);
2398     }
2399   else if (parser->scope && parser->scope != global_namespace)
2400     {
2401       switch (desired)
2402         {
2403           case NLE_TYPE:
2404             error_at (location, "%<%E::%E%> is not a type",
2405                                 parser->scope, name);
2406             break;
2407           case NLE_CXX98:
2408             error_at (location, "%<%E::%E%> is not a class or namespace",
2409                                 parser->scope, name);
2410             break;
2411           case NLE_NOT_CXX98:
2412             error_at (location,
2413                       "%<%E::%E%> is not a class, namespace, or enumeration",
2414                       parser->scope, name);
2415             break;
2416           default:
2417             gcc_unreachable ();
2418             
2419         }
2420     }
2421   else if (parser->scope == global_namespace)
2422     {
2423       switch (desired)
2424         {
2425           case NLE_TYPE:
2426             error_at (location, "%<::%E%> is not a type", name);
2427             break;
2428           case NLE_CXX98:
2429             error_at (location, "%<::%E%> is not a class or namespace", name);
2430             break;
2431           case NLE_NOT_CXX98:
2432             error_at (location,
2433                       "%<::%E%> is not a class, namespace, or enumeration",
2434                       name);
2435             break;
2436           default:
2437             gcc_unreachable ();
2438         }
2439     }
2440   else
2441     {
2442       switch (desired)
2443         {
2444           case NLE_TYPE:
2445             error_at (location, "%qE is not a type", name);
2446             break;
2447           case NLE_CXX98:
2448             error_at (location, "%qE is not a class or namespace", name);
2449             break;
2450           case NLE_NOT_CXX98:
2451             error_at (location,
2452                       "%qE is not a class, namespace, or enumeration", name);
2453             break;
2454           default:
2455             gcc_unreachable ();
2456         }
2457     }
2458 }
2459
2460 /* If we are parsing tentatively, remember that an error has occurred
2461    during this tentative parse.  Returns true if the error was
2462    simulated; false if a message should be issued by the caller.  */
2463
2464 static bool
2465 cp_parser_simulate_error (cp_parser* parser)
2466 {
2467   if (cp_parser_uncommitted_to_tentative_parse_p (parser))
2468     {
2469       parser->context->status = CP_PARSER_STATUS_KIND_ERROR;
2470       return true;
2471     }
2472   return false;
2473 }
2474
2475 /* Check for repeated decl-specifiers.  */
2476
2477 static void
2478 cp_parser_check_decl_spec (cp_decl_specifier_seq *decl_specs,
2479                            location_t location)
2480 {
2481   int ds;
2482
2483   for (ds = ds_first; ds != ds_last; ++ds)
2484     {
2485       unsigned count = decl_specs->specs[ds];
2486       if (count < 2)
2487         continue;
2488       /* The "long" specifier is a special case because of "long long".  */
2489       if (ds == ds_long)
2490         {
2491           if (count > 2)
2492             error_at (location, "%<long long long%> is too long for GCC");
2493           else 
2494             pedwarn_cxx98 (location, OPT_Wlong_long, 
2495                            "ISO C++ 1998 does not support %<long long%>");
2496         }
2497       else if (count > 1)
2498         {
2499           static const char *const decl_spec_names[] = {
2500             "signed",
2501             "unsigned",
2502             "short",
2503             "long",
2504             "const",
2505             "volatile",
2506             "restrict",
2507             "inline",
2508             "virtual",
2509             "explicit",
2510             "friend",
2511             "typedef",
2512             "constexpr",
2513             "__complex",
2514             "__thread"
2515           };
2516           error_at (location, "duplicate %qs", decl_spec_names[ds]);
2517         }
2518     }
2519 }
2520
2521 /* This function is called when a type is defined.  If type
2522    definitions are forbidden at this point, an error message is
2523    issued.  */
2524
2525 static bool
2526 cp_parser_check_type_definition (cp_parser* parser)
2527 {
2528   /* If types are forbidden here, issue a message.  */
2529   if (parser->type_definition_forbidden_message)
2530     {
2531       /* Don't use `%s' to print the string, because quotations (`%<', `%>')
2532          in the message need to be interpreted.  */
2533       error (parser->type_definition_forbidden_message);
2534       return false;
2535     }
2536   return true;
2537 }
2538
2539 /* This function is called when the DECLARATOR is processed.  The TYPE
2540    was a type defined in the decl-specifiers.  If it is invalid to
2541    define a type in the decl-specifiers for DECLARATOR, an error is
2542    issued. TYPE_LOCATION is the location of TYPE and is used
2543    for error reporting.  */
2544
2545 static void
2546 cp_parser_check_for_definition_in_return_type (cp_declarator *declarator,
2547                                                tree type, location_t type_location)
2548 {
2549   /* [dcl.fct] forbids type definitions in return types.
2550      Unfortunately, it's not easy to know whether or not we are
2551      processing a return type until after the fact.  */
2552   while (declarator
2553          && (declarator->kind == cdk_pointer
2554              || declarator->kind == cdk_reference
2555              || declarator->kind == cdk_ptrmem))
2556     declarator = declarator->declarator;
2557   if (declarator
2558       && declarator->kind == cdk_function)
2559     {
2560       error_at (type_location,
2561                 "new types may not be defined in a return type");
2562       inform (type_location, 
2563               "(perhaps a semicolon is missing after the definition of %qT)",
2564               type);
2565     }
2566 }
2567
2568 /* A type-specifier (TYPE) has been parsed which cannot be followed by
2569    "<" in any valid C++ program.  If the next token is indeed "<",
2570    issue a message warning the user about what appears to be an
2571    invalid attempt to form a template-id. LOCATION is the location
2572    of the type-specifier (TYPE) */
2573
2574 static void
2575 cp_parser_check_for_invalid_template_id (cp_parser* parser,
2576                                          tree type, location_t location)
2577 {
2578   cp_token_position start = 0;
2579
2580   if (cp_lexer_next_token_is (parser->lexer, CPP_LESS))
2581     {
2582       if (TYPE_P (type))
2583         error_at (location, "%qT is not a template", type);
2584       else if (TREE_CODE (type) == IDENTIFIER_NODE)
2585         error_at (location, "%qE is not a template", type);
2586       else
2587         error_at (location, "invalid template-id");
2588       /* Remember the location of the invalid "<".  */
2589       if (cp_parser_uncommitted_to_tentative_parse_p (parser))
2590         start = cp_lexer_token_position (parser->lexer, true);
2591       /* Consume the "<".  */
2592       cp_lexer_consume_token (parser->lexer);
2593       /* Parse the template arguments.  */
2594       cp_parser_enclosed_template_argument_list (parser);
2595       /* Permanently remove the invalid template arguments so that
2596          this error message is not issued again.  */
2597       if (start)
2598         cp_lexer_purge_tokens_after (parser->lexer, start);
2599     }
2600 }
2601
2602 /* If parsing an integral constant-expression, issue an error message
2603    about the fact that THING appeared and return true.  Otherwise,
2604    return false.  In either case, set
2605    PARSER->NON_INTEGRAL_CONSTANT_EXPRESSION_P.  */
2606
2607 static bool
2608 cp_parser_non_integral_constant_expression (cp_parser  *parser,
2609                                             non_integral_constant thing)
2610 {
2611   parser->non_integral_constant_expression_p = true;
2612   if (parser->integral_constant_expression_p)
2613     {
2614       if (!parser->allow_non_integral_constant_expression_p)
2615         {
2616           const char *msg = NULL;
2617           switch (thing)
2618             {
2619               case NIC_FLOAT:
2620                 error ("floating-point literal "
2621                        "cannot appear in a constant-expression");
2622                 return true;
2623               case NIC_CAST:
2624                 error ("a cast to a type other than an integral or "
2625                        "enumeration type cannot appear in a "
2626                        "constant-expression");
2627                 return true;
2628               case NIC_TYPEID:
2629                 error ("%<typeid%> operator "
2630                        "cannot appear in a constant-expression");
2631                 return true;
2632               case NIC_NCC:
2633                 error ("non-constant compound literals "
2634                        "cannot appear in a constant-expression");
2635                 return true;
2636               case NIC_FUNC_CALL:
2637                 error ("a function call "
2638                        "cannot appear in a constant-expression");
2639                 return true;
2640               case NIC_INC:
2641                 error ("an increment "
2642                        "cannot appear in a constant-expression");
2643                 return true;
2644               case NIC_DEC:
2645                 error ("an decrement "
2646                        "cannot appear in a constant-expression");
2647                 return true;
2648               case NIC_ARRAY_REF:
2649                 error ("an array reference "
2650                        "cannot appear in a constant-expression");
2651                 return true;
2652               case NIC_ADDR_LABEL:
2653                 error ("the address of a label "
2654                        "cannot appear in a constant-expression");
2655                 return true;
2656               case NIC_OVERLOADED:
2657                 error ("calls to overloaded operators "
2658                        "cannot appear in a constant-expression");
2659                 return true;
2660               case NIC_ASSIGNMENT:
2661                 error ("an assignment cannot appear in a constant-expression");
2662                 return true;
2663               case NIC_COMMA:
2664                 error ("a comma operator "
2665                        "cannot appear in a constant-expression");
2666                 return true;
2667               case NIC_CONSTRUCTOR:
2668                 error ("a call to a constructor "
2669                        "cannot appear in a constant-expression");
2670                 return true;
2671               case NIC_THIS:
2672                 msg = "this";
2673                 break;
2674               case NIC_FUNC_NAME:
2675                 msg = "__FUNCTION__";
2676                 break;
2677               case NIC_PRETTY_FUNC:
2678                 msg = "__PRETTY_FUNCTION__";
2679                 break;
2680               case NIC_C99_FUNC:
2681                 msg = "__func__";
2682                 break;
2683               case NIC_VA_ARG:
2684                 msg = "va_arg";
2685                 break;
2686               case NIC_ARROW:
2687                 msg = "->";
2688                 break;
2689               case NIC_POINT:
2690                 msg = ".";
2691                 break;
2692               case NIC_STAR:
2693                 msg = "*";
2694                 break;
2695               case NIC_ADDR:
2696                 msg = "&";
2697                 break;
2698               case NIC_PREINCREMENT:
2699                 msg = "++";
2700                 break;
2701               case NIC_PREDECREMENT:
2702                 msg = "--";
2703                 break;
2704               case NIC_NEW:
2705                 msg = "new";
2706                 break;
2707               case NIC_DEL:
2708                 msg = "delete";
2709                 break;
2710               default:
2711                 gcc_unreachable ();
2712             }
2713           if (msg)
2714             error ("%qs cannot appear in a constant-expression", msg);
2715           return true;
2716         }
2717     }
2718   return false;
2719 }
2720
2721 /* Emit a diagnostic for an invalid type name.  SCOPE is the
2722    qualifying scope (or NULL, if none) for ID.  This function commits
2723    to the current active tentative parse, if any.  (Otherwise, the
2724    problematic construct might be encountered again later, resulting
2725    in duplicate error messages.) LOCATION is the location of ID.  */
2726
2727 static void
2728 cp_parser_diagnose_invalid_type_name (cp_parser *parser,
2729                                       tree scope, tree id,
2730                                       location_t location)
2731 {
2732   tree decl, old_scope;
2733   cp_parser_commit_to_tentative_parse (parser);
2734   /* Try to lookup the identifier.  */
2735   old_scope = parser->scope;
2736   parser->scope = scope;
2737   decl = cp_parser_lookup_name_simple (parser, id, location);
2738   parser->scope = old_scope;
2739   /* If the lookup found a template-name, it means that the user forgot
2740   to specify an argument list. Emit a useful error message.  */
2741   if (TREE_CODE (decl) == TEMPLATE_DECL)
2742     error_at (location,
2743               "invalid use of template-name %qE without an argument list",
2744               decl);
2745   else if (TREE_CODE (id) == BIT_NOT_EXPR)
2746     error_at (location, "invalid use of destructor %qD as a type", id);
2747   else if (TREE_CODE (decl) == TYPE_DECL)
2748     /* Something like 'unsigned A a;'  */
2749     error_at (location, "invalid combination of multiple type-specifiers");
2750   else if (!parser->scope)
2751     {
2752       /* Issue an error message.  */
2753       error_at (location, "%qE does not name a type", id);
2754       /* If we're in a template class, it's possible that the user was
2755          referring to a type from a base class.  For example:
2756
2757            template <typename T> struct A { typedef T X; };
2758            template <typename T> struct B : public A<T> { X x; };
2759
2760          The user should have said "typename A<T>::X".  */
2761       if (cxx_dialect < cxx0x && id == ridpointers[(int)RID_CONSTEXPR])
2762         inform (location, "C++0x %<constexpr%> only available with "
2763                 "-std=c++0x or -std=gnu++0x");
2764       else if (processing_template_decl && current_class_type
2765                && TYPE_BINFO (current_class_type))
2766         {
2767           tree b;
2768
2769           for (b = TREE_CHAIN (TYPE_BINFO (current_class_type));
2770                b;
2771                b = TREE_CHAIN (b))
2772             {
2773               tree base_type = BINFO_TYPE (b);
2774               if (CLASS_TYPE_P (base_type)
2775                   && dependent_type_p (base_type))
2776                 {
2777                   tree field;
2778                   /* Go from a particular instantiation of the
2779                      template (which will have an empty TYPE_FIELDs),
2780                      to the main version.  */
2781                   base_type = CLASSTYPE_PRIMARY_TEMPLATE_TYPE (base_type);
2782                   for (field = TYPE_FIELDS (base_type);
2783                        field;
2784                        field = DECL_CHAIN (field))
2785                     if (TREE_CODE (field) == TYPE_DECL
2786                         && DECL_NAME (field) == id)
2787                       {
2788                         inform (location, 
2789                                 "(perhaps %<typename %T::%E%> was intended)",
2790                                 BINFO_TYPE (b), id);
2791                         break;
2792                       }
2793                   if (field)
2794                     break;
2795                 }
2796             }
2797         }
2798     }
2799   /* Here we diagnose qualified-ids where the scope is actually correct,
2800      but the identifier does not resolve to a valid type name.  */
2801   else if (parser->scope != error_mark_node)
2802     {
2803       if (TREE_CODE (parser->scope) == NAMESPACE_DECL)
2804         error_at (location, "%qE in namespace %qE does not name a type",
2805                   id, parser->scope);
2806       else if (CLASS_TYPE_P (parser->scope)
2807                && constructor_name_p (id, parser->scope))
2808         {
2809           /* A<T>::A<T>() */
2810           error_at (location, "%<%T::%E%> names the constructor, not"
2811                     " the type", parser->scope, id);
2812           if (cp_lexer_next_token_is (parser->lexer, CPP_LESS))
2813             error_at (location, "and %qT has no template constructors",
2814                       parser->scope);
2815         }
2816       else if (TYPE_P (parser->scope)
2817                && dependent_scope_p (parser->scope))
2818         error_at (location, "need %<typename%> before %<%T::%E%> because "
2819                   "%qT is a dependent scope",
2820                   parser->scope, id, parser->scope);
2821       else if (TYPE_P (parser->scope))
2822         error_at (location, "%qE in %q#T does not name a type",
2823                   id, parser->scope);
2824       else
2825         gcc_unreachable ();
2826     }
2827 }
2828
2829 /* Check for a common situation where a type-name should be present,
2830    but is not, and issue a sensible error message.  Returns true if an
2831    invalid type-name was detected.
2832
2833    The situation handled by this function are variable declarations of the
2834    form `ID a', where `ID' is an id-expression and `a' is a plain identifier.
2835    Usually, `ID' should name a type, but if we got here it means that it
2836    does not. We try to emit the best possible error message depending on
2837    how exactly the id-expression looks like.  */
2838
2839 static bool
2840 cp_parser_parse_and_diagnose_invalid_type_name (cp_parser *parser)
2841 {
2842   tree id;
2843   cp_token *token = cp_lexer_peek_token (parser->lexer);
2844
2845   /* Avoid duplicate error about ambiguous lookup.  */
2846   if (token->type == CPP_NESTED_NAME_SPECIFIER)
2847     {
2848       cp_token *next = cp_lexer_peek_nth_token (parser->lexer, 2);
2849       if (next->type == CPP_NAME && next->ambiguous_p)
2850         goto out;
2851     }
2852
2853   cp_parser_parse_tentatively (parser);
2854   id = cp_parser_id_expression (parser,
2855                                 /*template_keyword_p=*/false,
2856                                 /*check_dependency_p=*/true,
2857                                 /*template_p=*/NULL,
2858                                 /*declarator_p=*/true,
2859                                 /*optional_p=*/false);
2860   /* If the next token is a (, this is a function with no explicit return
2861      type, i.e. constructor, destructor or conversion op.  */
2862   if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN)
2863       || TREE_CODE (id) == TYPE_DECL)
2864     {
2865       cp_parser_abort_tentative_parse (parser);
2866       return false;
2867     }
2868   if (!cp_parser_parse_definitely (parser))
2869     return false;
2870
2871   /* Emit a diagnostic for the invalid type.  */
2872   cp_parser_diagnose_invalid_type_name (parser, parser->scope,
2873                                         id, token->location);
2874  out:
2875   /* If we aren't in the middle of a declarator (i.e. in a
2876      parameter-declaration-clause), skip to the end of the declaration;
2877      there's no point in trying to process it.  */
2878   if (!parser->in_declarator_p)
2879     cp_parser_skip_to_end_of_block_or_statement (parser);
2880   return true;
2881 }
2882
2883 /* Consume tokens up to, and including, the next non-nested closing `)'.
2884    Returns 1 iff we found a closing `)'.  RECOVERING is true, if we
2885    are doing error recovery. Returns -1 if OR_COMMA is true and we
2886    found an unnested comma.  */
2887
2888 static int
2889 cp_parser_skip_to_closing_parenthesis (cp_parser *parser,
2890                                        bool recovering,
2891                                        bool or_comma,
2892                                        bool consume_paren)
2893 {
2894   unsigned paren_depth = 0;
2895   unsigned brace_depth = 0;
2896   unsigned square_depth = 0;
2897
2898   if (recovering && !or_comma
2899       && cp_parser_uncommitted_to_tentative_parse_p (parser))
2900     return 0;
2901
2902   while (true)
2903     {
2904       cp_token * token = cp_lexer_peek_token (parser->lexer);
2905
2906       switch (token->type)
2907         {
2908         case CPP_EOF:
2909         case CPP_PRAGMA_EOL:
2910           /* If we've run out of tokens, then there is no closing `)'.  */
2911           return 0;
2912
2913         /* This is good for lambda expression capture-lists.  */
2914         case CPP_OPEN_SQUARE:
2915           ++square_depth;
2916           break;
2917         case CPP_CLOSE_SQUARE:
2918           if (!square_depth--)
2919             return 0;
2920           break;
2921
2922         case CPP_SEMICOLON:
2923           /* This matches the processing in skip_to_end_of_statement.  */
2924           if (!brace_depth)
2925             return 0;
2926           break;
2927
2928         case CPP_OPEN_BRACE:
2929           ++brace_depth;
2930           break;
2931         case CPP_CLOSE_BRACE:
2932           if (!brace_depth--)
2933             return 0;
2934           break;
2935
2936         case CPP_COMMA:
2937           if (recovering && or_comma && !brace_depth && !paren_depth
2938               && !square_depth)
2939             return -1;
2940           break;
2941
2942         case CPP_OPEN_PAREN:
2943           if (!brace_depth)
2944             ++paren_depth;
2945           break;
2946
2947         case CPP_CLOSE_PAREN:
2948           if (!brace_depth && !paren_depth--)
2949             {
2950               if (consume_paren)
2951                 cp_lexer_consume_token (parser->lexer);
2952               return 1;
2953             }
2954           break;
2955
2956         default:
2957           break;
2958         }
2959
2960       /* Consume the token.  */
2961       cp_lexer_consume_token (parser->lexer);
2962     }
2963 }
2964
2965 /* Consume tokens until we reach the end of the current statement.
2966    Normally, that will be just before consuming a `;'.  However, if a
2967    non-nested `}' comes first, then we stop before consuming that.  */
2968
2969 static void
2970 cp_parser_skip_to_end_of_statement (cp_parser* parser)
2971 {
2972   unsigned nesting_depth = 0;
2973
2974   while (true)
2975     {
2976       cp_token *token = cp_lexer_peek_token (parser->lexer);
2977
2978       switch (token->type)
2979         {
2980         case CPP_EOF:
2981         case CPP_PRAGMA_EOL:
2982           /* If we've run out of tokens, stop.  */
2983           return;
2984
2985         case CPP_SEMICOLON:
2986           /* If the next token is a `;', we have reached the end of the
2987              statement.  */
2988           if (!nesting_depth)
2989             return;
2990           break;
2991
2992         case CPP_CLOSE_BRACE:
2993           /* If this is a non-nested '}', stop before consuming it.
2994              That way, when confronted with something like:
2995
2996                { 3 + }
2997
2998              we stop before consuming the closing '}', even though we
2999              have not yet reached a `;'.  */
3000           if (nesting_depth == 0)
3001             return;
3002
3003           /* If it is the closing '}' for a block that we have
3004              scanned, stop -- but only after consuming the token.
3005              That way given:
3006
3007                 void f g () { ... }
3008                 typedef int I;
3009
3010              we will stop after the body of the erroneously declared
3011              function, but before consuming the following `typedef'
3012              declaration.  */
3013           if (--nesting_depth == 0)
3014             {
3015               cp_lexer_consume_token (parser->lexer);
3016               return;
3017             }
3018
3019         case CPP_OPEN_BRACE:
3020           ++nesting_depth;
3021           break;
3022
3023         default:
3024           break;
3025         }
3026
3027       /* Consume the token.  */
3028       cp_lexer_consume_token (parser->lexer);
3029     }
3030 }
3031
3032 /* This function is called at the end of a statement or declaration.
3033    If the next token is a semicolon, it is consumed; otherwise, error
3034    recovery is attempted.  */
3035
3036 static void
3037 cp_parser_consume_semicolon_at_end_of_statement (cp_parser *parser)
3038 {
3039   /* Look for the trailing `;'.  */
3040   if (!cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON))
3041     {
3042       /* If there is additional (erroneous) input, skip to the end of
3043          the statement.  */
3044       cp_parser_skip_to_end_of_statement (parser);
3045       /* If the next token is now a `;', consume it.  */
3046       if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
3047         cp_lexer_consume_token (parser->lexer);
3048     }
3049 }
3050
3051 /* Skip tokens until we have consumed an entire block, or until we
3052    have consumed a non-nested `;'.  */
3053
3054 static void
3055 cp_parser_skip_to_end_of_block_or_statement (cp_parser* parser)
3056 {
3057   int nesting_depth = 0;
3058
3059   while (nesting_depth >= 0)
3060     {
3061       cp_token *token = cp_lexer_peek_token (parser->lexer);
3062
3063       switch (token->type)
3064         {
3065         case CPP_EOF:
3066         case CPP_PRAGMA_EOL:
3067           /* If we've run out of tokens, stop.  */
3068           return;
3069
3070         case CPP_SEMICOLON:
3071           /* Stop if this is an unnested ';'. */
3072           if (!nesting_depth)
3073             nesting_depth = -1;
3074           break;
3075
3076         case CPP_CLOSE_BRACE:
3077           /* Stop if this is an unnested '}', or closes the outermost
3078              nesting level.  */
3079           nesting_depth--;
3080           if (nesting_depth < 0)
3081             return;
3082           if (!nesting_depth)
3083             nesting_depth = -1;
3084           break;
3085
3086         case CPP_OPEN_BRACE:
3087           /* Nest. */
3088           nesting_depth++;
3089           break;
3090
3091         default:
3092           break;
3093         }
3094
3095       /* Consume the token.  */
3096       cp_lexer_consume_token (parser->lexer);
3097     }
3098 }
3099
3100 /* Skip tokens until a non-nested closing curly brace is the next
3101    token, or there are no more tokens. Return true in the first case,
3102    false otherwise.  */
3103
3104 static bool
3105 cp_parser_skip_to_closing_brace (cp_parser *parser)
3106 {
3107   unsigned nesting_depth = 0;
3108
3109   while (true)
3110     {
3111       cp_token *token = cp_lexer_peek_token (parser->lexer);
3112
3113       switch (token->type)
3114         {
3115         case CPP_EOF:
3116         case CPP_PRAGMA_EOL:
3117           /* If we've run out of tokens, stop.  */
3118           return false;
3119
3120         case CPP_CLOSE_BRACE:
3121           /* If the next token is a non-nested `}', then we have reached
3122              the end of the current block.  */
3123           if (nesting_depth-- == 0)
3124             return true;
3125           break;
3126
3127         case CPP_OPEN_BRACE:
3128           /* If it the next token is a `{', then we are entering a new
3129              block.  Consume the entire block.  */
3130           ++nesting_depth;
3131           break;
3132
3133         default:
3134           break;
3135         }
3136
3137       /* Consume the token.  */
3138       cp_lexer_consume_token (parser->lexer);
3139     }
3140 }
3141
3142 /* Consume tokens until we reach the end of the pragma.  The PRAGMA_TOK
3143    parameter is the PRAGMA token, allowing us to purge the entire pragma
3144    sequence.  */
3145
3146 static void
3147 cp_parser_skip_to_pragma_eol (cp_parser* parser, cp_token *pragma_tok)
3148 {
3149   cp_token *token;
3150
3151   parser->lexer->in_pragma = false;
3152
3153   do
3154     token = cp_lexer_consume_token (parser->lexer);
3155   while (token->type != CPP_PRAGMA_EOL && token->type != CPP_EOF);
3156
3157   /* Ensure that the pragma is not parsed again.  */
3158   cp_lexer_purge_tokens_after (parser->lexer, pragma_tok);
3159 }
3160
3161 /* Require pragma end of line, resyncing with it as necessary.  The
3162    arguments are as for cp_parser_skip_to_pragma_eol.  */
3163
3164 static void
3165 cp_parser_require_pragma_eol (cp_parser *parser, cp_token *pragma_tok)
3166 {
3167   parser->lexer->in_pragma = false;
3168   if (!cp_parser_require (parser, CPP_PRAGMA_EOL, RT_PRAGMA_EOL))
3169     cp_parser_skip_to_pragma_eol (parser, pragma_tok);
3170 }
3171
3172 /* This is a simple wrapper around make_typename_type. When the id is
3173    an unresolved identifier node, we can provide a superior diagnostic
3174    using cp_parser_diagnose_invalid_type_name.  */
3175
3176 static tree
3177 cp_parser_make_typename_type (cp_parser *parser, tree scope,
3178                               tree id, location_t id_location)
3179 {
3180   tree result;
3181   if (TREE_CODE (id) == IDENTIFIER_NODE)
3182     {
3183       result = make_typename_type (scope, id, typename_type,
3184                                    /*complain=*/tf_none);
3185       if (result == error_mark_node)
3186         cp_parser_diagnose_invalid_type_name (parser, scope, id, id_location);
3187       return result;
3188     }
3189   return make_typename_type (scope, id, typename_type, tf_error);
3190 }
3191
3192 /* This is a wrapper around the
3193    make_{pointer,ptrmem,reference}_declarator functions that decides
3194    which one to call based on the CODE and CLASS_TYPE arguments. The
3195    CODE argument should be one of the values returned by
3196    cp_parser_ptr_operator. */
3197 static cp_declarator *
3198 cp_parser_make_indirect_declarator (enum tree_code code, tree class_type,
3199                                     cp_cv_quals cv_qualifiers,
3200                                     cp_declarator *target)
3201 {
3202   if (code == ERROR_MARK)
3203     return cp_error_declarator;
3204
3205   if (code == INDIRECT_REF)
3206     if (class_type == NULL_TREE)
3207       return make_pointer_declarator (cv_qualifiers, target);
3208     else
3209       return make_ptrmem_declarator (cv_qualifiers, class_type, target);
3210   else if (code == ADDR_EXPR && class_type == NULL_TREE)
3211     return make_reference_declarator (cv_qualifiers, target, false);
3212   else if (code == NON_LVALUE_EXPR && class_type == NULL_TREE)
3213     return make_reference_declarator (cv_qualifiers, target, true);
3214   gcc_unreachable ();
3215 }
3216
3217 /* Create a new C++ parser.  */
3218
3219 static cp_parser *
3220 cp_parser_new (void)
3221 {
3222   cp_parser *parser;
3223   cp_lexer *lexer;
3224   unsigned i;
3225
3226   /* cp_lexer_new_main is called before doing GC allocation because
3227      cp_lexer_new_main might load a PCH file.  */
3228   lexer = cp_lexer_new_main ();
3229
3230   /* Initialize the binops_by_token so that we can get the tree
3231      directly from the token.  */
3232   for (i = 0; i < sizeof (binops) / sizeof (binops[0]); i++)
3233     binops_by_token[binops[i].token_type] = binops[i];
3234
3235   parser = ggc_alloc_cleared_cp_parser ();
3236   parser->lexer = lexer;
3237   parser->context = cp_parser_context_new (NULL);
3238
3239   /* For now, we always accept GNU extensions.  */
3240   parser->allow_gnu_extensions_p = 1;
3241
3242   /* The `>' token is a greater-than operator, not the end of a
3243      template-id.  */
3244   parser->greater_than_is_operator_p = true;
3245
3246   parser->default_arg_ok_p = true;
3247
3248   /* We are not parsing a constant-expression.  */
3249   parser->integral_constant_expression_p = false;
3250   parser->allow_non_integral_constant_expression_p = false;
3251   parser->non_integral_constant_expression_p = false;
3252
3253   /* Local variable names are not forbidden.  */
3254   parser->local_variables_forbidden_p = false;
3255
3256   /* We are not processing an `extern "C"' declaration.  */
3257   parser->in_unbraced_linkage_specification_p = false;
3258
3259   /* We are not processing a declarator.  */
3260   parser->in_declarator_p = false;
3261
3262   /* We are not processing a template-argument-list.  */
3263   parser->in_template_argument_list_p = false;
3264
3265   /* We are not in an iteration statement.  */
3266   parser->in_statement = 0;
3267
3268   /* We are not in a switch statement.  */
3269   parser->in_switch_statement_p = false;
3270
3271   /* We are not parsing a type-id inside an expression.  */
3272   parser->in_type_id_in_expr_p = false;
3273
3274   /* Declarations aren't implicitly extern "C".  */
3275   parser->implicit_extern_c = false;
3276
3277   /* String literals should be translated to the execution character set.  */
3278   parser->translate_strings_p = true;
3279
3280   /* We are not parsing a function body.  */
3281   parser->in_function_body = false;
3282
3283   /* We can correct until told otherwise.  */
3284   parser->colon_corrects_to_scope_p = true;
3285
3286   /* The unparsed function queue is empty.  */
3287   push_unparsed_function_queues (parser);
3288
3289   /* There are no classes being defined.  */
3290   parser->num_classes_being_defined = 0;
3291
3292   /* No template parameters apply.  */
3293   parser->num_template_parameter_lists = 0;
3294
3295   return parser;
3296 }
3297
3298 /* Create a cp_lexer structure which will emit the tokens in CACHE
3299    and push it onto the parser's lexer stack.  This is used for delayed
3300    parsing of in-class method bodies and default arguments, and should
3301    not be confused with tentative parsing.  */
3302 static void
3303 cp_parser_push_lexer_for_tokens (cp_parser *parser, cp_token_cache *cache)
3304 {
3305   cp_lexer *lexer = cp_lexer_new_from_tokens (cache);
3306   lexer->next = parser->lexer;
3307   parser->lexer = lexer;
3308
3309   /* Move the current source position to that of the first token in the
3310      new lexer.  */
3311   cp_lexer_set_source_position_from_token (lexer->next_token);
3312 }
3313
3314 /* Pop the top lexer off the parser stack.  This is never used for the
3315    "main" lexer, only for those pushed by cp_parser_push_lexer_for_tokens.  */
3316 static void
3317 cp_parser_pop_lexer (cp_parser *parser)
3318 {
3319   cp_lexer *lexer = parser->lexer;
3320   parser->lexer = lexer->next;
3321   cp_lexer_destroy (lexer);
3322
3323   /* Put the current source position back where it was before this
3324      lexer was pushed.  */
3325   cp_lexer_set_source_position_from_token (parser->lexer->next_token);
3326 }
3327
3328 /* Lexical conventions [gram.lex]  */
3329
3330 /* Parse an identifier.  Returns an IDENTIFIER_NODE representing the
3331    identifier.  */
3332
3333 static tree
3334 cp_parser_identifier (cp_parser* parser)
3335 {
3336   cp_token *token;
3337
3338   /* Look for the identifier.  */
3339   token = cp_parser_require (parser, CPP_NAME, RT_NAME);
3340   /* Return the value.  */
3341   return token ? token->u.value : error_mark_node;
3342 }
3343
3344 /* Parse a sequence of adjacent string constants.  Returns a
3345    TREE_STRING representing the combined, nul-terminated string
3346    constant.  If TRANSLATE is true, translate the string to the
3347    execution character set.  If WIDE_OK is true, a wide string is
3348    invalid here.
3349
3350    C++98 [lex.string] says that if a narrow string literal token is
3351    adjacent to a wide string literal token, the behavior is undefined.
3352    However, C99 6.4.5p4 says that this results in a wide string literal.
3353    We follow C99 here, for consistency with the C front end.
3354
3355    This code is largely lifted from lex_string() in c-lex.c.
3356
3357    FUTURE: ObjC++ will need to handle @-strings here.  */
3358 static tree
3359 cp_parser_string_literal (cp_parser *parser, bool translate, bool wide_ok)
3360 {
3361   tree value;
3362   size_t count;
3363   struct obstack str_ob;
3364   cpp_string str, istr, *strs;
3365   cp_token *tok;
3366   enum cpp_ttype type, curr_type;
3367   int have_suffix_p = 0;
3368   tree string_tree;
3369   tree suffix_id = NULL_TREE;
3370   bool curr_tok_is_userdef_p = false;
3371
3372   tok = cp_lexer_peek_token (parser->lexer);
3373   if (!cp_parser_is_string_literal (tok))
3374     {
3375       cp_parser_error (parser, "expected string-literal");
3376       return error_mark_node;
3377     }
3378
3379   if (cpp_userdef_string_p (tok->type))
3380     {
3381       string_tree = USERDEF_LITERAL_VALUE (tok->u.value);
3382       curr_type = cpp_userdef_string_remove_type (tok->type);
3383       curr_tok_is_userdef_p = true;
3384     }
3385   else
3386     {
3387       string_tree = tok->u.value;
3388       curr_type = tok->type;
3389     }
3390   type = curr_type;
3391
3392   /* Try to avoid the overhead of creating and destroying an obstack
3393      for the common case of just one string.  */
3394   if (!cp_parser_is_string_literal
3395       (cp_lexer_peek_nth_token (parser->lexer, 2)))
3396     {
3397       cp_lexer_consume_token (parser->lexer);
3398
3399       str.text = (const unsigned char *)TREE_STRING_POINTER (string_tree);
3400       str.len = TREE_STRING_LENGTH (string_tree);
3401       count = 1;
3402
3403       if (curr_tok_is_userdef_p)
3404         {
3405           suffix_id = USERDEF_LITERAL_SUFFIX_ID (tok->u.value);
3406           have_suffix_p = 1;
3407           curr_type = cpp_userdef_string_remove_type (tok->type);
3408         }
3409       else
3410         curr_type = tok->type;
3411
3412       strs = &str;
3413     }
3414   else
3415     {
3416       gcc_obstack_init (&str_ob);
3417       count = 0;
3418
3419       do
3420         {
3421           cp_lexer_consume_token (parser->lexer);
3422           count++;
3423           str.text = (const unsigned char *)TREE_STRING_POINTER (string_tree);
3424           str.len = TREE_STRING_LENGTH (string_tree);
3425
3426           if (curr_tok_is_userdef_p)
3427             {
3428               tree curr_suffix_id = USERDEF_LITERAL_SUFFIX_ID (tok->u.value);
3429               if (have_suffix_p == 0)
3430                 {
3431                   suffix_id = curr_suffix_id;
3432                   have_suffix_p = 1;
3433                 }
3434               else if (have_suffix_p == 1
3435                        && curr_suffix_id != suffix_id)
3436                 {
3437                   error ("inconsistent user-defined literal suffixes"
3438                          " %qD and %qD in string literal",
3439                          suffix_id, curr_suffix_id);
3440                   have_suffix_p = -1;
3441                 }
3442               curr_type = cpp_userdef_string_remove_type (tok->type);
3443             }
3444           else
3445             curr_type = tok->type;
3446
3447           if (type != curr_type)
3448             {
3449               if (type == CPP_STRING)
3450                 type = curr_type;
3451               else if (curr_type != CPP_STRING)
3452                 error_at (tok->location,
3453                           "unsupported non-standard concatenation "
3454                           "of string literals");
3455             }
3456
3457           obstack_grow (&str_ob, &str, sizeof (cpp_string));
3458
3459           tok = cp_lexer_peek_token (parser->lexer);
3460           if (cpp_userdef_string_p (tok->type))
3461             {
3462               string_tree = USERDEF_LITERAL_VALUE (tok->u.value);
3463               curr_type = cpp_userdef_string_remove_type (tok->type);
3464               curr_tok_is_userdef_p = true;
3465             }
3466           else
3467             {
3468               string_tree = tok->u.value;
3469               curr_type = tok->type;
3470               curr_tok_is_userdef_p = false;
3471             }
3472         }
3473       while (cp_parser_is_string_literal (tok));
3474
3475       strs = (cpp_string *) obstack_finish (&str_ob);
3476     }
3477
3478   if (type != CPP_STRING && !wide_ok)
3479     {
3480       cp_parser_error (parser, "a wide string is invalid in this context");
3481       type = CPP_STRING;
3482     }
3483
3484   if ((translate ? cpp_interpret_string : cpp_interpret_string_notranslate)
3485       (parse_in, strs, count, &istr, type))
3486     {
3487       value = build_string (istr.len, (const char *)istr.text);
3488       free (CONST_CAST (unsigned char *, istr.text));
3489
3490       switch (type)
3491         {
3492         default:
3493         case CPP_STRING:
3494         case CPP_UTF8STRING:
3495           TREE_TYPE (value) = char_array_type_node;
3496           break;
3497         case CPP_STRING16:
3498           TREE_TYPE (value) = char16_array_type_node;
3499           break;
3500         case CPP_STRING32:
3501           TREE_TYPE (value) = char32_array_type_node;
3502           break;
3503         case CPP_WSTRING:
3504           TREE_TYPE (value) = wchar_array_type_node;
3505           break;
3506         }
3507
3508       value = fix_string_type (value);
3509
3510       if (have_suffix_p)
3511         {
3512           tree literal = build_userdef_literal (suffix_id, value, NULL_TREE);
3513           tok->u.value = literal;
3514           return cp_parser_userdef_string_literal (tok);
3515         }
3516     }
3517   else
3518     /* cpp_interpret_string has issued an error.  */
3519     value = error_mark_node;
3520
3521   if (count > 1)
3522     obstack_free (&str_ob, 0);
3523
3524   return value;
3525 }
3526
3527 /* Parse a user-defined char constant.  Returns a call to a user-defined
3528    literal operator taking the character as an argument.  */
3529
3530 static tree
3531 cp_parser_userdef_char_literal (cp_parser *parser)
3532 {
3533   cp_token *token = NULL;
3534   tree literal, suffix_id, value;
3535   tree name, decl;
3536   tree result;
3537   VEC(tree,gc) *vec;
3538
3539   token = cp_lexer_consume_token (parser->lexer);
3540   literal = token->u.value;
3541   suffix_id = USERDEF_LITERAL_SUFFIX_ID (literal);
3542   value = USERDEF_LITERAL_VALUE (literal);
3543   name = cp_literal_operator_id (IDENTIFIER_POINTER (suffix_id));
3544
3545   /* Build up a call to the user-defined operator  */
3546   /* Lookup the name we got back from the id-expression.  */
3547   vec = make_tree_vector ();
3548   VEC_safe_push (tree, gc, vec, value);
3549   decl = lookup_function_nonclass (name, vec, /*block_p=*/false);
3550   if (!decl || decl == error_mark_node)
3551     {
3552       error ("unable to find user-defined character literal operator %qD",
3553              name);
3554       release_tree_vector (vec);
3555       return error_mark_node;
3556     }
3557   result = finish_call_expr (decl, &vec, false, true, tf_warning_or_error);
3558   release_tree_vector (vec);
3559
3560   return result;
3561 }
3562
3563 /* A subroutine of cp_parser_userdef_numeric_literal to
3564    create a char... template parameter pack from a string node.  */
3565
3566 static tree
3567 make_char_string_pack (tree value)
3568 {
3569   tree charvec;
3570   tree argpack = make_node (NONTYPE_ARGUMENT_PACK);
3571   const char *str = TREE_STRING_POINTER (value);
3572   int i, len = TREE_STRING_LENGTH (value) - 1;
3573   tree argvec = make_tree_vec (1);
3574
3575   /* Fill in CHARVEC with all of the parameters.  */
3576   charvec = make_tree_vec (len);
3577   for (i = 0; i < len; ++i)
3578     TREE_VEC_ELT (charvec, i) = build_int_cst (char_type_node, str[i]);
3579
3580   /* Build the argument packs.  */
3581   SET_ARGUMENT_PACK_ARGS (argpack, charvec);
3582   TREE_TYPE (argpack) = char_type_node;
3583
3584   TREE_VEC_ELT (argvec, 0) = argpack;
3585
3586   return argvec;
3587 }
3588
3589 /* Parse a user-defined numeric constant.  returns a call to a user-defined
3590    literal operator.  */
3591
3592 static tree
3593 cp_parser_userdef_numeric_literal (cp_parser *parser)
3594 {
3595   cp_token *token = NULL;
3596   tree literal, suffix_id, value, num_string;
3597   tree name, decl;
3598   tree result = error_mark_node;
3599   VEC(tree,gc) *args;
3600
3601   token = cp_lexer_consume_token (parser->lexer);
3602   literal = token->u.value;
3603   suffix_id = USERDEF_LITERAL_SUFFIX_ID (literal);
3604   value = USERDEF_LITERAL_VALUE (literal);
3605   num_string = USERDEF_LITERAL_NUM_STRING (literal);
3606   name = cp_literal_operator_id (IDENTIFIER_POINTER (suffix_id));
3607
3608   /* Build up a call to the user-defined operator  */
3609   /* Lookup the name we got back from the id-expression.  */
3610   /* Try to find the literal operator by finishing the call expression
3611      with the numeric argument.  */
3612   args = make_tree_vector ();
3613   VEC_safe_push (tree, gc, args, value);
3614   decl = lookup_function_nonclass (name, args, /*block_p=*/false);
3615   if (decl && decl != error_mark_node)
3616     {
3617       result = finish_call_expr (decl, &args, false, true, tf_none);
3618       if (result != error_mark_node)
3619         {
3620           release_tree_vector (args);
3621           return result;
3622         }
3623     }
3624   release_tree_vector (args);
3625
3626   /* If the numeric argument didn't work, look for a raw literal
3627      operator taking a const char* argument consisting of the number
3628      in string format.  */
3629   args = make_tree_vector ();
3630   VEC_safe_push (tree, gc, args, num_string);
3631   decl = lookup_function_nonclass (name, args, /*block_p=*/false);
3632   if (decl && decl != error_mark_node)
3633     {
3634       result = finish_call_expr (decl, &args, false, true, tf_none);
3635       if (result != error_mark_node)
3636         {
3637           release_tree_vector (args);
3638           return result;
3639         }
3640     }
3641   release_tree_vector (args);
3642
3643   /* If the raw literal didn't work, look for a non-type template
3644      function with parameter pack char....  Call the function with
3645      template parameter characters representing the number.  */
3646   args = make_tree_vector ();
3647   decl = lookup_function_nonclass (name, args, /*block_p=*/false);
3648   if (decl && decl != error_mark_node)
3649     {
3650       tree tmpl_args = make_char_string_pack (num_string);
3651       decl = lookup_template_function (decl, tmpl_args);
3652       result = finish_call_expr (decl, &args, false, true, tf_none);
3653       if (result != error_mark_node)
3654         {
3655           release_tree_vector (args);
3656           return result;
3657         }
3658     }
3659   release_tree_vector (args);
3660
3661   if (result == error_mark_node)
3662     error ("unable to find user-defined numeric literal operator %qD", name);
3663
3664   return result;