OSDN Git Service

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