OSDN Git Service

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