OSDN Git Service

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