OSDN Git Service

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