OSDN Git Service

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