OSDN Git Service

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