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