OSDN Git Service

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