OSDN Git Service

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