OSDN Git Service

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