OSDN Git Service

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