OSDN Git Service

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