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