OSDN Git Service

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