OSDN Git Service

05151cd300b763055f26cfa07b7582cd6301889c
[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);
1397 static tree cp_parser_unqualified_id
1398   (cp_parser *, 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 void cp_parser_label_for_labeled_statement
1455   (cp_parser *);
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 bool cp_parser_using_declaration
1522   (cp_parser *, bool);
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);
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_to_end_of_template_parameter_list
1823   (cp_parser *);
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 (TREE_CODE (decl) == TYPE_DECL)
2105     /* Something like 'unsigned A a;'  */
2106     error ("invalid combination of multiple type-specifiers");
2107   else if (!parser->scope)
2108     {
2109       /* Issue an error message.  */
2110       error ("%qE does not name a type", id);
2111       /* If we're in a template class, it's possible that the user was
2112          referring to a type from a base class.  For example:
2113
2114            template <typename T> struct A { typedef T X; };
2115            template <typename T> struct B : public A<T> { X x; };
2116
2117          The user should have said "typename A<T>::X".  */
2118       if (processing_template_decl && current_class_type
2119           && TYPE_BINFO (current_class_type))
2120         {
2121           tree b;
2122
2123           for (b = TREE_CHAIN (TYPE_BINFO (current_class_type));
2124                b;
2125                b = TREE_CHAIN (b))
2126             {
2127               tree base_type = BINFO_TYPE (b);
2128               if (CLASS_TYPE_P (base_type)
2129                   && dependent_type_p (base_type))
2130                 {
2131                   tree field;
2132                   /* Go from a particular instantiation of the
2133                      template (which will have an empty TYPE_FIELDs),
2134                      to the main version.  */
2135                   base_type = CLASSTYPE_PRIMARY_TEMPLATE_TYPE (base_type);
2136                   for (field = TYPE_FIELDS (base_type);
2137                        field;
2138                        field = TREE_CHAIN (field))
2139                     if (TREE_CODE (field) == TYPE_DECL
2140                         && DECL_NAME (field) == id)
2141                       {
2142                         inform ("(perhaps %<typename %T::%E%> was intended)",
2143                                 BINFO_TYPE (b), id);
2144                         break;
2145                       }
2146                   if (field)
2147                     break;
2148                 }
2149             }
2150         }
2151     }
2152   /* Here we diagnose qualified-ids where the scope is actually correct,
2153      but the identifier does not resolve to a valid type name.  */
2154   else if (parser->scope != error_mark_node)
2155     {
2156       if (TREE_CODE (parser->scope) == NAMESPACE_DECL)
2157         error ("%qE in namespace %qE does not name a type",
2158                id, parser->scope);
2159       else if (TYPE_P (parser->scope))
2160         error ("%qE in class %qT does not name a type", id, parser->scope);
2161       else
2162         gcc_unreachable ();
2163     }
2164   cp_parser_commit_to_tentative_parse (parser);
2165 }
2166
2167 /* Check for a common situation where a type-name should be present,
2168    but is not, and issue a sensible error message.  Returns true if an
2169    invalid type-name was detected.
2170
2171    The situation handled by this function are variable declarations of the
2172    form `ID a', where `ID' is an id-expression and `a' is a plain identifier.
2173    Usually, `ID' should name a type, but if we got here it means that it
2174    does not. We try to emit the best possible error message depending on
2175    how exactly the id-expression looks like.  */
2176
2177 static bool
2178 cp_parser_parse_and_diagnose_invalid_type_name (cp_parser *parser)
2179 {
2180   tree id;
2181
2182   cp_parser_parse_tentatively (parser);
2183   id = cp_parser_id_expression (parser,
2184                                 /*template_keyword_p=*/false,
2185                                 /*check_dependency_p=*/true,
2186                                 /*template_p=*/NULL,
2187                                 /*declarator_p=*/true,
2188                                 /*optional_p=*/false);
2189   /* After the id-expression, there should be a plain identifier,
2190      otherwise this is not a simple variable declaration. Also, if
2191      the scope is dependent, we cannot do much.  */
2192   if (!cp_lexer_next_token_is (parser->lexer, CPP_NAME)
2193       || (parser->scope && TYPE_P (parser->scope)
2194           && dependent_type_p (parser->scope)))
2195     {
2196       cp_parser_abort_tentative_parse (parser);
2197       return false;
2198     }
2199   if (!cp_parser_parse_definitely (parser) || TREE_CODE (id) == TYPE_DECL)
2200     return false;
2201
2202   /* Emit a diagnostic for the invalid type.  */
2203   cp_parser_diagnose_invalid_type_name (parser, parser->scope, id);
2204   /* Skip to the end of the declaration; there's no point in
2205      trying to process it.  */
2206   cp_parser_skip_to_end_of_block_or_statement (parser);
2207   return true;
2208 }
2209
2210 /* Consume tokens up to, and including, the next non-nested closing `)'.
2211    Returns 1 iff we found a closing `)'.  RECOVERING is true, if we
2212    are doing error recovery. Returns -1 if OR_COMMA is true and we
2213    found an unnested comma.  */
2214
2215 static int
2216 cp_parser_skip_to_closing_parenthesis (cp_parser *parser,
2217                                        bool recovering,
2218                                        bool or_comma,
2219                                        bool consume_paren)
2220 {
2221   unsigned paren_depth = 0;
2222   unsigned brace_depth = 0;
2223
2224   if (recovering && !or_comma
2225       && cp_parser_uncommitted_to_tentative_parse_p (parser))
2226     return 0;
2227
2228   while (true)
2229     {
2230       cp_token * token = cp_lexer_peek_token (parser->lexer);
2231
2232       switch (token->type)
2233         {
2234         case CPP_EOF:
2235         case CPP_PRAGMA_EOL:
2236           /* If we've run out of tokens, then there is no closing `)'.  */
2237           return 0;
2238
2239         case CPP_SEMICOLON:
2240           /* This matches the processing in skip_to_end_of_statement.  */
2241           if (!brace_depth)
2242             return 0;
2243           break;
2244
2245         case CPP_OPEN_BRACE:
2246           ++brace_depth;
2247           break;
2248         case CPP_CLOSE_BRACE:
2249           if (!brace_depth--)
2250             return 0;
2251           break;
2252
2253         case CPP_COMMA:
2254           if (recovering && or_comma && !brace_depth && !paren_depth)
2255             return -1;
2256           break;
2257
2258         case CPP_OPEN_PAREN:
2259           if (!brace_depth)
2260             ++paren_depth;
2261           break;
2262
2263         case CPP_CLOSE_PAREN:
2264           if (!brace_depth && !paren_depth--)
2265             {
2266               if (consume_paren)
2267                 cp_lexer_consume_token (parser->lexer);
2268               return 1;
2269             }
2270           break;
2271
2272         default:
2273           break;
2274         }
2275
2276       /* Consume the token.  */
2277       cp_lexer_consume_token (parser->lexer);
2278     }
2279 }
2280
2281 /* Consume tokens until we reach the end of the current statement.
2282    Normally, that will be just before consuming a `;'.  However, if a
2283    non-nested `}' comes first, then we stop before consuming that.  */
2284
2285 static void
2286 cp_parser_skip_to_end_of_statement (cp_parser* parser)
2287 {
2288   unsigned nesting_depth = 0;
2289
2290   while (true)
2291     {
2292       cp_token *token = cp_lexer_peek_token (parser->lexer);
2293
2294       switch (token->type)
2295         {
2296         case CPP_EOF:
2297         case CPP_PRAGMA_EOL:
2298           /* If we've run out of tokens, stop.  */
2299           return;
2300
2301         case CPP_SEMICOLON:
2302           /* If the next token is a `;', we have reached the end of the
2303              statement.  */
2304           if (!nesting_depth)
2305             return;
2306           break;
2307
2308         case CPP_CLOSE_BRACE:
2309           /* If this is a non-nested '}', stop before consuming it.
2310              That way, when confronted with something like:
2311
2312                { 3 + }
2313
2314              we stop before consuming the closing '}', even though we
2315              have not yet reached a `;'.  */
2316           if (nesting_depth == 0)
2317             return;
2318
2319           /* If it is the closing '}' for a block that we have
2320              scanned, stop -- but only after consuming the token.
2321              That way given:
2322
2323                 void f g () { ... }
2324                 typedef int I;
2325
2326              we will stop after the body of the erroneously declared
2327              function, but before consuming the following `typedef'
2328              declaration.  */
2329           if (--nesting_depth == 0)
2330             {
2331               cp_lexer_consume_token (parser->lexer);
2332               return;
2333             }
2334
2335         case CPP_OPEN_BRACE:
2336           ++nesting_depth;
2337           break;
2338
2339         default:
2340           break;
2341         }
2342
2343       /* Consume the token.  */
2344       cp_lexer_consume_token (parser->lexer);
2345     }
2346 }
2347
2348 /* This function is called at the end of a statement or declaration.
2349    If the next token is a semicolon, it is consumed; otherwise, error
2350    recovery is attempted.  */
2351
2352 static void
2353 cp_parser_consume_semicolon_at_end_of_statement (cp_parser *parser)
2354 {
2355   /* Look for the trailing `;'.  */
2356   if (!cp_parser_require (parser, CPP_SEMICOLON, "`;'"))
2357     {
2358       /* If there is additional (erroneous) input, skip to the end of
2359          the statement.  */
2360       cp_parser_skip_to_end_of_statement (parser);
2361       /* If the next token is now a `;', consume it.  */
2362       if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
2363         cp_lexer_consume_token (parser->lexer);
2364     }
2365 }
2366
2367 /* Skip tokens until we have consumed an entire block, or until we
2368    have consumed a non-nested `;'.  */
2369
2370 static void
2371 cp_parser_skip_to_end_of_block_or_statement (cp_parser* parser)
2372 {
2373   int nesting_depth = 0;
2374
2375   while (nesting_depth >= 0)
2376     {
2377       cp_token *token = cp_lexer_peek_token (parser->lexer);
2378
2379       switch (token->type)
2380         {
2381         case CPP_EOF:
2382         case CPP_PRAGMA_EOL:
2383           /* If we've run out of tokens, stop.  */
2384           return;
2385
2386         case CPP_SEMICOLON:
2387           /* Stop if this is an unnested ';'. */
2388           if (!nesting_depth)
2389             nesting_depth = -1;
2390           break;
2391
2392         case CPP_CLOSE_BRACE:
2393           /* Stop if this is an unnested '}', or closes the outermost
2394              nesting level.  */
2395           nesting_depth--;
2396           if (!nesting_depth)
2397             nesting_depth = -1;
2398           break;
2399
2400         case CPP_OPEN_BRACE:
2401           /* Nest. */
2402           nesting_depth++;
2403           break;
2404
2405         default:
2406           break;
2407         }
2408
2409       /* Consume the token.  */
2410       cp_lexer_consume_token (parser->lexer);
2411     }
2412 }
2413
2414 /* Skip tokens until a non-nested closing curly brace is the next
2415    token.  */
2416
2417 static void
2418 cp_parser_skip_to_closing_brace (cp_parser *parser)
2419 {
2420   unsigned nesting_depth = 0;
2421
2422   while (true)
2423     {
2424       cp_token *token = cp_lexer_peek_token (parser->lexer);
2425
2426       switch (token->type)
2427         {
2428         case CPP_EOF:
2429         case CPP_PRAGMA_EOL:
2430           /* If we've run out of tokens, stop.  */
2431           return;
2432
2433         case CPP_CLOSE_BRACE:
2434           /* If the next token is a non-nested `}', then we have reached
2435              the end of the current block.  */
2436           if (nesting_depth-- == 0)
2437             return;
2438           break;
2439
2440         case CPP_OPEN_BRACE:
2441           /* If it the next token is a `{', then we are entering a new
2442              block.  Consume the entire block.  */
2443           ++nesting_depth;
2444           break;
2445
2446         default:
2447           break;
2448         }
2449
2450       /* Consume the token.  */
2451       cp_lexer_consume_token (parser->lexer);
2452     }
2453 }
2454
2455 /* Consume tokens until we reach the end of the pragma.  The PRAGMA_TOK
2456    parameter is the PRAGMA token, allowing us to purge the entire pragma
2457    sequence.  */
2458
2459 static void
2460 cp_parser_skip_to_pragma_eol (cp_parser* parser, cp_token *pragma_tok)
2461 {
2462   cp_token *token;
2463
2464   parser->lexer->in_pragma = false;
2465
2466   do
2467     token = cp_lexer_consume_token (parser->lexer);
2468   while (token->type != CPP_PRAGMA_EOL && token->type != CPP_EOF);
2469
2470   /* Ensure that the pragma is not parsed again.  */
2471   cp_lexer_purge_tokens_after (parser->lexer, pragma_tok);
2472 }
2473
2474 /* Require pragma end of line, resyncing with it as necessary.  The
2475    arguments are as for cp_parser_skip_to_pragma_eol.  */
2476
2477 static void
2478 cp_parser_require_pragma_eol (cp_parser *parser, cp_token *pragma_tok)
2479 {
2480   parser->lexer->in_pragma = false;
2481   if (!cp_parser_require (parser, CPP_PRAGMA_EOL, "end of line"))
2482     cp_parser_skip_to_pragma_eol (parser, pragma_tok);
2483 }
2484
2485 /* This is a simple wrapper around make_typename_type. When the id is
2486    an unresolved identifier node, we can provide a superior diagnostic
2487    using cp_parser_diagnose_invalid_type_name.  */
2488
2489 static tree
2490 cp_parser_make_typename_type (cp_parser *parser, tree scope, tree id)
2491 {
2492   tree result;
2493   if (TREE_CODE (id) == IDENTIFIER_NODE)
2494     {
2495       result = make_typename_type (scope, id, typename_type,
2496                                    /*complain=*/tf_none);
2497       if (result == error_mark_node)
2498         cp_parser_diagnose_invalid_type_name (parser, scope, id);
2499       return result;
2500     }
2501   return make_typename_type (scope, id, typename_type, tf_error);
2502 }
2503
2504
2505 /* Create a new C++ parser.  */
2506
2507 static cp_parser *
2508 cp_parser_new (void)
2509 {
2510   cp_parser *parser;
2511   cp_lexer *lexer;
2512   unsigned i;
2513
2514   /* cp_lexer_new_main is called before calling ggc_alloc because
2515      cp_lexer_new_main might load a PCH file.  */
2516   lexer = cp_lexer_new_main ();
2517
2518   /* Initialize the binops_by_token so that we can get the tree
2519      directly from the token.  */
2520   for (i = 0; i < sizeof (binops) / sizeof (binops[0]); i++)
2521     binops_by_token[binops[i].token_type] = binops[i];
2522
2523   parser = GGC_CNEW (cp_parser);
2524   parser->lexer = lexer;
2525   parser->context = cp_parser_context_new (NULL);
2526
2527   /* For now, we always accept GNU extensions.  */
2528   parser->allow_gnu_extensions_p = 1;
2529
2530   /* The `>' token is a greater-than operator, not the end of a
2531      template-id.  */
2532   parser->greater_than_is_operator_p = true;
2533
2534   parser->default_arg_ok_p = true;
2535
2536   /* We are not parsing a constant-expression.  */
2537   parser->integral_constant_expression_p = false;
2538   parser->allow_non_integral_constant_expression_p = false;
2539   parser->non_integral_constant_expression_p = false;
2540
2541   /* Local variable names are not forbidden.  */
2542   parser->local_variables_forbidden_p = false;
2543
2544   /* We are not processing an `extern "C"' declaration.  */
2545   parser->in_unbraced_linkage_specification_p = false;
2546
2547   /* We are not processing a declarator.  */
2548   parser->in_declarator_p = false;
2549
2550   /* We are not processing a template-argument-list.  */
2551   parser->in_template_argument_list_p = false;
2552
2553   /* We are not in an iteration statement.  */
2554   parser->in_statement = 0;
2555
2556   /* We are not in a switch statement.  */
2557   parser->in_switch_statement_p = false;
2558
2559   /* We are not parsing a type-id inside an expression.  */
2560   parser->in_type_id_in_expr_p = false;
2561
2562   /* Declarations aren't implicitly extern "C".  */
2563   parser->implicit_extern_c = false;
2564
2565   /* String literals should be translated to the execution character set.  */
2566   parser->translate_strings_p = true;
2567
2568   /* The unparsed function queue is empty.  */
2569   parser->unparsed_functions_queues = build_tree_list (NULL_TREE, NULL_TREE);
2570
2571   /* There are no classes being defined.  */
2572   parser->num_classes_being_defined = 0;
2573
2574   /* No template parameters apply.  */
2575   parser->num_template_parameter_lists = 0;
2576
2577   return parser;
2578 }
2579
2580 /* Create a cp_lexer structure which will emit the tokens in CACHE
2581    and push it onto the parser's lexer stack.  This is used for delayed
2582    parsing of in-class method bodies and default arguments, and should
2583    not be confused with tentative parsing.  */
2584 static void
2585 cp_parser_push_lexer_for_tokens (cp_parser *parser, cp_token_cache *cache)
2586 {
2587   cp_lexer *lexer = cp_lexer_new_from_tokens (cache);
2588   lexer->next = parser->lexer;
2589   parser->lexer = lexer;
2590
2591   /* Move the current source position to that of the first token in the
2592      new lexer.  */
2593   cp_lexer_set_source_position_from_token (lexer->next_token);
2594 }
2595
2596 /* Pop the top lexer off the parser stack.  This is never used for the
2597    "main" lexer, only for those pushed by cp_parser_push_lexer_for_tokens.  */
2598 static void
2599 cp_parser_pop_lexer (cp_parser *parser)
2600 {
2601   cp_lexer *lexer = parser->lexer;
2602   parser->lexer = lexer->next;
2603   cp_lexer_destroy (lexer);
2604
2605   /* Put the current source position back where it was before this
2606      lexer was pushed.  */
2607   cp_lexer_set_source_position_from_token (parser->lexer->next_token);
2608 }
2609
2610 /* Lexical conventions [gram.lex]  */
2611
2612 /* Parse an identifier.  Returns an IDENTIFIER_NODE representing the
2613    identifier.  */
2614
2615 static tree
2616 cp_parser_identifier (cp_parser* parser)
2617 {
2618   cp_token *token;
2619
2620   /* Look for the identifier.  */
2621   token = cp_parser_require (parser, CPP_NAME, "identifier");
2622   /* Return the value.  */
2623   return token ? token->value : error_mark_node;
2624 }
2625
2626 /* Parse a sequence of adjacent string constants.  Returns a
2627    TREE_STRING representing the combined, nul-terminated string
2628    constant.  If TRANSLATE is true, translate the string to the
2629    execution character set.  If WIDE_OK is true, a wide string is
2630    invalid here.
2631
2632    C++98 [lex.string] says that if a narrow string literal token is
2633    adjacent to a wide string literal token, the behavior is undefined.
2634    However, C99 6.4.5p4 says that this results in a wide string literal.
2635    We follow C99 here, for consistency with the C front end.
2636
2637    This code is largely lifted from lex_string() in c-lex.c.
2638
2639    FUTURE: ObjC++ will need to handle @-strings here.  */
2640 static tree
2641 cp_parser_string_literal (cp_parser *parser, bool translate, bool wide_ok)
2642 {
2643   tree value;
2644   bool wide = false;
2645   size_t count;
2646   struct obstack str_ob;
2647   cpp_string str, istr, *strs;
2648   cp_token *tok;
2649
2650   tok = cp_lexer_peek_token (parser->lexer);
2651   if (!cp_parser_is_string_literal (tok))
2652     {
2653       cp_parser_error (parser, "expected string-literal");
2654       return error_mark_node;
2655     }
2656
2657   /* Try to avoid the overhead of creating and destroying an obstack
2658      for the common case of just one string.  */
2659   if (!cp_parser_is_string_literal
2660       (cp_lexer_peek_nth_token (parser->lexer, 2)))
2661     {
2662       cp_lexer_consume_token (parser->lexer);
2663
2664       str.text = (const unsigned char *)TREE_STRING_POINTER (tok->value);
2665       str.len = TREE_STRING_LENGTH (tok->value);
2666       count = 1;
2667       if (tok->type == CPP_WSTRING)
2668         wide = true;
2669
2670       strs = &str;
2671     }
2672   else
2673     {
2674       gcc_obstack_init (&str_ob);
2675       count = 0;
2676
2677       do
2678         {
2679           cp_lexer_consume_token (parser->lexer);
2680           count++;
2681           str.text = (unsigned char *)TREE_STRING_POINTER (tok->value);
2682           str.len = TREE_STRING_LENGTH (tok->value);
2683           if (tok->type == CPP_WSTRING)
2684             wide = true;
2685
2686           obstack_grow (&str_ob, &str, sizeof (cpp_string));
2687
2688           tok = cp_lexer_peek_token (parser->lexer);
2689         }
2690       while (cp_parser_is_string_literal (tok));
2691
2692       strs = (cpp_string *) obstack_finish (&str_ob);
2693     }
2694
2695   if (wide && !wide_ok)
2696     {
2697       cp_parser_error (parser, "a wide string is invalid in this context");
2698       wide = false;
2699     }
2700
2701   if ((translate ? cpp_interpret_string : cpp_interpret_string_notranslate)
2702       (parse_in, strs, count, &istr, wide))
2703     {
2704       value = build_string (istr.len, (char *)istr.text);
2705       free ((void *)istr.text);
2706
2707       TREE_TYPE (value) = wide ? wchar_array_type_node : char_array_type_node;
2708       value = fix_string_type (value);
2709     }
2710   else
2711     /* cpp_interpret_string has issued an error.  */
2712     value = error_mark_node;
2713
2714   if (count > 1)
2715     obstack_free (&str_ob, 0);
2716
2717   return value;
2718 }
2719
2720
2721 /* Basic concepts [gram.basic]  */
2722
2723 /* Parse a translation-unit.
2724
2725    translation-unit:
2726      declaration-seq [opt]
2727
2728    Returns TRUE if all went well.  */
2729
2730 static bool
2731 cp_parser_translation_unit (cp_parser* parser)
2732 {
2733   /* The address of the first non-permanent object on the declarator
2734      obstack.  */
2735   static void *declarator_obstack_base;
2736
2737   bool success;
2738
2739   /* Create the declarator obstack, if necessary.  */
2740   if (!cp_error_declarator)
2741     {
2742       gcc_obstack_init (&declarator_obstack);
2743       /* Create the error declarator.  */
2744       cp_error_declarator = make_declarator (cdk_error);
2745       /* Create the empty parameter list.  */
2746       no_parameters = make_parameter_declarator (NULL, NULL, NULL_TREE);
2747       /* Remember where the base of the declarator obstack lies.  */
2748       declarator_obstack_base = obstack_next_free (&declarator_obstack);
2749     }
2750
2751   cp_parser_declaration_seq_opt (parser);
2752
2753   /* If there are no tokens left then all went well.  */
2754   if (cp_lexer_next_token_is (parser->lexer, CPP_EOF))
2755     {
2756       /* Get rid of the token array; we don't need it any more.  */
2757       cp_lexer_destroy (parser->lexer);
2758       parser->lexer = NULL;
2759
2760       /* This file might have been a context that's implicitly extern
2761          "C".  If so, pop the lang context.  (Only relevant for PCH.) */
2762       if (parser->implicit_extern_c)
2763         {
2764           pop_lang_context ();
2765           parser->implicit_extern_c = false;
2766         }
2767
2768       /* Finish up.  */
2769       finish_translation_unit ();
2770
2771       success = true;
2772     }
2773   else
2774     {
2775       cp_parser_error (parser, "expected declaration");
2776       success = false;
2777     }
2778
2779   /* Make sure the declarator obstack was fully cleaned up.  */
2780   gcc_assert (obstack_next_free (&declarator_obstack)
2781               == declarator_obstack_base);
2782
2783   /* All went well.  */
2784   return success;
2785 }
2786
2787 /* Expressions [gram.expr] */
2788
2789 /* Parse a primary-expression.
2790
2791    primary-expression:
2792      literal
2793      this
2794      ( expression )
2795      id-expression
2796
2797    GNU Extensions:
2798
2799    primary-expression:
2800      ( compound-statement )
2801      __builtin_va_arg ( assignment-expression , type-id )
2802      __builtin_offsetof ( type-id , offsetof-expression )
2803
2804    Objective-C++ Extension:
2805
2806    primary-expression:
2807      objc-expression
2808
2809    literal:
2810      __null
2811
2812    ADDRESS_P is true iff this expression was immediately preceded by
2813    "&" and therefore might denote a pointer-to-member.  CAST_P is true
2814    iff this expression is the target of a cast.  TEMPLATE_ARG_P is
2815    true iff this expression is a template argument.
2816
2817    Returns a representation of the expression.  Upon return, *IDK
2818    indicates what kind of id-expression (if any) was present.  */
2819
2820 static tree
2821 cp_parser_primary_expression (cp_parser *parser,
2822                               bool address_p,
2823                               bool cast_p,
2824                               bool template_arg_p,
2825                               cp_id_kind *idk)
2826 {
2827   cp_token *token;
2828
2829   /* Assume the primary expression is not an id-expression.  */
2830   *idk = CP_ID_KIND_NONE;
2831
2832   /* Peek at the next token.  */
2833   token = cp_lexer_peek_token (parser->lexer);
2834   switch (token->type)
2835     {
2836       /* literal:
2837            integer-literal
2838            character-literal
2839            floating-literal
2840            string-literal
2841            boolean-literal  */
2842     case CPP_CHAR:
2843     case CPP_WCHAR:
2844     case CPP_NUMBER:
2845       token = cp_lexer_consume_token (parser->lexer);
2846       /* Floating-point literals are only allowed in an integral
2847          constant expression if they are cast to an integral or
2848          enumeration type.  */
2849       if (TREE_CODE (token->value) == REAL_CST
2850           && parser->integral_constant_expression_p
2851           && pedantic)
2852         {
2853           /* CAST_P will be set even in invalid code like "int(2.7 +
2854              ...)".   Therefore, we have to check that the next token
2855              is sure to end the cast.  */
2856           if (cast_p)
2857             {
2858               cp_token *next_token;
2859
2860               next_token = cp_lexer_peek_token (parser->lexer);
2861               if (/* The comma at the end of an
2862                      enumerator-definition.  */
2863                   next_token->type != CPP_COMMA
2864                   /* The curly brace at the end of an enum-specifier.  */
2865                   && next_token->type != CPP_CLOSE_BRACE
2866                   /* The end of a statement.  */
2867                   && next_token->type != CPP_SEMICOLON
2868                   /* The end of the cast-expression.  */
2869                   && next_token->type != CPP_CLOSE_PAREN
2870                   /* The end of an array bound.  */
2871                   && next_token->type != CPP_CLOSE_SQUARE
2872                   /* The closing ">" in a template-argument-list.  */
2873                   && (next_token->type != CPP_GREATER
2874                       || parser->greater_than_is_operator_p))
2875                 cast_p = false;
2876             }
2877
2878           /* If we are within a cast, then the constraint that the
2879              cast is to an integral or enumeration type will be
2880              checked at that point.  If we are not within a cast, then
2881              this code is invalid.  */
2882           if (!cast_p)
2883             cp_parser_non_integral_constant_expression
2884               (parser, "floating-point literal");
2885         }
2886       return token->value;
2887
2888     case CPP_STRING:
2889     case CPP_WSTRING:
2890       /* ??? Should wide strings be allowed when parser->translate_strings_p
2891          is false (i.e. in attributes)?  If not, we can kill the third
2892          argument to cp_parser_string_literal.  */
2893       return cp_parser_string_literal (parser,
2894                                        parser->translate_strings_p,
2895                                        true);
2896
2897     case CPP_OPEN_PAREN:
2898       {
2899         tree expr;
2900         bool saved_greater_than_is_operator_p;
2901
2902         /* Consume the `('.  */
2903         cp_lexer_consume_token (parser->lexer);
2904         /* Within a parenthesized expression, a `>' token is always
2905            the greater-than operator.  */
2906         saved_greater_than_is_operator_p
2907           = parser->greater_than_is_operator_p;
2908         parser->greater_than_is_operator_p = true;
2909         /* If we see `( { ' then we are looking at the beginning of
2910            a GNU statement-expression.  */
2911         if (cp_parser_allow_gnu_extensions_p (parser)
2912             && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
2913           {
2914             /* Statement-expressions are not allowed by the standard.  */
2915             if (pedantic)
2916               pedwarn ("ISO C++ forbids braced-groups within expressions");
2917
2918             /* And they're not allowed outside of a function-body; you
2919                cannot, for example, write:
2920
2921                  int i = ({ int j = 3; j + 1; });
2922
2923                at class or namespace scope.  */
2924             if (!at_function_scope_p ())
2925               error ("statement-expressions are allowed only inside functions");
2926             /* Start the statement-expression.  */
2927             expr = begin_stmt_expr ();
2928             /* Parse the compound-statement.  */
2929             cp_parser_compound_statement (parser, expr, false);
2930             /* Finish up.  */
2931             expr = finish_stmt_expr (expr, false);
2932           }
2933         else
2934           {
2935             /* Parse the parenthesized expression.  */
2936             expr = cp_parser_expression (parser, cast_p);
2937             /* Let the front end know that this expression was
2938                enclosed in parentheses. This matters in case, for
2939                example, the expression is of the form `A::B', since
2940                `&A::B' might be a pointer-to-member, but `&(A::B)' is
2941                not.  */
2942             finish_parenthesized_expr (expr);
2943           }
2944         /* The `>' token might be the end of a template-id or
2945            template-parameter-list now.  */
2946         parser->greater_than_is_operator_p
2947           = saved_greater_than_is_operator_p;
2948         /* Consume the `)'.  */
2949         if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"))
2950           cp_parser_skip_to_end_of_statement (parser);
2951
2952         return expr;
2953       }
2954
2955     case CPP_KEYWORD:
2956       switch (token->keyword)
2957         {
2958           /* These two are the boolean literals.  */
2959         case RID_TRUE:
2960           cp_lexer_consume_token (parser->lexer);
2961           return boolean_true_node;
2962         case RID_FALSE:
2963           cp_lexer_consume_token (parser->lexer);
2964           return boolean_false_node;
2965
2966           /* The `__null' literal.  */
2967         case RID_NULL:
2968           cp_lexer_consume_token (parser->lexer);
2969           return null_node;
2970
2971           /* Recognize the `this' keyword.  */
2972         case RID_THIS:
2973           cp_lexer_consume_token (parser->lexer);
2974           if (parser->local_variables_forbidden_p)
2975             {
2976               error ("%<this%> may not be used in this context");
2977               return error_mark_node;
2978             }
2979           /* Pointers cannot appear in constant-expressions.  */
2980           if (cp_parser_non_integral_constant_expression (parser,
2981                                                           "`this'"))
2982             return error_mark_node;
2983           return finish_this_expr ();
2984
2985           /* The `operator' keyword can be the beginning of an
2986              id-expression.  */
2987         case RID_OPERATOR:
2988           goto id_expression;
2989
2990         case RID_FUNCTION_NAME:
2991         case RID_PRETTY_FUNCTION_NAME:
2992         case RID_C99_FUNCTION_NAME:
2993           /* The symbols __FUNCTION__, __PRETTY_FUNCTION__, and
2994              __func__ are the names of variables -- but they are
2995              treated specially.  Therefore, they are handled here,
2996              rather than relying on the generic id-expression logic
2997              below.  Grammatically, these names are id-expressions.
2998
2999              Consume the token.  */
3000           token = cp_lexer_consume_token (parser->lexer);
3001           /* Look up the name.  */
3002           return finish_fname (token->value);
3003
3004         case RID_VA_ARG:
3005           {
3006             tree expression;
3007             tree type;
3008
3009             /* The `__builtin_va_arg' construct is used to handle
3010                `va_arg'.  Consume the `__builtin_va_arg' token.  */
3011             cp_lexer_consume_token (parser->lexer);
3012             /* Look for the opening `('.  */
3013             cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
3014             /* Now, parse the assignment-expression.  */
3015             expression = cp_parser_assignment_expression (parser,
3016                                                           /*cast_p=*/false);
3017             /* Look for the `,'.  */
3018             cp_parser_require (parser, CPP_COMMA, "`,'");
3019             /* Parse the type-id.  */
3020             type = cp_parser_type_id (parser);
3021             /* Look for the closing `)'.  */
3022             cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
3023             /* Using `va_arg' in a constant-expression is not
3024                allowed.  */
3025             if (cp_parser_non_integral_constant_expression (parser,
3026                                                             "`va_arg'"))
3027               return error_mark_node;
3028             return build_x_va_arg (expression, type);
3029           }
3030
3031         case RID_OFFSETOF:
3032           return cp_parser_builtin_offsetof (parser);
3033
3034           /* Objective-C++ expressions.  */
3035         case RID_AT_ENCODE:
3036         case RID_AT_PROTOCOL:
3037         case RID_AT_SELECTOR:
3038           return cp_parser_objc_expression (parser);
3039
3040         default:
3041           cp_parser_error (parser, "expected primary-expression");
3042           return error_mark_node;
3043         }
3044
3045       /* An id-expression can start with either an identifier, a
3046          `::' as the beginning of a qualified-id, or the "operator"
3047          keyword.  */
3048     case CPP_NAME:
3049     case CPP_SCOPE:
3050     case CPP_TEMPLATE_ID:
3051     case CPP_NESTED_NAME_SPECIFIER:
3052       {
3053         tree id_expression;
3054         tree decl;
3055         const char *error_msg;
3056         bool template_p;
3057         bool done;
3058
3059       id_expression:
3060         /* Parse the id-expression.  */
3061         id_expression
3062           = cp_parser_id_expression (parser,
3063                                      /*template_keyword_p=*/false,
3064                                      /*check_dependency_p=*/true,
3065                                      &template_p,
3066                                      /*declarator_p=*/false,
3067                                      /*optional_p=*/false);
3068         if (id_expression == error_mark_node)
3069           return error_mark_node;
3070         token = cp_lexer_peek_token (parser->lexer);
3071         done = (token->type != CPP_OPEN_SQUARE
3072                 && token->type != CPP_OPEN_PAREN
3073                 && token->type != CPP_DOT
3074                 && token->type != CPP_DEREF
3075                 && token->type != CPP_PLUS_PLUS
3076                 && token->type != CPP_MINUS_MINUS);
3077         /* If we have a template-id, then no further lookup is
3078            required.  If the template-id was for a template-class, we
3079            will sometimes have a TYPE_DECL at this point.  */
3080         if (TREE_CODE (id_expression) == TEMPLATE_ID_EXPR
3081                  || TREE_CODE (id_expression) == TYPE_DECL)
3082           decl = id_expression;
3083         /* Look up the name.  */
3084         else
3085           {
3086             tree ambiguous_decls;
3087
3088             decl = cp_parser_lookup_name (parser, id_expression,
3089                                           none_type,
3090                                           template_p,
3091                                           /*is_namespace=*/false,
3092                                           /*check_dependency=*/true,
3093                                           &ambiguous_decls);
3094             /* If the lookup was ambiguous, an error will already have
3095                been issued.  */
3096             if (ambiguous_decls)
3097               return error_mark_node;
3098
3099             /* In Objective-C++, an instance variable (ivar) may be preferred
3100                to whatever cp_parser_lookup_name() found.  */
3101             decl = objc_lookup_ivar (decl, id_expression);
3102
3103             /* If name lookup gives us a SCOPE_REF, then the
3104                qualifying scope was dependent.  */
3105             if (TREE_CODE (decl) == SCOPE_REF)
3106               return decl;
3107             /* Check to see if DECL is a local variable in a context
3108                where that is forbidden.  */
3109             if (parser->local_variables_forbidden_p
3110                 && local_variable_p (decl))
3111               {
3112                 /* It might be that we only found DECL because we are
3113                    trying to be generous with pre-ISO scoping rules.
3114                    For example, consider:
3115
3116                      int i;
3117                      void g() {
3118                        for (int i = 0; i < 10; ++i) {}
3119                        extern void f(int j = i);
3120                      }
3121
3122                    Here, name look up will originally find the out
3123                    of scope `i'.  We need to issue a warning message,
3124                    but then use the global `i'.  */
3125                 decl = check_for_out_of_scope_variable (decl);
3126                 if (local_variable_p (decl))
3127                   {
3128                     error ("local variable %qD may not appear in this context",
3129                            decl);
3130                     return error_mark_node;
3131                   }
3132               }
3133           }
3134
3135         decl = (finish_id_expression
3136                 (id_expression, decl, parser->scope,
3137                  idk,
3138                  parser->integral_constant_expression_p,
3139                  parser->allow_non_integral_constant_expression_p,
3140                  &parser->non_integral_constant_expression_p,
3141                  template_p, done, address_p,
3142                  template_arg_p,
3143                  &error_msg));
3144         if (error_msg)
3145           cp_parser_error (parser, error_msg);
3146         return decl;
3147       }
3148
3149       /* Anything else is an error.  */
3150     default:
3151       /* ...unless we have an Objective-C++ message or string literal, that is.  */
3152       if (c_dialect_objc ()
3153           && (token->type == CPP_OPEN_SQUARE || token->type == CPP_OBJC_STRING))
3154         return cp_parser_objc_expression (parser);
3155
3156       cp_parser_error (parser, "expected primary-expression");
3157       return error_mark_node;
3158     }
3159 }
3160
3161 /* Parse an id-expression.
3162
3163    id-expression:
3164      unqualified-id
3165      qualified-id
3166
3167    qualified-id:
3168      :: [opt] nested-name-specifier template [opt] unqualified-id
3169      :: identifier
3170      :: operator-function-id
3171      :: template-id
3172
3173    Return a representation of the unqualified portion of the
3174    identifier.  Sets PARSER->SCOPE to the qualifying scope if there is
3175    a `::' or nested-name-specifier.
3176
3177    Often, if the id-expression was a qualified-id, the caller will
3178    want to make a SCOPE_REF to represent the qualified-id.  This
3179    function does not do this in order to avoid wastefully creating
3180    SCOPE_REFs when they are not required.
3181
3182    If TEMPLATE_KEYWORD_P is true, then we have just seen the
3183    `template' keyword.
3184
3185    If CHECK_DEPENDENCY_P is false, then names are looked up inside
3186    uninstantiated templates.
3187
3188    If *TEMPLATE_P is non-NULL, it is set to true iff the
3189    `template' keyword is used to explicitly indicate that the entity
3190    named is a template.
3191
3192    If DECLARATOR_P is true, the id-expression is appearing as part of
3193    a declarator, rather than as part of an expression.  */
3194
3195 static tree
3196 cp_parser_id_expression (cp_parser *parser,
3197                          bool template_keyword_p,
3198                          bool check_dependency_p,
3199                          bool *template_p,
3200                          bool declarator_p,
3201                          bool optional_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        != NULL_TREE);
3214   /* Look for the optional nested-name-specifier.  */
3215   nested_name_specifier_p
3216     = (cp_parser_nested_name_specifier_opt (parser,
3217                                             /*typename_keyword_p=*/false,
3218                                             check_dependency_p,
3219                                             /*type_p=*/false,
3220                                             declarator_p)
3221        != NULL_TREE);
3222   /* If there is a nested-name-specifier, then we are looking at
3223      the first qualified-id production.  */
3224   if (nested_name_specifier_p)
3225     {
3226       tree saved_scope;
3227       tree saved_object_scope;
3228       tree saved_qualifying_scope;
3229       tree unqualified_id;
3230       bool is_template;
3231
3232       /* See if the next token is the `template' keyword.  */
3233       if (!template_p)
3234         template_p = &is_template;
3235       *template_p = cp_parser_optional_template_keyword (parser);
3236       /* Name lookup we do during the processing of the
3237          unqualified-id might obliterate SCOPE.  */
3238       saved_scope = parser->scope;
3239       saved_object_scope = parser->object_scope;
3240       saved_qualifying_scope = parser->qualifying_scope;
3241       /* Process the final unqualified-id.  */
3242       unqualified_id = cp_parser_unqualified_id (parser, *template_p,
3243                                                  check_dependency_p,
3244                                                  declarator_p,
3245                                                  /*optional_p=*/false);
3246       /* Restore the SAVED_SCOPE for our caller.  */
3247       parser->scope = saved_scope;
3248       parser->object_scope = saved_object_scope;
3249       parser->qualifying_scope = saved_qualifying_scope;
3250
3251       return unqualified_id;
3252     }
3253   /* Otherwise, if we are in global scope, then we are looking at one
3254      of the other qualified-id productions.  */
3255   else if (global_scope_p)
3256     {
3257       cp_token *token;
3258       tree id;
3259
3260       /* Peek at the next token.  */
3261       token = cp_lexer_peek_token (parser->lexer);
3262
3263       /* If it's an identifier, and the next token is not a "<", then
3264          we can avoid the template-id case.  This is an optimization
3265          for this common case.  */
3266       if (token->type == CPP_NAME
3267           && !cp_parser_nth_token_starts_template_argument_list_p
3268                (parser, 2))
3269         return cp_parser_identifier (parser);
3270
3271       cp_parser_parse_tentatively (parser);
3272       /* Try a template-id.  */
3273       id = cp_parser_template_id (parser,
3274                                   /*template_keyword_p=*/false,
3275                                   /*check_dependency_p=*/true,
3276                                   declarator_p);
3277       /* If that worked, we're done.  */
3278       if (cp_parser_parse_definitely (parser))
3279         return id;
3280
3281       /* Peek at the next token.  (Changes in the token buffer may
3282          have invalidated the pointer obtained above.)  */
3283       token = cp_lexer_peek_token (parser->lexer);
3284
3285       switch (token->type)
3286         {
3287         case CPP_NAME:
3288           return cp_parser_identifier (parser);
3289
3290         case CPP_KEYWORD:
3291           if (token->keyword == RID_OPERATOR)
3292             return cp_parser_operator_function_id (parser);
3293           /* Fall through.  */
3294
3295         default:
3296           cp_parser_error (parser, "expected id-expression");
3297           return error_mark_node;
3298         }
3299     }
3300   else
3301     return cp_parser_unqualified_id (parser, template_keyword_p,
3302                                      /*check_dependency_p=*/true,
3303                                      declarator_p,
3304                                      optional_p);
3305 }
3306
3307 /* Parse an unqualified-id.
3308
3309    unqualified-id:
3310      identifier
3311      operator-function-id
3312      conversion-function-id
3313      ~ class-name
3314      template-id
3315
3316    If TEMPLATE_KEYWORD_P is TRUE, we have just seen the `template'
3317    keyword, in a construct like `A::template ...'.
3318
3319    Returns a representation of unqualified-id.  For the `identifier'
3320    production, an IDENTIFIER_NODE is returned.  For the `~ class-name'
3321    production a BIT_NOT_EXPR is returned; the operand of the
3322    BIT_NOT_EXPR is an IDENTIFIER_NODE for the class-name.  For the
3323    other productions, see the documentation accompanying the
3324    corresponding parsing functions.  If CHECK_DEPENDENCY_P is false,
3325    names are looked up in uninstantiated templates.  If DECLARATOR_P
3326    is true, the unqualified-id is appearing as part of a declarator,
3327    rather than as part of an expression.  */
3328
3329 static tree
3330 cp_parser_unqualified_id (cp_parser* parser,
3331                           bool template_keyword_p,
3332                           bool check_dependency_p,
3333                           bool declarator_p,
3334                           bool optional_p)
3335 {
3336   cp_token *token;
3337
3338   /* Peek at the next token.  */
3339   token = cp_lexer_peek_token (parser->lexer);
3340
3341   switch (token->type)
3342     {
3343     case CPP_NAME:
3344       {
3345         tree id;
3346
3347         /* We don't know yet whether or not this will be a
3348            template-id.  */
3349         cp_parser_parse_tentatively (parser);
3350         /* Try a template-id.  */
3351         id = cp_parser_template_id (parser, template_keyword_p,
3352                                     check_dependency_p,
3353                                     declarator_p);
3354         /* If it worked, we're done.  */
3355         if (cp_parser_parse_definitely (parser))
3356           return id;
3357         /* Otherwise, it's an ordinary identifier.  */
3358         return cp_parser_identifier (parser);
3359       }
3360
3361     case CPP_TEMPLATE_ID:
3362       return cp_parser_template_id (parser, template_keyword_p,
3363                                     check_dependency_p,
3364                                     declarator_p);
3365
3366     case CPP_COMPL:
3367       {
3368         tree type_decl;
3369         tree qualifying_scope;
3370         tree object_scope;
3371         tree scope;
3372         bool done;
3373
3374         /* Consume the `~' token.  */
3375         cp_lexer_consume_token (parser->lexer);
3376         /* Parse the class-name.  The standard, as written, seems to
3377            say that:
3378
3379              template <typename T> struct S { ~S (); };
3380              template <typename T> S<T>::~S() {}
3381
3382            is invalid, since `~' must be followed by a class-name, but
3383            `S<T>' is dependent, and so not known to be a class.
3384            That's not right; we need to look in uninstantiated
3385            templates.  A further complication arises from:
3386
3387              template <typename T> void f(T t) {
3388                t.T::~T();
3389              }
3390
3391            Here, it is not possible to look up `T' in the scope of `T'
3392            itself.  We must look in both the current scope, and the
3393            scope of the containing complete expression.
3394
3395            Yet another issue is:
3396
3397              struct S {
3398                int S;
3399                ~S();
3400              };
3401
3402              S::~S() {}
3403
3404            The standard does not seem to say that the `S' in `~S'
3405            should refer to the type `S' and not the data member
3406            `S::S'.  */
3407
3408         /* DR 244 says that we look up the name after the "~" in the
3409            same scope as we looked up the qualifying name.  That idea
3410            isn't fully worked out; it's more complicated than that.  */
3411         scope = parser->scope;
3412         object_scope = parser->object_scope;
3413         qualifying_scope = parser->qualifying_scope;
3414
3415         /* Check for invalid scopes.  */
3416         if (scope == error_mark_node)
3417           {
3418             if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
3419               cp_lexer_consume_token (parser->lexer);
3420             return error_mark_node;
3421           }
3422         if (scope && TREE_CODE (scope) == NAMESPACE_DECL)
3423           {
3424             if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
3425               error ("scope %qT before %<~%> is not a class-name", scope);
3426             cp_parser_simulate_error (parser);
3427             if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
3428               cp_lexer_consume_token (parser->lexer);
3429             return error_mark_node;
3430           }
3431         gcc_assert (!scope || TYPE_P (scope));
3432
3433         /* If the name is of the form "X::~X" it's OK.  */
3434         token = cp_lexer_peek_token (parser->lexer);
3435         if (scope
3436             && token->type == CPP_NAME
3437             && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
3438                 == CPP_OPEN_PAREN)
3439             && constructor_name_p (token->value, scope))
3440           {
3441             cp_lexer_consume_token (parser->lexer);
3442             return build_nt (BIT_NOT_EXPR, scope);
3443           }
3444
3445         /* If there was an explicit qualification (S::~T), first look
3446            in the scope given by the qualification (i.e., S).  */
3447         done = false;
3448         type_decl = NULL_TREE;
3449         if (scope)
3450           {
3451             cp_parser_parse_tentatively (parser);
3452             type_decl = cp_parser_class_name (parser,
3453                                               /*typename_keyword_p=*/false,
3454                                               /*template_keyword_p=*/false,
3455                                               none_type,
3456                                               /*check_dependency=*/false,
3457                                               /*class_head_p=*/false,
3458                                               declarator_p);
3459             if (cp_parser_parse_definitely (parser))
3460               done = true;
3461           }
3462         /* In "N::S::~S", look in "N" as well.  */
3463         if (!done && scope && qualifying_scope)
3464           {
3465             cp_parser_parse_tentatively (parser);
3466             parser->scope = qualifying_scope;
3467             parser->object_scope = NULL_TREE;
3468             parser->qualifying_scope = NULL_TREE;
3469             type_decl
3470               = cp_parser_class_name (parser,
3471                                       /*typename_keyword_p=*/false,
3472                                       /*template_keyword_p=*/false,
3473                                       none_type,
3474                                       /*check_dependency=*/false,
3475                                       /*class_head_p=*/false,
3476                                       declarator_p);
3477             if (cp_parser_parse_definitely (parser))
3478               done = true;
3479           }
3480         /* In "p->S::~T", look in the scope given by "*p" as well.  */
3481         else if (!done && object_scope)
3482           {
3483             cp_parser_parse_tentatively (parser);
3484             parser->scope = object_scope;
3485             parser->object_scope = NULL_TREE;
3486             parser->qualifying_scope = NULL_TREE;
3487             type_decl
3488               = cp_parser_class_name (parser,
3489                                       /*typename_keyword_p=*/false,
3490                                       /*template_keyword_p=*/false,
3491                                       none_type,
3492                                       /*check_dependency=*/false,
3493                                       /*class_head_p=*/false,
3494                                       declarator_p);
3495             if (cp_parser_parse_definitely (parser))
3496               done = true;
3497           }
3498         /* Look in the surrounding context.  */
3499         if (!done)
3500           {
3501             parser->scope = NULL_TREE;
3502             parser->object_scope = NULL_TREE;
3503             parser->qualifying_scope = NULL_TREE;
3504             type_decl
3505               = cp_parser_class_name (parser,
3506                                       /*typename_keyword_p=*/false,
3507                                       /*template_keyword_p=*/false,
3508                                       none_type,
3509                                       /*check_dependency=*/false,
3510                                       /*class_head_p=*/false,
3511                                       declarator_p);
3512           }
3513         /* If an error occurred, assume that the name of the
3514            destructor is the same as the name of the qualifying
3515            class.  That allows us to keep parsing after running
3516            into ill-formed destructor names.  */
3517         if (type_decl == error_mark_node && scope)
3518           return build_nt (BIT_NOT_EXPR, scope);
3519         else if (type_decl == error_mark_node)
3520           return error_mark_node;
3521
3522         /* Check that destructor name and scope match.  */
3523         if (declarator_p && scope && !check_dtor_name (scope, type_decl))
3524           {
3525             if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
3526               error ("declaration of %<~%T%> as member of %qT",
3527                      type_decl, scope);
3528             cp_parser_simulate_error (parser);
3529             return error_mark_node;
3530           }
3531
3532         /* [class.dtor]
3533
3534            A typedef-name that names a class shall not be used as the
3535            identifier in the declarator for a destructor declaration.  */
3536         if (declarator_p
3537             && !DECL_IMPLICIT_TYPEDEF_P (type_decl)
3538             && !DECL_SELF_REFERENCE_P (type_decl)
3539             && !cp_parser_uncommitted_to_tentative_parse_p (parser))
3540           error ("typedef-name %qD used as destructor declarator",
3541                  type_decl);
3542
3543         return build_nt (BIT_NOT_EXPR, TREE_TYPE (type_decl));
3544       }
3545
3546     case CPP_KEYWORD:
3547       if (token->keyword == RID_OPERATOR)
3548         {
3549           tree id;
3550
3551           /* This could be a template-id, so we try that first.  */
3552           cp_parser_parse_tentatively (parser);
3553           /* Try a template-id.  */
3554           id = cp_parser_template_id (parser, template_keyword_p,
3555                                       /*check_dependency_p=*/true,
3556                                       declarator_p);
3557           /* If that worked, we're done.  */
3558           if (cp_parser_parse_definitely (parser))
3559             return id;
3560           /* We still don't know whether we're looking at an
3561              operator-function-id or a conversion-function-id.  */
3562           cp_parser_parse_tentatively (parser);
3563           /* Try an operator-function-id.  */
3564           id = cp_parser_operator_function_id (parser);
3565           /* If that didn't work, try a conversion-function-id.  */
3566           if (!cp_parser_parse_definitely (parser))
3567             id = cp_parser_conversion_function_id (parser);
3568
3569           return id;
3570         }
3571       /* Fall through.  */
3572
3573     default:
3574       if (optional_p)
3575         return NULL_TREE;
3576       cp_parser_error (parser, "expected unqualified-id");
3577       return error_mark_node;
3578     }
3579 }
3580
3581 /* Parse an (optional) nested-name-specifier.
3582
3583    nested-name-specifier:
3584      class-or-namespace-name :: nested-name-specifier [opt]
3585      class-or-namespace-name :: template nested-name-specifier [opt]
3586
3587    PARSER->SCOPE should be set appropriately before this function is
3588    called.  TYPENAME_KEYWORD_P is TRUE if the `typename' keyword is in
3589    effect.  TYPE_P is TRUE if we non-type bindings should be ignored
3590    in name lookups.
3591
3592    Sets PARSER->SCOPE to the class (TYPE) or namespace
3593    (NAMESPACE_DECL) specified by the nested-name-specifier, or leaves
3594    it unchanged if there is no nested-name-specifier.  Returns the new
3595    scope iff there is a nested-name-specifier, or NULL_TREE otherwise.
3596
3597    If IS_DECLARATION is TRUE, the nested-name-specifier is known to be
3598    part of a declaration and/or decl-specifier.  */
3599
3600 static tree
3601 cp_parser_nested_name_specifier_opt (cp_parser *parser,
3602                                      bool typename_keyword_p,
3603                                      bool check_dependency_p,
3604                                      bool type_p,
3605                                      bool is_declaration)
3606 {
3607   bool success = false;
3608   cp_token_position start = 0;
3609   cp_token *token;
3610
3611   /* Remember where the nested-name-specifier starts.  */
3612   if (cp_parser_uncommitted_to_tentative_parse_p (parser))
3613     {
3614       start = cp_lexer_token_position (parser->lexer, false);
3615       push_deferring_access_checks (dk_deferred);
3616     }
3617
3618   while (true)
3619     {
3620       tree new_scope;
3621       tree old_scope;
3622       tree saved_qualifying_scope;
3623       bool template_keyword_p;
3624
3625       /* Spot cases that cannot be the beginning of a
3626          nested-name-specifier.  */
3627       token = cp_lexer_peek_token (parser->lexer);
3628
3629       /* If the next token is CPP_NESTED_NAME_SPECIFIER, just process
3630          the already parsed nested-name-specifier.  */
3631       if (token->type == CPP_NESTED_NAME_SPECIFIER)
3632         {
3633           /* Grab the nested-name-specifier and continue the loop.  */
3634           cp_parser_pre_parsed_nested_name_specifier (parser);
3635           if (is_declaration
3636               && TREE_CODE (parser->scope) == TYPENAME_TYPE)
3637             parser->scope = resolve_typename_type (parser->scope,
3638                                                    /*only_current_p=*/false);
3639           success = true;
3640           continue;
3641         }
3642
3643       /* Spot cases that cannot be the beginning of a
3644          nested-name-specifier.  On the second and subsequent times
3645          through the loop, we look for the `template' keyword.  */
3646       if (success && token->keyword == RID_TEMPLATE)
3647         ;
3648       /* A template-id can start a nested-name-specifier.  */
3649       else if (token->type == CPP_TEMPLATE_ID)
3650         ;
3651       else
3652         {
3653           /* If the next token is not an identifier, then it is
3654              definitely not a class-or-namespace-name.  */
3655           if (token->type != CPP_NAME)
3656             break;
3657           /* If the following token is neither a `<' (to begin a
3658              template-id), nor a `::', then we are not looking at a
3659              nested-name-specifier.  */
3660           token = cp_lexer_peek_nth_token (parser->lexer, 2);
3661           if (token->type != CPP_SCOPE
3662               && !cp_parser_nth_token_starts_template_argument_list_p
3663                   (parser, 2))
3664             break;
3665         }
3666
3667       /* The nested-name-specifier is optional, so we parse
3668          tentatively.  */
3669       cp_parser_parse_tentatively (parser);
3670
3671       /* Look for the optional `template' keyword, if this isn't the
3672          first time through the loop.  */
3673       if (success)
3674         template_keyword_p = cp_parser_optional_template_keyword (parser);
3675       else
3676         template_keyword_p = false;
3677
3678       /* Save the old scope since the name lookup we are about to do
3679          might destroy it.  */
3680       old_scope = parser->scope;
3681       saved_qualifying_scope = parser->qualifying_scope;
3682       /* In a declarator-id like "X<T>::I::Y<T>" we must be able to
3683          look up names in "X<T>::I" in order to determine that "Y" is
3684          a template.  So, if we have a typename at this point, we make
3685          an effort to look through it.  */
3686       if (is_declaration
3687           && !typename_keyword_p
3688           && parser->scope
3689           && TREE_CODE (parser->scope) == TYPENAME_TYPE)
3690         parser->scope = resolve_typename_type (parser->scope,
3691                                                /*only_current_p=*/false);
3692       /* Parse the qualifying entity.  */
3693       new_scope
3694         = cp_parser_class_or_namespace_name (parser,
3695                                              typename_keyword_p,
3696                                              template_keyword_p,
3697                                              check_dependency_p,
3698                                              type_p,
3699                                              is_declaration);
3700       /* Look for the `::' token.  */
3701       cp_parser_require (parser, CPP_SCOPE, "`::'");
3702
3703       /* If we found what we wanted, we keep going; otherwise, we're
3704          done.  */
3705       if (!cp_parser_parse_definitely (parser))
3706         {
3707           bool error_p = false;
3708
3709           /* Restore the OLD_SCOPE since it was valid before the
3710              failed attempt at finding the last
3711              class-or-namespace-name.  */
3712           parser->scope = old_scope;
3713           parser->qualifying_scope = saved_qualifying_scope;
3714           if (cp_parser_uncommitted_to_tentative_parse_p (parser))
3715             break;
3716           /* If the next token is an identifier, and the one after
3717              that is a `::', then any valid interpretation would have
3718              found a class-or-namespace-name.  */
3719           while (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
3720                  && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
3721                      == CPP_SCOPE)
3722                  && (cp_lexer_peek_nth_token (parser->lexer, 3)->type
3723                      != CPP_COMPL))
3724             {
3725               token = cp_lexer_consume_token (parser->lexer);
3726               if (!error_p)
3727                 {
3728                   if (!token->ambiguous_p)
3729                     {
3730                       tree decl;
3731                       tree ambiguous_decls;
3732
3733                       decl = cp_parser_lookup_name (parser, token->value,
3734                                                     none_type,
3735                                                     /*is_template=*/false,
3736                                                     /*is_namespace=*/false,
3737                                                     /*check_dependency=*/true,
3738                                                     &ambiguous_decls);
3739                       if (TREE_CODE (decl) == TEMPLATE_DECL)
3740                         error ("%qD used without template parameters", decl);
3741                       else if (ambiguous_decls)
3742                         {
3743                           error ("reference to %qD is ambiguous",
3744                                  token->value);
3745                           print_candidates (ambiguous_decls);
3746                           decl = error_mark_node;
3747                         }
3748                       else
3749                         cp_parser_name_lookup_error
3750                           (parser, token->value, decl,
3751                            "is not a class or namespace");
3752                     }
3753                   parser->scope = error_mark_node;
3754                   error_p = true;
3755                   /* Treat this as a successful nested-name-specifier
3756                      due to:
3757
3758                      [basic.lookup.qual]
3759
3760                      If the name found is not a class-name (clause
3761                      _class_) or namespace-name (_namespace.def_), the
3762                      program is ill-formed.  */
3763                   success = true;
3764                 }
3765               cp_lexer_consume_token (parser->lexer);
3766             }
3767           break;
3768         }
3769       /* We've found one valid nested-name-specifier.  */
3770       success = true;
3771       /* Name lookup always gives us a DECL.  */
3772       if (TREE_CODE (new_scope) == TYPE_DECL)
3773         new_scope = TREE_TYPE (new_scope);
3774       /* Uses of "template" must be followed by actual templates.  */
3775       if (template_keyword_p
3776           && !(CLASS_TYPE_P (new_scope)
3777                && ((CLASSTYPE_USE_TEMPLATE (new_scope)
3778                     && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (new_scope)))
3779                    || CLASSTYPE_IS_TEMPLATE (new_scope)))
3780           && !(TREE_CODE (new_scope) == TYPENAME_TYPE
3781                && (TREE_CODE (TYPENAME_TYPE_FULLNAME (new_scope))
3782                    == TEMPLATE_ID_EXPR)))
3783         pedwarn (TYPE_P (new_scope)
3784                  ? "%qT is not a template"
3785                  : "%qD is not a template",
3786                  new_scope);
3787       /* If it is a class scope, try to complete it; we are about to
3788          be looking up names inside the class.  */
3789       if (TYPE_P (new_scope)
3790           /* Since checking types for dependency can be expensive,
3791              avoid doing it if the type is already complete.  */
3792           && !COMPLETE_TYPE_P (new_scope)
3793           /* Do not try to complete dependent types.  */
3794           && !dependent_type_p (new_scope))
3795         new_scope = complete_type (new_scope);
3796       /* Make sure we look in the right scope the next time through
3797          the loop.  */
3798       parser->scope = new_scope;
3799     }
3800
3801   /* If parsing tentatively, replace the sequence of tokens that makes
3802      up the nested-name-specifier with a CPP_NESTED_NAME_SPECIFIER
3803      token.  That way, should we re-parse the token stream, we will
3804      not have to repeat the effort required to do the parse, nor will
3805      we issue duplicate error messages.  */
3806   if (success && start)
3807     {
3808       cp_token *token;
3809       tree access_checks;
3810
3811       token = cp_lexer_token_at (parser->lexer, start);
3812       /* Reset the contents of the START token.  */
3813       token->type = CPP_NESTED_NAME_SPECIFIER;
3814       /* Retrieve any deferred checks.  Do not pop this access checks yet
3815          so the memory will not be reclaimed during token replacing below.  */
3816       access_checks = get_deferred_access_checks ();
3817       token->value = build_tree_list (copy_list (access_checks),
3818                                       parser->scope);
3819       TREE_TYPE (token->value) = parser->qualifying_scope;
3820       token->keyword = RID_MAX;
3821
3822       /* Purge all subsequent tokens.  */
3823       cp_lexer_purge_tokens_after (parser->lexer, start);
3824     }
3825
3826   if (start)
3827     pop_to_parent_deferring_access_checks ();
3828
3829   return success ? parser->scope : NULL_TREE;
3830 }
3831
3832 /* Parse a nested-name-specifier.  See
3833    cp_parser_nested_name_specifier_opt for details.  This function
3834    behaves identically, except that it will an issue an error if no
3835    nested-name-specifier is present.  */
3836
3837 static tree
3838 cp_parser_nested_name_specifier (cp_parser *parser,
3839                                  bool typename_keyword_p,
3840                                  bool check_dependency_p,
3841                                  bool type_p,
3842                                  bool is_declaration)
3843 {
3844   tree scope;
3845
3846   /* Look for the nested-name-specifier.  */
3847   scope = cp_parser_nested_name_specifier_opt (parser,
3848                                                typename_keyword_p,
3849                                                check_dependency_p,
3850                                                type_p,
3851                                                is_declaration);
3852   /* If it was not present, issue an error message.  */
3853   if (!scope)
3854     {
3855       cp_parser_error (parser, "expected nested-name-specifier");
3856       parser->scope = NULL_TREE;
3857     }
3858
3859   return scope;
3860 }
3861
3862 /* Parse a class-or-namespace-name.
3863
3864    class-or-namespace-name:
3865      class-name
3866      namespace-name
3867
3868    TYPENAME_KEYWORD_P is TRUE iff the `typename' keyword is in effect.
3869    TEMPLATE_KEYWORD_P is TRUE iff the `template' keyword is in effect.
3870    CHECK_DEPENDENCY_P is FALSE iff dependent names should be looked up.
3871    TYPE_P is TRUE iff the next name should be taken as a class-name,
3872    even the same name is declared to be another entity in the same
3873    scope.
3874
3875    Returns the class (TYPE_DECL) or namespace (NAMESPACE_DECL)
3876    specified by the class-or-namespace-name.  If neither is found the
3877    ERROR_MARK_NODE is returned.  */
3878
3879 static tree
3880 cp_parser_class_or_namespace_name (cp_parser *parser,
3881                                    bool typename_keyword_p,
3882                                    bool template_keyword_p,
3883                                    bool check_dependency_p,
3884                                    bool type_p,
3885                                    bool is_declaration)
3886 {
3887   tree saved_scope;
3888   tree saved_qualifying_scope;
3889   tree saved_object_scope;
3890   tree scope;
3891   bool only_class_p;
3892
3893   /* Before we try to parse the class-name, we must save away the
3894      current PARSER->SCOPE since cp_parser_class_name will destroy
3895      it.  */
3896   saved_scope = parser->scope;
3897   saved_qualifying_scope = parser->qualifying_scope;
3898   saved_object_scope = parser->object_scope;
3899   /* Try for a class-name first.  If the SAVED_SCOPE is a type, then
3900      there is no need to look for a namespace-name.  */
3901   only_class_p = template_keyword_p || (saved_scope && TYPE_P (saved_scope));
3902   if (!only_class_p)
3903     cp_parser_parse_tentatively (parser);
3904   scope = cp_parser_class_name (parser,
3905                                 typename_keyword_p,
3906                                 template_keyword_p,
3907                                 type_p ? class_type : none_type,
3908                                 check_dependency_p,
3909                                 /*class_head_p=*/false,
3910                                 is_declaration);
3911   /* If that didn't work, try for a namespace-name.  */
3912   if (!only_class_p && !cp_parser_parse_definitely (parser))
3913     {
3914       /* Restore the saved scope.  */
3915       parser->scope = saved_scope;
3916       parser->qualifying_scope = saved_qualifying_scope;
3917       parser->object_scope = saved_object_scope;
3918       /* If we are not looking at an identifier followed by the scope
3919          resolution operator, then this is not part of a
3920          nested-name-specifier.  (Note that this function is only used
3921          to parse the components of a nested-name-specifier.)  */
3922       if (cp_lexer_next_token_is_not (parser->lexer, CPP_NAME)
3923           || cp_lexer_peek_nth_token (parser->lexer, 2)->type != CPP_SCOPE)
3924         return error_mark_node;
3925       scope = cp_parser_namespace_name (parser);
3926     }
3927
3928   return scope;
3929 }
3930
3931 /* Parse a postfix-expression.
3932
3933    postfix-expression:
3934      primary-expression
3935      postfix-expression [ expression ]
3936      postfix-expression ( expression-list [opt] )
3937      simple-type-specifier ( expression-list [opt] )
3938      typename :: [opt] nested-name-specifier identifier
3939        ( expression-list [opt] )
3940      typename :: [opt] nested-name-specifier template [opt] template-id
3941        ( expression-list [opt] )
3942      postfix-expression . template [opt] id-expression
3943      postfix-expression -> template [opt] id-expression
3944      postfix-expression . pseudo-destructor-name
3945      postfix-expression -> pseudo-destructor-name
3946      postfix-expression ++
3947      postfix-expression --
3948      dynamic_cast < type-id > ( expression )
3949      static_cast < type-id > ( expression )
3950      reinterpret_cast < type-id > ( expression )
3951      const_cast < type-id > ( expression )
3952      typeid ( expression )
3953      typeid ( type-id )
3954
3955    GNU Extension:
3956
3957    postfix-expression:
3958      ( type-id ) { initializer-list , [opt] }
3959
3960    This extension is a GNU version of the C99 compound-literal
3961    construct.  (The C99 grammar uses `type-name' instead of `type-id',
3962    but they are essentially the same concept.)
3963
3964    If ADDRESS_P is true, the postfix expression is the operand of the
3965    `&' operator.  CAST_P is true if this expression is the target of a
3966    cast.
3967
3968    Returns a representation of the expression.  */
3969
3970 static tree
3971 cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p)
3972 {
3973   cp_token *token;
3974   enum rid keyword;
3975   cp_id_kind idk = CP_ID_KIND_NONE;
3976   tree postfix_expression = NULL_TREE;
3977
3978   /* Peek at the next token.  */
3979   token = cp_lexer_peek_token (parser->lexer);
3980   /* Some of the productions are determined by keywords.  */
3981   keyword = token->keyword;
3982   switch (keyword)
3983     {
3984     case RID_DYNCAST:
3985     case RID_STATCAST:
3986     case RID_REINTCAST:
3987     case RID_CONSTCAST:
3988       {
3989         tree type;
3990         tree expression;
3991         const char *saved_message;
3992
3993         /* All of these can be handled in the same way from the point
3994            of view of parsing.  Begin by consuming the token
3995            identifying the cast.  */
3996         cp_lexer_consume_token (parser->lexer);
3997
3998         /* New types cannot be defined in the cast.  */
3999         saved_message = parser->type_definition_forbidden_message;
4000         parser->type_definition_forbidden_message
4001           = "types may not be defined in casts";
4002
4003         /* Look for the opening `<'.  */
4004         cp_parser_require (parser, CPP_LESS, "`<'");
4005         /* Parse the type to which we are casting.  */
4006         type = cp_parser_type_id (parser);
4007         /* Look for the closing `>'.  */
4008         cp_parser_require (parser, CPP_GREATER, "`>'");
4009         /* Restore the old message.  */
4010         parser->type_definition_forbidden_message = saved_message;
4011
4012         /* And the expression which is being cast.  */
4013         cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
4014         expression = cp_parser_expression (parser, /*cast_p=*/true);
4015         cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
4016
4017         /* Only type conversions to integral or enumeration types
4018            can be used in constant-expressions.  */
4019         if (!cast_valid_in_integral_constant_expression_p (type)
4020             && (cp_parser_non_integral_constant_expression
4021                 (parser,
4022                  "a cast to a type other than an integral or "
4023                  "enumeration type")))
4024           return error_mark_node;
4025
4026         switch (keyword)
4027           {
4028           case RID_DYNCAST:
4029             postfix_expression
4030               = build_dynamic_cast (type, expression);
4031             break;
4032           case RID_STATCAST:
4033             postfix_expression
4034               = build_static_cast (type, expression);
4035             break;
4036           case RID_REINTCAST:
4037             postfix_expression
4038               = build_reinterpret_cast (type, expression);
4039             break;
4040           case RID_CONSTCAST:
4041             postfix_expression
4042               = build_const_cast (type, expression);
4043             break;
4044           default:
4045             gcc_unreachable ();
4046           }
4047       }
4048       break;
4049
4050     case RID_TYPEID:
4051       {
4052         tree type;
4053         const char *saved_message;
4054         bool saved_in_type_id_in_expr_p;
4055
4056         /* Consume the `typeid' token.  */
4057         cp_lexer_consume_token (parser->lexer);
4058         /* Look for the `(' token.  */
4059         cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
4060         /* Types cannot be defined in a `typeid' expression.  */
4061         saved_message = parser->type_definition_forbidden_message;
4062         parser->type_definition_forbidden_message
4063           = "types may not be defined in a `typeid\' expression";
4064         /* We can't be sure yet whether we're looking at a type-id or an
4065            expression.  */
4066         cp_parser_parse_tentatively (parser);
4067         /* Try a type-id first.  */
4068         saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p;
4069         parser->in_type_id_in_expr_p = true;
4070         type = cp_parser_type_id (parser);
4071         parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
4072         /* Look for the `)' token.  Otherwise, we can't be sure that
4073            we're not looking at an expression: consider `typeid (int
4074            (3))', for example.  */
4075         cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
4076         /* If all went well, simply lookup the type-id.  */
4077         if (cp_parser_parse_definitely (parser))
4078           postfix_expression = get_typeid (type);
4079         /* Otherwise, fall back to the expression variant.  */
4080         else
4081           {
4082             tree expression;
4083
4084             /* Look for an expression.  */
4085             expression = cp_parser_expression (parser, /*cast_p=*/false);
4086             /* Compute its typeid.  */
4087             postfix_expression = build_typeid (expression);
4088             /* Look for the `)' token.  */
4089             cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
4090           }
4091         /* Restore the saved message.  */
4092         parser->type_definition_forbidden_message = saved_message;
4093         /* `typeid' may not appear in an integral constant expression.  */
4094         if (cp_parser_non_integral_constant_expression(parser,
4095                                                        "`typeid' operator"))
4096           return error_mark_node;
4097       }
4098       break;
4099
4100     case RID_TYPENAME:
4101       {
4102         tree type;
4103         /* The syntax permitted here is the same permitted for an
4104            elaborated-type-specifier.  */
4105         type = cp_parser_elaborated_type_specifier (parser,
4106                                                     /*is_friend=*/false,
4107                                                     /*is_declaration=*/false);
4108         postfix_expression = cp_parser_functional_cast (parser, type);
4109       }
4110       break;
4111
4112     default:
4113       {
4114         tree type;
4115
4116         /* If the next thing is a simple-type-specifier, we may be
4117            looking at a functional cast.  We could also be looking at
4118            an id-expression.  So, we try the functional cast, and if
4119            that doesn't work we fall back to the primary-expression.  */
4120         cp_parser_parse_tentatively (parser);
4121         /* Look for the simple-type-specifier.  */
4122         type = cp_parser_simple_type_specifier (parser,
4123                                                 /*decl_specs=*/NULL,
4124                                                 CP_PARSER_FLAGS_NONE);
4125         /* Parse the cast itself.  */
4126         if (!cp_parser_error_occurred (parser))
4127           postfix_expression
4128             = cp_parser_functional_cast (parser, type);
4129         /* If that worked, we're done.  */
4130         if (cp_parser_parse_definitely (parser))
4131           break;
4132
4133         /* If the functional-cast didn't work out, try a
4134            compound-literal.  */
4135         if (cp_parser_allow_gnu_extensions_p (parser)
4136             && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
4137           {
4138             VEC(constructor_elt,gc) *initializer_list = NULL;
4139             bool saved_in_type_id_in_expr_p;
4140
4141             cp_parser_parse_tentatively (parser);
4142             /* Consume the `('.  */
4143             cp_lexer_consume_token (parser->lexer);
4144             /* Parse the type.  */
4145             saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p;
4146             parser->in_type_id_in_expr_p = true;
4147             type = cp_parser_type_id (parser);
4148             parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
4149             /* Look for the `)'.  */
4150             cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
4151             /* Look for the `{'.  */
4152             cp_parser_require (parser, CPP_OPEN_BRACE, "`{'");