OSDN Git Service

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