OSDN Git Service

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