2 Copyright (C) 2000, 2001, 2002, 2003, 2004,
3 2005, 2007, 2008 Free Software Foundation, Inc.
4 Written by Mark Mitchell <mark@codesourcery.com>.
6 This file is part of GCC.
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)
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.
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/>. */
24 #include "coretypes.h"
26 #include "dyn-string.h"
34 #include "diagnostic.h"
44 /* The cp_lexer_* routines mediate between the lexer proper (in libcpp
45 and c-lex.c) and the C++ parser. */
47 /* A token's value and its associated deferred access checks and
50 struct tree_check GTY(())
52 /* The value associated with the token. */
54 /* The checks that have been associated with value. */
55 VEC (deferred_access_check, gc)* checks;
56 /* The token's qualifying scope (used when it is a
57 CPP_NESTED_NAME_SPECIFIER). */
58 tree qualifying_scope;
63 typedef struct cp_token GTY (())
65 /* The kind of token. */
66 ENUM_BITFIELD (cpp_ttype) type : 8;
67 /* If this token is a keyword, this value indicates which keyword.
68 Otherwise, this value is RID_MAX. */
69 ENUM_BITFIELD (rid) keyword : 8;
72 /* Identifier for the pragma. */
73 ENUM_BITFIELD (pragma_kind) pragma_kind : 6;
74 /* True if this token is from a system header. */
75 BOOL_BITFIELD in_system_header : 1;
76 /* True if this token is from a context where it is implicitly extern "C" */
77 BOOL_BITFIELD implicit_extern_c : 1;
78 /* True for a CPP_NAME token that is not a keyword (i.e., for which
79 KEYWORD is RID_MAX) iff this name was looked up and found to be
80 ambiguous. An error has already been reported. */
81 BOOL_BITFIELD ambiguous_p : 1;
82 /* The value associated with this token, if any. */
83 union cp_token_value {
84 /* Used for CPP_NESTED_NAME_SPECIFIER and CPP_TEMPLATE_ID. */
85 struct tree_check* GTY((tag ("1"))) tree_check_value;
86 /* Use for all other tokens. */
87 tree GTY((tag ("0"))) value;
88 } GTY((desc ("(%1.type == CPP_TEMPLATE_ID) || (%1.type == CPP_NESTED_NAME_SPECIFIER)"))) u;
89 /* The location at which this token was found. */
93 /* We use a stack of token pointer for saving token sets. */
94 typedef struct cp_token *cp_token_position;
95 DEF_VEC_P (cp_token_position);
96 DEF_VEC_ALLOC_P (cp_token_position,heap);
98 static cp_token eof_token =
100 CPP_EOF, RID_MAX, 0, PRAGMA_NONE, 0, false, 0, { NULL },
104 /* The cp_lexer structure represents the C++ lexer. It is responsible
105 for managing the token stream from the preprocessor and supplying
106 it to the parser. Tokens are never added to the cp_lexer after
109 typedef struct cp_lexer GTY (())
111 /* The memory allocated for the buffer. NULL if this lexer does not
112 own the token buffer. */
113 cp_token * GTY ((length ("%h.buffer_length"))) buffer;
114 /* If the lexer owns the buffer, this is the number of tokens in the
116 size_t buffer_length;
118 /* A pointer just past the last available token. The tokens
119 in this lexer are [buffer, last_token). */
120 cp_token_position GTY ((skip)) last_token;
122 /* The next available token. If NEXT_TOKEN is &eof_token, then there are
123 no more available tokens. */
124 cp_token_position GTY ((skip)) next_token;
126 /* A stack indicating positions at which cp_lexer_save_tokens was
127 called. The top entry is the most recent position at which we
128 began saving tokens. If the stack is non-empty, we are saving
130 VEC(cp_token_position,heap) *GTY ((skip)) saved_tokens;
132 /* The next lexer in a linked list of lexers. */
133 struct cp_lexer *next;
135 /* True if we should output debugging information. */
138 /* True if we're in the context of parsing a pragma, and should not
139 increment past the end-of-line marker. */
143 /* cp_token_cache is a range of tokens. There is no need to represent
144 allocate heap memory for it, since tokens are never removed from the
145 lexer's array. There is also no need for the GC to walk through
146 a cp_token_cache, since everything in here is referenced through
149 typedef struct cp_token_cache GTY(())
151 /* The beginning of the token range. */
152 cp_token * GTY((skip)) first;
154 /* Points immediately after the last token in the range. */
155 cp_token * GTY ((skip)) last;
160 static cp_lexer *cp_lexer_new_main
162 static cp_lexer *cp_lexer_new_from_tokens
163 (cp_token_cache *tokens);
164 static void cp_lexer_destroy
166 static int cp_lexer_saving_tokens
168 static cp_token_position cp_lexer_token_position
170 static cp_token *cp_lexer_token_at
171 (cp_lexer *, cp_token_position);
172 static void cp_lexer_get_preprocessor_token
173 (cp_lexer *, cp_token *);
174 static inline cp_token *cp_lexer_peek_token
176 static cp_token *cp_lexer_peek_nth_token
177 (cp_lexer *, size_t);
178 static inline bool cp_lexer_next_token_is
179 (cp_lexer *, enum cpp_ttype);
180 static bool cp_lexer_next_token_is_not
181 (cp_lexer *, enum cpp_ttype);
182 static bool cp_lexer_next_token_is_keyword
183 (cp_lexer *, enum rid);
184 static cp_token *cp_lexer_consume_token
186 static void cp_lexer_purge_token
188 static void cp_lexer_purge_tokens_after
189 (cp_lexer *, cp_token_position);
190 static void cp_lexer_save_tokens
192 static void cp_lexer_commit_tokens
194 static void cp_lexer_rollback_tokens
196 #ifdef ENABLE_CHECKING
197 static void cp_lexer_print_token
198 (FILE *, cp_token *);
199 static inline bool cp_lexer_debugging_p
201 static void cp_lexer_start_debugging
202 (cp_lexer *) ATTRIBUTE_UNUSED;
203 static void cp_lexer_stop_debugging
204 (cp_lexer *) ATTRIBUTE_UNUSED;
206 /* If we define cp_lexer_debug_stream to NULL it will provoke warnings
207 about passing NULL to functions that require non-NULL arguments
208 (fputs, fprintf). It will never be used, so all we need is a value
209 of the right type that's guaranteed not to be NULL. */
210 #define cp_lexer_debug_stream stdout
211 #define cp_lexer_print_token(str, tok) (void) 0
212 #define cp_lexer_debugging_p(lexer) 0
213 #endif /* ENABLE_CHECKING */
215 static cp_token_cache *cp_token_cache_new
216 (cp_token *, cp_token *);
218 static void cp_parser_initial_pragma
221 /* Manifest constants. */
222 #define CP_LEXER_BUFFER_SIZE ((256 * 1024) / sizeof (cp_token))
223 #define CP_SAVED_TOKEN_STACK 5
225 /* A token type for keywords, as opposed to ordinary identifiers. */
226 #define CPP_KEYWORD ((enum cpp_ttype) (N_TTYPES + 1))
228 /* A token type for template-ids. If a template-id is processed while
229 parsing tentatively, it is replaced with a CPP_TEMPLATE_ID token;
230 the value of the CPP_TEMPLATE_ID is whatever was returned by
231 cp_parser_template_id. */
232 #define CPP_TEMPLATE_ID ((enum cpp_ttype) (CPP_KEYWORD + 1))
234 /* A token type for nested-name-specifiers. If a
235 nested-name-specifier is processed while parsing tentatively, it is
236 replaced with a CPP_NESTED_NAME_SPECIFIER token; the value of the
237 CPP_NESTED_NAME_SPECIFIER is whatever was returned by
238 cp_parser_nested_name_specifier_opt. */
239 #define CPP_NESTED_NAME_SPECIFIER ((enum cpp_ttype) (CPP_TEMPLATE_ID + 1))
241 /* A token type for tokens that are not tokens at all; these are used
242 to represent slots in the array where there used to be a token
243 that has now been deleted. */
244 #define CPP_PURGED ((enum cpp_ttype) (CPP_NESTED_NAME_SPECIFIER + 1))
246 /* The number of token types, including C++-specific ones. */
247 #define N_CP_TTYPES ((int) (CPP_PURGED + 1))
251 #ifdef ENABLE_CHECKING
252 /* The stream to which debugging output should be written. */
253 static FILE *cp_lexer_debug_stream;
254 #endif /* ENABLE_CHECKING */
256 /* Create a new main C++ lexer, the lexer that gets tokens from the
260 cp_lexer_new_main (void)
262 cp_token first_token;
269 /* It's possible that parsing the first pragma will load a PCH file,
270 which is a GC collection point. So we have to do that before
271 allocating any memory. */
272 cp_parser_initial_pragma (&first_token);
274 c_common_no_more_pch ();
276 /* Allocate the memory. */
277 lexer = GGC_CNEW (cp_lexer);
279 #ifdef ENABLE_CHECKING
280 /* Initially we are not debugging. */
281 lexer->debugging_p = false;
282 #endif /* ENABLE_CHECKING */
283 lexer->saved_tokens = VEC_alloc (cp_token_position, heap,
284 CP_SAVED_TOKEN_STACK);
286 /* Create the buffer. */
287 alloc = CP_LEXER_BUFFER_SIZE;
288 buffer = GGC_NEWVEC (cp_token, alloc);
290 /* Put the first token in the buffer. */
295 /* Get the remaining tokens from the preprocessor. */
296 while (pos->type != CPP_EOF)
303 buffer = GGC_RESIZEVEC (cp_token, buffer, alloc);
304 pos = buffer + space;
306 cp_lexer_get_preprocessor_token (lexer, pos);
308 lexer->buffer = buffer;
309 lexer->buffer_length = alloc - space;
310 lexer->last_token = pos;
311 lexer->next_token = lexer->buffer_length ? buffer : &eof_token;
313 /* Subsequent preprocessor diagnostics should use compiler
314 diagnostic functions to get the compiler source location. */
315 cpp_get_options (parse_in)->client_diagnostic = true;
316 cpp_get_callbacks (parse_in)->error = cp_cpp_error;
318 gcc_assert (lexer->next_token->type != CPP_PURGED);
322 /* Create a new lexer whose token stream is primed with the tokens in
323 CACHE. When these tokens are exhausted, no new tokens will be read. */
326 cp_lexer_new_from_tokens (cp_token_cache *cache)
328 cp_token *first = cache->first;
329 cp_token *last = cache->last;
330 cp_lexer *lexer = GGC_CNEW (cp_lexer);
332 /* We do not own the buffer. */
333 lexer->buffer = NULL;
334 lexer->buffer_length = 0;
335 lexer->next_token = first == last ? &eof_token : first;
336 lexer->last_token = last;
338 lexer->saved_tokens = VEC_alloc (cp_token_position, heap,
339 CP_SAVED_TOKEN_STACK);
341 #ifdef ENABLE_CHECKING
342 /* Initially we are not debugging. */
343 lexer->debugging_p = false;
346 gcc_assert (lexer->next_token->type != CPP_PURGED);
350 /* Frees all resources associated with LEXER. */
353 cp_lexer_destroy (cp_lexer *lexer)
356 ggc_free (lexer->buffer);
357 VEC_free (cp_token_position, heap, lexer->saved_tokens);
361 /* Returns nonzero if debugging information should be output. */
363 #ifdef ENABLE_CHECKING
366 cp_lexer_debugging_p (cp_lexer *lexer)
368 return lexer->debugging_p;
371 #endif /* ENABLE_CHECKING */
373 static inline cp_token_position
374 cp_lexer_token_position (cp_lexer *lexer, bool previous_p)
376 gcc_assert (!previous_p || lexer->next_token != &eof_token);
378 return lexer->next_token - previous_p;
381 static inline cp_token *
382 cp_lexer_token_at (cp_lexer *lexer ATTRIBUTE_UNUSED, cp_token_position pos)
387 /* nonzero if we are presently saving tokens. */
390 cp_lexer_saving_tokens (const cp_lexer* lexer)
392 return VEC_length (cp_token_position, lexer->saved_tokens) != 0;
395 /* Store the next token from the preprocessor in *TOKEN. Return true
396 if we reach EOF. If LEXER is NULL, assume we are handling an
397 initial #pragma pch_preprocess, and thus want the lexer to return
398 processed strings. */
401 cp_lexer_get_preprocessor_token (cp_lexer *lexer, cp_token *token)
403 static int is_extern_c = 0;
405 /* Get a new token from the preprocessor. */
407 = c_lex_with_flags (&token->u.value, &token->location, &token->flags,
408 lexer == NULL ? 0 : C_LEX_RAW_STRINGS);
409 token->keyword = RID_MAX;
410 token->pragma_kind = PRAGMA_NONE;
411 token->in_system_header = in_system_header;
413 /* On some systems, some header files are surrounded by an
414 implicit extern "C" block. Set a flag in the token if it
415 comes from such a header. */
416 is_extern_c += pending_lang_change;
417 pending_lang_change = 0;
418 token->implicit_extern_c = is_extern_c > 0;
420 /* Check to see if this token is a keyword. */
421 if (token->type == CPP_NAME)
423 if (C_IS_RESERVED_WORD (token->u.value))
425 /* Mark this token as a keyword. */
426 token->type = CPP_KEYWORD;
427 /* Record which keyword. */
428 token->keyword = C_RID_CODE (token->u.value);
429 /* Update the value. Some keywords are mapped to particular
430 entities, rather than simply having the value of the
431 corresponding IDENTIFIER_NODE. For example, `__const' is
432 mapped to `const'. */
433 token->u.value = ridpointers[token->keyword];
437 if (warn_cxx0x_compat
438 && C_RID_CODE (token->u.value) >= RID_FIRST_CXX0X
439 && C_RID_CODE (token->u.value) <= RID_LAST_CXX0X)
441 /* Warn about the C++0x keyword (but still treat it as
443 warning (OPT_Wc__0x_compat,
444 "identifier %<%s%> will become a keyword in C++0x",
445 IDENTIFIER_POINTER (token->u.value));
447 /* Clear out the C_RID_CODE so we don't warn about this
448 particular identifier-turned-keyword again. */
449 C_RID_CODE (token->u.value) = RID_MAX;
452 token->ambiguous_p = false;
453 token->keyword = RID_MAX;
456 /* Handle Objective-C++ keywords. */
457 else if (token->type == CPP_AT_NAME)
459 token->type = CPP_KEYWORD;
460 switch (C_RID_CODE (token->u.value))
462 /* Map 'class' to '@class', 'private' to '@private', etc. */
463 case RID_CLASS: token->keyword = RID_AT_CLASS; break;
464 case RID_PRIVATE: token->keyword = RID_AT_PRIVATE; break;
465 case RID_PROTECTED: token->keyword = RID_AT_PROTECTED; break;
466 case RID_PUBLIC: token->keyword = RID_AT_PUBLIC; break;
467 case RID_THROW: token->keyword = RID_AT_THROW; break;
468 case RID_TRY: token->keyword = RID_AT_TRY; break;
469 case RID_CATCH: token->keyword = RID_AT_CATCH; break;
470 default: token->keyword = C_RID_CODE (token->u.value);
473 else if (token->type == CPP_PRAGMA)
475 /* We smuggled the cpp_token->u.pragma value in an INTEGER_CST. */
476 token->pragma_kind = TREE_INT_CST_LOW (token->u.value);
477 token->u.value = NULL_TREE;
481 /* Update the globals input_location and in_system_header and the
482 input file stack from TOKEN. */
484 cp_lexer_set_source_position_from_token (cp_token *token)
486 if (token->type != CPP_EOF)
488 input_location = token->location;
489 in_system_header = token->in_system_header;
493 /* Return a pointer to the next token in the token stream, but do not
496 static inline cp_token *
497 cp_lexer_peek_token (cp_lexer *lexer)
499 if (cp_lexer_debugging_p (lexer))
501 fputs ("cp_lexer: peeking at token: ", cp_lexer_debug_stream);
502 cp_lexer_print_token (cp_lexer_debug_stream, lexer->next_token);
503 putc ('\n', cp_lexer_debug_stream);
505 return lexer->next_token;
508 /* Return true if the next token has the indicated TYPE. */
511 cp_lexer_next_token_is (cp_lexer* lexer, enum cpp_ttype type)
513 return cp_lexer_peek_token (lexer)->type == type;
516 /* Return true if the next token does not have the indicated TYPE. */
519 cp_lexer_next_token_is_not (cp_lexer* lexer, enum cpp_ttype type)
521 return !cp_lexer_next_token_is (lexer, type);
524 /* Return true if the next token is the indicated KEYWORD. */
527 cp_lexer_next_token_is_keyword (cp_lexer* lexer, enum rid keyword)
529 return cp_lexer_peek_token (lexer)->keyword == keyword;
532 /* Return true if the next token is a keyword for a decl-specifier. */
535 cp_lexer_next_token_is_decl_specifier_keyword (cp_lexer *lexer)
539 token = cp_lexer_peek_token (lexer);
540 switch (token->keyword)
542 /* auto specifier: storage-class-specifier in C++,
543 simple-type-specifier in C++0x. */
545 /* Storage classes. */
551 /* Elaborated type specifiers. */
557 /* Simple type specifiers. */
571 /* GNU extensions. */
574 /* C++0x extensions. */
583 /* Return a pointer to the Nth token in the token stream. If N is 1,
584 then this is precisely equivalent to cp_lexer_peek_token (except
585 that it is not inline). One would like to disallow that case, but
586 there is one case (cp_parser_nth_token_starts_template_id) where
587 the caller passes a variable for N and it might be 1. */
590 cp_lexer_peek_nth_token (cp_lexer* lexer, size_t n)
594 /* N is 1-based, not zero-based. */
597 if (cp_lexer_debugging_p (lexer))
598 fprintf (cp_lexer_debug_stream,
599 "cp_lexer: peeking ahead %ld at token: ", (long)n);
602 token = lexer->next_token;
603 gcc_assert (!n || token != &eof_token);
607 if (token == lexer->last_token)
613 if (token->type != CPP_PURGED)
617 if (cp_lexer_debugging_p (lexer))
619 cp_lexer_print_token (cp_lexer_debug_stream, token);
620 putc ('\n', cp_lexer_debug_stream);
626 /* Return the next token, and advance the lexer's next_token pointer
627 to point to the next non-purged token. */
630 cp_lexer_consume_token (cp_lexer* lexer)
632 cp_token *token = lexer->next_token;
634 gcc_assert (token != &eof_token);
635 gcc_assert (!lexer->in_pragma || token->type != CPP_PRAGMA_EOL);
640 if (lexer->next_token == lexer->last_token)
642 lexer->next_token = &eof_token;
647 while (lexer->next_token->type == CPP_PURGED);
649 cp_lexer_set_source_position_from_token (token);
651 /* Provide debugging output. */
652 if (cp_lexer_debugging_p (lexer))
654 fputs ("cp_lexer: consuming token: ", cp_lexer_debug_stream);
655 cp_lexer_print_token (cp_lexer_debug_stream, token);
656 putc ('\n', cp_lexer_debug_stream);
662 /* Permanently remove the next token from the token stream, and
663 advance the next_token pointer to refer to the next non-purged
667 cp_lexer_purge_token (cp_lexer *lexer)
669 cp_token *tok = lexer->next_token;
671 gcc_assert (tok != &eof_token);
672 tok->type = CPP_PURGED;
673 tok->location = UNKNOWN_LOCATION;
674 tok->u.value = NULL_TREE;
675 tok->keyword = RID_MAX;
680 if (tok == lexer->last_token)
686 while (tok->type == CPP_PURGED);
687 lexer->next_token = tok;
690 /* Permanently remove all tokens after TOK, up to, but not
691 including, the token that will be returned next by
692 cp_lexer_peek_token. */
695 cp_lexer_purge_tokens_after (cp_lexer *lexer, cp_token *tok)
697 cp_token *peek = lexer->next_token;
699 if (peek == &eof_token)
700 peek = lexer->last_token;
702 gcc_assert (tok < peek);
704 for ( tok += 1; tok != peek; tok += 1)
706 tok->type = CPP_PURGED;
707 tok->location = UNKNOWN_LOCATION;
708 tok->u.value = NULL_TREE;
709 tok->keyword = RID_MAX;
713 /* Begin saving tokens. All tokens consumed after this point will be
717 cp_lexer_save_tokens (cp_lexer* lexer)
719 /* Provide debugging output. */
720 if (cp_lexer_debugging_p (lexer))
721 fprintf (cp_lexer_debug_stream, "cp_lexer: saving tokens\n");
723 VEC_safe_push (cp_token_position, heap,
724 lexer->saved_tokens, lexer->next_token);
727 /* Commit to the portion of the token stream most recently saved. */
730 cp_lexer_commit_tokens (cp_lexer* lexer)
732 /* Provide debugging output. */
733 if (cp_lexer_debugging_p (lexer))
734 fprintf (cp_lexer_debug_stream, "cp_lexer: committing tokens\n");
736 VEC_pop (cp_token_position, lexer->saved_tokens);
739 /* Return all tokens saved since the last call to cp_lexer_save_tokens
740 to the token stream. Stop saving tokens. */
743 cp_lexer_rollback_tokens (cp_lexer* lexer)
745 /* Provide debugging output. */
746 if (cp_lexer_debugging_p (lexer))
747 fprintf (cp_lexer_debug_stream, "cp_lexer: restoring tokens\n");
749 lexer->next_token = VEC_pop (cp_token_position, lexer->saved_tokens);
752 /* Print a representation of the TOKEN on the STREAM. */
754 #ifdef ENABLE_CHECKING
757 cp_lexer_print_token (FILE * stream, cp_token *token)
759 /* We don't use cpp_type2name here because the parser defines
760 a few tokens of its own. */
761 static const char *const token_names[] = {
762 /* cpplib-defined token types */
768 /* C++ parser token types - see "Manifest constants", above. */
771 "NESTED_NAME_SPECIFIER",
775 /* If we have a name for the token, print it out. Otherwise, we
776 simply give the numeric code. */
777 gcc_assert (token->type < ARRAY_SIZE(token_names));
778 fputs (token_names[token->type], stream);
780 /* For some tokens, print the associated data. */
784 /* Some keywords have a value that is not an IDENTIFIER_NODE.
785 For example, `struct' is mapped to an INTEGER_CST. */
786 if (TREE_CODE (token->u.value) != IDENTIFIER_NODE)
788 /* else fall through */
790 fputs (IDENTIFIER_POINTER (token->u.value), stream);
797 fprintf (stream, " \"%s\"", TREE_STRING_POINTER (token->u.value));
805 /* Start emitting debugging information. */
808 cp_lexer_start_debugging (cp_lexer* lexer)
810 lexer->debugging_p = true;
813 /* Stop emitting debugging information. */
816 cp_lexer_stop_debugging (cp_lexer* lexer)
818 lexer->debugging_p = false;
821 #endif /* ENABLE_CHECKING */
823 /* Create a new cp_token_cache, representing a range of tokens. */
825 static cp_token_cache *
826 cp_token_cache_new (cp_token *first, cp_token *last)
828 cp_token_cache *cache = GGC_NEW (cp_token_cache);
829 cache->first = first;
835 /* Decl-specifiers. */
837 /* Set *DECL_SPECS to represent an empty decl-specifier-seq. */
840 clear_decl_specs (cp_decl_specifier_seq *decl_specs)
842 memset (decl_specs, 0, sizeof (cp_decl_specifier_seq));
847 /* Nothing other than the parser should be creating declarators;
848 declarators are a semi-syntactic representation of C++ entities.
849 Other parts of the front end that need to create entities (like
850 VAR_DECLs or FUNCTION_DECLs) should do that directly. */
852 static cp_declarator *make_call_declarator
853 (cp_declarator *, cp_parameter_declarator *, cp_cv_quals, tree);
854 static cp_declarator *make_array_declarator
855 (cp_declarator *, tree);
856 static cp_declarator *make_pointer_declarator
857 (cp_cv_quals, cp_declarator *);
858 static cp_declarator *make_reference_declarator
859 (cp_cv_quals, cp_declarator *, bool);
860 static cp_parameter_declarator *make_parameter_declarator
861 (cp_decl_specifier_seq *, cp_declarator *, tree);
862 static cp_declarator *make_ptrmem_declarator
863 (cp_cv_quals, tree, cp_declarator *);
865 /* An erroneous declarator. */
866 static cp_declarator *cp_error_declarator;
868 /* The obstack on which declarators and related data structures are
870 static struct obstack declarator_obstack;
872 /* Alloc BYTES from the declarator memory pool. */
875 alloc_declarator (size_t bytes)
877 return obstack_alloc (&declarator_obstack, bytes);
880 /* Allocate a declarator of the indicated KIND. Clear fields that are
881 common to all declarators. */
883 static cp_declarator *
884 make_declarator (cp_declarator_kind kind)
886 cp_declarator *declarator;
888 declarator = (cp_declarator *) alloc_declarator (sizeof (cp_declarator));
889 declarator->kind = kind;
890 declarator->attributes = NULL_TREE;
891 declarator->declarator = NULL;
892 declarator->parameter_pack_p = false;
897 /* Make a declarator for a generalized identifier. If
898 QUALIFYING_SCOPE is non-NULL, the identifier is
899 QUALIFYING_SCOPE::UNQUALIFIED_NAME; otherwise, it is just
900 UNQUALIFIED_NAME. SFK indicates the kind of special function this
903 static cp_declarator *
904 make_id_declarator (tree qualifying_scope, tree unqualified_name,
905 special_function_kind sfk)
907 cp_declarator *declarator;
909 /* It is valid to write:
911 class C { void f(); };
915 The standard is not clear about whether `typedef const C D' is
916 legal; as of 2002-09-15 the committee is considering that
917 question. EDG 3.0 allows that syntax. Therefore, we do as
919 if (qualifying_scope && TYPE_P (qualifying_scope))
920 qualifying_scope = TYPE_MAIN_VARIANT (qualifying_scope);
922 gcc_assert (TREE_CODE (unqualified_name) == IDENTIFIER_NODE
923 || TREE_CODE (unqualified_name) == BIT_NOT_EXPR
924 || TREE_CODE (unqualified_name) == TEMPLATE_ID_EXPR);
926 declarator = make_declarator (cdk_id);
927 declarator->u.id.qualifying_scope = qualifying_scope;
928 declarator->u.id.unqualified_name = unqualified_name;
929 declarator->u.id.sfk = sfk;
934 /* Make a declarator for a pointer to TARGET. CV_QUALIFIERS is a list
935 of modifiers such as const or volatile to apply to the pointer
936 type, represented as identifiers. */
939 make_pointer_declarator (cp_cv_quals cv_qualifiers, cp_declarator *target)
941 cp_declarator *declarator;
943 declarator = make_declarator (cdk_pointer);
944 declarator->declarator = target;
945 declarator->u.pointer.qualifiers = cv_qualifiers;
946 declarator->u.pointer.class_type = NULL_TREE;
949 declarator->parameter_pack_p = target->parameter_pack_p;
950 target->parameter_pack_p = false;
953 declarator->parameter_pack_p = false;
958 /* Like make_pointer_declarator -- but for references. */
961 make_reference_declarator (cp_cv_quals cv_qualifiers, cp_declarator *target,
964 cp_declarator *declarator;
966 declarator = make_declarator (cdk_reference);
967 declarator->declarator = target;
968 declarator->u.reference.qualifiers = cv_qualifiers;
969 declarator->u.reference.rvalue_ref = rvalue_ref;
972 declarator->parameter_pack_p = target->parameter_pack_p;
973 target->parameter_pack_p = false;
976 declarator->parameter_pack_p = false;
981 /* Like make_pointer_declarator -- but for a pointer to a non-static
982 member of CLASS_TYPE. */
985 make_ptrmem_declarator (cp_cv_quals cv_qualifiers, tree class_type,
986 cp_declarator *pointee)
988 cp_declarator *declarator;
990 declarator = make_declarator (cdk_ptrmem);
991 declarator->declarator = pointee;
992 declarator->u.pointer.qualifiers = cv_qualifiers;
993 declarator->u.pointer.class_type = class_type;
997 declarator->parameter_pack_p = pointee->parameter_pack_p;
998 pointee->parameter_pack_p = false;
1001 declarator->parameter_pack_p = false;
1006 /* Make a declarator for the function given by TARGET, with the
1007 indicated PARMS. The CV_QUALIFIERS aply to the function, as in
1008 "const"-qualified member function. The EXCEPTION_SPECIFICATION
1009 indicates what exceptions can be thrown. */
1012 make_call_declarator (cp_declarator *target,
1013 cp_parameter_declarator *parms,
1014 cp_cv_quals cv_qualifiers,
1015 tree exception_specification)
1017 cp_declarator *declarator;
1019 declarator = make_declarator (cdk_function);
1020 declarator->declarator = target;
1021 declarator->u.function.parameters = parms;
1022 declarator->u.function.qualifiers = cv_qualifiers;
1023 declarator->u.function.exception_specification = exception_specification;
1026 declarator->parameter_pack_p = target->parameter_pack_p;
1027 target->parameter_pack_p = false;
1030 declarator->parameter_pack_p = false;
1035 /* Make a declarator for an array of BOUNDS elements, each of which is
1036 defined by ELEMENT. */
1039 make_array_declarator (cp_declarator *element, tree bounds)
1041 cp_declarator *declarator;
1043 declarator = make_declarator (cdk_array);
1044 declarator->declarator = element;
1045 declarator->u.array.bounds = bounds;
1048 declarator->parameter_pack_p = element->parameter_pack_p;
1049 element->parameter_pack_p = false;
1052 declarator->parameter_pack_p = false;
1057 /* Determine whether the declarator we've seen so far can be a
1058 parameter pack, when followed by an ellipsis. */
1060 declarator_can_be_parameter_pack (cp_declarator *declarator)
1062 /* Search for a declarator name, or any other declarator that goes
1063 after the point where the ellipsis could appear in a parameter
1064 pack. If we find any of these, then this declarator can not be
1065 made into a parameter pack. */
1067 while (declarator && !found)
1069 switch ((int)declarator->kind)
1080 declarator = declarator->declarator;
1088 cp_parameter_declarator *no_parameters;
1090 /* Create a parameter declarator with the indicated DECL_SPECIFIERS,
1091 DECLARATOR and DEFAULT_ARGUMENT. */
1093 cp_parameter_declarator *
1094 make_parameter_declarator (cp_decl_specifier_seq *decl_specifiers,
1095 cp_declarator *declarator,
1096 tree default_argument)
1098 cp_parameter_declarator *parameter;
1100 parameter = ((cp_parameter_declarator *)
1101 alloc_declarator (sizeof (cp_parameter_declarator)));
1102 parameter->next = NULL;
1103 if (decl_specifiers)
1104 parameter->decl_specifiers = *decl_specifiers;
1106 clear_decl_specs (¶meter->decl_specifiers);
1107 parameter->declarator = declarator;
1108 parameter->default_argument = default_argument;
1109 parameter->ellipsis_p = false;
1114 /* Returns true iff DECLARATOR is a declaration for a function. */
1117 function_declarator_p (const cp_declarator *declarator)
1121 if (declarator->kind == cdk_function
1122 && declarator->declarator->kind == cdk_id)
1124 if (declarator->kind == cdk_id
1125 || declarator->kind == cdk_error)
1127 declarator = declarator->declarator;
1137 A cp_parser parses the token stream as specified by the C++
1138 grammar. Its job is purely parsing, not semantic analysis. For
1139 example, the parser breaks the token stream into declarators,
1140 expressions, statements, and other similar syntactic constructs.
1141 It does not check that the types of the expressions on either side
1142 of an assignment-statement are compatible, or that a function is
1143 not declared with a parameter of type `void'.
1145 The parser invokes routines elsewhere in the compiler to perform
1146 semantic analysis and to build up the abstract syntax tree for the
1149 The parser (and the template instantiation code, which is, in a
1150 way, a close relative of parsing) are the only parts of the
1151 compiler that should be calling push_scope and pop_scope, or
1152 related functions. The parser (and template instantiation code)
1153 keeps track of what scope is presently active; everything else
1154 should simply honor that. (The code that generates static
1155 initializers may also need to set the scope, in order to check
1156 access control correctly when emitting the initializers.)
1161 The parser is of the standard recursive-descent variety. Upcoming
1162 tokens in the token stream are examined in order to determine which
1163 production to use when parsing a non-terminal. Some C++ constructs
1164 require arbitrary look ahead to disambiguate. For example, it is
1165 impossible, in the general case, to tell whether a statement is an
1166 expression or declaration without scanning the entire statement.
1167 Therefore, the parser is capable of "parsing tentatively." When the
1168 parser is not sure what construct comes next, it enters this mode.
1169 Then, while we attempt to parse the construct, the parser queues up
1170 error messages, rather than issuing them immediately, and saves the
1171 tokens it consumes. If the construct is parsed successfully, the
1172 parser "commits", i.e., it issues any queued error messages and
1173 the tokens that were being preserved are permanently discarded.
1174 If, however, the construct is not parsed successfully, the parser
1175 rolls back its state completely so that it can resume parsing using
1176 a different alternative.
1181 The performance of the parser could probably be improved substantially.
1182 We could often eliminate the need to parse tentatively by looking ahead
1183 a little bit. In some places, this approach might not entirely eliminate
1184 the need to parse tentatively, but it might still speed up the average
1187 /* Flags that are passed to some parsing functions. These values can
1188 be bitwise-ored together. */
1190 typedef enum cp_parser_flags
1193 CP_PARSER_FLAGS_NONE = 0x0,
1194 /* The construct is optional. If it is not present, then no error
1195 should be issued. */
1196 CP_PARSER_FLAGS_OPTIONAL = 0x1,
1197 /* When parsing a type-specifier, do not allow user-defined types. */
1198 CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES = 0x2
1201 /* The different kinds of declarators we want to parse. */
1203 typedef enum cp_parser_declarator_kind
1205 /* We want an abstract declarator. */
1206 CP_PARSER_DECLARATOR_ABSTRACT,
1207 /* We want a named declarator. */
1208 CP_PARSER_DECLARATOR_NAMED,
1209 /* We don't mind, but the name must be an unqualified-id. */
1210 CP_PARSER_DECLARATOR_EITHER
1211 } cp_parser_declarator_kind;
1213 /* The precedence values used to parse binary expressions. The minimum value
1214 of PREC must be 1, because zero is reserved to quickly discriminate
1215 binary operators from other tokens. */
1220 PREC_LOGICAL_OR_EXPRESSION,
1221 PREC_LOGICAL_AND_EXPRESSION,
1222 PREC_INCLUSIVE_OR_EXPRESSION,
1223 PREC_EXCLUSIVE_OR_EXPRESSION,
1224 PREC_AND_EXPRESSION,
1225 PREC_EQUALITY_EXPRESSION,
1226 PREC_RELATIONAL_EXPRESSION,
1227 PREC_SHIFT_EXPRESSION,
1228 PREC_ADDITIVE_EXPRESSION,
1229 PREC_MULTIPLICATIVE_EXPRESSION,
1231 NUM_PREC_VALUES = PREC_PM_EXPRESSION
1234 /* A mapping from a token type to a corresponding tree node type, with a
1235 precedence value. */
1237 typedef struct cp_parser_binary_operations_map_node
1239 /* The token type. */
1240 enum cpp_ttype token_type;
1241 /* The corresponding tree code. */
1242 enum tree_code tree_type;
1243 /* The precedence of this operator. */
1244 enum cp_parser_prec prec;
1245 } cp_parser_binary_operations_map_node;
1247 /* The status of a tentative parse. */
1249 typedef enum cp_parser_status_kind
1251 /* No errors have occurred. */
1252 CP_PARSER_STATUS_KIND_NO_ERROR,
1253 /* An error has occurred. */
1254 CP_PARSER_STATUS_KIND_ERROR,
1255 /* We are committed to this tentative parse, whether or not an error
1257 CP_PARSER_STATUS_KIND_COMMITTED
1258 } cp_parser_status_kind;
1260 typedef struct cp_parser_expression_stack_entry
1262 /* Left hand side of the binary operation we are currently
1265 /* Original tree code for left hand side, if it was a binary
1266 expression itself (used for -Wparentheses). */
1267 enum tree_code lhs_type;
1268 /* Tree code for the binary operation we are parsing. */
1269 enum tree_code tree_type;
1270 /* Precedence of the binary operation we are parsing. */
1272 } cp_parser_expression_stack_entry;
1274 /* The stack for storing partial expressions. We only need NUM_PREC_VALUES
1275 entries because precedence levels on the stack are monotonically
1277 typedef struct cp_parser_expression_stack_entry
1278 cp_parser_expression_stack[NUM_PREC_VALUES];
1280 /* Context that is saved and restored when parsing tentatively. */
1281 typedef struct cp_parser_context GTY (())
1283 /* If this is a tentative parsing context, the status of the
1285 enum cp_parser_status_kind status;
1286 /* If non-NULL, we have just seen a `x->' or `x.' expression. Names
1287 that are looked up in this context must be looked up both in the
1288 scope given by OBJECT_TYPE (the type of `x' or `*x') and also in
1289 the context of the containing expression. */
1292 /* The next parsing context in the stack. */
1293 struct cp_parser_context *next;
1294 } cp_parser_context;
1298 /* Constructors and destructors. */
1300 static cp_parser_context *cp_parser_context_new
1301 (cp_parser_context *);
1303 /* Class variables. */
1305 static GTY((deletable)) cp_parser_context* cp_parser_context_free_list;
1307 /* The operator-precedence table used by cp_parser_binary_expression.
1308 Transformed into an associative array (binops_by_token) by
1311 static const cp_parser_binary_operations_map_node binops[] = {
1312 { CPP_DEREF_STAR, MEMBER_REF, PREC_PM_EXPRESSION },
1313 { CPP_DOT_STAR, DOTSTAR_EXPR, PREC_PM_EXPRESSION },
1315 { CPP_MULT, MULT_EXPR, PREC_MULTIPLICATIVE_EXPRESSION },
1316 { CPP_DIV, TRUNC_DIV_EXPR, PREC_MULTIPLICATIVE_EXPRESSION },
1317 { CPP_MOD, TRUNC_MOD_EXPR, PREC_MULTIPLICATIVE_EXPRESSION },
1319 { CPP_PLUS, PLUS_EXPR, PREC_ADDITIVE_EXPRESSION },
1320 { CPP_MINUS, MINUS_EXPR, PREC_ADDITIVE_EXPRESSION },
1322 { CPP_LSHIFT, LSHIFT_EXPR, PREC_SHIFT_EXPRESSION },
1323 { CPP_RSHIFT, RSHIFT_EXPR, PREC_SHIFT_EXPRESSION },
1325 { CPP_LESS, LT_EXPR, PREC_RELATIONAL_EXPRESSION },
1326 { CPP_GREATER, GT_EXPR, PREC_RELATIONAL_EXPRESSION },
1327 { CPP_LESS_EQ, LE_EXPR, PREC_RELATIONAL_EXPRESSION },
1328 { CPP_GREATER_EQ, GE_EXPR, PREC_RELATIONAL_EXPRESSION },
1330 { CPP_EQ_EQ, EQ_EXPR, PREC_EQUALITY_EXPRESSION },
1331 { CPP_NOT_EQ, NE_EXPR, PREC_EQUALITY_EXPRESSION },
1333 { CPP_AND, BIT_AND_EXPR, PREC_AND_EXPRESSION },
1335 { CPP_XOR, BIT_XOR_EXPR, PREC_EXCLUSIVE_OR_EXPRESSION },
1337 { CPP_OR, BIT_IOR_EXPR, PREC_INCLUSIVE_OR_EXPRESSION },
1339 { CPP_AND_AND, TRUTH_ANDIF_EXPR, PREC_LOGICAL_AND_EXPRESSION },
1341 { CPP_OR_OR, TRUTH_ORIF_EXPR, PREC_LOGICAL_OR_EXPRESSION }
1344 /* The same as binops, but initialized by cp_parser_new so that
1345 binops_by_token[N].token_type == N. Used in cp_parser_binary_expression
1347 static cp_parser_binary_operations_map_node binops_by_token[N_CP_TTYPES];
1349 /* Constructors and destructors. */
1351 /* Construct a new context. The context below this one on the stack
1352 is given by NEXT. */
1354 static cp_parser_context *
1355 cp_parser_context_new (cp_parser_context* next)
1357 cp_parser_context *context;
1359 /* Allocate the storage. */
1360 if (cp_parser_context_free_list != NULL)
1362 /* Pull the first entry from the free list. */
1363 context = cp_parser_context_free_list;
1364 cp_parser_context_free_list = context->next;
1365 memset (context, 0, sizeof (*context));
1368 context = GGC_CNEW (cp_parser_context);
1370 /* No errors have occurred yet in this context. */
1371 context->status = CP_PARSER_STATUS_KIND_NO_ERROR;
1372 /* If this is not the bottomost context, copy information that we
1373 need from the previous context. */
1376 /* If, in the NEXT context, we are parsing an `x->' or `x.'
1377 expression, then we are parsing one in this context, too. */
1378 context->object_type = next->object_type;
1379 /* Thread the stack. */
1380 context->next = next;
1386 /* The cp_parser structure represents the C++ parser. */
1388 typedef struct cp_parser GTY(())
1390 /* The lexer from which we are obtaining tokens. */
1393 /* The scope in which names should be looked up. If NULL_TREE, then
1394 we look up names in the scope that is currently open in the
1395 source program. If non-NULL, this is either a TYPE or
1396 NAMESPACE_DECL for the scope in which we should look. It can
1397 also be ERROR_MARK, when we've parsed a bogus scope.
1399 This value is not cleared automatically after a name is looked
1400 up, so we must be careful to clear it before starting a new look
1401 up sequence. (If it is not cleared, then `X::Y' followed by `Z'
1402 will look up `Z' in the scope of `X', rather than the current
1403 scope.) Unfortunately, it is difficult to tell when name lookup
1404 is complete, because we sometimes peek at a token, look it up,
1405 and then decide not to consume it. */
1408 /* OBJECT_SCOPE and QUALIFYING_SCOPE give the scopes in which the
1409 last lookup took place. OBJECT_SCOPE is used if an expression
1410 like "x->y" or "x.y" was used; it gives the type of "*x" or "x",
1411 respectively. QUALIFYING_SCOPE is used for an expression of the
1412 form "X::Y"; it refers to X. */
1414 tree qualifying_scope;
1416 /* A stack of parsing contexts. All but the bottom entry on the
1417 stack will be tentative contexts.
1419 We parse tentatively in order to determine which construct is in
1420 use in some situations. For example, in order to determine
1421 whether a statement is an expression-statement or a
1422 declaration-statement we parse it tentatively as a
1423 declaration-statement. If that fails, we then reparse the same
1424 token stream as an expression-statement. */
1425 cp_parser_context *context;
1427 /* True if we are parsing GNU C++. If this flag is not set, then
1428 GNU extensions are not recognized. */
1429 bool allow_gnu_extensions_p;
1431 /* TRUE if the `>' token should be interpreted as the greater-than
1432 operator. FALSE if it is the end of a template-id or
1433 template-parameter-list. In C++0x mode, this flag also applies to
1434 `>>' tokens, which are viewed as two consecutive `>' tokens when
1435 this flag is FALSE. */
1436 bool greater_than_is_operator_p;
1438 /* TRUE if default arguments are allowed within a parameter list
1439 that starts at this point. FALSE if only a gnu extension makes
1440 them permissible. */
1441 bool default_arg_ok_p;
1443 /* TRUE if we are parsing an integral constant-expression. See
1444 [expr.const] for a precise definition. */
1445 bool integral_constant_expression_p;
1447 /* TRUE if we are parsing an integral constant-expression -- but a
1448 non-constant expression should be permitted as well. This flag
1449 is used when parsing an array bound so that GNU variable-length
1450 arrays are tolerated. */
1451 bool allow_non_integral_constant_expression_p;
1453 /* TRUE if ALLOW_NON_CONSTANT_EXPRESSION_P is TRUE and something has
1454 been seen that makes the expression non-constant. */
1455 bool non_integral_constant_expression_p;
1457 /* TRUE if local variable names and `this' are forbidden in the
1459 bool local_variables_forbidden_p;
1461 /* TRUE if the declaration we are parsing is part of a
1462 linkage-specification of the form `extern string-literal
1464 bool in_unbraced_linkage_specification_p;
1466 /* TRUE if we are presently parsing a declarator, after the
1467 direct-declarator. */
1468 bool in_declarator_p;
1470 /* TRUE if we are presently parsing a template-argument-list. */
1471 bool in_template_argument_list_p;
1473 /* Set to IN_ITERATION_STMT if parsing an iteration-statement,
1474 to IN_OMP_BLOCK if parsing OpenMP structured block and
1475 IN_OMP_FOR if parsing OpenMP loop. If parsing a switch statement,
1476 this is bitwise ORed with IN_SWITCH_STMT, unless parsing an
1477 iteration-statement, OpenMP block or loop within that switch. */
1478 #define IN_SWITCH_STMT 1
1479 #define IN_ITERATION_STMT 2
1480 #define IN_OMP_BLOCK 4
1481 #define IN_OMP_FOR 8
1482 #define IN_IF_STMT 16
1483 unsigned char in_statement;
1485 /* TRUE if we are presently parsing the body of a switch statement.
1486 Note that this doesn't quite overlap with in_statement above.
1487 The difference relates to giving the right sets of error messages:
1488 "case not in switch" vs "break statement used with OpenMP...". */
1489 bool in_switch_statement_p;
1491 /* TRUE if we are parsing a type-id in an expression context. In
1492 such a situation, both "type (expr)" and "type (type)" are valid
1494 bool in_type_id_in_expr_p;
1496 /* TRUE if we are currently in a header file where declarations are
1497 implicitly extern "C". */
1498 bool implicit_extern_c;
1500 /* TRUE if strings in expressions should be translated to the execution
1502 bool translate_strings_p;
1504 /* TRUE if we are presently parsing the body of a function, but not
1506 bool in_function_body;
1508 /* If non-NULL, then we are parsing a construct where new type
1509 definitions are not permitted. The string stored here will be
1510 issued as an error message if a type is defined. */
1511 const char *type_definition_forbidden_message;
1513 /* A list of lists. The outer list is a stack, used for member
1514 functions of local classes. At each level there are two sub-list,
1515 one on TREE_VALUE and one on TREE_PURPOSE. Each of those
1516 sub-lists has a FUNCTION_DECL or TEMPLATE_DECL on their
1517 TREE_VALUE's. The functions are chained in reverse declaration
1520 The TREE_PURPOSE sublist contains those functions with default
1521 arguments that need post processing, and the TREE_VALUE sublist
1522 contains those functions with definitions that need post
1525 These lists can only be processed once the outermost class being
1526 defined is complete. */
1527 tree unparsed_functions_queues;
1529 /* The number of classes whose definitions are currently in
1531 unsigned num_classes_being_defined;
1533 /* The number of template parameter lists that apply directly to the
1534 current declaration. */
1535 unsigned num_template_parameter_lists;
1540 /* Constructors and destructors. */
1542 static cp_parser *cp_parser_new
1545 /* Routines to parse various constructs.
1547 Those that return `tree' will return the error_mark_node (rather
1548 than NULL_TREE) if a parse error occurs, unless otherwise noted.
1549 Sometimes, they will return an ordinary node if error-recovery was
1550 attempted, even though a parse error occurred. So, to check
1551 whether or not a parse error occurred, you should always use
1552 cp_parser_error_occurred. If the construct is optional (indicated
1553 either by an `_opt' in the name of the function that does the
1554 parsing or via a FLAGS parameter), then NULL_TREE is returned if
1555 the construct is not present. */
1557 /* Lexical conventions [gram.lex] */
1559 static tree cp_parser_identifier
1561 static tree cp_parser_string_literal
1562 (cp_parser *, bool, bool);
1564 /* Basic concepts [gram.basic] */
1566 static bool cp_parser_translation_unit
1569 /* Expressions [gram.expr] */
1571 static tree cp_parser_primary_expression
1572 (cp_parser *, bool, bool, bool, cp_id_kind *);
1573 static tree cp_parser_id_expression
1574 (cp_parser *, bool, bool, bool *, bool, bool);
1575 static tree cp_parser_unqualified_id
1576 (cp_parser *, bool, bool, bool, bool);
1577 static tree cp_parser_nested_name_specifier_opt
1578 (cp_parser *, bool, bool, bool, bool);
1579 static tree cp_parser_nested_name_specifier
1580 (cp_parser *, bool, bool, bool, bool);
1581 static tree cp_parser_class_or_namespace_name
1582 (cp_parser *, bool, bool, bool, bool, bool);
1583 static tree cp_parser_postfix_expression
1584 (cp_parser *, bool, bool, bool);
1585 static tree cp_parser_postfix_open_square_expression
1586 (cp_parser *, tree, bool);
1587 static tree cp_parser_postfix_dot_deref_expression
1588 (cp_parser *, enum cpp_ttype, tree, bool, cp_id_kind *);
1589 static tree cp_parser_parenthesized_expression_list
1590 (cp_parser *, bool, bool, bool, bool *);
1591 static void cp_parser_pseudo_destructor_name
1592 (cp_parser *, tree *, tree *);
1593 static tree cp_parser_unary_expression
1594 (cp_parser *, bool, bool);
1595 static enum tree_code cp_parser_unary_operator
1597 static tree cp_parser_new_expression
1599 static tree cp_parser_new_placement
1601 static tree cp_parser_new_type_id
1602 (cp_parser *, tree *);
1603 static cp_declarator *cp_parser_new_declarator_opt
1605 static cp_declarator *cp_parser_direct_new_declarator
1607 static tree cp_parser_new_initializer
1609 static tree cp_parser_delete_expression
1611 static tree cp_parser_cast_expression
1612 (cp_parser *, bool, bool);
1613 static tree cp_parser_binary_expression
1614 (cp_parser *, bool, enum cp_parser_prec);
1615 static tree cp_parser_question_colon_clause
1616 (cp_parser *, tree);
1617 static tree cp_parser_assignment_expression
1618 (cp_parser *, bool);
1619 static enum tree_code cp_parser_assignment_operator_opt
1621 static tree cp_parser_expression
1622 (cp_parser *, bool);
1623 static tree cp_parser_constant_expression
1624 (cp_parser *, bool, bool *);
1625 static tree cp_parser_builtin_offsetof
1628 /* Statements [gram.stmt.stmt] */
1630 static void cp_parser_statement
1631 (cp_parser *, tree, bool, bool *);
1632 static void cp_parser_label_for_labeled_statement
1634 static tree cp_parser_expression_statement
1635 (cp_parser *, tree);
1636 static tree cp_parser_compound_statement
1637 (cp_parser *, tree, bool);
1638 static void cp_parser_statement_seq_opt
1639 (cp_parser *, tree);
1640 static tree cp_parser_selection_statement
1641 (cp_parser *, bool *);
1642 static tree cp_parser_condition
1644 static tree cp_parser_iteration_statement
1646 static void cp_parser_for_init_statement
1648 static tree cp_parser_jump_statement
1650 static void cp_parser_declaration_statement
1653 static tree cp_parser_implicitly_scoped_statement
1654 (cp_parser *, bool *);
1655 static void cp_parser_already_scoped_statement
1658 /* Declarations [gram.dcl.dcl] */
1660 static void cp_parser_declaration_seq_opt
1662 static void cp_parser_declaration
1664 static void cp_parser_block_declaration
1665 (cp_parser *, bool);
1666 static void cp_parser_simple_declaration
1667 (cp_parser *, bool);
1668 static void cp_parser_decl_specifier_seq
1669 (cp_parser *, cp_parser_flags, cp_decl_specifier_seq *, int *);
1670 static tree cp_parser_storage_class_specifier_opt
1672 static tree cp_parser_function_specifier_opt
1673 (cp_parser *, cp_decl_specifier_seq *);
1674 static tree cp_parser_type_specifier
1675 (cp_parser *, cp_parser_flags, cp_decl_specifier_seq *, bool,
1677 static tree cp_parser_simple_type_specifier
1678 (cp_parser *, cp_decl_specifier_seq *, cp_parser_flags);
1679 static tree cp_parser_type_name
1681 static tree cp_parser_nonclass_name
1682 (cp_parser* parser);
1683 static tree cp_parser_elaborated_type_specifier
1684 (cp_parser *, bool, bool);
1685 static tree cp_parser_enum_specifier
1687 static void cp_parser_enumerator_list
1688 (cp_parser *, tree);
1689 static void cp_parser_enumerator_definition
1690 (cp_parser *, tree);
1691 static tree cp_parser_namespace_name
1693 static void cp_parser_namespace_definition
1695 static void cp_parser_namespace_body
1697 static tree cp_parser_qualified_namespace_specifier
1699 static void cp_parser_namespace_alias_definition
1701 static bool cp_parser_using_declaration
1702 (cp_parser *, bool);
1703 static void cp_parser_using_directive
1705 static void cp_parser_asm_definition
1707 static void cp_parser_linkage_specification
1709 static void cp_parser_static_assert
1710 (cp_parser *, bool);
1711 static tree cp_parser_decltype
1714 /* Declarators [gram.dcl.decl] */
1716 static tree cp_parser_init_declarator
1717 (cp_parser *, cp_decl_specifier_seq *, VEC (deferred_access_check,gc)*, bool, bool, int, bool *);
1718 static cp_declarator *cp_parser_declarator
1719 (cp_parser *, cp_parser_declarator_kind, int *, bool *, bool);
1720 static cp_declarator *cp_parser_direct_declarator
1721 (cp_parser *, cp_parser_declarator_kind, int *, bool);
1722 static enum tree_code cp_parser_ptr_operator
1723 (cp_parser *, tree *, cp_cv_quals *);
1724 static cp_cv_quals cp_parser_cv_qualifier_seq_opt
1726 static tree cp_parser_declarator_id
1727 (cp_parser *, bool);
1728 static tree cp_parser_type_id
1730 static void cp_parser_type_specifier_seq
1731 (cp_parser *, bool, cp_decl_specifier_seq *);
1732 static cp_parameter_declarator *cp_parser_parameter_declaration_clause
1734 static cp_parameter_declarator *cp_parser_parameter_declaration_list
1735 (cp_parser *, bool *);
1736 static cp_parameter_declarator *cp_parser_parameter_declaration
1737 (cp_parser *, bool, bool *);
1738 static tree cp_parser_default_argument
1739 (cp_parser *, bool);
1740 static void cp_parser_function_body
1742 static tree cp_parser_initializer
1743 (cp_parser *, bool *, bool *);
1744 static tree cp_parser_initializer_clause
1745 (cp_parser *, bool *);
1746 static VEC(constructor_elt,gc) *cp_parser_initializer_list
1747 (cp_parser *, bool *);
1749 static bool cp_parser_ctor_initializer_opt_and_function_body
1752 /* Classes [gram.class] */
1754 static tree cp_parser_class_name
1755 (cp_parser *, bool, bool, enum tag_types, bool, bool, bool);
1756 static tree cp_parser_class_specifier
1758 static tree cp_parser_class_head
1759 (cp_parser *, bool *, tree *, tree *);
1760 static enum tag_types cp_parser_class_key
1762 static void cp_parser_member_specification_opt
1764 static void cp_parser_member_declaration
1766 static tree cp_parser_pure_specifier
1768 static tree cp_parser_constant_initializer
1771 /* Derived classes [gram.class.derived] */
1773 static tree cp_parser_base_clause
1775 static tree cp_parser_base_specifier
1778 /* Special member functions [gram.special] */
1780 static tree cp_parser_conversion_function_id
1782 static tree cp_parser_conversion_type_id
1784 static cp_declarator *cp_parser_conversion_declarator_opt
1786 static bool cp_parser_ctor_initializer_opt
1788 static void cp_parser_mem_initializer_list
1790 static tree cp_parser_mem_initializer
1792 static tree cp_parser_mem_initializer_id
1795 /* Overloading [gram.over] */
1797 static tree cp_parser_operator_function_id
1799 static tree cp_parser_operator
1802 /* Templates [gram.temp] */
1804 static void cp_parser_template_declaration
1805 (cp_parser *, bool);
1806 static tree cp_parser_template_parameter_list
1808 static tree cp_parser_template_parameter
1809 (cp_parser *, bool *, bool *);
1810 static tree cp_parser_type_parameter
1811 (cp_parser *, bool *);
1812 static tree cp_parser_template_id
1813 (cp_parser *, bool, bool, bool);
1814 static tree cp_parser_template_name
1815 (cp_parser *, bool, bool, bool, bool *);
1816 static tree cp_parser_template_argument_list
1818 static tree cp_parser_template_argument
1820 static void cp_parser_explicit_instantiation
1822 static void cp_parser_explicit_specialization
1825 /* Exception handling [gram.exception] */
1827 static tree cp_parser_try_block
1829 static bool cp_parser_function_try_block
1831 static void cp_parser_handler_seq
1833 static void cp_parser_handler
1835 static tree cp_parser_exception_declaration
1837 static tree cp_parser_throw_expression
1839 static tree cp_parser_exception_specification_opt
1841 static tree cp_parser_type_id_list
1844 /* GNU Extensions */
1846 static tree cp_parser_asm_specification_opt
1848 static tree cp_parser_asm_operand_list
1850 static tree cp_parser_asm_clobber_list
1852 static tree cp_parser_attributes_opt
1854 static tree cp_parser_attribute_list
1856 static bool cp_parser_extension_opt
1857 (cp_parser *, int *);
1858 static void cp_parser_label_declaration
1861 enum pragma_context { pragma_external, pragma_stmt, pragma_compound };
1862 static bool cp_parser_pragma
1863 (cp_parser *, enum pragma_context);
1865 /* Objective-C++ Productions */
1867 static tree cp_parser_objc_message_receiver
1869 static tree cp_parser_objc_message_args
1871 static tree cp_parser_objc_message_expression
1873 static tree cp_parser_objc_encode_expression
1875 static tree cp_parser_objc_defs_expression
1877 static tree cp_parser_objc_protocol_expression
1879 static tree cp_parser_objc_selector_expression
1881 static tree cp_parser_objc_expression
1883 static bool cp_parser_objc_selector_p
1885 static tree cp_parser_objc_selector
1887 static tree cp_parser_objc_protocol_refs_opt
1889 static void cp_parser_objc_declaration
1891 static tree cp_parser_objc_statement
1894 /* Utility Routines */
1896 static tree cp_parser_lookup_name
1897 (cp_parser *, tree, enum tag_types, bool, bool, bool, tree *);
1898 static tree cp_parser_lookup_name_simple
1899 (cp_parser *, tree);
1900 static tree cp_parser_maybe_treat_template_as_class
1902 static bool cp_parser_check_declarator_template_parameters
1903 (cp_parser *, cp_declarator *);
1904 static bool cp_parser_check_template_parameters
1905 (cp_parser *, unsigned);
1906 static tree cp_parser_simple_cast_expression
1908 static tree cp_parser_global_scope_opt
1909 (cp_parser *, bool);
1910 static bool cp_parser_constructor_declarator_p
1911 (cp_parser *, bool);
1912 static tree cp_parser_function_definition_from_specifiers_and_declarator
1913 (cp_parser *, cp_decl_specifier_seq *, tree, const cp_declarator *);
1914 static tree cp_parser_function_definition_after_declarator
1915 (cp_parser *, bool);
1916 static void cp_parser_template_declaration_after_export
1917 (cp_parser *, bool);
1918 static void cp_parser_perform_template_parameter_access_checks
1919 (VEC (deferred_access_check,gc)*);
1920 static tree cp_parser_single_declaration
1921 (cp_parser *, VEC (deferred_access_check,gc)*, bool, bool, bool *);
1922 static tree cp_parser_functional_cast
1923 (cp_parser *, tree);
1924 static tree cp_parser_save_member_function_body
1925 (cp_parser *, cp_decl_specifier_seq *, cp_declarator *, tree);
1926 static tree cp_parser_enclosed_template_argument_list
1928 static void cp_parser_save_default_args
1929 (cp_parser *, tree);
1930 static void cp_parser_late_parsing_for_member
1931 (cp_parser *, tree);
1932 static void cp_parser_late_parsing_default_args
1933 (cp_parser *, tree);
1934 static tree cp_parser_sizeof_operand
1935 (cp_parser *, enum rid);
1936 static tree cp_parser_trait_expr
1937 (cp_parser *, enum rid);
1938 static bool cp_parser_declares_only_class_p
1940 static void cp_parser_set_storage_class
1941 (cp_parser *, cp_decl_specifier_seq *, enum rid);
1942 static void cp_parser_set_decl_spec_type
1943 (cp_decl_specifier_seq *, tree, bool);
1944 static bool cp_parser_friend_p
1945 (const cp_decl_specifier_seq *);
1946 static cp_token *cp_parser_require
1947 (cp_parser *, enum cpp_ttype, const char *);
1948 static cp_token *cp_parser_require_keyword
1949 (cp_parser *, enum rid, const char *);
1950 static bool cp_parser_token_starts_function_definition_p
1952 static bool cp_parser_next_token_starts_class_definition_p
1954 static bool cp_parser_next_token_ends_template_argument_p
1956 static bool cp_parser_nth_token_starts_template_argument_list_p
1957 (cp_parser *, size_t);
1958 static enum tag_types cp_parser_token_is_class_key
1960 static void cp_parser_check_class_key
1961 (enum tag_types, tree type);
1962 static void cp_parser_check_access_in_redeclaration
1964 static bool cp_parser_optional_template_keyword
1966 static void cp_parser_pre_parsed_nested_name_specifier
1968 static void cp_parser_cache_group
1969 (cp_parser *, enum cpp_ttype, unsigned);
1970 static void cp_parser_parse_tentatively
1972 static void cp_parser_commit_to_tentative_parse
1974 static void cp_parser_abort_tentative_parse
1976 static bool cp_parser_parse_definitely
1978 static inline bool cp_parser_parsing_tentatively
1980 static bool cp_parser_uncommitted_to_tentative_parse_p
1982 static void cp_parser_error
1983 (cp_parser *, const char *);
1984 static void cp_parser_name_lookup_error
1985 (cp_parser *, tree, tree, const char *);
1986 static bool cp_parser_simulate_error
1988 static bool cp_parser_check_type_definition
1990 static void cp_parser_check_for_definition_in_return_type
1991 (cp_declarator *, tree);
1992 static void cp_parser_check_for_invalid_template_id
1993 (cp_parser *, tree);
1994 static bool cp_parser_non_integral_constant_expression
1995 (cp_parser *, const char *);
1996 static void cp_parser_diagnose_invalid_type_name
1997 (cp_parser *, tree, tree);
1998 static bool cp_parser_parse_and_diagnose_invalid_type_name
2000 static int cp_parser_skip_to_closing_parenthesis
2001 (cp_parser *, bool, bool, bool);
2002 static void cp_parser_skip_to_end_of_statement
2004 static void cp_parser_consume_semicolon_at_end_of_statement
2006 static void cp_parser_skip_to_end_of_block_or_statement
2008 static bool cp_parser_skip_to_closing_brace
2010 static void cp_parser_skip_to_end_of_template_parameter_list
2012 static void cp_parser_skip_to_pragma_eol
2013 (cp_parser*, cp_token *);
2014 static bool cp_parser_error_occurred
2016 static bool cp_parser_allow_gnu_extensions_p
2018 static bool cp_parser_is_string_literal
2020 static bool cp_parser_is_keyword
2021 (cp_token *, enum rid);
2022 static tree cp_parser_make_typename_type
2023 (cp_parser *, tree, tree);
2024 static cp_declarator * cp_parser_make_indirect_declarator
2025 (enum tree_code, tree, cp_cv_quals, cp_declarator *);
2027 /* Returns nonzero if we are parsing tentatively. */
2030 cp_parser_parsing_tentatively (cp_parser* parser)
2032 return parser->context->next != NULL;
2035 /* Returns nonzero if TOKEN is a string literal. */
2038 cp_parser_is_string_literal (cp_token* token)
2040 return (token->type == CPP_STRING ||
2041 token->type == CPP_STRING16 ||
2042 token->type == CPP_STRING32 ||
2043 token->type == CPP_WSTRING);
2046 /* Returns nonzero if TOKEN is the indicated KEYWORD. */
2049 cp_parser_is_keyword (cp_token* token, enum rid keyword)
2051 return token->keyword == keyword;
2054 /* If not parsing tentatively, issue a diagnostic of the form
2055 FILE:LINE: MESSAGE before TOKEN
2056 where TOKEN is the next token in the input stream. MESSAGE
2057 (specified by the caller) is usually of the form "expected
2061 cp_parser_error (cp_parser* parser, const char* message)
2063 if (!cp_parser_simulate_error (parser))
2065 cp_token *token = cp_lexer_peek_token (parser->lexer);
2066 /* This diagnostic makes more sense if it is tagged to the line
2067 of the token we just peeked at. */
2068 cp_lexer_set_source_position_from_token (token);
2070 if (token->type == CPP_PRAGMA)
2072 error ("%<#pragma%> is not allowed here");
2073 cp_parser_skip_to_pragma_eol (parser, token);
2077 c_parse_error (message,
2078 /* Because c_parser_error does not understand
2079 CPP_KEYWORD, keywords are treated like
2081 (token->type == CPP_KEYWORD ? CPP_NAME : token->type),
2086 /* Issue an error about name-lookup failing. NAME is the
2087 IDENTIFIER_NODE DECL is the result of
2088 the lookup (as returned from cp_parser_lookup_name). DESIRED is
2089 the thing that we hoped to find. */
2092 cp_parser_name_lookup_error (cp_parser* parser,
2095 const char* desired)
2097 /* If name lookup completely failed, tell the user that NAME was not
2099 if (decl == error_mark_node)
2101 if (parser->scope && parser->scope != global_namespace)
2102 error ("%<%E::%E%> has not been declared",
2103 parser->scope, name);
2104 else if (parser->scope == global_namespace)
2105 error ("%<::%E%> has not been declared", name);
2106 else if (parser->object_scope
2107 && !CLASS_TYPE_P (parser->object_scope))
2108 error ("request for member %qE in non-class type %qT",
2109 name, parser->object_scope);
2110 else if (parser->object_scope)
2111 error ("%<%T::%E%> has not been declared",
2112 parser->object_scope, name);
2114 error ("%qE has not been declared", name);
2116 else if (parser->scope && parser->scope != global_namespace)
2117 error ("%<%E::%E%> %s", parser->scope, name, desired);
2118 else if (parser->scope == global_namespace)
2119 error ("%<::%E%> %s", name, desired);
2121 error ("%qE %s", name, desired);
2124 /* If we are parsing tentatively, remember that an error has occurred
2125 during this tentative parse. Returns true if the error was
2126 simulated; false if a message should be issued by the caller. */
2129 cp_parser_simulate_error (cp_parser* parser)
2131 if (cp_parser_uncommitted_to_tentative_parse_p (parser))
2133 parser->context->status = CP_PARSER_STATUS_KIND_ERROR;
2139 /* Check for repeated decl-specifiers. */
2142 cp_parser_check_decl_spec (cp_decl_specifier_seq *decl_specs)
2146 for (ds = ds_first; ds != ds_last; ++ds)
2148 unsigned count = decl_specs->specs[(int)ds];
2151 /* The "long" specifier is a special case because of "long long". */
2155 error ("%<long long long%> is too long for GCC");
2156 else if (pedantic && !in_system_header && warn_long_long
2157 && cxx_dialect == cxx98)
2158 pedwarn ("ISO C++ 1998 does not support %<long long%>");
2162 static const char *const decl_spec_names[] = {
2178 error ("duplicate %qs", decl_spec_names[(int)ds]);
2183 /* This function is called when a type is defined. If type
2184 definitions are forbidden at this point, an error message is
2188 cp_parser_check_type_definition (cp_parser* parser)
2190 /* If types are forbidden here, issue a message. */
2191 if (parser->type_definition_forbidden_message)
2193 /* Don't use `%s' to print the string, because quotations (`%<', `%>')
2194 in the message need to be interpreted. */
2195 error (parser->type_definition_forbidden_message);
2201 /* This function is called when the DECLARATOR is processed. The TYPE
2202 was a type defined in the decl-specifiers. If it is invalid to
2203 define a type in the decl-specifiers for DECLARATOR, an error is
2207 cp_parser_check_for_definition_in_return_type (cp_declarator *declarator,
2210 /* [dcl.fct] forbids type definitions in return types.
2211 Unfortunately, it's not easy to know whether or not we are
2212 processing a return type until after the fact. */
2214 && (declarator->kind == cdk_pointer
2215 || declarator->kind == cdk_reference
2216 || declarator->kind == cdk_ptrmem))
2217 declarator = declarator->declarator;
2219 && declarator->kind == cdk_function)
2221 error ("new types may not be defined in a return type");
2222 inform ("(perhaps a semicolon is missing after the definition of %qT)",
2227 /* A type-specifier (TYPE) has been parsed which cannot be followed by
2228 "<" in any valid C++ program. If the next token is indeed "<",
2229 issue a message warning the user about what appears to be an
2230 invalid attempt to form a template-id. */
2233 cp_parser_check_for_invalid_template_id (cp_parser* parser,
2236 cp_token_position start = 0;
2238 if (cp_lexer_next_token_is (parser->lexer, CPP_LESS))
2241 error ("%qT is not a template", type);
2242 else if (TREE_CODE (type) == IDENTIFIER_NODE)
2243 error ("%qE is not a template", type);
2245 error ("invalid template-id");
2246 /* Remember the location of the invalid "<". */
2247 if (cp_parser_uncommitted_to_tentative_parse_p (parser))
2248 start = cp_lexer_token_position (parser->lexer, true);
2249 /* Consume the "<". */
2250 cp_lexer_consume_token (parser->lexer);
2251 /* Parse the template arguments. */
2252 cp_parser_enclosed_template_argument_list (parser);
2253 /* Permanently remove the invalid template arguments so that
2254 this error message is not issued again. */
2256 cp_lexer_purge_tokens_after (parser->lexer, start);
2260 /* If parsing an integral constant-expression, issue an error message
2261 about the fact that THING appeared and return true. Otherwise,
2262 return false. In either case, set
2263 PARSER->NON_INTEGRAL_CONSTANT_EXPRESSION_P. */
2266 cp_parser_non_integral_constant_expression (cp_parser *parser,
2269 parser->non_integral_constant_expression_p = true;
2270 if (parser->integral_constant_expression_p)
2272 if (!parser->allow_non_integral_constant_expression_p)
2274 /* Don't use `%s' to print THING, because quotations (`%<', `%>')
2275 in the message need to be interpreted. */
2276 char *message = concat (thing,
2277 " cannot appear in a constant-expression",
2287 /* Emit a diagnostic for an invalid type name. SCOPE is the
2288 qualifying scope (or NULL, if none) for ID. This function commits
2289 to the current active tentative parse, if any. (Otherwise, the
2290 problematic construct might be encountered again later, resulting
2291 in duplicate error messages.) */
2294 cp_parser_diagnose_invalid_type_name (cp_parser *parser, tree scope, tree id)
2296 tree decl, old_scope;
2297 /* Try to lookup the identifier. */
2298 old_scope = parser->scope;
2299 parser->scope = scope;
2300 decl = cp_parser_lookup_name_simple (parser, id);
2301 parser->scope = old_scope;
2302 /* If the lookup found a template-name, it means that the user forgot
2303 to specify an argument list. Emit a useful error message. */
2304 if (TREE_CODE (decl) == TEMPLATE_DECL)
2305 error ("invalid use of template-name %qE without an argument list", decl);
2306 else if (TREE_CODE (id) == BIT_NOT_EXPR)
2307 error ("invalid use of destructor %qD as a type", id);
2308 else if (TREE_CODE (decl) == TYPE_DECL)
2309 /* Something like 'unsigned A a;' */
2310 error ("invalid combination of multiple type-specifiers");
2311 else if (!parser->scope)
2313 /* Issue an error message. */
2314 error ("%qE does not name a type", id);
2315 /* If we're in a template class, it's possible that the user was
2316 referring to a type from a base class. For example:
2318 template <typename T> struct A { typedef T X; };
2319 template <typename T> struct B : public A<T> { X x; };
2321 The user should have said "typename A<T>::X". */
2322 if (processing_template_decl && current_class_type
2323 && TYPE_BINFO (current_class_type))
2327 for (b = TREE_CHAIN (TYPE_BINFO (current_class_type));
2331 tree base_type = BINFO_TYPE (b);
2332 if (CLASS_TYPE_P (base_type)
2333 && dependent_type_p (base_type))
2336 /* Go from a particular instantiation of the
2337 template (which will have an empty TYPE_FIELDs),
2338 to the main version. */
2339 base_type = CLASSTYPE_PRIMARY_TEMPLATE_TYPE (base_type);
2340 for (field = TYPE_FIELDS (base_type);
2342 field = TREE_CHAIN (field))
2343 if (TREE_CODE (field) == TYPE_DECL
2344 && DECL_NAME (field) == id)
2346 inform ("(perhaps %<typename %T::%E%> was intended)",
2347 BINFO_TYPE (b), id);
2356 /* Here we diagnose qualified-ids where the scope is actually correct,
2357 but the identifier does not resolve to a valid type name. */
2358 else if (parser->scope != error_mark_node)
2360 if (TREE_CODE (parser->scope) == NAMESPACE_DECL)
2361 error ("%qE in namespace %qE does not name a type",
2363 else if (TYPE_P (parser->scope))
2364 error ("%qE in class %qT does not name a type", id, parser->scope);
2368 cp_parser_commit_to_tentative_parse (parser);
2371 /* Check for a common situation where a type-name should be present,
2372 but is not, and issue a sensible error message. Returns true if an
2373 invalid type-name was detected.
2375 The situation handled by this function are variable declarations of the
2376 form `ID a', where `ID' is an id-expression and `a' is a plain identifier.
2377 Usually, `ID' should name a type, but if we got here it means that it
2378 does not. We try to emit the best possible error message depending on
2379 how exactly the id-expression looks like. */
2382 cp_parser_parse_and_diagnose_invalid_type_name (cp_parser *parser)
2386 cp_parser_parse_tentatively (parser);
2387 id = cp_parser_id_expression (parser,
2388 /*template_keyword_p=*/false,
2389 /*check_dependency_p=*/true,
2390 /*template_p=*/NULL,
2391 /*declarator_p=*/true,
2392 /*optional_p=*/false);
2393 /* After the id-expression, there should be a plain identifier,
2394 otherwise this is not a simple variable declaration. Also, if
2395 the scope is dependent, we cannot do much. */
2396 if (!cp_lexer_next_token_is (parser->lexer, CPP_NAME)
2397 || (parser->scope && TYPE_P (parser->scope)
2398 && dependent_type_p (parser->scope))
2399 || TREE_CODE (id) == TYPE_DECL)
2401 cp_parser_abort_tentative_parse (parser);
2404 if (!cp_parser_parse_definitely (parser))
2407 /* Emit a diagnostic for the invalid type. */
2408 cp_parser_diagnose_invalid_type_name (parser, parser->scope, id);
2409 /* Skip to the end of the declaration; there's no point in
2410 trying to process it. */
2411 cp_parser_skip_to_end_of_block_or_statement (parser);
2415 /* Consume tokens up to, and including, the next non-nested closing `)'.
2416 Returns 1 iff we found a closing `)'. RECOVERING is true, if we
2417 are doing error recovery. Returns -1 if OR_COMMA is true and we
2418 found an unnested comma. */
2421 cp_parser_skip_to_closing_parenthesis (cp_parser *parser,
2426 unsigned paren_depth = 0;
2427 unsigned brace_depth = 0;
2429 if (recovering && !or_comma
2430 && cp_parser_uncommitted_to_tentative_parse_p (parser))
2435 cp_token * token = cp_lexer_peek_token (parser->lexer);
2437 switch (token->type)
2440 case CPP_PRAGMA_EOL:
2441 /* If we've run out of tokens, then there is no closing `)'. */
2445 /* This matches the processing in skip_to_end_of_statement. */
2450 case CPP_OPEN_BRACE:
2453 case CPP_CLOSE_BRACE:
2459 if (recovering && or_comma && !brace_depth && !paren_depth)
2463 case CPP_OPEN_PAREN:
2468 case CPP_CLOSE_PAREN:
2469 if (!brace_depth && !paren_depth--)
2472 cp_lexer_consume_token (parser->lexer);
2481 /* Consume the token. */
2482 cp_lexer_consume_token (parser->lexer);
2486 /* Consume tokens until we reach the end of the current statement.
2487 Normally, that will be just before consuming a `;'. However, if a
2488 non-nested `}' comes first, then we stop before consuming that. */
2491 cp_parser_skip_to_end_of_statement (cp_parser* parser)
2493 unsigned nesting_depth = 0;
2497 cp_token *token = cp_lexer_peek_token (parser->lexer);
2499 switch (token->type)
2502 case CPP_PRAGMA_EOL:
2503 /* If we've run out of tokens, stop. */
2507 /* If the next token is a `;', we have reached the end of the
2513 case CPP_CLOSE_BRACE:
2514 /* If this is a non-nested '}', stop before consuming it.
2515 That way, when confronted with something like:
2519 we stop before consuming the closing '}', even though we
2520 have not yet reached a `;'. */
2521 if (nesting_depth == 0)
2524 /* If it is the closing '}' for a block that we have
2525 scanned, stop -- but only after consuming the token.
2531 we will stop after the body of the erroneously declared
2532 function, but before consuming the following `typedef'
2534 if (--nesting_depth == 0)
2536 cp_lexer_consume_token (parser->lexer);
2540 case CPP_OPEN_BRACE:
2548 /* Consume the token. */
2549 cp_lexer_consume_token (parser->lexer);
2553 /* This function is called at the end of a statement or declaration.
2554 If the next token is a semicolon, it is consumed; otherwise, error
2555 recovery is attempted. */
2558 cp_parser_consume_semicolon_at_end_of_statement (cp_parser *parser)
2560 /* Look for the trailing `;'. */
2561 if (!cp_parser_require (parser, CPP_SEMICOLON, "%<;%>"))
2563 /* If there is additional (erroneous) input, skip to the end of
2565 cp_parser_skip_to_end_of_statement (parser);
2566 /* If the next token is now a `;', consume it. */
2567 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
2568 cp_lexer_consume_token (parser->lexer);
2572 /* Skip tokens until we have consumed an entire block, or until we
2573 have consumed a non-nested `;'. */
2576 cp_parser_skip_to_end_of_block_or_statement (cp_parser* parser)
2578 int nesting_depth = 0;
2580 while (nesting_depth >= 0)
2582 cp_token *token = cp_lexer_peek_token (parser->lexer);
2584 switch (token->type)
2587 case CPP_PRAGMA_EOL:
2588 /* If we've run out of tokens, stop. */
2592 /* Stop if this is an unnested ';'. */
2597 case CPP_CLOSE_BRACE:
2598 /* Stop if this is an unnested '}', or closes the outermost
2605 case CPP_OPEN_BRACE:
2614 /* Consume the token. */
2615 cp_lexer_consume_token (parser->lexer);
2619 /* Skip tokens until a non-nested closing curly brace is the next
2620 token, or there are no more tokens. Return true in the first case,
2624 cp_parser_skip_to_closing_brace (cp_parser *parser)
2626 unsigned nesting_depth = 0;
2630 cp_token *token = cp_lexer_peek_token (parser->lexer);
2632 switch (token->type)
2635 case CPP_PRAGMA_EOL:
2636 /* If we've run out of tokens, stop. */
2639 case CPP_CLOSE_BRACE:
2640 /* If the next token is a non-nested `}', then we have reached
2641 the end of the current block. */
2642 if (nesting_depth-- == 0)
2646 case CPP_OPEN_BRACE:
2647 /* If it the next token is a `{', then we are entering a new
2648 block. Consume the entire block. */
2656 /* Consume the token. */
2657 cp_lexer_consume_token (parser->lexer);
2661 /* Consume tokens until we reach the end of the pragma. The PRAGMA_TOK
2662 parameter is the PRAGMA token, allowing us to purge the entire pragma
2666 cp_parser_skip_to_pragma_eol (cp_parser* parser, cp_token *pragma_tok)
2670 parser->lexer->in_pragma = false;
2673 token = cp_lexer_consume_token (parser->lexer);
2674 while (token->type != CPP_PRAGMA_EOL && token->type != CPP_EOF);
2676 /* Ensure that the pragma is not parsed again. */
2677 cp_lexer_purge_tokens_after (parser->lexer, pragma_tok);
2680 /* Require pragma end of line, resyncing with it as necessary. The
2681 arguments are as for cp_parser_skip_to_pragma_eol. */
2684 cp_parser_require_pragma_eol (cp_parser *parser, cp_token *pragma_tok)
2686 parser->lexer->in_pragma = false;
2687 if (!cp_parser_require (parser, CPP_PRAGMA_EOL, "end of line"))
2688 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
2691 /* This is a simple wrapper around make_typename_type. When the id is
2692 an unresolved identifier node, we can provide a superior diagnostic
2693 using cp_parser_diagnose_invalid_type_name. */
2696 cp_parser_make_typename_type (cp_parser *parser, tree scope, tree id)
2699 if (TREE_CODE (id) == IDENTIFIER_NODE)
2701 result = make_typename_type (scope, id, typename_type,
2702 /*complain=*/tf_none);
2703 if (result == error_mark_node)
2704 cp_parser_diagnose_invalid_type_name (parser, scope, id);
2707 return make_typename_type (scope, id, typename_type, tf_error);
2710 /* This is a wrapper around the
2711 make_{pointer,ptrmem,reference}_declarator functions that decides
2712 which one to call based on the CODE and CLASS_TYPE arguments. The
2713 CODE argument should be one of the values returned by
2714 cp_parser_ptr_operator. */
2715 static cp_declarator *
2716 cp_parser_make_indirect_declarator (enum tree_code code, tree class_type,
2717 cp_cv_quals cv_qualifiers,
2718 cp_declarator *target)
2720 if (code == ERROR_MARK)
2721 return cp_error_declarator;
2723 if (code == INDIRECT_REF)
2724 if (class_type == NULL_TREE)
2725 return make_pointer_declarator (cv_qualifiers, target);
2727 return make_ptrmem_declarator (cv_qualifiers, class_type, target);
2728 else if (code == ADDR_EXPR && class_type == NULL_TREE)
2729 return make_reference_declarator (cv_qualifiers, target, false);
2730 else if (code == NON_LVALUE_EXPR && class_type == NULL_TREE)
2731 return make_reference_declarator (cv_qualifiers, target, true);
2735 /* Create a new C++ parser. */
2738 cp_parser_new (void)
2744 /* cp_lexer_new_main is called before calling ggc_alloc because
2745 cp_lexer_new_main might load a PCH file. */
2746 lexer = cp_lexer_new_main ();
2748 /* Initialize the binops_by_token so that we can get the tree
2749 directly from the token. */
2750 for (i = 0; i < sizeof (binops) / sizeof (binops[0]); i++)
2751 binops_by_token[binops[i].token_type] = binops[i];
2753 parser = GGC_CNEW (cp_parser);
2754 parser->lexer = lexer;
2755 parser->context = cp_parser_context_new (NULL);
2757 /* For now, we always accept GNU extensions. */
2758 parser->allow_gnu_extensions_p = 1;
2760 /* The `>' token is a greater-than operator, not the end of a
2762 parser->greater_than_is_operator_p = true;
2764 parser->default_arg_ok_p = true;
2766 /* We are not parsing a constant-expression. */
2767 parser->integral_constant_expression_p = false;
2768 parser->allow_non_integral_constant_expression_p = false;
2769 parser->non_integral_constant_expression_p = false;
2771 /* Local variable names are not forbidden. */
2772 parser->local_variables_forbidden_p = false;
2774 /* We are not processing an `extern "C"' declaration. */
2775 parser->in_unbraced_linkage_specification_p = false;
2777 /* We are not processing a declarator. */
2778 parser->in_declarator_p = false;
2780 /* We are not processing a template-argument-list. */
2781 parser->in_template_argument_list_p = false;
2783 /* We are not in an iteration statement. */
2784 parser->in_statement = 0;
2786 /* We are not in a switch statement. */
2787 parser->in_switch_statement_p = false;
2789 /* We are not parsing a type-id inside an expression. */
2790 parser->in_type_id_in_expr_p = false;
2792 /* Declarations aren't implicitly extern "C". */
2793 parser->implicit_extern_c = false;
2795 /* String literals should be translated to the execution character set. */
2796 parser->translate_strings_p = true;
2798 /* We are not parsing a function body. */
2799 parser->in_function_body = false;
2801 /* The unparsed function queue is empty. */
2802 parser->unparsed_functions_queues = build_tree_list (NULL_TREE, NULL_TREE);
2804 /* There are no classes being defined. */
2805 parser->num_classes_being_defined = 0;
2807 /* No template parameters apply. */
2808 parser->num_template_parameter_lists = 0;
2813 /* Create a cp_lexer structure which will emit the tokens in CACHE
2814 and push it onto the parser's lexer stack. This is used for delayed
2815 parsing of in-class method bodies and default arguments, and should
2816 not be confused with tentative parsing. */
2818 cp_parser_push_lexer_for_tokens (cp_parser *parser, cp_token_cache *cache)
2820 cp_lexer *lexer = cp_lexer_new_from_tokens (cache);
2821 lexer->next = parser->lexer;
2822 parser->lexer = lexer;
2824 /* Move the current source position to that of the first token in the
2826 cp_lexer_set_source_position_from_token (lexer->next_token);
2829 /* Pop the top lexer off the parser stack. This is never used for the
2830 "main" lexer, only for those pushed by cp_parser_push_lexer_for_tokens. */
2832 cp_parser_pop_lexer (cp_parser *parser)
2834 cp_lexer *lexer = parser->lexer;
2835 parser->lexer = lexer->next;
2836 cp_lexer_destroy (lexer);
2838 /* Put the current source position back where it was before this
2839 lexer was pushed. */
2840 cp_lexer_set_source_position_from_token (parser->lexer->next_token);
2843 /* Lexical conventions [gram.lex] */
2845 /* Parse an identifier. Returns an IDENTIFIER_NODE representing the
2849 cp_parser_identifier (cp_parser* parser)
2853 /* Look for the identifier. */
2854 token = cp_parser_require (parser, CPP_NAME, "identifier");
2855 /* Return the value. */
2856 return token ? token->u.value : error_mark_node;
2859 /* Parse a sequence of adjacent string constants. Returns a
2860 TREE_STRING representing the combined, nul-terminated string
2861 constant. If TRANSLATE is true, translate the string to the
2862 execution character set. If WIDE_OK is true, a wide string is
2865 C++98 [lex.string] says that if a narrow string literal token is
2866 adjacent to a wide string literal token, the behavior is undefined.
2867 However, C99 6.4.5p4 says that this results in a wide string literal.
2868 We follow C99 here, for consistency with the C front end.
2870 This code is largely lifted from lex_string() in c-lex.c.
2872 FUTURE: ObjC++ will need to handle @-strings here. */
2874 cp_parser_string_literal (cp_parser *parser, bool translate, bool wide_ok)
2878 struct obstack str_ob;
2879 cpp_string str, istr, *strs;
2881 enum cpp_ttype type;
2883 tok = cp_lexer_peek_token (parser->lexer);
2884 if (!cp_parser_is_string_literal (tok))
2886 cp_parser_error (parser, "expected string-literal");
2887 return error_mark_node;
2892 /* Try to avoid the overhead of creating and destroying an obstack
2893 for the common case of just one string. */
2894 if (!cp_parser_is_string_literal
2895 (cp_lexer_peek_nth_token (parser->lexer, 2)))
2897 cp_lexer_consume_token (parser->lexer);
2899 str.text = (const unsigned char *)TREE_STRING_POINTER (tok->u.value);
2900 str.len = TREE_STRING_LENGTH (tok->u.value);
2907 gcc_obstack_init (&str_ob);
2912 cp_lexer_consume_token (parser->lexer);
2914 str.text = (const unsigned char *)TREE_STRING_POINTER (tok->u.value);
2915 str.len = TREE_STRING_LENGTH (tok->u.value);
2917 if (type != tok->type)
2919 if (type == CPP_STRING)
2921 else if (tok->type != CPP_STRING)
2922 error ("unsupported non-standard concatenation of string literals");
2925 obstack_grow (&str_ob, &str, sizeof (cpp_string));
2927 tok = cp_lexer_peek_token (parser->lexer);
2929 while (cp_parser_is_string_literal (tok));
2931 strs = (cpp_string *) obstack_finish (&str_ob);
2934 if (type != CPP_STRING && !wide_ok)
2936 cp_parser_error (parser, "a wide string is invalid in this context");
2940 if ((translate ? cpp_interpret_string : cpp_interpret_string_notranslate)
2941 (parse_in, strs, count, &istr, type))
2943 value = build_string (istr.len, (const char *)istr.text);
2944 free (CONST_CAST (unsigned char *, istr.text));
2950 TREE_TYPE (value) = char_array_type_node;
2953 TREE_TYPE (value) = char16_array_type_node;
2956 TREE_TYPE (value) = char32_array_type_node;
2959 TREE_TYPE (value) = wchar_array_type_node;
2963 value = fix_string_type (value);
2966 /* cpp_interpret_string has issued an error. */
2967 value = error_mark_node;
2970 obstack_free (&str_ob, 0);
2976 /* Basic concepts [gram.basic] */
2978 /* Parse a translation-unit.
2981 declaration-seq [opt]
2983 Returns TRUE if all went well. */
2986 cp_parser_translation_unit (cp_parser* parser)
2988 /* The address of the first non-permanent object on the declarator
2990 static void *declarator_obstack_base;
2994 /* Create the declarator obstack, if necessary. */
2995 if (!cp_error_declarator)
2997 gcc_obstack_init (&declarator_obstack);
2998 /* Create the error declarator. */
2999 cp_error_declarator = make_declarator (cdk_error);
3000 /* Create the empty parameter list. */
3001 no_parameters = make_parameter_declarator (NULL, NULL, NULL_TREE);
3002 /* Remember where the base of the declarator obstack lies. */
3003 declarator_obstack_base = obstack_next_free (&declarator_obstack);
3006 cp_parser_declaration_seq_opt (parser);
3008 /* If there are no tokens left then all went well. */
3009 if (cp_lexer_next_token_is (parser->lexer, CPP_EOF))
3011 /* Get rid of the token array; we don't need it any more. */
3012 cp_lexer_destroy (parser->lexer);
3013 parser->lexer = NULL;
3015 /* This file might have been a context that's implicitly extern
3016 "C". If so, pop the lang context. (Only relevant for PCH.) */
3017 if (parser->implicit_extern_c)
3019 pop_lang_context ();
3020 parser->implicit_extern_c = false;
3024 finish_translation_unit ();
3030 cp_parser_error (parser, "expected declaration");
3034 /* Make sure the declarator obstack was fully cleaned up. */
3035 gcc_assert (obstack_next_free (&declarator_obstack)
3036 == declarator_obstack_base);
3038 /* All went well. */
3042 /* Expressions [gram.expr] */
3044 /* Parse a primary-expression.
3055 ( compound-statement )
3056 __builtin_va_arg ( assignment-expression , type-id )
3057 __builtin_offsetof ( type-id , offsetof-expression )
3060 __has_nothrow_assign ( type-id )
3061 __has_nothrow_constructor ( type-id )
3062 __has_nothrow_copy ( type-id )
3063 __has_trivial_assign ( type-id )
3064 __has_trivial_constructor ( type-id )
3065 __has_trivial_copy ( type-id )
3066 __has_trivial_destructor ( type-id )
3067 __has_virtual_destructor ( type-id )
3068 __is_abstract ( type-id )
3069 __is_base_of ( type-id , type-id )
3070 __is_class ( type-id )
3071 __is_convertible_to ( type-id , type-id )
3072 __is_empty ( type-id )
3073 __is_enum ( type-id )
3074 __is_pod ( type-id )
3075 __is_polymorphic ( type-id )
3076 __is_union ( type-id )
3078 Objective-C++ Extension:
3086 ADDRESS_P is true iff this expression was immediately preceded by
3087 "&" and therefore might denote a pointer-to-member. CAST_P is true
3088 iff this expression is the target of a cast. TEMPLATE_ARG_P is
3089 true iff this expression is a template argument.
3091 Returns a representation of the expression. Upon return, *IDK
3092 indicates what kind of id-expression (if any) was present. */
3095 cp_parser_primary_expression (cp_parser *parser,
3098 bool template_arg_p,
3103 /* Assume the primary expression is not an id-expression. */
3104 *idk = CP_ID_KIND_NONE;
3106 /* Peek at the next token. */
3107 token = cp_lexer_peek_token (parser->lexer);
3108 switch (token->type)
3121 token = cp_lexer_consume_token (parser->lexer);
3122 /* Floating-point literals are only allowed in an integral
3123 constant expression if they are cast to an integral or
3124 enumeration type. */
3125 if (TREE_CODE (token->u.value) == REAL_CST
3126 && parser->integral_constant_expression_p
3129 /* CAST_P will be set even in invalid code like "int(2.7 +
3130 ...)". Therefore, we have to check that the next token
3131 is sure to end the cast. */
3134 cp_token *next_token;
3136 next_token = cp_lexer_peek_token (parser->lexer);
3137 if (/* The comma at the end of an
3138 enumerator-definition. */
3139 next_token->type != CPP_COMMA
3140 /* The curly brace at the end of an enum-specifier. */
3141 && next_token->type != CPP_CLOSE_BRACE
3142 /* The end of a statement. */
3143 && next_token->type != CPP_SEMICOLON
3144 /* The end of the cast-expression. */
3145 && next_token->type != CPP_CLOSE_PAREN
3146 /* The end of an array bound. */
3147 && next_token->type != CPP_CLOSE_SQUARE
3148 /* The closing ">" in a template-argument-list. */
3149 && (next_token->type != CPP_GREATER
3150 || parser->greater_than_is_operator_p)
3151 /* C++0x only: A ">>" treated like two ">" tokens,
3152 in a template-argument-list. */
3153 && (next_token->type != CPP_RSHIFT
3154 || (cxx_dialect == cxx98)
3155 || parser->greater_than_is_operator_p))
3159 /* If we are within a cast, then the constraint that the
3160 cast is to an integral or enumeration type will be
3161 checked at that point. If we are not within a cast, then
3162 this code is invalid. */
3164 cp_parser_non_integral_constant_expression
3165 (parser, "floating-point literal");
3167 return token->u.value;
3173 /* ??? Should wide strings be allowed when parser->translate_strings_p
3174 is false (i.e. in attributes)? If not, we can kill the third
3175 argument to cp_parser_string_literal. */
3176 return cp_parser_string_literal (parser,
3177 parser->translate_strings_p,
3180 case CPP_OPEN_PAREN:
3183 bool saved_greater_than_is_operator_p;
3185 /* Consume the `('. */
3186 cp_lexer_consume_token (parser->lexer);
3187 /* Within a parenthesized expression, a `>' token is always
3188 the greater-than operator. */
3189 saved_greater_than_is_operator_p
3190 = parser->greater_than_is_operator_p;
3191 parser->greater_than_is_operator_p = true;
3192 /* If we see `( { ' then we are looking at the beginning of
3193 a GNU statement-expression. */
3194 if (cp_parser_allow_gnu_extensions_p (parser)
3195 && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
3197 /* Statement-expressions are not allowed by the standard. */
3199 pedwarn ("ISO C++ forbids braced-groups within expressions");
3201 /* And they're not allowed outside of a function-body; you
3202 cannot, for example, write:
3204 int i = ({ int j = 3; j + 1; });
3206 at class or namespace scope. */
3207 if (!parser->in_function_body
3208 || parser->in_template_argument_list_p)
3210 error ("statement-expressions are not allowed outside "
3211 "functions nor in template-argument lists");
3212 cp_parser_skip_to_end_of_block_or_statement (parser);
3213 expr = error_mark_node;
3217 /* Start the statement-expression. */
3218 expr = begin_stmt_expr ();
3219 /* Parse the compound-statement. */
3220 cp_parser_compound_statement (parser, expr, false);
3222 expr = finish_stmt_expr (expr, false);
3227 /* Parse the parenthesized expression. */
3228 expr = cp_parser_expression (parser, cast_p);
3229 /* Let the front end know that this expression was
3230 enclosed in parentheses. This matters in case, for
3231 example, the expression is of the form `A::B', since
3232 `&A::B' might be a pointer-to-member, but `&(A::B)' is
3234 finish_parenthesized_expr (expr);
3236 /* The `>' token might be the end of a template-id or
3237 template-parameter-list now. */
3238 parser->greater_than_is_operator_p
3239 = saved_greater_than_is_operator_p;
3240 /* Consume the `)'. */
3241 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>"))
3242 cp_parser_skip_to_end_of_statement (parser);
3248 switch (token->keyword)
3250 /* These two are the boolean literals. */
3252 cp_lexer_consume_token (parser->lexer);
3253 return boolean_true_node;
3255 cp_lexer_consume_token (parser->lexer);
3256 return boolean_false_node;
3258 /* The `__null' literal. */
3260 cp_lexer_consume_token (parser->lexer);
3263 /* Recognize the `this' keyword. */
3265 cp_lexer_consume_token (parser->lexer);
3266 if (parser->local_variables_forbidden_p)
3268 error ("%<this%> may not be used in this context");
3269 return error_mark_node;
3271 /* Pointers cannot appear in constant-expressions. */
3272 if (cp_parser_non_integral_constant_expression (parser, "%<this%>"))
3273 return error_mark_node;
3274 return finish_this_expr ();
3276 /* The `operator' keyword can be the beginning of an
3281 case RID_FUNCTION_NAME:
3282 case RID_PRETTY_FUNCTION_NAME:
3283 case RID_C99_FUNCTION_NAME:
3284 /* The symbols __FUNCTION__, __PRETTY_FUNCTION__, and
3285 __func__ are the names of variables -- but they are
3286 treated specially. Therefore, they are handled here,
3287 rather than relying on the generic id-expression logic
3288 below. Grammatically, these names are id-expressions.
3290 Consume the token. */
3291 token = cp_lexer_consume_token (parser->lexer);
3292 /* Look up the name. */
3293 return finish_fname (token->u.value);
3300 /* The `__builtin_va_arg' construct is used to handle
3301 `va_arg'. Consume the `__builtin_va_arg' token. */
3302 cp_lexer_consume_token (parser->lexer);
3303 /* Look for the opening `('. */
3304 cp_parser_require (parser, CPP_OPEN_PAREN, "%<(%>");
3305 /* Now, parse the assignment-expression. */
3306 expression = cp_parser_assignment_expression (parser,
3308 /* Look for the `,'. */
3309 cp_parser_require (parser, CPP_COMMA, "%<,%>");
3310 /* Parse the type-id. */
3311 type = cp_parser_type_id (parser);
3312 /* Look for the closing `)'. */
3313 cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>");
3314 /* Using `va_arg' in a constant-expression is not
3316 if (cp_parser_non_integral_constant_expression (parser,
3318 return error_mark_node;
3319 return build_x_va_arg (expression, type);
3323 return cp_parser_builtin_offsetof (parser);
3325 case RID_HAS_NOTHROW_ASSIGN:
3326 case RID_HAS_NOTHROW_CONSTRUCTOR:
3327 case RID_HAS_NOTHROW_COPY:
3328 case RID_HAS_TRIVIAL_ASSIGN:
3329 case RID_HAS_TRIVIAL_CONSTRUCTOR:
3330 case RID_HAS_TRIVIAL_COPY:
3331 case RID_HAS_TRIVIAL_DESTRUCTOR:
3332 case RID_HAS_VIRTUAL_DESTRUCTOR:
3333 case RID_IS_ABSTRACT:
3334 case RID_IS_BASE_OF:
3336 case RID_IS_CONVERTIBLE_TO:
3340 case RID_IS_POLYMORPHIC:
3342 return cp_parser_trait_expr (parser, token->keyword);
3344 /* Objective-C++ expressions. */
3346 case RID_AT_PROTOCOL:
3347 case RID_AT_SELECTOR:
3348 return cp_parser_objc_expression (parser);
3351 cp_parser_error (parser, "expected primary-expression");
3352 return error_mark_node;
3355 /* An id-expression can start with either an identifier, a
3356 `::' as the beginning of a qualified-id, or the "operator"
3360 case CPP_TEMPLATE_ID:
3361 case CPP_NESTED_NAME_SPECIFIER:
3365 const char *error_msg;
3370 /* Parse the id-expression. */
3372 = cp_parser_id_expression (parser,
3373 /*template_keyword_p=*/false,
3374 /*check_dependency_p=*/true,
3376 /*declarator_p=*/false,
3377 /*optional_p=*/false);
3378 if (id_expression == error_mark_node)
3379 return error_mark_node;
3380 token = cp_lexer_peek_token (parser->lexer);
3381 done = (token->type != CPP_OPEN_SQUARE
3382 && token->type != CPP_OPEN_PAREN
3383 && token->type != CPP_DOT
3384 && token->type != CPP_DEREF
3385 && token->type != CPP_PLUS_PLUS
3386 && token->type != CPP_MINUS_MINUS);
3387 /* If we have a template-id, then no further lookup is
3388 required. If the template-id was for a template-class, we
3389 will sometimes have a TYPE_DECL at this point. */
3390 if (TREE_CODE (id_expression) == TEMPLATE_ID_EXPR
3391 || TREE_CODE (id_expression) == TYPE_DECL)
3392 decl = id_expression;
3393 /* Look up the name. */
3396 tree ambiguous_decls;
3398 decl = cp_parser_lookup_name (parser, id_expression,
3401 /*is_namespace=*/false,
3402 /*check_dependency=*/true,
3404 /* If the lookup was ambiguous, an error will already have
3406 if (ambiguous_decls)
3407 return error_mark_node;
3409 /* In Objective-C++, an instance variable (ivar) may be preferred
3410 to whatever cp_parser_lookup_name() found. */
3411 decl = objc_lookup_ivar (decl, id_expression);
3413 /* If name lookup gives us a SCOPE_REF, then the
3414 qualifying scope was dependent. */
3415 if (TREE_CODE (decl) == SCOPE_REF)
3417 /* At this point, we do not know if DECL is a valid
3418 integral constant expression. We assume that it is
3419 in fact such an expression, so that code like:
3421 template <int N> struct A {
3425 is accepted. At template-instantiation time, we
3426 will check that B<N>::i is actually a constant. */
3429 /* Check to see if DECL is a local variable in a context
3430 where that is forbidden. */
3431 if (parser->local_variables_forbidden_p
3432 && local_variable_p (decl))
3434 /* It might be that we only found DECL because we are
3435 trying to be generous with pre-ISO scoping rules.
3436 For example, consider:
3440 for (int i = 0; i < 10; ++i) {}
3441 extern void f(int j = i);
3444 Here, name look up will originally find the out
3445 of scope `i'. We need to issue a warning message,
3446 but then use the global `i'. */
3447 decl = check_for_out_of_scope_variable (decl);
3448 if (local_variable_p (decl))
3450 error ("local variable %qD may not appear in this context",
3452 return error_mark_node;
3457 decl = (finish_id_expression
3458 (id_expression, decl, parser->scope,
3460 parser->integral_constant_expression_p,
3461 parser->allow_non_integral_constant_expression_p,
3462 &parser->non_integral_constant_expression_p,
3463 template_p, done, address_p,
3467 cp_parser_error (parser, error_msg);
3471 /* Anything else is an error. */
3473 /* ...unless we have an Objective-C++ message or string literal,
3475 if (c_dialect_objc ()
3476 && (token->type == CPP_OPEN_SQUARE
3477 || token->type == CPP_OBJC_STRING))
3478 return cp_parser_objc_expression (parser);
3480 cp_parser_error (parser, "expected primary-expression");
3481 return error_mark_node;
3485 /* Parse an id-expression.
3492 :: [opt] nested-name-specifier template [opt] unqualified-id
3494 :: operator-function-id
3497 Return a representation of the unqualified portion of the
3498 identifier. Sets PARSER->SCOPE to the qualifying scope if there is
3499 a `::' or nested-name-specifier.
3501 Often, if the id-expression was a qualified-id, the caller will
3502 want to make a SCOPE_REF to represent the qualified-id. This
3503 function does not do this in order to avoid wastefully creating
3504 SCOPE_REFs when they are not required.
3506 If TEMPLATE_KEYWORD_P is true, then we have just seen the
3509 If CHECK_DEPENDENCY_P is false, then names are looked up inside
3510 uninstantiated templates.
3512 If *TEMPLATE_P is non-NULL, it is set to true iff the
3513 `template' keyword is used to explicitly indicate that the entity
3514 named is a template.
3516 If DECLARATOR_P is true, the id-expression is appearing as part of
3517 a declarator, rather than as part of an expression. */
3520 cp_parser_id_expression (cp_parser *parser,
3521 bool template_keyword_p,
3522 bool check_dependency_p,
3527 bool global_scope_p;
3528 bool nested_name_specifier_p;
3530 /* Assume the `template' keyword was not used. */
3532 *template_p = template_keyword_p;
3534 /* Look for the optional `::' operator. */
3536 = (cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/false)
3538 /* Look for the optional nested-name-specifier. */
3539 nested_name_specifier_p
3540 = (cp_parser_nested_name_specifier_opt (parser,
3541 /*typename_keyword_p=*/false,
3546 /* If there is a nested-name-specifier, then we are looking at
3547 the first qualified-id production. */
3548 if (nested_name_specifier_p)
3551 tree saved_object_scope;
3552 tree saved_qualifying_scope;
3553 tree unqualified_id;
3556 /* See if the next token is the `template' keyword. */
3558 template_p = &is_template;
3559 *template_p = cp_parser_optional_template_keyword (parser);
3560 /* Name lookup we do during the processing of the
3561 unqualified-id might obliterate SCOPE. */
3562 saved_scope = parser->scope;
3563 saved_object_scope = parser->object_scope;
3564 saved_qualifying_scope = parser->qualifying_scope;
3565 /* Process the final unqualified-id. */
3566 unqualified_id = cp_parser_unqualified_id (parser, *template_p,
3569 /*optional_p=*/false);
3570 /* Restore the SAVED_SCOPE for our caller. */
3571 parser->scope = saved_scope;
3572 parser->object_scope = saved_object_scope;
3573 parser->qualifying_scope = saved_qualifying_scope;
3575 return unqualified_id;
3577 /* Otherwise, if we are in global scope, then we are looking at one
3578 of the other qualified-id productions. */
3579 else if (global_scope_p)
3584 /* Peek at the next token. */
3585 token = cp_lexer_peek_token (parser->lexer);
3587 /* If it's an identifier, and the next token is not a "<", then
3588 we can avoid the template-id case. This is an optimization
3589 for this common case. */
3590 if (token->type == CPP_NAME
3591 && !cp_parser_nth_token_starts_template_argument_list_p
3593 return cp_parser_identifier (parser);
3595 cp_parser_parse_tentatively (parser);
3596 /* Try a template-id. */
3597 id = cp_parser_template_id (parser,
3598 /*template_keyword_p=*/false,
3599 /*check_dependency_p=*/true,
3601 /* If that worked, we're done. */
3602 if (cp_parser_parse_definitely (parser))
3605 /* Peek at the next token. (Changes in the token buffer may
3606 have invalidated the pointer obtained above.) */
3607 token = cp_lexer_peek_token (parser->lexer);
3609 switch (token->type)
3612 return cp_parser_identifier (parser);
3615 if (token->keyword == RID_OPERATOR)
3616 return cp_parser_operator_function_id (parser);
3620 cp_parser_error (parser, "expected id-expression");
3621 return error_mark_node;
3625 return cp_parser_unqualified_id (parser, template_keyword_p,
3626 /*check_dependency_p=*/true,
3631 /* Parse an unqualified-id.
3635 operator-function-id
3636 conversion-function-id
3640 If TEMPLATE_KEYWORD_P is TRUE, we have just seen the `template'
3641 keyword, in a construct like `A::template ...'.
3643 Returns a representation of unqualified-id. For the `identifier'
3644 production, an IDENTIFIER_NODE is returned. For the `~ class-name'
3645 production a BIT_NOT_EXPR is returned; the operand of the
3646 BIT_NOT_EXPR is an IDENTIFIER_NODE for the class-name. For the
3647 other productions, see the documentation accompanying the
3648 corresponding parsing functions. If CHECK_DEPENDENCY_P is false,
3649 names are looked up in uninstantiated templates. If DECLARATOR_P
3650 is true, the unqualified-id is appearing as part of a declarator,
3651 rather than as part of an expression. */
3654 cp_parser_unqualified_id (cp_parser* parser,
3655 bool template_keyword_p,
3656 bool check_dependency_p,
3662 /* Peek at the next token. */
3663 token = cp_lexer_peek_token (parser->lexer);
3665 switch (token->type)
3671 /* We don't know yet whether or not this will be a
3673 cp_parser_parse_tentatively (parser);
3674 /* Try a template-id. */
3675 id = cp_parser_template_id (parser, template_keyword_p,
3678 /* If it worked, we're done. */
3679 if (cp_parser_parse_definitely (parser))
3681 /* Otherwise, it's an ordinary identifier. */
3682 return cp_parser_identifier (parser);
3685 case CPP_TEMPLATE_ID:
3686 return cp_parser_template_id (parser, template_keyword_p,
3693 tree qualifying_scope;
3698 /* Consume the `~' token. */
3699 cp_lexer_consume_token (parser->lexer);
3700 /* Parse the class-name. The standard, as written, seems to
3703 template <typename T> struct S { ~S (); };
3704 template <typename T> S<T>::~S() {}
3706 is invalid, since `~' must be followed by a class-name, but
3707 `S<T>' is dependent, and so not known to be a class.
3708 That's not right; we need to look in uninstantiated
3709 templates. A further complication arises from:
3711 template <typename T> void f(T t) {
3715 Here, it is not possible to look up `T' in the scope of `T'
3716 itself. We must look in both the current scope, and the
3717 scope of the containing complete expression.
3719 Yet another issue is:
3728 The standard does not seem to say that the `S' in `~S'
3729 should refer to the type `S' and not the data member
3732 /* DR 244 says that we look up the name after the "~" in the
3733 same scope as we looked up the qualifying name. That idea
3734 isn't fully worked out; it's more complicated than that. */
3735 scope = parser->scope;
3736 object_scope = parser->object_scope;
3737 qualifying_scope = parser->qualifying_scope;
3739 /* Check for invalid scopes. */
3740 if (scope == error_mark_node)
3742 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
3743 cp_lexer_consume_token (parser->lexer);
3744 return error_mark_node;
3746 if (scope && TREE_CODE (scope) == NAMESPACE_DECL)
3748 if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
3749 error ("scope %qT before %<~%> is not a class-name", scope);
3750 cp_parser_simulate_error (parser);
3751 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
3752 cp_lexer_consume_token (parser->lexer);
3753 return error_mark_node;
3755 gcc_assert (!scope || TYPE_P (scope));
3757 /* If the name is of the form "X::~X" it's OK. */
3758 token = cp_lexer_peek_token (parser->lexer);
3760 && token->type == CPP_NAME
3761 && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
3763 && constructor_name_p (token->u.value, scope))
3765 cp_lexer_consume_token (parser->lexer);
3766 return build_nt (BIT_NOT_EXPR, scope);
3769 /* If there was an explicit qualification (S::~T), first look
3770 in the scope given by the qualification (i.e., S). */
3772 type_decl = NULL_TREE;
3775 cp_parser_parse_tentatively (parser);
3776 type_decl = cp_parser_class_name (parser,
3777 /*typename_keyword_p=*/false,
3778 /*template_keyword_p=*/false,
3780 /*check_dependency=*/false,
3781 /*class_head_p=*/false,
3783 if (cp_parser_parse_definitely (parser))
3786 /* In "N::S::~S", look in "N" as well. */
3787 if (!done && scope && qualifying_scope)
3789 cp_parser_parse_tentatively (parser);
3790 parser->scope = qualifying_scope;
3791 parser->object_scope = NULL_TREE;
3792 parser->qualifying_scope = NULL_TREE;
3794 = cp_parser_class_name (parser,
3795 /*typename_keyword_p=*/false,
3796 /*template_keyword_p=*/false,
3798 /*check_dependency=*/false,
3799 /*class_head_p=*/false,
3801 if (cp_parser_parse_definitely (parser))
3804 /* In "p->S::~T", look in the scope given by "*p" as well. */
3805 else if (!done && object_scope)
3807 cp_parser_parse_tentatively (parser);
3808 parser->scope = object_scope;
3809 parser->object_scope = NULL_TREE;
3810 parser->qualifying_scope = NULL_TREE;
3812 = cp_parser_class_name (parser,
3813 /*typename_keyword_p=*/false,
3814 /*template_keyword_p=*/false,
3816 /*check_dependency=*/false,
3817 /*class_head_p=*/false,
3819 if (cp_parser_parse_definitely (parser))
3822 /* Look in the surrounding context. */
3825 parser->scope = NULL_TREE;
3826 parser->object_scope = NULL_TREE;
3827 parser->qualifying_scope = NULL_TREE;
3829 = cp_parser_class_name (parser,
3830 /*typename_keyword_p=*/false,
3831 /*template_keyword_p=*/false,
3833 /*check_dependency=*/false,
3834 /*class_head_p=*/false,
3837 /* If an error occurred, assume that the name of the
3838 destructor is the same as the name of the qualifying
3839 class. That allows us to keep parsing after running
3840 into ill-formed destructor names. */
3841 if (type_decl == error_mark_node && scope)
3842 return build_nt (BIT_NOT_EXPR, scope);
3843 else if (type_decl == error_mark_node)
3844 return error_mark_node;
3846 /* Check that destructor name and scope match. */
3847 if (declarator_p && scope && !check_dtor_name (scope, type_decl))
3849 if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
3850 error ("declaration of %<~%T%> as member of %qT",
3852 cp_parser_simulate_error (parser);
3853 return error_mark_node;
3858 A typedef-name that names a class shall not be used as the
3859 identifier in the declarator for a destructor declaration. */
3861 && !DECL_IMPLICIT_TYPEDEF_P (type_decl)
3862 && !DECL_SELF_REFERENCE_P (type_decl)
3863 && !cp_parser_uncommitted_to_tentative_parse_p (parser))
3864 error ("typedef-name %qD used as destructor declarator",
3867 return build_nt (BIT_NOT_EXPR, TREE_TYPE (type_decl));
3871 if (token->keyword == RID_OPERATOR)
3875 /* This could be a template-id, so we try that first. */
3876 cp_parser_parse_tentatively (parser);
3877 /* Try a template-id. */
3878 id = cp_parser_template_id (parser, template_keyword_p,
3879 /*check_dependency_p=*/true,
3881 /* If that worked, we're done. */
3882 if (cp_parser_parse_definitely (parser))
3884 /* We still don't know whether we're looking at an
3885 operator-function-id or a conversion-function-id. */
3886 cp_parser_parse_tentatively (parser);
3887 /* Try an operator-function-id. */
3888 id = cp_parser_operator_function_id (parser);
3889 /* If that didn't work, try a conversion-function-id. */
3890 if (!cp_parser_parse_definitely (parser))
3891 id = cp_parser_conversion_function_id (parser);
3900 cp_parser_error (parser, "expected unqualified-id");
3901 return error_mark_node;
3905 /* Parse an (optional) nested-name-specifier.
3907 nested-name-specifier:
3908 class-or-namespace-name :: nested-name-specifier [opt]
3909 class-or-namespace-name :: template nested-name-specifier [opt]
3911 PARSER->SCOPE should be set appropriately before this function is
3912 called. TYPENAME_KEYWORD_P is TRUE if the `typename' keyword is in
3913 effect. TYPE_P is TRUE if we non-type bindings should be ignored
3916 Sets PARSER->SCOPE to the class (TYPE) or namespace
3917 (NAMESPACE_DECL) specified by the nested-name-specifier, or leaves
3918 it unchanged if there is no nested-name-specifier. Returns the new
3919 scope iff there is a nested-name-specifier, or NULL_TREE otherwise.
3921 If IS_DECLARATION is TRUE, the nested-name-specifier is known to be
3922 part of a declaration and/or decl-specifier. */
3925 cp_parser_nested_name_specifier_opt (cp_parser *parser,
3926 bool typename_keyword_p,
3927 bool check_dependency_p,
3929 bool is_declaration)
3931 bool success = false;
3932 cp_token_position start = 0;
3935 /* Remember where the nested-name-specifier starts. */
3936 if (cp_parser_uncommitted_to_tentative_parse_p (parser))
3938 start = cp_lexer_token_position (parser->lexer, false);
3939 push_deferring_access_checks (dk_deferred);
3946 tree saved_qualifying_scope;
3947 bool template_keyword_p;
3949 /* Spot cases that cannot be the beginning of a
3950 nested-name-specifier. */
3951 token = cp_lexer_peek_token (parser->lexer);
3953 /* If the next token is CPP_NESTED_NAME_SPECIFIER, just process
3954 the already parsed nested-name-specifier. */
3955 if (token->type == CPP_NESTED_NAME_SPECIFIER)
3957 /* Grab the nested-name-specifier and continue the loop. */
3958 cp_parser_pre_parsed_nested_name_specifier (parser);
3959 /* If we originally encountered this nested-name-specifier
3960 with IS_DECLARATION set to false, we will not have
3961 resolved TYPENAME_TYPEs, so we must do so here. */
3963 && TREE_CODE (parser->scope) == TYPENAME_TYPE)
3965 new_scope = resolve_typename_type (parser->scope,
3966 /*only_current_p=*/false);
3967 if (TREE_CODE (new_scope) != TYPENAME_TYPE)
3968 parser->scope = new_scope;
3974 /* Spot cases that cannot be the beginning of a
3975 nested-name-specifier. On the second and subsequent times
3976 through the loop, we look for the `template' keyword. */
3977 if (success && token->keyword == RID_TEMPLATE)
3979 /* A template-id can start a nested-name-specifier. */
3980 else if (token->type == CPP_TEMPLATE_ID)
3984 /* If the next token is not an identifier, then it is
3985 definitely not a class-or-namespace-name. */
3986 if (token->type != CPP_NAME)
3988 /* If the following token is neither a `<' (to begin a
3989 template-id), nor a `::', then we are not looking at a
3990 nested-name-specifier. */
3991 token = cp_lexer_peek_nth_token (parser->lexer, 2);
3992 if (token->type != CPP_SCOPE
3993 && !cp_parser_nth_token_starts_template_argument_list_p
3998 /* The nested-name-specifier is optional, so we parse
4000 cp_parser_parse_tentatively (parser);
4002 /* Look for the optional `template' keyword, if this isn't the
4003 first time through the loop. */
4005 template_keyword_p = cp_parser_optional_template_keyword (parser);
4007 template_keyword_p = false;
4009 /* Save the old scope since the name lookup we are about to do
4010 might destroy it. */
4011 old_scope = parser->scope;
4012 saved_qualifying_scope = parser->qualifying_scope;
4013 /* In a declarator-id like "X<T>::I::Y<T>" we must be able to
4014 look up names in "X<T>::I" in order to determine that "Y" is
4015 a template. So, if we have a typename at this point, we make
4016 an effort to look through it. */
4018 && !typename_keyword_p
4020 && TREE_CODE (parser->scope) == TYPENAME_TYPE)
4021 parser->scope = resolve_typename_type (parser->scope,
4022 /*only_current_p=*/false);
4023 /* Parse the qualifying entity. */
4025 = cp_parser_class_or_namespace_name (parser,
4031 /* Look for the `::' token. */
4032 cp_parser_require (parser, CPP_SCOPE, "%<::%>");
4034 /* If we found what we wanted, we keep going; otherwise, we're
4036 if (!cp_parser_parse_definitely (parser))
4038 bool error_p = false;
4040 /* Restore the OLD_SCOPE since it was valid before the
4041 failed attempt at finding the last
4042 class-or-namespace-name. */
4043 parser->scope = old_scope;
4044 parser->qualifying_scope = saved_qualifying_scope;
4045 if (cp_parser_uncommitted_to_tentative_parse_p (parser))
4047 /* If the next token is an identifier, and the one after
4048 that is a `::', then any valid interpretation would have
4049 found a class-or-namespace-name. */
4050 while (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
4051 && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
4053 && (cp_lexer_peek_nth_token (parser->lexer, 3)->type
4056 token = cp_lexer_consume_token (parser->lexer);
4059 if (!token->ambiguous_p)
4062 tree ambiguous_decls;
4064 decl = cp_parser_lookup_name (parser, token->u.value,
4066 /*is_template=*/false,
4067 /*is_namespace=*/false,
4068 /*check_dependency=*/true,
4070 if (TREE_CODE (decl) == TEMPLATE_DECL)
4071 error ("%qD used without template parameters", decl);
4072 else if (ambiguous_decls)
4074 error ("reference to %qD is ambiguous",
4076 print_candidates (ambiguous_decls);
4077 decl = error_mark_node;
4080 cp_parser_name_lookup_error
4081 (parser, token->u.value, decl,
4082 "is not a class or namespace");
4084 parser->scope = error_mark_node;
4086 /* Treat this as a successful nested-name-specifier
4091 If the name found is not a class-name (clause
4092 _class_) or namespace-name (_namespace.def_), the
4093 program is ill-formed. */
4096 cp_lexer_consume_token (parser->lexer);
4100 /* We've found one valid nested-name-specifier. */
4102 /* Name lookup always gives us a DECL. */
4103 if (TREE_CODE (new_scope) == TYPE_DECL)
4104 new_scope = TREE_TYPE (new_scope);
4105 /* Uses of "template" must be followed by actual templates. */
4106 if (template_keyword_p
4107 && !(CLASS_TYPE_P (new_scope)
4108 && ((CLASSTYPE_USE_TEMPLATE (new_scope)
4109 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (new_scope)))
4110 || CLASSTYPE_IS_TEMPLATE (new_scope)))
4111 && !(TREE_CODE (new_scope) == TYPENAME_TYPE
4112 && (TREE_CODE (TYPENAME_TYPE_FULLNAME (new_scope))
4113 == TEMPLATE_ID_EXPR)))
4114 pedwarn (TYPE_P (new_scope)
4115 ? "%qT is not a template"
4116 : "%qD is not a template",
4118 /* If it is a class scope, try to complete it; we are about to
4119 be looking up names inside the class. */
4120 if (TYPE_P (new_scope)
4121 /* Since checking types for dependency can be expensive,
4122 avoid doing it if the type is already complete. */
4123 && !COMPLETE_TYPE_P (new_scope)
4124 /* Do not try to complete dependent types. */
4125 && !dependent_type_p (new_scope))
4127 new_scope = complete_type (new_scope);
4128 /* If it is a typedef to current class, use the current
4129 class instead, as the typedef won't have any names inside
4131 if (!COMPLETE_TYPE_P (new_scope)
4132 && currently_open_class (new_scope))
4133 new_scope = TYPE_MAIN_VARIANT (new_scope);
4135 /* Make sure we look in the right scope the next time through
4137 parser->scope = new_scope;
4140 /* If parsing tentatively, replace the sequence of tokens that makes
4141 up the nested-name-specifier with a CPP_NESTED_NAME_SPECIFIER
4142 token. That way, should we re-parse the token stream, we will
4143 not have to repeat the effort required to do the parse, nor will
4144 we issue duplicate error messages. */
4145 if (success && start)
4149 token = cp_lexer_token_at (parser->lexer, start);
4150 /* Reset the contents of the START token. */
4151 token->type = CPP_NESTED_NAME_SPECIFIER;
4152 /* Retrieve any deferred checks. Do not pop this access checks yet
4153 so the memory will not be reclaimed during token replacing below. */
4154 token->u.tree_check_value = GGC_CNEW (struct tree_check);
4155 token->u.tree_check_value->value = parser->scope;
4156 token->u.tree_check_value->checks = get_deferred_access_checks ();
4157 token->u.tree_check_value->qualifying_scope =
4158 parser->qualifying_scope;
4159 token->keyword = RID_MAX;
4161 /* Purge all subsequent tokens. */
4162 cp_lexer_purge_tokens_after (parser->lexer, start);
4166 pop_to_parent_deferring_access_checks ();
4168 return success ? parser->scope : NULL_TREE;
4171 /* Parse a nested-name-specifier. See
4172 cp_parser_nested_name_specifier_opt for details. This function
4173 behaves identically, except that it will an issue an error if no
4174 nested-name-specifier is present. */
4177 cp_parser_nested_name_specifier (cp_parser *parser,
4178 bool typename_keyword_p,
4179 bool check_dependency_p,
4181 bool is_declaration)
4185 /* Look for the nested-name-specifier. */
4186 scope = cp_parser_nested_name_specifier_opt (parser,
4191 /* If it was not present, issue an error message. */
4194 cp_parser_error (parser, "expected nested-name-specifier");
4195 parser->scope = NULL_TREE;
4201 /* Parse a class-or-namespace-name.
4203 class-or-namespace-name:
4207 TYPENAME_KEYWORD_P is TRUE iff the `typename' keyword is in effect.
4208 TEMPLATE_KEYWORD_P is TRUE iff the `template' keyword is in effect.
4209 CHECK_DEPENDENCY_P is FALSE iff dependent names should be looked up.
4210 TYPE_P is TRUE iff the next name should be taken as a class-name,
4211 even the same name is declared to be another entity in the same
4214 Returns the class (TYPE_DECL) or namespace (NAMESPACE_DECL)
4215 specified by the class-or-namespace-name. If neither is found the
4216 ERROR_MARK_NODE is returned. */
4219 cp_parser_class_or_namespace_name (cp_parser *parser,
4220 bool typename_keyword_p,
4221 bool template_keyword_p,
4222 bool check_dependency_p,
4224 bool is_declaration)
4227 tree saved_qualifying_scope;
4228 tree saved_object_scope;
4232 /* Before we try to parse the class-name, we must save away the
4233 current PARSER->SCOPE since cp_parser_class_name will destroy
4235 saved_scope = parser->scope;
4236 saved_qualifying_scope = parser->qualifying_scope;
4237 saved_object_scope = parser->object_scope;
4238 /* Try for a class-name first. If the SAVED_SCOPE is a type, then
4239 there is no need to look for a namespace-name. */
4240 only_class_p = template_keyword_p || (saved_scope && TYPE_P (saved_scope));
4242 cp_parser_parse_tentatively (parser);
4243 scope = cp_parser_class_name (parser,
4246 type_p ? class_type : none_type,
4248 /*class_head_p=*/false,
4250 /* If that didn't work, try for a namespace-name. */
4251 if (!only_class_p && !cp_parser_parse_definitely (parser))
4253 /* Restore the saved scope. */
4254 parser->scope = saved_scope;
4255 parser->qualifying_scope = saved_qualifying_scope;
4256 parser->object_scope = saved_object_scope;
4257 /* If we are not looking at an identifier followed by the scope
4258 resolution operator, then this is not part of a
4259 nested-name-specifier. (Note that this function is only used
4260 to parse the components of a nested-name-specifier.) */
4261 if (cp_lexer_next_token_is_not (parser->lexer, CPP_NAME)
4262 || cp_lexer_peek_nth_token (parser->lexer, 2)->type != CPP_SCOPE)
4263 return error_mark_node;
4264 scope = cp_parser_namespace_name (parser);
4270 /* Parse a postfix-expression.
4274 postfix-expression [ expression ]
4275 postfix-expression ( expression-list [opt] )
4276 simple-type-specifier ( expression-list [opt] )
4277 typename :: [opt] nested-name-specifier identifier
4278 ( expression-list [opt] )
4279 typename :: [opt] nested-name-specifier template [opt] template-id
4280 ( expression-list [opt] )
4281 postfix-expression . template [opt] id-expression
4282 postfix-expression -> template [opt] id-expression
4283 postfix-expression . pseudo-destructor-name
4284 postfix-expression -> pseudo-destructor-name
4285 postfix-expression ++
4286 postfix-expression --
4287 dynamic_cast < type-id > ( expression )
4288 static_cast < type-id > ( expression )
4289 reinterpret_cast < type-id > ( expression )
4290 const_cast < type-id > ( expression )
4291 typeid ( expression )
4297 ( type-id ) { initializer-list , [opt] }
4299 This extension is a GNU version of the C99 compound-literal
4300 construct. (The C99 grammar uses `type-name' instead of `type-id',
4301 but they are essentially the same concept.)
4303 If ADDRESS_P is true, the postfix expression is the operand of the
4304 `&' operator. CAST_P is true if this expression is the target of a
4307 If MEMBER_ACCESS_ONLY_P, we only allow postfix expressions that are
4308 class member access expressions [expr.ref].
4310 Returns a representation of the expression. */
4313 cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p,
4314 bool member_access_only_p)
4318 cp_id_kind idk = CP_ID_KIND_NONE;
4319 tree postfix_expression = NULL_TREE;
4320 bool is_member_access = false;
4322 /* Peek at the next token. */
4323 token = cp_lexer_peek_token (parser->lexer);
4324 /* Some of the productions are determined by keywords. */
4325 keyword = token->keyword;
4335 const char *saved_message;
4337 /* All of these can be handled in the same way from the point
4338 of view of parsing. Begin by consuming the token
4339 identifying the cast. */
4340 cp_lexer_consume_token (parser->lexer);
4342 /* New types cannot be defined in the cast. */
4343 saved_message = parser->type_definition_forbidden_message;
4344 parser->type_definition_forbidden_message
4345 = "types may not be defined in casts";
4347 /* Look for the opening `<'. */
4348 cp_parser_require (parser, CPP_LESS, "%<<%>");
4349 /* Parse the type to which we are casting. */
4350 type = cp_parser_type_id (parser);
4351 /* Look for the closing `>'. */
4352 cp_parser_require (parser, CPP_GREATER, "%<>%>");
4353 /* Restore the old message. */
4354 parser->type_definition_forbidden_message = saved_message;
4356 /* And the expression which is being cast. */
4357 cp_parser_require (parser, CPP_OPEN_PAREN, "%<(%>");
4358 expression = cp_parser_expression (parser, /*cast_p=*/true);
4359 cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>");
4361 /* Only type conversions to integral or enumeration types
4362 can be used in constant-expressions. */
4363 if (!cast_valid_in_integral_constant_expression_p (type)
4364 && (cp_parser_non_integral_constant_expression
4366 "a cast to a type other than an integral or "
4367 "enumeration type")))
4368 return error_mark_node;
4374 = build_dynamic_cast (type, expression, tf_warning_or_error);
4378 = build_static_cast (type, expression, tf_warning_or_error);
4382 = build_reinterpret_cast (type, expression,
4383 tf_warning_or_error);
4387 = build_const_cast (type, expression, tf_warning_or_error);
4398 const char *saved_message;
4399 bool saved_in_type_id_in_expr_p;
4401 /* Consume the `typeid' token. */
4402 cp_lexer_consume_token (parser->lexer);
4403 /* Look for the `(' token. */
4404 cp_parser_require (parser, CPP_OPEN_PAREN, "%<(%>");
4405 /* Types cannot be defined in a `typeid' expression. */
4406 saved_message = parser->type_definition_forbidden_message;
4407 parser->type_definition_forbidden_message
4408 = "types may not be defined in a %<typeid%> expression";
4409 /* We can't be sure yet whether we're looking at a type-id or an
4411 cp_parser_parse_tentatively (parser);
4412 /* Try a type-id first. */
4413 saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p;
4414 parser->in_type_id_in_expr_p = true;
4415 type = cp_parser_type_id (parser);
4416 parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
4417 /* Look for the `)' token. Otherwise, we can't be sure that
4418 we're not looking at an expression: consider `typeid (int
4419 (3))', for example. */
4420 cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>");
4421 /* If all went well, simply lookup the type-id. */
4422 if (cp_parser_parse_definitely (parser))
4423 postfix_expression = get_typeid (type);
4424 /* Otherwise, fall back to the expression variant. */
4429 /* Look for an expression. */
4430 expression = cp_parser_expression (parser, /*cast_p=*/false);
4431 /* Compute its typeid. */
4432 postfix_expression = build_typeid (expression);
4433 /* Look for the `)' token. */
4434 cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>");
4436 /* Restore the saved message. */
4437 parser->type_definition_forbidden_message = saved_message;
4438 /* `typeid' may not appear in an integral constant expression. */
4439 if (cp_parser_non_integral_constant_expression(parser,
4440 "%<typeid%> operator"))
4441 return error_mark_node;
4448 /* The syntax permitted here is the same permitted for an
4449 elaborated-type-specifier. */
4450 type = cp_parser_elaborated_type_specifier (parser,
4451 /*is_friend=*/false,
4452 /*is_declaration=*/false);
4453 postfix_expression = cp_parser_functional_cast (parser, type);
4461 /* If the next thing is a simple-type-specifier, we may be
4462 looking at a functional cast. We could also be looking at
4463 an id-expression. So, we try the functional cast, and if
4464 that doesn't work we fall back to the primary-expression. */
4465 cp_parser_parse_tentatively (parser);
4466 /* Look for the simple-type-specifier. */
4467 type = cp_parser_simple_type_specifier (parser,
4468 /*decl_specs=*/NULL,
4469 CP_PARSER_FLAGS_NONE);
4470 /* Parse the cast itself. */
4471 if (!cp_parser_error_occurred (parser))
4473 = cp_parser_functional_cast (parser, type);
4474 /* If that worked, we're done. */
4475 if (cp_parser_parse_definitely (parser))
4478 /* If the functional-cast didn't work out, try a
4479 compound-literal. */
4480 if (cp_parser_allow_gnu_extensions_p (parser)
4481 && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
4483 VEC(constructor_elt,gc) *initializer_list = NULL;
4484 bool saved_in_type_id_in_expr_p;
4486 cp_parser_parse_tentatively (parser);
4487 /* Consume the `('. */
4488 cp_lexer_consume_token (parser->lexer);
4489 /* Parse the type. */
4490 saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p;
4491 parser->in_type_id_in_expr_p = true;
4492 type = cp_parser_type_id (parser);
4493 parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
4494 /* Look for the `)'. */
4495 cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>");
4496 /* Look for the `{'. */
4497 cp_parser_require (parser, CPP_OPEN_BRACE, "%<{%>");
4498 /* If things aren't going well, there's no need to
4500 if (!cp_parser_error_occurred (parser))
4502 bool non_constant_p;
4503 /* Parse the initializer-list. */
4505 = cp_parser_initializer_list (parser, &non_constant_p);
4506 /* Allow a trailing `,'. */
4507 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
4508 cp_lexer_consume_token (parser->lexer);
4509 /* Look for the final `}'. */
4510 cp_parser_require (parser, CPP_CLOSE_BRACE, "%<}%>");
4512 /* If that worked, we're definitely looking at a
4513 compound-literal expression. */
4514 if (cp_parser_parse_definitely (parser))
4516 /* Warn the user that a compound literal is not
4517 allowed in standard C++. */
4519 pedwarn ("ISO C++ forbids compound-literals");
4520 /* For simplicity, we disallow compound literals in
4521 constant-expressions. We could
4522 allow compound literals of integer type, whose
4523 initializer was a constant, in constant
4524 expressions. Permitting that usage, as a further
4525 extension, would not change the meaning of any
4526 currently accepted programs. (Of course, as
4527 compound literals are not part of ISO C++, the
4528 standard has nothing to say.) */
4529 if (cp_parser_non_integral_constant_expression
4530 (parser, "non-constant compound literals"))
4532 postfix_expression = error_mark_node;
4535 /* Form the representation of the compound-literal. */
4537 = finish_compound_literal (type, initializer_list);
4542 /* It must be a primary-expression. */
4544 = cp_parser_primary_expression (parser, address_p, cast_p,
4545 /*template_arg_p=*/false,
4551 /* Keep looping until the postfix-expression is complete. */
4554 if (idk == CP_ID_KIND_UNQUALIFIED
4555 && TREE_CODE (postfix_expression) == IDENTIFIER_NODE
4556 && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_PAREN))
4557 /* It is not a Koenig lookup function call. */
4559 = unqualified_name_lookup_error (postfix_expression);
4561 /* Peek at the next token. */
4562 token = cp_lexer_peek_token (parser->lexer);
4564 switch (token->type)
4566 case CPP_OPEN_SQUARE:
4568 = cp_parser_postfix_open_square_expression (parser,
4571 idk = CP_ID_KIND_NONE;
4572 is_member_access = false;
4575 case CPP_OPEN_PAREN:
4576 /* postfix-expression ( expression-list [opt] ) */
4579 bool is_builtin_constant_p;
4580 bool saved_integral_constant_expression_p = false;
4581 bool saved_non_integral_constant_expression_p = false;
4584 is_member_access = false;
4586 is_builtin_constant_p
4587 = DECL_IS_BUILTIN_CONSTANT_P (postfix_expression);
4588 if (is_builtin_constant_p)
4590 /* The whole point of __builtin_constant_p is to allow
4591 non-constant expressions to appear as arguments. */
4592 saved_integral_constant_expression_p
4593 = parser->integral_constant_expression_p;
4594 saved_non_integral_constant_expression_p
4595 = parser->non_integral_constant_expression_p;
4596 parser->integral_constant_expression_p = false;
4598 args = (cp_parser_parenthesized_expression_list
4599 (parser, /*is_attribute_list=*/false,
4600 /*cast_p=*/false, /*allow_expansion_p=*/true,
4601 /*non_constant_p=*/NULL));
4602 if (is_builtin_constant_p)
4604 parser->integral_constant_expression_p
4605 = saved_integral_constant_expression_p;
4606 parser->non_integral_constant_expression_p
4607 = saved_non_integral_constant_expression_p;
4610 if (args == error_mark_node)
4612 postfix_expression = error_mark_node;
4616 /* Function calls are not permitted in
4617 constant-expressions. */
4618 if (! builtin_valid_in_constant_expr_p (postfix_expression)
4619 && cp_parser_non_integral_constant_expression (parser,
4622 postfix_expression = error_mark_node;
4627 if (idk == CP_ID_KIND_UNQUALIFIED)
4629 if (TREE_CODE (postfix_expression) == IDENTIFIER_NODE)
4635 = perform_koenig_lookup (postfix_expression, args);
4639 = unqualified_fn_lookup_error (postfix_expression);
4641 /* We do not perform argument-dependent lookup if
4642 normal lookup finds a non-function, in accordance
4643 with the expected resolution of DR 218. */
4644 else if (args && is_overloaded_fn (postfix_expression))
4646 tree fn = get_first_fn (postfix_expression);
4648 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
4649 fn = OVL_CURRENT (TREE_OPERAND (fn, 0));
4651 /* Only do argument dependent lookup if regular
4652 lookup does not find a set of member functions.
4653 [basic.lookup.koenig]/2a */
4654 if (!DECL_FUNCTION_MEMBER_P (fn))
4658 = perform_koenig_lookup (postfix_expression, args);
4663 if (TREE_CODE (postfix_expression) == COMPONENT_REF)
4665 tree instance = TREE_OPERAND (postfix_expression, 0);
4666 tree fn = TREE_OPERAND (postfix_expression, 1);
4668 if (processing_template_decl
4669 && (type_dependent_expression_p (instance)
4670 || (!BASELINK_P (fn)
4671 && TREE_CODE (fn) != FIELD_DECL)
4672 || type_dependent_expression_p (fn)
4673 || any_type_dependent_arguments_p (args)))
4676 = build_nt_call_list (postfix_expression, args);
4680 if (BASELINK_P (fn))
4682 = (build_new_method_call
4683 (instance, fn, args, NULL_TREE,
4684 (idk == CP_ID_KIND_QUALIFIED
4685 ? LOOKUP_NONVIRTUAL : LOOKUP_NORMAL),
4687 tf_warning_or_error));
4690 = finish_call_expr (postfix_expression, args,
4691 /*disallow_virtual=*/false,
4693 tf_warning_or_error);
4695 else if (TREE_CODE (postfix_expression) == OFFSET_REF
4696 || TREE_CODE (postfix_expression) == MEMBER_REF
4697 || TREE_CODE (postfix_expression) == DOTSTAR_EXPR)
4698 postfix_expression = (build_offset_ref_call_from_tree
4699 (postfix_expression, args));
4700 else if (idk == CP_ID_KIND_QUALIFIED)
4701 /* A call to a static class member, or a namespace-scope
4704 = finish_call_expr (postfix_expression, args,
4705 /*disallow_virtual=*/true,
4707 tf_warning_or_error);
4709 /* All other function calls. */
4711 = finish_call_expr (postfix_expression, args,
4712 /*disallow_virtual=*/false,
4714 tf_warning_or_error);
4716 /* The POSTFIX_EXPRESSION is certainly no longer an id. */
4717 idk = CP_ID_KIND_NONE;
4723 /* postfix-expression . template [opt] id-expression
4724 postfix-expression . pseudo-destructor-name
4725 postfix-expression -> template [opt] id-expression
4726 postfix-expression -> pseudo-destructor-name */
4728 /* Consume the `.' or `->' operator. */
4729 cp_lexer_consume_token (parser->lexer);
4732 = cp_parser_postfix_dot_deref_expression (parser, token->type,
4736 is_member_access = true;
4740 /* postfix-expression ++ */
4741 /* Consume the `++' token. */
4742 cp_lexer_consume_token (parser->lexer);
4743 /* Generate a representation for the complete expression. */
4745 = finish_increment_expr (postfix_expression,
4746 POSTINCREMENT_EXPR);
4747 /* Increments may not appear in constant-expressions. */
4748 if (cp_parser_non_integral_constant_expression (parser,
4750 postfix_expression = error_mark_node;
4751 idk = CP_ID_KIND_NONE;
4752 is_member_access = false;
4755 case CPP_MINUS_MINUS:
4756 /* postfix-expression -- */
4757 /* Consume the `--' token. */
4758 cp_lexer_consume_token (parser->lexer);
4759 /* Generate a representation for the complete expression. */
4761 = finish_increment_expr (postfix_expression,
4762 POSTDECREMENT_EXPR);
4763 /* Decrements may not appear in constant-expressions. */
4764 if (cp_parser_non_integral_constant_expression (parser,
4766 postfix_expression = error_mark_node;
4767 idk = CP_ID_KIND_NONE;
4768 is_member_access = false;
4772 if (member_access_only_p)
4773 return is_member_access? postfix_expression : error_mark_node;
4775 return postfix_expression;
4779 /* We should never get here. */
4781 return error_mark_node;
4784 /* A subroutine of cp_parser_postfix_expression that also gets hijacked
4785 by cp_parser_builtin_offsetof. We're looking for
4787 postfix-expression [ expression ]
4789 FOR_OFFSETOF is set if we're being called in that context, which
4790 changes how we deal with integer constant expressions. */
4793 cp_parser_postfix_open_square_expression (cp_parser *parser,
4794 tree postfix_expression,
4799 /* Consume the `[' token. */
4800 cp_lexer_consume_token (parser->lexer);
4802 /* Parse the index expression. */
4803 /* ??? For offsetof, there is a question of what to allow here. If
4804 offsetof is not being used in an integral constant expression context,
4805 then we *could* get the right answer by computing the value at runtime.
4806 If we are in an integral constant expression context, then we might
4807 could accept any constant expression; hard to say without analysis.
4808 Rather than open the barn door too wide right away, allow only integer
4809 constant expressions here. */
4811 index = cp_parser_constant_expression (parser, false, NULL);
4813 index = cp_parser_expression (parser, /*cast_p=*/false);
4815 /* Look for the closing `]'. */
4816 cp_parser_require (parser, CPP_CLOSE_SQUARE, "%<]%>");
4818 /* Build the ARRAY_REF. */
4819 postfix_expression = grok_array_decl (postfix_expression, index);
4821 /* When not doing offsetof, array references are not permitted in
4822 constant-expressions. */
4824 && (cp_parser_non_integral_constant_expression
4825 (parser, "an array reference")))
4826 postfix_expression = error_mark_node;
4828 return postfix_expression;
4831 /* A subroutine of cp_parser_postfix_expression that also gets hijacked
4832 by cp_parser_builtin_offsetof. We're looking for
4834 postfix-expression . template [opt] id-expression
4835 postfix-expression . pseudo-destructor-name
4836 postfix-expression -> template [opt] id-expression
4837 postfix-expression -> pseudo-destructor-name
4839 FOR_OFFSETOF is set if we're being called in that context. That sorta
4840 limits what of the above we'll actually accept, but nevermind.
4841 TOKEN_TYPE is the "." or "->" token, which will already have been
4842 removed from the stream. */
4845 cp_parser_postfix_dot_deref_expression (cp_parser *parser,
4846 enum cpp_ttype token_type,
4847 tree postfix_expression,
4848 bool for_offsetof, cp_id_kind *idk)
4852 bool pseudo_destructor_p;
4853 tree scope = NULL_TREE;
4855 /* If this is a `->' operator, dereference the pointer. */
4856 if (token_type == CPP_DEREF)
4857 postfix_expression = build_x_arrow (postfix_expression);
4858 /* Check to see whether or not the expression is type-dependent. */
4859 dependent_p = type_dependent_expression_p (postfix_expression);
4860 /* The identifier following the `->' or `.' is not qualified. */
4861 parser->scope = NULL_TREE;
4862 parser->qualifying_scope = NULL_TREE;
4863 parser->object_scope = NULL_TREE;
4864 *idk = CP_ID_KIND_NONE;
4865 /* Enter the scope corresponding to the type of the object
4866 given by the POSTFIX_EXPRESSION. */
4867 if (!dependent_p && TREE_TYPE (postfix_expression) != NULL_TREE)
4869 scope = TREE_TYPE (postfix_expression);
4870 /* According to the standard, no expression should ever have
4871 reference type. Unfortunately, we do not currently match
4872 the standard in this respect in that our internal representation
4873 of an expression may have reference type even when the standard
4874 says it does not. Therefore, we have to manually obtain the
4875 underlying type here. */
4876 scope = non_reference (scope);
4877 /* The type of the POSTFIX_EXPRESSION must be complete. */
4878 if (scope == unknown_type_node)
4880 error ("%qE does not have class type", postfix_expression);
4884 scope = complete_type_or_else (scope, NULL_TREE);
4885 /* Let the name lookup machinery know that we are processing a
4886 class member access expression. */
4887 parser->context->object_type = scope;
4888 /* If something went wrong, we want to be able to discern that case,
4889 as opposed to the case where there was no SCOPE due to the type
4890 of expression being dependent. */
4892 scope = error_mark_node;
4893 /* If the SCOPE was erroneous, make the various semantic analysis
4894 functions exit quickly -- and without issuing additional error
4896 if (scope == error_mark_node)
4897 postfix_expression = error_mark_node;
4900 /* Assume this expression is not a pseudo-destructor access. */
4901 pseudo_destructor_p = false;
4903 /* If the SCOPE is a scalar type, then, if this is a valid program,
4904 we must be looking at a pseudo-destructor-name. If POSTFIX_EXPRESSION
4905 is type dependent, it can be pseudo-destructor-name or something else.
4906 Try to parse it as pseudo-destructor-name first. */
4907 if ((scope && SCALAR_TYPE_P (scope)) || dependent_p)
4912 cp_parser_parse_tentatively (parser);
4913 /* Parse the pseudo-destructor-name. */
4915 cp_parser_pseudo_destructor_name (parser, &s, &type);
4917 && (cp_parser_error_occurred (parser)
4918 || TREE_CODE (type) != TYPE_DECL
4919 || !SCALAR_TYPE_P (TREE_TYPE (type))))
4920 cp_parser_abort_tentative_parse (parser);
4921 else if (cp_parser_parse_definitely (parser))
4923 pseudo_destructor_p = true;
4925 = finish_pseudo_destructor_expr (postfix_expression,
4926 s, TREE_TYPE (type));
4930 if (!pseudo_destructor_p)
4932 /* If the SCOPE is not a scalar type, we are looking at an
4933 ordinary class member access expression, rather than a
4934 pseudo-destructor-name. */
4936 /* Parse the id-expression. */
4937 name = (cp_parser_id_expression
4939 cp_parser_optional_template_keyword (parser),
4940 /*check_dependency_p=*/true,
4942 /*declarator_p=*/false,
4943 /*optional_p=*/false));
4944 /* In general, build a SCOPE_REF if the member name is qualified.
4945 However, if the name was not dependent and has already been
4946 resolved; there is no need to build the SCOPE_REF. For example;
4948 struct X { void f(); };
4949 template <typename T> void f(T* t) { t->X::f(); }
4951 Even though "t" is dependent, "X::f" is not and has been resolved
4952 to a BASELINK; there is no need to include scope information. */
4954 /* But we do need to remember that there was an explicit scope for
4955 virtual function calls. */
4957 *idk = CP_ID_KIND_QUALIFIED;
4959 /* If the name is a template-id that names a type, we will get a
4960 TYPE_DECL here. That is invalid code. */
4961 if (TREE_CODE (name) == TYPE_DECL)
4963 error ("invalid use of %qD", name);
4964 postfix_expression = error_mark_node;
4968 if (name != error_mark_node && !BASELINK_P (name) && parser->scope)
4970 name = build_qualified_name (/*type=*/NULL_TREE,
4974 parser->scope = NULL_TREE;
4975 parser->qualifying_scope = NULL_TREE;
4976 parser->object_scope = NULL_TREE;
4978 if (scope && name && BASELINK_P (name))
4979 adjust_result_of_qualified_name_lookup
4980 (name, BINFO_TYPE (BASELINK_ACCESS_BINFO (name)), scope);
4982 = finish_class_member_access_expr (postfix_expression, name,
4984 tf_warning_or_error);
4988 /* We no longer need to look up names in the scope of the object on
4989 the left-hand side of the `.' or `->' operator. */
4990 parser->context->object_type = NULL_TREE;
4992 /* Outside of offsetof, these operators may not appear in
4993 constant-expressions. */
4995 && (cp_parser_non_integral_constant_expression
4996 (parser, token_type == CPP_DEREF ? "%<->%>" : "%<.%>")))
4997 postfix_expression = error_mark_node;
4999 return postfix_expression;
5002 /* Parse a parenthesized expression-list.
5005 assignment-expression
5006 expression-list, assignment-expression
5011 identifier, expression-list
5013 CAST_P is true if this expression is the target of a cast.
5015 ALLOW_EXPANSION_P is true if this expression allows expansion of an
5018 Returns a TREE_LIST. The TREE_VALUE of each node is a
5019 representation of an assignment-expression. Note that a TREE_LIST
5020 is returned even if there is only a single expression in the list.
5021 error_mark_node is returned if the ( and or ) are
5022 missing. NULL_TREE is returned on no expressions. The parentheses
5023 are eaten. IS_ATTRIBUTE_LIST is true if this is really an attribute
5024 list being parsed. If NON_CONSTANT_P is non-NULL, *NON_CONSTANT_P
5025 indicates whether or not all of the expressions in the list were
5029 cp_parser_parenthesized_expression_list (cp_parser* parser,
5030 bool is_attribute_list,
5032 bool allow_expansion_p,
5033 bool *non_constant_p)
5035 tree expression_list = NULL_TREE;
5036 bool fold_expr_p = is_attribute_list;
5037 tree identifier = NULL_TREE;
5038 bool saved_greater_than_is_operator_p;
5040 /* Assume all the expressions will be constant. */
5042 *non_constant_p = false;
5044 if (!cp_parser_require (parser, CPP_OPEN_PAREN, "%<(%>"))
5045 return error_mark_node;
5047 /* Within a parenthesized expression, a `>' token is always
5048 the greater-than operator. */
5049 saved_greater_than_is_operator_p
5050 = parser->greater_than_is_operator_p;
5051 parser->greater_than_is_operator_p = true;
5053 /* Consume expressions until there are no more. */
5054 if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
5059 /* At the beginning of attribute lists, check to see if the
5060 next token is an identifier. */
5061 if (is_attribute_list
5062 && cp_lexer_peek_token (parser->lexer)->type == CPP_NAME)
5066 /* Consume the identifier. */
5067 token = cp_lexer_consume_token (parser->lexer);
5068 /* Save the identifier. */
5069 identifier = token->u.value;
5073 /* Parse the next assignment-expression. */
5076 bool expr_non_constant_p;
5077 expr = (cp_parser_constant_expression
5078 (parser, /*allow_non_constant_p=*/true,
5079 &expr_non_constant_p));
5080 if (expr_non_constant_p)
5081 *non_constant_p = true;
5084 expr = cp_parser_assignment_expression (parser, cast_p);
5087 expr = fold_non_dependent_expr (expr);
5089 /* If we have an ellipsis, then this is an expression
5091 if (allow_expansion_p
5092 && cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
5094 /* Consume the `...'. */
5095 cp_lexer_consume_token (parser->lexer);
5097 /* Build the argument pack. */
5098 expr = make_pack_expansion (expr);
5101 /* Add it to the list. We add error_mark_node
5102 expressions to the list, so that we can still tell if
5103 the correct form for a parenthesized expression-list
5104 is found. That gives better errors. */
5105 expression_list = tree_cons (NULL_TREE, expr, expression_list);
5107 if (expr == error_mark_node)
5111 /* After the first item, attribute lists look the same as
5112 expression lists. */
5113 is_attribute_list = false;
5116 /* If the next token isn't a `,', then we are done. */
5117 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
5120 /* Otherwise, consume the `,' and keep going. */
5121 cp_lexer_consume_token (parser->lexer);
5124 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>"))
5129 /* We try and resync to an unnested comma, as that will give the
5130 user better diagnostics. */
5131 ending = cp_parser_skip_to_closing_parenthesis (parser,
5132 /*recovering=*/true,
5134 /*consume_paren=*/true);
5139 parser->greater_than_is_operator_p
5140 = saved_greater_than_is_operator_p;
5141 return error_mark_node;
5145 parser->greater_than_is_operator_p
5146 = saved_greater_than_is_operator_p;
5148 /* We built up the list in reverse order so we must reverse it now. */
5149 expression_list = nreverse (expression_list);
5151 expression_list = tree_cons (NULL_TREE, identifier, expression_list);
5153 return expression_list;
5156 /* Parse a pseudo-destructor-name.
5158 pseudo-destructor-name:
5159 :: [opt] nested-name-specifier [opt] type-name :: ~ type-name
5160 :: [opt] nested-name-specifier template template-id :: ~ type-name
5161 :: [opt] nested-name-specifier [opt] ~ type-name
5163 If either of the first two productions is used, sets *SCOPE to the
5164 TYPE specified before the final `::'. Otherwise, *SCOPE is set to
5165 NULL_TREE. *TYPE is set to the TYPE_DECL for the final type-name,
5166 or ERROR_MARK_NODE if the parse fails. */
5169 cp_parser_pseudo_destructor_name (cp_parser* parser,
5173 bool nested_name_specifier_p;
5175 /* Assume that things will not work out. */
5176 *type = error_mark_node;
5178 /* Look for the optional `::' operator. */
5179 cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/true);
5180 /* Look for the optional nested-name-specifier. */
5181 nested_name_specifier_p
5182 = (cp_parser_nested_name_specifier_opt (parser,
5183 /*typename_keyword_p=*/false,
5184 /*check_dependency_p=*/true,
5186 /*is_declaration=*/true)
5188 /* Now, if we saw a nested-name-specifier, we might be doing the
5189 second production. */
5190 if (nested_name_specifier_p
5191 && cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
5193 /* Consume the `template' keyword. */
5194 cp_lexer_consume_token (parser->lexer);
5195 /* Parse the template-id. */
5196 cp_parser_template_id (parser,
5197 /*template_keyword_p=*/true,
5198 /*check_dependency_p=*/false,
5199 /*is_declaration=*/true);
5200 /* Look for the `::' token. */
5201 cp_parser_require (parser, CPP_SCOPE, "%<::%>");
5203 /* If the next token is not a `~', then there might be some
5204 additional qualification. */
5205 else if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMPL))
5207 /* At this point, we're looking for "type-name :: ~". The type-name
5208 must not be a class-name, since this is a pseudo-destructor. So,
5209 it must be either an enum-name, or a typedef-name -- both of which
5210 are just identifiers. So, we peek ahead to check that the "::"
5211 and "~" tokens are present; if they are not, then we can avoid
5212 calling type_name. */
5213 if (cp_lexer_peek_token (parser->lexer)->type != CPP_NAME
5214 || cp_lexer_peek_nth_token (parser->lexer, 2)->type != CPP_SCOPE
5215 || cp_lexer_peek_nth_token (parser->lexer, 3)->type != CPP_COMPL)
5217 cp_parser_error (parser, "non-scalar type");
5221 /* Look for the type-name. */
5222 *scope = TREE_TYPE (cp_parser_nonclass_name (parser));
5223 if (*scope == error_mark_node)
5226 /* Look for the `::' token. */
5227 cp_parser_require (parser, CPP_SCOPE, "%<::%>");
5232 /* Look for the `~'. */
5233 cp_parser_require (parser, CPP_COMPL, "%<~%>");
5234 /* Look for the type-name again. We are not responsible for
5235 checking that it matches the first type-name. */
5236 *type = cp_parser_nonclass_name (parser);
5239 /* Parse a unary-expression.
5245 unary-operator cast-expression
5246 sizeof unary-expression
5254 __extension__ cast-expression
5255 __alignof__ unary-expression
5256 __alignof__ ( type-id )
5257 __real__ cast-expression
5258 __imag__ cast-expression
5261 ADDRESS_P is true iff the unary-expression is appearing as the
5262 operand of the `&' operator. CAST_P is true if this expression is
5263 the target of a cast.
5265 Returns a representation of the expression. */
5268 cp_parser_unary_expression (cp_parser *parser, bool address_p, bool cast_p)
5271 enum tree_code unary_operator;
5273 /* Peek at the next token. */
5274 token = cp_lexer_peek_token (parser->lexer);
5275 /* Some keywords give away the kind of expression. */
5276 if (token->type == CPP_KEYWORD)
5278 enum rid keyword = token->keyword;
5288 op = keyword == RID_ALIGNOF ? ALIGNOF_EXPR : SIZEOF_EXPR;
5289 /* Consume the token. */
5290 cp_lexer_consume_token (parser->lexer);
5291 /* Parse the operand. */
5292 operand = cp_parser_sizeof_operand (parser, keyword);
5294 if (TYPE_P (operand))
5295 return cxx_sizeof_or_alignof_type (operand, op, true);
5297 return cxx_sizeof_or_alignof_expr (operand, op, true);
5301 return cp_parser_new_expression (parser);
5304 return cp_parser_delete_expression (parser);
5308 /* The saved value of the PEDANTIC flag. */
5312 /* Save away the PEDANTIC flag. */
5313 cp_parser_extension_opt (parser, &saved_pedantic);
5314 /* Parse the cast-expression. */
5315 expr = cp_parser_simple_cast_expression (parser);
5316 /* Restore the PEDANTIC flag. */
5317 pedantic = saved_pedantic;
5327 /* Consume the `__real__' or `__imag__' token. */
5328 cp_lexer_consume_token (parser->lexer);
5329 /* Parse the cast-expression. */
5330 expression = cp_parser_simple_cast_expression (parser);
5331 /* Create the complete representation. */
5332 return build_x_unary_op ((keyword == RID_REALPART
5333 ? REALPART_EXPR : IMAGPART_EXPR),
5335 tf_warning_or_error);
5344 /* Look for the `:: new' and `:: delete', which also signal the
5345 beginning of a new-expression, or delete-expression,
5346 respectively. If the next token is `::', then it might be one of
5348 if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
5352 /* See if the token after the `::' is one of the keywords in
5353 which we're interested. */
5354 keyword = cp_lexer_peek_nth_token (parser->lexer, 2)->keyword;
5355 /* If it's `new', we have a new-expression. */
5356 if (keyword == RID_NEW)
5357 return cp_parser_new_expression (parser);
5358 /* Similarly, for `delete'. */
5359 else if (keyword == RID_DELETE)
5360 return cp_parser_delete_expression (parser);
5363 /* Look for a unary operator. */
5364 unary_operator = cp_parser_unary_operator (token);
5365 /* The `++' and `--' operators can be handled similarly, even though
5366 they are not technically unary-operators in the grammar. */
5367 if (unary_operator == ERROR_MARK)
5369 if (token->type == CPP_PLUS_PLUS)
5370 unary_operator = PREINCREMENT_EXPR;
5371 else if (token->type == CPP_MINUS_MINUS)
5372 unary_operator = PREDECREMENT_EXPR;
5373 /* Handle the GNU address-of-label extension. */
5374 else if (cp_parser_allow_gnu_extensions_p (parser)
5375 && token->type == CPP_AND_AND)
5380 /* Consume the '&&' token. */
5381 cp_lexer_consume_token (parser->lexer);
5382 /* Look for the identifier. */
5383 identifier = cp_parser_identifier (parser);
5384 /* Create an expression representing the address. */
5385 expression = finish_label_address_expr (identifier);
5386 if (cp_parser_non_integral_constant_expression (parser,
5387 "the address of a label"))
5388 expression = error_mark_node;
5392 if (unary_operator != ERROR_MARK)
5394 tree cast_expression;
5395 tree expression = error_mark_node;
5396 const char *non_constant_p = NULL;
5398 /* Consume the operator token. */
5399 token = cp_lexer_consume_token (parser->lexer);
5400 /* Parse the cast-expression. */
5402 = cp_parser_cast_expression (parser,
5403 unary_operator == ADDR_EXPR,
5405 /* Now, build an appropriate representation. */
5406 switch (unary_operator)
5409 non_constant_p = "%<*%>";
5410 expression = build_x_indirect_ref (cast_expression, "unary *",
5411 tf_warning_or_error);
5415 non_constant_p = "%<&%>";
5418 expression = build_x_unary_op (unary_operator, cast_expression,
5419 tf_warning_or_error);
5422 case PREINCREMENT_EXPR:
5423 case PREDECREMENT_EXPR:
5424 non_constant_p = (unary_operator == PREINCREMENT_EXPR
5425 ? "%<++%>" : "%<--%>");
5427 case UNARY_PLUS_EXPR:
5429 case TRUTH_NOT_EXPR:
5430 expression = finish_unary_op_expr (unary_operator, cast_expression);
5438 && cp_parser_non_integral_constant_expression (parser,
5440 expression = error_mark_node;
5445 return cp_parser_postfix_expression (parser, address_p, cast_p,
5446 /*member_access_only_p=*/false);
5449 /* Returns ERROR_MARK if TOKEN is not a unary-operator. If TOKEN is a
5450 unary-operator, the corresponding tree code is returned. */
5452 static enum tree_code
5453 cp_parser_unary_operator (cp_token* token)
5455 switch (token->type)
5458 return INDIRECT_REF;
5464 return UNARY_PLUS_EXPR;
5470 return TRUTH_NOT_EXPR;
5473 return BIT_NOT_EXPR;
5480 /* Parse a new-expression.
5483 :: [opt] new new-placement [opt] new-type-id new-initializer [opt]
5484 :: [opt] new new-placement [opt] ( type-id ) new-initializer [opt]
5486 Returns a representation of the expression. */
5489 cp_parser_new_expression (cp_parser* parser)
5491 bool global_scope_p;
5497 /* Look for the optional `::' operator. */
5499 = (cp_parser_global_scope_opt (parser,
5500 /*current_scope_valid_p=*/false)
5502 /* Look for the `new' operator. */
5503 cp_parser_require_keyword (parser, RID_NEW, "%<new%>");
5504 /* There's no easy way to tell a new-placement from the
5505 `( type-id )' construct. */
5506 cp_parser_parse_tentatively (parser);
5507 /* Look for a new-placement. */
5508 placement = cp_parser_new_placement (parser);
5509 /* If that didn't work out, there's no new-placement. */
5510 if (!cp_parser_parse_definitely (parser))
5511 placement = NULL_TREE;
5513 /* If the next token is a `(', then we have a parenthesized
5515 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
5517 /* Consume the `('. */
5518 cp_lexer_consume_token (parser->lexer);
5519 /* Parse the type-id. */
5520 type = cp_parser_type_id (parser);
5521 /* Look for the closing `)'. */
5522 cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>");
5523 /* There should not be a direct-new-declarator in this production,
5524 but GCC used to allowed this, so we check and emit a sensible error
5525 message for this case. */
5526 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
5528 error ("array bound forbidden after parenthesized type-id");
5529 inform ("try removing the parentheses around the type-id");
5530 cp_parser_direct_new_declarator (parser);
5534 /* Otherwise, there must be a new-type-id. */
5536 type = cp_parser_new_type_id (parser, &nelts);
5538 /* If the next token is a `(', then we have a new-initializer. */
5539 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
5540 initializer = cp_parser_new_initializer (parser);
5542 initializer = NULL_TREE;
5544 /* A new-expression may not appear in an integral constant
5546 if (cp_parser_non_integral_constant_expression (parser, "%<new%>"))
5547 return error_mark_node;
5549 /* Create a representation of the new-expression. */
5550 return build_new (placement, type, nelts, initializer, global_scope_p,
5551 tf_warning_or_error);
5554 /* Parse a new-placement.
5559 Returns the same representation as for an expression-list. */
5562 cp_parser_new_placement (cp_parser* parser)
5564 tree expression_list;
5566 /* Parse the expression-list. */
5567 expression_list = (cp_parser_parenthesized_expression_list
5568 (parser, false, /*cast_p=*/false, /*allow_expansion_p=*/true,
5569 /*non_constant_p=*/NULL));
5571 return expression_list;
5574 /* Parse a new-type-id.
5577 type-specifier-seq new-declarator [opt]
5579 Returns the TYPE allocated. If the new-type-id indicates an array
5580 type, *NELTS is set to the number of elements in the last array
5581 bound; the TYPE will not include the last array bound. */
5584 cp_parser_new_type_id (cp_parser* parser, tree *nelts)
5586 cp_decl_specifier_seq type_specifier_seq;
5587 cp_declarator *new_declarator;
5588 cp_declarator *declarator;
5589 cp_declarator *outer_declarator;
5590 const char *saved_message;
5593 /* The type-specifier sequence must not contain type definitions.
5594 (It cannot contain declarations of new types either, but if they
5595 are not definitions we will catch that because they are not
5597 saved_message = parser->type_definition_forbidden_message;
5598 parser->type_definition_forbidden_message
5599 = "types may not be defined in a new-type-id";
5600 /* Parse the type-specifier-seq. */
5601 cp_parser_type_specifier_seq (parser, /*is_condition=*/false,
5602 &type_specifier_seq);
5603 /* Restore the old message. */
5604 parser->type_definition_forbidden_message = saved_message;
5605 /* Parse the new-declarator. */
5606 new_declarator = cp_parser_new_declarator_opt (parser);
5608 /* Determine the number of elements in the last array dimension, if
5611 /* Skip down to the last array dimension. */
5612 declarator = new_declarator;
5613 outer_declarator = NULL;
5614 while (declarator && (declarator->kind == cdk_pointer
5615 || declarator->kind == cdk_ptrmem))
5617 outer_declarator = declarator;
5618 declarator = declarator->declarator;
5621 && declarator->kind == cdk_array
5622 && declarator->declarator
5623 && declarator->declarator->kind == cdk_array)
5625 outer_declarator = declarator;
5626 declarator = declarator->declarator;
5629 if (declarator && declarator->kind == cdk_array)
5631 *nelts = declarator->u.array.bounds;
5632 if (*nelts == error_mark_node)
5633 *nelts = integer_one_node;
5635 if (outer_declarator)
5636 outer_declarator->declarator = declarator->declarator;
5638 new_declarator = NULL;
5641 type = groktypename (&type_specifier_seq, new_declarator);
5645 /* Parse an (optional) new-declarator.
5648 ptr-operator new-declarator [opt]
5649 direct-new-declarator
5651 Returns the declarator. */
5653 static cp_declarator *
5654 cp_parser_new_declarator_opt (cp_parser* parser)
5656 enum tree_code code;
5658 cp_cv_quals cv_quals;
5660 /* We don't know if there's a ptr-operator next, or not. */
5661 cp_parser_parse_tentatively (parser);
5662 /* Look for a ptr-operator. */
5663 code = cp_parser_ptr_operator (parser, &type, &cv_quals);
5664 /* If that worked, look for more new-declarators. */
5665 if (cp_parser_parse_definitely (parser))
5667 cp_declarator *declarator;
5669 /* Parse another optional declarator. */
5670 declarator = cp_parser_new_declarator_opt (parser);
5672 return cp_parser_make_indirect_declarator
5673 (code, type, cv_quals, declarator);
5676 /* If the next token is a `[', there is a direct-new-declarator. */
5677 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
5678 return cp_parser_direct_new_declarator (parser);
5683 /* Parse a direct-new-declarator.
5685 direct-new-declarator:
5687 direct-new-declarator [constant-expression]
5691 static cp_declarator *
5692 cp_parser_direct_new_declarator (cp_parser* parser)
5694 cp_declarator *declarator = NULL;
5700 /* Look for the opening `['. */
5701 cp_parser_require (parser, CPP_OPEN_SQUARE, "%<[%>");
5702 /* The first expression is not required to be constant. */
5705 expression = cp_parser_expression (parser, /*cast_p=*/false);
5706 /* The standard requires that the expression have integral
5707 type. DR 74 adds enumeration types. We believe that the
5708 real intent is that these expressions be handled like the
5709 expression in a `switch' condition, which also allows
5710 classes with a single conversion to integral or
5711 enumeration type. */
5712 if (!processing_template_decl)
5715 = build_expr_type_conversion (WANT_INT | WANT_ENUM,
5720 error ("expression in new-declarator must have integral "
5721 "or enumeration type");
5722 expression = error_mark_node;
5726 /* But all the other expressions must be. */
5729 = cp_parser_constant_expression (parser,
5730 /*allow_non_constant=*/false,
5732 /* Look for the closing `]'. */
5733 cp_parser_require (parser, CPP_CLOSE_SQUARE, "%<]%>");
5735 /* Add this bound to the declarator. */
5736 declarator = make_array_declarator (declarator, expression);
5738 /* If the next token is not a `[', then there are no more
5740 if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_SQUARE))
5747 /* Parse a new-initializer.
5750 ( expression-list [opt] )
5752 Returns a representation of the expression-list. If there is no
5753 expression-list, VOID_ZERO_NODE is returned. */
5756 cp_parser_new_initializer (cp_parser* parser)
5758 tree expression_list;
5760 expression_list = (cp_parser_parenthesized_expression_list
5761 (parser, false, /*cast_p=*/false, /*allow_expansion_p=*/true,
5762 /*non_constant_p=*/NULL));
5763 if (!expression_list)
5764 expression_list = void_zero_node;
5766 return expression_list;
5769 /* Parse a delete-expression.
5772 :: [opt] delete cast-expression
5773 :: [opt] delete [ ] cast-expression
5775 Returns a representation of the expression. */
5778 cp_parser_delete_expression (cp_parser* parser)
5780 bool global_scope_p;
5784 /* Look for the optional `::' operator. */
5786 = (cp_parser_global_scope_opt (parser,
5787 /*current_scope_valid_p=*/false)
5789 /* Look for the `delete' keyword. */
5790 cp_parser_require_keyword (parser, RID_DELETE, "%<delete%>");
5791 /* See if the array syntax is in use. */
5792 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
5794 /* Consume the `[' token. */
5795 cp_lexer_consume_token (parser->lexer);
5796 /* Look for the `]' token. */
5797 cp_parser_require (parser, CPP_CLOSE_SQUARE, "%<]%>");
5798 /* Remember that this is the `[]' construct. */
5804 /* Parse the cast-expression. */
5805 expression = cp_parser_simple_cast_expression (parser);
5807 /* A delete-expression may not appear in an integral constant
5809 if (cp_parser_non_integral_constant_expression (parser, "%<delete%>"))
5810 return error_mark_node;
5812 return delete_sanity (expression, NULL_TREE, array_p, global_scope_p);
5815 /* Parse a cast-expression.
5819 ( type-id ) cast-expression
5821 ADDRESS_P is true iff the unary-expression is appearing as the
5822 operand of the `&' operator. CAST_P is true if this expression is
5823 the target of a cast.
5825 Returns a representation of the expression. */
5828 cp_parser_cast_expression (cp_parser *parser, bool address_p, bool cast_p)
5830 /* If it's a `(', then we might be looking at a cast. */
5831 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
5833 tree type = NULL_TREE;
5834 tree expr = NULL_TREE;
5835 bool compound_literal_p;
5836 const char *saved_message;
5838 /* There's no way to know yet whether or not this is a cast.
5839 For example, `(int (3))' is a unary-expression, while `(int)
5840 3' is a cast. So, we resort to parsing tentatively. */
5841 cp_parser_parse_tentatively (parser);
5842 /* Types may not be defined in a cast. */
5843 saved_message = parser->type_definition_forbidden_message;
5844 parser->type_definition_forbidden_message
5845 = "types may not be defined in casts";
5846 /* Consume the `('. */
5847 cp_lexer_consume_token (parser->lexer);
5848 /* A very tricky bit is that `(struct S) { 3 }' is a
5849 compound-literal (which we permit in C++ as an extension).
5850 But, that construct is not a cast-expression -- it is a
5851 postfix-expression. (The reason is that `(struct S) { 3 }.i'
5852 is legal; if the compound-literal were a cast-expression,
5853 you'd need an extra set of parentheses.) But, if we parse
5854 the type-id, and it happens to be a class-specifier, then we
5855 will commit to the parse at that point, because we cannot
5856 undo the action that is done when creating a new class. So,
5857 then we cannot back up and do a postfix-expression.
5859 Therefore, we scan ahead to the closing `)', and check to see
5860 if the token after the `)' is a `{'. If so, we are not
5861 looking at a cast-expression.
5863 Save tokens so that we can put them back. */
5864 cp_lexer_save_tokens (parser->lexer);
5865 /* Skip tokens until the next token is a closing parenthesis.
5866 If we find the closing `)', and the next token is a `{', then
5867 we are looking at a compound-literal. */
5869 = (cp_parser_skip_to_closing_parenthesis (parser, false, false,
5870 /*consume_paren=*/true)
5871 && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE));
5872 /* Roll back the tokens we skipped. */
5873 cp_lexer_rollback_tokens (parser->lexer);
5874 /* If we were looking at a compound-literal, simulate an error
5875 so that the call to cp_parser_parse_definitely below will
5877 if (compound_literal_p)
5878 cp_parser_simulate_error (parser);
5881 bool saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p;
5882 parser->in_type_id_in_expr_p = true;
5883 /* Look for the type-id. */
5884 type = cp_parser_type_id (parser);
5885 /* Look for the closing `)'. */
5886 cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>");
5887 parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
5890 /* Restore the saved message. */
5891 parser->type_definition_forbidden_message = saved_message;
5893 /* If ok so far, parse the dependent expression. We cannot be
5894 sure it is a cast. Consider `(T ())'. It is a parenthesized
5895 ctor of T, but looks like a cast to function returning T
5896 without a dependent expression. */
5897 if (!cp_parser_error_occurred (parser))
5898 expr = cp_parser_cast_expression (parser,
5899 /*address_p=*/false,
5902 if (cp_parser_parse_definitely (parser))
5904 /* Warn about old-style casts, if so requested. */
5905 if (warn_old_style_cast
5906 && !in_system_header
5907 && !VOID_TYPE_P (type)
5908 && current_lang_name != lang_name_c)
5909 warning (OPT_Wold_style_cast, "use of old-style cast");
5911 /* Only type conversions to integral or enumeration types
5912 can be used in constant-expressions. */
5913 if (!cast_valid_in_integral_constant_expression_p (type)
5914 && (cp_parser_non_integral_constant_expression
5916 "a cast to a type other than an integral or "
5917 "enumeration type")))
5918 return error_mark_node;
5920 /* Perform the cast. */
5921 expr = build_c_cast (type, expr);
5926 /* If we get here, then it's not a cast, so it must be a
5927 unary-expression. */
5928 return cp_parser_unary_expression (parser, address_p, cast_p);
5931 /* Parse a binary expression of the general form:
5935 pm-expression .* cast-expression
5936 pm-expression ->* cast-expression
5938 multiplicative-expression:
5940 multiplicative-expression * pm-expression
5941 multiplicative-expression / pm-expression
5942 multiplicative-expression % pm-expression
5944 additive-expression:
5945 multiplicative-expression
5946 additive-expression + multiplicative-expression
5947 additive-expression - multiplicative-expression
5951 shift-expression << additive-expression
5952 shift-expression >> additive-expression
5954 relational-expression:
5956 relational-expression < shift-expression
5957 relational-expression > shift-expression
5958 relational-expression <= shift-expression
5959 relational-expression >= shift-expression
5963 relational-expression:
5964 relational-expression <? shift-expression
5965 relational-expression >? shift-expression
5967 equality-expression:
5968 relational-expression
5969 equality-expression == relational-expression
5970 equality-expression != relational-expression
5974 and-expression & equality-expression
5976 exclusive-or-expression:
5978 exclusive-or-expression ^ and-expression
5980 inclusive-or-expression:
5981 exclusive-or-expression
5982 inclusive-or-expression | exclusive-or-expression
5984 logical-and-expression:
5985 inclusive-or-expression
5986 logical-and-expression && inclusive-or-expression
5988 logical-or-expression:
5989 logical-and-expression
5990 logical-or-expression || logical-and-expression
5992 All these are implemented with a single function like:
5995 simple-cast-expression
5996 binary-expression <token> binary-expression
5998 CAST_P is true if this expression is the target of a cast.
6000 The binops_by_token map is used to get the tree codes for each <token> type.
6001 binary-expressions are associated according to a precedence table. */
6003 #define TOKEN_PRECEDENCE(token) \
6004 (((token->type == CPP_GREATER \
6005 || ((cxx_dialect != cxx98) && token->type == CPP_RSHIFT)) \
6006 && !parser->greater_than_is_operator_p) \
6007 ? PREC_NOT_OPERATOR \
6008 : binops_by_token[token->type].prec)
6011 cp_parser_binary_expression (cp_parser* parser, bool cast_p,
6012 enum cp_parser_prec prec)
6014 cp_parser_expression_stack stack;
6015 cp_parser_expression_stack_entry *sp = &stack[0];
6018 enum tree_code tree_type, lhs_type, rhs_type;
6019 enum cp_parser_prec new_prec, lookahead_prec;
6022 /* Parse the first expression. */
6023 lhs = cp_parser_cast_expression (parser, /*address_p=*/false, cast_p);
6024 lhs_type = ERROR_MARK;
6028 /* Get an operator token. */
6029 token = cp_lexer_peek_token (parser->lexer);
6031 if (warn_cxx0x_compat
6032 && token->type == CPP_RSHIFT
6033 && !parser->greater_than_is_operator_p)
6035 warning (OPT_Wc__0x_compat,
6036 "%H%<>>%> operator will be treated as two right angle brackets in C++0x",
6038 warning (OPT_Wc__0x_compat,
6039 "suggest parentheses around %<>>%> expression");
6042 new_prec = TOKEN_PRECEDENCE (token);
6044 /* Popping an entry off the stack means we completed a subexpression:
6045 - either we found a token which is not an operator (`>' where it is not
6046 an operator, or prec == PREC_NOT_OPERATOR), in which case popping
6047 will happen repeatedly;
6048 - or, we found an operator which has lower priority. This is the case
6049 where the recursive descent *ascends*, as in `3 * 4 + 5' after
6051 if (new_prec <= prec)
6060 tree_type = binops_by_token[token->type].tree_type;
6062 /* We used the operator token. */
6063 cp_lexer_consume_token (parser->lexer);
6065 /* Extract another operand. It may be the RHS of this expression
6066 or the LHS of a new, higher priority expression. */
6067 rhs = cp_parser_simple_cast_expression (parser);
6068 rhs_type = ERROR_MARK;
6070 /* Get another operator token. Look up its precedence to avoid
6071 building a useless (immediately popped) stack entry for common
6072 cases such as 3 + 4 + 5 or 3 * 4 + 5. */
6073 token = cp_lexer_peek_token (parser->lexer);
6074 lookahead_prec = TOKEN_PRECEDENCE (token);
6075 if (lookahead_prec > new_prec)
6077 /* ... and prepare to parse the RHS of the new, higher priority
6078 expression. Since precedence levels on the stack are
6079 monotonically increasing, we do not have to care about
6082 sp->tree_type = tree_type;
6084 sp->lhs_type = lhs_type;
6087 lhs_type = rhs_type;
6089 new_prec = lookahead_prec;
6093 /* If the stack is not empty, we have parsed into LHS the right side
6094 (`4' in the example above) of an expression we had suspended.
6095 We can use the information on the stack to recover the LHS (`3')
6096 from the stack together with the tree code (`MULT_EXPR'), and
6097 the precedence of the higher level subexpression
6098 (`PREC_ADDITIVE_EXPRESSION'). TOKEN is the CPP_PLUS token,
6099 which will be used to actually build the additive expression. */
6102 tree_type = sp->tree_type;
6104 rhs_type = lhs_type;
6106 lhs_type = sp->lhs_type;
6109 overloaded_p = false;
6110 lhs = build_x_binary_op (tree_type, lhs, lhs_type, rhs, rhs_type,
6111 &overloaded_p, tf_warning_or_error);
6112 lhs_type = tree_type;
6114 /* If the binary operator required the use of an overloaded operator,
6115 then this expression cannot be an integral constant-expression.
6116 An overloaded operator can be used even if both operands are
6117 otherwise permissible in an integral constant-expression if at
6118 least one of the operands is of enumeration type. */
6121 && (cp_parser_non_integral_constant_expression
6122 (parser, "calls to overloaded operators")))
6123 return error_mark_node;
6130 /* Parse the `? expression : assignment-expression' part of a
6131 conditional-expression. The LOGICAL_OR_EXPR is the
6132 logical-or-expression that started the conditional-expression.
6133 Returns a representation of the entire conditional-expression.
6135 This routine is used by cp_parser_assignment_expression.
6137 ? expression : assignment-expression
6141 ? : assignment-expression */
6144 cp_parser_question_colon_clause (cp_parser* parser, tree logical_or_expr)
6147 tree assignment_expr;
6149 /* Consume the `?' token. */
6150 cp_lexer_consume_token (parser->lexer);
6151 if (cp_parser_allow_gnu_extensions_p (parser)
6152 && cp_lexer_next_token_is (parser->lexer, CPP_COLON))
6153 /* Implicit true clause. */
6156 /* Parse the expression. */
6157 expr = cp_parser_expression (parser, /*cast_p=*/false);
6159 /* The next token should be a `:'. */
6160 cp_parser_require (parser, CPP_COLON, "%<:%>");
6161 /* Parse the assignment-expression. */
6162 assignment_expr = cp_parser_assignment_expression (parser, /*cast_p=*/false);
6164 /* Build the conditional-expression. */
6165 return build_x_conditional_expr (logical_or_expr,
6168 tf_warning_or_error);
6171 /* Parse an assignment-expression.
6173 assignment-expression:
6174 conditional-expression
6175 logical-or-expression assignment-operator assignment_expression
6178 CAST_P is true if this expression is the target of a cast.
6180 Returns a representation for the expression. */
6183 cp_parser_assignment_expression (cp_parser* parser, bool cast_p)
6187 /* If the next token is the `throw' keyword, then we're looking at
6188 a throw-expression. */
6189 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_THROW))
6190 expr = cp_parser_throw_expression (parser);
6191 /* Otherwise, it must be that we are looking at a
6192 logical-or-expression. */
6195 /* Parse the binary expressions (logical-or-expression). */
6196 expr = cp_parser_binary_expression (parser, cast_p, PREC_NOT_OPERATOR);
6197 /* If the next token is a `?' then we're actually looking at a
6198 conditional-expression. */
6199 if (cp_lexer_next_token_is (parser->lexer, CPP_QUERY))
6200 return cp_parser_question_colon_clause (parser, expr);
6203 enum tree_code assignment_operator;
6205 /* If it's an assignment-operator, we're using the second
6208 = cp_parser_assignment_operator_opt (parser);
6209 if (assignment_operator != ERROR_MARK)
6213 /* Parse the right-hand side of the assignment. */
6214 rhs = cp_parser_assignment_expression (parser, cast_p);
6215 /* An assignment may not appear in a
6216 constant-expression. */
6217 if (cp_parser_non_integral_constant_expression (parser,
6219 return error_mark_node;
6220 /* Build the assignment expression. */
6221 expr = build_x_modify_expr (expr,
6222 assignment_operator,
6224 tf_warning_or_error);
6232 /* Parse an (optional) assignment-operator.
6234 assignment-operator: one of
6235 = *= /= %= += -= >>= <<= &= ^= |=
6239 assignment-operator: one of
6242 If the next token is an assignment operator, the corresponding tree
6243 code is returned, and the token is consumed. For example, for
6244 `+=', PLUS_EXPR is returned. For `=' itself, the code returned is
6245 NOP_EXPR. For `/', TRUNC_DIV_EXPR is returned; for `%',
6246 TRUNC_MOD_EXPR is returned. If TOKEN is not an assignment
6247 operator, ERROR_MARK is returned. */
6249 static enum tree_code
6250 cp_parser_assignment_operator_opt (cp_parser* parser)
6255 /* Peek at the next toen. */
6256 token = cp_lexer_peek_token (parser->lexer);
6258 switch (token->type)
6269 op = TRUNC_DIV_EXPR;
6273 op = TRUNC_MOD_EXPR;
6305 /* Nothing else is an assignment operator. */
6309 /* If it was an assignment operator, consume it. */
6310 if (op != ERROR_MARK)
6311 cp_lexer_consume_token (parser->lexer);
6316 /* Parse an expression.
6319 assignment-expression
6320 expression , assignment-expression
6322 CAST_P is true if this expression is the target of a cast.
6324 Returns a representation of the expression. */
6327 cp_parser_expression (cp_parser* parser, bool cast_p)
6329 tree expression = NULL_TREE;
6333 tree assignment_expression;
6335 /* Parse the next assignment-expression. */
6336 assignment_expression
6337 = cp_parser_assignment_expression (parser, cast_p);
6338 /* If this is the first assignment-expression, we can just
6341 expression = assignment_expression;
6343 expression = build_x_compound_expr (expression,
6344 assignment_expression,
6345 tf_warning_or_error);
6346 /* If the next token is not a comma, then we are done with the
6348 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
6350 /* Consume the `,'. */
6351 cp_lexer_consume_token (parser->lexer);
6352 /* A comma operator cannot appear in a constant-expression. */
6353 if (cp_parser_non_integral_constant_expression (parser,
6354 "a comma operator"))
6355 expression = error_mark_node;
6361 /* Parse a constant-expression.
6363 constant-expression:
6364 conditional-expression
6366 If ALLOW_NON_CONSTANT_P a non-constant expression is silently
6367 accepted. If ALLOW_NON_CONSTANT_P is true and the expression is not
6368 constant, *NON_CONSTANT_P is set to TRUE. If ALLOW_NON_CONSTANT_P
6369 is false, NON_CONSTANT_P should be NULL. */
6372 cp_parser_constant_expression (cp_parser* parser,
6373 bool allow_non_constant_p,
6374 bool *non_constant_p)
6376 bool saved_integral_constant_expression_p;
6377 bool saved_allow_non_integral_constant_expression_p;
6378 bool saved_non_integral_constant_expression_p;
6381 /* It might seem that we could simply parse the
6382 conditional-expression, and then check to see if it were
6383 TREE_CONSTANT. However, an expression that is TREE_CONSTANT is
6384 one that the compiler can figure out is constant, possibly after
6385 doing some simplifications or optimizations. The standard has a
6386 precise definition of constant-expression, and we must honor
6387 that, even though it is somewhat more restrictive.
6393 is not a legal declaration, because `(2, 3)' is not a
6394 constant-expression. The `,' operator is forbidden in a
6395 constant-expression. However, GCC's constant-folding machinery
6396 will fold this operation to an INTEGER_CST for `3'. */
6398 /* Save the old settings. */
6399 saved_integral_constant_expression_p = parser->integral_constant_expression_p;
6400 saved_allow_non_integral_constant_expression_p
6401 = parser->allow_non_integral_constant_expression_p;
6402 saved_non_integral_constant_expression_p = parser->non_integral_constant_expression_p;
6403 /* We are now parsing a constant-expression. */
6404 parser->integral_constant_expression_p = true;
6405 parser->allow_non_integral_constant_expression_p = allow_non_constant_p;
6406 parser->non_integral_constant_expression_p = false;
6407 /* Although the grammar says "conditional-expression", we parse an
6408 "assignment-expression", which also permits "throw-expression"
6409 and the use of assignment operators. In the case that
6410 ALLOW_NON_CONSTANT_P is false, we get better errors than we would
6411 otherwise. In the case that ALLOW_NON_CONSTANT_P is true, it is
6412 actually essential that we look for an assignment-expression.
6413 For example, cp_parser_initializer_clauses uses this function to
6414 determine whether a particular assignment-expression is in fact
6416 expression = cp_parser_assignment_expression (parser, /*cast_p=*/false);
6417 /* Restore the old settings. */
6418 parser->integral_constant_expression_p
6419 = saved_integral_constant_expression_p;
6420 parser->allow_non_integral_constant_expression_p
6421 = saved_allow_non_integral_constant_expression_p;
6422 if (allow_non_constant_p)
6423 *non_constant_p = parser->non_integral_constant_expression_p;
6424 else if (parser->non_integral_constant_expression_p)
6425 expression = error_mark_node;
6426 parser->non_integral_constant_expression_p
6427 = saved_non_integral_constant_expression_p;
6432 /* Parse __builtin_offsetof.
6434 offsetof-expression:
6435 "__builtin_offsetof" "(" type-id "," offsetof-member-designator ")"
6437 offsetof-member-designator:
6439 | offsetof-member-designator "." id-expression
6440 | offsetof-member-designator "[" expression "]" */
6443 cp_parser_builtin_offsetof (cp_parser *parser)
6445 int save_ice_p, save_non_ice_p;
6449 /* We're about to accept non-integral-constant things, but will
6450 definitely yield an integral constant expression. Save and
6451 restore these values around our local parsing. */
6452 save_ice_p = parser->integral_constant_expression_p;
6453 save_non_ice_p = parser->non_integral_constant_expression_p;
6455 /* Consume the "__builtin_offsetof" token. */
6456 cp_lexer_consume_token (parser->lexer);
6457 /* Consume the opening `('. */
6458 cp_parser_require (parser, CPP_OPEN_PAREN, "%<(%>");
6459 /* Parse the type-id. */
6460 type = cp_parser_type_id (parser);
6461 /* Look for the `,'. */
6462 cp_parser_require (parser, CPP_COMMA, "%<,%>");
6464 /* Build the (type *)null that begins the traditional offsetof macro. */
6465 expr = build_static_cast (build_pointer_type (type), null_pointer_node,
6466 tf_warning_or_error);
6468 /* Parse the offsetof-member-designator. We begin as if we saw "expr->". */
6469 expr = cp_parser_postfix_dot_deref_expression (parser, CPP_DEREF, expr,
6473 cp_token *token = cp_lexer_peek_token (parser->lexer);
6474 switch (token->type)
6476 case CPP_OPEN_SQUARE:
6477 /* offsetof-member-designator "[" expression "]" */
6478 expr = cp_parser_postfix_open_square_expression (parser, expr, true);
6482 /* offsetof-member-designator "." identifier */
6483 cp_lexer_consume_token (parser->lexer);
6484 expr = cp_parser_postfix_dot_deref_expression (parser, CPP_DOT, expr,
6488 case CPP_CLOSE_PAREN:
6489 /* Consume the ")" token. */
6490 cp_lexer_consume_token (parser->lexer);
6494 /* Error. We know the following require will fail, but
6495 that gives the proper error message. */
6496 cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>");
6497 cp_parser_skip_to_closing_parenthesis (parser, true, false, true);
6498 expr = error_mark_node;
6504 /* If we're processing a template, we can't finish the semantics yet.
6505 Otherwise we can fold the entire expression now. */
6506 if (processing_template_decl)
6507 expr = build1 (OFFSETOF_EXPR, size_type_node, expr);
6509 expr = finish_offsetof (expr);
6512 parser->integral_constant_expression_p = save_ice_p;
6513 parser->non_integral_constant_expression_p = save_non_ice_p;
6518 /* Parse a trait expression. */
6521 cp_parser_trait_expr (cp_parser* parser, enum rid keyword)
6524 tree type1, type2 = NULL_TREE;
6525 bool binary = false;
6526 cp_decl_specifier_seq decl_specs;
6530 case RID_HAS_NOTHROW_ASSIGN:
6531 kind = CPTK_HAS_NOTHROW_ASSIGN;
6533 case RID_HAS_NOTHROW_CONSTRUCTOR:
6534 kind = CPTK_HAS_NOTHROW_CONSTRUCTOR;
6536 case RID_HAS_NOTHROW_COPY:
6537 kind = CPTK_HAS_NOTHROW_COPY;
6539 case RID_HAS_TRIVIAL_ASSIGN:
6540 kind = CPTK_HAS_TRIVIAL_ASSIGN;
6542 case RID_HAS_TRIVIAL_CONSTRUCTOR:
6543 kind = CPTK_HAS_TRIVIAL_CONSTRUCTOR;
6545 case RID_HAS_TRIVIAL_COPY:
6546 kind = CPTK_HAS_TRIVIAL_COPY;
6548 case RID_HAS_TRIVIAL_DESTRUCTOR:
6549 kind = CPTK_HAS_TRIVIAL_DESTRUCTOR;
6551 case RID_HAS_VIRTUAL_DESTRUCTOR:
6552 kind = CPTK_HAS_VIRTUAL_DESTRUCTOR;
6554 case RID_IS_ABSTRACT:
6555 kind = CPTK_IS_ABSTRACT;
6557 case RID_IS_BASE_OF:
6558 kind = CPTK_IS_BASE_OF;
6562 kind = CPTK_IS_CLASS;
6564 case RID_IS_CONVERTIBLE_TO:
6565 kind = CPTK_IS_CONVERTIBLE_TO;
6569 kind = CPTK_IS_EMPTY;
6572 kind = CPTK_IS_ENUM;
6577 case RID_IS_POLYMORPHIC:
6578 kind = CPTK_IS_POLYMORPHIC;
6581 kind = CPTK_IS_UNION;
6587 /* Consume the token. */
6588 cp_lexer_consume_token (parser->lexer);
6590 cp_parser_require (parser, CPP_OPEN_PAREN, "%<(%>");
6592 type1 = cp_parser_type_id (parser);
6594 if (type1 == error_mark_node)
6595 return error_mark_node;
6597 /* Build a trivial decl-specifier-seq. */
6598 clear_decl_specs (&decl_specs);
6599 decl_specs.type = type1;
6601 /* Call grokdeclarator to figure out what type this is. */
6602 type1 = grokdeclarator (NULL, &decl_specs, TYPENAME,
6603 /*initialized=*/0, /*attrlist=*/NULL);
6607 cp_parser_require (parser, CPP_COMMA, "%<,%>");
6609 type2 = cp_parser_type_id (parser);
6611 if (type2 == error_mark_node)
6612 return error_mark_node;
6614 /* Build a trivial decl-specifier-seq. */
6615 clear_decl_specs (&decl_specs);
6616 decl_specs.type = type2;
6618 /* Call grokdeclarator to figure out what type this is. */
6619 type2 = grokdeclarator (NULL, &decl_specs, TYPENAME,
6620 /*initialized=*/0, /*attrlist=*/NULL);
6623 cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>");
6625 /* Complete the trait expression, which may mean either processing
6626 the trait expr now or saving it for template instantiation. */
6627 return finish_trait_expr (kind, type1, type2);
6630 /* Statements [gram.stmt.stmt] */
6632 /* Parse a statement.
6636 expression-statement
6641 declaration-statement
6644 IN_COMPOUND is true when the statement is nested inside a
6645 cp_parser_compound_statement; this matters for certain pragmas.
6647 If IF_P is not NULL, *IF_P is set to indicate whether the statement
6648 is a (possibly labeled) if statement which is not enclosed in braces
6649 and has an else clause. This is used to implement -Wparentheses. */
6652 cp_parser_statement (cp_parser* parser, tree in_statement_expr,
6653 bool in_compound, bool *if_p)
6657 location_t statement_location;
6662 /* There is no statement yet. */
6663 statement = NULL_TREE;
6664 /* Peek at the next token. */
6665 token = cp_lexer_peek_token (parser->lexer);
6666 /* Remember the location of the first token in the statement. */
6667 statement_location = token->location;
6668 /* If this is a keyword, then that will often determine what kind of
6669 statement we have. */
6670 if (token->type == CPP_KEYWORD)
6672 enum rid keyword = token->keyword;
6678 /* Looks like a labeled-statement with a case label.
6679 Parse the label, and then use tail recursion to parse
6681 cp_parser_label_for_labeled_statement (parser);
6686 statement = cp_parser_selection_statement (parser, if_p);
6692 statement = cp_parser_iteration_statement (parser);
6699 statement = cp_parser_jump_statement (parser);
6702 /* Objective-C++ exception-handling constructs. */
6705 case RID_AT_FINALLY:
6706 case RID_AT_SYNCHRONIZED:
6708 statement = cp_parser_objc_statement (parser);
6712 statement = cp_parser_try_block (parser);
6716 /* This must be a namespace alias definition. */
6717 cp_parser_declaration_statement (parser);
6721 /* It might be a keyword like `int' that can start a
6722 declaration-statement. */
6726 else if (token->type == CPP_NAME)
6728 /* If the next token is a `:', then we are looking at a
6729 labeled-statement. */
6730 token = cp_lexer_peek_nth_token (parser->lexer, 2);
6731 if (token->type == CPP_COLON)
6733 /* Looks like a labeled-statement with an ordinary label.
6734 Parse the label, and then use tail recursion to parse
6736 cp_parser_label_for_labeled_statement (parser);
6740 /* Anything that starts with a `{' must be a compound-statement. */
6741 else if (token->type == CPP_OPEN_BRACE)
6742 statement = cp_parser_compound_statement (parser, NULL, false);
6743 /* CPP_PRAGMA is a #pragma inside a function body, which constitutes
6744 a statement all its own. */
6745 else if (token->type == CPP_PRAGMA)
6747 /* Only certain OpenMP pragmas are attached to statements, and thus
6748 are considered statements themselves. All others are not. In
6749 the context of a compound, accept the pragma as a "statement" and
6750 return so that we can check for a close brace. Otherwise we
6751 require a real statement and must go back and read one. */
6753 cp_parser_pragma (parser, pragma_compound);
6754 else if (!cp_parser_pragma (parser, pragma_stmt))
6758 else if (token->type == CPP_EOF)
6760 cp_parser_error (parser, "expected statement");
6764 /* Everything else must be a declaration-statement or an
6765 expression-statement. Try for the declaration-statement
6766 first, unless we are looking at a `;', in which case we know that
6767 we have an expression-statement. */
6770 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
6772 cp_parser_parse_tentatively (parser);
6773 /* Try to parse the declaration-statement. */
6774 cp_parser_declaration_statement (parser);
6775 /* If that worked, we're done. */
6776 if (cp_parser_parse_definitely (parser))
6779 /* Look for an expression-statement instead. */
6780 statement = cp_parser_expression_statement (parser, in_statement_expr);
6783 /* Set the line number for the statement. */
6784 if (statement && STATEMENT_CODE_P (TREE_CODE (statement)))
6785 SET_EXPR_LOCATION (statement, statement_location);
6788 /* Parse the label for a labeled-statement, i.e.
6791 case constant-expression :
6795 case constant-expression ... constant-expression : statement
6797 When a label is parsed without errors, the label is added to the
6798 parse tree by the finish_* functions, so this function doesn't
6799 have to return the label. */
6802 cp_parser_label_for_labeled_statement (cp_parser* parser)
6806 /* The next token should be an identifier. */
6807 token = cp_lexer_peek_token (parser->lexer);
6808 if (token->type != CPP_NAME
6809 && token->type != CPP_KEYWORD)
6811 cp_parser_error (parser, "expected labeled-statement");
6815 switch (token->keyword)
6822 /* Consume the `case' token. */
6823 cp_lexer_consume_token (parser->lexer);
6824 /* Parse the constant-expression. */
6825 expr = cp_parser_constant_expression (parser,
6826 /*allow_non_constant_p=*/false,
6829 ellipsis = cp_lexer_peek_token (parser->lexer);
6830 if (ellipsis->type == CPP_ELLIPSIS)
6832 /* Consume the `...' token. */
6833 cp_lexer_consume_token (parser->lexer);
6835 cp_parser_constant_expression (parser,
6836 /*allow_non_constant_p=*/false,
6838 /* We don't need to emit warnings here, as the common code
6839 will do this for us. */
6842 expr_hi = NULL_TREE;
6844 if (parser->in_switch_statement_p)
6845 finish_case_label (expr, expr_hi);
6847 error ("case label %qE not within a switch statement", expr);
6852 /* Consume the `default' token. */
6853 cp_lexer_consume_token (parser->lexer);
6855 if (parser->in_switch_statement_p)
6856 finish_case_label (NULL_TREE, NULL_TREE);
6858 error ("case label not within a switch statement");
6862 /* Anything else must be an ordinary label. */
6863 finish_label_stmt (cp_parser_identifier (parser));
6867 /* Require the `:' token. */
6868 cp_parser_require (parser, CPP_COLON, "%<:%>");
6871 /* Parse an expression-statement.
6873 expression-statement:
6876 Returns the new EXPR_STMT -- or NULL_TREE if the expression
6877 statement consists of nothing more than an `;'. IN_STATEMENT_EXPR_P
6878 indicates whether this expression-statement is part of an
6879 expression statement. */
6882 cp_parser_expression_statement (cp_parser* parser, tree in_statement_expr)
6884 tree statement = NULL_TREE;
6886 /* If the next token is a ';', then there is no expression
6888 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
6889 statement = cp_parser_expression (parser, /*cast_p=*/false);
6891 /* Consume the final `;'. */
6892 cp_parser_consume_semicolon_at_end_of_statement (parser);
6894 if (in_statement_expr
6895 && cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
6896 /* This is the final expression statement of a statement
6898 statement = finish_stmt_expr_expr (statement, in_statement_expr);
6900 statement = finish_expr_stmt (statement);
6907 /* Parse a compound-statement.
6910 { statement-seq [opt] }
6915 { label-declaration-seq [opt] statement-seq [opt] }
6917 label-declaration-seq:
6919 label-declaration-seq label-declaration
6921 Returns a tree representing the statement. */
6924 cp_parser_compound_statement (cp_parser *parser, tree in_statement_expr,
6929 /* Consume the `{'. */
6930 if (!cp_parser_require (parser, CPP_OPEN_BRACE, "%<{%>"))
6931 return error_mark_node;
6932 /* Begin the compound-statement. */
6933 compound_stmt = begin_compound_stmt (in_try ? BCS_TRY_BLOCK : 0);
6934 /* If the next keyword is `__label__' we have a label declaration. */
6935 while (cp_lexer_next_token_is_keyword (parser->lexer, RID_LABEL))
6936 cp_parser_label_declaration (parser);
6937 /* Parse an (optional) statement-seq. */
6938 cp_parser_statement_seq_opt (parser, in_statement_expr);
6939 /* Finish the compound-statement. */
6940 finish_compound_stmt (compound_stmt);
6941 /* Consume the `}'. */
6942 cp_parser_require (parser, CPP_CLOSE_BRACE, "%<}%>");
6944 return compound_stmt;
6947 /* Parse an (optional) statement-seq.
6951 statement-seq [opt] statement */
6954 cp_parser_statement_seq_opt (cp_parser* parser, tree in_statement_expr)
6956 /* Scan statements until there aren't any more. */
6959 cp_token *token = cp_lexer_peek_token (parser->lexer);
6961 /* If we're looking at a `}', then we've run out of statements. */
6962 if (token->type == CPP_CLOSE_BRACE
6963 || token->type == CPP_EOF
6964 || token->type == CPP_PRAGMA_EOL)
6967 /* If we are in a compound statement and find 'else' then
6968 something went wrong. */
6969 else if (token->type == CPP_KEYWORD && token->keyword == RID_ELSE)
6971 if (parser->in_statement & IN_IF_STMT)
6975 token = cp_lexer_consume_token (parser->lexer);
6976 error ("%<else%> without a previous %<if%>");
6980 /* Parse the statement. */
6981 cp_parser_statement (parser, in_statement_expr, true, NULL);
6985 /* Parse a selection-statement.
6987 selection-statement:
6988 if ( condition ) statement
6989 if ( condition ) statement else statement
6990 switch ( condition ) statement
6992 Returns the new IF_STMT or SWITCH_STMT.
6994 If IF_P is not NULL, *IF_P is set to indicate whether the statement
6995 is a (possibly labeled) if statement which is not enclosed in
6996 braces and has an else clause. This is used to implement
7000 cp_parser_selection_statement (cp_parser* parser, bool *if_p)
7008 /* Peek at the next token. */
7009 token = cp_parser_require (parser, CPP_KEYWORD, "selection-statement");
7011 /* See what kind of keyword it is. */
7012 keyword = token->keyword;
7021 /* Look for the `('. */
7022 if (!cp_parser_require (parser, CPP_OPEN_PAREN, "%<(%>"))
7024 cp_parser_skip_to_end_of_statement (parser);
7025 return error_mark_node;
7028 /* Begin the selection-statement. */
7029 if (keyword == RID_IF)
7030 statement = begin_if_stmt ();
7032 statement = begin_switch_stmt ();
7034 /* Parse the condition. */
7035 condition = cp_parser_condition (parser);
7036 /* Look for the `)'. */
7037 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>"))
7038 cp_parser_skip_to_closing_parenthesis (parser, true, false,
7039 /*consume_paren=*/true);
7041 if (keyword == RID_IF)
7044 unsigned char in_statement;
7046 /* Add the condition. */
7047 finish_if_stmt_cond (condition, statement);
7049 /* Parse the then-clause. */
7050 in_statement = parser->in_statement;
7051 parser->in_statement |= IN_IF_STMT;
7052 cp_parser_implicitly_scoped_statement (parser, &nested_if);
7053 parser->in_statement = in_statement;
7055 finish_then_clause (statement);
7057 /* If the next token is `else', parse the else-clause. */
7058 if (cp_lexer_next_token_is_keyword (parser->lexer,
7061 /* Consume the `else' keyword. */
7062 cp_lexer_consume_token (parser->lexer);
7063 begin_else_clause (statement);
7064 /* Parse the else-clause. */
7065 cp_parser_implicitly_scoped_statement (parser, NULL);
7066 finish_else_clause (statement);
7068 /* If we are currently parsing a then-clause, then
7069 IF_P will not be NULL. We set it to true to
7070 indicate that this if statement has an else clause.
7071 This may trigger the Wparentheses warning below
7072 when we get back up to the parent if statement. */
7078 /* This if statement does not have an else clause. If
7079 NESTED_IF is true, then the then-clause is an if
7080 statement which does have an else clause. We warn
7081 about the potential ambiguity. */
7083 warning (OPT_Wparentheses,
7084 ("%Hsuggest explicit braces "
7085 "to avoid ambiguous %<else%>"),
7086 EXPR_LOCUS (statement));
7089 /* Now we're all done with the if-statement. */
7090 finish_if_stmt (statement);
7094 bool in_switch_statement_p;
7095 unsigned char in_statement;
7097 /* Add the condition. */
7098 finish_switch_cond (condition, statement);
7100 /* Parse the body of the switch-statement. */
7101 in_switch_statement_p = parser->in_switch_statement_p;
7102 in_statement = parser->in_statement;
7103 parser->in_switch_statement_p = true;
7104 parser->in_statement |= IN_SWITCH_STMT;
7105 cp_parser_implicitly_scoped_statement (parser, NULL);
7106 parser->in_switch_statement_p = in_switch_statement_p;
7107 parser->in_statement = in_statement;
7109 /* Now we're all done with the switch-statement. */
7110 finish_switch_stmt (statement);
7118 cp_parser_error (parser, "expected selection-statement");
7119 return error_mark_node;
7123 /* Parse a condition.
7127 type-specifier-seq declarator = assignment-expression
7132 type-specifier-seq declarator asm-specification [opt]
7133 attributes [opt] = assignment-expression
7135 Returns the expression that should be tested. */
7138 cp_parser_condition (cp_parser* parser)
7140 cp_decl_specifier_seq type_specifiers;
7141 const char *saved_message;
7143 /* Try the declaration first. */
7144 cp_parser_parse_tentatively (parser);
7145 /* New types are not allowed in the type-specifier-seq for a
7147 saved_message = parser->type_definition_forbidden_message;
7148 parser->type_definition_forbidden_message
7149 = "types may not be defined in conditions";
7150 /* Parse the type-specifier-seq. */
7151 cp_parser_type_specifier_seq (parser, /*is_condition==*/true,
7153 /* Restore the saved message. */
7154 parser->type_definition_forbidden_message = saved_message;
7155 /* If all is well, we might be looking at a declaration. */
7156 if (!cp_parser_error_occurred (parser))
7159 tree asm_specification;
7161 cp_declarator *declarator;
7162 tree initializer = NULL_TREE;
7164 /* Parse the declarator. */
7165 declarator = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
7166 /*ctor_dtor_or_conv_p=*/NULL,
7167 /*parenthesized_p=*/NULL,
7168 /*member_p=*/false);
7169 /* Parse the attributes. */
7170 attributes = cp_parser_attributes_opt (parser);
7171 /* Parse the asm-specification. */
7172 asm_specification = cp_parser_asm_specification_opt (parser);
7173 /* If the next token is not an `=', then we might still be
7174 looking at an expression. For example:
7178 looks like a decl-specifier-seq and a declarator -- but then
7179 there is no `=', so this is an expression. */
7180 cp_parser_require (parser, CPP_EQ, "%<=%>");
7181 /* If we did see an `=', then we are looking at a declaration
7183 if (cp_parser_parse_definitely (parser))
7186 bool non_constant_p;
7188 /* Create the declaration. */
7189 decl = start_decl (declarator, &type_specifiers,
7190 /*initialized_p=*/true,
7191 attributes, /*prefix_attributes=*/NULL_TREE,
7193 /* Parse the assignment-expression. */
7195 = cp_parser_constant_expression (parser,
7196 /*allow_non_constant_p=*/true,
7198 if (!non_constant_p)
7199 initializer = fold_non_dependent_expr (initializer);
7201 /* Process the initializer. */
7202 cp_finish_decl (decl,
7203 initializer, !non_constant_p,
7205 LOOKUP_ONLYCONVERTING);
7208 pop_scope (pushed_scope);
7210 return convert_from_reference (decl);
7213 /* If we didn't even get past the declarator successfully, we are
7214 definitely not looking at a declaration. */
7216 cp_parser_abort_tentative_parse (parser);
7218 /* Otherwise, we are looking at an expression. */
7219 return cp_parser_expression (parser, /*cast_p=*/false);
7222 /* We check for a ) immediately followed by ; with no whitespacing
7223 between. This is used to issue a warning for:
7231 as the semicolon is probably extraneous.
7233 On parse errors, the next token might not be a ), so do nothing in
7237 check_empty_body (cp_parser* parser, const char* type)
7240 cp_token *close_paren;
7241 expanded_location close_loc;
7242 expanded_location semi_loc;
7244 close_paren = cp_lexer_peek_token (parser->lexer);
7245 if (close_paren->type != CPP_CLOSE_PAREN)
7248 close_loc = expand_location (close_paren->location);
7249 token = cp_lexer_peek_nth_token (parser->lexer, 2);
7251 if (token->type != CPP_SEMICOLON
7252 || (token->flags & PREV_WHITE))
7255 semi_loc = expand_location (token->location);
7256 if (close_loc.line == semi_loc.line
7257 && close_loc.column+1 == semi_loc.column)
7258 warning (OPT_Wempty_body,
7259 "suggest a space before %<;%> or explicit braces around empty "
7260 "body in %<%s%> statement",
7264 /* Parse an iteration-statement.
7266 iteration-statement:
7267 while ( condition ) statement
7268 do statement while ( expression ) ;
7269 for ( for-init-statement condition [opt] ; expression [opt] )
7272 Returns the new WHILE_STMT, DO_STMT, or FOR_STMT. */
7275 cp_parser_iteration_statement (cp_parser* parser)
7280 unsigned char in_statement;
7282 /* Peek at the next token. */
7283 token = cp_parser_require (parser, CPP_KEYWORD, "iteration-statement");
7285 return error_mark_node;
7287 /* Remember whether or not we are already within an iteration
7289 in_statement = parser->in_statement;
7291 /* See what kind of keyword it is. */
7292 keyword = token->keyword;
7299 /* Begin the while-statement. */
7300 statement = begin_while_stmt ();
7301 /* Look for the `('. */
7302 cp_parser_require (parser, CPP_OPEN_PAREN, "%<(%>");
7303 /* Parse the condition. */
7304 condition = cp_parser_condition (parser);
7305 finish_while_stmt_cond (condition, statement);
7306 check_empty_body (parser, "while");
7307 /* Look for the `)'. */
7308 cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>");
7309 /* Parse the dependent statement. */
7310 parser->in_statement = IN_ITERATION_STMT;
7311 cp_parser_already_scoped_statement (parser);
7312 parser->in_statement = in_statement;
7313 /* We're done with the while-statement. */
7314 finish_while_stmt (statement);
7322 /* Begin the do-statement. */
7323 statement = begin_do_stmt ();
7324 /* Parse the body of the do-statement. */
7325 parser->in_statement = IN_ITERATION_STMT;
7326 cp_parser_implicitly_scoped_statement (parser, NULL);
7327 parser->in_statement = in_statement;
7328 finish_do_body (statement);
7329 /* Look for the `while' keyword. */
7330 cp_parser_require_keyword (parser, RID_WHILE, "%<while%>");
7331 /* Look for the `('. */
7332 cp_parser_require (parser, CPP_OPEN_PAREN, "%<(%>");
7333 /* Parse the expression. */
7334 expression = cp_parser_expression (parser, /*cast_p=*/false);
7335 /* We're done with the do-statement. */
7336 finish_do_stmt (expression, statement);
7337 /* Look for the `)'. */
7338 cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>");
7339 /* Look for the `;'. */
7340 cp_parser_require (parser, CPP_SEMICOLON, "%<;%>");
7346 tree condition = NULL_TREE;
7347 tree expression = NULL_TREE;
7349 /* Begin the for-statement. */
7350 statement = begin_for_stmt ();
7351 /* Look for the `('. */
7352 cp_parser_require (parser, CPP_OPEN_PAREN, "%<(%>");
7353 /* Parse the initialization. */
7354 cp_parser_for_init_statement (parser);
7355 finish_for_init_stmt (statement);
7357 /* If there's a condition, process it. */
7358 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
7359 condition = cp_parser_condition (parser);
7360 finish_for_cond (condition, statement);
7361 /* Look for the `;'. */
7362 cp_parser_require (parser, CPP_SEMICOLON, "%<;%>");
7364 /* If there's an expression, process it. */
7365 if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
7366 expression = cp_parser_expression (parser, /*cast_p=*/false);
7367 finish_for_expr (expression, statement);
7368 check_empty_body (parser, "for");
7369 /* Look for the `)'. */
7370 cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>");
7372 /* Parse the body of the for-statement. */
7373 parser->in_statement = IN_ITERATION_STMT;
7374 cp_parser_already_scoped_statement (parser);
7375 parser->in_statement = in_statement;
7377 /* We're done with the for-statement. */
7378 finish_for_stmt (statement);
7383 cp_parser_error (parser, "expected iteration-statement");
7384 statement = error_mark_node;
7391 /* Parse a for-init-statement.
7394 expression-statement
7395 simple-declaration */
7398 cp_parser_for_init_statement (cp_parser* parser)
7400 /* If the next token is a `;', then we have an empty
7401 expression-statement. Grammatically, this is also a
7402 simple-declaration, but an invalid one, because it does not
7403 declare anything. Therefore, if we did not handle this case
7404 specially, we would issue an error message about an invalid
7406 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
7408 /* We're going to speculatively look for a declaration, falling back
7409 to an expression, if necessary. */
7410 cp_parser_parse_tentatively (parser);
7411 /* Parse the declaration. */
7412 cp_parser_simple_declaration (parser,
7413 /*function_definition_allowed_p=*/false);
7414 /* If the tentative parse failed, then we shall need to look for an
7415 expression-statement. */
7416 if (cp_parser_parse_definitely (parser))
7420 cp_parser_expression_statement (parser, false);
7423 /* Parse a jump-statement.
7428 return expression [opt] ;
7436 Returns the new BREAK_STMT, CONTINUE_STMT, RETURN_EXPR, or GOTO_EXPR. */
7439 cp_parser_jump_statement (cp_parser* parser)
7441 tree statement = error_mark_node;
7444 unsigned char in_statement;
7446 /* Peek at the next token. */
7447 token = cp_parser_require (parser, CPP_KEYWORD, "jump-statement");
7449 return error_mark_node;
7451 /* See what kind of keyword it is. */
7452 keyword = token->keyword;
7456 in_statement = parser->in_statement & ~IN_IF_STMT;
7457 switch (in_statement)
7460 error ("break statement not within loop or switch");
7463 gcc_assert ((in_statement & IN_SWITCH_STMT)
7464 || in_statement == IN_ITERATION_STMT);
7465 statement = finish_break_stmt ();
7468 error ("invalid exit from OpenMP structured block");
7471 error ("break statement used with OpenMP for loop");
7474 cp_parser_require (parser, CPP_SEMICOLON, "%<;%>");
7478 switch (parser->in_statement & ~(IN_SWITCH_STMT | IN_IF_STMT))
7481 error ("continue statement not within a loop");
7483 case IN_ITERATION_STMT:
7485 statement = finish_continue_stmt ();
7488 error ("invalid exit from OpenMP structured block");
7493 cp_parser_require (parser, CPP_SEMICOLON, "%<;%>");
7500 /* If the next token is a `;', then there is no
7502 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
7503 expr = cp_parser_expression (parser, /*cast_p=*/false);
7506 /* Build the return-statement. */
7507 statement = finish_return_stmt (expr);
7508 /* Look for the final `;'. */
7509 cp_parser_require (parser, CPP_SEMICOLON, "%<;%>");
7514 /* Create the goto-statement. */
7515 if (cp_lexer_next_token_is (parser->lexer, CPP_MULT))
7517 /* Issue a warning about this use of a GNU extension. */
7519 pedwarn ("ISO C++ forbids computed gotos");
7520 /* Consume the '*' token. */
7521 cp_lexer_consume_token (parser->lexer);
7522 /* Parse the dependent expression. */
7523 finish_goto_stmt (cp_parser_expression (parser, /*cast_p=*/false));
7526 finish_goto_stmt (cp_parser_identifier (parser));
7527 /* Look for the final `;'. */
7528 cp_parser_require (parser, CPP_SEMICOLON, "%<;%>");
7532 cp_parser_error (parser, "expected jump-statement");
7539 /* Parse a declaration-statement.
7541 declaration-statement:
7542 block-declaration */
7545 cp_parser_declaration_statement (cp_parser* parser)
7549 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
7550 p = obstack_alloc (&declarator_obstack, 0);
7552 /* Parse the block-declaration. */
7553 cp_parser_block_declaration (parser, /*statement_p=*/true);
7555 /* Free any declarators allocated. */
7556 obstack_free (&declarator_obstack, p);
7558 /* Finish off the statement. */
7562 /* Some dependent statements (like `if (cond) statement'), are
7563 implicitly in their own scope. In other words, if the statement is
7564 a single statement (as opposed to a compound-statement), it is
7565 none-the-less treated as if it were enclosed in braces. Any
7566 declarations appearing in the dependent statement are out of scope
7567 after control passes that point. This function parses a statement,
7568 but ensures that is in its own scope, even if it is not a
7571 If IF_P is not NULL, *IF_P is set to indicate whether the statement
7572 is a (possibly labeled) if statement which is not enclosed in
7573 braces and has an else clause. This is used to implement
7576 Returns the new statement. */
7579 cp_parser_implicitly_scoped_statement (cp_parser* parser, bool *if_p)
7586 /* Mark if () ; with a special NOP_EXPR. */
7587 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
7589 cp_lexer_consume_token (parser->lexer);
7590 statement = add_stmt (build_empty_stmt ());
7592 /* if a compound is opened, we simply parse the statement directly. */
7593 else if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
7594 statement = cp_parser_compound_statement (parser, NULL, false);
7595 /* If the token is not a `{', then we must take special action. */
7598 /* Create a compound-statement. */
7599 statement = begin_compound_stmt (0);
7600 /* Parse the dependent-statement. */
7601 cp_parser_statement (parser, NULL_TREE, false, if_p);
7602 /* Finish the dummy compound-statement. */
7603 finish_compound_stmt (statement);
7606 /* Return the statement. */
7610 /* For some dependent statements (like `while (cond) statement'), we
7611 have already created a scope. Therefore, even if the dependent
7612 statement is a compound-statement, we do not want to create another
7616 cp_parser_already_scoped_statement (cp_parser* parser)
7618 /* If the token is a `{', then we must take special action. */
7619 if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE))
7620 cp_parser_statement (parser, NULL_TREE, false, NULL);
7623 /* Avoid calling cp_parser_compound_statement, so that we
7624 don't create a new scope. Do everything else by hand. */
7625 cp_parser_require (parser, CPP_OPEN_BRACE, "%<{%>");
7626 cp_parser_statement_seq_opt (parser, NULL_TREE);
7627 cp_parser_require (parser, CPP_CLOSE_BRACE, "%<}%>");
7631 /* Declarations [gram.dcl.dcl] */
7633 /* Parse an optional declaration-sequence.
7637 declaration-seq declaration */
7640 cp_parser_declaration_seq_opt (cp_parser* parser)
7646 token = cp_lexer_peek_token (parser->lexer);
7648 if (token->type == CPP_CLOSE_BRACE
7649 || token->type == CPP_EOF
7650 || token->type == CPP_PRAGMA_EOL)
7653 if (token->type == CPP_SEMICOLON)
7655 /* A declaration consisting of a single semicolon is
7656 invalid. Allow it unless we're being pedantic. */
7657 cp_lexer_consume_token (parser->lexer);
7658 if (pedantic && !in_system_header)
7659 pedwarn ("extra %<;%>");
7663 /* If we're entering or exiting a region that's implicitly
7664 extern "C", modify the lang context appropriately. */
7665 if (!parser->implicit_extern_c && token->implicit_extern_c)
7667 push_lang_context (lang_name_c);
7668 parser->implicit_extern_c = true;
7670 else if (parser->implicit_extern_c && !token->implicit_extern_c)
7672 pop_lang_context ();
7673 parser->implicit_extern_c = false;
7676 if (token->type == CPP_PRAGMA)
7678 /* A top-level declaration can consist solely of a #pragma.
7679 A nested declaration cannot, so this is done here and not
7680 in cp_parser_declaration. (A #pragma at block scope is
7681 handled in cp_parser_statement.) */
7682 cp_parser_pragma (parser, pragma_external);
7686 /* Parse the declaration itself. */
7687 cp_parser_declaration (parser);
7691 /* Parse a declaration.
7696 template-declaration
7697 explicit-instantiation
7698 explicit-specialization
7699 linkage-specification
7700 namespace-definition
7705 __extension__ declaration */
7708 cp_parser_declaration (cp_parser* parser)
7715 /* Check for the `__extension__' keyword. */
7716 if (cp_parser_extension_opt (parser, &saved_pedantic))
7718 /* Parse the qualified declaration. */
7719 cp_parser_declaration (parser);
7720 /* Restore the PEDANTIC flag. */
7721 pedantic = saved_pedantic;
7726 /* Try to figure out what kind of declaration is present. */
7727 token1 = *cp_lexer_peek_token (parser->lexer);
7729 if (token1.type != CPP_EOF)
7730 token2 = *cp_lexer_peek_nth_token (parser->lexer, 2);
7733 token2.type = CPP_EOF;
7734 token2.keyword = RID_MAX;
7737 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
7738 p = obstack_alloc (&declarator_obstack, 0);
7740 /* If the next token is `extern' and the following token is a string
7741 literal, then we have a linkage specification. */
7742 if (token1.keyword == RID_EXTERN
7743 && cp_parser_is_string_literal (&token2))
7744 cp_parser_linkage_specification (parser);
7745 /* If the next token is `template', then we have either a template
7746 declaration, an explicit instantiation, or an explicit
7748 else if (token1.keyword == RID_TEMPLATE)
7750 /* `template <>' indicates a template specialization. */
7751 if (token2.type == CPP_LESS
7752 && cp_lexer_peek_nth_token (parser->lexer, 3)->type == CPP_GREATER)
7753 cp_parser_explicit_specialization (parser);
7754 /* `template <' indicates a template declaration. */
7755 else if (token2.type == CPP_LESS)
7756 cp_parser_template_declaration (parser, /*member_p=*/false);
7757 /* Anything else must be an explicit instantiation. */
7759 cp_parser_explicit_instantiation (parser);
7761 /* If the next token is `export', then we have a template
7763 else if (token1.keyword == RID_EXPORT)
7764 cp_parser_template_declaration (parser, /*member_p=*/false);
7765 /* If the next token is `extern', 'static' or 'inline' and the one
7766 after that is `template', we have a GNU extended explicit
7767 instantiation directive. */
7768 else if (cp_parser_allow_gnu_extensions_p (parser)
7769 && (token1.keyword == RID_EXTERN
7770 || token1.keyword == RID_STATIC
7771 || token1.keyword == RID_INLINE)
7772 && token2.keyword == RID_TEMPLATE)
7773 cp_parser_explicit_instantiation (parser);
7774 /* If the next token is `namespace', check for a named or unnamed
7775 namespace definition. */
7776 else if (token1.keyword == RID_NAMESPACE
7777 && (/* A named namespace definition. */
7778 (token2.type == CPP_NAME
7779 && (cp_lexer_peek_nth_token (parser->lexer, 3)->type
7781 /* An unnamed namespace definition. */
7782 || token2.type == CPP_OPEN_BRACE
7783 || token2.keyword == RID_ATTRIBUTE))
7784 cp_parser_namespace_definition (parser);
7785 /* An inline (associated) namespace definition. */
7786 else if (token1.keyword == RID_INLINE
7787 && token2.keyword == RID_NAMESPACE)
7788 cp_parser_namespace_definition (parser);
7789 /* Objective-C++ declaration/definition. */
7790 else if (c_dialect_objc () && OBJC_IS_AT_KEYWORD (token1.keyword))
7791 cp_parser_objc_declaration (parser);
7792 /* We must have either a block declaration or a function
7795 /* Try to parse a block-declaration, or a function-definition. */
7796 cp_parser_block_declaration (parser, /*statement_p=*/false);
7798 /* Free any declarators allocated. */
7799 obstack_free (&declarator_obstack, p);
7802 /* Parse a block-declaration.
7807 namespace-alias-definition
7814 __extension__ block-declaration
7819 static_assert-declaration
7821 If STATEMENT_P is TRUE, then this block-declaration is occurring as
7822 part of a declaration-statement. */
7825 cp_parser_block_declaration (cp_parser *parser,
7831 /* Check for the `__extension__' keyword. */
7832 if (cp_parser_extension_opt (parser, &saved_pedantic))
7834 /* Parse the qualified declaration. */
7835 cp_parser_block_declaration (parser, statement_p);
7836 /* Restore the PEDANTIC flag. */
7837 pedantic = saved_pedantic;
7842 /* Peek at the next token to figure out which kind of declaration is
7844 token1 = cp_lexer_peek_token (parser->lexer);
7846 /* If the next keyword is `asm', we have an asm-definition. */
7847 if (token1->keyword == RID_ASM)
7850 cp_parser_commit_to_tentative_parse (parser);
7851 cp_parser_asm_definition (parser);
7853 /* If the next keyword is `namespace', we have a
7854 namespace-alias-definition. */
7855 else if (token1->keyword == RID_NAMESPACE)
7856 cp_parser_namespace_alias_definition (parser);
7857 /* If the next keyword is `using', we have either a
7858 using-declaration or a using-directive. */
7859 else if (token1->keyword == RID_USING)
7864 cp_parser_commit_to_tentative_parse (parser);
7865 /* If the token after `using' is `namespace', then we have a
7867 token2 = cp_lexer_peek_nth_token (parser->lexer, 2);
7868 if (token2->keyword == RID_NAMESPACE)
7869 cp_parser_using_directive (parser);
7870 /* Otherwise, it's a using-declaration. */
7872 cp_parser_using_declaration (parser,
7873 /*access_declaration_p=*/false);
7875 /* If the next keyword is `__label__' we have a misplaced label
7877 else if (token1->keyword == RID_LABEL)
7879 cp_lexer_consume_token (parser->lexer);
7880 error ("%<__label__%> not at the beginning of a block");
7881 cp_parser_skip_to_end_of_statement (parser);
7882 /* If the next token is now a `;', consume it. */
7883 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
7884 cp_lexer_consume_token (parser->lexer);
7886 /* If the next token is `static_assert' we have a static assertion. */
7887 else if (token1->keyword == RID_STATIC_ASSERT)
7888 cp_parser_static_assert (parser, /*member_p=*/false);
7889 /* Anything else must be a simple-declaration. */
7891 cp_parser_simple_declaration (parser, !statement_p);
7894 /* Parse a simple-declaration.
7897 decl-specifier-seq [opt] init-declarator-list [opt] ;
7899 init-declarator-list:
7901 init-declarator-list , init-declarator
7903 If FUNCTION_DEFINITION_ALLOWED_P is TRUE, then we also recognize a
7904 function-definition as a simple-declaration. */
7907 cp_parser_simple_declaration (cp_parser* parser,
7908 bool function_definition_allowed_p)
7910 cp_decl_specifier_seq decl_specifiers;
7911 int declares_class_or_enum;
7912 bool saw_declarator;
7914 /* Defer access checks until we know what is being declared; the
7915 checks for names appearing in the decl-specifier-seq should be
7916 done as if we were in the scope of the thing being declared. */
7917 push_deferring_access_checks (dk_deferred);
7919 /* Parse the decl-specifier-seq. We have to keep track of whether
7920 or not the decl-specifier-seq declares a named class or
7921 enumeration type, since that is the only case in which the
7922 init-declarator-list is allowed to be empty.
7926 In a simple-declaration, the optional init-declarator-list can be
7927 omitted only when declaring a class or enumeration, that is when
7928 the decl-specifier-seq contains either a class-specifier, an
7929 elaborated-type-specifier, or an enum-specifier. */
7930 cp_parser_decl_specifier_seq (parser,
7931 CP_PARSER_FLAGS_OPTIONAL,
7933 &declares_class_or_enum);
7934 /* We no longer need to defer access checks. */
7935 stop_deferring_access_checks ();
7937 /* In a block scope, a valid declaration must always have a
7938 decl-specifier-seq. By not trying to parse declarators, we can
7939 resolve the declaration/expression ambiguity more quickly. */
7940 if (!function_definition_allowed_p
7941 && !decl_specifiers.any_specifiers_p)
7943 cp_parser_error (parser, "expected declaration");
7947 /* If the next two tokens are both identifiers, the code is
7948 erroneous. The usual cause of this situation is code like:
7952 where "T" should name a type -- but does not. */
7953 if (!decl_specifiers.type
7954 && cp_parser_parse_and_diagnose_invalid_type_name (parser))
7956 /* If parsing tentatively, we should commit; we really are
7957 looking at a declaration. */
7958 cp_parser_commit_to_tentative_parse (parser);
7963 /* If we have seen at least one decl-specifier, and the next token
7964 is not a parenthesis, then we must be looking at a declaration.
7965 (After "int (" we might be looking at a functional cast.) */
7966 if (decl_specifiers.any_specifiers_p
7967 && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_PAREN))
7968 cp_parser_commit_to_tentative_parse (parser);
7970 /* Keep going until we hit the `;' at the end of the simple
7972 saw_declarator = false;
7973 while (cp_lexer_next_token_is_not (parser->lexer,
7977 bool function_definition_p;
7982 /* If we are processing next declarator, coma is expected */
7983 token = cp_lexer_peek_token (parser->lexer);
7984 gcc_assert (token->type == CPP_COMMA);
7985 cp_lexer_consume_token (parser->lexer);
7988 saw_declarator = true;
7990 /* Parse the init-declarator. */
7991 decl = cp_parser_init_declarator (parser, &decl_specifiers,
7993 function_definition_allowed_p,
7995 declares_class_or_enum,
7996 &function_definition_p);
7997 /* If an error occurred while parsing tentatively, exit quickly.
7998 (That usually happens when in the body of a function; each
7999 statement is treated as a declaration-statement until proven
8001 if (cp_parser_error_occurred (parser))
8003 /* Handle function definitions specially. */
8004 if (function_definition_p)
8006 /* If the next token is a `,', then we are probably
8007 processing something like:
8011 which is erroneous. */
8012 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
8013 error ("mixing declarations and function-definitions is forbidden");
8014 /* Otherwise, we're done with the list of declarators. */
8017 pop_deferring_access_checks ();
8021 /* The next token should be either a `,' or a `;'. */
8022 token = cp_lexer_peek_token (parser->lexer);
8023 /* If it's a `,', there are more declarators to come. */
8024 if (token->type == CPP_COMMA)
8025 /* will be consumed next time around */;
8026 /* If it's a `;', we are done. */
8027 else if (token->type == CPP_SEMICOLON)
8029 /* Anything else is an error. */
8032 /* If we have already issued an error message we don't need
8033 to issue another one. */
8034 if (decl != error_mark_node
8035 || cp_parser_uncommitted_to_tentative_parse_p (parser))
8036 cp_parser_error (parser, "expected %<,%> or %<;%>");
8037 /* Skip tokens until we reach the end of the statement. */
8038 cp_parser_skip_to_end_of_statement (parser);
8039 /* If the next token is now a `;', consume it. */
8040 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
8041 cp_lexer_consume_token (parser->lexer);
8044 /* After the first time around, a function-definition is not
8045 allowed -- even if it was OK at first. For example:
8050 function_definition_allowed_p = false;
8053 /* Issue an error message if no declarators are present, and the
8054 decl-specifier-seq does not itself declare a class or
8056 if (!saw_declarator)
8058 if (cp_parser_declares_only_class_p (parser))
8059 shadow_tag (&decl_specifiers);
8060 /* Perform any deferred access checks. */
8061 perform_deferred_access_checks ();
8064 /* Consume the `;'. */
8065 cp_parser_require (parser, CPP_SEMICOLON, "%<;%>");
8068 pop_deferring_access_checks ();
8071 /* Parse a decl-specifier-seq.
8074 decl-specifier-seq [opt] decl-specifier
8077 storage-class-specifier
8088 Set *DECL_SPECS to a representation of the decl-specifier-seq.
8090 The parser flags FLAGS is used to control type-specifier parsing.
8092 *DECLARES_CLASS_OR_ENUM is set to the bitwise or of the following
8095 1: one of the decl-specifiers is an elaborated-type-specifier
8096 (i.e., a type declaration)
8097 2: one of the decl-specifiers is an enum-specifier or a
8098 class-specifier (i.e., a type definition)
8103 cp_parser_decl_specifier_seq (cp_parser* parser,
8104 cp_parser_flags flags,
8105 cp_decl_specifier_seq *decl_specs,
8106 int* declares_class_or_enum)
8108 bool constructor_possible_p = !parser->in_declarator_p;
8110 /* Clear DECL_SPECS. */
8111 clear_decl_specs (decl_specs);
8113 /* Assume no class or enumeration type is declared. */
8114 *declares_class_or_enum = 0;
8116 /* Keep reading specifiers until there are no more to read. */
8120 bool found_decl_spec;
8123 /* Peek at the next token. */
8124 token = cp_lexer_peek_token (parser->lexer);
8125 /* Handle attributes. */
8126 if (token->keyword == RID_ATTRIBUTE)
8128 /* Parse the attributes. */
8129 decl_specs->attributes
8130 = chainon (decl_specs->attributes,
8131 cp_parser_attributes_opt (parser));
8134 /* Assume we will find a decl-specifier keyword. */
8135 found_decl_spec = true;
8136 /* If the next token is an appropriate keyword, we can simply
8137 add it to the list. */
8138 switch (token->keyword)
8143 if (!at_class_scope_p ())
8145 error ("%H%<friend%> used outside of class", &token->location);
8146 cp_lexer_purge_token (parser->lexer);
8150 ++decl_specs->specs[(int) ds_friend];
8151 /* Consume the token. */
8152 cp_lexer_consume_token (parser->lexer);
8156 /* function-specifier:
8163 cp_parser_function_specifier_opt (parser, decl_specs);
8169 ++decl_specs->specs[(int) ds_typedef];
8170 /* Consume the token. */
8171 cp_lexer_consume_token (parser->lexer);
8172 /* A constructor declarator cannot appear in a typedef. */
8173 constructor_possible_p = false;
8174 /* The "typedef" keyword can only occur in a declaration; we
8175 may as well commit at this point. */
8176 cp_parser_commit_to_tentative_parse (parser);
8178 if (decl_specs->storage_class != sc_none)
8179 decl_specs->conflicting_specifiers_p = true;
8182 /* storage-class-specifier:
8192 /* Consume the token. */
8193 cp_lexer_consume_token (parser->lexer);
8195 if (cxx_dialect == cxx98)
8197 /* Complain about `auto' as a storage specifier, if
8198 we're complaining about C++0x compatibility. */
8201 "%<auto%> will change meaning in C++0x; please remove it");
8203 /* Set the storage class anyway. */
8204 cp_parser_set_storage_class (parser, decl_specs, RID_AUTO);
8207 /* We do not yet support the use of `auto' as a
8209 error ("C++0x %<auto%> specifier not supported");
8216 /* Consume the token. */
8217 cp_lexer_consume_token (parser->lexer);
8218 cp_parser_set_storage_class (parser, decl_specs, token->keyword);
8221 /* Consume the token. */
8222 cp_lexer_consume_token (parser->lexer);
8223 ++decl_specs->specs[(int) ds_thread];
8227 /* We did not yet find a decl-specifier yet. */
8228 found_decl_spec = false;
8232 /* Constructors are a special case. The `S' in `S()' is not a
8233 decl-specifier; it is the beginning of the declarator. */
8236 && constructor_possible_p
8237 && (cp_parser_constructor_declarator_p
8238 (parser, decl_specs->specs[(int) ds_friend] != 0)));
8240 /* If we don't have a DECL_SPEC yet, then we must be looking at
8241 a type-specifier. */
8242 if (!found_decl_spec && !constructor_p)
8244 int decl_spec_declares_class_or_enum;
8245 bool is_cv_qualifier;
8249 = cp_parser_type_specifier (parser, flags,
8251 /*is_declaration=*/true,
8252 &decl_spec_declares_class_or_enum,
8255 *declares_class_or_enum |= decl_spec_declares_class_or_enum;
8257 /* If this type-specifier referenced a user-defined type
8258 (a typedef, class-name, etc.), then we can't allow any
8259 more such type-specifiers henceforth.
8263 The longest sequence of decl-specifiers that could
8264 possibly be a type name is taken as the
8265 decl-specifier-seq of a declaration. The sequence shall
8266 be self-consistent as described below.
8270 As a general rule, at most one type-specifier is allowed
8271 in the complete decl-specifier-seq of a declaration. The
8272 only exceptions are the following:
8274 -- const or volatile can be combined with any other
8277 -- signed or unsigned can be combined with char, long,
8285 void g (const int Pc);
8287 Here, Pc is *not* part of the decl-specifier seq; it's
8288 the declarator. Therefore, once we see a type-specifier
8289 (other than a cv-qualifier), we forbid any additional
8290 user-defined types. We *do* still allow things like `int
8291 int' to be considered a decl-specifier-seq, and issue the
8292 error message later. */
8293 if (type_spec && !is_cv_qualifier)
8294 flags |= CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES;
8295 /* A constructor declarator cannot follow a type-specifier. */
8298 constructor_possible_p = false;
8299 found_decl_spec = true;
8303 /* If we still do not have a DECL_SPEC, then there are no more
8305 if (!found_decl_spec)
8308 decl_specs->any_specifiers_p = true;
8309 /* After we see one decl-specifier, further decl-specifiers are
8311 flags |= CP_PARSER_FLAGS_OPTIONAL;
8314 cp_parser_check_decl_spec (decl_specs);
8316 /* Don't allow a friend specifier with a class definition. */
8317 if (decl_specs->specs[(int) ds_friend] != 0
8318 && (*declares_class_or_enum & 2))
8319 error ("class definition may not be declared a friend");
8322 /* Parse an (optional) storage-class-specifier.
8324 storage-class-specifier:
8333 storage-class-specifier:
8336 Returns an IDENTIFIER_NODE corresponding to the keyword used. */
8339 cp_parser_storage_class_specifier_opt (cp_parser* parser)
8341 switch (cp_lexer_peek_token (parser->lexer)->keyword)
8344 if (cxx_dialect != cxx98)
8346 /* Fall through for C++98. */
8353 /* Consume the token. */
8354 return cp_lexer_consume_token (parser->lexer)->u.value;
8361 /* Parse an (optional) function-specifier.
8368 Returns an IDENTIFIER_NODE corresponding to the keyword used.
8369 Updates DECL_SPECS, if it is non-NULL. */
8372 cp_parser_function_specifier_opt (cp_parser* parser,
8373 cp_decl_specifier_seq *decl_specs)
8375 switch (cp_lexer_peek_token (parser->lexer)->keyword)
8379 ++decl_specs->specs[(int) ds_inline];
8383 /* 14.5.2.3 [temp.mem]
8385 A member function template shall not be virtual. */
8386 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8387 error ("templates may not be %<virtual%>");
8388 else if (decl_specs)
8389 ++decl_specs->specs[(int) ds_virtual];
8394 ++decl_specs->specs[(int) ds_explicit];
8401 /* Consume the token. */
8402 return cp_lexer_consume_token (parser->lexer)->u.value;
8405 /* Parse a linkage-specification.
8407 linkage-specification:
8408 extern string-literal { declaration-seq [opt] }
8409 extern string-literal declaration */
8412 cp_parser_linkage_specification (cp_parser* parser)
8416 /* Look for the `extern' keyword. */
8417 cp_parser_require_keyword (parser, RID_EXTERN, "%<extern%>");
8419 /* Look for the string-literal. */
8420 linkage = cp_parser_string_literal (parser, false, false);
8422 /* Transform the literal into an identifier. If the literal is a
8423 wide-character string, or contains embedded NULs, then we can't
8424 handle it as the user wants. */
8425 if (strlen (TREE_STRING_POINTER (linkage))
8426 != (size_t) (TREE_STRING_LENGTH (linkage) - 1))
8428 cp_parser_error (parser, "invalid linkage-specification");
8429 /* Assume C++ linkage. */
8430 linkage = lang_name_cplusplus;
8433 linkage = get_identifier (TREE_STRING_POINTER (linkage));
8435 /* We're now using the new linkage. */
8436 push_lang_context (linkage);
8438 /* If the next token is a `{', then we're using the first
8440 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
8442 /* Consume the `{' token. */
8443 cp_lexer_consume_token (parser->lexer);
8444 /* Parse the declarations. */
8445 cp_parser_declaration_seq_opt (parser);
8446 /* Look for the closing `}'. */
8447 cp_parser_require (parser, CPP_CLOSE_BRACE, "%<}%>");
8449 /* Otherwise, there's just one declaration. */
8452 bool saved_in_unbraced_linkage_specification_p;
8454 saved_in_unbraced_linkage_specification_p
8455 = parser->in_unbraced_linkage_specification_p;
8456 parser->in_unbraced_linkage_specification_p = true;
8457 cp_parser_declaration (parser);
8458 parser->in_unbraced_linkage_specification_p
8459 = saved_in_unbraced_linkage_specification_p;
8462 /* We're done with the linkage-specification. */
8463 pop_lang_context ();
8466 /* Parse a static_assert-declaration.
8468 static_assert-declaration:
8469 static_assert ( constant-expression , string-literal ) ;
8471 If MEMBER_P, this static_assert is a class member. */
8474 cp_parser_static_assert(cp_parser *parser, bool member_p)
8479 location_t saved_loc;
8481 /* Peek at the `static_assert' token so we can keep track of exactly
8482 where the static assertion started. */
8483 token = cp_lexer_peek_token (parser->lexer);
8484 saved_loc = token->location;
8486 /* Look for the `static_assert' keyword. */
8487 if (!cp_parser_require_keyword (parser, RID_STATIC_ASSERT,
8488 "%<static_assert%>"))
8491 /* We know we are in a static assertion; commit to any tentative
8493 if (cp_parser_parsing_tentatively (parser))
8494 cp_parser_commit_to_tentative_parse (parser);
8496 /* Parse the `(' starting the static assertion condition. */
8497 cp_parser_require (parser, CPP_OPEN_PAREN, "%<(%>");
8499 /* Parse the constant-expression. */
8501 cp_parser_constant_expression (parser,
8502 /*allow_non_constant_p=*/false,
8503 /*non_constant_p=*/NULL);
8505 /* Parse the separating `,'. */
8506 cp_parser_require (parser, CPP_COMMA, "%<,%>");
8508 /* Parse the string-literal message. */
8509 message = cp_parser_string_literal (parser,
8510 /*translate=*/false,
8513 /* A `)' completes the static assertion. */
8514 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>"))
8515 cp_parser_skip_to_closing_parenthesis (parser,
8516 /*recovering=*/true,
8518 /*consume_paren=*/true);
8520 /* A semicolon terminates the declaration. */
8521 cp_parser_require (parser, CPP_SEMICOLON, "%<;%>");
8523 /* Complete the static assertion, which may mean either processing
8524 the static assert now or saving it for template instantiation. */
8525 finish_static_assert (condition, message, saved_loc, member_p);
8528 /* Parse a `decltype' type. Returns the type.
8530 simple-type-specifier:
8531 decltype ( expression ) */
8534 cp_parser_decltype (cp_parser *parser)
8537 bool id_expression_or_member_access_p = false;
8538 const char *saved_message;
8539 bool saved_integral_constant_expression_p;
8540 bool saved_non_integral_constant_expression_p;
8542 /* Look for the `decltype' token. */
8543 if (!cp_parser_require_keyword (parser, RID_DECLTYPE, "%<decltype%>"))
8544 return error_mark_node;
8546 /* Types cannot be defined in a `decltype' expression. Save away the
8548 saved_message = parser->type_definition_forbidden_message;
8550 /* And create the new one. */
8551 parser->type_definition_forbidden_message
8552 = "types may not be defined in %<decltype%> expressions";
8554 /* The restrictions on constant-expressions do not apply inside
8555 decltype expressions. */
8556 saved_integral_constant_expression_p
8557 = parser->integral_constant_expression_p;
8558 saved_non_integral_constant_expression_p
8559 = parser->non_integral_constant_expression_p;
8560 parser->integral_constant_expression_p = false;
8562 /* Do not actually evaluate the expression. */
8565 /* Parse the opening `('. */
8566 if (!cp_parser_require (parser, CPP_OPEN_PAREN, "%<(%>"))
8567 return error_mark_node;
8569 /* First, try parsing an id-expression. */
8570 cp_parser_parse_tentatively (parser);
8571 expr = cp_parser_id_expression (parser,
8572 /*template_keyword_p=*/false,
8573 /*check_dependency_p=*/true,
8574 /*template_p=*/NULL,
8575 /*declarator_p=*/false,
8576 /*optional_p=*/false);
8578 if (!cp_parser_error_occurred (parser) && expr != error_mark_node)
8580 bool non_integral_constant_expression_p = false;
8581 tree id_expression = expr;
8583 const char *error_msg;
8585 if (TREE_CODE (expr) == IDENTIFIER_NODE)
8586 /* Lookup the name we got back from the id-expression. */
8587 expr = cp_parser_lookup_name (parser, expr,
8589 /*is_template=*/false,
8590 /*is_namespace=*/false,
8591 /*check_dependency=*/true,
8592 /*ambiguous_decls=*/NULL);
8595 && expr != error_mark_node
8596 && TREE_CODE (expr) != TEMPLATE_ID_EXPR
8597 && TREE_CODE (expr) != TYPE_DECL
8598 && (TREE_CODE (expr) != BIT_NOT_EXPR
8599 || !TYPE_P (TREE_OPERAND (expr, 0)))
8600 && cp_lexer_peek_token (parser->lexer)->type == CPP_CLOSE_PAREN)
8602 /* Complete lookup of the id-expression. */
8603 expr = (finish_id_expression
8604 (id_expression, expr, parser->scope, &idk,
8605 /*integral_constant_expression_p=*/false,
8606 /*allow_non_integral_constant_expression_p=*/true,
8607 &non_integral_constant_expression_p,
8608 /*template_p=*/false,
8610 /*address_p=*/false,
8611 /*template_arg_p=*/false,
8614 if (expr == error_mark_node)
8615 /* We found an id-expression, but it was something that we
8616 should not have found. This is an error, not something
8617 we can recover from, so note that we found an
8618 id-expression and we'll recover as gracefully as
8620 id_expression_or_member_access_p = true;
8624 && expr != error_mark_node
8625 && cp_lexer_peek_token (parser->lexer)->type == CPP_CLOSE_PAREN)
8626 /* We have an id-expression. */
8627 id_expression_or_member_access_p = true;
8630 if (!id_expression_or_member_access_p)
8632 /* Abort the id-expression parse. */
8633 cp_parser_abort_tentative_parse (parser);
8635 /* Parsing tentatively, again. */
8636 cp_parser_parse_tentatively (parser);
8638 /* Parse a class member access. */
8639 expr = cp_parser_postfix_expression (parser, /*address_p=*/false,
8641 /*member_access_only_p=*/true);
8644 && expr != error_mark_node
8645 && cp_lexer_peek_token (parser->lexer)->type == CPP_CLOSE_PAREN)
8646 /* We have an id-expression. */
8647 id_expression_or_member_access_p = true;
8650 if (id_expression_or_member_access_p)
8651 /* We have parsed the complete id-expression or member access. */
8652 cp_parser_parse_definitely (parser);
8655 /* Abort our attempt to parse an id-expression or member access
8657 cp_parser_abort_tentative_parse (parser);
8659 /* Parse a full expression. */
8660 expr = cp_parser_expression (parser, /*cast_p=*/false);
8663 /* Go back to evaluating expressions. */
8666 /* Restore the old message and the integral constant expression
8668 parser->type_definition_forbidden_message = saved_message;
8669 parser->integral_constant_expression_p
8670 = saved_integral_constant_expression_p;
8671 parser->non_integral_constant_expression_p
8672 = saved_non_integral_constant_expression_p;
8674 if (expr == error_mark_node)
8676 /* Skip everything up to the closing `)'. */
8677 cp_parser_skip_to_closing_parenthesis (parser, true, false,
8678 /*consume_paren=*/true);
8679 return error_mark_node;
8682 /* Parse to the closing `)'. */
8683 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>"))
8685 cp_parser_skip_to_closing_parenthesis (parser, true, false,
8686 /*consume_paren=*/true);
8687 return error_mark_node;
8690 return finish_decltype_type (expr, id_expression_or_member_access_p);
8693 /* Special member functions [gram.special] */
8695 /* Parse a conversion-function-id.
8697 conversion-function-id:
8698 operator conversion-type-id
8700 Returns an IDENTIFIER_NODE representing the operator. */
8703 cp_parser_conversion_function_id (cp_parser* parser)
8707 tree saved_qualifying_scope;
8708 tree saved_object_scope;
8709 tree pushed_scope = NULL_TREE;
8711 /* Look for the `operator' token. */
8712 if (!cp_parser_require_keyword (parser, RID_OPERATOR, "%<operator%>"))
8713 return error_mark_node;
8714 /* When we parse the conversion-type-id, the current scope will be
8715 reset. However, we need that information in able to look up the
8716 conversion function later, so we save it here. */
8717 saved_scope = parser->scope;
8718 saved_qualifying_scope = parser->qualifying_scope;
8719 saved_object_scope = parser->object_scope;
8720 /* We must enter the scope of the class so that the names of
8721 entities declared within the class are available in the
8722 conversion-type-id. For example, consider:
8729 S::operator I() { ... }
8731 In order to see that `I' is a type-name in the definition, we
8732 must be in the scope of `S'. */
8734 pushed_scope = push_scope (saved_scope);
8735 /* Parse the conversion-type-id. */
8736 type = cp_parser_conversion_type_id (parser);
8737 /* Leave the scope of the class, if any. */
8739 pop_scope (pushed_scope);
8740 /* Restore the saved scope. */
8741 parser->scope = saved_scope;
8742 parser->qualifying_scope = saved_qualifying_scope;
8743 parser->object_scope = saved_object_scope;
8744 /* If the TYPE is invalid, indicate failure. */
8745 if (type == error_mark_node)
8746 return error_mark_node;
8747 return mangle_conv_op_name_for_type (type);
8750 /* Parse a conversion-type-id:
8753 type-specifier-seq conversion-declarator [opt]
8755 Returns the TYPE specified. */
8758 cp_parser_conversion_type_id (cp_parser* parser)
8761 cp_decl_specifier_seq type_specifiers;
8762 cp_declarator *declarator;
8763 tree type_specified;
8765 /* Parse the attributes. */
8766 attributes = cp_parser_attributes_opt (parser);
8767 /* Parse the type-specifiers. */
8768 cp_parser_type_specifier_seq (parser, /*is_condition=*/false,
8770 /* If that didn't work, stop. */
8771 if (type_specifiers.type == error_mark_node)
8772 return error_mark_node;
8773 /* Parse the conversion-declarator. */
8774 declarator = cp_parser_conversion_declarator_opt (parser);
8776 type_specified = grokdeclarator (declarator, &type_specifiers, TYPENAME,
8777 /*initialized=*/0, &attributes);
8779 cplus_decl_attributes (&type_specified, attributes, /*flags=*/0);
8780 return type_specified;
8783 /* Parse an (optional) conversion-declarator.
8785 conversion-declarator:
8786 ptr-operator conversion-declarator [opt]
8790 static cp_declarator *
8791 cp_parser_conversion_declarator_opt (cp_parser* parser)
8793 enum tree_code code;
8795 cp_cv_quals cv_quals;
8797 /* We don't know if there's a ptr-operator next, or not. */
8798 cp_parser_parse_tentatively (parser);
8799 /* Try the ptr-operator. */
8800 code = cp_parser_ptr_operator (parser, &class_type, &cv_quals);
8801 /* If it worked, look for more conversion-declarators. */
8802 if (cp_parser_parse_definitely (parser))
8804 cp_declarator *declarator;
8806 /* Parse another optional declarator. */
8807 declarator = cp_parser_conversion_declarator_opt (parser);
8809 return cp_parser_make_indirect_declarator
8810 (code, class_type, cv_quals, declarator);
8816 /* Parse an (optional) ctor-initializer.
8819 : mem-initializer-list
8821 Returns TRUE iff the ctor-initializer was actually present. */
8824 cp_parser_ctor_initializer_opt (cp_parser* parser)
8826 /* If the next token is not a `:', then there is no
8827 ctor-initializer. */
8828 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COLON))
8830 /* Do default initialization of any bases and members. */
8831 if (DECL_CONSTRUCTOR_P (current_function_decl))
8832 finish_mem_initializers (NULL_TREE);
8837 /* Consume the `:' token. */
8838 cp_lexer_consume_token (parser->lexer);
8839 /* And the mem-initializer-list. */
8840 cp_parser_mem_initializer_list (parser);
8845 /* Parse a mem-initializer-list.
8847 mem-initializer-list:
8848 mem-initializer ... [opt]
8849 mem-initializer ... [opt] , mem-initializer-list */
8852 cp_parser_mem_initializer_list (cp_parser* parser)
8854 tree mem_initializer_list = NULL_TREE;
8856 /* Let the semantic analysis code know that we are starting the
8857 mem-initializer-list. */
8858 if (!DECL_CONSTRUCTOR_P (current_function_decl))
8859 error ("only constructors take base initializers");
8861 /* Loop through the list. */
8864 tree mem_initializer;
8866 /* Parse the mem-initializer. */
8867 mem_initializer = cp_parser_mem_initializer (parser);
8868 /* If the next token is a `...', we're expanding member initializers. */
8869 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
8871 /* Consume the `...'. */
8872 cp_lexer_consume_token (parser->lexer);
8874 /* The TREE_PURPOSE must be a _TYPE, because base-specifiers
8875 can be expanded but members cannot. */
8876 if (mem_initializer != error_mark_node
8877 && !TYPE_P (TREE_PURPOSE (mem_initializer)))
8879 error ("cannot expand initializer for member %<%D%>",
8880 TREE_PURPOSE (mem_initializer));
8881 mem_initializer = error_mark_node;
8884 /* Construct the pack expansion type. */
8885 if (mem_initializer != error_mark_node)
8886 mem_initializer = make_pack_expansion (mem_initializer);
8888 /* Add it to the list, unless it was erroneous. */
8889 if (mem_initializer != error_mark_node)
8891 TREE_CHAIN (mem_initializer) = mem_initializer_list;
8892 mem_initializer_list = mem_initializer;
8894 /* If the next token is not a `,', we're done. */
8895 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
8897 /* Consume the `,' token. */
8898 cp_lexer_consume_token (parser->lexer);
8901 /* Perform semantic analysis. */
8902 if (DECL_CONSTRUCTOR_P (current_function_decl))
8903 finish_mem_initializers (mem_initializer_list);
8906 /* Parse a mem-initializer.
8909 mem-initializer-id ( expression-list [opt] )
8914 ( expression-list [opt] )
8916 Returns a TREE_LIST. The TREE_PURPOSE is the TYPE (for a base
8917 class) or FIELD_DECL (for a non-static data member) to initialize;
8918 the TREE_VALUE is the expression-list. An empty initialization
8919 list is represented by void_list_node. */
8922 cp_parser_mem_initializer (cp_parser* parser)
8924 tree mem_initializer_id;
8925 tree expression_list;
8928 /* Find out what is being initialized. */
8929 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
8931 pedwarn ("anachronistic old-style base class initializer");
8932 mem_initializer_id = NULL_TREE;
8935 mem_initializer_id = cp_parser_mem_initializer_id (parser);
8936 member = expand_member_init (mem_initializer_id);
8937 if (member && !DECL_P (member))
8938 in_base_initializer = 1;
8941 = cp_parser_parenthesized_expression_list (parser, false,
8943 /*allow_expansion_p=*/true,
8944 /*non_constant_p=*/NULL);
8945 if (expression_list == error_mark_node)
8946 return error_mark_node;
8947 if (!expression_list)
8948 expression_list = void_type_node;
8950 in_base_initializer = 0;
8952 return member ? build_tree_list (member, expression_list) : error_mark_node;
8955 /* Parse a mem-initializer-id.
8958 :: [opt] nested-name-specifier [opt] class-name
8961 Returns a TYPE indicating the class to be initializer for the first
8962 production. Returns an IDENTIFIER_NODE indicating the data member
8963 to be initialized for the second production. */
8966 cp_parser_mem_initializer_id (cp_parser* parser)
8968 bool global_scope_p;
8969 bool nested_name_specifier_p;
8970 bool template_p = false;
8973 /* `typename' is not allowed in this context ([temp.res]). */
8974 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TYPENAME))
8976 error ("keyword %<typename%> not allowed in this context (a qualified "
8977 "member initializer is implicitly a type)");
8978 cp_lexer_consume_token (parser->lexer);
8980 /* Look for the optional `::' operator. */
8982 = (cp_parser_global_scope_opt (parser,
8983 /*current_scope_valid_p=*/false)
8985 /* Look for the optional nested-name-specifier. The simplest way to
8990 The keyword `typename' is not permitted in a base-specifier or
8991 mem-initializer; in these contexts a qualified name that
8992 depends on a template-parameter is implicitly assumed to be a
8995 is to assume that we have seen the `typename' keyword at this
8997 nested_name_specifier_p
8998 = (cp_parser_nested_name_specifier_opt (parser,
8999 /*typename_keyword_p=*/true,
9000 /*check_dependency_p=*/true,
9002 /*is_declaration=*/true)
9004 if (nested_name_specifier_p)
9005 template_p = cp_parser_optional_template_keyword (parser);
9006 /* If there is a `::' operator or a nested-name-specifier, then we
9007 are definitely looking for a class-name. */
9008 if (global_scope_p || nested_name_specifier_p)
9009 return cp_parser_class_name (parser,
9010 /*typename_keyword_p=*/true,
9011 /*template_keyword_p=*/template_p,
9013 /*check_dependency_p=*/true,
9014 /*class_head_p=*/false,
9015 /*is_declaration=*/true);
9016 /* Otherwise, we could also be looking for an ordinary identifier. */
9017 cp_parser_parse_tentatively (parser);
9018 /* Try a class-name. */
9019 id = cp_parser_class_name (parser,
9020 /*typename_keyword_p=*/true,
9021 /*template_keyword_p=*/false,
9023 /*check_dependency_p=*/true,
9024 /*class_head_p=*/false,
9025 /*is_declaration=*/true);
9026 /* If we found one, we're done. */
9027 if (cp_parser_parse_definitely (parser))
9029 /* Otherwise, look for an ordinary identifier. */
9030 return cp_parser_identifier (parser);
9033 /* Overloading [gram.over] */
9035 /* Parse an operator-function-id.
9037 operator-function-id:
9040 Returns an IDENTIFIER_NODE for the operator which is a
9041 human-readable spelling of the identifier, e.g., `operator +'. */
9044 cp_parser_operator_function_id (cp_parser* parser)
9046 /* Look for the `operator' keyword. */
9047 if (!cp_parser_require_keyword (parser, RID_OPERATOR, "%<operator%>"))
9048 return error_mark_node;
9049 /* And then the name of the operator itself. */
9050 return cp_parser_operator (parser);
9053 /* Parse an operator.
9056 new delete new[] delete[] + - * / % ^ & | ~ ! = < >
9057 += -= *= /= %= ^= &= |= << >> >>= <<= == != <= >= &&
9058 || ++ -- , ->* -> () []
9065 Returns an IDENTIFIER_NODE for the operator which is a
9066 human-readable spelling of the identifier, e.g., `operator +'. */
9069 cp_parser_operator (cp_parser* parser)
9071 tree id = NULL_TREE;
9074 /* Peek at the next token. */
9075 token = cp_lexer_peek_token (parser->lexer);
9076 /* Figure out which operator we have. */
9077 switch (token->type)
9083 /* The keyword should be either `new' or `delete'. */
9084 if (token->keyword == RID_NEW)
9086 else if (token->keyword == RID_DELETE)
9091 /* Consume the `new' or `delete' token. */
9092 cp_lexer_consume_token (parser->lexer);
9094 /* Peek at the next token. */
9095 token = cp_lexer_peek_token (parser->lexer);
9096 /* If it's a `[' token then this is the array variant of the
9098 if (token->type == CPP_OPEN_SQUARE)
9100 /* Consume the `[' token. */
9101 cp_lexer_consume_token (parser->lexer);
9102 /* Look for the `]' token. */
9103 cp_parser_require (parser, CPP_CLOSE_SQUARE, "%<]%>");
9104 id = ansi_opname (op == NEW_EXPR
9105 ? VEC_NEW_EXPR : VEC_DELETE_EXPR);
9107 /* Otherwise, we have the non-array variant. */
9109 id = ansi_opname (op);
9115 id = ansi_opname (PLUS_EXPR);
9119 id = ansi_opname (MINUS_EXPR);
9123 id = ansi_opname (MULT_EXPR);
9127 id = ansi_opname (TRUNC_DIV_EXPR);
9131 id = ansi_opname (TRUNC_MOD_EXPR);
9135 id = ansi_opname (BIT_XOR_EXPR);
9139 id = ansi_opname (BIT_AND_EXPR);
9143 id = ansi_opname (BIT_IOR_EXPR);
9147 id = ansi_opname (BIT_NOT_EXPR);
9151 id = ansi_opname (TRUTH_NOT_EXPR);
9155 id = ansi_assopname (NOP_EXPR);
9159 id = ansi_opname (LT_EXPR);
9163 id = ansi_opname (GT_EXPR);
9167 id = ansi_assopname (PLUS_EXPR);
9171 id = ansi_assopname (MINUS_EXPR);
9175 id = ansi_assopname (MULT_EXPR);
9179 id = ansi_assopname (TRUNC_DIV_EXPR);
9183 id = ansi_assopname (TRUNC_MOD_EXPR);
9187 id = ansi_assopname (BIT_XOR_EXPR);
9191 id = ansi_assopname (BIT_AND_EXPR);
9195 id = ansi_assopname (BIT_IOR_EXPR);
9199 id = ansi_opname (LSHIFT_EXPR);
9203 id = ansi_opname (RSHIFT_EXPR);
9207 id = ansi_assopname (LSHIFT_EXPR);
9211 id = ansi_assopname (RSHIFT_EXPR);
9215 id = ansi_opname (EQ_EXPR);
9219 id = ansi_opname (NE_EXPR);
9223 id = ansi_opname (LE_EXPR);
9226 case CPP_GREATER_EQ:
9227 id = ansi_opname (GE_EXPR);
9231 id = ansi_opname (TRUTH_ANDIF_EXPR);
9235 id = ansi_opname (TRUTH_ORIF_EXPR);
9239 id = ansi_opname (POSTINCREMENT_EXPR);
9242 case CPP_MINUS_MINUS:
9243 id = ansi_opname (PREDECREMENT_EXPR);
9247 id = ansi_opname (COMPOUND_EXPR);
9250 case CPP_DEREF_STAR:
9251 id = ansi_opname (MEMBER_REF);
9255 id = ansi_opname (COMPONENT_REF);
9258 case CPP_OPEN_PAREN:
9259 /* Consume the `('. */
9260 cp_lexer_consume_token (parser->lexer);
9261 /* Look for the matching `)'. */
9262 cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>");
9263 return ansi_opname (CALL_EXPR);
9265 case CPP_OPEN_SQUARE:
9266 /* Consume the `['. */
9267 cp_lexer_consume_token (parser->lexer);
9268 /* Look for the matching `]'. */
9269 cp_parser_require (parser, CPP_CLOSE_SQUARE, "%<]%>");
9270 return ansi_opname (ARRAY_REF);
9273 /* Anything else is an error. */
9277 /* If we have selected an identifier, we need to consume the
9280 cp_lexer_consume_token (parser->lexer);
9281 /* Otherwise, no valid operator name was present. */
9284 cp_parser_error (parser, "expected operator");
9285 id = error_mark_node;
9291 /* Parse a template-declaration.
9293 template-declaration:
9294 export [opt] template < template-parameter-list > declaration
9296 If MEMBER_P is TRUE, this template-declaration occurs within a
9299 The grammar rule given by the standard isn't correct. What
9302 template-declaration:
9303 export [opt] template-parameter-list-seq
9304 decl-specifier-seq [opt] init-declarator [opt] ;
9305 export [opt] template-parameter-list-seq
9308 template-parameter-list-seq:
9309 template-parameter-list-seq [opt]
9310 template < template-parameter-list > */
9313 cp_parser_template_declaration (cp_parser* parser, bool member_p)
9315 /* Check for `export'. */
9316 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_EXPORT))
9318 /* Consume the `export' token. */
9319 cp_lexer_consume_token (parser->lexer);
9320 /* Warn that we do not support `export'. */
9321 warning (0, "keyword %<export%> not implemented, and will be ignored");
9324 cp_parser_template_declaration_after_export (parser, member_p);
9327 /* Parse a template-parameter-list.
9329 template-parameter-list:
9331 template-parameter-list , template-parameter
9333 Returns a TREE_LIST. Each node represents a template parameter.
9334 The nodes are connected via their TREE_CHAINs. */
9337 cp_parser_template_parameter_list (cp_parser* parser)
9339 tree parameter_list = NULL_TREE;
9341 begin_template_parm_list ();
9346 bool is_parameter_pack;
9348 /* Parse the template-parameter. */
9349 parameter = cp_parser_template_parameter (parser,
9351 &is_parameter_pack);
9352 /* Add it to the list. */
9353 if (parameter != error_mark_node)
9354 parameter_list = process_template_parm (parameter_list,
9360 tree err_parm = build_tree_list (parameter, parameter);
9361 TREE_VALUE (err_parm) = error_mark_node;
9362 parameter_list = chainon (parameter_list, err_parm);
9365 /* If the next token is not a `,', we're done. */
9366 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
9368 /* Otherwise, consume the `,' token. */
9369 cp_lexer_consume_token (parser->lexer);
9372 return end_template_parm_list (parameter_list);
9375 /* Parse a template-parameter.
9379 parameter-declaration
9381 If all goes well, returns a TREE_LIST. The TREE_VALUE represents
9382 the parameter. The TREE_PURPOSE is the default value, if any.
9383 Returns ERROR_MARK_NODE on failure. *IS_NON_TYPE is set to true
9384 iff this parameter is a non-type parameter. *IS_PARAMETER_PACK is
9385 set to true iff this parameter is a parameter pack. */
9388 cp_parser_template_parameter (cp_parser* parser, bool *is_non_type,
9389 bool *is_parameter_pack)
9392 cp_parameter_declarator *parameter_declarator;
9393 cp_declarator *id_declarator;
9396 /* Assume it is a type parameter or a template parameter. */
9397 *is_non_type = false;
9398 /* Assume it not a parameter pack. */
9399 *is_parameter_pack = false;
9400 /* Peek at the next token. */
9401 token = cp_lexer_peek_token (parser->lexer);
9402 /* If it is `class' or `template', we have a type-parameter. */
9403 if (token->keyword == RID_TEMPLATE)
9404 return cp_parser_type_parameter (parser, is_parameter_pack);
9405 /* If it is `class' or `typename' we do not know yet whether it is a
9406 type parameter or a non-type parameter. Consider:
9408 template <typename T, typename T::X X> ...
9412 template <class C, class D*> ...
9414 Here, the first parameter is a type parameter, and the second is
9415 a non-type parameter. We can tell by looking at the token after
9416 the identifier -- if it is a `,', `=', or `>' then we have a type
9418 if (token->keyword == RID_TYPENAME || token->keyword == RID_CLASS)
9420 /* Peek at the token after `class' or `typename'. */
9421 token = cp_lexer_peek_nth_token (parser->lexer, 2);
9422 /* If it's an ellipsis, we have a template type parameter
9424 if (token->type == CPP_ELLIPSIS)
9425 return cp_parser_type_parameter (parser, is_parameter_pack);
9426 /* If it's an identifier, skip it. */
9427 if (token->type == CPP_NAME)
9428 token = cp_lexer_peek_nth_token (parser->lexer, 3);
9429 /* Now, see if the token looks like the end of a template
9431 if (token->type == CPP_COMMA
9432 || token->type == CPP_EQ
9433 || token->type == CPP_GREATER)
9434 return cp_parser_type_parameter (parser, is_parameter_pack);
9437 /* Otherwise, it is a non-type parameter.
9441 When parsing a default template-argument for a non-type
9442 template-parameter, the first non-nested `>' is taken as the end
9443 of the template parameter-list rather than a greater-than
9445 *is_non_type = true;
9446 parameter_declarator
9447 = cp_parser_parameter_declaration (parser, /*template_parm_p=*/true,
9448 /*parenthesized_p=*/NULL);
9450 /* If the parameter declaration is marked as a parameter pack, set
9451 *IS_PARAMETER_PACK to notify the caller. Also, unmark the
9452 declarator's PACK_EXPANSION_P, otherwise we'll get errors from
9454 if (parameter_declarator
9455 && parameter_declarator->declarator
9456 && parameter_declarator->declarator->parameter_pack_p)
9458 *is_parameter_pack = true;
9459 parameter_declarator->declarator->parameter_pack_p = false;
9462 /* If the next token is an ellipsis, and we don't already have it
9463 marked as a parameter pack, then we have a parameter pack (that
9464 has no declarator). */
9465 if (!*is_parameter_pack
9466 && cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS)
9467 && declarator_can_be_parameter_pack (parameter_declarator->declarator))
9469 /* Consume the `...'. */
9470 cp_lexer_consume_token (parser->lexer);
9471 maybe_warn_variadic_templates ();
9473 *is_parameter_pack = true;
9475 /* We might end up with a pack expansion as the type of the non-type
9476 template parameter, in which case this is a non-type template
9478 else if (parameter_declarator
9479 && parameter_declarator->decl_specifiers.type
9480 && PACK_EXPANSION_P (parameter_declarator->decl_specifiers.type))
9482 *is_parameter_pack = true;
9483 parameter_declarator->decl_specifiers.type =
9484 PACK_EXPANSION_PATTERN (parameter_declarator->decl_specifiers.type);
9487 if (*is_parameter_pack && cp_lexer_next_token_is (parser->lexer, CPP_EQ))
9489 /* Parameter packs cannot have default arguments. However, a
9490 user may try to do so, so we'll parse them and give an
9491 appropriate diagnostic here. */
9493 /* Consume the `='. */
9494 cp_lexer_consume_token (parser->lexer);
9496 /* Find the name of the parameter pack. */
9497 id_declarator = parameter_declarator->declarator;
9498 while (id_declarator && id_declarator->kind != cdk_id)
9499 id_declarator = id_declarator->declarator;
9501 if (id_declarator && id_declarator->kind == cdk_id)
9502 error ("template parameter pack %qD cannot have a default argument",
9503 id_declarator->u.id.unqualified_name);
9505 error ("template parameter pack cannot have a default argument");
9507 /* Parse the default argument, but throw away the result. */
9508 cp_parser_default_argument (parser, /*template_parm_p=*/true);
9511 parm = grokdeclarator (parameter_declarator->declarator,
9512 ¶meter_declarator->decl_specifiers,
9513 PARM, /*initialized=*/0,
9515 if (parm == error_mark_node)
9516 return error_mark_node;
9518 return build_tree_list (parameter_declarator->default_argument, parm);
9521 /* Parse a type-parameter.
9524 class identifier [opt]
9525 class identifier [opt] = type-id
9526 typename identifier [opt]
9527 typename identifier [opt] = type-id
9528 template < template-parameter-list > class identifier [opt]
9529 template < template-parameter-list > class identifier [opt]
9532 GNU Extension (variadic templates):
9535 class ... identifier [opt]
9536 typename ... identifier [opt]
9538 Returns a TREE_LIST. The TREE_VALUE is itself a TREE_LIST. The
9539 TREE_PURPOSE is the default-argument, if any. The TREE_VALUE is
9540 the declaration of the parameter.
9542 Sets *IS_PARAMETER_PACK if this is a template parameter pack. */
9545 cp_parser_type_parameter (cp_parser* parser, bool *is_parameter_pack)
9550 /* Look for a keyword to tell us what kind of parameter this is. */
9551 token = cp_parser_require (parser, CPP_KEYWORD,
9552 "%<class%>, %<typename%>, or %<template%>");
9554 return error_mark_node;
9556 switch (token->keyword)
9562 tree default_argument;
9564 /* If the next token is an ellipsis, we have a template
9566 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
9568 /* Consume the `...' token. */
9569 cp_lexer_consume_token (parser->lexer);
9570 maybe_warn_variadic_templates ();
9572 *is_parameter_pack = true;
9575 /* If the next token is an identifier, then it names the
9577 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
9578 identifier = cp_parser_identifier (parser);
9580 identifier = NULL_TREE;
9582 /* Create the parameter. */
9583 parameter = finish_template_type_parm (class_type_node, identifier);
9585 /* If the next token is an `=', we have a default argument. */
9586 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
9588 /* Consume the `=' token. */
9589 cp_lexer_consume_token (parser->lexer);
9590 /* Parse the default-argument. */
9591 push_deferring_access_checks (dk_no_deferred);
9592 default_argument = cp_parser_type_id (parser);
9594 /* Template parameter packs cannot have default
9596 if (*is_parameter_pack)
9599 error ("template parameter pack %qD cannot have a default argument",
9602 error ("template parameter packs cannot have default arguments");
9603 default_argument = NULL_TREE;
9605 pop_deferring_access_checks ();
9608 default_argument = NULL_TREE;
9610 /* Create the combined representation of the parameter and the
9611 default argument. */
9612 parameter = build_tree_list (default_argument, parameter);
9618 tree parameter_list;
9620 tree default_argument;
9622 /* Look for the `<'. */
9623 cp_parser_require (parser, CPP_LESS, "%<<%>");
9624 /* Parse the template-parameter-list. */
9625 parameter_list = cp_parser_template_parameter_list (parser);
9626 /* Look for the `>'. */
9627 cp_parser_require (parser, CPP_GREATER, "%<>%>");
9628 /* Look for the `class' keyword. */
9629 cp_parser_require_keyword (parser, RID_CLASS, "%<class%>");
9630 /* If the next token is an ellipsis, we have a template
9632 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
9634 /* Consume the `...' token. */
9635 cp_lexer_consume_token (parser->lexer);
9636 maybe_warn_variadic_templates ();
9638 *is_parameter_pack = true;
9640 /* If the next token is an `=', then there is a
9641 default-argument. If the next token is a `>', we are at
9642 the end of the parameter-list. If the next token is a `,',
9643 then we are at the end of this parameter. */
9644 if (cp_lexer_next_token_is_not (parser->lexer, CPP_EQ)
9645 && cp_lexer_next_token_is_not (parser->lexer, CPP_GREATER)
9646 && cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
9648 identifier = cp_parser_identifier (parser);
9649 /* Treat invalid names as if the parameter were nameless. */
9650 if (identifier == error_mark_node)
9651 identifier = NULL_TREE;
9654 identifier = NULL_TREE;
9656 /* Create the template parameter. */
9657 parameter = finish_template_template_parm (class_type_node,
9660 /* If the next token is an `=', then there is a
9661 default-argument. */
9662 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
9666 /* Consume the `='. */
9667 cp_lexer_consume_token (parser->lexer);
9668 /* Parse the id-expression. */
9669 push_deferring_access_checks (dk_no_deferred);
9671 = cp_parser_id_expression (parser,
9672 /*template_keyword_p=*/false,
9673 /*check_dependency_p=*/true,
9674 /*template_p=*/&is_template,
9675 /*declarator_p=*/false,
9676 /*optional_p=*/false);
9677 if (TREE_CODE (default_argument) == TYPE_DECL)
9678 /* If the id-expression was a template-id that refers to
9679 a template-class, we already have the declaration here,
9680 so no further lookup is needed. */
9683 /* Look up the name. */
9685 = cp_parser_lookup_name (parser, default_argument,
9687 /*is_template=*/is_template,
9688 /*is_namespace=*/false,
9689 /*check_dependency=*/true,
9690 /*ambiguous_decls=*/NULL);
9691 /* See if the default argument is valid. */
9693 = check_template_template_default_arg (default_argument);
9695 /* Template parameter packs cannot have default
9697 if (*is_parameter_pack)
9700 error ("template parameter pack %qD cannot have a default argument",
9703 error ("template parameter packs cannot have default arguments");
9704 default_argument = NULL_TREE;
9706 pop_deferring_access_checks ();
9709 default_argument = NULL_TREE;
9711 /* Create the combined representation of the parameter and the
9712 default argument. */
9713 parameter = build_tree_list (default_argument, parameter);
9725 /* Parse a template-id.
9728 template-name < template-argument-list [opt] >
9730 If TEMPLATE_KEYWORD_P is TRUE, then we have just seen the
9731 `template' keyword. In this case, a TEMPLATE_ID_EXPR will be
9732 returned. Otherwise, if the template-name names a function, or set
9733 of functions, returns a TEMPLATE_ID_EXPR. If the template-name
9734 names a class, returns a TYPE_DECL for the specialization.
9736 If CHECK_DEPENDENCY_P is FALSE, names are looked up in
9737 uninstantiated templates. */
9740 cp_parser_template_id (cp_parser *parser,
9741 bool template_keyword_p,
9742 bool check_dependency_p,
9743 bool is_declaration)
9749 cp_token_position start_of_id = 0;
9750 deferred_access_check *chk;
9751 VEC (deferred_access_check,gc) *access_check;
9752 cp_token *next_token, *next_token_2;
9755 /* If the next token corresponds to a template-id, there is no need
9757 next_token = cp_lexer_peek_token (parser->lexer);
9758 if (next_token->type == CPP_TEMPLATE_ID)
9760 struct tree_check *check_value;
9762 /* Get the stored value. */
9763 check_value = cp_lexer_consume_token (parser->lexer)->u.tree_check_value;
9764 /* Perform any access checks that were deferred. */
9765 access_check = check_value->checks;
9769 VEC_iterate (deferred_access_check, access_check, i, chk) ;
9772 perform_or_defer_access_check (chk->binfo,
9777 /* Return the stored value. */
9778 return check_value->value;
9781 /* Avoid performing name lookup if there is no possibility of
9782 finding a template-id. */
9783 if ((next_token->type != CPP_NAME && next_token->keyword != RID_OPERATOR)
9784 || (next_token->type == CPP_NAME
9785 && !cp_parser_nth_token_starts_template_argument_list_p
9788 cp_parser_error (parser, "expected template-id");
9789 return error_mark_node;
9792 /* Remember where the template-id starts. */
9793 if (cp_parser_uncommitted_to_tentative_parse_p (parser))
9794 start_of_id = cp_lexer_token_position (parser->lexer, false);
9796 push_deferring_access_checks (dk_deferred);
9798 /* Parse the template-name. */
9799 is_identifier = false;
9800 template = cp_parser_template_name (parser, template_keyword_p,
9804 if (template == error_mark_node || is_identifier)
9806 pop_deferring_access_checks ();
9810 /* If we find the sequence `[:' after a template-name, it's probably
9811 a digraph-typo for `< ::'. Substitute the tokens and check if we can
9812 parse correctly the argument list. */
9813 next_token = cp_lexer_peek_token (parser->lexer);
9814 next_token_2 = cp_lexer_peek_nth_token (parser->lexer, 2);
9815 if (next_token->type == CPP_OPEN_SQUARE
9816 && next_token->flags & DIGRAPH
9817 && next_token_2->type == CPP_COLON
9818 && !(next_token_2->flags & PREV_WHITE))
9820 cp_parser_parse_tentatively (parser);
9821 /* Change `:' into `::'. */
9822 next_token_2->type = CPP_SCOPE;
9823 /* Consume the first token (CPP_OPEN_SQUARE - which we pretend it is
9825 cp_lexer_consume_token (parser->lexer);
9826 /* Parse the arguments. */
9827 arguments = cp_parser_enclosed_template_argument_list (parser);
9828 if (!cp_parser_parse_definitely (parser))
9830 /* If we couldn't parse an argument list, then we revert our changes
9831 and return simply an error. Maybe this is not a template-id
9833 next_token_2->type = CPP_COLON;
9834 cp_parser_error (parser, "expected %<<%>");
9835 pop_deferring_access_checks ();
9836 return error_mark_node;
9838 /* Otherwise, emit an error about the invalid digraph, but continue
9839 parsing because we got our argument list. */
9840 permerror ("%<<::%> cannot begin a template-argument list");
9841 inform ("%<<:%> is an alternate spelling for %<[%>. Insert whitespace "
9842 "between %<<%> and %<::%>");
9843 if (!flag_permissive)
9848 inform ("(if you use -fpermissive G++ will accept your code)");
9855 /* Look for the `<' that starts the template-argument-list. */
9856 if (!cp_parser_require (parser, CPP_LESS, "%<<%>"))
9858 pop_deferring_access_checks ();
9859 return error_mark_node;
9861 /* Parse the arguments. */
9862 arguments = cp_parser_enclosed_template_argument_list (parser);
9865 /* Build a representation of the specialization. */
9866 if (TREE_CODE (template) == IDENTIFIER_NODE)
9867 template_id = build_min_nt (TEMPLATE_ID_EXPR, template, arguments);
9868 else if (DECL_CLASS_TEMPLATE_P (template)
9869 || DECL_TEMPLATE_TEMPLATE_PARM_P (template))
9871 bool entering_scope;
9872 /* In "template <typename T> ... A<T>::", A<T> is the abstract A
9873 template (rather than some instantiation thereof) only if
9874 is not nested within some other construct. For example, in
9875 "template <typename T> void f(T) { A<T>::", A<T> is just an
9876 instantiation of A. */
9877 entering_scope = (template_parm_scope_p ()
9878 && cp_lexer_next_token_is (parser->lexer,
9881 = finish_template_type (template, arguments, entering_scope);
9885 /* If it's not a class-template or a template-template, it should be
9886 a function-template. */
9887 gcc_assert ((DECL_FUNCTION_TEMPLATE_P (template)
9888 || TREE_CODE (template) == OVERLOAD
9889 || BASELINK_P (template)));
9891 template_id = lookup_template_function (template, arguments);
9894 /* If parsing tentatively, replace the sequence of tokens that makes
9895 up the template-id with a CPP_TEMPLATE_ID token. That way,
9896 should we re-parse the token stream, we will not have to repeat
9897 the effort required to do the parse, nor will we issue duplicate
9898 error messages about problems during instantiation of the
9902 cp_token *token = cp_lexer_token_at (parser->lexer, start_of_id);
9904 /* Reset the contents of the START_OF_ID token. */
9905 token->type = CPP_TEMPLATE_ID;
9906 /* Retrieve any deferred checks. Do not pop this access checks yet
9907 so the memory will not be reclaimed during token replacing below. */
9908 token->u.tree_check_value = GGC_CNEW (struct tree_check);
9909 token->u.tree_check_value->value = template_id;
9910 token->u.tree_check_value->checks = get_deferred_access_checks ();
9911 token->keyword = RID_MAX;
9913 /* Purge all subsequent tokens. */
9914 cp_lexer_purge_tokens_after (parser->lexer, start_of_id);
9916 /* ??? Can we actually assume that, if template_id ==
9917 error_mark_node, we will have issued a diagnostic to the
9918 user, as opposed to simply marking the tentative parse as
9920 if (cp_parser_error_occurred (parser) && template_id != error_mark_node)
9921 error ("parse error in template argument list");
9924 pop_deferring_access_checks ();
9928 /* Parse a template-name.
9933 The standard should actually say:
9937 operator-function-id
9939 A defect report has been filed about this issue.
9941 A conversion-function-id cannot be a template name because they cannot
9942 be part of a template-id. In fact, looking at this code:
9946 the conversion-function-id is "operator K<int>", and K<int> is a type-id.
9947 It is impossible to call a templated conversion-function-id with an
9948 explicit argument list, since the only allowed template parameter is
9949 the type to which it is converting.
9951 If TEMPLATE_KEYWORD_P is true, then we have just seen the
9952 `template' keyword, in a construction like:
9956 In that case `f' is taken to be a template-name, even though there
9957 is no way of knowing for sure.
9959 Returns the TEMPLATE_DECL for the template, or an OVERLOAD if the
9960 name refers to a set of overloaded functions, at least one of which
9961 is a template, or an IDENTIFIER_NODE with the name of the template,
9962 if TEMPLATE_KEYWORD_P is true. If CHECK_DEPENDENCY_P is FALSE,
9963 names are looked up inside uninstantiated templates. */
9966 cp_parser_template_name (cp_parser* parser,
9967 bool template_keyword_p,
9968 bool check_dependency_p,
9969 bool is_declaration,
9970 bool *is_identifier)
9976 /* If the next token is `operator', then we have either an
9977 operator-function-id or a conversion-function-id. */
9978 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_OPERATOR))
9980 /* We don't know whether we're looking at an
9981 operator-function-id or a conversion-function-id. */
9982 cp_parser_parse_tentatively (parser);
9983 /* Try an operator-function-id. */
9984 identifier = cp_parser_operator_function_id (parser);
9985 /* If that didn't work, try a conversion-function-id. */
9986 if (!cp_parser_parse_definitely (parser))
9988 cp_parser_error (parser, "expected template-name");
9989 return error_mark_node;
9992 /* Look for the identifier. */
9994 identifier = cp_parser_identifier (parser);
9996 /* If we didn't find an identifier, we don't have a template-id. */
9997 if (identifier == error_mark_node)
9998 return error_mark_node;
10000 /* If the name immediately followed the `template' keyword, then it
10001 is a template-name. However, if the next token is not `<', then
10002 we do not treat it as a template-name, since it is not being used
10003 as part of a template-id. This enables us to handle constructs
10006 template <typename T> struct S { S(); };
10007 template <typename T> S<T>::S();
10009 correctly. We would treat `S' as a template -- if it were `S<T>'
10010 -- but we do not if there is no `<'. */
10012 if (processing_template_decl
10013 && cp_parser_nth_token_starts_template_argument_list_p (parser, 1))
10015 /* In a declaration, in a dependent context, we pretend that the
10016 "template" keyword was present in order to improve error
10017 recovery. For example, given:
10019 template <typename T> void f(T::X<int>);
10021 we want to treat "X<int>" as a template-id. */
10023 && !template_keyword_p
10024 && parser->scope && TYPE_P (parser->scope)
10025 && check_dependency_p
10026 && dependent_type_p (parser->scope)
10027 /* Do not do this for dtors (or ctors), since they never
10028 need the template keyword before their name. */
10029 && !constructor_name_p (identifier, parser->scope))
10031 cp_token_position start = 0;
10033 /* Explain what went wrong. */
10034 error ("non-template %qD used as template", identifier);
10035 inform ("use %<%T::template %D%> to indicate that it is a template",
10036 parser->scope, identifier);
10037 /* If parsing tentatively, find the location of the "<" token. */
10038 if (cp_parser_simulate_error (parser))
10039 start = cp_lexer_token_position (parser->lexer, true);
10040 /* Parse the template arguments so that we can issue error
10041 messages about them. */
10042 cp_lexer_consume_token (parser->lexer);
10043 cp_parser_enclosed_template_argument_list (parser);
10044 /* Skip tokens until we find a good place from which to
10045 continue parsing. */
10046 cp_parser_skip_to_closing_parenthesis (parser,
10047 /*recovering=*/true,
10049 /*consume_paren=*/false);
10050 /* If parsing tentatively, permanently remove the
10051 template argument list. That will prevent duplicate
10052 error messages from being issued about the missing
10053 "template" keyword. */
10055 cp_lexer_purge_tokens_after (parser->lexer, start);
10057 *is_identifier = true;
10061 /* If the "template" keyword is present, then there is generally
10062 no point in doing name-lookup, so we just return IDENTIFIER.
10063 But, if the qualifying scope is non-dependent then we can
10064 (and must) do name-lookup normally. */
10065 if (template_keyword_p
10067 || (TYPE_P (parser->scope)
10068 && dependent_type_p (parser->scope))))
10072 /* Look up the name. */
10073 decl = cp_parser_lookup_name (parser, identifier,
10075 /*is_template=*/false,
10076 /*is_namespace=*/false,
10077 check_dependency_p,
10078 /*ambiguous_decls=*/NULL);
10079 decl = maybe_get_template_decl_from_type_decl (decl);
10081 /* If DECL is a template, then the name was a template-name. */
10082 if (TREE_CODE (decl) == TEMPLATE_DECL)
10086 tree fn = NULL_TREE;
10088 /* The standard does not explicitly indicate whether a name that
10089 names a set of overloaded declarations, some of which are
10090 templates, is a template-name. However, such a name should
10091 be a template-name; otherwise, there is no way to form a
10092 template-id for the overloaded templates. */
10093 fns = BASELINK_P (decl) ? BASELINK_FUNCTIONS (decl) : decl;
10094 if (TREE_CODE (fns) == OVERLOAD)
10095 for (fn = fns; fn; fn = OVL_NEXT (fn))
10096 if (TREE_CODE (OVL_CURRENT (fn)) == TEMPLATE_DECL)
10101 /* The name does not name a template. */
10102 cp_parser_error (parser, "expected template-name");
10103 return error_mark_node;
10107 /* If DECL is dependent, and refers to a function, then just return
10108 its name; we will look it up again during template instantiation. */
10109 if (DECL_FUNCTION_TEMPLATE_P (decl) || !DECL_P (decl))
10111 tree scope = CP_DECL_CONTEXT (get_first_fn (decl));
10112 if (TYPE_P (scope) && dependent_type_p (scope))
10119 /* Parse a template-argument-list.
10121 template-argument-list:
10122 template-argument ... [opt]
10123 template-argument-list , template-argument ... [opt]
10125 Returns a TREE_VEC containing the arguments. */
10128 cp_parser_template_argument_list (cp_parser* parser)
10130 tree fixed_args[10];
10131 unsigned n_args = 0;
10132 unsigned alloced = 10;
10133 tree *arg_ary = fixed_args;
10135 bool saved_in_template_argument_list_p;
10137 bool saved_non_ice_p;
10139 saved_in_template_argument_list_p = parser->in_template_argument_list_p;
10140 parser->in_template_argument_list_p = true;
10141 /* Even if the template-id appears in an integral
10142 constant-expression, the contents of the argument list do
10144 saved_ice_p = parser->integral_constant_expression_p;
10145 parser->integral_constant_expression_p = false;
10146 saved_non_ice_p = parser->non_integral_constant_expression_p;
10147 parser->non_integral_constant_expression_p = false;
10148 /* Parse the arguments. */
10154 /* Consume the comma. */
10155 cp_lexer_consume_token (parser->lexer);
10157 /* Parse the template-argument. */
10158 argument = cp_parser_template_argument (parser);
10160 /* If the next token is an ellipsis, we're expanding a template
10162 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
10164 /* Consume the `...' token. */
10165 cp_lexer_consume_token (parser->lexer);
10167 /* Make the argument into a TYPE_PACK_EXPANSION or
10168 EXPR_PACK_EXPANSION. */
10169 argument = make_pack_expansion (argument);
10172 if (n_args == alloced)
10176 if (arg_ary == fixed_args)
10178 arg_ary = XNEWVEC (tree, alloced);
10179 memcpy (arg_ary, fixed_args, sizeof (tree) * n_args);
10182 arg_ary = XRESIZEVEC (tree, arg_ary, alloced);
10184 arg_ary[n_args++] = argument;
10186 while (cp_lexer_next_token_is (parser->lexer, CPP_COMMA));
10188 vec = make_tree_vec (n_args);
10191 TREE_VEC_ELT (vec, n_args) = arg_ary[n_args];
10193 if (arg_ary != fixed_args)
10195 parser->non_integral_constant_expression_p = saved_non_ice_p;
10196 parser->integral_constant_expression_p = saved_ice_p;
10197 parser->in_template_argument_list_p = saved_in_template_argument_list_p;
10201 /* Parse a template-argument.
10204 assignment-expression
10208 The representation is that of an assignment-expression, type-id, or
10209 id-expression -- except that the qualified id-expression is
10210 evaluated, so that the value returned is either a DECL or an
10213 Although the standard says "assignment-expression", it forbids
10214 throw-expressions or assignments in the template argument.
10215 Therefore, we use "conditional-expression" instead. */
10218 cp_parser_template_argument (cp_parser* parser)
10223 bool maybe_type_id = false;
10227 /* There's really no way to know what we're looking at, so we just
10228 try each alternative in order.
10232 In a template-argument, an ambiguity between a type-id and an
10233 expression is resolved to a type-id, regardless of the form of
10234 the corresponding template-parameter.
10236 Therefore, we try a type-id first. */
10237 cp_parser_parse_tentatively (parser);
10238 argument = cp_parser_type_id (parser);
10239 /* If there was no error parsing the type-id but the next token is a '>>',
10240 we probably found a typo for '> >'. But there are type-id which are
10241 also valid expressions. For instance:
10243 struct X { int operator >> (int); };
10244 template <int V> struct Foo {};
10247 Here 'X()' is a valid type-id of a function type, but the user just
10248 wanted to write the expression "X() >> 5". Thus, we remember that we
10249 found a valid type-id, but we still try to parse the argument as an
10250 expression to see what happens. */
10251 if (!cp_parser_error_occurred (parser)
10252 && cp_lexer_next_token_is (parser->lexer, CPP_RSHIFT))
10254 maybe_type_id = true;
10255 cp_parser_abort_tentative_parse (parser);
10259 /* If the next token isn't a `,' or a `>', then this argument wasn't
10260 really finished. This means that the argument is not a valid
10262 if (!cp_parser_next_token_ends_template_argument_p (parser))
10263 cp_parser_error (parser, "expected template-argument");
10264 /* If that worked, we're done. */
10265 if (cp_parser_parse_definitely (parser))
10268 /* We're still not sure what the argument will be. */
10269 cp_parser_parse_tentatively (parser);
10270 /* Try a template. */
10271 argument = cp_parser_id_expression (parser,
10272 /*template_keyword_p=*/false,
10273 /*check_dependency_p=*/true,
10275 /*declarator_p=*/false,
10276 /*optional_p=*/false);
10277 /* If the next token isn't a `,' or a `>', then this argument wasn't
10278 really finished. */
10279 if (!cp_parser_next_token_ends_template_argument_p (parser))
10280 cp_parser_error (parser, "expected template-argument");
10281 if (!cp_parser_error_occurred (parser))
10283 /* Figure out what is being referred to. If the id-expression
10284 was for a class template specialization, then we will have a
10285 TYPE_DECL at this point. There is no need to do name lookup
10286 at this point in that case. */
10287 if (TREE_CODE (argument) != TYPE_DECL)
10288 argument = cp_parser_lookup_name (parser, argument,
10290 /*is_template=*/template_p,
10291 /*is_namespace=*/false,
10292 /*check_dependency=*/true,
10293 /*ambiguous_decls=*/NULL);
10294 if (TREE_CODE (argument) != TEMPLATE_DECL
10295 && TREE_CODE (argument) != UNBOUND_CLASS_TEMPLATE)
10296 cp_parser_error (parser, "expected template-name");
10298 if (cp_parser_parse_definitely (parser))
10300 /* It must be a non-type argument. There permitted cases are given
10301 in [temp.arg.nontype]:
10303 -- an integral constant-expression of integral or enumeration
10306 -- the name of a non-type template-parameter; or
10308 -- the name of an object or function with external linkage...
10310 -- the address of an object or function with external linkage...
10312 -- a pointer to member... */
10313 /* Look for a non-type template parameter. */
10314 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
10316 cp_parser_parse_tentatively (parser);
10317 argument = cp_parser_primary_expression (parser,
10318 /*adress_p=*/false,
10320 /*template_arg_p=*/true,
10322 if (TREE_CODE (argument) != TEMPLATE_PARM_INDEX
10323 || !cp_parser_next_token_ends_template_argument_p (parser))
10324 cp_parser_simulate_error (parser);
10325 if (cp_parser_parse_definitely (parser))
10329 /* If the next token is "&", the argument must be the address of an
10330 object or function with external linkage. */
10331 address_p = cp_lexer_next_token_is (parser->lexer, CPP_AND);
10333 cp_lexer_consume_token (parser->lexer);
10334 /* See if we might have an id-expression. */
10335 token = cp_lexer_peek_token (parser->lexer);
10336 if (token->type == CPP_NAME
10337 || token->keyword == RID_OPERATOR
10338 || token->type == CPP_SCOPE
10339 || token->type == CPP_TEMPLATE_ID
10340 || token->type == CPP_NESTED_NAME_SPECIFIER)
10342 cp_parser_parse_tentatively (parser);
10343 argument = cp_parser_primary_expression (parser,
10346 /*template_arg_p=*/true,
10348 if (cp_parser_error_occurred (parser)
10349 || !cp_parser_next_token_ends_template_argument_p (parser))
10350 cp_parser_abort_tentative_parse (parser);
10353 if (TREE_CODE (argument) == INDIRECT_REF)
10355 gcc_assert (REFERENCE_REF_P (argument));
10356 argument = TREE_OPERAND (argument, 0);
10359 if (TREE_CODE (argument) == VAR_DECL)
10361 /* A variable without external linkage might still be a
10362 valid constant-expression, so no error is issued here
10363 if the external-linkage check fails. */
10364 if (!address_p && !DECL_EXTERNAL_LINKAGE_P (argument))
10365 cp_parser_simulate_error (parser);
10367 else if (is_overloaded_fn (argument))
10368 /* All overloaded functions are allowed; if the external
10369 linkage test does not pass, an error will be issued
10373 && (TREE_CODE (argument) == OFFSET_REF
10374 || TREE_CODE (argument) == SCOPE_REF))
10375 /* A pointer-to-member. */
10377 else if (TREE_CODE (argument) == TEMPLATE_PARM_INDEX)
10380 cp_parser_simulate_error (parser);
10382 if (cp_parser_parse_definitely (parser))
10385 argument = build_x_unary_op (ADDR_EXPR, argument,
10386 tf_warning_or_error);
10391 /* If the argument started with "&", there are no other valid
10392 alternatives at this point. */
10395 cp_parser_error (parser, "invalid non-type template argument");
10396 return error_mark_node;
10399 /* If the argument wasn't successfully parsed as a type-id followed
10400 by '>>', the argument can only be a constant expression now.
10401 Otherwise, we try parsing the constant-expression tentatively,
10402 because the argument could really be a type-id. */
10404 cp_parser_parse_tentatively (parser);
10405 argument = cp_parser_constant_expression (parser,
10406 /*allow_non_constant_p=*/false,
10407 /*non_constant_p=*/NULL);
10408 argument = fold_non_dependent_expr (argument);
10409 if (!maybe_type_id)
10411 if (!cp_parser_next_token_ends_template_argument_p (parser))
10412 cp_parser_error (parser, "expected template-argument");
10413 if (cp_parser_parse_definitely (parser))
10415 /* We did our best to parse the argument as a non type-id, but that
10416 was the only alternative that matched (albeit with a '>' after
10417 it). We can assume it's just a typo from the user, and a
10418 diagnostic will then be issued. */
10419 return cp_parser_type_id (parser);
10422 /* Parse an explicit-instantiation.
10424 explicit-instantiation:
10425 template declaration
10427 Although the standard says `declaration', what it really means is:
10429 explicit-instantiation:
10430 template decl-specifier-seq [opt] declarator [opt] ;
10432 Things like `template int S<int>::i = 5, int S<double>::j;' are not
10433 supposed to be allowed. A defect report has been filed about this
10438 explicit-instantiation:
10439 storage-class-specifier template
10440 decl-specifier-seq [opt] declarator [opt] ;
10441 function-specifier template
10442 decl-specifier-seq [opt] declarator [opt] ; */
10445 cp_parser_explicit_instantiation (cp_parser* parser)
10447 int declares_class_or_enum;
10448 cp_decl_specifier_seq decl_specifiers;
10449 tree extension_specifier = NULL_TREE;
10451 /* Look for an (optional) storage-class-specifier or
10452 function-specifier. */
10453 if (cp_parser_allow_gnu_extensions_p (parser))
10455 extension_specifier
10456 = cp_parser_storage_class_specifier_opt (parser);
10457 if (!extension_specifier)
10458 extension_specifier
10459 = cp_parser_function_specifier_opt (parser,
10460 /*decl_specs=*/NULL);
10463 /* Look for the `template' keyword. */
10464 cp_parser_require_keyword (parser, RID_TEMPLATE, "%<template%>");
10465 /* Let the front end know that we are processing an explicit
10467 begin_explicit_instantiation ();
10468 /* [temp.explicit] says that we are supposed to ignore access
10469 control while processing explicit instantiation directives. */
10470 push_deferring_access_checks (dk_no_check);
10471 /* Parse a decl-specifier-seq. */
10472 cp_parser_decl_specifier_seq (parser,
10473 CP_PARSER_FLAGS_OPTIONAL,
10475 &declares_class_or_enum);
10476 /* If there was exactly one decl-specifier, and it declared a class,
10477 and there's no declarator, then we have an explicit type
10479 if (declares_class_or_enum && cp_parser_declares_only_class_p (parser))
10483 type = check_tag_decl (&decl_specifiers);
10484 /* Turn access control back on for names used during
10485 template instantiation. */
10486 pop_deferring_access_checks ();
10488 do_type_instantiation (type, extension_specifier,
10489 /*complain=*/tf_error);
10493 cp_declarator *declarator;
10496 /* Parse the declarator. */
10498 = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
10499 /*ctor_dtor_or_conv_p=*/NULL,
10500 /*parenthesized_p=*/NULL,
10501 /*member_p=*/false);
10502 if (declares_class_or_enum & 2)
10503 cp_parser_check_for_definition_in_return_type (declarator,
10504 decl_specifiers.type);
10505 if (declarator != cp_error_declarator)
10507 decl = grokdeclarator (declarator, &decl_specifiers,
10508 NORMAL, 0, &decl_specifiers.attributes);
10509 /* Turn access control back on for names used during
10510 template instantiation. */
10511 pop_deferring_access_checks ();
10512 /* Do the explicit instantiation. */
10513 do_decl_instantiation (decl, extension_specifier);
10517 pop_deferring_access_checks ();
10518 /* Skip the body of the explicit instantiation. */
10519 cp_parser_skip_to_end_of_statement (parser);
10522 /* We're done with the instantiation. */
10523 end_explicit_instantiation ();
10525 cp_parser_consume_semicolon_at_end_of_statement (parser);
10528 /* Parse an explicit-specialization.
10530 explicit-specialization:
10531 template < > declaration
10533 Although the standard says `declaration', what it really means is:
10535 explicit-specialization:
10536 template <> decl-specifier [opt] init-declarator [opt] ;
10537 template <> function-definition
10538 template <> explicit-specialization
10539 template <> template-declaration */
10542 cp_parser_explicit_specialization (cp_parser* parser)
10544 bool need_lang_pop;
10545 /* Look for the `template' keyword. */
10546 cp_parser_require_keyword (parser, RID_TEMPLATE, "%<template%>");
10547 /* Look for the `<'. */
10548 cp_parser_require (parser, CPP_LESS, "%<<%>");
10549 /* Look for the `>'. */
10550 cp_parser_require (parser, CPP_GREATER, "%<>%>");
10551 /* We have processed another parameter list. */
10552 ++parser->num_template_parameter_lists;
10555 A template ... explicit specialization ... shall not have C
10557 if (current_lang_name == lang_name_c)
10559 error ("template specialization with C linkage");
10560 /* Give it C++ linkage to avoid confusing other parts of the
10562 push_lang_context (lang_name_cplusplus);
10563 need_lang_pop = true;
10566 need_lang_pop = false;
10567 /* Let the front end know that we are beginning a specialization. */
10568 if (!begin_specialization ())
10570 end_specialization ();
10571 cp_parser_skip_to_end_of_block_or_statement (parser);
10575 /* If the next keyword is `template', we need to figure out whether
10576 or not we're looking a template-declaration. */
10577 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
10579 if (cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_LESS
10580 && cp_lexer_peek_nth_token (parser->lexer, 3)->type != CPP_GREATER)
10581 cp_parser_template_declaration_after_export (parser,
10582 /*member_p=*/false);
10584 cp_parser_explicit_specialization (parser);
10587 /* Parse the dependent declaration. */
10588 cp_parser_single_declaration (parser,
10590 /*member_p=*/false,
10591 /*explicit_specialization_p=*/true,
10592 /*friend_p=*/NULL);
10593 /* We're done with the specialization. */
10594 end_specialization ();
10595 /* For the erroneous case of a template with C linkage, we pushed an
10596 implicit C++ linkage scope; exit that scope now. */
10598 pop_lang_context ();
10599 /* We're done with this parameter list. */
10600 --parser->num_template_parameter_lists;
10603 /* Parse a type-specifier.
10606 simple-type-specifier
10609 elaborated-type-specifier
10617 Returns a representation of the type-specifier. For a
10618 class-specifier, enum-specifier, or elaborated-type-specifier, a
10619 TREE_TYPE is returned; otherwise, a TYPE_DECL is returned.
10621 The parser flags FLAGS is used to control type-specifier parsing.
10623 If IS_DECLARATION is TRUE, then this type-specifier is appearing
10624 in a decl-specifier-seq.
10626 If DECLARES_CLASS_OR_ENUM is non-NULL, and the type-specifier is a
10627 class-specifier, enum-specifier, or elaborated-type-specifier, then
10628 *DECLARES_CLASS_OR_ENUM is set to a nonzero value. The value is 1
10629 if a type is declared; 2 if it is defined. Otherwise, it is set to
10632 If IS_CV_QUALIFIER is non-NULL, and the type-specifier is a
10633 cv-qualifier, then IS_CV_QUALIFIER is set to TRUE. Otherwise, it
10634 is set to FALSE. */
10637 cp_parser_type_specifier (cp_parser* parser,
10638 cp_parser_flags flags,
10639 cp_decl_specifier_seq *decl_specs,
10640 bool is_declaration,
10641 int* declares_class_or_enum,
10642 bool* is_cv_qualifier)
10644 tree type_spec = NULL_TREE;
10647 cp_decl_spec ds = ds_last;
10649 /* Assume this type-specifier does not declare a new type. */
10650 if (declares_class_or_enum)
10651 *declares_class_or_enum = 0;
10652 /* And that it does not specify a cv-qualifier. */
10653 if (is_cv_qualifier)
10654 *is_cv_qualifier = false;
10655 /* Peek at the next token. */
10656 token = cp_lexer_peek_token (parser->lexer);
10658 /* If we're looking at a keyword, we can use that to guide the
10659 production we choose. */
10660 keyword = token->keyword;
10664 /* Look for the enum-specifier. */
10665 type_spec = cp_parser_enum_specifier (parser);
10666 /* If that worked, we're done. */
10669 if (declares_class_or_enum)
10670 *declares_class_or_enum = 2;
10672 cp_parser_set_decl_spec_type (decl_specs,
10674 /*user_defined_p=*/true);
10678 goto elaborated_type_specifier;
10680 /* Any of these indicate either a class-specifier, or an
10681 elaborated-type-specifier. */
10685 /* Parse tentatively so that we can back up if we don't find a
10686 class-specifier. */
10687 cp_parser_parse_tentatively (parser);
10688 /* Look for the class-specifier. */
10689 type_spec = cp_parser_class_specifier (parser);
10690 /* If that worked, we're done. */
10691 if (cp_parser_parse_definitely (parser))
10693 if (declares_class_or_enum)
10694 *declares_class_or_enum = 2;
10696 cp_parser_set_decl_spec_type (decl_specs,
10698 /*user_defined_p=*/true);
10702 /* Fall through. */
10703 elaborated_type_specifier:
10704 /* We're declaring (not defining) a class or enum. */
10705 if (declares_class_or_enum)
10706 *declares_class_or_enum = 1;
10708 /* Fall through. */
10710 /* Look for an elaborated-type-specifier. */
10712 = (cp_parser_elaborated_type_specifier
10714 decl_specs && decl_specs->specs[(int) ds_friend],
10717 cp_parser_set_decl_spec_type (decl_specs,
10719 /*user_defined_p=*/true);
10724 if (is_cv_qualifier)
10725 *is_cv_qualifier = true;
10730 if (is_cv_qualifier)
10731 *is_cv_qualifier = true;
10736 if (is_cv_qualifier)
10737 *is_cv_qualifier = true;
10741 /* The `__complex__' keyword is a GNU extension. */
10749 /* Handle simple keywords. */
10754 ++decl_specs->specs[(int)ds];
10755 decl_specs->any_specifiers_p = true;
10757 return cp_lexer_consume_token (parser->lexer)->u.value;
10760 /* If we do not already have a type-specifier, assume we are looking
10761 at a simple-type-specifier. */
10762 type_spec = cp_parser_simple_type_specifier (parser,
10766 /* If we didn't find a type-specifier, and a type-specifier was not
10767 optional in this context, issue an error message. */
10768 if (!type_spec && !(flags & CP_PARSER_FLAGS_OPTIONAL))
10770 cp_parser_error (parser, "expected type specifier");
10771 return error_mark_node;
10777 /* Parse a simple-type-specifier.
10779 simple-type-specifier:
10780 :: [opt] nested-name-specifier [opt] type-name
10781 :: [opt] nested-name-specifier template template-id
10796 simple-type-specifier:
10798 decltype ( expression )
10804 simple-type-specifier:
10805 __typeof__ unary-expression
10806 __typeof__ ( type-id )
10808 Returns the indicated TYPE_DECL. If DECL_SPECS is not NULL, it is
10809 appropriately updated. */
10812 cp_parser_simple_type_specifier (cp_parser* parser,
10813 cp_decl_specifier_seq *decl_specs,
10814 cp_parser_flags flags)
10816 tree type = NULL_TREE;
10819 /* Peek at the next token. */
10820 token = cp_lexer_peek_token (parser->lexer);
10822 /* If we're looking at a keyword, things are easy. */
10823 switch (token->keyword)
10827 decl_specs->explicit_char_p = true;
10828 type = char_type_node;
10831 type = char16_type_node;
10834 type = char32_type_node;
10837 type = wchar_type_node;
10840 type = boolean_type_node;
10844 ++decl_specs->specs[(int) ds_short];
10845 type = short_integer_type_node;
10849 decl_specs->explicit_int_p = true;
10850 type = integer_type_node;
10854 ++decl_specs->specs[(int) ds_long];
10855 type = long_integer_type_node;
10859 ++decl_specs->specs[(int) ds_signed];
10860 type = integer_type_node;
10864 ++decl_specs->specs[(int) ds_unsigned];
10865 type = unsigned_type_node;
10868 type = float_type_node;
10871 type = double_type_node;
10874 type = void_type_node;
10878 if (cxx_dialect != cxx98)
10880 /* Consume the token. */
10881 cp_lexer_consume_token (parser->lexer);
10882 /* We do not yet support the use of `auto' as a
10884 error ("C++0x %<auto%> specifier not supported");
10889 /* Parse the `decltype' type. */
10890 type = cp_parser_decltype (parser);
10893 cp_parser_set_decl_spec_type (decl_specs, type,
10894 /*user_defined_p=*/true);
10899 /* Consume the `typeof' token. */
10900 cp_lexer_consume_token (parser->lexer);
10901 /* Parse the operand to `typeof'. */
10902 type = cp_parser_sizeof_operand (parser, RID_TYPEOF);
10903 /* If it is not already a TYPE, take its type. */
10904 if (!TYPE_P (type))
10905 type = finish_typeof (type);
10908 cp_parser_set_decl_spec_type (decl_specs, type,
10909 /*user_defined_p=*/true);
10917 /* If the type-specifier was for a built-in type, we're done. */
10922 /* Record the type. */
10924 && (token->keyword != RID_SIGNED
10925 && token->keyword != RID_UNSIGNED
10926 && token->keyword != RID_SHORT
10927 && token->keyword != RID_LONG))
10928 cp_parser_set_decl_spec_type (decl_specs,
10930 /*user_defined=*/false);
10932 decl_specs->any_specifiers_p = true;
10934 /* Consume the token. */
10935 id = cp_lexer_consume_token (parser->lexer)->u.value;
10937 /* There is no valid C++ program where a non-template type is
10938 followed by a "<". That usually indicates that the user thought
10939 that the type was a template. */
10940 cp_parser_check_for_invalid_template_id (parser, type);
10942 return TYPE_NAME (type);
10945 /* The type-specifier must be a user-defined type. */
10946 if (!(flags & CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES))
10951 /* Don't gobble tokens or issue error messages if this is an
10952 optional type-specifier. */
10953 if (flags & CP_PARSER_FLAGS_OPTIONAL)
10954 cp_parser_parse_tentatively (parser);
10956 /* Look for the optional `::' operator. */
10958 = (cp_parser_global_scope_opt (parser,
10959 /*current_scope_valid_p=*/false)
10961 /* Look for the nested-name specifier. */
10963 = (cp_parser_nested_name_specifier_opt (parser,
10964 /*typename_keyword_p=*/false,
10965 /*check_dependency_p=*/true,
10967 /*is_declaration=*/false)
10969 /* If we have seen a nested-name-specifier, and the next token
10970 is `template', then we are using the template-id production. */
10972 && cp_parser_optional_template_keyword (parser))
10974 /* Look for the template-id. */
10975 type = cp_parser_template_id (parser,
10976 /*template_keyword_p=*/true,
10977 /*check_dependency_p=*/true,
10978 /*is_declaration=*/false);
10979 /* If the template-id did not name a type, we are out of
10981 if (TREE_CODE (type) != TYPE_DECL)
10983 cp_parser_error (parser, "expected template-id for type");
10987 /* Otherwise, look for a type-name. */
10989 type = cp_parser_type_name (parser);
10990 /* Keep track of all name-lookups performed in class scopes. */
10994 && TREE_CODE (type) == TYPE_DECL
10995 && TREE_CODE (DECL_NAME (type)) == IDENTIFIER_NODE)
10996 maybe_note_name_used_in_class (DECL_NAME (type), type);
10997 /* If it didn't work out, we don't have a TYPE. */
10998 if ((flags & CP_PARSER_FLAGS_OPTIONAL)
10999 && !cp_parser_parse_definitely (parser))
11001 if (type && decl_specs)
11002 cp_parser_set_decl_spec_type (decl_specs, type,
11003 /*user_defined=*/true);
11006 /* If we didn't get a type-name, issue an error message. */
11007 if (!type && !(flags & CP_PARSER_FLAGS_OPTIONAL))
11009 cp_parser_error (parser, "expected type-name");
11010 return error_mark_node;
11013 /* There is no valid C++ program where a non-template type is
11014 followed by a "<". That usually indicates that the user thought
11015 that the type was a template. */
11016 if (type && type != error_mark_node)
11018 /* As a last-ditch effort, see if TYPE is an Objective-C type.
11019 If it is, then the '<'...'>' enclose protocol names rather than
11020 template arguments, and so everything is fine. */
11021 if (c_dialect_objc ()
11022 && (objc_is_id (type) || objc_is_class_name (type)))
11024 tree protos = cp_parser_objc_protocol_refs_opt (parser);
11025 tree qual_type = objc_get_protocol_qualified_type (type, protos);
11027 /* Clobber the "unqualified" type previously entered into
11028 DECL_SPECS with the new, improved protocol-qualified version. */
11030 decl_specs->type = qual_type;
11035 cp_parser_check_for_invalid_template_id (parser, TREE_TYPE (type));
11041 /* Parse a type-name.
11054 Returns a TYPE_DECL for the type. */
11057 cp_parser_type_name (cp_parser* parser)
11061 /* We can't know yet whether it is a class-name or not. */
11062 cp_parser_parse_tentatively (parser);
11063 /* Try a class-name. */
11064 type_decl = cp_parser_class_name (parser,
11065 /*typename_keyword_p=*/false,
11066 /*template_keyword_p=*/false,
11068 /*check_dependency_p=*/true,
11069 /*class_head_p=*/false,
11070 /*is_declaration=*/false);
11071 /* If it's not a class-name, keep looking. */
11072 if (!cp_parser_parse_definitely (parser))
11074 /* It must be a typedef-name or an enum-name. */
11075 return cp_parser_nonclass_name (parser);
11081 /* Parse a non-class type-name, that is, either an enum-name or a typedef-name.
11089 Returns a TYPE_DECL for the type. */
11092 cp_parser_nonclass_name (cp_parser* parser)
11097 identifier = cp_parser_identifier (parser);
11098 if (identifier == error_mark_node)
11099 return error_mark_node;
11101 /* Look up the type-name. */
11102 type_decl = cp_parser_lookup_name_simple (parser, identifier);
11104 if (TREE_CODE (type_decl) != TYPE_DECL
11105 && (objc_is_id (identifier) || objc_is_class_name (identifier)))
11107 /* See if this is an Objective-C type. */
11108 tree protos = cp_parser_objc_protocol_refs_opt (parser);
11109 tree type = objc_get_protocol_qualified_type (identifier, protos);
11111 type_decl = TYPE_NAME (type);
11114 /* Issue an error if we did not find a type-name. */
11115 if (TREE_CODE (type_decl) != TYPE_DECL)
11117 if (!cp_parser_simulate_error (parser))
11118 cp_parser_name_lookup_error (parser, identifier, type_decl,
11120 return error_mark_node;
11122 /* Remember that the name was used in the definition of the
11123 current class so that we can check later to see if the
11124 meaning would have been different after the class was
11125 entirely defined. */
11126 else if (type_decl != error_mark_node
11128 maybe_note_name_used_in_class (identifier, type_decl);
11133 /* Parse an elaborated-type-specifier. Note that the grammar given
11134 here incorporates the resolution to DR68.
11136 elaborated-type-specifier:
11137 class-key :: [opt] nested-name-specifier [opt] identifier
11138 class-key :: [opt] nested-name-specifier [opt] template [opt] template-id
11139 enum :: [opt] nested-name-specifier [opt] identifier
11140 typename :: [opt] nested-name-specifier identifier
11141 typename :: [opt] nested-name-specifier template [opt]
11146 elaborated-type-specifier:
11147 class-key attributes :: [opt] nested-name-specifier [opt] identifier
11148 class-key attributes :: [opt] nested-name-specifier [opt]
11149 template [opt] template-id
11150 enum attributes :: [opt] nested-name-specifier [opt] identifier
11152 If IS_FRIEND is TRUE, then this elaborated-type-specifier is being
11153 declared `friend'. If IS_DECLARATION is TRUE, then this
11154 elaborated-type-specifier appears in a decl-specifiers-seq, i.e.,
11155 something is being declared.
11157 Returns the TYPE specified. */
11160 cp_parser_elaborated_type_specifier (cp_parser* parser,
11162 bool is_declaration)
11164 enum tag_types tag_type;
11166 tree type = NULL_TREE;
11167 tree attributes = NULL_TREE;
11169 /* See if we're looking at the `enum' keyword. */
11170 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_ENUM))
11172 /* Consume the `enum' token. */
11173 cp_lexer_consume_token (parser->lexer);
11174 /* Remember that it's an enumeration type. */
11175 tag_type = enum_type;
11176 /* Parse the attributes. */
11177 attributes = cp_parser_attributes_opt (parser);
11179 /* Or, it might be `typename'. */
11180 else if (cp_lexer_next_token_is_keyword (parser->lexer,
11183 /* Consume the `typename' token. */
11184 cp_lexer_consume_token (parser->lexer);
11185 /* Remember that it's a `typename' type. */
11186 tag_type = typename_type;
11187 /* The `typename' keyword is only allowed in templates. */
11188 if (!processing_template_decl)
11189 pedwarn ("using %<typename%> outside of template");
11191 /* Otherwise it must be a class-key. */
11194 tag_type = cp_parser_class_key (parser);
11195 if (tag_type == none_type)
11196 return error_mark_node;
11197 /* Parse the attributes. */
11198 attributes = cp_parser_attributes_opt (parser);
11201 /* Look for the `::' operator. */
11202 cp_parser_global_scope_opt (parser,
11203 /*current_scope_valid_p=*/false);
11204 /* Look for the nested-name-specifier. */
11205 if (tag_type == typename_type)
11207 if (!cp_parser_nested_name_specifier (parser,
11208 /*typename_keyword_p=*/true,
11209 /*check_dependency_p=*/true,
11212 return error_mark_node;
11215 /* Even though `typename' is not present, the proposed resolution
11216 to Core Issue 180 says that in `class A<T>::B', `B' should be
11217 considered a type-name, even if `A<T>' is dependent. */
11218 cp_parser_nested_name_specifier_opt (parser,
11219 /*typename_keyword_p=*/true,
11220 /*check_dependency_p=*/true,
11223 /* For everything but enumeration types, consider a template-id.
11224 For an enumeration type, consider only a plain identifier. */
11225 if (tag_type != enum_type)
11227 bool template_p = false;
11230 /* Allow the `template' keyword. */
11231 template_p = cp_parser_optional_template_keyword (parser);
11232 /* If we didn't see `template', we don't know if there's a
11233 template-id or not. */
11235 cp_parser_parse_tentatively (parser);
11236 /* Parse the template-id. */
11237 decl = cp_parser_template_id (parser, template_p,
11238 /*check_dependency_p=*/true,
11240 /* If we didn't find a template-id, look for an ordinary
11242 if (!template_p && !cp_parser_parse_definitely (parser))
11244 /* If DECL is a TEMPLATE_ID_EXPR, and the `typename' keyword is
11245 in effect, then we must assume that, upon instantiation, the
11246 template will correspond to a class. */
11247 else if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
11248 && tag_type == typename_type)
11249 type = make_typename_type (parser->scope, decl,
11251 /*complain=*/tf_error);
11253 type = TREE_TYPE (decl);
11258 identifier = cp_parser_identifier (parser);
11260 if (identifier == error_mark_node)
11262 parser->scope = NULL_TREE;
11263 return error_mark_node;
11266 /* For a `typename', we needn't call xref_tag. */
11267 if (tag_type == typename_type
11268 && TREE_CODE (parser->scope) != NAMESPACE_DECL)
11269 return cp_parser_make_typename_type (parser, parser->scope,
11271 /* Look up a qualified name in the usual way. */
11275 tree ambiguous_decls;
11277 decl = cp_parser_lookup_name (parser, identifier,
11279 /*is_template=*/false,
11280 /*is_namespace=*/false,
11281 /*check_dependency=*/true,
11284 /* If the lookup was ambiguous, an error will already have been
11286 if (ambiguous_decls)
11287 return error_mark_node;
11289 /* If we are parsing friend declaration, DECL may be a
11290 TEMPLATE_DECL tree node here. However, we need to check
11291 whether this TEMPLATE_DECL results in valid code. Consider
11292 the following example:
11295 template <class T> class C {};
11298 template <class T> friend class N::C; // #1, valid code
11300 template <class T> class Y {
11301 friend class N::C; // #2, invalid code
11304 For both case #1 and #2, we arrive at a TEMPLATE_DECL after
11305 name lookup of `N::C'. We see that friend declaration must
11306 be template for the code to be valid. Note that
11307 processing_template_decl does not work here since it is
11308 always 1 for the above two cases. */
11310 decl = (cp_parser_maybe_treat_template_as_class
11311 (decl, /*tag_name_p=*/is_friend
11312 && parser->num_template_parameter_lists));
11314 if (TREE_CODE (decl) != TYPE_DECL)
11316 cp_parser_diagnose_invalid_type_name (parser,
11319 return error_mark_node;
11322 if (TREE_CODE (TREE_TYPE (decl)) != TYPENAME_TYPE)
11324 bool allow_template = (parser->num_template_parameter_lists
11325 || DECL_SELF_REFERENCE_P (decl));
11326 type = check_elaborated_type_specifier (tag_type, decl,
11329 if (type == error_mark_node)
11330 return error_mark_node;
11333 /* Forward declarations of nested types, such as
11338 are invalid unless all components preceding the final '::'
11339 are complete. If all enclosing types are complete, these
11340 declarations become merely pointless.
11342 Invalid forward declarations of nested types are errors
11343 caught elsewhere in parsing. Those that are pointless arrive
11346 if (cp_parser_declares_only_class_p (parser)
11347 && !is_friend && !processing_explicit_instantiation)
11348 warning (0, "declaration %qD does not declare anything", decl);
11350 type = TREE_TYPE (decl);
11354 /* An elaborated-type-specifier sometimes introduces a new type and
11355 sometimes names an existing type. Normally, the rule is that it
11356 introduces a new type only if there is not an existing type of
11357 the same name already in scope. For example, given:
11360 void f() { struct S s; }
11362 the `struct S' in the body of `f' is the same `struct S' as in
11363 the global scope; the existing definition is used. However, if
11364 there were no global declaration, this would introduce a new
11365 local class named `S'.
11367 An exception to this rule applies to the following code:
11369 namespace N { struct S; }
11371 Here, the elaborated-type-specifier names a new type
11372 unconditionally; even if there is already an `S' in the
11373 containing scope this declaration names a new type.
11374 This exception only applies if the elaborated-type-specifier
11375 forms the complete declaration:
11379 A declaration consisting solely of `class-key identifier ;' is
11380 either a redeclaration of the name in the current scope or a
11381 forward declaration of the identifier as a class name. It
11382 introduces the name into the current scope.
11384 We are in this situation precisely when the next token is a `;'.
11386 An exception to the exception is that a `friend' declaration does
11387 *not* name a new type; i.e., given:
11389 struct S { friend struct T; };
11391 `T' is not a new type in the scope of `S'.
11393 Also, `new struct S' or `sizeof (struct S)' never results in the
11394 definition of a new type; a new type can only be declared in a
11395 declaration context. */
11401 /* Friends have special name lookup rules. */
11402 ts = ts_within_enclosing_non_class;
11403 else if (is_declaration
11404 && cp_lexer_next_token_is (parser->lexer,
11406 /* This is a `class-key identifier ;' */
11412 (parser->num_template_parameter_lists
11413 && (cp_parser_next_token_starts_class_definition_p (parser)
11414 || cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)));
11415 /* An unqualified name was used to reference this type, so
11416 there were no qualifying templates. */
11417 if (!cp_parser_check_template_parameters (parser,
11418 /*num_templates=*/0))
11419 return error_mark_node;
11420 type = xref_tag (tag_type, identifier, ts, template_p);
11424 if (type == error_mark_node)
11425 return error_mark_node;
11427 /* Allow attributes on forward declarations of classes. */
11430 if (TREE_CODE (type) == TYPENAME_TYPE)
11431 warning (OPT_Wattributes,
11432 "attributes ignored on uninstantiated type");
11433 else if (tag_type != enum_type && CLASSTYPE_TEMPLATE_INSTANTIATION (type)
11434 && ! processing_explicit_instantiation)
11435 warning (OPT_Wattributes,
11436 "attributes ignored on template instantiation");
11437 else if (is_declaration && cp_parser_declares_only_class_p (parser))
11438 cplus_decl_attributes (&type, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
11440 warning (OPT_Wattributes,
11441 "attributes ignored on elaborated-type-specifier that is not a forward declaration");
11444 if (tag_type != enum_type)
11445 cp_parser_check_class_key (tag_type, type);
11447 /* A "<" cannot follow an elaborated type specifier. If that
11448 happens, the user was probably trying to form a template-id. */
11449 cp_parser_check_for_invalid_template_id (parser, type);
11454 /* Parse an enum-specifier.
11457 enum identifier [opt] { enumerator-list [opt] }
11460 enum attributes[opt] identifier [opt] { enumerator-list [opt] }
11463 Returns an ENUM_TYPE representing the enumeration, or NULL_TREE
11464 if the token stream isn't an enum-specifier after all. */
11467 cp_parser_enum_specifier (cp_parser* parser)
11473 /* Parse tentatively so that we can back up if we don't find a
11475 cp_parser_parse_tentatively (parser);
11477 /* Caller guarantees that the current token is 'enum', an identifier
11478 possibly follows, and the token after that is an opening brace.
11479 If we don't have an identifier, fabricate an anonymous name for
11480 the enumeration being defined. */
11481 cp_lexer_consume_token (parser->lexer);
11483 attributes = cp_parser_attributes_opt (parser);
11485 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
11486 identifier = cp_parser_identifier (parser);
11488 identifier = make_anon_name ();
11490 /* Look for the `{' but don't consume it yet. */
11491 if (!cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
11492 cp_parser_simulate_error (parser);
11494 if (!cp_parser_parse_definitely (parser))
11497 /* Issue an error message if type-definitions are forbidden here. */
11498 if (!cp_parser_check_type_definition (parser))
11499 type = error_mark_node;
11501 /* Create the new type. We do this before consuming the opening
11502 brace so the enum will be recorded as being on the line of its
11503 tag (or the 'enum' keyword, if there is no tag). */
11504 type = start_enum (identifier);
11506 /* Consume the opening brace. */
11507 cp_lexer_consume_token (parser->lexer);
11509 if (type == error_mark_node)
11511 cp_parser_skip_to_end_of_block_or_statement (parser);
11512 return error_mark_node;
11515 /* If the next token is not '}', then there are some enumerators. */
11516 if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_BRACE))
11517 cp_parser_enumerator_list (parser, type);
11519 /* Consume the final '}'. */
11520 cp_parser_require (parser, CPP_CLOSE_BRACE, "%<}%>");
11522 /* Look for trailing attributes to apply to this enumeration, and
11523 apply them if appropriate. */
11524 if (cp_parser_allow_gnu_extensions_p (parser))
11526 tree trailing_attr = cp_parser_attributes_opt (parser);
11527 cplus_decl_attributes (&type,
11529 (int) ATTR_FLAG_TYPE_IN_PLACE);
11532 /* Finish up the enumeration. */
11533 finish_enum (type);
11538 /* Parse an enumerator-list. The enumerators all have the indicated
11542 enumerator-definition
11543 enumerator-list , enumerator-definition */
11546 cp_parser_enumerator_list (cp_parser* parser, tree type)
11550 /* Parse an enumerator-definition. */
11551 cp_parser_enumerator_definition (parser, type);
11553 /* If the next token is not a ',', we've reached the end of
11555 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
11557 /* Otherwise, consume the `,' and keep going. */
11558 cp_lexer_consume_token (parser->lexer);
11559 /* If the next token is a `}', there is a trailing comma. */
11560 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
11562 if (pedantic && !in_system_header)
11563 pedwarn ("comma at end of enumerator list");
11569 /* Parse an enumerator-definition. The enumerator has the indicated
11572 enumerator-definition:
11574 enumerator = constant-expression
11580 cp_parser_enumerator_definition (cp_parser* parser, tree type)
11585 /* Look for the identifier. */
11586 identifier = cp_parser_identifier (parser);
11587 if (identifier == error_mark_node)
11590 /* If the next token is an '=', then there is an explicit value. */
11591 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
11593 /* Consume the `=' token. */
11594 cp_lexer_consume_token (parser->lexer);
11595 /* Parse the value. */
11596 value = cp_parser_constant_expression (parser,
11597 /*allow_non_constant_p=*/false,
11603 /* Create the enumerator. */
11604 build_enumerator (identifier, value, type);
11607 /* Parse a namespace-name.
11610 original-namespace-name
11613 Returns the NAMESPACE_DECL for the namespace. */
11616 cp_parser_namespace_name (cp_parser* parser)
11619 tree namespace_decl;
11621 /* Get the name of the namespace. */
11622 identifier = cp_parser_identifier (parser);
11623 if (identifier == error_mark_node)
11624 return error_mark_node;
11626 /* Look up the identifier in the currently active scope. Look only
11627 for namespaces, due to:
11629 [basic.lookup.udir]
11631 When looking up a namespace-name in a using-directive or alias
11632 definition, only namespace names are considered.
11636 [basic.lookup.qual]
11638 During the lookup of a name preceding the :: scope resolution
11639 operator, object, function, and enumerator names are ignored.
11641 (Note that cp_parser_class_or_namespace_name only calls this
11642 function if the token after the name is the scope resolution
11644 namespace_decl = cp_parser_lookup_name (parser, identifier,
11646 /*is_template=*/false,
11647 /*is_namespace=*/true,
11648 /*check_dependency=*/true,
11649 /*ambiguous_decls=*/NULL);
11650 /* If it's not a namespace, issue an error. */
11651 if (namespace_decl == error_mark_node
11652 || TREE_CODE (namespace_decl) != NAMESPACE_DECL)
11654 if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
11655 error ("%qD is not a namespace-name", identifier);
11656 cp_parser_error (parser, "expected namespace-name");
11657 namespace_decl = error_mark_node;
11660 return namespace_decl;
11663 /* Parse a namespace-definition.
11665 namespace-definition:
11666 named-namespace-definition
11667 unnamed-namespace-definition
11669 named-namespace-definition:
11670 original-namespace-definition
11671 extension-namespace-definition
11673 original-namespace-definition:
11674 namespace identifier { namespace-body }
11676 extension-namespace-definition:
11677 namespace original-namespace-name { namespace-body }
11679 unnamed-namespace-definition:
11680 namespace { namespace-body } */
11683 cp_parser_namespace_definition (cp_parser* parser)
11685 tree identifier, attribs;
11686 bool has_visibility;
11689 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_INLINE))
11692 cp_lexer_consume_token (parser->lexer);
11697 /* Look for the `namespace' keyword. */
11698 cp_parser_require_keyword (parser, RID_NAMESPACE, "%<namespace%>");
11700 /* Get the name of the namespace. We do not attempt to distinguish
11701 between an original-namespace-definition and an
11702 extension-namespace-definition at this point. The semantic
11703 analysis routines are responsible for that. */
11704 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
11705 identifier = cp_parser_identifier (parser);
11707 identifier = NULL_TREE;
11709 /* Parse any specified attributes. */
11710 attribs = cp_parser_attributes_opt (parser);
11712 /* Look for the `{' to start the namespace. */
11713 cp_parser_require (parser, CPP_OPEN_BRACE, "%<{%>");
11714 /* Start the namespace. */
11715 push_namespace (identifier);
11717 /* "inline namespace" is equivalent to a stub namespace definition
11718 followed by a strong using directive. */
11721 tree namespace = current_namespace;
11722 /* Set up namespace association. */
11723 DECL_NAMESPACE_ASSOCIATIONS (namespace)
11724 = tree_cons (CP_DECL_CONTEXT (namespace), NULL_TREE,
11725 DECL_NAMESPACE_ASSOCIATIONS (namespace));
11726 /* Import the contents of the inline namespace. */
11728 do_using_directive (namespace);
11729 push_namespace (identifier);
11732 has_visibility = handle_namespace_attrs (current_namespace, attribs);
11734 /* Parse the body of the namespace. */
11735 cp_parser_namespace_body (parser);
11737 #ifdef HANDLE_PRAGMA_VISIBILITY
11738 if (has_visibility)
11742 /* Finish the namespace. */
11744 /* Look for the final `}'. */
11745 cp_parser_require (parser, CPP_CLOSE_BRACE, "%<}%>");
11748 /* Parse a namespace-body.
11751 declaration-seq [opt] */
11754 cp_parser_namespace_body (cp_parser* parser)
11756 cp_parser_declaration_seq_opt (parser);
11759 /* Parse a namespace-alias-definition.
11761 namespace-alias-definition:
11762 namespace identifier = qualified-namespace-specifier ; */
11765 cp_parser_namespace_alias_definition (cp_parser* parser)
11768 tree namespace_specifier;
11770 /* Look for the `namespace' keyword. */
11771 cp_parser_require_keyword (parser, RID_NAMESPACE, "%<namespace%>");
11772 /* Look for the identifier. */
11773 identifier = cp_parser_identifier (parser);
11774 if (identifier == error_mark_node)
11776 /* Look for the `=' token. */
11777 if (!cp_parser_uncommitted_to_tentative_parse_p (parser)
11778 && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
11780 error ("%<namespace%> definition is not allowed here");
11781 /* Skip the definition. */
11782 cp_lexer_consume_token (parser->lexer);
11783 if (cp_parser_skip_to_closing_brace (parser))
11784 cp_lexer_consume_token (parser->lexer);
11787 cp_parser_require (parser, CPP_EQ, "%<=%>");
11788 /* Look for the qualified-namespace-specifier. */
11789 namespace_specifier
11790 = cp_parser_qualified_namespace_specifier (parser);
11791 /* Look for the `;' token. */
11792 cp_parser_require (parser, CPP_SEMICOLON, "%<;%>");
11794 /* Register the alias in the symbol table. */
11795 do_namespace_alias (identifier, namespace_specifier);
11798 /* Parse a qualified-namespace-specifier.
11800 qualified-namespace-specifier:
11801 :: [opt] nested-name-specifier [opt] namespace-name
11803 Returns a NAMESPACE_DECL corresponding to the specified
11807 cp_parser_qualified_namespace_specifier (cp_parser* parser)
11809 /* Look for the optional `::'. */
11810 cp_parser_global_scope_opt (parser,
11811 /*current_scope_valid_p=*/false);
11813 /* Look for the optional nested-name-specifier. */
11814 cp_parser_nested_name_specifier_opt (parser,
11815 /*typename_keyword_p=*/false,
11816 /*check_dependency_p=*/true,
11818 /*is_declaration=*/true);
11820 return cp_parser_namespace_name (parser);
11823 /* Parse a using-declaration, or, if ACCESS_DECLARATION_P is true, an
11824 access declaration.
11827 using typename [opt] :: [opt] nested-name-specifier unqualified-id ;
11828 using :: unqualified-id ;
11830 access-declaration:
11836 cp_parser_using_declaration (cp_parser* parser,
11837 bool access_declaration_p)
11840 bool typename_p = false;
11841 bool global_scope_p;
11846 if (access_declaration_p)
11847 cp_parser_parse_tentatively (parser);
11850 /* Look for the `using' keyword. */
11851 cp_parser_require_keyword (parser, RID_USING, "%<using%>");
11853 /* Peek at the next token. */
11854 token = cp_lexer_peek_token (parser->lexer);
11855 /* See if it's `typename'. */
11856 if (token->keyword == RID_TYPENAME)
11858 /* Remember that we've seen it. */
11860 /* Consume the `typename' token. */
11861 cp_lexer_consume_token (parser->lexer);
11865 /* Look for the optional global scope qualification. */
11867 = (cp_parser_global_scope_opt (parser,
11868 /*current_scope_valid_p=*/false)
11871 /* If we saw `typename', or didn't see `::', then there must be a
11872 nested-name-specifier present. */
11873 if (typename_p || !global_scope_p)
11874 qscope = cp_parser_nested_name_specifier (parser, typename_p,
11875 /*check_dependency_p=*/true,
11877 /*is_declaration=*/true);
11878 /* Otherwise, we could be in either of the two productions. In that
11879 case, treat the nested-name-specifier as optional. */
11881 qscope = cp_parser_nested_name_specifier_opt (parser,
11882 /*typename_keyword_p=*/false,
11883 /*check_dependency_p=*/true,
11885 /*is_declaration=*/true);
11887 qscope = global_namespace;
11889 if (access_declaration_p && cp_parser_error_occurred (parser))
11890 /* Something has already gone wrong; there's no need to parse
11891 further. Since an error has occurred, the return value of
11892 cp_parser_parse_definitely will be false, as required. */
11893 return cp_parser_parse_definitely (parser);
11895 /* Parse the unqualified-id. */
11896 identifier = cp_parser_unqualified_id (parser,
11897 /*template_keyword_p=*/false,
11898 /*check_dependency_p=*/true,
11899 /*declarator_p=*/true,
11900 /*optional_p=*/false);
11902 if (access_declaration_p)
11904 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
11905 cp_parser_simulate_error (parser);
11906 if (!cp_parser_parse_definitely (parser))
11910 /* The function we call to handle a using-declaration is different
11911 depending on what scope we are in. */
11912 if (qscope == error_mark_node || identifier == error_mark_node)
11914 else if (TREE_CODE (identifier) != IDENTIFIER_NODE
11915 && TREE_CODE (identifier) != BIT_NOT_EXPR)
11916 /* [namespace.udecl]
11918 A using declaration shall not name a template-id. */
11919 error ("a template-id may not appear in a using-declaration");
11922 if (at_class_scope_p ())
11924 /* Create the USING_DECL. */
11925 decl = do_class_using_decl (parser->scope, identifier);
11927 if (check_for_bare_parameter_packs (decl))
11930 /* Add it to the list of members in this class. */
11931 finish_member_declaration (decl);
11935 decl = cp_parser_lookup_name_simple (parser, identifier);
11936 if (decl == error_mark_node)
11937 cp_parser_name_lookup_error (parser, identifier, decl, NULL);
11938 else if (check_for_bare_parameter_packs (decl))
11940 else if (!at_namespace_scope_p ())
11941 do_local_using_decl (decl, qscope, identifier);
11943 do_toplevel_using_decl (decl, qscope, identifier);
11947 /* Look for the final `;'. */
11948 cp_parser_require (parser, CPP_SEMICOLON, "%<;%>");
11953 /* Parse a using-directive.
11956 using namespace :: [opt] nested-name-specifier [opt]
11957 namespace-name ; */
11960 cp_parser_using_directive (cp_parser* parser)
11962 tree namespace_decl;
11965 /* Look for the `using' keyword. */
11966 cp_parser_require_keyword (parser, RID_USING, "%<using%>");
11967 /* And the `namespace' keyword. */
11968 cp_parser_require_keyword (parser, RID_NAMESPACE, "%<namespace%>");
11969 /* Look for the optional `::' operator. */
11970 cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/false);
11971 /* And the optional nested-name-specifier. */
11972 cp_parser_nested_name_specifier_opt (parser,
11973 /*typename_keyword_p=*/false,
11974 /*check_dependency_p=*/true,
11976 /*is_declaration=*/true);
11977 /* Get the namespace being used. */
11978 namespace_decl = cp_parser_namespace_name (parser);
11979 /* And any specified attributes. */
11980 attribs = cp_parser_attributes_opt (parser);
11981 /* Update the symbol table. */
11982 parse_using_directive (namespace_decl, attribs);
11983 /* Look for the final `;'. */
11984 cp_parser_require (parser, CPP_SEMICOLON, "%<;%>");
11987 /* Parse an asm-definition.
11990 asm ( string-literal ) ;
11995 asm volatile [opt] ( string-literal ) ;
11996 asm volatile [opt] ( string-literal : asm-operand-list [opt] ) ;
11997 asm volatile [opt] ( string-literal : asm-operand-list [opt]
11998 : asm-operand-list [opt] ) ;
11999 asm volatile [opt] ( string-literal : asm-operand-list [opt]
12000 : asm-operand-list [opt]
12001 : asm-operand-list [opt] ) ; */
12004 cp_parser_asm_definition (cp_parser* parser)
12007 tree outputs = NULL_TREE;
12008 tree inputs = NULL_TREE;
12009 tree clobbers = NULL_TREE;
12011 bool volatile_p = false;
12012 bool extended_p = false;
12013 bool invalid_inputs_p = false;
12014 bool invalid_outputs_p = false;
12016 /* Look for the `asm' keyword. */
12017 cp_parser_require_keyword (parser, RID_ASM, "%<asm%>");
12018 /* See if the next token is `volatile'. */
12019 if (cp_parser_allow_gnu_extensions_p (parser)
12020 && cp_lexer_next_token_is_keyword (parser->lexer, RID_VOLATILE))
12022 /* Remember that we saw the `volatile' keyword. */
12024 /* Consume the token. */
12025 cp_lexer_consume_token (parser->lexer);
12027 /* Look for the opening `('. */
12028 if (!cp_parser_require (parser, CPP_OPEN_PAREN, "%<(%>"))
12030 /* Look for the string. */
12031 string = cp_parser_string_literal (parser, false, false);
12032 if (string == error_mark_node)
12034 cp_parser_skip_to_closing_parenthesis (parser, true, false,
12035 /*consume_paren=*/true);
12039 /* If we're allowing GNU extensions, check for the extended assembly
12040 syntax. Unfortunately, the `:' tokens need not be separated by
12041 a space in C, and so, for compatibility, we tolerate that here
12042 too. Doing that means that we have to treat the `::' operator as
12044 if (cp_parser_allow_gnu_extensions_p (parser)
12045 && parser->in_function_body
12046 && (cp_lexer_next_token_is (parser->lexer, CPP_COLON)
12047 || cp_lexer_next_token_is (parser->lexer, CPP_SCOPE)))
12049 bool inputs_p = false;
12050 bool clobbers_p = false;
12052 /* The extended syntax was used. */
12055 /* Look for outputs. */
12056 if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
12058 /* Consume the `:'. */
12059 cp_lexer_consume_token (parser->lexer);
12060 /* Parse the output-operands. */
12061 if (cp_lexer_next_token_is_not (parser->lexer,
12063 && cp_lexer_next_token_is_not (parser->lexer,
12065 && cp_lexer_next_token_is_not (parser->lexer,
12067 outputs = cp_parser_asm_operand_list (parser);
12069 if (outputs == error_mark_node)
12070 invalid_outputs_p = true;
12072 /* If the next token is `::', there are no outputs, and the
12073 next token is the beginning of the inputs. */
12074 else if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
12075 /* The inputs are coming next. */
12078 /* Look for inputs. */
12080 || cp_lexer_next_token_is (parser->lexer, CPP_COLON))
12082 /* Consume the `:' or `::'. */
12083 cp_lexer_consume_token (parser->lexer);
12084 /* Parse the output-operands. */
12085 if (cp_lexer_next_token_is_not (parser->lexer,
12087 && cp_lexer_next_token_is_not (parser->lexer,
12089 inputs = cp_parser_asm_operand_list (parser);
12091 if (inputs == error_mark_node)
12092 invalid_inputs_p = true;
12094 else if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
12095 /* The clobbers are coming next. */
12098 /* Look for clobbers. */
12100 || cp_lexer_next_token_is (parser->lexer, CPP_COLON))
12102 /* Consume the `:' or `::'. */
12103 cp_lexer_consume_token (parser->lexer);
12104 /* Parse the clobbers. */
12105 if (cp_lexer_next_token_is_not (parser->lexer,
12107 clobbers = cp_parser_asm_clobber_list (parser);
12110 /* Look for the closing `)'. */
12111 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>"))
12112 cp_parser_skip_to_closing_parenthesis (parser, true, false,
12113 /*consume_paren=*/true);
12114 cp_parser_require (parser, CPP_SEMICOLON, "%<;%>");
12116 if (!invalid_inputs_p && !invalid_outputs_p)
12118 /* Create the ASM_EXPR. */
12119 if (parser->in_function_body)
12121 asm_stmt = finish_asm_stmt (volatile_p, string, outputs,
12123 /* If the extended syntax was not used, mark the ASM_EXPR. */
12126 tree temp = asm_stmt;
12127 if (TREE_CODE (temp) == CLEANUP_POINT_EXPR)
12128 temp = TREE_OPERAND (temp, 0);
12130 ASM_INPUT_P (temp) = 1;
12134 cgraph_add_asm_node (string);
12138 /* Declarators [gram.dcl.decl] */
12140 /* Parse an init-declarator.
12143 declarator initializer [opt]
12148 declarator asm-specification [opt] attributes [opt] initializer [opt]
12150 function-definition:
12151 decl-specifier-seq [opt] declarator ctor-initializer [opt]
12153 decl-specifier-seq [opt] declarator function-try-block
12157 function-definition:
12158 __extension__ function-definition
12160 The DECL_SPECIFIERS apply to this declarator. Returns a
12161 representation of the entity declared. If MEMBER_P is TRUE, then
12162 this declarator appears in a class scope. The new DECL created by
12163 this declarator is returned.
12165 The CHECKS are access checks that should be performed once we know
12166 what entity is being declared (and, therefore, what classes have
12169 If FUNCTION_DEFINITION_ALLOWED_P then we handle the declarator and
12170 for a function-definition here as well. If the declarator is a
12171 declarator for a function-definition, *FUNCTION_DEFINITION_P will
12172 be TRUE upon return. By that point, the function-definition will
12173 have been completely parsed.
12175 FUNCTION_DEFINITION_P may be NULL if FUNCTION_DEFINITION_ALLOWED_P
12179 cp_parser_init_declarator (cp_parser* parser,
12180 cp_decl_specifier_seq *decl_specifiers,
12181 VEC (deferred_access_check,gc)* checks,
12182 bool function_definition_allowed_p,
12184 int declares_class_or_enum,
12185 bool* function_definition_p)
12188 cp_declarator *declarator;
12189 tree prefix_attributes;
12191 tree asm_specification;
12193 tree decl = NULL_TREE;
12195 bool is_initialized;
12196 /* Only valid if IS_INITIALIZED is true. In that case, CPP_EQ if
12197 initialized with "= ..", CPP_OPEN_PAREN if initialized with
12199 enum cpp_ttype initialization_kind;
12200 bool is_parenthesized_init = false;
12201 bool is_non_constant_init;
12202 int ctor_dtor_or_conv_p;
12204 tree pushed_scope = NULL;
12206 /* Gather the attributes that were provided with the
12207 decl-specifiers. */
12208 prefix_attributes = decl_specifiers->attributes;
12210 /* Assume that this is not the declarator for a function
12212 if (function_definition_p)
12213 *function_definition_p = false;
12215 /* Defer access checks while parsing the declarator; we cannot know
12216 what names are accessible until we know what is being
12218 resume_deferring_access_checks ();
12220 /* Parse the declarator. */
12222 = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
12223 &ctor_dtor_or_conv_p,
12224 /*parenthesized_p=*/NULL,
12225 /*member_p=*/false);
12226 /* Gather up the deferred checks. */
12227 stop_deferring_access_checks ();
12229 /* If the DECLARATOR was erroneous, there's no need to go
12231 if (declarator == cp_error_declarator)
12232 return error_mark_node;
12234 /* Check that the number of template-parameter-lists is OK. */
12235 if (!cp_parser_check_declarator_template_parameters (parser, declarator))
12236 return error_mark_node;
12238 if (declares_class_or_enum & 2)
12239 cp_parser_check_for_definition_in_return_type (declarator,
12240 decl_specifiers->type);
12242 /* Figure out what scope the entity declared by the DECLARATOR is
12243 located in. `grokdeclarator' sometimes changes the scope, so
12244 we compute it now. */
12245 scope = get_scope_of_declarator (declarator);
12247 /* If we're allowing GNU extensions, look for an asm-specification
12249 if (cp_parser_allow_gnu_extensions_p (parser))
12251 /* Look for an asm-specification. */
12252 asm_specification = cp_parser_asm_specification_opt (parser);
12253 /* And attributes. */
12254 attributes = cp_parser_attributes_opt (parser);
12258 asm_specification = NULL_TREE;
12259 attributes = NULL_TREE;
12262 /* Peek at the next token. */
12263 token = cp_lexer_peek_token (parser->lexer);
12264 /* Check to see if the token indicates the start of a
12265 function-definition. */
12266 if (cp_parser_token_starts_function_definition_p (token))
12268 if (!function_definition_allowed_p)
12270 /* If a function-definition should not appear here, issue an
12272 cp_parser_error (parser,
12273 "a function-definition is not allowed here");
12274 return error_mark_node;
12278 /* Neither attributes nor an asm-specification are allowed
12279 on a function-definition. */
12280 if (asm_specification)
12281 error ("an asm-specification is not allowed on a function-definition");
12283 error ("attributes are not allowed on a function-definition");
12284 /* This is a function-definition. */
12285 *function_definition_p = true;
12287 /* Parse the function definition. */
12289 decl = cp_parser_save_member_function_body (parser,
12292 prefix_attributes);
12295 = (cp_parser_function_definition_from_specifiers_and_declarator
12296 (parser, decl_specifiers, prefix_attributes, declarator));
12304 Only in function declarations for constructors, destructors, and
12305 type conversions can the decl-specifier-seq be omitted.
12307 We explicitly postpone this check past the point where we handle
12308 function-definitions because we tolerate function-definitions
12309 that are missing their return types in some modes. */
12310 if (!decl_specifiers->any_specifiers_p && ctor_dtor_or_conv_p <= 0)
12312 cp_parser_error (parser,
12313 "expected constructor, destructor, or type conversion");
12314 return error_mark_node;
12317 /* An `=' or an `(' indicates an initializer. */
12318 if (token->type == CPP_EQ
12319 || token->type == CPP_OPEN_PAREN)
12321 is_initialized = true;
12322 initialization_kind = token->type;
12326 /* If the init-declarator isn't initialized and isn't followed by a
12327 `,' or `;', it's not a valid init-declarator. */
12328 if (token->type != CPP_COMMA
12329 && token->type != CPP_SEMICOLON)
12331 cp_parser_error (parser, "expected initializer");
12332 return error_mark_node;
12334 is_initialized = false;
12335 initialization_kind = CPP_EOF;
12338 /* Because start_decl has side-effects, we should only call it if we
12339 know we're going ahead. By this point, we know that we cannot
12340 possibly be looking at any other construct. */
12341 cp_parser_commit_to_tentative_parse (parser);
12343 /* If the decl specifiers were bad, issue an error now that we're
12344 sure this was intended to be a declarator. Then continue
12345 declaring the variable(s), as int, to try to cut down on further
12347 if (decl_specifiers->any_specifiers_p
12348 && decl_specifiers->type == error_mark_node)
12350 cp_parser_error (parser, "invalid type in declaration");
12351 decl_specifiers->type = integer_type_node;
12354 /* Check to see whether or not this declaration is a friend. */
12355 friend_p = cp_parser_friend_p (decl_specifiers);
12357 /* Enter the newly declared entry in the symbol table. If we're
12358 processing a declaration in a class-specifier, we wait until
12359 after processing the initializer. */
12362 if (parser->in_unbraced_linkage_specification_p)
12363 decl_specifiers->storage_class = sc_extern;
12364 decl = start_decl (declarator, decl_specifiers,
12365 is_initialized, attributes, prefix_attributes,
12369 /* Enter the SCOPE. That way unqualified names appearing in the
12370 initializer will be looked up in SCOPE. */
12371 pushed_scope = push_scope (scope);
12373 /* Perform deferred access control checks, now that we know in which
12374 SCOPE the declared entity resides. */
12375 if (!member_p && decl)
12377 tree saved_current_function_decl = NULL_TREE;
12379 /* If the entity being declared is a function, pretend that we
12380 are in its scope. If it is a `friend', it may have access to
12381 things that would not otherwise be accessible. */
12382 if (TREE_CODE (decl) == FUNCTION_DECL)
12384 saved_current_function_decl = current_function_decl;
12385 current_function_decl = decl;
12388 /* Perform access checks for template parameters. */
12389 cp_parser_perform_template_parameter_access_checks (checks);
12391 /* Perform the access control checks for the declarator and the
12392 the decl-specifiers. */
12393 perform_deferred_access_checks ();
12395 /* Restore the saved value. */
12396 if (TREE_CODE (decl) == FUNCTION_DECL)
12397 current_function_decl = saved_current_function_decl;
12400 /* Parse the initializer. */
12401 initializer = NULL_TREE;
12402 is_parenthesized_init = false;
12403 is_non_constant_init = true;
12404 if (is_initialized)
12406 if (function_declarator_p (declarator))
12408 if (initialization_kind == CPP_EQ)
12409 initializer = cp_parser_pure_specifier (parser);
12412 /* If the declaration was erroneous, we don't really
12413 know what the user intended, so just silently
12414 consume the initializer. */
12415 if (decl != error_mark_node)
12416 error ("initializer provided for function");
12417 cp_parser_skip_to_closing_parenthesis (parser,
12418 /*recovering=*/true,
12419 /*or_comma=*/false,
12420 /*consume_paren=*/true);
12424 initializer = cp_parser_initializer (parser,
12425 &is_parenthesized_init,
12426 &is_non_constant_init);
12429 /* The old parser allows attributes to appear after a parenthesized
12430 initializer. Mark Mitchell proposed removing this functionality
12431 on the GCC mailing lists on 2002-08-13. This parser accepts the
12432 attributes -- but ignores them. */
12433 if (cp_parser_allow_gnu_extensions_p (parser) && is_parenthesized_init)
12434 if (cp_parser_attributes_opt (parser))
12435 warning (OPT_Wattributes,
12436 "attributes after parenthesized initializer ignored");
12438 /* For an in-class declaration, use `grokfield' to create the
12444 pop_scope (pushed_scope);
12445 pushed_scope = false;
12447 decl = grokfield (declarator, decl_specifiers,
12448 initializer, !is_non_constant_init,
12449 /*asmspec=*/NULL_TREE,
12450 prefix_attributes);
12451 if (decl && TREE_CODE (decl) == FUNCTION_DECL)
12452 cp_parser_save_default_args (parser, decl);
12455 /* Finish processing the declaration. But, skip friend
12457 if (!friend_p && decl && decl != error_mark_node)
12459 cp_finish_decl (decl,
12460 initializer, !is_non_constant_init,
12462 /* If the initializer is in parentheses, then this is
12463 a direct-initialization, which means that an
12464 `explicit' constructor is OK. Otherwise, an
12465 `explicit' constructor cannot be used. */
12466 ((is_parenthesized_init || !is_initialized)
12467 ? 0 : LOOKUP_ONLYCONVERTING));
12469 else if ((cxx_dialect != cxx98) && friend_p
12470 && decl && TREE_CODE (decl) == FUNCTION_DECL)
12471 /* Core issue #226 (C++0x only): A default template-argument
12472 shall not be specified in a friend class template
12474 check_default_tmpl_args (decl, current_template_parms, /*is_primary=*/1,
12475 /*is_partial=*/0, /*is_friend_decl=*/1);
12477 if (!friend_p && pushed_scope)
12478 pop_scope (pushed_scope);
12483 /* Parse a declarator.
12487 ptr-operator declarator
12489 abstract-declarator:
12490 ptr-operator abstract-declarator [opt]
12491 direct-abstract-declarator
12496 attributes [opt] direct-declarator
12497 attributes [opt] ptr-operator declarator
12499 abstract-declarator:
12500 attributes [opt] ptr-operator abstract-declarator [opt]
12501 attributes [opt] direct-abstract-declarator
12503 If CTOR_DTOR_OR_CONV_P is not NULL, *CTOR_DTOR_OR_CONV_P is used to
12504 detect constructor, destructor or conversion operators. It is set
12505 to -1 if the declarator is a name, and +1 if it is a
12506 function. Otherwise it is set to zero. Usually you just want to
12507 test for >0, but internally the negative value is used.
12509 (The reason for CTOR_DTOR_OR_CONV_P is that a declaration must have
12510 a decl-specifier-seq unless it declares a constructor, destructor,
12511 or conversion. It might seem that we could check this condition in
12512 semantic analysis, rather than parsing, but that makes it difficult
12513 to handle something like `f()'. We want to notice that there are
12514 no decl-specifiers, and therefore realize that this is an
12515 expression, not a declaration.)
12517 If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to true iff
12518 the declarator is a direct-declarator of the form "(...)".
12520 MEMBER_P is true iff this declarator is a member-declarator. */
12522 static cp_declarator *
12523 cp_parser_declarator (cp_parser* parser,
12524 cp_parser_declarator_kind dcl_kind,
12525 int* ctor_dtor_or_conv_p,
12526 bool* parenthesized_p,
12530 cp_declarator *declarator;
12531 enum tree_code code;
12532 cp_cv_quals cv_quals;
12534 tree attributes = NULL_TREE;
12536 /* Assume this is not a constructor, destructor, or type-conversion
12538 if (ctor_dtor_or_conv_p)
12539 *ctor_dtor_or_conv_p = 0;
12541 if (cp_parser_allow_gnu_extensions_p (parser))
12542 attributes = cp_parser_attributes_opt (parser);
12544 /* Peek at the next token. */
12545 token = cp_lexer_peek_token (parser->lexer);
12547 /* Check for the ptr-operator production. */
12548 cp_parser_parse_tentatively (parser);
12549 /* Parse the ptr-operator. */
12550 code = cp_parser_ptr_operator (parser,
12553 /* If that worked, then we have a ptr-operator. */
12554 if (cp_parser_parse_definitely (parser))
12556 /* If a ptr-operator was found, then this declarator was not
12558 if (parenthesized_p)
12559 *parenthesized_p = true;
12560 /* The dependent declarator is optional if we are parsing an
12561 abstract-declarator. */
12562 if (dcl_kind != CP_PARSER_DECLARATOR_NAMED)
12563 cp_parser_parse_tentatively (parser);
12565 /* Parse the dependent declarator. */
12566 declarator = cp_parser_declarator (parser, dcl_kind,
12567 /*ctor_dtor_or_conv_p=*/NULL,
12568 /*parenthesized_p=*/NULL,
12569 /*member_p=*/false);
12571 /* If we are parsing an abstract-declarator, we must handle the
12572 case where the dependent declarator is absent. */
12573 if (dcl_kind != CP_PARSER_DECLARATOR_NAMED
12574 && !cp_parser_parse_definitely (parser))
12577 declarator = cp_parser_make_indirect_declarator
12578 (code, class_type, cv_quals, declarator);
12580 /* Everything else is a direct-declarator. */
12583 if (parenthesized_p)
12584 *parenthesized_p = cp_lexer_next_token_is (parser->lexer,
12586 declarator = cp_parser_direct_declarator (parser, dcl_kind,
12587 ctor_dtor_or_conv_p,
12591 if (attributes && declarator && declarator != cp_error_declarator)
12592 declarator->attributes = attributes;
12597 /* Parse a direct-declarator or direct-abstract-declarator.
12601 direct-declarator ( parameter-declaration-clause )
12602 cv-qualifier-seq [opt]
12603 exception-specification [opt]
12604 direct-declarator [ constant-expression [opt] ]
12607 direct-abstract-declarator:
12608 direct-abstract-declarator [opt]
12609 ( parameter-declaration-clause )
12610 cv-qualifier-seq [opt]
12611 exception-specification [opt]
12612 direct-abstract-declarator [opt] [ constant-expression [opt] ]
12613 ( abstract-declarator )
12615 Returns a representation of the declarator. DCL_KIND is
12616 CP_PARSER_DECLARATOR_ABSTRACT, if we are parsing a
12617 direct-abstract-declarator. It is CP_PARSER_DECLARATOR_NAMED, if
12618 we are parsing a direct-declarator. It is
12619 CP_PARSER_DECLARATOR_EITHER, if we can accept either - in the case
12620 of ambiguity we prefer an abstract declarator, as per
12621 [dcl.ambig.res]. CTOR_DTOR_OR_CONV_P and MEMBER_P are as for
12622 cp_parser_declarator. */
12624 static cp_declarator *
12625 cp_parser_direct_declarator (cp_parser* parser,
12626 cp_parser_declarator_kind dcl_kind,
12627 int* ctor_dtor_or_conv_p,
12631 cp_declarator *declarator = NULL;
12632 tree scope = NULL_TREE;
12633 bool saved_default_arg_ok_p = parser->default_arg_ok_p;
12634 bool saved_in_declarator_p = parser->in_declarator_p;
12636 tree pushed_scope = NULL_TREE;
12640 /* Peek at the next token. */
12641 token = cp_lexer_peek_token (parser->lexer);
12642 if (token->type == CPP_OPEN_PAREN)
12644 /* This is either a parameter-declaration-clause, or a
12645 parenthesized declarator. When we know we are parsing a
12646 named declarator, it must be a parenthesized declarator
12647 if FIRST is true. For instance, `(int)' is a
12648 parameter-declaration-clause, with an omitted
12649 direct-abstract-declarator. But `((*))', is a
12650 parenthesized abstract declarator. Finally, when T is a
12651 template parameter `(T)' is a
12652 parameter-declaration-clause, and not a parenthesized
12655 We first try and parse a parameter-declaration-clause,
12656 and then try a nested declarator (if FIRST is true).
12658 It is not an error for it not to be a
12659 parameter-declaration-clause, even when FIRST is
12665 The first is the declaration of a function while the
12666 second is a the definition of a variable, including its
12669 Having seen only the parenthesis, we cannot know which of
12670 these two alternatives should be selected. Even more
12671 complex are examples like:
12676 The former is a function-declaration; the latter is a
12677 variable initialization.
12679 Thus again, we try a parameter-declaration-clause, and if
12680 that fails, we back out and return. */
12682 if (!first || dcl_kind != CP_PARSER_DECLARATOR_NAMED)
12684 cp_parameter_declarator *params;
12685 unsigned saved_num_template_parameter_lists;
12687 /* In a member-declarator, the only valid interpretation
12688 of a parenthesis is the start of a
12689 parameter-declaration-clause. (It is invalid to
12690 initialize a static data member with a parenthesized
12691 initializer; only the "=" form of initialization is
12694 cp_parser_parse_tentatively (parser);
12696 /* Consume the `('. */
12697 cp_lexer_consume_token (parser->lexer);
12700 /* If this is going to be an abstract declarator, we're
12701 in a declarator and we can't have default args. */
12702 parser->default_arg_ok_p = false;
12703 parser->in_declarator_p = true;
12706 /* Inside the function parameter list, surrounding
12707 template-parameter-lists do not apply. */
12708 saved_num_template_parameter_lists
12709 = parser->num_template_parameter_lists;
12710 parser->num_template_parameter_lists = 0;
12712 /* Parse the parameter-declaration-clause. */
12713 params = cp_parser_parameter_declaration_clause (parser);
12715 parser->num_template_parameter_lists
12716 = saved_num_template_parameter_lists;
12718 /* If all went well, parse the cv-qualifier-seq and the
12719 exception-specification. */
12720 if (member_p || cp_parser_parse_definitely (parser))
12722 cp_cv_quals cv_quals;
12723 tree exception_specification;
12725 if (ctor_dtor_or_conv_p)
12726 *ctor_dtor_or_conv_p = *ctor_dtor_or_conv_p < 0;
12728 /* Consume the `)'. */
12729 cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>");
12731 /* Parse the cv-qualifier-seq. */
12732 cv_quals = cp_parser_cv_qualifier_seq_opt (parser);
12733 /* And the exception-specification. */
12734 exception_specification
12735 = cp_parser_exception_specification_opt (parser);
12737 /* Create the function-declarator. */
12738 declarator = make_call_declarator (declarator,
12741 exception_specification);
12742 /* Any subsequent parameter lists are to do with
12743 return type, so are not those of the declared
12745 parser->default_arg_ok_p = false;
12747 /* Repeat the main loop. */
12752 /* If this is the first, we can try a parenthesized
12756 bool saved_in_type_id_in_expr_p;
12758 parser->default_arg_ok_p = saved_default_arg_ok_p;
12759 parser->in_declarator_p = saved_in_declarator_p;
12761 /* Consume the `('. */
12762 cp_lexer_consume_token (parser->lexer);
12763 /* Parse the nested declarator. */
12764 saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p;
12765 parser->in_type_id_in_expr_p = true;
12767 = cp_parser_declarator (parser, dcl_kind, ctor_dtor_or_conv_p,
12768 /*parenthesized_p=*/NULL,
12770 parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
12772 /* Expect a `)'. */
12773 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>"))
12774 declarator = cp_error_declarator;
12775 if (declarator == cp_error_declarator)
12778 goto handle_declarator;
12780 /* Otherwise, we must be done. */
12784 else if ((!first || dcl_kind != CP_PARSER_DECLARATOR_NAMED)
12785 && token->type == CPP_OPEN_SQUARE)
12787 /* Parse an array-declarator. */
12790 if (ctor_dtor_or_conv_p)
12791 *ctor_dtor_or_conv_p = 0;
12794 parser->default_arg_ok_p = false;
12795 parser->in_declarator_p = true;
12796 /* Consume the `['. */
12797 cp_lexer_consume_token (parser->lexer);
12798 /* Peek at the next token. */
12799 token = cp_lexer_peek_token (parser->lexer);
12800 /* If the next token is `]', then there is no
12801 constant-expression. */
12802 if (token->type != CPP_CLOSE_SQUARE)
12804 bool non_constant_p;
12807 = cp_parser_constant_expression (parser,
12808 /*allow_non_constant=*/true,
12810 if (!non_constant_p)
12811 bounds = fold_non_dependent_expr (bounds);
12812 /* Normally, the array bound must be an integral constant
12813 expression. However, as an extension, we allow VLAs
12814 in function scopes. */
12815 else if (!parser->in_function_body)
12817 error ("array bound is not an integer constant");
12818 bounds = error_mark_node;
12822 bounds = NULL_TREE;
12823 /* Look for the closing `]'. */
12824 if (!cp_parser_require (parser, CPP_CLOSE_SQUARE, "%<]%>"))
12826 declarator = cp_error_declarator;
12830 declarator = make_array_declarator (declarator, bounds);
12832 else if (first && dcl_kind != CP_PARSER_DECLARATOR_ABSTRACT)
12834 tree qualifying_scope;
12835 tree unqualified_name;
12836 special_function_kind sfk;
12838 bool pack_expansion_p = false;
12840 /* Parse a declarator-id */
12841 abstract_ok = (dcl_kind == CP_PARSER_DECLARATOR_EITHER);
12844 cp_parser_parse_tentatively (parser);
12846 /* If we see an ellipsis, we should be looking at a
12848 if (token->type == CPP_ELLIPSIS)
12850 /* Consume the `...' */
12851 cp_lexer_consume_token (parser->lexer);
12853 pack_expansion_p = true;
12858 = cp_parser_declarator_id (parser, /*optional_p=*/abstract_ok);
12859 qualifying_scope = parser->scope;
12864 if (!unqualified_name && pack_expansion_p)
12866 /* Check whether an error occurred. */
12867 okay = !cp_parser_error_occurred (parser);
12869 /* We already consumed the ellipsis to mark a
12870 parameter pack, but we have no way to report it,
12871 so abort the tentative parse. We will be exiting
12872 immediately anyway. */
12873 cp_parser_abort_tentative_parse (parser);
12876 okay = cp_parser_parse_definitely (parser);
12879 unqualified_name = error_mark_node;
12880 else if (unqualified_name
12881 && (qualifying_scope
12882 || (TREE_CODE (unqualified_name)
12883 != IDENTIFIER_NODE)))
12885 cp_parser_error (parser, "expected unqualified-id");
12886 unqualified_name = error_mark_node;
12890 if (!unqualified_name)
12892 if (unqualified_name == error_mark_node)
12894 declarator = cp_error_declarator;
12895 pack_expansion_p = false;
12896 declarator->parameter_pack_p = false;
12900 if (qualifying_scope && at_namespace_scope_p ()
12901 && TREE_CODE (qualifying_scope) == TYPENAME_TYPE)
12903 /* In the declaration of a member of a template class
12904 outside of the class itself, the SCOPE will sometimes
12905 be a TYPENAME_TYPE. For example, given:
12907 template <typename T>
12908 int S<T>::R::i = 3;
12910 the SCOPE will be a TYPENAME_TYPE for `S<T>::R'. In
12911 this context, we must resolve S<T>::R to an ordinary
12912 type, rather than a typename type.
12914 The reason we normally avoid resolving TYPENAME_TYPEs
12915 is that a specialization of `S' might render
12916 `S<T>::R' not a type. However, if `S' is
12917 specialized, then this `i' will not be used, so there
12918 is no harm in resolving the types here. */
12921 /* Resolve the TYPENAME_TYPE. */
12922 type = resolve_typename_type (qualifying_scope,
12923 /*only_current_p=*/false);
12924 /* If that failed, the declarator is invalid. */
12925 if (TREE_CODE (type) == TYPENAME_TYPE)
12926 error ("%<%T::%E%> is not a type",
12927 TYPE_CONTEXT (qualifying_scope),
12928 TYPE_IDENTIFIER (qualifying_scope));
12929 qualifying_scope = type;
12934 if (unqualified_name)
12938 if (qualifying_scope
12939 && CLASS_TYPE_P (qualifying_scope))
12940 class_type = qualifying_scope;
12942 class_type = current_class_type;
12944 if (TREE_CODE (unqualified_name) == TYPE_DECL)
12946 tree name_type = TREE_TYPE (unqualified_name);
12947 if (class_type && same_type_p (name_type, class_type))
12949 if (qualifying_scope
12950 && CLASSTYPE_USE_TEMPLATE (name_type))
12952 error ("invalid use of constructor as a template");
12953 inform ("use %<%T::%D%> instead of %<%T::%D%> to "
12954 "name the constructor in a qualified name",
12956 DECL_NAME (TYPE_TI_TEMPLATE (class_type)),
12957 class_type, name_type);
12958 declarator = cp_error_declarator;
12962 unqualified_name = constructor_name (class_type);
12966 /* We do not attempt to print the declarator
12967 here because we do not have enough
12968 information about its original syntactic
12970 cp_parser_error (parser, "invalid declarator");
12971 declarator = cp_error_declarator;
12978 if (TREE_CODE (unqualified_name) == BIT_NOT_EXPR)
12979 sfk = sfk_destructor;
12980 else if (IDENTIFIER_TYPENAME_P (unqualified_name))
12981 sfk = sfk_conversion;
12982 else if (/* There's no way to declare a constructor
12983 for an anonymous type, even if the type
12984 got a name for linkage purposes. */
12985 !TYPE_WAS_ANONYMOUS (class_type)
12986 && constructor_name_p (unqualified_name,
12989 unqualified_name = constructor_name (class_type);
12990 sfk = sfk_constructor;
12993 if (ctor_dtor_or_conv_p && sfk != sfk_none)
12994 *ctor_dtor_or_conv_p = -1;
12997 declarator = make_id_declarator (qualifying_scope,
13000 declarator->id_loc = token->location;
13001 declarator->parameter_pack_p = pack_expansion_p;
13003 if (pack_expansion_p)
13004 maybe_warn_variadic_templates ();
13006 handle_declarator:;
13007 scope = get_scope_of_declarator (declarator);
13009 /* Any names that appear after the declarator-id for a
13010 member are looked up in the containing scope. */
13011 pushed_scope = push_scope (scope);
13012 parser->in_declarator_p = true;
13013 if ((ctor_dtor_or_conv_p && *ctor_dtor_or_conv_p)
13014 || (declarator && declarator->kind == cdk_id))
13015 /* Default args are only allowed on function
13017 parser->default_arg_ok_p = saved_default_arg_ok_p;
13019 parser->default_arg_ok_p = false;
13028 /* For an abstract declarator, we might wind up with nothing at this
13029 point. That's an error; the declarator is not optional. */
13031 cp_parser_error (parser, "expected declarator");
13033 /* If we entered a scope, we must exit it now. */
13035 pop_scope (pushed_scope);
13037 parser->default_arg_ok_p = saved_default_arg_ok_p;
13038 parser->in_declarator_p = saved_in_declarator_p;
13043 /* Parse a ptr-operator.
13046 * cv-qualifier-seq [opt]
13048 :: [opt] nested-name-specifier * cv-qualifier-seq [opt]
13053 & cv-qualifier-seq [opt]
13055 Returns INDIRECT_REF if a pointer, or pointer-to-member, was used.
13056 Returns ADDR_EXPR if a reference was used, or NON_LVALUE_EXPR for
13057 an rvalue reference. In the case of a pointer-to-member, *TYPE is
13058 filled in with the TYPE containing the member. *CV_QUALS is
13059 filled in with the cv-qualifier-seq, or TYPE_UNQUALIFIED, if there
13060 are no cv-qualifiers. Returns ERROR_MARK if an error occurred.
13061 Note that the tree codes returned by this function have nothing
13062 to do with the types of trees that will be eventually be created
13063 to represent the pointer or reference type being parsed. They are
13064 just constants with suggestive names. */
13065 static enum tree_code
13066 cp_parser_ptr_operator (cp_parser* parser,
13068 cp_cv_quals *cv_quals)
13070 enum tree_code code = ERROR_MARK;
13073 /* Assume that it's not a pointer-to-member. */
13075 /* And that there are no cv-qualifiers. */
13076 *cv_quals = TYPE_UNQUALIFIED;
13078 /* Peek at the next token. */
13079 token = cp_lexer_peek_token (parser->lexer);
13081 /* If it's a `*', `&' or `&&' we have a pointer or reference. */
13082 if (token->type == CPP_MULT)
13083 code = INDIRECT_REF;
13084 else if (token->type == CPP_AND)
13086 else if ((cxx_dialect != cxx98) &&
13087 token->type == CPP_AND_AND) /* C++0x only */
13088 code = NON_LVALUE_EXPR;
13090 if (code != ERROR_MARK)
13092 /* Consume the `*', `&' or `&&'. */
13093 cp_lexer_consume_token (parser->lexer);
13095 /* A `*' can be followed by a cv-qualifier-seq, and so can a
13096 `&', if we are allowing GNU extensions. (The only qualifier
13097 that can legally appear after `&' is `restrict', but that is
13098 enforced during semantic analysis. */
13099 if (code == INDIRECT_REF
13100 || cp_parser_allow_gnu_extensions_p (parser))
13101 *cv_quals = cp_parser_cv_qualifier_seq_opt (parser);
13105 /* Try the pointer-to-member case. */
13106 cp_parser_parse_tentatively (parser);
13107 /* Look for the optional `::' operator. */
13108 cp_parser_global_scope_opt (parser,
13109 /*current_scope_valid_p=*/false);
13110 /* Look for the nested-name specifier. */
13111 cp_parser_nested_name_specifier (parser,
13112 /*typename_keyword_p=*/false,
13113 /*check_dependency_p=*/true,
13115 /*is_declaration=*/false);
13116 /* If we found it, and the next token is a `*', then we are
13117 indeed looking at a pointer-to-member operator. */
13118 if (!cp_parser_error_occurred (parser)
13119 && cp_parser_require (parser, CPP_MULT, "%<*%>"))
13121 /* Indicate that the `*' operator was used. */
13122 code = INDIRECT_REF;
13124 if (TREE_CODE (parser->scope) == NAMESPACE_DECL)
13125 error ("%qD is a namespace", parser->scope);
13128 /* The type of which the member is a member is given by the
13130 *type = parser->scope;
13131 /* The next name will not be qualified. */
13132 parser->scope = NULL_TREE;
13133 parser->qualifying_scope = NULL_TREE;
13134 parser->object_scope = NULL_TREE;
13135 /* Look for the optional cv-qualifier-seq. */
13136 *cv_quals = cp_parser_cv_qualifier_seq_opt (parser);
13139 /* If that didn't work we don't have a ptr-operator. */
13140 if (!cp_parser_parse_definitely (parser))
13141 cp_parser_error (parser, "expected ptr-operator");
13147 /* Parse an (optional) cv-qualifier-seq.
13150 cv-qualifier cv-qualifier-seq [opt]
13161 Returns a bitmask representing the cv-qualifiers. */
13164 cp_parser_cv_qualifier_seq_opt (cp_parser* parser)
13166 cp_cv_quals cv_quals = TYPE_UNQUALIFIED;
13171 cp_cv_quals cv_qualifier;
13173 /* Peek at the next token. */
13174 token = cp_lexer_peek_token (parser->lexer);
13175 /* See if it's a cv-qualifier. */
13176 switch (token->keyword)
13179 cv_qualifier = TYPE_QUAL_CONST;
13183 cv_qualifier = TYPE_QUAL_VOLATILE;
13187 cv_qualifier = TYPE_QUAL_RESTRICT;
13191 cv_qualifier = TYPE_UNQUALIFIED;
13198 if (cv_quals & cv_qualifier)
13200 error ("duplicate cv-qualifier");
13201 cp_lexer_purge_token (parser->lexer);
13205 cp_lexer_consume_token (parser->lexer);
13206 cv_quals |= cv_qualifier;
13213 /* Parse a declarator-id.
13217 :: [opt] nested-name-specifier [opt] type-name
13219 In the `id-expression' case, the value returned is as for
13220 cp_parser_id_expression if the id-expression was an unqualified-id.
13221 If the id-expression was a qualified-id, then a SCOPE_REF is
13222 returned. The first operand is the scope (either a NAMESPACE_DECL
13223 or TREE_TYPE), but the second is still just a representation of an
13227 cp_parser_declarator_id (cp_parser* parser, bool optional_p)
13230 /* The expression must be an id-expression. Assume that qualified
13231 names are the names of types so that:
13234 int S<T>::R::i = 3;
13236 will work; we must treat `S<T>::R' as the name of a type.
13237 Similarly, assume that qualified names are templates, where
13241 int S<T>::R<T>::i = 3;
13244 id = cp_parser_id_expression (parser,
13245 /*template_keyword_p=*/false,
13246 /*check_dependency_p=*/false,
13247 /*template_p=*/NULL,
13248 /*declarator_p=*/true,
13250 if (id && BASELINK_P (id))
13251 id = BASELINK_FUNCTIONS (id);
13255 /* Parse a type-id.
13258 type-specifier-seq abstract-declarator [opt]
13260 Returns the TYPE specified. */
13263 cp_parser_type_id (cp_parser* parser)
13265 cp_decl_specifier_seq type_specifier_seq;
13266 cp_declarator *abstract_declarator;
13268 /* Parse the type-specifier-seq. */
13269 cp_parser_type_specifier_seq (parser, /*is_condition=*/false,
13270 &type_specifier_seq);
13271 if (type_specifier_seq.type == error_mark_node)
13272 return error_mark_node;
13274 /* There might or might not be an abstract declarator. */
13275 cp_parser_parse_tentatively (parser);
13276 /* Look for the declarator. */
13277 abstract_declarator
13278 = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_ABSTRACT, NULL,
13279 /*parenthesized_p=*/NULL,
13280 /*member_p=*/false);
13281 /* Check to see if there really was a declarator. */
13282 if (!cp_parser_parse_definitely (parser))
13283 abstract_declarator = NULL;
13285 return groktypename (&type_specifier_seq, abstract_declarator);
13288 /* Parse a type-specifier-seq.
13290 type-specifier-seq:
13291 type-specifier type-specifier-seq [opt]
13295 type-specifier-seq:
13296 attributes type-specifier-seq [opt]
13298 If IS_CONDITION is true, we are at the start of a "condition",
13299 e.g., we've just seen "if (".
13301 Sets *TYPE_SPECIFIER_SEQ to represent the sequence. */
13304 cp_parser_type_specifier_seq (cp_parser* parser,
13306 cp_decl_specifier_seq *type_specifier_seq)
13308 bool seen_type_specifier = false;
13309 cp_parser_flags flags = CP_PARSER_FLAGS_OPTIONAL;
13311 /* Clear the TYPE_SPECIFIER_SEQ. */
13312 clear_decl_specs (type_specifier_seq);
13314 /* Parse the type-specifiers and attributes. */
13317 tree type_specifier;
13318 bool is_cv_qualifier;
13320 /* Check for attributes first. */
13321 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_ATTRIBUTE))
13323 type_specifier_seq->attributes =
13324 chainon (type_specifier_seq->attributes,
13325 cp_parser_attributes_opt (parser));
13329 /* Look for the type-specifier. */
13330 type_specifier = cp_parser_type_specifier (parser,
13332 type_specifier_seq,
13333 /*is_declaration=*/false,
13336 if (!type_specifier)
13338 /* If the first type-specifier could not be found, this is not a
13339 type-specifier-seq at all. */
13340 if (!seen_type_specifier)
13342 cp_parser_error (parser, "expected type-specifier");
13343 type_specifier_seq->type = error_mark_node;
13346 /* If subsequent type-specifiers could not be found, the
13347 type-specifier-seq is complete. */
13351 seen_type_specifier = true;
13352 /* The standard says that a condition can be:
13354 type-specifier-seq declarator = assignment-expression
13361 we should treat the "S" as a declarator, not as a
13362 type-specifier. The standard doesn't say that explicitly for
13363 type-specifier-seq, but it does say that for
13364 decl-specifier-seq in an ordinary declaration. Perhaps it
13365 would be clearer just to allow a decl-specifier-seq here, and
13366 then add a semantic restriction that if any decl-specifiers
13367 that are not type-specifiers appear, the program is invalid. */
13368 if (is_condition && !is_cv_qualifier)
13369 flags |= CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES;
13372 cp_parser_check_decl_spec (type_specifier_seq);
13375 /* Parse a parameter-declaration-clause.
13377 parameter-declaration-clause:
13378 parameter-declaration-list [opt] ... [opt]
13379 parameter-declaration-list , ...
13381 Returns a representation for the parameter declarations. A return
13382 value of NULL indicates a parameter-declaration-clause consisting
13383 only of an ellipsis. */
13385 static cp_parameter_declarator *
13386 cp_parser_parameter_declaration_clause (cp_parser* parser)
13388 cp_parameter_declarator *parameters;
13393 /* Peek at the next token. */
13394 token = cp_lexer_peek_token (parser->lexer);
13395 /* Check for trivial parameter-declaration-clauses. */
13396 if (token->type == CPP_ELLIPSIS)
13398 /* Consume the `...' token. */
13399 cp_lexer_consume_token (parser->lexer);
13402 else if (token->type == CPP_CLOSE_PAREN)
13403 /* There are no parameters. */
13405 #ifndef NO_IMPLICIT_EXTERN_C
13406 if (in_system_header && current_class_type == NULL
13407 && current_lang_name == lang_name_c)
13411 return no_parameters;
13413 /* Check for `(void)', too, which is a special case. */
13414 else if (token->keyword == RID_VOID
13415 && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
13416 == CPP_CLOSE_PAREN))
13418 /* Consume the `void' token. */
13419 cp_lexer_consume_token (parser->lexer);
13420 /* There are no parameters. */
13421 return no_parameters;
13424 /* Parse the parameter-declaration-list. */
13425 parameters = cp_parser_parameter_declaration_list (parser, &is_error);
13426 /* If a parse error occurred while parsing the
13427 parameter-declaration-list, then the entire
13428 parameter-declaration-clause is erroneous. */
13432 /* Peek at the next token. */
13433 token = cp_lexer_peek_token (parser->lexer);
13434 /* If it's a `,', the clause should terminate with an ellipsis. */
13435 if (token->type == CPP_COMMA)
13437 /* Consume the `,'. */
13438 cp_lexer_consume_token (parser->lexer);
13439 /* Expect an ellipsis. */
13441 = (cp_parser_require (parser, CPP_ELLIPSIS, "%<...%>") != NULL);
13443 /* It might also be `...' if the optional trailing `,' was
13445 else if (token->type == CPP_ELLIPSIS)
13447 /* Consume the `...' token. */
13448 cp_lexer_consume_token (parser->lexer);
13449 /* And remember that we saw it. */
13453 ellipsis_p = false;
13455 /* Finish the parameter list. */
13456 if (parameters && ellipsis_p)
13457 parameters->ellipsis_p = true;
13462 /* Parse a parameter-declaration-list.
13464 parameter-declaration-list:
13465 parameter-declaration
13466 parameter-declaration-list , parameter-declaration
13468 Returns a representation of the parameter-declaration-list, as for
13469 cp_parser_parameter_declaration_clause. However, the
13470 `void_list_node' is never appended to the list. Upon return,
13471 *IS_ERROR will be true iff an error occurred. */
13473 static cp_parameter_declarator *
13474 cp_parser_parameter_declaration_list (cp_parser* parser, bool *is_error)
13476 cp_parameter_declarator *parameters = NULL;
13477 cp_parameter_declarator **tail = ¶meters;
13478 bool saved_in_unbraced_linkage_specification_p;
13480 /* Assume all will go well. */
13482 /* The special considerations that apply to a function within an
13483 unbraced linkage specifications do not apply to the parameters
13484 to the function. */
13485 saved_in_unbraced_linkage_specification_p
13486 = parser->in_unbraced_linkage_specification_p;
13487 parser->in_unbraced_linkage_specification_p = false;
13489 /* Look for more parameters. */
13492 cp_parameter_declarator *parameter;
13493 bool parenthesized_p;
13494 /* Parse the parameter. */
13496 = cp_parser_parameter_declaration (parser,
13497 /*template_parm_p=*/false,
13500 /* If a parse error occurred parsing the parameter declaration,
13501 then the entire parameter-declaration-list is erroneous. */
13508 /* Add the new parameter to the list. */
13510 tail = ¶meter->next;
13512 /* Peek at the next token. */
13513 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN)
13514 || cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS)
13515 /* These are for Objective-C++ */
13516 || cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)
13517 || cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
13518 /* The parameter-declaration-list is complete. */
13520 else if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
13524 /* Peek at the next token. */
13525 token = cp_lexer_peek_nth_token (parser->lexer, 2);
13526 /* If it's an ellipsis, then the list is complete. */
13527 if (token->type == CPP_ELLIPSIS)
13529 /* Otherwise, there must be more parameters. Consume the
13531 cp_lexer_consume_token (parser->lexer);
13532 /* When parsing something like:
13534 int i(float f, double d)
13536 we can tell after seeing the declaration for "f" that we
13537 are not looking at an initialization of a variable "i",
13538 but rather at the declaration of a function "i".
13540 Due to the fact that the parsing of template arguments
13541 (as specified to a template-id) requires backtracking we
13542 cannot use this technique when inside a template argument
13544 if (!parser->in_template_argument_list_p
13545 && !parser->in_type_id_in_expr_p
13546 && cp_parser_uncommitted_to_tentative_parse_p (parser)
13547 /* However, a parameter-declaration of the form
13548 "foat(f)" (which is a valid declaration of a
13549 parameter "f") can also be interpreted as an
13550 expression (the conversion of "f" to "float"). */
13551 && !parenthesized_p)
13552 cp_parser_commit_to_tentative_parse (parser);
13556 cp_parser_error (parser, "expected %<,%> or %<...%>");
13557 if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
13558 cp_parser_skip_to_closing_parenthesis (parser,
13559 /*recovering=*/true,
13560 /*or_comma=*/false,
13561 /*consume_paren=*/false);
13566 parser->in_unbraced_linkage_specification_p
13567 = saved_in_unbraced_linkage_specification_p;
13572 /* Parse a parameter declaration.
13574 parameter-declaration:
13575 decl-specifier-seq ... [opt] declarator
13576 decl-specifier-seq declarator = assignment-expression
13577 decl-specifier-seq ... [opt] abstract-declarator [opt]
13578 decl-specifier-seq abstract-declarator [opt] = assignment-expression
13580 If TEMPLATE_PARM_P is TRUE, then this parameter-declaration
13581 declares a template parameter. (In that case, a non-nested `>'
13582 token encountered during the parsing of the assignment-expression
13583 is not interpreted as a greater-than operator.)
13585 Returns a representation of the parameter, or NULL if an error
13586 occurs. If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to
13587 true iff the declarator is of the form "(p)". */
13589 static cp_parameter_declarator *
13590 cp_parser_parameter_declaration (cp_parser *parser,
13591 bool template_parm_p,
13592 bool *parenthesized_p)
13594 int declares_class_or_enum;
13595 bool greater_than_is_operator_p;
13596 cp_decl_specifier_seq decl_specifiers;
13597 cp_declarator *declarator;
13598 tree default_argument;
13600 const char *saved_message;
13602 /* In a template parameter, `>' is not an operator.
13606 When parsing a default template-argument for a non-type
13607 template-parameter, the first non-nested `>' is taken as the end
13608 of the template parameter-list rather than a greater-than
13610 greater_than_is_operator_p = !template_parm_p;
13612 /* Type definitions may not appear in parameter types. */
13613 saved_message = parser->type_definition_forbidden_message;
13614 parser->type_definition_forbidden_message
13615 = "types may not be defined in parameter types";
13617 /* Parse the declaration-specifiers. */
13618 cp_parser_decl_specifier_seq (parser,
13619 CP_PARSER_FLAGS_NONE,
13621 &declares_class_or_enum);
13622 /* If an error occurred, there's no reason to attempt to parse the
13623 rest of the declaration. */
13624 if (cp_parser_error_occurred (parser))
13626 parser->type_definition_forbidden_message = saved_message;
13630 /* Peek at the next token. */
13631 token = cp_lexer_peek_token (parser->lexer);
13633 /* If the next token is a `)', `,', `=', `>', or `...', then there
13634 is no declarator. However, when variadic templates are enabled,
13635 there may be a declarator following `...'. */
13636 if (token->type == CPP_CLOSE_PAREN
13637 || token->type == CPP_COMMA
13638 || token->type == CPP_EQ
13639 || token->type == CPP_GREATER)
13642 if (parenthesized_p)
13643 *parenthesized_p = false;
13645 /* Otherwise, there should be a declarator. */
13648 bool saved_default_arg_ok_p = parser->default_arg_ok_p;
13649 parser->default_arg_ok_p = false;
13651 /* After seeing a decl-specifier-seq, if the next token is not a
13652 "(", there is no possibility that the code is a valid
13653 expression. Therefore, if parsing tentatively, we commit at
13655 if (!parser->in_template_argument_list_p
13656 /* In an expression context, having seen:
13660 we cannot be sure whether we are looking at a
13661 function-type (taking a "char" as a parameter) or a cast
13662 of some object of type "char" to "int". */
13663 && !parser->in_type_id_in_expr_p
13664 && cp_parser_uncommitted_to_tentative_parse_p (parser)
13665 && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_PAREN))
13666 cp_parser_commit_to_tentative_parse (parser);
13667 /* Parse the declarator. */
13668 declarator = cp_parser_declarator (parser,
13669 CP_PARSER_DECLARATOR_EITHER,
13670 /*ctor_dtor_or_conv_p=*/NULL,
13672 /*member_p=*/false);
13673 parser->default_arg_ok_p = saved_default_arg_ok_p;
13674 /* After the declarator, allow more attributes. */
13675 decl_specifiers.attributes
13676 = chainon (decl_specifiers.attributes,
13677 cp_parser_attributes_opt (parser));
13680 /* If the next token is an ellipsis, and we have not seen a
13681 declarator name, and the type of the declarator contains parameter
13682 packs but it is not a TYPE_PACK_EXPANSION, then we actually have
13683 a parameter pack expansion expression. Otherwise, leave the
13684 ellipsis for a C-style variadic function. */
13685 token = cp_lexer_peek_token (parser->lexer);
13686 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
13688 tree type = decl_specifiers.type;
13690 if (type && DECL_P (type))
13691 type = TREE_TYPE (type);
13694 && TREE_CODE (type) != TYPE_PACK_EXPANSION
13695 && declarator_can_be_parameter_pack (declarator)
13696 && (!declarator || !declarator->parameter_pack_p)
13697 && uses_parameter_packs (type))
13699 /* Consume the `...'. */
13700 cp_lexer_consume_token (parser->lexer);
13701 maybe_warn_variadic_templates ();
13703 /* Build a pack expansion type */
13705 declarator->parameter_pack_p = true;
13707 decl_specifiers.type = make_pack_expansion (type);
13711 /* The restriction on defining new types applies only to the type
13712 of the parameter, not to the default argument. */
13713 parser->type_definition_forbidden_message = saved_message;
13715 /* If the next token is `=', then process a default argument. */
13716 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
13718 /* Consume the `='. */
13719 cp_lexer_consume_token (parser->lexer);
13721 /* If we are defining a class, then the tokens that make up the
13722 default argument must be saved and processed later. */
13723 if (!template_parm_p && at_class_scope_p ()
13724 && TYPE_BEING_DEFINED (current_class_type))
13726 unsigned depth = 0;
13727 int maybe_template_id = 0;
13728 cp_token *first_token;
13731 /* Add tokens until we have processed the entire default
13732 argument. We add the range [first_token, token). */
13733 first_token = cp_lexer_peek_token (parser->lexer);
13738 /* Peek at the next token. */
13739 token = cp_lexer_peek_token (parser->lexer);
13740 /* What we do depends on what token we have. */
13741 switch (token->type)
13743 /* In valid code, a default argument must be
13744 immediately followed by a `,' `)', or `...'. */
13746 if (depth == 0 && maybe_template_id)
13748 /* If we've seen a '<', we might be in a
13749 template-argument-list. Until Core issue 325 is
13750 resolved, we don't know how this situation ought
13751 to be handled, so try to DTRT. We check whether
13752 what comes after the comma is a valid parameter
13753 declaration list. If it is, then the comma ends
13754 the default argument; otherwise the default
13755 argument continues. */
13756 bool error = false;
13758 /* Set ITALP so cp_parser_parameter_declaration_list
13759 doesn't decide to commit to this parse. */
13760 bool saved_italp = parser->in_template_argument_list_p;
13761 parser->in_template_argument_list_p = true;
13763 cp_parser_parse_tentatively (parser);
13764 cp_lexer_consume_token (parser->lexer);
13765 cp_parser_parameter_declaration_list (parser, &error);
13766 if (!cp_parser_error_occurred (parser) && !error)
13768 cp_parser_abort_tentative_parse (parser);
13770 parser->in_template_argument_list_p = saved_italp;
13773 case CPP_CLOSE_PAREN:
13775 /* If we run into a non-nested `;', `}', or `]',
13776 then the code is invalid -- but the default
13777 argument is certainly over. */
13778 case CPP_SEMICOLON:
13779 case CPP_CLOSE_BRACE:
13780 case CPP_CLOSE_SQUARE:
13783 /* Update DEPTH, if necessary. */
13784 else if (token->type == CPP_CLOSE_PAREN
13785 || token->type == CPP_CLOSE_BRACE
13786 || token->type == CPP_CLOSE_SQUARE)
13790 case CPP_OPEN_PAREN:
13791 case CPP_OPEN_SQUARE:
13792 case CPP_OPEN_BRACE:
13798 /* This might be the comparison operator, or it might
13799 start a template argument list. */
13800 ++maybe_template_id;
13804 if (cxx_dialect == cxx98)
13806 /* Fall through for C++0x, which treats the `>>'
13807 operator like two `>' tokens in certain
13813 /* This might be an operator, or it might close a
13814 template argument list. But if a previous '<'
13815 started a template argument list, this will have
13816 closed it, so we can't be in one anymore. */
13817 maybe_template_id -= 1 + (token->type == CPP_RSHIFT);
13818 if (maybe_template_id < 0)
13819 maybe_template_id = 0;
13823 /* If we run out of tokens, issue an error message. */
13825 case CPP_PRAGMA_EOL:
13826 error ("file ends in default argument");
13832 /* In these cases, we should look for template-ids.
13833 For example, if the default argument is
13834 `X<int, double>()', we need to do name lookup to
13835 figure out whether or not `X' is a template; if
13836 so, the `,' does not end the default argument.
13838 That is not yet done. */
13845 /* If we've reached the end, stop. */
13849 /* Add the token to the token block. */
13850 token = cp_lexer_consume_token (parser->lexer);
13853 /* Create a DEFAULT_ARG to represent the unparsed default
13855 default_argument = make_node (DEFAULT_ARG);
13856 DEFARG_TOKENS (default_argument)
13857 = cp_token_cache_new (first_token, token);
13858 DEFARG_INSTANTIATIONS (default_argument) = NULL;
13860 /* Outside of a class definition, we can just parse the
13861 assignment-expression. */
13864 = cp_parser_default_argument (parser, template_parm_p);
13866 if (!parser->default_arg_ok_p)
13868 if (!flag_pedantic_errors)
13869 warning (0, "deprecated use of default argument for parameter of non-function");
13872 error ("default arguments are only permitted for function parameters");
13873 default_argument = NULL_TREE;
13876 else if ((declarator && declarator->parameter_pack_p)
13877 || (decl_specifiers.type
13878 && PACK_EXPANSION_P (decl_specifiers.type)))
13880 const char* kind = template_parm_p? "template " : "";
13882 /* Find the name of the parameter pack. */
13883 cp_declarator *id_declarator = declarator;
13884 while (id_declarator && id_declarator->kind != cdk_id)
13885 id_declarator = id_declarator->declarator;
13887 if (id_declarator && id_declarator->kind == cdk_id)
13888 error ("%sparameter pack %qD cannot have a default argument",
13889 kind, id_declarator->u.id.unqualified_name);
13891 error ("%sparameter pack cannot have a default argument",
13894 default_argument = NULL_TREE;
13898 default_argument = NULL_TREE;
13900 return make_parameter_declarator (&decl_specifiers,
13905 /* Parse a default argument and return it.
13907 TEMPLATE_PARM_P is true if this is a default argument for a
13908 non-type template parameter. */
13910 cp_parser_default_argument (cp_parser *parser, bool template_parm_p)
13912 tree default_argument = NULL_TREE;
13913 bool saved_greater_than_is_operator_p;
13914 bool saved_local_variables_forbidden_p;
13916 /* Make sure that PARSER->GREATER_THAN_IS_OPERATOR_P is
13918 saved_greater_than_is_operator_p = parser->greater_than_is_operator_p;
13919 parser->greater_than_is_operator_p = !template_parm_p;
13920 /* Local variable names (and the `this' keyword) may not
13921 appear in a default argument. */
13922 saved_local_variables_forbidden_p = parser->local_variables_forbidden_p;
13923 parser->local_variables_forbidden_p = true;
13924 /* The default argument expression may cause implicitly
13925 defined member functions to be synthesized, which will
13926 result in garbage collection. We must treat this
13927 situation as if we were within the body of function so as
13928 to avoid collecting live data on the stack. */
13930 /* Parse the assignment-expression. */
13931 if (template_parm_p)
13932 push_deferring_access_checks (dk_no_deferred);
13934 = cp_parser_assignment_expression (parser, /*cast_p=*/false);
13935 if (template_parm_p)
13936 pop_deferring_access_checks ();
13937 /* Restore saved state. */
13939 parser->greater_than_is_operator_p = saved_greater_than_is_operator_p;
13940 parser->local_variables_forbidden_p = saved_local_variables_forbidden_p;
13942 return default_argument;
13945 /* Parse a function-body.
13948 compound_statement */
13951 cp_parser_function_body (cp_parser *parser)
13953 cp_parser_compound_statement (parser, NULL, false);
13956 /* Parse a ctor-initializer-opt followed by a function-body. Return
13957 true if a ctor-initializer was present. */
13960 cp_parser_ctor_initializer_opt_and_function_body (cp_parser *parser)
13963 bool ctor_initializer_p;
13965 /* Begin the function body. */
13966 body = begin_function_body ();
13967 /* Parse the optional ctor-initializer. */
13968 ctor_initializer_p = cp_parser_ctor_initializer_opt (parser);
13969 /* Parse the function-body. */
13970 cp_parser_function_body (parser);
13971 /* Finish the function body. */
13972 finish_function_body (body);
13974 return ctor_initializer_p;
13977 /* Parse an initializer.
13980 = initializer-clause
13981 ( expression-list )
13983 Returns an expression representing the initializer. If no
13984 initializer is present, NULL_TREE is returned.
13986 *IS_PARENTHESIZED_INIT is set to TRUE if the `( expression-list )'
13987 production is used, and zero otherwise. *IS_PARENTHESIZED_INIT is
13988 set to FALSE if there is no initializer present. If there is an
13989 initializer, and it is not a constant-expression, *NON_CONSTANT_P
13990 is set to true; otherwise it is set to false. */
13993 cp_parser_initializer (cp_parser* parser, bool* is_parenthesized_init,
13994 bool* non_constant_p)
13999 /* Peek at the next token. */
14000 token = cp_lexer_peek_token (parser->lexer);
14002 /* Let our caller know whether or not this initializer was
14004 *is_parenthesized_init = (token->type == CPP_OPEN_PAREN);
14005 /* Assume that the initializer is constant. */
14006 *non_constant_p = false;
14008 if (token->type == CPP_EQ)
14010 /* Consume the `='. */
14011 cp_lexer_consume_token (parser->lexer);
14012 /* Parse the initializer-clause. */
14013 init = cp_parser_initializer_clause (parser, non_constant_p);
14015 else if (token->type == CPP_OPEN_PAREN)
14016 init = cp_parser_parenthesized_expression_list (parser, false,
14018 /*allow_expansion_p=*/true,
14022 /* Anything else is an error. */
14023 cp_parser_error (parser, "expected initializer");
14024 init = error_mark_node;
14030 /* Parse an initializer-clause.
14032 initializer-clause:
14033 assignment-expression
14034 { initializer-list , [opt] }
14037 Returns an expression representing the initializer.
14039 If the `assignment-expression' production is used the value
14040 returned is simply a representation for the expression.
14042 Otherwise, a CONSTRUCTOR is returned. The CONSTRUCTOR_ELTS will be
14043 the elements of the initializer-list (or NULL, if the last
14044 production is used). The TREE_TYPE for the CONSTRUCTOR will be
14045 NULL_TREE. There is no way to detect whether or not the optional
14046 trailing `,' was provided. NON_CONSTANT_P is as for
14047 cp_parser_initializer. */
14050 cp_parser_initializer_clause (cp_parser* parser, bool* non_constant_p)
14054 /* Assume the expression is constant. */
14055 *non_constant_p = false;
14057 /* If it is not a `{', then we are looking at an
14058 assignment-expression. */
14059 if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE))
14062 = cp_parser_constant_expression (parser,
14063 /*allow_non_constant_p=*/true,
14065 if (!*non_constant_p)
14066 initializer = fold_non_dependent_expr (initializer);
14070 /* Consume the `{' token. */
14071 cp_lexer_consume_token (parser->lexer);
14072 /* Create a CONSTRUCTOR to represent the braced-initializer. */
14073 initializer = make_node (CONSTRUCTOR);
14074 /* If it's not a `}', then there is a non-trivial initializer. */
14075 if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_BRACE))
14077 /* Parse the initializer list. */
14078 CONSTRUCTOR_ELTS (initializer)
14079 = cp_parser_initializer_list (parser, non_constant_p);
14080 /* A trailing `,' token is allowed. */
14081 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
14082 cp_lexer_consume_token (parser->lexer);
14084 /* Now, there should be a trailing `}'. */
14085 cp_parser_require (parser, CPP_CLOSE_BRACE, "%<}%>");
14088 return initializer;
14091 /* Parse an initializer-list.
14094 initializer-clause ... [opt]
14095 initializer-list , initializer-clause ... [opt]
14100 identifier : initializer-clause
14101 initializer-list, identifier : initializer-clause
14103 Returns a VEC of constructor_elt. The VALUE of each elt is an expression
14104 for the initializer. If the INDEX of the elt is non-NULL, it is the
14105 IDENTIFIER_NODE naming the field to initialize. NON_CONSTANT_P is
14106 as for cp_parser_initializer. */
14108 static VEC(constructor_elt,gc) *
14109 cp_parser_initializer_list (cp_parser* parser, bool* non_constant_p)
14111 VEC(constructor_elt,gc) *v = NULL;
14113 /* Assume all of the expressions are constant. */
14114 *non_constant_p = false;
14116 /* Parse the rest of the list. */
14122 bool clause_non_constant_p;
14124 /* If the next token is an identifier and the following one is a
14125 colon, we are looking at the GNU designated-initializer
14127 if (cp_parser_allow_gnu_extensions_p (parser)
14128 && cp_lexer_next_token_is (parser->lexer, CPP_NAME)
14129 && cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_COLON)
14131 /* Warn the user that they are using an extension. */
14133 pedwarn ("ISO C++ does not allow designated initializers");
14134 /* Consume the identifier. */
14135 identifier = cp_lexer_consume_token (parser->lexer)->u.value;
14136 /* Consume the `:'. */
14137 cp_lexer_consume_token (parser->lexer);
14140 identifier = NULL_TREE;
14142 /* Parse the initializer. */
14143 initializer = cp_parser_initializer_clause (parser,
14144 &clause_non_constant_p);
14145 /* If any clause is non-constant, so is the entire initializer. */
14146 if (clause_non_constant_p)
14147 *non_constant_p = true;
14149 /* If we have an ellipsis, this is an initializer pack
14151 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
14153 /* Consume the `...'. */
14154 cp_lexer_consume_token (parser->lexer);
14156 /* Turn the initializer into an initializer expansion. */
14157 initializer = make_pack_expansion (initializer);
14160 /* Add it to the vector. */
14161 CONSTRUCTOR_APPEND_ELT(v, identifier, initializer);
14163 /* If the next token is not a comma, we have reached the end of
14165 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
14168 /* Peek at the next token. */
14169 token = cp_lexer_peek_nth_token (parser->lexer, 2);
14170 /* If the next token is a `}', then we're still done. An
14171 initializer-clause can have a trailing `,' after the
14172 initializer-list and before the closing `}'. */
14173 if (token->type == CPP_CLOSE_BRACE)
14176 /* Consume the `,' token. */
14177 cp_lexer_consume_token (parser->lexer);
14183 /* Classes [gram.class] */
14185 /* Parse a class-name.
14191 TYPENAME_KEYWORD_P is true iff the `typename' keyword has been used
14192 to indicate that names looked up in dependent types should be
14193 assumed to be types. TEMPLATE_KEYWORD_P is true iff the `template'
14194 keyword has been used to indicate that the name that appears next
14195 is a template. TAG_TYPE indicates the explicit tag given before
14196 the type name, if any. If CHECK_DEPENDENCY_P is FALSE, names are
14197 looked up in dependent scopes. If CLASS_HEAD_P is TRUE, this class
14198 is the class being defined in a class-head.
14200 Returns the TYPE_DECL representing the class. */
14203 cp_parser_class_name (cp_parser *parser,
14204 bool typename_keyword_p,
14205 bool template_keyword_p,
14206 enum tag_types tag_type,
14207 bool check_dependency_p,
14209 bool is_declaration)
14216 /* All class-names start with an identifier. */
14217 token = cp_lexer_peek_token (parser->lexer);
14218 if (token->type != CPP_NAME && token->type != CPP_TEMPLATE_ID)
14220 cp_parser_error (parser, "expected class-name");
14221 return error_mark_node;
14224 /* PARSER->SCOPE can be cleared when parsing the template-arguments
14225 to a template-id, so we save it here. */
14226 scope = parser->scope;
14227 if (scope == error_mark_node)
14228 return error_mark_node;
14230 /* Any name names a type if we're following the `typename' keyword
14231 in a qualified name where the enclosing scope is type-dependent. */
14232 typename_p = (typename_keyword_p && scope && TYPE_P (scope)
14233 && dependent_type_p (scope));
14234 /* Handle the common case (an identifier, but not a template-id)
14236 if (token->type == CPP_NAME
14237 && !cp_parser_nth_token_starts_template_argument_list_p (parser, 2))
14239 cp_token *identifier_token;
14243 /* Look for the identifier. */
14244 identifier_token = cp_lexer_peek_token (parser->lexer);
14245 ambiguous_p = identifier_token->ambiguous_p;
14246 identifier = cp_parser_identifier (parser);
14247 /* If the next token isn't an identifier, we are certainly not
14248 looking at a class-name. */
14249 if (identifier == error_mark_node)
14250 decl = error_mark_node;
14251 /* If we know this is a type-name, there's no need to look it
14253 else if (typename_p)
14257 tree ambiguous_decls;
14258 /* If we already know that this lookup is ambiguous, then
14259 we've already issued an error message; there's no reason
14263 cp_parser_simulate_error (parser);
14264 return error_mark_node;
14266 /* If the next token is a `::', then the name must be a type
14269 [basic.lookup.qual]
14271 During the lookup for a name preceding the :: scope
14272 resolution operator, object, function, and enumerator
14273 names are ignored. */
14274 if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
14275 tag_type = typename_type;
14276 /* Look up the name. */
14277 decl = cp_parser_lookup_name (parser, identifier,
14279 /*is_template=*/false,
14280 /*is_namespace=*/false,
14281 check_dependency_p,
14283 if (ambiguous_decls)
14285 error ("reference to %qD is ambiguous", identifier);
14286 print_candidates (ambiguous_decls);
14287 if (cp_parser_parsing_tentatively (parser))
14289 identifier_token->ambiguous_p = true;
14290 cp_parser_simulate_error (parser);
14292 return error_mark_node;
14298 /* Try a template-id. */
14299 decl = cp_parser_template_id (parser, template_keyword_p,
14300 check_dependency_p,
14302 if (decl == error_mark_node)
14303 return error_mark_node;
14306 decl = cp_parser_maybe_treat_template_as_class (decl, class_head_p);
14308 /* If this is a typename, create a TYPENAME_TYPE. */
14309 if (typename_p && decl != error_mark_node)
14311 decl = make_typename_type (scope, decl, typename_type,
14312 /*complain=*/tf_error);
14313 if (decl != error_mark_node)
14314 decl = TYPE_NAME (decl);
14317 /* Check to see that it is really the name of a class. */
14318 if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
14319 && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
14320 && cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
14321 /* Situations like this:
14323 template <typename T> struct A {
14324 typename T::template X<int>::I i;
14327 are problematic. Is `T::template X<int>' a class-name? The
14328 standard does not seem to be definitive, but there is no other
14329 valid interpretation of the following `::'. Therefore, those
14330 names are considered class-names. */
14332 decl = make_typename_type (scope, decl, tag_type, tf_error);
14333 if (decl != error_mark_node)
14334 decl = TYPE_NAME (decl);
14336 else if (TREE_CODE (decl) != TYPE_DECL
14337 || TREE_TYPE (decl) == error_mark_node
14338 || !MAYBE_CLASS_TYPE_P (TREE_TYPE (decl)))
14339 decl = error_mark_node;
14341 if (decl == error_mark_node)
14342 cp_parser_error (parser, "expected class-name");
14347 /* Parse a class-specifier.
14350 class-head { member-specification [opt] }
14352 Returns the TREE_TYPE representing the class. */
14355 cp_parser_class_specifier (cp_parser* parser)
14359 tree attributes = NULL_TREE;
14360 int has_trailing_semicolon;
14361 bool nested_name_specifier_p;
14362 unsigned saved_num_template_parameter_lists;
14363 bool saved_in_function_body;
14364 tree old_scope = NULL_TREE;
14365 tree scope = NULL_TREE;
14368 push_deferring_access_checks (dk_no_deferred);
14370 /* Parse the class-head. */
14371 type = cp_parser_class_head (parser,
14372 &nested_name_specifier_p,
14375 /* If the class-head was a semantic disaster, skip the entire body
14379 cp_parser_skip_to_end_of_block_or_statement (parser);
14380 pop_deferring_access_checks ();
14381 return error_mark_node;
14384 /* Look for the `{'. */
14385 if (!cp_parser_require (parser, CPP_OPEN_BRACE, "%<{%>"))
14387 pop_deferring_access_checks ();
14388 return error_mark_node;
14391 /* Process the base classes. If they're invalid, skip the
14392 entire class body. */
14393 if (!xref_basetypes (type, bases))
14395 /* Consuming the closing brace yields better error messages
14397 if (cp_parser_skip_to_closing_brace (parser))
14398 cp_lexer_consume_token (parser->lexer);
14399 pop_deferring_access_checks ();
14400 return error_mark_node;
14403 /* Issue an error message if type-definitions are forbidden here. */
14404 cp_parser_check_type_definition (parser);
14405 /* Remember that we are defining one more class. */
14406 ++parser->num_classes_being_defined;
14407 /* Inside the class, surrounding template-parameter-lists do not
14409 saved_num_template_parameter_lists
14410 = parser->num_template_parameter_lists;
14411 parser->num_template_parameter_lists = 0;
14412 /* We are not in a function body. */
14413 saved_in_function_body = parser->in_function_body;
14414 parser->in_function_body = false;
14416 /* Start the class. */
14417 if (nested_name_specifier_p)
14419 scope = CP_DECL_CONTEXT (TYPE_MAIN_DECL (type));
14420 old_scope = push_inner_scope (scope);
14422 type = begin_class_definition (type, attributes);
14424 if (type == error_mark_node)
14425 /* If the type is erroneous, skip the entire body of the class. */
14426 cp_parser_skip_to_closing_brace (parser);
14428 /* Parse the member-specification. */
14429 cp_parser_member_specification_opt (parser);
14431 /* Look for the trailing `}'. */
14432 cp_parser_require (parser, CPP_CLOSE_BRACE, "%<}%>");
14433 /* We get better error messages by noticing a common problem: a
14434 missing trailing `;'. */
14435 token = cp_lexer_peek_token (parser->lexer);
14436 has_trailing_semicolon = (token->type == CPP_SEMICOLON);
14437 /* Look for trailing attributes to apply to this class. */
14438 if (cp_parser_allow_gnu_extensions_p (parser))
14439 attributes = cp_parser_attributes_opt (parser);
14440 if (type != error_mark_node)
14441 type = finish_struct (type, attributes);
14442 if (nested_name_specifier_p)
14443 pop_inner_scope (old_scope, scope);
14444 /* If this class is not itself within the scope of another class,
14445 then we need to parse the bodies of all of the queued function
14446 definitions. Note that the queued functions defined in a class
14447 are not always processed immediately following the
14448 class-specifier for that class. Consider:
14451 struct B { void f() { sizeof (A); } };
14454 If `f' were processed before the processing of `A' were
14455 completed, there would be no way to compute the size of `A'.
14456 Note that the nesting we are interested in here is lexical --
14457 not the semantic nesting given by TYPE_CONTEXT. In particular,
14460 struct A { struct B; };
14461 struct A::B { void f() { } };
14463 there is no need to delay the parsing of `A::B::f'. */
14464 if (--parser->num_classes_being_defined == 0)
14468 tree class_type = NULL_TREE;
14469 tree pushed_scope = NULL_TREE;
14471 /* In a first pass, parse default arguments to the functions.
14472 Then, in a second pass, parse the bodies of the functions.
14473 This two-phased approach handles cases like:
14481 for (TREE_PURPOSE (parser->unparsed_functions_queues)
14482 = nreverse (TREE_PURPOSE (parser->unparsed_functions_queues));
14483 (queue_entry = TREE_PURPOSE (parser->unparsed_functions_queues));
14484 TREE_PURPOSE (parser->unparsed_functions_queues)
14485 = TREE_CHAIN (TREE_PURPOSE (parser->unparsed_functions_queues)))
14487 fn = TREE_VALUE (queue_entry);
14488 /* If there are default arguments that have not yet been processed,
14489 take care of them now. */
14490 if (class_type != TREE_PURPOSE (queue_entry))
14493 pop_scope (pushed_scope);
14494 class_type = TREE_PURPOSE (queue_entry);
14495 pushed_scope = push_scope (class_type);
14497 /* Make sure that any template parameters are in scope. */
14498 maybe_begin_member_template_processing (fn);
14499 /* Parse the default argument expressions. */
14500 cp_parser_late_parsing_default_args (parser, fn);
14501 /* Remove any template parameters from the symbol table. */
14502 maybe_end_member_template_processing ();
14505 pop_scope (pushed_scope);
14506 /* Now parse the body of the functions. */
14507 for (TREE_VALUE (parser->unparsed_functions_queues)
14508 = nreverse (TREE_VALUE (parser->unparsed_functions_queues));
14509 (queue_entry = TREE_VALUE (parser->unparsed_functions_queues));
14510 TREE_VALUE (parser->unparsed_functions_queues)
14511 = TREE_CHAIN (TREE_VALUE (parser->unparsed_functions_queues)))
14513 /* Figure out which function we need to process. */
14514 fn = TREE_VALUE (queue_entry);
14515 /* Parse the function. */
14516 cp_parser_late_parsing_for_member (parser, fn);
14520 /* Put back any saved access checks. */
14521 pop_deferring_access_checks ();
14523 /* Restore saved state. */
14524 parser->in_function_body = saved_in_function_body;
14525 parser->num_template_parameter_lists
14526 = saved_num_template_parameter_lists;
14531 /* Parse a class-head.
14534 class-key identifier [opt] base-clause [opt]
14535 class-key nested-name-specifier identifier base-clause [opt]
14536 class-key nested-name-specifier [opt] template-id
14540 class-key attributes identifier [opt] base-clause [opt]
14541 class-key attributes nested-name-specifier identifier base-clause [opt]
14542 class-key attributes nested-name-specifier [opt] template-id
14545 Upon return BASES is initialized to the list of base classes (or
14546 NULL, if there are none) in the same form returned by
14547 cp_parser_base_clause.
14549 Returns the TYPE of the indicated class. Sets
14550 *NESTED_NAME_SPECIFIER_P to TRUE iff one of the productions
14551 involving a nested-name-specifier was used, and FALSE otherwise.
14553 Returns error_mark_node if this is not a class-head.
14555 Returns NULL_TREE if the class-head is syntactically valid, but
14556 semantically invalid in a way that means we should skip the entire
14557 body of the class. */
14560 cp_parser_class_head (cp_parser* parser,
14561 bool* nested_name_specifier_p,
14562 tree *attributes_p,
14565 tree nested_name_specifier;
14566 enum tag_types class_key;
14567 tree id = NULL_TREE;
14568 tree type = NULL_TREE;
14570 bool template_id_p = false;
14571 bool qualified_p = false;
14572 bool invalid_nested_name_p = false;
14573 bool invalid_explicit_specialization_p = false;
14574 tree pushed_scope = NULL_TREE;
14575 unsigned num_templates;
14577 /* Assume no nested-name-specifier will be present. */
14578 *nested_name_specifier_p = false;
14579 /* Assume no template parameter lists will be used in defining the
14583 *bases = NULL_TREE;
14585 /* Look for the class-key. */
14586 class_key = cp_parser_class_key (parser);
14587 if (class_key == none_type)
14588 return error_mark_node;
14590 /* Parse the attributes. */
14591 attributes = cp_parser_attributes_opt (parser);
14593 /* If the next token is `::', that is invalid -- but sometimes
14594 people do try to write:
14598 Handle this gracefully by accepting the extra qualifier, and then
14599 issuing an error about it later if this really is a
14600 class-head. If it turns out just to be an elaborated type
14601 specifier, remain silent. */
14602 if (cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/false))
14603 qualified_p = true;
14605 push_deferring_access_checks (dk_no_check);
14607 /* Determine the name of the class. Begin by looking for an
14608 optional nested-name-specifier. */
14609 nested_name_specifier
14610 = cp_parser_nested_name_specifier_opt (parser,
14611 /*typename_keyword_p=*/false,
14612 /*check_dependency_p=*/false,
14614 /*is_declaration=*/false);
14615 /* If there was a nested-name-specifier, then there *must* be an
14617 if (nested_name_specifier)
14619 /* Although the grammar says `identifier', it really means
14620 `class-name' or `template-name'. You are only allowed to
14621 define a class that has already been declared with this
14624 The proposed resolution for Core Issue 180 says that wherever
14625 you see `class T::X' you should treat `X' as a type-name.
14627 It is OK to define an inaccessible class; for example:
14629 class A { class B; };
14632 We do not know if we will see a class-name, or a
14633 template-name. We look for a class-name first, in case the
14634 class-name is a template-id; if we looked for the
14635 template-name first we would stop after the template-name. */
14636 cp_parser_parse_tentatively (parser);
14637 type = cp_parser_class_name (parser,
14638 /*typename_keyword_p=*/false,
14639 /*template_keyword_p=*/false,
14641 /*check_dependency_p=*/false,
14642 /*class_head_p=*/true,
14643 /*is_declaration=*/false);
14644 /* If that didn't work, ignore the nested-name-specifier. */
14645 if (!cp_parser_parse_definitely (parser))
14647 invalid_nested_name_p = true;
14648 id = cp_parser_identifier (parser);
14649 if (id == error_mark_node)
14652 /* If we could not find a corresponding TYPE, treat this
14653 declaration like an unqualified declaration. */
14654 if (type == error_mark_node)
14655 nested_name_specifier = NULL_TREE;
14656 /* Otherwise, count the number of templates used in TYPE and its
14657 containing scopes. */
14662 for (scope = TREE_TYPE (type);
14663 scope && TREE_CODE (scope) != NAMESPACE_DECL;
14664 scope = (TYPE_P (scope)
14665 ? TYPE_CONTEXT (scope)
14666 : DECL_CONTEXT (scope)))
14668 && CLASS_TYPE_P (scope)
14669 && CLASSTYPE_TEMPLATE_INFO (scope)
14670 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (scope))
14671 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (scope))
14675 /* Otherwise, the identifier is optional. */
14678 /* We don't know whether what comes next is a template-id,
14679 an identifier, or nothing at all. */
14680 cp_parser_parse_tentatively (parser);
14681 /* Check for a template-id. */
14682 id = cp_parser_template_id (parser,
14683 /*template_keyword_p=*/false,
14684 /*check_dependency_p=*/true,
14685 /*is_declaration=*/true);
14686 /* If that didn't work, it could still be an identifier. */
14687 if (!cp_parser_parse_definitely (parser))
14689 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
14690 id = cp_parser_identifier (parser);
14696 template_id_p = true;
14701 pop_deferring_access_checks ();
14704 cp_parser_check_for_invalid_template_id (parser, id);
14706 /* If it's not a `:' or a `{' then we can't really be looking at a
14707 class-head, since a class-head only appears as part of a
14708 class-specifier. We have to detect this situation before calling
14709 xref_tag, since that has irreversible side-effects. */
14710 if (!cp_parser_next_token_starts_class_definition_p (parser))
14712 cp_parser_error (parser, "expected %<{%> or %<:%>");
14713 return error_mark_node;
14716 /* At this point, we're going ahead with the class-specifier, even
14717 if some other problem occurs. */
14718 cp_parser_commit_to_tentative_parse (parser);
14719 /* Issue the error about the overly-qualified name now. */
14721 cp_parser_error (parser,
14722 "global qualification of class name is invalid");
14723 else if (invalid_nested_name_p)
14724 cp_parser_error (parser,
14725 "qualified name does not name a class");
14726 else if (nested_name_specifier)
14730 /* Reject typedef-names in class heads. */
14731 if (!DECL_IMPLICIT_TYPEDEF_P (type))
14733 error ("invalid class name in declaration of %qD", type);
14738 /* Figure out in what scope the declaration is being placed. */
14739 scope = current_scope ();
14740 /* If that scope does not contain the scope in which the
14741 class was originally declared, the program is invalid. */
14742 if (scope && !is_ancestor (scope, nested_name_specifier))
14744 if (at_namespace_scope_p ())
14745 error ("declaration of %qD in namespace %qD which does not "
14746 "enclose %qD", type, scope, nested_name_specifier);
14748 error ("declaration of %qD in %qD which does not enclose %qD",
14749 type, scope, nested_name_specifier);
14755 A declarator-id shall not be qualified exception of the
14756 definition of a ... nested class outside of its class
14757 ... [or] a the definition or explicit instantiation of a
14758 class member of a namespace outside of its namespace. */
14759 if (scope == nested_name_specifier)
14761 pedwarn ("extra qualification ignored");
14762 nested_name_specifier = NULL_TREE;
14766 /* An explicit-specialization must be preceded by "template <>". If
14767 it is not, try to recover gracefully. */
14768 if (at_namespace_scope_p ()
14769 && parser->num_template_parameter_lists == 0
14772 error ("an explicit specialization must be preceded by %<template <>%>");
14773 invalid_explicit_specialization_p = true;
14774 /* Take the same action that would have been taken by
14775 cp_parser_explicit_specialization. */
14776 ++parser->num_template_parameter_lists;
14777 begin_specialization ();
14779 /* There must be no "return" statements between this point and the
14780 end of this function; set "type "to the correct return value and
14781 use "goto done;" to return. */
14782 /* Make sure that the right number of template parameters were
14784 if (!cp_parser_check_template_parameters (parser, num_templates))
14786 /* If something went wrong, there is no point in even trying to
14787 process the class-definition. */
14792 /* Look up the type. */
14795 if (TREE_CODE (id) == TEMPLATE_ID_EXPR
14796 && (DECL_FUNCTION_TEMPLATE_P (TREE_OPERAND (id, 0))
14797 || TREE_CODE (TREE_OPERAND (id, 0)) == OVERLOAD))
14799 error ("function template %qD redeclared as a class template", id);
14800 type = error_mark_node;
14804 type = TREE_TYPE (id);
14805 type = maybe_process_partial_specialization (type);
14807 if (nested_name_specifier)
14808 pushed_scope = push_scope (nested_name_specifier);
14810 else if (nested_name_specifier)
14816 template <typename T> struct S { struct T };
14817 template <typename T> struct S<T>::T { };
14819 we will get a TYPENAME_TYPE when processing the definition of
14820 `S::T'. We need to resolve it to the actual type before we
14821 try to define it. */
14822 if (TREE_CODE (TREE_TYPE (type)) == TYPENAME_TYPE)
14824 class_type = resolve_typename_type (TREE_TYPE (type),
14825 /*only_current_p=*/false);
14826 if (TREE_CODE (class_type) != TYPENAME_TYPE)
14827 type = TYPE_NAME (class_type);
14830 cp_parser_error (parser, "could not resolve typename type");
14831 type = error_mark_node;
14835 if (maybe_process_partial_specialization (TREE_TYPE (type))
14836 == error_mark_node)
14842 class_type = current_class_type;
14843 /* Enter the scope indicated by the nested-name-specifier. */
14844 pushed_scope = push_scope (nested_name_specifier);
14845 /* Get the canonical version of this type. */
14846 type = TYPE_MAIN_DECL (TREE_TYPE (type));
14847 if (PROCESSING_REAL_TEMPLATE_DECL_P ()
14848 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (type)))
14850 type = push_template_decl (type);
14851 if (type == error_mark_node)
14858 type = TREE_TYPE (type);
14859 *nested_name_specifier_p = true;
14861 else /* The name is not a nested name. */
14863 /* If the class was unnamed, create a dummy name. */
14865 id = make_anon_name ();
14866 type = xref_tag (class_key, id, /*tag_scope=*/ts_current,
14867 parser->num_template_parameter_lists);
14870 /* Indicate whether this class was declared as a `class' or as a
14872 if (TREE_CODE (type) == RECORD_TYPE)
14873 CLASSTYPE_DECLARED_CLASS (type) = (class_key == class_type);
14874 cp_parser_check_class_key (class_key, type);
14876 /* If this type was already complete, and we see another definition,
14877 that's an error. */
14878 if (type != error_mark_node && COMPLETE_TYPE_P (type))
14880 error ("redefinition of %q#T", type);
14881 error ("previous definition of %q+#T", type);
14885 else if (type == error_mark_node)
14888 /* We will have entered the scope containing the class; the names of
14889 base classes should be looked up in that context. For example:
14891 struct A { struct B {}; struct C; };
14892 struct A::C : B {};
14896 /* Get the list of base-classes, if there is one. */
14897 if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
14898 *bases = cp_parser_base_clause (parser);
14901 /* Leave the scope given by the nested-name-specifier. We will
14902 enter the class scope itself while processing the members. */
14904 pop_scope (pushed_scope);
14906 if (invalid_explicit_specialization_p)
14908 end_specialization ();
14909 --parser->num_template_parameter_lists;
14911 *attributes_p = attributes;
14915 /* Parse a class-key.
14922 Returns the kind of class-key specified, or none_type to indicate
14925 static enum tag_types
14926 cp_parser_class_key (cp_parser* parser)
14929 enum tag_types tag_type;
14931 /* Look for the class-key. */
14932 token = cp_parser_require (parser, CPP_KEYWORD, "class-key");
14936 /* Check to see if the TOKEN is a class-key. */
14937 tag_type = cp_parser_token_is_class_key (token);
14939 cp_parser_error (parser, "expected class-key");
14943 /* Parse an (optional) member-specification.
14945 member-specification:
14946 member-declaration member-specification [opt]
14947 access-specifier : member-specification [opt] */
14950 cp_parser_member_specification_opt (cp_parser* parser)
14957 /* Peek at the next token. */
14958 token = cp_lexer_peek_token (parser->lexer);
14959 /* If it's a `}', or EOF then we've seen all the members. */
14960 if (token->type == CPP_CLOSE_BRACE
14961 || token->type == CPP_EOF
14962 || token->type == CPP_PRAGMA_EOL)
14965 /* See if this token is a keyword. */
14966 keyword = token->keyword;
14970 case RID_PROTECTED:
14972 /* Consume the access-specifier. */
14973 cp_lexer_consume_token (parser->lexer);
14974 /* Remember which access-specifier is active. */
14975 current_access_specifier = token->u.value;
14976 /* Look for the `:'. */
14977 cp_parser_require (parser, CPP_COLON, "%<:%>");
14981 /* Accept #pragmas at class scope. */
14982 if (token->type == CPP_PRAGMA)
14984 cp_parser_pragma (parser, pragma_external);
14988 /* Otherwise, the next construction must be a
14989 member-declaration. */
14990 cp_parser_member_declaration (parser);
14995 /* Parse a member-declaration.
14997 member-declaration:
14998 decl-specifier-seq [opt] member-declarator-list [opt] ;
14999 function-definition ; [opt]
15000 :: [opt] nested-name-specifier template [opt] unqualified-id ;
15002 template-declaration
15004 member-declarator-list:
15006 member-declarator-list , member-declarator
15009 declarator pure-specifier [opt]
15010 declarator constant-initializer [opt]
15011 identifier [opt] : constant-expression
15015 member-declaration:
15016 __extension__ member-declaration
15019 declarator attributes [opt] pure-specifier [opt]
15020 declarator attributes [opt] constant-initializer [opt]
15021 identifier [opt] attributes [opt] : constant-expression
15025 member-declaration:
15026 static_assert-declaration */
15029 cp_parser_member_declaration (cp_parser* parser)
15031 cp_decl_specifier_seq decl_specifiers;
15032 tree prefix_attributes;
15034 int declares_class_or_enum;
15037 int saved_pedantic;
15039 /* Check for the `__extension__' keyword. */
15040 if (cp_parser_extension_opt (parser, &saved_pedantic))
15043 cp_parser_member_declaration (parser);
15044 /* Restore the old value of the PEDANTIC flag. */
15045 pedantic = saved_pedantic;
15050 /* Check for a template-declaration. */
15051 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
15053 /* An explicit specialization here is an error condition, and we
15054 expect the specialization handler to detect and report this. */
15055 if (cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_LESS
15056 && cp_lexer_peek_nth_token (parser->lexer, 3)->type == CPP_GREATER)
15057 cp_parser_explicit_specialization (parser);
15059 cp_parser_template_declaration (parser, /*member_p=*/true);
15064 /* Check for a using-declaration. */
15065 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_USING))
15067 /* Parse the using-declaration. */
15068 cp_parser_using_declaration (parser,
15069 /*access_declaration_p=*/false);
15073 /* Check for @defs. */
15074 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_AT_DEFS))
15077 tree ivar_chains = cp_parser_objc_defs_expression (parser);
15078 ivar = ivar_chains;
15082 ivar = TREE_CHAIN (member);
15083 TREE_CHAIN (member) = NULL_TREE;
15084 finish_member_declaration (member);
15089 /* If the next token is `static_assert' we have a static assertion. */
15090 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_STATIC_ASSERT))
15092 cp_parser_static_assert (parser, /*member_p=*/true);
15096 if (cp_parser_using_declaration (parser, /*access_declaration=*/true))
15099 /* Parse the decl-specifier-seq. */
15100 cp_parser_decl_specifier_seq (parser,
15101 CP_PARSER_FLAGS_OPTIONAL,
15103 &declares_class_or_enum);
15104 prefix_attributes = decl_specifiers.attributes;
15105 decl_specifiers.attributes = NULL_TREE;
15106 /* Check for an invalid type-name. */
15107 if (!decl_specifiers.type
15108 && cp_parser_parse_and_diagnose_invalid_type_name (parser))
15110 /* If there is no declarator, then the decl-specifier-seq should
15112 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
15114 /* If there was no decl-specifier-seq, and the next token is a
15115 `;', then we have something like:
15121 Each member-declaration shall declare at least one member
15122 name of the class. */
15123 if (!decl_specifiers.any_specifiers_p)
15125 cp_token *token = cp_lexer_peek_token (parser->lexer);
15126 if (pedantic && !token->in_system_header)
15127 pedwarn ("%Hextra %<;%>", &token->location);
15133 /* See if this declaration is a friend. */
15134 friend_p = cp_parser_friend_p (&decl_specifiers);
15135 /* If there were decl-specifiers, check to see if there was
15136 a class-declaration. */
15137 type = check_tag_decl (&decl_specifiers);
15138 /* Nested classes have already been added to the class, but
15139 a `friend' needs to be explicitly registered. */
15142 /* If the `friend' keyword was present, the friend must
15143 be introduced with a class-key. */
15144 if (!declares_class_or_enum)
15145 error ("a class-key must be used when declaring a friend");
15148 template <typename T> struct A {
15149 friend struct A<T>::B;
15152 A<T>::B will be represented by a TYPENAME_TYPE, and
15153 therefore not recognized by check_tag_decl. */
15155 && decl_specifiers.type
15156 && TYPE_P (decl_specifiers.type))
15157 type = decl_specifiers.type;
15158 if (!type || !TYPE_P (type))
15159 error ("friend declaration does not name a class or "
15162 make_friend_class (current_class_type, type,
15163 /*complain=*/true);
15165 /* If there is no TYPE, an error message will already have
15167 else if (!type || type == error_mark_node)
15169 /* An anonymous aggregate has to be handled specially; such
15170 a declaration really declares a data member (with a
15171 particular type), as opposed to a nested class. */
15172 else if (ANON_AGGR_TYPE_P (type))
15174 /* Remove constructors and such from TYPE, now that we
15175 know it is an anonymous aggregate. */
15176 fixup_anonymous_aggr (type);
15177 /* And make the corresponding data member. */
15178 decl = build_decl (FIELD_DECL, NULL_TREE, type);
15179 /* Add it to the class. */
15180 finish_member_declaration (decl);
15183 cp_parser_check_access_in_redeclaration (TYPE_NAME (type));
15188 /* See if these declarations will be friends. */
15189 friend_p = cp_parser_friend_p (&decl_specifiers);
15191 /* Keep going until we hit the `;' at the end of the
15193 while (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
15195 tree attributes = NULL_TREE;
15196 tree first_attribute;
15198 /* Peek at the next token. */
15199 token = cp_lexer_peek_token (parser->lexer);
15201 /* Check for a bitfield declaration. */
15202 if (token->type == CPP_COLON
15203 || (token->type == CPP_NAME
15204 && cp_lexer_peek_nth_token (parser->lexer, 2)->type
15210 /* Get the name of the bitfield. Note that we cannot just
15211 check TOKEN here because it may have been invalidated by
15212 the call to cp_lexer_peek_nth_token above. */
15213 if (cp_lexer_peek_token (parser->lexer)->type != CPP_COLON)
15214 identifier = cp_parser_identifier (parser);
15216 identifier = NULL_TREE;
15218 /* Consume the `:' token. */
15219 cp_lexer_consume_token (parser->lexer);
15220 /* Get the width of the bitfield. */
15222 = cp_parser_constant_expression (parser,
15223 /*allow_non_constant=*/false,
15226 /* Look for attributes that apply to the bitfield. */
15227 attributes = cp_parser_attributes_opt (parser);
15228 /* Remember which attributes are prefix attributes and
15230 first_attribute = attributes;
15231 /* Combine the attributes. */
15232 attributes = chainon (prefix_attributes, attributes);
15234 /* Create the bitfield declaration. */
15235 decl = grokbitfield (identifier
15236 ? make_id_declarator (NULL_TREE,
15246 cp_declarator *declarator;
15248 tree asm_specification;
15249 int ctor_dtor_or_conv_p;
15251 /* Parse the declarator. */
15253 = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
15254 &ctor_dtor_or_conv_p,
15255 /*parenthesized_p=*/NULL,
15256 /*member_p=*/true);
15258 /* If something went wrong parsing the declarator, make sure
15259 that we at least consume some tokens. */
15260 if (declarator == cp_error_declarator)
15262 /* Skip to the end of the statement. */
15263 cp_parser_skip_to_end_of_statement (parser);
15264 /* If the next token is not a semicolon, that is
15265 probably because we just skipped over the body of
15266 a function. So, we consume a semicolon if
15267 present, but do not issue an error message if it
15269 if (cp_lexer_next_token_is (parser->lexer,
15271 cp_lexer_consume_token (parser->lexer);
15275 if (declares_class_or_enum & 2)
15276 cp_parser_check_for_definition_in_return_type
15277 (declarator, decl_specifiers.type);
15279 /* Look for an asm-specification. */
15280 asm_specification = cp_parser_asm_specification_opt (parser);
15281 /* Look for attributes that apply to the declaration. */
15282 attributes = cp_parser_attributes_opt (parser);
15283 /* Remember which attributes are prefix attributes and
15285 first_attribute = attributes;
15286 /* Combine the attributes. */
15287 attributes = chainon (prefix_attributes, attributes);
15289 /* If it's an `=', then we have a constant-initializer or a
15290 pure-specifier. It is not correct to parse the
15291 initializer before registering the member declaration
15292 since the member declaration should be in scope while
15293 its initializer is processed. However, the rest of the
15294 front end does not yet provide an interface that allows
15295 us to handle this correctly. */
15296 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
15300 A pure-specifier shall be used only in the declaration of
15301 a virtual function.
15303 A member-declarator can contain a constant-initializer
15304 only if it declares a static member of integral or
15307 Therefore, if the DECLARATOR is for a function, we look
15308 for a pure-specifier; otherwise, we look for a
15309 constant-initializer. When we call `grokfield', it will
15310 perform more stringent semantics checks. */
15311 if (function_declarator_p (declarator))
15312 initializer = cp_parser_pure_specifier (parser);
15314 /* Parse the initializer. */
15315 initializer = cp_parser_constant_initializer (parser);
15317 /* Otherwise, there is no initializer. */
15319 initializer = NULL_TREE;
15321 /* See if we are probably looking at a function
15322 definition. We are certainly not looking at a
15323 member-declarator. Calling `grokfield' has
15324 side-effects, so we must not do it unless we are sure
15325 that we are looking at a member-declarator. */
15326 if (cp_parser_token_starts_function_definition_p
15327 (cp_lexer_peek_token (parser->lexer)))
15329 /* The grammar does not allow a pure-specifier to be
15330 used when a member function is defined. (It is
15331 possible that this fact is an oversight in the
15332 standard, since a pure function may be defined
15333 outside of the class-specifier. */
15335 error ("pure-specifier on function-definition");
15336 decl = cp_parser_save_member_function_body (parser,
15340 /* If the member was not a friend, declare it here. */
15342 finish_member_declaration (decl);
15343 /* Peek at the next token. */
15344 token = cp_lexer_peek_token (parser->lexer);
15345 /* If the next token is a semicolon, consume it. */
15346 if (token->type == CPP_SEMICOLON)
15347 cp_lexer_consume_token (parser->lexer);
15351 /* Create the declaration. */
15352 decl = grokfield (declarator, &decl_specifiers,
15353 initializer, /*init_const_expr_p=*/true,
15358 /* Reset PREFIX_ATTRIBUTES. */
15359 while (attributes && TREE_CHAIN (attributes) != first_attribute)
15360 attributes = TREE_CHAIN (attributes);
15362 TREE_CHAIN (attributes) = NULL_TREE;
15364 /* If there is any qualification still in effect, clear it
15365 now; we will be starting fresh with the next declarator. */
15366 parser->scope = NULL_TREE;
15367 parser->qualifying_scope = NULL_TREE;
15368 parser->object_scope = NULL_TREE;
15369 /* If it's a `,', then there are more declarators. */
15370 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
15371 cp_lexer_consume_token (parser->lexer);
15372 /* If the next token isn't a `;', then we have a parse error. */
15373 else if (cp_lexer_next_token_is_not (parser->lexer,
15376 cp_parser_error (parser, "expected %<;%>");
15377 /* Skip tokens until we find a `;'. */
15378 cp_parser_skip_to_end_of_statement (parser);
15385 /* Add DECL to the list of members. */
15387 finish_member_declaration (decl);
15389 if (TREE_CODE (decl) == FUNCTION_DECL)
15390 cp_parser_save_default_args (parser, decl);
15395 cp_parser_require (parser, CPP_SEMICOLON, "%<;%>");
15398 /* Parse a pure-specifier.
15403 Returns INTEGER_ZERO_NODE if a pure specifier is found.
15404 Otherwise, ERROR_MARK_NODE is returned. */
15407 cp_parser_pure_specifier (cp_parser* parser)
15411 /* Look for the `=' token. */
15412 if (!cp_parser_require (parser, CPP_EQ, "%<=%>"))
15413 return error_mark_node;
15414 /* Look for the `0' token. */
15415 token = cp_lexer_consume_token (parser->lexer);
15416 /* c_lex_with_flags marks a single digit '0' with PURE_ZERO. */
15417 if (token->type != CPP_NUMBER || !(token->flags & PURE_ZERO))
15419 cp_parser_error (parser,
15420 "invalid pure specifier (only %<= 0%> is allowed)");
15421 cp_parser_skip_to_end_of_statement (parser);
15422 return error_mark_node;
15424 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
15426 error ("templates may not be %<virtual%>");
15427 return error_mark_node;
15430 return integer_zero_node;
15433 /* Parse a constant-initializer.
15435 constant-initializer:
15436 = constant-expression
15438 Returns a representation of the constant-expression. */
15441 cp_parser_constant_initializer (cp_parser* parser)
15443 /* Look for the `=' token. */
15444 if (!cp_parser_require (parser, CPP_EQ, "%<=%>"))
15445 return error_mark_node;
15447 /* It is invalid to write:
15449 struct S { static const int i = { 7 }; };
15452 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
15454 cp_parser_error (parser,
15455 "a brace-enclosed initializer is not allowed here");
15456 /* Consume the opening brace. */
15457 cp_lexer_consume_token (parser->lexer);
15458 /* Skip the initializer. */
15459 cp_parser_skip_to_closing_brace (parser);
15460 /* Look for the trailing `}'. */
15461 cp_parser_require (parser, CPP_CLOSE_BRACE, "%<}%>");
15463 return error_mark_node;
15466 return cp_parser_constant_expression (parser,
15467 /*allow_non_constant=*/false,
15471 /* Derived classes [gram.class.derived] */
15473 /* Parse a base-clause.
15476 : base-specifier-list
15478 base-specifier-list:
15479 base-specifier ... [opt]
15480 base-specifier-list , base-specifier ... [opt]
15482 Returns a TREE_LIST representing the base-classes, in the order in
15483 which they were declared. The representation of each node is as
15484 described by cp_parser_base_specifier.
15486 In the case that no bases are specified, this function will return
15487 NULL_TREE, not ERROR_MARK_NODE. */
15490 cp_parser_base_clause (cp_parser* parser)
15492 tree bases = NULL_TREE;
15494 /* Look for the `:' that begins the list. */
15495 cp_parser_require (parser, CPP_COLON, "%<:%>");
15497 /* Scan the base-specifier-list. */
15502 bool pack_expansion_p = false;
15504 /* Look for the base-specifier. */
15505 base = cp_parser_base_specifier (parser);
15506 /* Look for the (optional) ellipsis. */
15507 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
15509 /* Consume the `...'. */
15510 cp_lexer_consume_token (parser->lexer);
15512 pack_expansion_p = true;
15515 /* Add BASE to the front of the list. */
15516 if (base != error_mark_node)
15518 if (pack_expansion_p)
15519 /* Make this a pack expansion type. */
15520 TREE_VALUE (base) = make_pack_expansion (TREE_VALUE (base));
15523 if (!check_for_bare_parameter_packs (TREE_VALUE (base)))
15525 TREE_CHAIN (base) = bases;
15529 /* Peek at the next token. */
15530 token = cp_lexer_peek_token (parser->lexer);
15531 /* If it's not a comma, then the list is complete. */
15532 if (token->type != CPP_COMMA)
15534 /* Consume the `,'. */
15535 cp_lexer_consume_token (parser->lexer);
15538 /* PARSER->SCOPE may still be non-NULL at this point, if the last
15539 base class had a qualified name. However, the next name that
15540 appears is certainly not qualified. */
15541 parser->scope = NULL_TREE;
15542 parser->qualifying_scope = NULL_TREE;
15543 parser->object_scope = NULL_TREE;
15545 return nreverse (bases);
15548 /* Parse a base-specifier.
15551 :: [opt] nested-name-specifier [opt] class-name
15552 virtual access-specifier [opt] :: [opt] nested-name-specifier
15554 access-specifier virtual [opt] :: [opt] nested-name-specifier
15557 Returns a TREE_LIST. The TREE_PURPOSE will be one of
15558 ACCESS_{DEFAULT,PUBLIC,PROTECTED,PRIVATE}_[VIRTUAL]_NODE to
15559 indicate the specifiers provided. The TREE_VALUE will be a TYPE
15560 (or the ERROR_MARK_NODE) indicating the type that was specified. */
15563 cp_parser_base_specifier (cp_parser* parser)
15567 bool virtual_p = false;
15568 bool duplicate_virtual_error_issued_p = false;
15569 bool duplicate_access_error_issued_p = false;
15570 bool class_scope_p, template_p;
15571 tree access = access_default_node;
15574 /* Process the optional `virtual' and `access-specifier'. */
15577 /* Peek at the next token. */
15578 token = cp_lexer_peek_token (parser->lexer);
15579 /* Process `virtual'. */
15580 switch (token->keyword)
15583 /* If `virtual' appears more than once, issue an error. */
15584 if (virtual_p && !duplicate_virtual_error_issued_p)
15586 cp_parser_error (parser,
15587 "%<virtual%> specified more than once in base-specified");
15588 duplicate_virtual_error_issued_p = true;
15593 /* Consume the `virtual' token. */
15594 cp_lexer_consume_token (parser->lexer);
15599 case RID_PROTECTED:
15601 /* If more than one access specifier appears, issue an
15603 if (access != access_default_node
15604 && !duplicate_access_error_issued_p)
15606 cp_parser_error (parser,
15607 "more than one access specifier in base-specified");
15608 duplicate_access_error_issued_p = true;
15611 access = ridpointers[(int) token->keyword];
15613 /* Consume the access-specifier. */
15614 cp_lexer_consume_token (parser->lexer);
15623 /* It is not uncommon to see programs mechanically, erroneously, use
15624 the 'typename' keyword to denote (dependent) qualified types
15625 as base classes. */
15626 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TYPENAME))
15628 if (!processing_template_decl)
15629 error ("keyword %<typename%> not allowed outside of templates");
15631 error ("keyword %<typename%> not allowed in this context "
15632 "(the base class is implicitly a type)");
15633 cp_lexer_consume_token (parser->lexer);
15636 /* Look for the optional `::' operator. */
15637 cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/false);
15638 /* Look for the nested-name-specifier. The simplest way to
15643 The keyword `typename' is not permitted in a base-specifier or
15644 mem-initializer; in these contexts a qualified name that
15645 depends on a template-parameter is implicitly assumed to be a
15648 is to pretend that we have seen the `typename' keyword at this
15650 cp_parser_nested_name_specifier_opt (parser,
15651 /*typename_keyword_p=*/true,
15652 /*check_dependency_p=*/true,
15654 /*is_declaration=*/true);
15655 /* If the base class is given by a qualified name, assume that names
15656 we see are type names or templates, as appropriate. */
15657 class_scope_p = (parser->scope && TYPE_P (parser->scope));
15658 template_p = class_scope_p && cp_parser_optional_template_keyword (parser);
15660 /* Finally, look for the class-name. */
15661 type = cp_parser_class_name (parser,
15665 /*check_dependency_p=*/true,
15666 /*class_head_p=*/false,
15667 /*is_declaration=*/true);
15669 if (type == error_mark_node)
15670 return error_mark_node;
15672 return finish_base_specifier (TREE_TYPE (type), access, virtual_p);
15675 /* Exception handling [gram.exception] */
15677 /* Parse an (optional) exception-specification.
15679 exception-specification:
15680 throw ( type-id-list [opt] )
15682 Returns a TREE_LIST representing the exception-specification. The
15683 TREE_VALUE of each node is a type. */
15686 cp_parser_exception_specification_opt (cp_parser* parser)
15691 /* Peek at the next token. */
15692 token = cp_lexer_peek_token (parser->lexer);
15693 /* If it's not `throw', then there's no exception-specification. */
15694 if (!cp_parser_is_keyword (token, RID_THROW))
15697 /* Consume the `throw'. */
15698 cp_lexer_consume_token (parser->lexer);
15700 /* Look for the `('. */
15701 cp_parser_require (parser, CPP_OPEN_PAREN, "%<(%>");
15703 /* Peek at the next token. */
15704 token = cp_lexer_peek_token (parser->lexer);
15705 /* If it's not a `)', then there is a type-id-list. */
15706 if (token->type != CPP_CLOSE_PAREN)
15708 const char *saved_message;
15710 /* Types may not be defined in an exception-specification. */
15711 saved_message = parser->type_definition_forbidden_message;
15712 parser->type_definition_forbidden_message
15713 = "types may not be defined in an exception-specification";
15714 /* Parse the type-id-list. */
15715 type_id_list = cp_parser_type_id_list (parser);
15716 /* Restore the saved message. */
15717 parser->type_definition_forbidden_message = saved_message;
15720 type_id_list = empty_except_spec;
15722 /* Look for the `)'. */
15723 cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>");
15725 return type_id_list;
15728 /* Parse an (optional) type-id-list.
15732 type-id-list , type-id ... [opt]
15734 Returns a TREE_LIST. The TREE_VALUE of each node is a TYPE,
15735 in the order that the types were presented. */
15738 cp_parser_type_id_list (cp_parser* parser)
15740 tree types = NULL_TREE;
15747 /* Get the next type-id. */
15748 type = cp_parser_type_id (parser);
15749 /* Parse the optional ellipsis. */
15750 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
15752 /* Consume the `...'. */
15753 cp_lexer_consume_token (parser->lexer);
15755 /* Turn the type into a pack expansion expression. */
15756 type = make_pack_expansion (type);
15758 /* Add it to the list. */
15759 types = add_exception_specifier (types, type, /*complain=*/1);
15760 /* Peek at the next token. */
15761 token = cp_lexer_peek_token (parser->lexer);
15762 /* If it is not a `,', we are done. */
15763 if (token->type != CPP_COMMA)
15765 /* Consume the `,'. */
15766 cp_lexer_consume_token (parser->lexer);
15769 return nreverse (types);
15772 /* Parse a try-block.
15775 try compound-statement handler-seq */
15778 cp_parser_try_block (cp_parser* parser)
15782 cp_parser_require_keyword (parser, RID_TRY, "%<try%>");
15783 try_block = begin_try_block ();
15784 cp_parser_compound_statement (parser, NULL, true);
15785 finish_try_block (try_block);
15786 cp_parser_handler_seq (parser);
15787 finish_handler_sequence (try_block);
15792 /* Parse a function-try-block.
15794 function-try-block:
15795 try ctor-initializer [opt] function-body handler-seq */
15798 cp_parser_function_try_block (cp_parser* parser)
15800 tree compound_stmt;
15802 bool ctor_initializer_p;
15804 /* Look for the `try' keyword. */
15805 if (!cp_parser_require_keyword (parser, RID_TRY, "%<try%>"))
15807 /* Let the rest of the front end know where we are. */
15808 try_block = begin_function_try_block (&compound_stmt);
15809 /* Parse the function-body. */
15811 = cp_parser_ctor_initializer_opt_and_function_body (parser);
15812 /* We're done with the `try' part. */
15813 finish_function_try_block (try_block);
15814 /* Parse the handlers. */
15815 cp_parser_handler_seq (parser);
15816 /* We're done with the handlers. */
15817 finish_function_handler_sequence (try_block, compound_stmt);
15819 return ctor_initializer_p;
15822 /* Parse a handler-seq.
15825 handler handler-seq [opt] */
15828 cp_parser_handler_seq (cp_parser* parser)
15834 /* Parse the handler. */
15835 cp_parser_handler (parser);
15836 /* Peek at the next token. */
15837 token = cp_lexer_peek_token (parser->lexer);
15838 /* If it's not `catch' then there are no more handlers. */
15839 if (!cp_parser_is_keyword (token, RID_CATCH))
15844 /* Parse a handler.
15847 catch ( exception-declaration ) compound-statement */
15850 cp_parser_handler (cp_parser* parser)
15855 cp_parser_require_keyword (parser, RID_CATCH, "%<catch%>");
15856 handler = begin_handler ();
15857 cp_parser_require (parser, CPP_OPEN_PAREN, "%<(%>");
15858 declaration = cp_parser_exception_declaration (parser);
15859 finish_handler_parms (declaration, handler);
15860 cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>");
15861 cp_parser_compound_statement (parser, NULL, false);
15862 finish_handler (handler);
15865 /* Parse an exception-declaration.
15867 exception-declaration:
15868 type-specifier-seq declarator
15869 type-specifier-seq abstract-declarator
15873 Returns a VAR_DECL for the declaration, or NULL_TREE if the
15874 ellipsis variant is used. */
15877 cp_parser_exception_declaration (cp_parser* parser)
15879 cp_decl_specifier_seq type_specifiers;
15880 cp_declarator *declarator;
15881 const char *saved_message;
15883 /* If it's an ellipsis, it's easy to handle. */
15884 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
15886 /* Consume the `...' token. */
15887 cp_lexer_consume_token (parser->lexer);
15891 /* Types may not be defined in exception-declarations. */
15892 saved_message = parser->type_definition_forbidden_message;
15893 parser->type_definition_forbidden_message
15894 = "types may not be defined in exception-declarations";
15896 /* Parse the type-specifier-seq. */
15897 cp_parser_type_specifier_seq (parser, /*is_condition=*/false,
15899 /* If it's a `)', then there is no declarator. */
15900 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
15903 declarator = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_EITHER,
15904 /*ctor_dtor_or_conv_p=*/NULL,
15905 /*parenthesized_p=*/NULL,
15906 /*member_p=*/false);
15908 /* Restore the saved message. */
15909 parser->type_definition_forbidden_message = saved_message;
15911 if (!type_specifiers.any_specifiers_p)
15912 return error_mark_node;
15914 return grokdeclarator (declarator, &type_specifiers, CATCHPARM, 1, NULL);
15917 /* Parse a throw-expression.
15920 throw assignment-expression [opt]
15922 Returns a THROW_EXPR representing the throw-expression. */
15925 cp_parser_throw_expression (cp_parser* parser)
15930 cp_parser_require_keyword (parser, RID_THROW, "%<throw%>");
15931 token = cp_lexer_peek_token (parser->lexer);
15932 /* Figure out whether or not there is an assignment-expression
15933 following the "throw" keyword. */
15934 if (token->type == CPP_COMMA
15935 || token->type == CPP_SEMICOLON
15936 || token->type == CPP_CLOSE_PAREN
15937 || token->type == CPP_CLOSE_SQUARE
15938 || token->type == CPP_CLOSE_BRACE
15939 || token->type == CPP_COLON)
15940 expression = NULL_TREE;
15942 expression = cp_parser_assignment_expression (parser,
15945 return build_throw (expression);
15948 /* GNU Extensions */
15950 /* Parse an (optional) asm-specification.
15953 asm ( string-literal )
15955 If the asm-specification is present, returns a STRING_CST
15956 corresponding to the string-literal. Otherwise, returns
15960 cp_parser_asm_specification_opt (cp_parser* parser)
15963 tree asm_specification;
15965 /* Peek at the next token. */
15966 token = cp_lexer_peek_token (parser->lexer);
15967 /* If the next token isn't the `asm' keyword, then there's no
15968 asm-specification. */
15969 if (!cp_parser_is_keyword (token, RID_ASM))
15972 /* Consume the `asm' token. */
15973 cp_lexer_consume_token (parser->lexer);
15974 /* Look for the `('. */
15975 cp_parser_require (parser, CPP_OPEN_PAREN, "%<(%>");
15977 /* Look for the string-literal. */
15978 asm_specification = cp_parser_string_literal (parser, false, false);
15980 /* Look for the `)'. */
15981 cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>");
15983 return asm_specification;
15986 /* Parse an asm-operand-list.
15990 asm-operand-list , asm-operand
15993 string-literal ( expression )
15994 [ string-literal ] string-literal ( expression )
15996 Returns a TREE_LIST representing the operands. The TREE_VALUE of
15997 each node is the expression. The TREE_PURPOSE is itself a
15998 TREE_LIST whose TREE_PURPOSE is a STRING_CST for the bracketed
15999 string-literal (or NULL_TREE if not present) and whose TREE_VALUE
16000 is a STRING_CST for the string literal before the parenthesis. Returns
16001 ERROR_MARK_NODE if any of the operands are invalid. */
16004 cp_parser_asm_operand_list (cp_parser* parser)
16006 tree asm_operands = NULL_TREE;
16007 bool invalid_operands = false;
16011 tree string_literal;
16015 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
16017 /* Consume the `[' token. */
16018 cp_lexer_consume_token (parser->lexer);
16019 /* Read the operand name. */
16020 name = cp_parser_identifier (parser);
16021 if (name != error_mark_node)
16022 name = build_string (IDENTIFIER_LENGTH (name),
16023 IDENTIFIER_POINTER (name));
16024 /* Look for the closing `]'. */
16025 cp_parser_require (parser, CPP_CLOSE_SQUARE, "%<]%>");
16029 /* Look for the string-literal. */
16030 string_literal = cp_parser_string_literal (parser, false, false);
16032 /* Look for the `('. */
16033 cp_parser_require (parser, CPP_OPEN_PAREN, "%<(%>");
16034 /* Parse the expression. */
16035 expression = cp_parser_expression (parser, /*cast_p=*/false);
16036 /* Look for the `)'. */
16037 cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>");
16039 if (name == error_mark_node
16040 || string_literal == error_mark_node
16041 || expression == error_mark_node)
16042 invalid_operands = true;
16044 /* Add this operand to the list. */
16045 asm_operands = tree_cons (build_tree_list (name, string_literal),
16048 /* If the next token is not a `,', there are no more
16050 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
16052 /* Consume the `,'. */
16053 cp_lexer_consume_token (parser->lexer);
16056 return invalid_operands ? error_mark_node : nreverse (asm_operands);
16059 /* Parse an asm-clobber-list.
16063 asm-clobber-list , string-literal
16065 Returns a TREE_LIST, indicating the clobbers in the order that they
16066 appeared. The TREE_VALUE of each node is a STRING_CST. */
16069 cp_parser_asm_clobber_list (cp_parser* parser)
16071 tree clobbers = NULL_TREE;
16075 tree string_literal;
16077 /* Look for the string literal. */
16078 string_literal = cp_parser_string_literal (parser, false, false);
16079 /* Add it to the list. */
16080 clobbers = tree_cons (NULL_TREE, string_literal, clobbers);
16081 /* If the next token is not a `,', then the list is
16083 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
16085 /* Consume the `,' token. */
16086 cp_lexer_consume_token (parser->lexer);
16092 /* Parse an (optional) series of attributes.
16095 attributes attribute
16098 __attribute__ (( attribute-list [opt] ))
16100 The return value is as for cp_parser_attribute_list. */
16103 cp_parser_attributes_opt (cp_parser* parser)
16105 tree attributes = NULL_TREE;
16110 tree attribute_list;
16112 /* Peek at the next token. */
16113 token = cp_lexer_peek_token (parser->lexer);
16114 /* If it's not `__attribute__', then we're done. */
16115 if (token->keyword != RID_ATTRIBUTE)
16118 /* Consume the `__attribute__' keyword. */
16119 cp_lexer_consume_token (parser->lexer);
16120 /* Look for the two `(' tokens. */
16121 cp_parser_require (parser, CPP_OPEN_PAREN, "%<(%>");
16122 cp_parser_require (parser, CPP_OPEN_PAREN, "%<(%>");
16124 /* Peek at the next token. */
16125 token = cp_lexer_peek_token (parser->lexer);
16126 if (token->type != CPP_CLOSE_PAREN)
16127 /* Parse the attribute-list. */
16128 attribute_list = cp_parser_attribute_list (parser);
16130 /* If the next token is a `)', then there is no attribute
16132 attribute_list = NULL;
16134 /* Look for the two `)' tokens. */
16135 cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>");
16136 cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>");
16138 /* Add these new attributes to the list. */
16139 attributes = chainon (attributes, attribute_list);
16145 /* Parse an attribute-list.
16149 attribute-list , attribute
16153 identifier ( identifier )
16154 identifier ( identifier , expression-list )
16155 identifier ( expression-list )
16157 Returns a TREE_LIST, or NULL_TREE on error. Each node corresponds
16158 to an attribute. The TREE_PURPOSE of each node is the identifier
16159 indicating which attribute is in use. The TREE_VALUE represents
16160 the arguments, if any. */
16163 cp_parser_attribute_list (cp_parser* parser)
16165 tree attribute_list = NULL_TREE;
16166 bool save_translate_strings_p = parser->translate_strings_p;
16168 parser->translate_strings_p = false;
16175 /* Look for the identifier. We also allow keywords here; for
16176 example `__attribute__ ((const))' is legal. */
16177 token = cp_lexer_peek_token (parser->lexer);
16178 if (token->type == CPP_NAME
16179 || token->type == CPP_KEYWORD)
16181 tree arguments = NULL_TREE;
16183 /* Consume the token. */
16184 token = cp_lexer_consume_token (parser->lexer);
16186 /* Save away the identifier that indicates which attribute
16188 identifier = token->u.value;
16189 attribute = build_tree_list (identifier, NULL_TREE);
16191 /* Peek at the next token. */
16192 token = cp_lexer_peek_token (parser->lexer);
16193 /* If it's an `(', then parse the attribute arguments. */
16194 if (token->type == CPP_OPEN_PAREN)
16196 arguments = cp_parser_parenthesized_expression_list
16197 (parser, true, /*cast_p=*/false,
16198 /*allow_expansion_p=*/false,
16199 /*non_constant_p=*/NULL);
16200 /* Save the arguments away. */
16201 TREE_VALUE (attribute) = arguments;
16204 if (arguments != error_mark_node)
16206 /* Add this attribute to the list. */
16207 TREE_CHAIN (attribute) = attribute_list;
16208 attribute_list = attribute;
16211 token = cp_lexer_peek_token (parser->lexer);
16213 /* Now, look for more attributes. If the next token isn't a
16214 `,', we're done. */
16215 if (token->type != CPP_COMMA)
16218 /* Consume the comma and keep going. */
16219 cp_lexer_consume_token (parser->lexer);
16221 parser->translate_strings_p = save_translate_strings_p;
16223 /* We built up the list in reverse order. */
16224 return nreverse (attribute_list);
16227 /* Parse an optional `__extension__' keyword. Returns TRUE if it is
16228 present, and FALSE otherwise. *SAVED_PEDANTIC is set to the
16229 current value of the PEDANTIC flag, regardless of whether or not
16230 the `__extension__' keyword is present. The caller is responsible
16231 for restoring the value of the PEDANTIC flag. */
16234 cp_parser_extension_opt (cp_parser* parser, int* saved_pedantic)
16236 /* Save the old value of the PEDANTIC flag. */
16237 *saved_pedantic = pedantic;
16239 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_EXTENSION))
16241 /* Consume the `__extension__' token. */
16242 cp_lexer_consume_token (parser->lexer);
16243 /* We're not being pedantic while the `__extension__' keyword is
16253 /* Parse a label declaration.
16256 __label__ label-declarator-seq ;
16258 label-declarator-seq:
16259 identifier , label-declarator-seq
16263 cp_parser_label_declaration (cp_parser* parser)
16265 /* Look for the `__label__' keyword. */
16266 cp_parser_require_keyword (parser, RID_LABEL, "%<__label__%>");
16272 /* Look for an identifier. */
16273 identifier = cp_parser_identifier (parser);
16274 /* If we failed, stop. */
16275 if (identifier == error_mark_node)
16277 /* Declare it as a label. */
16278 finish_label_decl (identifier);
16279 /* If the next token is a `;', stop. */
16280 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
16282 /* Look for the `,' separating the label declarations. */
16283 cp_parser_require (parser, CPP_COMMA, "%<,%>");
16286 /* Look for the final `;'. */
16287 cp_parser_require (parser, CPP_SEMICOLON, "%<;%>");
16290 /* Support Functions */
16292 /* Looks up NAME in the current scope, as given by PARSER->SCOPE.
16293 NAME should have one of the representations used for an
16294 id-expression. If NAME is the ERROR_MARK_NODE, the ERROR_MARK_NODE
16295 is returned. If PARSER->SCOPE is a dependent type, then a
16296 SCOPE_REF is returned.
16298 If NAME is a TEMPLATE_ID_EXPR, then it will be immediately
16299 returned; the name was already resolved when the TEMPLATE_ID_EXPR
16300 was formed. Abstractly, such entities should not be passed to this
16301 function, because they do not need to be looked up, but it is
16302 simpler to check for this special case here, rather than at the
16305 In cases not explicitly covered above, this function returns a
16306 DECL, OVERLOAD, or baselink representing the result of the lookup.
16307 If there was no entity with the indicated NAME, the ERROR_MARK_NODE
16310 If TAG_TYPE is not NONE_TYPE, it indicates an explicit type keyword
16311 (e.g., "struct") that was used. In that case bindings that do not
16312 refer to types are ignored.
16314 If IS_TEMPLATE is TRUE, bindings that do not refer to templates are
16317 If IS_NAMESPACE is TRUE, bindings that do not refer to namespaces
16320 If CHECK_DEPENDENCY is TRUE, names are not looked up in dependent
16323 If AMBIGUOUS_DECLS is non-NULL, *AMBIGUOUS_DECLS is set to a
16324 TREE_LIST of candidates if name-lookup results in an ambiguity, and
16325 NULL_TREE otherwise. */
16328 cp_parser_lookup_name (cp_parser *parser, tree name,
16329 enum tag_types tag_type,
16332 bool check_dependency,
16333 tree *ambiguous_decls)
16337 tree object_type = parser->context->object_type;
16339 if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
16340 flags |= LOOKUP_COMPLAIN;
16342 /* Assume that the lookup will be unambiguous. */
16343 if (ambiguous_decls)
16344 *ambiguous_decls = NULL_TREE;
16346 /* Now that we have looked up the name, the OBJECT_TYPE (if any) is
16347 no longer valid. Note that if we are parsing tentatively, and
16348 the parse fails, OBJECT_TYPE will be automatically restored. */
16349 parser->context->object_type = NULL_TREE;
16351 if (name == error_mark_node)
16352 return error_mark_node;
16354 /* A template-id has already been resolved; there is no lookup to
16356 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
16358 if (BASELINK_P (name))
16360 gcc_assert (TREE_CODE (BASELINK_FUNCTIONS (name))
16361 == TEMPLATE_ID_EXPR);
16365 /* A BIT_NOT_EXPR is used to represent a destructor. By this point,
16366 it should already have been checked to make sure that the name
16367 used matches the type being destroyed. */
16368 if (TREE_CODE (name) == BIT_NOT_EXPR)
16372 /* Figure out to which type this destructor applies. */
16374 type = parser->scope;
16375 else if (object_type)
16376 type = object_type;
16378 type = current_class_type;
16379 /* If that's not a class type, there is no destructor. */
16380 if (!type || !CLASS_TYPE_P (type))
16381 return error_mark_node;
16382 if (CLASSTYPE_LAZY_DESTRUCTOR (type))
16383 lazily_declare_fn (sfk_destructor, type);
16384 if (!CLASSTYPE_DESTRUCTORS (type))
16385 return error_mark_node;
16386 /* If it was a class type, return the destructor. */
16387 return CLASSTYPE_DESTRUCTORS (type);
16390 /* By this point, the NAME should be an ordinary identifier. If
16391 the id-expression was a qualified name, the qualifying scope is
16392 stored in PARSER->SCOPE at this point. */
16393 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
16395 /* Perform the lookup. */
16400 if (parser->scope == error_mark_node)
16401 return error_mark_node;
16403 /* If the SCOPE is dependent, the lookup must be deferred until
16404 the template is instantiated -- unless we are explicitly
16405 looking up names in uninstantiated templates. Even then, we
16406 cannot look up the name if the scope is not a class type; it
16407 might, for example, be a template type parameter. */
16408 dependent_p = (TYPE_P (parser->scope)
16409 && !(parser->in_declarator_p
16410 && currently_open_class (parser->scope))
16411 && dependent_type_p (parser->scope));
16412 if ((check_dependency || !CLASS_TYPE_P (parser->scope))
16419 /* The resolution to Core Issue 180 says that `struct
16420 A::B' should be considered a type-name, even if `A'
16422 type = make_typename_type (parser->scope, name, tag_type,
16423 /*complain=*/tf_error);
16424 decl = TYPE_NAME (type);
16426 else if (is_template
16427 && (cp_parser_next_token_ends_template_argument_p (parser)
16428 || cp_lexer_next_token_is (parser->lexer,
16430 decl = make_unbound_class_template (parser->scope,
16432 /*complain=*/tf_error);
16434 decl = build_qualified_name (/*type=*/NULL_TREE,
16435 parser->scope, name,
16440 tree pushed_scope = NULL_TREE;
16442 /* If PARSER->SCOPE is a dependent type, then it must be a
16443 class type, and we must not be checking dependencies;
16444 otherwise, we would have processed this lookup above. So
16445 that PARSER->SCOPE is not considered a dependent base by
16446 lookup_member, we must enter the scope here. */
16448 pushed_scope = push_scope (parser->scope);
16449 /* If the PARSER->SCOPE is a template specialization, it
16450 may be instantiated during name lookup. In that case,
16451 errors may be issued. Even if we rollback the current
16452 tentative parse, those errors are valid. */
16453 decl = lookup_qualified_name (parser->scope, name,
16454 tag_type != none_type,
16455 /*complain=*/true);
16457 /* If we have a single function from a using decl, pull it out. */
16459 && TREE_CODE (decl) == OVERLOAD
16460 && !really_overloaded_fn (decl))
16461 decl = OVL_FUNCTION (decl);
16464 pop_scope (pushed_scope);
16466 parser->qualifying_scope = parser->scope;
16467 parser->object_scope = NULL_TREE;
16469 else if (object_type)
16471 tree object_decl = NULL_TREE;
16472 /* Look up the name in the scope of the OBJECT_TYPE, unless the
16473 OBJECT_TYPE is not a class. */
16474 if (CLASS_TYPE_P (object_type))
16475 /* If the OBJECT_TYPE is a template specialization, it may
16476 be instantiated during name lookup. In that case, errors
16477 may be issued. Even if we rollback the current tentative
16478 parse, those errors are valid. */
16479 object_decl = lookup_member (object_type,
16482 tag_type != none_type);
16483 /* Look it up in the enclosing context, too. */
16484 decl = lookup_name_real (name, tag_type != none_type,
16486 /*block_p=*/true, is_namespace, flags);
16487 parser->object_scope = object_type;
16488 parser->qualifying_scope = NULL_TREE;
16490 decl = object_decl;
16494 decl = lookup_name_real (name, tag_type != none_type,
16496 /*block_p=*/true, is_namespace, flags);
16497 parser->qualifying_scope = NULL_TREE;
16498 parser->object_scope = NULL_TREE;
16501 /* If the lookup failed, let our caller know. */
16502 if (!decl || decl == error_mark_node)
16503 return error_mark_node;
16505 /* If it's a TREE_LIST, the result of the lookup was ambiguous. */
16506 if (TREE_CODE (decl) == TREE_LIST)
16508 if (ambiguous_decls)
16509 *ambiguous_decls = decl;
16510 /* The error message we have to print is too complicated for
16511 cp_parser_error, so we incorporate its actions directly. */
16512 if (!cp_parser_simulate_error (parser))
16514 error ("reference to %qD is ambiguous", name);
16515 print_candidates (decl);
16517 return error_mark_node;
16520 gcc_assert (DECL_P (decl)
16521 || TREE_CODE (decl) == OVERLOAD
16522 || TREE_CODE (decl) == SCOPE_REF
16523 || TREE_CODE (decl) == UNBOUND_CLASS_TEMPLATE
16524 || BASELINK_P (decl));
16526 /* If we have resolved the name of a member declaration, check to
16527 see if the declaration is accessible. When the name resolves to
16528 set of overloaded functions, accessibility is checked when
16529 overload resolution is done.
16531 During an explicit instantiation, access is not checked at all,
16532 as per [temp.explicit]. */
16534 check_accessibility_of_qualified_id (decl, object_type, parser->scope);
16539 /* Like cp_parser_lookup_name, but for use in the typical case where
16540 CHECK_ACCESS is TRUE, IS_TYPE is FALSE, IS_TEMPLATE is FALSE,
16541 IS_NAMESPACE is FALSE, and CHECK_DEPENDENCY is TRUE. */
16544 cp_parser_lookup_name_simple (cp_parser* parser, tree name)
16546 return cp_parser_lookup_name (parser, name,
16548 /*is_template=*/false,
16549 /*is_namespace=*/false,
16550 /*check_dependency=*/true,
16551 /*ambiguous_decls=*/NULL);
16554 /* If DECL is a TEMPLATE_DECL that can be treated like a TYPE_DECL in
16555 the current context, return the TYPE_DECL. If TAG_NAME_P is
16556 true, the DECL indicates the class being defined in a class-head,
16557 or declared in an elaborated-type-specifier.
16559 Otherwise, return DECL. */
16562 cp_parser_maybe_treat_template_as_class (tree decl, bool tag_name_p)
16564 /* If the TEMPLATE_DECL is being declared as part of a class-head,
16565 the translation from TEMPLATE_DECL to TYPE_DECL occurs:
16568 template <typename T> struct B;
16571 template <typename T> struct A::B {};
16573 Similarly, in an elaborated-type-specifier:
16575 namespace N { struct X{}; }
16578 template <typename T> friend struct N::X;
16581 However, if the DECL refers to a class type, and we are in
16582 the scope of the class, then the name lookup automatically
16583 finds the TYPE_DECL created by build_self_reference rather
16584 than a TEMPLATE_DECL. For example, in:
16586 template <class T> struct S {
16590 there is no need to handle such case. */
16592 if (DECL_CLASS_TEMPLATE_P (decl) && tag_name_p)
16593 return DECL_TEMPLATE_RESULT (decl);
16598 /* If too many, or too few, template-parameter lists apply to the
16599 declarator, issue an error message. Returns TRUE if all went well,
16600 and FALSE otherwise. */
16603 cp_parser_check_declarator_template_parameters (cp_parser* parser,
16604 cp_declarator *declarator)
16606 unsigned num_templates;
16608 /* We haven't seen any classes that involve template parameters yet. */
16611 switch (declarator->kind)
16614 if (declarator->u.id.qualifying_scope)
16619 scope = declarator->u.id.qualifying_scope;
16620 member = declarator->u.id.unqualified_name;
16622 while (scope && CLASS_TYPE_P (scope))
16624 /* You're supposed to have one `template <...>'
16625 for every template class, but you don't need one
16626 for a full specialization. For example:
16628 template <class T> struct S{};
16629 template <> struct S<int> { void f(); };
16630 void S<int>::f () {}
16632 is correct; there shouldn't be a `template <>' for
16633 the definition of `S<int>::f'. */
16634 if (!CLASSTYPE_TEMPLATE_INFO (scope))
16635 /* If SCOPE does not have template information of any
16636 kind, then it is not a template, nor is it nested
16637 within a template. */
16639 if (explicit_class_specialization_p (scope))
16641 if (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (scope)))
16644 scope = TYPE_CONTEXT (scope);
16647 else if (TREE_CODE (declarator->u.id.unqualified_name)
16648 == TEMPLATE_ID_EXPR)
16649 /* If the DECLARATOR has the form `X<y>' then it uses one
16650 additional level of template parameters. */
16653 return cp_parser_check_template_parameters (parser,
16659 case cdk_reference:
16661 return (cp_parser_check_declarator_template_parameters
16662 (parser, declarator->declarator));
16668 gcc_unreachable ();
16673 /* NUM_TEMPLATES were used in the current declaration. If that is
16674 invalid, return FALSE and issue an error messages. Otherwise,
16678 cp_parser_check_template_parameters (cp_parser* parser,
16679 unsigned num_templates)
16681 /* If there are more template classes than parameter lists, we have
16684 template <class T> void S<T>::R<T>::f (); */
16685 if (parser->num_template_parameter_lists < num_templates)
16687 error ("too few template-parameter-lists");
16690 /* If there are the same number of template classes and parameter
16691 lists, that's OK. */
16692 if (parser->num_template_parameter_lists == num_templates)
16694 /* If there are more, but only one more, then we are referring to a
16695 member template. That's OK too. */
16696 if (parser->num_template_parameter_lists == num_templates + 1)
16698 /* Otherwise, there are too many template parameter lists. We have
16701 template <class T> template <class U> void S::f(); */
16702 error ("too many template-parameter-lists");
16706 /* Parse an optional `::' token indicating that the following name is
16707 from the global namespace. If so, PARSER->SCOPE is set to the
16708 GLOBAL_NAMESPACE. Otherwise, PARSER->SCOPE is set to NULL_TREE,
16709 unless CURRENT_SCOPE_VALID_P is TRUE, in which case it is left alone.
16710 Returns the new value of PARSER->SCOPE, if the `::' token is
16711 present, and NULL_TREE otherwise. */
16714 cp_parser_global_scope_opt (cp_parser* parser, bool current_scope_valid_p)
16718 /* Peek at the next token. */
16719 token = cp_lexer_peek_token (parser->lexer);
16720 /* If we're looking at a `::' token then we're starting from the
16721 global namespace, not our current location. */
16722 if (token->type == CPP_SCOPE)
16724 /* Consume the `::' token. */
16725 cp_lexer_consume_token (parser->lexer);
16726 /* Set the SCOPE so that we know where to start the lookup. */
16727 parser->scope = global_namespace;
16728 parser->qualifying_scope = global_namespace;
16729 parser->object_scope = NULL_TREE;
16731 return parser->scope;
16733 else if (!current_scope_valid_p)
16735 parser->scope = NULL_TREE;
16736 parser->qualifying_scope = NULL_TREE;
16737 parser->object_scope = NULL_TREE;
16743 /* Returns TRUE if the upcoming token sequence is the start of a
16744 constructor declarator. If FRIEND_P is true, the declarator is
16745 preceded by the `friend' specifier. */
16748 cp_parser_constructor_declarator_p (cp_parser *parser, bool friend_p)
16750 bool constructor_p;
16751 tree type_decl = NULL_TREE;
16752 bool nested_name_p;
16753 cp_token *next_token;
16755 /* The common case is that this is not a constructor declarator, so
16756 try to avoid doing lots of work if at all possible. It's not
16757 valid declare a constructor at function scope. */
16758 if (parser->in_function_body)
16760 /* And only certain tokens can begin a constructor declarator. */
16761 next_token = cp_lexer_peek_token (parser->lexer);
16762 if (next_token->type != CPP_NAME
16763 && next_token->type != CPP_SCOPE
16764 && next_token->type != CPP_NESTED_NAME_SPECIFIER
16765 && next_token->type != CPP_TEMPLATE_ID)
16768 /* Parse tentatively; we are going to roll back all of the tokens
16770 cp_parser_parse_tentatively (parser);
16771 /* Assume that we are looking at a constructor declarator. */
16772 constructor_p = true;
16774 /* Look for the optional `::' operator. */
16775 cp_parser_global_scope_opt (parser,
16776 /*current_scope_valid_p=*/false);
16777 /* Look for the nested-name-specifier. */
16779 = (cp_parser_nested_name_specifier_opt (parser,
16780 /*typename_keyword_p=*/false,
16781 /*check_dependency_p=*/false,
16783 /*is_declaration=*/false)
16785 /* Outside of a class-specifier, there must be a
16786 nested-name-specifier. */
16787 if (!nested_name_p &&
16788 (!at_class_scope_p () || !TYPE_BEING_DEFINED (current_class_type)
16790 constructor_p = false;
16791 /* If we still think that this might be a constructor-declarator,
16792 look for a class-name. */
16797 template <typename T> struct S { S(); };
16798 template <typename T> S<T>::S ();
16800 we must recognize that the nested `S' names a class.
16803 template <typename T> S<T>::S<T> ();
16805 we must recognize that the nested `S' names a template. */
16806 type_decl = cp_parser_class_name (parser,
16807 /*typename_keyword_p=*/false,
16808 /*template_keyword_p=*/false,
16810 /*check_dependency_p=*/false,
16811 /*class_head_p=*/false,
16812 /*is_declaration=*/false);
16813 /* If there was no class-name, then this is not a constructor. */
16814 constructor_p = !cp_parser_error_occurred (parser);
16817 /* If we're still considering a constructor, we have to see a `(',
16818 to begin the parameter-declaration-clause, followed by either a
16819 `)', an `...', or a decl-specifier. We need to check for a
16820 type-specifier to avoid being fooled into thinking that:
16824 is a constructor. (It is actually a function named `f' that
16825 takes one parameter (of type `int') and returns a value of type
16828 && cp_parser_require (parser, CPP_OPEN_PAREN, "%<(%>"))
16830 if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN)
16831 && cp_lexer_next_token_is_not (parser->lexer, CPP_ELLIPSIS)
16832 /* A parameter declaration begins with a decl-specifier,
16833 which is either the "attribute" keyword, a storage class
16834 specifier, or (usually) a type-specifier. */
16835 && !cp_lexer_next_token_is_decl_specifier_keyword (parser->lexer))
16838 tree pushed_scope = NULL_TREE;
16839 unsigned saved_num_template_parameter_lists;
16841 /* Names appearing in the type-specifier should be looked up
16842 in the scope of the class. */
16843 if (current_class_type)
16847 type = TREE_TYPE (type_decl);
16848 if (TREE_CODE (type) == TYPENAME_TYPE)
16850 type = resolve_typename_type (type,
16851 /*only_current_p=*/false);
16852 if (TREE_CODE (type) == TYPENAME_TYPE)
16854 cp_parser_abort_tentative_parse (parser);
16858 pushed_scope = push_scope (type);
16861 /* Inside the constructor parameter list, surrounding
16862 template-parameter-lists do not apply. */
16863 saved_num_template_parameter_lists
16864 = parser->num_template_parameter_lists;
16865 parser->num_template_parameter_lists = 0;
16867 /* Look for the type-specifier. */
16868 cp_parser_type_specifier (parser,
16869 CP_PARSER_FLAGS_NONE,
16870 /*decl_specs=*/NULL,
16871 /*is_declarator=*/true,
16872 /*declares_class_or_enum=*/NULL,
16873 /*is_cv_qualifier=*/NULL);
16875 parser->num_template_parameter_lists
16876 = saved_num_template_parameter_lists;
16878 /* Leave the scope of the class. */
16880 pop_scope (pushed_scope);
16882 constructor_p = !cp_parser_error_occurred (parser);
16886 constructor_p = false;
16887 /* We did not really want to consume any tokens. */
16888 cp_parser_abort_tentative_parse (parser);
16890 return constructor_p;
16893 /* Parse the definition of the function given by the DECL_SPECIFIERS,
16894 ATTRIBUTES, and DECLARATOR. The access checks have been deferred;
16895 they must be performed once we are in the scope of the function.
16897 Returns the function defined. */
16900 cp_parser_function_definition_from_specifiers_and_declarator
16901 (cp_parser* parser,
16902 cp_decl_specifier_seq *decl_specifiers,
16904 const cp_declarator *declarator)
16909 /* Begin the function-definition. */
16910 success_p = start_function (decl_specifiers, declarator, attributes);
16912 /* The things we're about to see are not directly qualified by any
16913 template headers we've seen thus far. */
16914 reset_specialization ();
16916 /* If there were names looked up in the decl-specifier-seq that we
16917 did not check, check them now. We must wait until we are in the
16918 scope of the function to perform the checks, since the function
16919 might be a friend. */
16920 perform_deferred_access_checks ();
16924 /* Skip the entire function. */
16925 cp_parser_skip_to_end_of_block_or_statement (parser);
16926 fn = error_mark_node;
16928 else if (DECL_INITIAL (current_function_decl) != error_mark_node)
16930 /* Seen already, skip it. An error message has already been output. */
16931 cp_parser_skip_to_end_of_block_or_statement (parser);
16932 fn = current_function_decl;
16933 current_function_decl = NULL_TREE;
16934 /* If this is a function from a class, pop the nested class. */
16935 if (current_class_name)
16936 pop_nested_class ();
16939 fn = cp_parser_function_definition_after_declarator (parser,
16940 /*inline_p=*/false);
16945 /* Parse the part of a function-definition that follows the
16946 declarator. INLINE_P is TRUE iff this function is an inline
16947 function defined with a class-specifier.
16949 Returns the function defined. */
16952 cp_parser_function_definition_after_declarator (cp_parser* parser,
16956 bool ctor_initializer_p = false;
16957 bool saved_in_unbraced_linkage_specification_p;
16958 bool saved_in_function_body;
16959 unsigned saved_num_template_parameter_lists;
16961 saved_in_function_body = parser->in_function_body;
16962 parser->in_function_body = true;
16963 /* If the next token is `return', then the code may be trying to
16964 make use of the "named return value" extension that G++ used to
16966 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_RETURN))
16968 /* Consume the `return' keyword. */
16969 cp_lexer_consume_token (parser->lexer);
16970 /* Look for the identifier that indicates what value is to be
16972 cp_parser_identifier (parser);
16973 /* Issue an error message. */
16974 error ("named return values are no longer supported");
16975 /* Skip tokens until we reach the start of the function body. */
16978 cp_token *token = cp_lexer_peek_token (parser->lexer);
16979 if (token->type == CPP_OPEN_BRACE
16980 || token->type == CPP_EOF
16981 || token->type == CPP_PRAGMA_EOL)
16983 cp_lexer_consume_token (parser->lexer);
16986 /* The `extern' in `extern "C" void f () { ... }' does not apply to
16987 anything declared inside `f'. */
16988 saved_in_unbraced_linkage_specification_p
16989 = parser->in_unbraced_linkage_specification_p;
16990 parser->in_unbraced_linkage_specification_p = false;
16991 /* Inside the function, surrounding template-parameter-lists do not
16993 saved_num_template_parameter_lists
16994 = parser->num_template_parameter_lists;
16995 parser->num_template_parameter_lists = 0;
16996 /* If the next token is `try', then we are looking at a
16997 function-try-block. */
16998 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TRY))
16999 ctor_initializer_p = cp_parser_function_try_block (parser);
17000 /* A function-try-block includes the function-body, so we only do
17001 this next part if we're not processing a function-try-block. */
17004 = cp_parser_ctor_initializer_opt_and_function_body (parser);
17006 /* Finish the function. */
17007 fn = finish_function ((ctor_initializer_p ? 1 : 0) |
17008 (inline_p ? 2 : 0));
17009 /* Generate code for it, if necessary. */
17010 expand_or_defer_fn (fn);
17011 /* Restore the saved values. */
17012 parser->in_unbraced_linkage_specification_p
17013 = saved_in_unbraced_linkage_specification_p;
17014 parser->num_template_parameter_lists
17015 = saved_num_template_parameter_lists;
17016 parser->in_function_body = saved_in_function_body;
17021 /* Parse a template-declaration, assuming that the `export' (and
17022 `extern') keywords, if present, has already been scanned. MEMBER_P
17023 is as for cp_parser_template_declaration. */
17026 cp_parser_template_declaration_after_export (cp_parser* parser, bool member_p)
17028 tree decl = NULL_TREE;
17029 VEC (deferred_access_check,gc) *checks;
17030 tree parameter_list;
17031 bool friend_p = false;
17032 bool need_lang_pop;
17034 /* Look for the `template' keyword. */
17035 if (!cp_parser_require_keyword (parser, RID_TEMPLATE, "%<template%>"))
17039 if (!cp_parser_require (parser, CPP_LESS, "%<<%>"))
17041 if (at_class_scope_p () && current_function_decl)
17043 /* 14.5.2.2 [temp.mem]
17045 A local class shall not have member templates. */
17046 error ("invalid declaration of member template in local class");
17047 cp_parser_skip_to_end_of_block_or_statement (parser);
17052 A template ... shall not have C linkage. */
17053 if (current_lang_name == lang_name_c)
17055 error ("template with C linkage");
17056 /* Give it C++ linkage to avoid confusing other parts of the
17058 push_lang_context (lang_name_cplusplus);
17059 need_lang_pop = true;
17062 need_lang_pop = false;
17064 /* We cannot perform access checks on the template parameter
17065 declarations until we know what is being declared, just as we
17066 cannot check the decl-specifier list. */
17067 push_deferring_access_checks (dk_deferred);
17069 /* If the next token is `>', then we have an invalid
17070 specialization. Rather than complain about an invalid template
17071 parameter, issue an error message here. */
17072 if (cp_lexer_next_token_is (parser->lexer, CPP_GREATER))
17074 cp_parser_error (parser, "invalid explicit specialization");
17075 begin_specialization ();
17076 parameter_list = NULL_TREE;
17079 /* Parse the template parameters. */
17080 parameter_list = cp_parser_template_parameter_list (parser);
17082 /* Get the deferred access checks from the parameter list. These
17083 will be checked once we know what is being declared, as for a
17084 member template the checks must be performed in the scope of the
17085 class containing the member. */
17086 checks = get_deferred_access_checks ();
17088 /* Look for the `>'. */
17089 cp_parser_skip_to_end_of_template_parameter_list (parser);
17090 /* We just processed one more parameter list. */
17091 ++parser->num_template_parameter_lists;
17092 /* If the next token is `template', there are more template
17094 if (cp_lexer_next_token_is_keyword (parser->lexer,
17096 cp_parser_template_declaration_after_export (parser, member_p);
17099 /* There are no access checks when parsing a template, as we do not
17100 know if a specialization will be a friend. */
17101 push_deferring_access_checks (dk_no_check);
17102 decl = cp_parser_single_declaration (parser,
17105 /*explicit_specialization_p=*/false,
17107 pop_deferring_access_checks ();
17109 /* If this is a member template declaration, let the front
17111 if (member_p && !friend_p && decl)
17113 if (TREE_CODE (decl) == TYPE_DECL)
17114 cp_parser_check_access_in_redeclaration (decl);
17116 decl = finish_member_template_decl (decl);
17118 else if (friend_p && decl && TREE_CODE (decl) == TYPE_DECL)
17119 make_friend_class (current_class_type, TREE_TYPE (decl),
17120 /*complain=*/true);
17122 /* We are done with the current parameter list. */
17123 --parser->num_template_parameter_lists;
17125 pop_deferring_access_checks ();
17128 finish_template_decl (parameter_list);
17130 /* Register member declarations. */
17131 if (member_p && !friend_p && decl && !DECL_CLASS_TEMPLATE_P (decl))
17132 finish_member_declaration (decl);
17133 /* For the erroneous case of a template with C linkage, we pushed an
17134 implicit C++ linkage scope; exit that scope now. */
17136 pop_lang_context ();
17137 /* If DECL is a function template, we must return to parse it later.
17138 (Even though there is no definition, there might be default
17139 arguments that need handling.) */
17140 if (member_p && decl
17141 && (TREE_CODE (decl) == FUNCTION_DECL
17142 || DECL_FUNCTION_TEMPLATE_P (decl)))
17143 TREE_VALUE (parser->unparsed_functions_queues)
17144 = tree_cons (NULL_TREE, decl,
17145 TREE_VALUE (parser->unparsed_functions_queues));
17148 /* Perform the deferred access checks from a template-parameter-list.
17149 CHECKS is a TREE_LIST of access checks, as returned by
17150 get_deferred_access_checks. */
17153 cp_parser_perform_template_parameter_access_checks (VEC (deferred_access_check,gc)* checks)
17155 ++processing_template_parmlist;
17156 perform_access_checks (checks);
17157 --processing_template_parmlist;
17160 /* Parse a `decl-specifier-seq [opt] init-declarator [opt] ;' or
17161 `function-definition' sequence. MEMBER_P is true, this declaration
17162 appears in a class scope.
17164 Returns the DECL for the declared entity. If FRIEND_P is non-NULL,
17165 *FRIEND_P is set to TRUE iff the declaration is a friend. */
17168 cp_parser_single_declaration (cp_parser* parser,
17169 VEC (deferred_access_check,gc)* checks,
17171 bool explicit_specialization_p,
17174 int declares_class_or_enum;
17175 tree decl = NULL_TREE;
17176 cp_decl_specifier_seq decl_specifiers;
17177 bool function_definition_p = false;
17179 /* This function is only used when processing a template
17181 gcc_assert (innermost_scope_kind () == sk_template_parms
17182 || innermost_scope_kind () == sk_template_spec);
17184 /* Defer access checks until we know what is being declared. */
17185 push_deferring_access_checks (dk_deferred);
17187 /* Try the `decl-specifier-seq [opt] init-declarator [opt]'
17189 cp_parser_decl_specifier_seq (parser,
17190 CP_PARSER_FLAGS_OPTIONAL,
17192 &declares_class_or_enum);
17194 *friend_p = cp_parser_friend_p (&decl_specifiers);
17196 /* There are no template typedefs. */
17197 if (decl_specifiers.specs[(int) ds_typedef])
17199 error ("template declaration of %qs", "typedef");
17200 decl = error_mark_node;
17203 /* Gather up the access checks that occurred the
17204 decl-specifier-seq. */
17205 stop_deferring_access_checks ();
17207 /* Check for the declaration of a template class. */
17208 if (declares_class_or_enum)
17210 if (cp_parser_declares_only_class_p (parser))
17212 decl = shadow_tag (&decl_specifiers);
17217 friend template <typename T> struct A<T>::B;
17220 A<T>::B will be represented by a TYPENAME_TYPE, and
17221 therefore not recognized by shadow_tag. */
17222 if (friend_p && *friend_p
17224 && decl_specifiers.type
17225 && TYPE_P (decl_specifiers.type))
17226 decl = decl_specifiers.type;
17228 if (decl && decl != error_mark_node)
17229 decl = TYPE_NAME (decl);
17231 decl = error_mark_node;
17233 /* Perform access checks for template parameters. */
17234 cp_parser_perform_template_parameter_access_checks (checks);
17237 /* If it's not a template class, try for a template function. If
17238 the next token is a `;', then this declaration does not declare
17239 anything. But, if there were errors in the decl-specifiers, then
17240 the error might well have come from an attempted class-specifier.
17241 In that case, there's no need to warn about a missing declarator. */
17243 && (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON)
17244 || decl_specifiers.type != error_mark_node))
17246 decl = cp_parser_init_declarator (parser,
17249 /*function_definition_allowed_p=*/true,
17251 declares_class_or_enum,
17252 &function_definition_p);
17254 /* 7.1.1-1 [dcl.stc]
17256 A storage-class-specifier shall not be specified in an explicit
17257 specialization... */
17259 && explicit_specialization_p
17260 && decl_specifiers.storage_class != sc_none)
17262 error ("explicit template specialization cannot have a storage class");
17263 decl = error_mark_node;
17267 pop_deferring_access_checks ();
17269 /* Clear any current qualification; whatever comes next is the start
17270 of something new. */
17271 parser->scope = NULL_TREE;
17272 parser->qualifying_scope = NULL_TREE;
17273 parser->object_scope = NULL_TREE;
17274 /* Look for a trailing `;' after the declaration. */
17275 if (!function_definition_p
17276 && (decl == error_mark_node
17277 || !cp_parser_require (parser, CPP_SEMICOLON, "%<;%>")))
17278 cp_parser_skip_to_end_of_block_or_statement (parser);
17283 /* Parse a cast-expression that is not the operand of a unary "&". */
17286 cp_parser_simple_cast_expression (cp_parser *parser)
17288 return cp_parser_cast_expression (parser, /*address_p=*/false,
17292 /* Parse a functional cast to TYPE. Returns an expression
17293 representing the cast. */
17296 cp_parser_functional_cast (cp_parser* parser, tree type)
17298 tree expression_list;
17302 = cp_parser_parenthesized_expression_list (parser, false,
17304 /*allow_expansion_p=*/true,
17305 /*non_constant_p=*/NULL);
17307 cast = build_functional_cast (type, expression_list,
17308 tf_warning_or_error);
17309 /* [expr.const]/1: In an integral constant expression "only type
17310 conversions to integral or enumeration type can be used". */
17311 if (TREE_CODE (type) == TYPE_DECL)
17312 type = TREE_TYPE (type);
17313 if (cast != error_mark_node
17314 && !cast_valid_in_integral_constant_expression_p (type)
17315 && (cp_parser_non_integral_constant_expression
17316 (parser, "a call to a constructor")))
17317 return error_mark_node;
17321 /* Save the tokens that make up the body of a member function defined
17322 in a class-specifier. The DECL_SPECIFIERS and DECLARATOR have
17323 already been parsed. The ATTRIBUTES are any GNU "__attribute__"
17324 specifiers applied to the declaration. Returns the FUNCTION_DECL
17325 for the member function. */
17328 cp_parser_save_member_function_body (cp_parser* parser,
17329 cp_decl_specifier_seq *decl_specifiers,
17330 cp_declarator *declarator,
17337 /* Create the function-declaration. */
17338 fn = start_method (decl_specifiers, declarator, attributes);
17339 /* If something went badly wrong, bail out now. */
17340 if (fn == error_mark_node)
17342 /* If there's a function-body, skip it. */
17343 if (cp_parser_token_starts_function_definition_p
17344 (cp_lexer_peek_token (parser->lexer)))
17345 cp_parser_skip_to_end_of_block_or_statement (parser);
17346 return error_mark_node;
17349 /* Remember it, if there default args to post process. */
17350 cp_parser_save_default_args (parser, fn);
17352 /* Save away the tokens that make up the body of the
17354 first = parser->lexer->next_token;
17355 cp_parser_cache_group (parser, CPP_CLOSE_BRACE, /*depth=*/0);
17356 /* Handle function try blocks. */
17357 while (cp_lexer_next_token_is_keyword (parser->lexer, RID_CATCH))
17358 cp_parser_cache_group (parser, CPP_CLOSE_BRACE, /*depth=*/0);
17359 last = parser->lexer->next_token;
17361 /* Save away the inline definition; we will process it when the
17362 class is complete. */
17363 DECL_PENDING_INLINE_INFO (fn) = cp_token_cache_new (first, last);
17364 DECL_PENDING_INLINE_P (fn) = 1;
17366 /* We need to know that this was defined in the class, so that
17367 friend templates are handled correctly. */
17368 DECL_INITIALIZED_IN_CLASS_P (fn) = 1;
17370 /* We're done with the inline definition. */
17371 finish_method (fn);
17373 /* Add FN to the queue of functions to be parsed later. */
17374 TREE_VALUE (parser->unparsed_functions_queues)
17375 = tree_cons (NULL_TREE, fn,
17376 TREE_VALUE (parser->unparsed_functions_queues));
17381 /* Parse a template-argument-list, as well as the trailing ">" (but
17382 not the opening ">"). See cp_parser_template_argument_list for the
17386 cp_parser_enclosed_template_argument_list (cp_parser* parser)
17390 tree saved_qualifying_scope;
17391 tree saved_object_scope;
17392 bool saved_greater_than_is_operator_p;
17393 bool saved_skip_evaluation;
17397 When parsing a template-id, the first non-nested `>' is taken as
17398 the end of the template-argument-list rather than a greater-than
17400 saved_greater_than_is_operator_p
17401 = parser->greater_than_is_operator_p;
17402 parser->greater_than_is_operator_p = false;
17403 /* Parsing the argument list may modify SCOPE, so we save it
17405 saved_scope = parser->scope;
17406 saved_qualifying_scope = parser->qualifying_scope;
17407 saved_object_scope = parser->object_scope;
17408 /* We need to evaluate the template arguments, even though this
17409 template-id may be nested within a "sizeof". */
17410 saved_skip_evaluation = skip_evaluation;
17411 skip_evaluation = false;
17412 /* Parse the template-argument-list itself. */
17413 if (cp_lexer_next_token_is (parser->lexer, CPP_GREATER)
17414 || cp_lexer_next_token_is (parser->lexer, CPP_RSHIFT))
17415 arguments = NULL_TREE;
17417 arguments = cp_parser_template_argument_list (parser);
17418 /* Look for the `>' that ends the template-argument-list. If we find
17419 a '>>' instead, it's probably just a typo. */
17420 if (cp_lexer_next_token_is (parser->lexer, CPP_RSHIFT))
17422 if (cxx_dialect != cxx98)
17424 /* In C++0x, a `>>' in a template argument list or cast
17425 expression is considered to be two separate `>'
17426 tokens. So, change the current token to a `>', but don't
17427 consume it: it will be consumed later when the outer
17428 template argument list (or cast expression) is parsed.
17429 Note that this replacement of `>' for `>>' is necessary
17430 even if we are parsing tentatively: in the tentative
17431 case, after calling
17432 cp_parser_enclosed_template_argument_list we will always
17433 throw away all of the template arguments and the first
17434 closing `>', either because the template argument list
17435 was erroneous or because we are replacing those tokens
17436 with a CPP_TEMPLATE_ID token. The second `>' (which will
17437 not have been thrown away) is needed either to close an
17438 outer template argument list or to complete a new-style
17440 cp_token *token = cp_lexer_peek_token (parser->lexer);
17441 token->type = CPP_GREATER;
17443 else if (!saved_greater_than_is_operator_p)
17445 /* If we're in a nested template argument list, the '>>' has
17446 to be a typo for '> >'. We emit the error message, but we
17447 continue parsing and we push a '>' as next token, so that
17448 the argument list will be parsed correctly. Note that the
17449 global source location is still on the token before the
17450 '>>', so we need to say explicitly where we want it. */
17451 cp_token *token = cp_lexer_peek_token (parser->lexer);
17452 error ("%H%<>>%> should be %<> >%> "
17453 "within a nested template argument list",
17456 token->type = CPP_GREATER;
17460 /* If this is not a nested template argument list, the '>>'
17461 is a typo for '>'. Emit an error message and continue.
17462 Same deal about the token location, but here we can get it
17463 right by consuming the '>>' before issuing the diagnostic. */
17464 cp_lexer_consume_token (parser->lexer);
17465 error ("spurious %<>>%>, use %<>%> to terminate "
17466 "a template argument list");
17470 cp_parser_skip_to_end_of_template_parameter_list (parser);
17471 /* The `>' token might be a greater-than operator again now. */
17472 parser->greater_than_is_operator_p
17473 = saved_greater_than_is_operator_p;
17474 /* Restore the SAVED_SCOPE. */
17475 parser->scope = saved_scope;
17476 parser->qualifying_scope = saved_qualifying_scope;
17477 parser->object_scope = saved_object_scope;
17478 skip_evaluation = saved_skip_evaluation;
17483 /* MEMBER_FUNCTION is a member function, or a friend. If default
17484 arguments, or the body of the function have not yet been parsed,
17488 cp_parser_late_parsing_for_member (cp_parser* parser, tree member_function)
17490 /* If this member is a template, get the underlying
17492 if (DECL_FUNCTION_TEMPLATE_P (member_function))
17493 member_function = DECL_TEMPLATE_RESULT (member_function);
17495 /* There should not be any class definitions in progress at this
17496 point; the bodies of members are only parsed outside of all class
17498 gcc_assert (parser->num_classes_being_defined == 0);
17499 /* While we're parsing the member functions we might encounter more
17500 classes. We want to handle them right away, but we don't want
17501 them getting mixed up with functions that are currently in the
17503 parser->unparsed_functions_queues
17504 = tree_cons (NULL_TREE, NULL_TREE, parser->unparsed_functions_queues);
17506 /* Make sure that any template parameters are in scope. */
17507 maybe_begin_member_template_processing (member_function);
17509 /* If the body of the function has not yet been parsed, parse it
17511 if (DECL_PENDING_INLINE_P (member_function))
17513 tree function_scope;
17514 cp_token_cache *tokens;
17516 /* The function is no longer pending; we are processing it. */
17517 tokens = DECL_PENDING_INLINE_INFO (member_function);
17518 DECL_PENDING_INLINE_INFO (member_function) = NULL;
17519 DECL_PENDING_INLINE_P (member_function) = 0;
17521 /* If this is a local class, enter the scope of the containing
17523 function_scope = current_function_decl;
17524 if (function_scope)
17525 push_function_context ();
17527 /* Push the body of the function onto the lexer stack. */
17528 cp_parser_push_lexer_for_tokens (parser, tokens);
17530 /* Let the front end know that we going to be defining this
17532 start_preparsed_function (member_function, NULL_TREE,
17533 SF_PRE_PARSED | SF_INCLASS_INLINE);
17535 /* Don't do access checking if it is a templated function. */
17536 if (processing_template_decl)
17537 push_deferring_access_checks (dk_no_check);
17539 /* Now, parse the body of the function. */
17540 cp_parser_function_definition_after_declarator (parser,
17541 /*inline_p=*/true);
17543 if (processing_template_decl)
17544 pop_deferring_access_checks ();
17546 /* Leave the scope of the containing function. */
17547 if (function_scope)
17548 pop_function_context ();
17549 cp_parser_pop_lexer (parser);
17552 /* Remove any template parameters from the symbol table. */
17553 maybe_end_member_template_processing ();
17555 /* Restore the queue. */
17556 parser->unparsed_functions_queues
17557 = TREE_CHAIN (parser->unparsed_functions_queues);
17560 /* If DECL contains any default args, remember it on the unparsed
17561 functions queue. */
17564 cp_parser_save_default_args (cp_parser* parser, tree decl)
17568 for (probe = TYPE_ARG_TYPES (TREE_TYPE (decl));
17570 probe = TREE_CHAIN (probe))
17571 if (TREE_PURPOSE (probe))
17573 TREE_PURPOSE (parser->unparsed_functions_queues)
17574 = tree_cons (current_class_type, decl,
17575 TREE_PURPOSE (parser->unparsed_functions_queues));
17580 /* FN is a FUNCTION_DECL which may contains a parameter with an
17581 unparsed DEFAULT_ARG. Parse the default args now. This function
17582 assumes that the current scope is the scope in which the default
17583 argument should be processed. */
17586 cp_parser_late_parsing_default_args (cp_parser *parser, tree fn)
17588 bool saved_local_variables_forbidden_p;
17591 /* While we're parsing the default args, we might (due to the
17592 statement expression extension) encounter more classes. We want
17593 to handle them right away, but we don't want them getting mixed
17594 up with default args that are currently in the queue. */
17595 parser->unparsed_functions_queues
17596 = tree_cons (NULL_TREE, NULL_TREE, parser->unparsed_functions_queues);
17598 /* Local variable names (and the `this' keyword) may not appear
17599 in a default argument. */
17600 saved_local_variables_forbidden_p = parser->local_variables_forbidden_p;
17601 parser->local_variables_forbidden_p = true;
17603 for (parm = TYPE_ARG_TYPES (TREE_TYPE (fn));
17605 parm = TREE_CHAIN (parm))
17607 cp_token_cache *tokens;
17608 tree default_arg = TREE_PURPOSE (parm);
17610 VEC(tree,gc) *insts;
17617 if (TREE_CODE (default_arg) != DEFAULT_ARG)
17618 /* This can happen for a friend declaration for a function
17619 already declared with default arguments. */
17622 /* Push the saved tokens for the default argument onto the parser's
17624 tokens = DEFARG_TOKENS (default_arg);
17625 cp_parser_push_lexer_for_tokens (parser, tokens);
17627 /* Parse the assignment-expression. */
17628 parsed_arg = cp_parser_assignment_expression (parser, /*cast_p=*/false);
17630 if (!processing_template_decl)
17631 parsed_arg = check_default_argument (TREE_VALUE (parm), parsed_arg);
17633 TREE_PURPOSE (parm) = parsed_arg;
17635 /* Update any instantiations we've already created. */
17636 for (insts = DEFARG_INSTANTIATIONS (default_arg), ix = 0;
17637 VEC_iterate (tree, insts, ix, copy); ix++)
17638 TREE_PURPOSE (copy) = parsed_arg;
17640 /* If the token stream has not been completely used up, then
17641 there was extra junk after the end of the default
17643 if (!cp_lexer_next_token_is (parser->lexer, CPP_EOF))
17644 cp_parser_error (parser, "expected %<,%>");
17646 /* Revert to the main lexer. */
17647 cp_parser_pop_lexer (parser);
17650 /* Make sure no default arg is missing. */
17651 check_default_args (fn);
17653 /* Restore the state of local_variables_forbidden_p. */
17654 parser->local_variables_forbidden_p = saved_local_variables_forbidden_p;
17656 /* Restore the queue. */
17657 parser->unparsed_functions_queues
17658 = TREE_CHAIN (parser->unparsed_functions_queues);
17661 /* Parse the operand of `sizeof' (or a similar operator). Returns
17662 either a TYPE or an expression, depending on the form of the
17663 input. The KEYWORD indicates which kind of expression we have
17667 cp_parser_sizeof_operand (cp_parser* parser, enum rid keyword)
17669 tree expr = NULL_TREE;
17670 const char *saved_message;
17672 bool saved_integral_constant_expression_p;
17673 bool saved_non_integral_constant_expression_p;
17674 bool pack_expansion_p = false;
17676 /* Types cannot be defined in a `sizeof' expression. Save away the
17678 saved_message = parser->type_definition_forbidden_message;
17679 /* And create the new one. */
17680 tmp = concat ("types may not be defined in %<",
17681 IDENTIFIER_POINTER (ridpointers[keyword]),
17682 "%> expressions", NULL);
17683 parser->type_definition_forbidden_message = tmp;
17685 /* The restrictions on constant-expressions do not apply inside
17686 sizeof expressions. */
17687 saved_integral_constant_expression_p
17688 = parser->integral_constant_expression_p;
17689 saved_non_integral_constant_expression_p
17690 = parser->non_integral_constant_expression_p;
17691 parser->integral_constant_expression_p = false;
17693 /* If it's a `...', then we are computing the length of a parameter
17695 if (keyword == RID_SIZEOF
17696 && cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
17698 /* Consume the `...'. */
17699 cp_lexer_consume_token (parser->lexer);
17700 maybe_warn_variadic_templates ();
17702 /* Note that this is an expansion. */
17703 pack_expansion_p = true;
17706 /* Do not actually evaluate the expression. */
17708 /* If it's a `(', then we might be looking at the type-id
17710 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
17713 bool saved_in_type_id_in_expr_p;
17715 /* We can't be sure yet whether we're looking at a type-id or an
17717 cp_parser_parse_tentatively (parser);
17718 /* Consume the `('. */
17719 cp_lexer_consume_token (parser->lexer);
17720 /* Parse the type-id. */
17721 saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p;
17722 parser->in_type_id_in_expr_p = true;
17723 type = cp_parser_type_id (parser);
17724 parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
17725 /* Now, look for the trailing `)'. */
17726 cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>");
17727 /* If all went well, then we're done. */
17728 if (cp_parser_parse_definitely (parser))
17730 cp_decl_specifier_seq decl_specs;
17732 /* Build a trivial decl-specifier-seq. */
17733 clear_decl_specs (&decl_specs);
17734 decl_specs.type = type;
17736 /* Call grokdeclarator to figure out what type this is. */
17737 expr = grokdeclarator (NULL,
17741 /*attrlist=*/NULL);
17745 /* If the type-id production did not work out, then we must be
17746 looking at the unary-expression production. */
17748 expr = cp_parser_unary_expression (parser, /*address_p=*/false,
17751 if (pack_expansion_p)
17752 /* Build a pack expansion. */
17753 expr = make_pack_expansion (expr);
17755 /* Go back to evaluating expressions. */
17758 /* Free the message we created. */
17760 /* And restore the old one. */
17761 parser->type_definition_forbidden_message = saved_message;
17762 parser->integral_constant_expression_p
17763 = saved_integral_constant_expression_p;
17764 parser->non_integral_constant_expression_p
17765 = saved_non_integral_constant_expression_p;
17770 /* If the current declaration has no declarator, return true. */
17773 cp_parser_declares_only_class_p (cp_parser *parser)
17775 /* If the next token is a `;' or a `,' then there is no
17777 return (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)
17778 || cp_lexer_next_token_is (parser->lexer, CPP_COMMA));
17781 /* Update the DECL_SPECS to reflect the storage class indicated by
17785 cp_parser_set_storage_class (cp_parser *parser,
17786 cp_decl_specifier_seq *decl_specs,
17789 cp_storage_class storage_class;
17791 if (parser->in_unbraced_linkage_specification_p)
17793 error ("invalid use of %qD in linkage specification",
17794 ridpointers[keyword]);
17797 else if (decl_specs->storage_class != sc_none)
17799 decl_specs->conflicting_specifiers_p = true;
17803 if ((keyword == RID_EXTERN || keyword == RID_STATIC)
17804 && decl_specs->specs[(int) ds_thread])
17806 error ("%<__thread%> before %qD", ridpointers[keyword]);
17807 decl_specs->specs[(int) ds_thread] = 0;
17813 storage_class = sc_auto;
17816 storage_class = sc_register;
17819 storage_class = sc_static;
17822 storage_class = sc_extern;
17825 storage_class = sc_mutable;
17828 gcc_unreachable ();
17830 decl_specs->storage_class = storage_class;
17832 /* A storage class specifier cannot be applied alongside a typedef
17833 specifier. If there is a typedef specifier present then set
17834 conflicting_specifiers_p which will trigger an error later
17835 on in grokdeclarator. */
17836 if (decl_specs->specs[(int)ds_typedef])
17837 decl_specs->conflicting_specifiers_p = true;
17840 /* Update the DECL_SPECS to reflect the TYPE_SPEC. If USER_DEFINED_P
17841 is true, the type is a user-defined type; otherwise it is a
17842 built-in type specified by a keyword. */
17845 cp_parser_set_decl_spec_type (cp_decl_specifier_seq *decl_specs,
17847 bool user_defined_p)
17849 decl_specs->any_specifiers_p = true;
17851 /* If the user tries to redeclare bool, char16_t, char32_t, or wchar_t
17852 (with, for example, in "typedef int wchar_t;") we remember that
17853 this is what happened. In system headers, we ignore these
17854 declarations so that G++ can work with system headers that are not
17856 if (decl_specs->specs[(int) ds_typedef]
17858 && (type_spec == boolean_type_node
17859 || type_spec == char16_type_node
17860 || type_spec == char32_type_node
17861 || type_spec == wchar_type_node)
17862 && (decl_specs->type
17863 || decl_specs->specs[(int) ds_long]
17864 || decl_specs->specs[(int) ds_short]
17865 || decl_specs->specs[(int) ds_unsigned]
17866 || decl_specs->specs[(int) ds_signed]))
17868 decl_specs->redefined_builtin_type = type_spec;
17869 if (!decl_specs->type)
17871 decl_specs->type = type_spec;
17872 decl_specs->user_defined_type_p = false;
17875 else if (decl_specs->type)
17876 decl_specs->multiple_types_p = true;
17879 decl_specs->type = type_spec;
17880 decl_specs->user_defined_type_p = user_defined_p;
17881 decl_specs->redefined_builtin_type = NULL_TREE;
17885 /* DECL_SPECIFIERS is the representation of a decl-specifier-seq.
17886 Returns TRUE iff `friend' appears among the DECL_SPECIFIERS. */
17889 cp_parser_friend_p (const cp_decl_specifier_seq *decl_specifiers)
17891 return decl_specifiers->specs[(int) ds_friend] != 0;
17894 /* If the next token is of the indicated TYPE, consume it. Otherwise,
17895 issue an error message indicating that TOKEN_DESC was expected.
17897 Returns the token consumed, if the token had the appropriate type.
17898 Otherwise, returns NULL. */
17901 cp_parser_require (cp_parser* parser,
17902 enum cpp_ttype type,
17903 const char* token_desc)
17905 if (cp_lexer_next_token_is (parser->lexer, type))
17906 return cp_lexer_consume_token (parser->lexer);
17909 /* Output the MESSAGE -- unless we're parsing tentatively. */
17910 if (!cp_parser_simulate_error (parser))
17912 char *message = concat ("expected ", token_desc, NULL);
17913 cp_parser_error (parser, message);
17920 /* An error message is produced if the next token is not '>'.
17921 All further tokens are skipped until the desired token is
17922 found or '{', '}', ';' or an unbalanced ')' or ']'. */
17925 cp_parser_skip_to_end_of_template_parameter_list (cp_parser* parser)
17927 /* Current level of '< ... >'. */
17928 unsigned level = 0;
17929 /* Ignore '<' and '>' nested inside '( ... )' or '[ ... ]'. */
17930 unsigned nesting_depth = 0;
17932 /* Are we ready, yet? If not, issue error message. */
17933 if (cp_parser_require (parser, CPP_GREATER, "%<>%>"))
17936 /* Skip tokens until the desired token is found. */
17939 /* Peek at the next token. */
17940 switch (cp_lexer_peek_token (parser->lexer)->type)
17943 if (!nesting_depth)
17948 if (cxx_dialect == cxx98)
17949 /* C++0x views the `>>' operator as two `>' tokens, but
17952 else if (!nesting_depth && level-- == 0)
17954 /* We've hit a `>>' where the first `>' closes the
17955 template argument list, and the second `>' is
17956 spurious. Just consume the `>>' and stop; we've
17957 already produced at least one error. */
17958 cp_lexer_consume_token (parser->lexer);
17961 /* Fall through for C++0x, so we handle the second `>' in
17965 if (!nesting_depth && level-- == 0)
17967 /* We've reached the token we want, consume it and stop. */
17968 cp_lexer_consume_token (parser->lexer);
17973 case CPP_OPEN_PAREN:
17974 case CPP_OPEN_SQUARE:
17978 case CPP_CLOSE_PAREN:
17979 case CPP_CLOSE_SQUARE:
17980 if (nesting_depth-- == 0)
17985 case CPP_PRAGMA_EOL:
17986 case CPP_SEMICOLON:
17987 case CPP_OPEN_BRACE:
17988 case CPP_CLOSE_BRACE:
17989 /* The '>' was probably forgotten, don't look further. */
17996 /* Consume this token. */
17997 cp_lexer_consume_token (parser->lexer);
18001 /* If the next token is the indicated keyword, consume it. Otherwise,
18002 issue an error message indicating that TOKEN_DESC was expected.
18004 Returns the token consumed, if the token had the appropriate type.
18005 Otherwise, returns NULL. */
18008 cp_parser_require_keyword (cp_parser* parser,
18010 const char* token_desc)
18012 cp_token *token = cp_parser_require (parser, CPP_KEYWORD, token_desc);
18014 if (token && token->keyword != keyword)
18016 dyn_string_t error_msg;
18018 /* Format the error message. */
18019 error_msg = dyn_string_new (0);
18020 dyn_string_append_cstr (error_msg, "expected ");
18021 dyn_string_append_cstr (error_msg, token_desc);
18022 cp_parser_error (parser, error_msg->s);
18023 dyn_string_delete (error_msg);
18030 /* Returns TRUE iff TOKEN is a token that can begin the body of a
18031 function-definition. */
18034 cp_parser_token_starts_function_definition_p (cp_token* token)
18036 return (/* An ordinary function-body begins with an `{'. */
18037 token->type == CPP_OPEN_BRACE
18038 /* A ctor-initializer begins with a `:'. */
18039 || token->type == CPP_COLON
18040 /* A function-try-block begins with `try'. */
18041 || token->keyword == RID_TRY
18042 /* The named return value extension begins with `return'. */
18043 || token->keyword == RID_RETURN);
18046 /* Returns TRUE iff the next token is the ":" or "{" beginning a class
18050 cp_parser_next_token_starts_class_definition_p (cp_parser *parser)
18054 token = cp_lexer_peek_token (parser->lexer);
18055 return (token->type == CPP_OPEN_BRACE || token->type == CPP_COLON);
18058 /* Returns TRUE iff the next token is the "," or ">" (or `>>', in
18059 C++0x) ending a template-argument. */
18062 cp_parser_next_token_ends_template_argument_p (cp_parser *parser)
18066 token = cp_lexer_peek_token (parser->lexer);
18067 return (token->type == CPP_COMMA
18068 || token->type == CPP_GREATER
18069 || token->type == CPP_ELLIPSIS
18070 || ((cxx_dialect != cxx98) && token->type == CPP_RSHIFT));
18073 /* Returns TRUE iff the n-th token is a "<", or the n-th is a "[" and the
18074 (n+1)-th is a ":" (which is a possible digraph typo for "< ::"). */
18077 cp_parser_nth_token_starts_template_argument_list_p (cp_parser * parser,
18082 token = cp_lexer_peek_nth_token (parser->lexer, n);
18083 if (token->type == CPP_LESS)
18085 /* Check for the sequence `<::' in the original code. It would be lexed as
18086 `[:', where `[' is a digraph, and there is no whitespace before
18088 if (token->type == CPP_OPEN_SQUARE && token->flags & DIGRAPH)
18091 token2 = cp_lexer_peek_nth_token (parser->lexer, n+1);
18092 if (token2->type == CPP_COLON && !(token2->flags & PREV_WHITE))
18098 /* Returns the kind of tag indicated by TOKEN, if it is a class-key,
18099 or none_type otherwise. */
18101 static enum tag_types
18102 cp_parser_token_is_class_key (cp_token* token)
18104 switch (token->keyword)
18109 return record_type;
18118 /* Issue an error message if the CLASS_KEY does not match the TYPE. */
18121 cp_parser_check_class_key (enum tag_types class_key, tree type)
18123 if ((TREE_CODE (type) == UNION_TYPE) != (class_key == union_type))
18124 pedwarn ("%qs tag used in naming %q#T",
18125 class_key == union_type ? "union"
18126 : class_key == record_type ? "struct" : "class",
18130 /* Issue an error message if DECL is redeclared with different
18131 access than its original declaration [class.access.spec/3].
18132 This applies to nested classes and nested class templates.
18136 cp_parser_check_access_in_redeclaration (tree decl)
18138 if (!decl || !CLASS_TYPE_P (TREE_TYPE (decl)))
18141 if ((TREE_PRIVATE (decl)
18142 != (current_access_specifier == access_private_node))
18143 || (TREE_PROTECTED (decl)
18144 != (current_access_specifier == access_protected_node)))
18145 error ("%qD redeclared with different access", decl);
18148 /* Look for the `template' keyword, as a syntactic disambiguator.
18149 Return TRUE iff it is present, in which case it will be
18153 cp_parser_optional_template_keyword (cp_parser *parser)
18155 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
18157 /* The `template' keyword can only be used within templates;
18158 outside templates the parser can always figure out what is a
18159 template and what is not. */
18160 if (!processing_template_decl)
18162 error ("%<template%> (as a disambiguator) is only allowed "
18163 "within templates");
18164 /* If this part of the token stream is rescanned, the same
18165 error message would be generated. So, we purge the token
18166 from the stream. */
18167 cp_lexer_purge_token (parser->lexer);
18172 /* Consume the `template' keyword. */
18173 cp_lexer_consume_token (parser->lexer);
18181 /* The next token is a CPP_NESTED_NAME_SPECIFIER. Consume the token,
18182 set PARSER->SCOPE, and perform other related actions. */
18185 cp_parser_pre_parsed_nested_name_specifier (cp_parser *parser)
18188 struct tree_check *check_value;
18189 deferred_access_check *chk;
18190 VEC (deferred_access_check,gc) *checks;
18192 /* Get the stored value. */
18193 check_value = cp_lexer_consume_token (parser->lexer)->u.tree_check_value;
18194 /* Perform any access checks that were deferred. */
18195 checks = check_value->checks;
18199 VEC_iterate (deferred_access_check, checks, i, chk) ;
18202 perform_or_defer_access_check (chk->binfo,
18207 /* Set the scope from the stored value. */
18208 parser->scope = check_value->value;
18209 parser->qualifying_scope = check_value->qualifying_scope;
18210 parser->object_scope = NULL_TREE;
18213 /* Consume tokens up through a non-nested END token. */
18216 cp_parser_cache_group (cp_parser *parser,
18217 enum cpp_ttype end,
18224 /* Abort a parenthesized expression if we encounter a brace. */
18225 if ((end == CPP_CLOSE_PAREN || depth == 0)
18226 && cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
18228 /* If we've reached the end of the file, stop. */
18229 if (cp_lexer_next_token_is (parser->lexer, CPP_EOF)
18230 || (end != CPP_PRAGMA_EOL
18231 && cp_lexer_next_token_is (parser->lexer, CPP_PRAGMA_EOL)))
18233 /* Consume the next token. */
18234 token = cp_lexer_consume_token (parser->lexer);
18235 /* See if it starts a new group. */
18236 if (token->type == CPP_OPEN_BRACE)
18238 cp_parser_cache_group (parser, CPP_CLOSE_BRACE, depth + 1);
18242 else if (token->type == CPP_OPEN_PAREN)
18243 cp_parser_cache_group (parser, CPP_CLOSE_PAREN, depth + 1);
18244 else if (token->type == CPP_PRAGMA)
18245 cp_parser_cache_group (parser, CPP_PRAGMA_EOL, depth + 1);
18246 else if (token->type == end)
18251 /* Begin parsing tentatively. We always save tokens while parsing
18252 tentatively so that if the tentative parsing fails we can restore the
18256 cp_parser_parse_tentatively (cp_parser* parser)
18258 /* Enter a new parsing context. */
18259 parser->context = cp_parser_context_new (parser->context);
18260 /* Begin saving tokens. */
18261 cp_lexer_save_tokens (parser->lexer);
18262 /* In order to avoid repetitive access control error messages,
18263 access checks are queued up until we are no longer parsing
18265 push_deferring_access_checks (dk_deferred);
18268 /* Commit to the currently active tentative parse. */
18271 cp_parser_commit_to_tentative_parse (cp_parser* parser)
18273 cp_parser_context *context;
18276 /* Mark all of the levels as committed. */
18277 lexer = parser->lexer;
18278 for (context = parser->context; context->next; context = context->next)
18280 if (context->status == CP_PARSER_STATUS_KIND_COMMITTED)
18282 context->status = CP_PARSER_STATUS_KIND_COMMITTED;
18283 while (!cp_lexer_saving_tokens (lexer))
18284 lexer = lexer->next;
18285 cp_lexer_commit_tokens (lexer);
18289 /* Abort the currently active tentative parse. All consumed tokens
18290 will be rolled back, and no diagnostics will be issued. */
18293 cp_parser_abort_tentative_parse (cp_parser* parser)
18295 cp_parser_simulate_error (parser);
18296 /* Now, pretend that we want to see if the construct was
18297 successfully parsed. */
18298 cp_parser_parse_definitely (parser);
18301 /* Stop parsing tentatively. If a parse error has occurred, restore the
18302 token stream. Otherwise, commit to the tokens we have consumed.
18303 Returns true if no error occurred; false otherwise. */
18306 cp_parser_parse_definitely (cp_parser* parser)
18308 bool error_occurred;
18309 cp_parser_context *context;
18311 /* Remember whether or not an error occurred, since we are about to
18312 destroy that information. */
18313 error_occurred = cp_parser_error_occurred (parser);
18314 /* Remove the topmost context from the stack. */
18315 context = parser->context;
18316 parser->context = context->next;
18317 /* If no parse errors occurred, commit to the tentative parse. */
18318 if (!error_occurred)
18320 /* Commit to the tokens read tentatively, unless that was
18322 if (context->status != CP_PARSER_STATUS_KIND_COMMITTED)
18323 cp_lexer_commit_tokens (parser->lexer);
18325 pop_to_parent_deferring_access_checks ();
18327 /* Otherwise, if errors occurred, roll back our state so that things
18328 are just as they were before we began the tentative parse. */
18331 cp_lexer_rollback_tokens (parser->lexer);
18332 pop_deferring_access_checks ();
18334 /* Add the context to the front of the free list. */
18335 context->next = cp_parser_context_free_list;
18336 cp_parser_context_free_list = context;
18338 return !error_occurred;
18341 /* Returns true if we are parsing tentatively and are not committed to
18342 this tentative parse. */
18345 cp_parser_uncommitted_to_tentative_parse_p (cp_parser* parser)
18347 return (cp_parser_parsing_tentatively (parser)
18348 && parser->context->status != CP_PARSER_STATUS_KIND_COMMITTED);
18351 /* Returns nonzero iff an error has occurred during the most recent
18352 tentative parse. */
18355 cp_parser_error_occurred (cp_parser* parser)
18357 return (cp_parser_parsing_tentatively (parser)
18358 && parser->context->status == CP_PARSER_STATUS_KIND_ERROR);
18361 /* Returns nonzero if GNU extensions are allowed. */
18364 cp_parser_allow_gnu_extensions_p (cp_parser* parser)
18366 return parser->allow_gnu_extensions_p;
18369 /* Objective-C++ Productions */
18372 /* Parse an Objective-C expression, which feeds into a primary-expression
18376 objc-message-expression
18377 objc-string-literal
18378 objc-encode-expression
18379 objc-protocol-expression
18380 objc-selector-expression
18382 Returns a tree representation of the expression. */
18385 cp_parser_objc_expression (cp_parser* parser)
18387 /* Try to figure out what kind of declaration is present. */
18388 cp_token *kwd = cp_lexer_peek_token (parser->lexer);
18392 case CPP_OPEN_SQUARE:
18393 return cp_parser_objc_message_expression (parser);
18395 case CPP_OBJC_STRING:
18396 kwd = cp_lexer_consume_token (parser->lexer);
18397 return objc_build_string_object (kwd->u.value);
18400 switch (kwd->keyword)
18402 case RID_AT_ENCODE:
18403 return cp_parser_objc_encode_expression (parser);
18405 case RID_AT_PROTOCOL:
18406 return cp_parser_objc_protocol_expression (parser);
18408 case RID_AT_SELECTOR:
18409 return cp_parser_objc_selector_expression (parser);
18415 error ("misplaced %<@%D%> Objective-C++ construct", kwd->u.value);
18416 cp_parser_skip_to_end_of_block_or_statement (parser);
18419 return error_mark_node;
18422 /* Parse an Objective-C message expression.
18424 objc-message-expression:
18425 [ objc-message-receiver objc-message-args ]
18427 Returns a representation of an Objective-C message. */
18430 cp_parser_objc_message_expression (cp_parser* parser)
18432 tree receiver, messageargs;
18434 cp_lexer_consume_token (parser->lexer); /* Eat '['. */
18435 receiver = cp_parser_objc_message_receiver (parser);
18436 messageargs = cp_parser_objc_message_args (parser);
18437 cp_parser_require (parser, CPP_CLOSE_SQUARE, "%<]%>");
18439 return objc_build_message_expr (build_tree_list (receiver, messageargs));
18442 /* Parse an objc-message-receiver.
18444 objc-message-receiver:
18446 simple-type-specifier
18448 Returns a representation of the type or expression. */
18451 cp_parser_objc_message_receiver (cp_parser* parser)
18455 /* An Objective-C message receiver may be either (1) a type
18456 or (2) an expression. */
18457 cp_parser_parse_tentatively (parser);
18458 rcv = cp_parser_expression (parser, false);
18460 if (cp_parser_parse_definitely (parser))
18463 rcv = cp_parser_simple_type_specifier (parser,
18464 /*decl_specs=*/NULL,
18465 CP_PARSER_FLAGS_NONE);
18467 return objc_get_class_reference (rcv);
18470 /* Parse the arguments and selectors comprising an Objective-C message.
18475 objc-selector-args , objc-comma-args
18477 objc-selector-args:
18478 objc-selector [opt] : assignment-expression
18479 objc-selector-args objc-selector [opt] : assignment-expression
18482 assignment-expression
18483 objc-comma-args , assignment-expression
18485 Returns a TREE_LIST, with TREE_PURPOSE containing a list of
18486 selector arguments and TREE_VALUE containing a list of comma
18490 cp_parser_objc_message_args (cp_parser* parser)
18492 tree sel_args = NULL_TREE, addl_args = NULL_TREE;
18493 bool maybe_unary_selector_p = true;
18494 cp_token *token = cp_lexer_peek_token (parser->lexer);
18496 while (cp_parser_objc_selector_p (token->type) || token->type == CPP_COLON)
18498 tree selector = NULL_TREE, arg;
18500 if (token->type != CPP_COLON)
18501 selector = cp_parser_objc_selector (parser);
18503 /* Detect if we have a unary selector. */
18504 if (maybe_unary_selector_p
18505 && cp_lexer_next_token_is_not (parser->lexer, CPP_COLON))
18506 return build_tree_list (selector, NULL_TREE);
18508 maybe_unary_selector_p = false;
18509 cp_parser_require (parser, CPP_COLON, "%<:%>");
18510 arg = cp_parser_assignment_expression (parser, false);
18513 = chainon (sel_args,
18514 build_tree_list (selector, arg));
18516 token = cp_lexer_peek_token (parser->lexer);
18519 /* Handle non-selector arguments, if any. */
18520 while (token->type == CPP_COMMA)
18524 cp_lexer_consume_token (parser->lexer);
18525 arg = cp_parser_assignment_expression (parser, false);
18528 = chainon (addl_args,
18529 build_tree_list (NULL_TREE, arg));
18531 token = cp_lexer_peek_token (parser->lexer);
18534 return build_tree_list (sel_args, addl_args);
18537 /* Parse an Objective-C encode expression.
18539 objc-encode-expression:
18540 @encode objc-typename
18542 Returns an encoded representation of the type argument. */
18545 cp_parser_objc_encode_expression (cp_parser* parser)
18549 cp_lexer_consume_token (parser->lexer); /* Eat '@encode'. */
18550 cp_parser_require (parser, CPP_OPEN_PAREN, "%<(%>");
18551 type = complete_type (cp_parser_type_id (parser));
18552 cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>");
18556 error ("%<@encode%> must specify a type as an argument");
18557 return error_mark_node;
18560 return objc_build_encode_expr (type);
18563 /* Parse an Objective-C @defs expression. */
18566 cp_parser_objc_defs_expression (cp_parser *parser)
18570 cp_lexer_consume_token (parser->lexer); /* Eat '@defs'. */
18571 cp_parser_require (parser, CPP_OPEN_PAREN, "%<(%>");
18572 name = cp_parser_identifier (parser);
18573 cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>");
18575 return objc_get_class_ivars (name);
18578 /* Parse an Objective-C protocol expression.
18580 objc-protocol-expression:
18581 @protocol ( identifier )
18583 Returns a representation of the protocol expression. */
18586 cp_parser_objc_protocol_expression (cp_parser* parser)
18590 cp_lexer_consume_token (parser->lexer); /* Eat '@protocol'. */
18591 cp_parser_require (parser, CPP_OPEN_PAREN, "%<(%>");
18592 proto = cp_parser_identifier (parser);
18593 cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>");
18595 return objc_build_protocol_expr (proto);
18598 /* Parse an Objective-C selector expression.
18600 objc-selector-expression:
18601 @selector ( objc-method-signature )
18603 objc-method-signature:
18609 objc-selector-seq objc-selector :
18611 Returns a representation of the method selector. */
18614 cp_parser_objc_selector_expression (cp_parser* parser)
18616 tree sel_seq = NULL_TREE;
18617 bool maybe_unary_selector_p = true;
18620 cp_lexer_consume_token (parser->lexer); /* Eat '@selector'. */
18621 cp_parser_require (parser, CPP_OPEN_PAREN, "%<(%>");
18622 token = cp_lexer_peek_token (parser->lexer);
18624 while (cp_parser_objc_selector_p (token->type) || token->type == CPP_COLON
18625 || token->type == CPP_SCOPE)
18627 tree selector = NULL_TREE;
18629 if (token->type != CPP_COLON
18630 || token->type == CPP_SCOPE)
18631 selector = cp_parser_objc_selector (parser);
18633 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COLON)
18634 && cp_lexer_next_token_is_not (parser->lexer, CPP_SCOPE))
18636 /* Detect if we have a unary selector. */
18637 if (maybe_unary_selector_p)
18639 sel_seq = selector;
18640 goto finish_selector;
18644 cp_parser_error (parser, "expected %<:%>");
18647 maybe_unary_selector_p = false;
18648 token = cp_lexer_consume_token (parser->lexer);
18650 if (token->type == CPP_SCOPE)
18653 = chainon (sel_seq,
18654 build_tree_list (selector, NULL_TREE));
18656 = chainon (sel_seq,
18657 build_tree_list (NULL_TREE, NULL_TREE));
18661 = chainon (sel_seq,
18662 build_tree_list (selector, NULL_TREE));
18664 token = cp_lexer_peek_token (parser->lexer);
18668 cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>");
18670 return objc_build_selector_expr (sel_seq);
18673 /* Parse a list of identifiers.
18675 objc-identifier-list:
18677 objc-identifier-list , identifier
18679 Returns a TREE_LIST of identifier nodes. */
18682 cp_parser_objc_identifier_list (cp_parser* parser)
18684 tree list = build_tree_list (NULL_TREE, cp_parser_identifier (parser));
18685 cp_token *sep = cp_lexer_peek_token (parser->lexer);
18687 while (sep->type == CPP_COMMA)
18689 cp_lexer_consume_token (parser->lexer); /* Eat ','. */
18690 list = chainon (list,
18691 build_tree_list (NULL_TREE,
18692 cp_parser_identifier (parser)));
18693 sep = cp_lexer_peek_token (parser->lexer);
18699 /* Parse an Objective-C alias declaration.
18701 objc-alias-declaration:
18702 @compatibility_alias identifier identifier ;
18704 This function registers the alias mapping with the Objective-C front end.
18705 It returns nothing. */
18708 cp_parser_objc_alias_declaration (cp_parser* parser)
18712 cp_lexer_consume_token (parser->lexer); /* Eat '@compatibility_alias'. */
18713 alias = cp_parser_identifier (parser);
18714 orig = cp_parser_identifier (parser);
18715 objc_declare_alias (alias, orig);
18716 cp_parser_consume_semicolon_at_end_of_statement (parser);
18719 /* Parse an Objective-C class forward-declaration.
18721 objc-class-declaration:
18722 @class objc-identifier-list ;
18724 The function registers the forward declarations with the Objective-C
18725 front end. It returns nothing. */
18728 cp_parser_objc_class_declaration (cp_parser* parser)
18730 cp_lexer_consume_token (parser->lexer); /* Eat '@class'. */
18731 objc_declare_class (cp_parser_objc_identifier_list (parser));
18732 cp_parser_consume_semicolon_at_end_of_statement (parser);
18735 /* Parse a list of Objective-C protocol references.
18737 objc-protocol-refs-opt:
18738 objc-protocol-refs [opt]
18740 objc-protocol-refs:
18741 < objc-identifier-list >
18743 Returns a TREE_LIST of identifiers, if any. */
18746 cp_parser_objc_protocol_refs_opt (cp_parser* parser)
18748 tree protorefs = NULL_TREE;
18750 if(cp_lexer_next_token_is (parser->lexer, CPP_LESS))
18752 cp_lexer_consume_token (parser->lexer); /* Eat '<'. */
18753 protorefs = cp_parser_objc_identifier_list (parser);
18754 cp_parser_require (parser, CPP_GREATER, "%<>%>");
18760 /* Parse a Objective-C visibility specification. */
18763 cp_parser_objc_visibility_spec (cp_parser* parser)
18765 cp_token *vis = cp_lexer_peek_token (parser->lexer);
18767 switch (vis->keyword)
18769 case RID_AT_PRIVATE:
18770 objc_set_visibility (2);
18772 case RID_AT_PROTECTED:
18773 objc_set_visibility (0);
18775 case RID_AT_PUBLIC:
18776 objc_set_visibility (1);
18782 /* Eat '@private'/'@protected'/'@public'. */
18783 cp_lexer_consume_token (parser->lexer);
18786 /* Parse an Objective-C method type. */
18789 cp_parser_objc_method_type (cp_parser* parser)
18791 objc_set_method_type
18792 (cp_lexer_consume_token (parser->lexer)->type == CPP_PLUS
18797 /* Parse an Objective-C protocol qualifier. */
18800 cp_parser_objc_protocol_qualifiers (cp_parser* parser)
18802 tree quals = NULL_TREE, node;
18803 cp_token *token = cp_lexer_peek_token (parser->lexer);
18805 node = token->u.value;
18807 while (node && TREE_CODE (node) == IDENTIFIER_NODE
18808 && (node == ridpointers [(int) RID_IN]
18809 || node == ridpointers [(int) RID_OUT]
18810 || node == ridpointers [(int) RID_INOUT]
18811 || node == ridpointers [(int) RID_BYCOPY]
18812 || node == ridpointers [(int) RID_BYREF]
18813 || node == ridpointers [(int) RID_ONEWAY]))
18815 quals = tree_cons (NULL_TREE, node, quals);
18816 cp_lexer_consume_token (parser->lexer);
18817 token = cp_lexer_peek_token (parser->lexer);
18818 node = token->u.value;
18824 /* Parse an Objective-C typename. */
18827 cp_parser_objc_typename (cp_parser* parser)
18829 tree typename = NULL_TREE;
18831 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
18833 tree proto_quals, cp_type = NULL_TREE;
18835 cp_lexer_consume_token (parser->lexer); /* Eat '('. */
18836 proto_quals = cp_parser_objc_protocol_qualifiers (parser);
18838 /* An ObjC type name may consist of just protocol qualifiers, in which
18839 case the type shall default to 'id'. */
18840 if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
18841 cp_type = cp_parser_type_id (parser);
18843 cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>");
18844 typename = build_tree_list (proto_quals, cp_type);
18850 /* Check to see if TYPE refers to an Objective-C selector name. */
18853 cp_parser_objc_selector_p (enum cpp_ttype type)
18855 return (type == CPP_NAME || type == CPP_KEYWORD
18856 || type == CPP_AND_AND || type == CPP_AND_EQ || type == CPP_AND
18857 || type == CPP_OR || type == CPP_COMPL || type == CPP_NOT
18858 || type == CPP_NOT_EQ || type == CPP_OR_OR || type == CPP_OR_EQ
18859 || type == CPP_XOR || type == CPP_XOR_EQ);
18862 /* Parse an Objective-C selector. */
18865 cp_parser_objc_selector (cp_parser* parser)
18867 cp_token *token = cp_lexer_consume_token (parser->lexer);
18869 if (!cp_parser_objc_selector_p (token->type))
18871 error ("invalid Objective-C++ selector name");
18872 return error_mark_node;
18875 /* C++ operator names are allowed to appear in ObjC selectors. */
18876 switch (token->type)
18878 case CPP_AND_AND: return get_identifier ("and");
18879 case CPP_AND_EQ: return get_identifier ("and_eq");
18880 case CPP_AND: return get_identifier ("bitand");
18881 case CPP_OR: return get_identifier ("bitor");
18882 case CPP_COMPL: return get_identifier ("compl");
18883 case CPP_NOT: return get_identifier ("not");
18884 case CPP_NOT_EQ: return get_identifier ("not_eq");
18885 case CPP_OR_OR: return get_identifier ("or");
18886 case CPP_OR_EQ: return get_identifier ("or_eq");
18887 case CPP_XOR: return get_identifier ("xor");
18888 case CPP_XOR_EQ: return get_identifier ("xor_eq");
18889 default: return token->u.value;
18893 /* Parse an Objective-C params list. */
18896 cp_parser_objc_method_keyword_params (cp_parser* parser)
18898 tree params = NULL_TREE;
18899 bool maybe_unary_selector_p = true;
18900 cp_token *token = cp_lexer_peek_token (parser->lexer);
18902 while (cp_parser_objc_selector_p (token->type) || token->type == CPP_COLON)
18904 tree selector = NULL_TREE, typename, identifier;
18906 if (token->type != CPP_COLON)
18907 selector = cp_parser_objc_selector (parser);
18909 /* Detect if we have a unary selector. */
18910 if (maybe_unary_selector_p
18911 && cp_lexer_next_token_is_not (parser->lexer, CPP_COLON))
18914 maybe_unary_selector_p = false;
18915 cp_parser_require (parser, CPP_COLON, "%<:%>");
18916 typename = cp_parser_objc_typename (parser);
18917 identifier = cp_parser_identifier (parser);
18921 objc_build_keyword_decl (selector,
18925 token = cp_lexer_peek_token (parser->lexer);
18931 /* Parse the non-keyword Objective-C params. */
18934 cp_parser_objc_method_tail_params_opt (cp_parser* parser, bool *ellipsisp)
18936 tree params = make_node (TREE_LIST);
18937 cp_token *token = cp_lexer_peek_token (parser->lexer);
18938 *ellipsisp = false; /* Initially, assume no ellipsis. */
18940 while (token->type == CPP_COMMA)
18942 cp_parameter_declarator *parmdecl;
18945 cp_lexer_consume_token (parser->lexer); /* Eat ','. */
18946 token = cp_lexer_peek_token (parser->lexer);
18948 if (token->type == CPP_ELLIPSIS)
18950 cp_lexer_consume_token (parser->lexer); /* Eat '...'. */
18955 parmdecl = cp_parser_parameter_declaration (parser, false, NULL);
18956 parm = grokdeclarator (parmdecl->declarator,
18957 &parmdecl->decl_specifiers,
18958 PARM, /*initialized=*/0,
18959 /*attrlist=*/NULL);
18961 chainon (params, build_tree_list (NULL_TREE, parm));
18962 token = cp_lexer_peek_token (parser->lexer);
18968 /* Parse a linkage specification, a pragma, an extra semicolon or a block. */
18971 cp_parser_objc_interstitial_code (cp_parser* parser)
18973 cp_token *token = cp_lexer_peek_token (parser->lexer);
18975 /* If the next token is `extern' and the following token is a string
18976 literal, then we have a linkage specification. */
18977 if (token->keyword == RID_EXTERN
18978 && cp_parser_is_string_literal (cp_lexer_peek_nth_token (parser->lexer, 2)))
18979 cp_parser_linkage_specification (parser);
18980 /* Handle #pragma, if any. */
18981 else if (token->type == CPP_PRAGMA)
18982 cp_parser_pragma (parser, pragma_external);
18983 /* Allow stray semicolons. */
18984 else if (token->type == CPP_SEMICOLON)
18985 cp_lexer_consume_token (parser->lexer);
18986 /* Finally, try to parse a block-declaration, or a function-definition. */
18988 cp_parser_block_declaration (parser, /*statement_p=*/false);
18991 /* Parse a method signature. */
18994 cp_parser_objc_method_signature (cp_parser* parser)
18996 tree rettype, kwdparms, optparms;
18997 bool ellipsis = false;
18999 cp_parser_objc_method_type (parser);
19000 rettype = cp_parser_objc_typename (parser);
19001 kwdparms = cp_parser_objc_method_keyword_params (parser);
19002 optparms = cp_parser_objc_method_tail_params_opt (parser, &ellipsis);
19004 return objc_build_method_signature (rettype, kwdparms, optparms, ellipsis);
19007 /* Pars an Objective-C method prototype list. */
19010 cp_parser_objc_method_prototype_list (cp_parser* parser)
19012 cp_token *token = cp_lexer_peek_token (parser->lexer);
19014 while (token->keyword != RID_AT_END)
19016 if (token->type == CPP_PLUS || token->type == CPP_MINUS)
19018 objc_add_method_declaration
19019 (cp_parser_objc_method_signature (parser));
19020 cp_parser_consume_semicolon_at_end_of_statement (parser);
19023 /* Allow for interspersed non-ObjC++ code. */
19024 cp_parser_objc_interstitial_code (parser);
19026 token = cp_lexer_peek_token (parser->lexer);
19029 cp_lexer_consume_token (parser->lexer); /* Eat '@end'. */
19030 objc_finish_interface ();
19033 /* Parse an Objective-C method definition list. */
19036 cp_parser_objc_method_definition_list (cp_parser* parser)
19038 cp_token *token = cp_lexer_peek_token (parser->lexer);
19040 while (token->keyword != RID_AT_END)
19044 if (token->type == CPP_PLUS || token->type == CPP_MINUS)
19046 push_deferring_access_checks (dk_deferred);
19047 objc_start_method_definition
19048 (cp_parser_objc_method_signature (parser));
19050 /* For historical reasons, we accept an optional semicolon. */
19051 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
19052 cp_lexer_consume_token (parser->lexer);
19054 perform_deferred_access_checks ();
19055 stop_deferring_access_checks ();
19056 meth = cp_parser_function_definition_after_declarator (parser,
19058 pop_deferring_access_checks ();
19059 objc_finish_method_definition (meth);
19062 /* Allow for interspersed non-ObjC++ code. */
19063 cp_parser_objc_interstitial_code (parser);
19065 token = cp_lexer_peek_token (parser->lexer);
19068 cp_lexer_consume_token (parser->lexer); /* Eat '@end'. */
19069 objc_finish_implementation ();
19072 /* Parse Objective-C ivars. */
19075 cp_parser_objc_class_ivars (cp_parser* parser)
19077 cp_token *token = cp_lexer_peek_token (parser->lexer);
19079 if (token->type != CPP_OPEN_BRACE)
19080 return; /* No ivars specified. */
19082 cp_lexer_consume_token (parser->lexer); /* Eat '{'. */
19083 token = cp_lexer_peek_token (parser->lexer);
19085 while (token->type != CPP_CLOSE_BRACE)
19087 cp_decl_specifier_seq declspecs;
19088 int decl_class_or_enum_p;
19089 tree prefix_attributes;
19091 cp_parser_objc_visibility_spec (parser);
19093 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
19096 cp_parser_decl_specifier_seq (parser,
19097 CP_PARSER_FLAGS_OPTIONAL,
19099 &decl_class_or_enum_p);
19100 prefix_attributes = declspecs.attributes;
19101 declspecs.attributes = NULL_TREE;
19103 /* Keep going until we hit the `;' at the end of the
19105 while (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
19107 tree width = NULL_TREE, attributes, first_attribute, decl;
19108 cp_declarator *declarator = NULL;
19109 int ctor_dtor_or_conv_p;
19111 /* Check for a (possibly unnamed) bitfield declaration. */
19112 token = cp_lexer_peek_token (parser->lexer);
19113 if (token->type == CPP_COLON)
19116 if (token->type == CPP_NAME
19117 && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
19120 /* Get the name of the bitfield. */
19121 declarator = make_id_declarator (NULL_TREE,
19122 cp_parser_identifier (parser),
19126 cp_lexer_consume_token (parser->lexer); /* Eat ':'. */
19127 /* Get the width of the bitfield. */
19129 = cp_parser_constant_expression (parser,
19130 /*allow_non_constant=*/false,
19135 /* Parse the declarator. */
19137 = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
19138 &ctor_dtor_or_conv_p,
19139 /*parenthesized_p=*/NULL,
19140 /*member_p=*/false);
19143 /* Look for attributes that apply to the ivar. */
19144 attributes = cp_parser_attributes_opt (parser);
19145 /* Remember which attributes are prefix attributes and
19147 first_attribute = attributes;
19148 /* Combine the attributes. */
19149 attributes = chainon (prefix_attributes, attributes);
19152 /* Create the bitfield declaration. */
19153 decl = grokbitfield (declarator, &declspecs,
19157 decl = grokfield (declarator, &declspecs,
19158 NULL_TREE, /*init_const_expr_p=*/false,
19159 NULL_TREE, attributes);
19161 /* Add the instance variable. */
19162 objc_add_instance_variable (decl);
19164 /* Reset PREFIX_ATTRIBUTES. */
19165 while (attributes && TREE_CHAIN (attributes) != first_attribute)
19166 attributes = TREE_CHAIN (attributes);
19168 TREE_CHAIN (attributes) = NULL_TREE;
19170 token = cp_lexer_peek_token (parser->lexer);
19172 if (token->type == CPP_COMMA)
19174 cp_lexer_consume_token (parser->lexer); /* Eat ','. */
19180 cp_parser_consume_semicolon_at_end_of_statement (parser);
19181 token = cp_lexer_peek_token (parser->lexer);
19184 cp_lexer_consume_token (parser->lexer); /* Eat '}'. */
19185 /* For historical reasons, we accept an optional semicolon. */
19186 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
19187 cp_lexer_consume_token (parser->lexer);
19190 /* Parse an Objective-C protocol declaration. */
19193 cp_parser_objc_protocol_declaration (cp_parser* parser)
19195 tree proto, protorefs;
19198 cp_lexer_consume_token (parser->lexer); /* Eat '@protocol'. */
19199 if (cp_lexer_next_token_is_not (parser->lexer, CPP_NAME))
19201 error ("identifier expected after %<@protocol%>");
19205 /* See if we have a forward declaration or a definition. */
19206 tok = cp_lexer_peek_nth_token (parser->lexer, 2);
19208 /* Try a forward declaration first. */
19209 if (tok->type == CPP_COMMA || tok->type == CPP_SEMICOLON)
19211 objc_declare_protocols (cp_parser_objc_identifier_list (parser));
19213 cp_parser_consume_semicolon_at_end_of_statement (parser);
19216 /* Ok, we got a full-fledged definition (or at least should). */
19219 proto = cp_parser_identifier (parser);
19220 protorefs = cp_parser_objc_protocol_refs_opt (parser);
19221 objc_start_protocol (proto, protorefs);
19222 cp_parser_objc_method_prototype_list (parser);
19226 /* Parse an Objective-C superclass or category. */
19229 cp_parser_objc_superclass_or_category (cp_parser *parser, tree *super,
19232 cp_token *next = cp_lexer_peek_token (parser->lexer);
19234 *super = *categ = NULL_TREE;
19235 if (next->type == CPP_COLON)
19237 cp_lexer_consume_token (parser->lexer); /* Eat ':'. */
19238 *super = cp_parser_identifier (parser);
19240 else if (next->type == CPP_OPEN_PAREN)
19242 cp_lexer_consume_token (parser->lexer); /* Eat '('. */
19243 *categ = cp_parser_identifier (parser);
19244 cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>");
19248 /* Parse an Objective-C class interface. */
19251 cp_parser_objc_class_interface (cp_parser* parser)
19253 tree name, super, categ, protos;
19255 cp_lexer_consume_token (parser->lexer); /* Eat '@interface'. */
19256 name = cp_parser_identifier (parser);
19257 cp_parser_objc_superclass_or_category (parser, &super, &categ);
19258 protos = cp_parser_objc_protocol_refs_opt (parser);
19260 /* We have either a class or a category on our hands. */
19262 objc_start_category_interface (name, categ, protos);
19265 objc_start_class_interface (name, super, protos);
19266 /* Handle instance variable declarations, if any. */
19267 cp_parser_objc_class_ivars (parser);
19268 objc_continue_interface ();
19271 cp_parser_objc_method_prototype_list (parser);
19274 /* Parse an Objective-C class implementation. */
19277 cp_parser_objc_class_implementation (cp_parser* parser)
19279 tree name, super, categ;
19281 cp_lexer_consume_token (parser->lexer); /* Eat '@implementation'. */
19282 name = cp_parser_identifier (parser);
19283 cp_parser_objc_superclass_or_category (parser, &super, &categ);
19285 /* We have either a class or a category on our hands. */
19287 objc_start_category_implementation (name, categ);
19290 objc_start_class_implementation (name, super);
19291 /* Handle instance variable declarations, if any. */
19292 cp_parser_objc_class_ivars (parser);
19293 objc_continue_implementation ();
19296 cp_parser_objc_method_definition_list (parser);
19299 /* Consume the @end token and finish off the implementation. */
19302 cp_parser_objc_end_implementation (cp_parser* parser)
19304 cp_lexer_consume_token (parser->lexer); /* Eat '@end'. */
19305 objc_finish_implementation ();
19308 /* Parse an Objective-C declaration. */
19311 cp_parser_objc_declaration (cp_parser* parser)
19313 /* Try to figure out what kind of declaration is present. */
19314 cp_token *kwd = cp_lexer_peek_token (parser->lexer);
19316 switch (kwd->keyword)
19319 cp_parser_objc_alias_declaration (parser);
19322 cp_parser_objc_class_declaration (parser);
19324 case RID_AT_PROTOCOL:
19325 cp_parser_objc_protocol_declaration (parser);
19327 case RID_AT_INTERFACE:
19328 cp_parser_objc_class_interface (parser);
19330 case RID_AT_IMPLEMENTATION:
19331 cp_parser_objc_class_implementation (parser);
19334 cp_parser_objc_end_implementation (parser);
19337 error ("misplaced %<@%D%> Objective-C++ construct", kwd->u.value);
19338 cp_parser_skip_to_end_of_block_or_statement (parser);
19342 /* Parse an Objective-C try-catch-finally statement.
19344 objc-try-catch-finally-stmt:
19345 @try compound-statement objc-catch-clause-seq [opt]
19346 objc-finally-clause [opt]
19348 objc-catch-clause-seq:
19349 objc-catch-clause objc-catch-clause-seq [opt]
19352 @catch ( exception-declaration ) compound-statement
19354 objc-finally-clause
19355 @finally compound-statement
19357 Returns NULL_TREE. */
19360 cp_parser_objc_try_catch_finally_statement (cp_parser *parser) {
19361 location_t location;
19364 cp_parser_require_keyword (parser, RID_AT_TRY, "%<@try%>");
19365 location = cp_lexer_peek_token (parser->lexer)->location;
19366 /* NB: The @try block needs to be wrapped in its own STATEMENT_LIST
19367 node, lest it get absorbed into the surrounding block. */
19368 stmt = push_stmt_list ();
19369 cp_parser_compound_statement (parser, NULL, false);
19370 objc_begin_try_stmt (location, pop_stmt_list (stmt));
19372 while (cp_lexer_next_token_is_keyword (parser->lexer, RID_AT_CATCH))
19374 cp_parameter_declarator *parmdecl;
19377 cp_lexer_consume_token (parser->lexer);
19378 cp_parser_require (parser, CPP_OPEN_PAREN, "%<(%>");
19379 parmdecl = cp_parser_parameter_declaration (parser, false, NULL);
19380 parm = grokdeclarator (parmdecl->declarator,
19381 &parmdecl->decl_specifiers,
19382 PARM, /*initialized=*/0,
19383 /*attrlist=*/NULL);
19384 cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>");
19385 objc_begin_catch_clause (parm);
19386 cp_parser_compound_statement (parser, NULL, false);
19387 objc_finish_catch_clause ();
19390 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_AT_FINALLY))
19392 cp_lexer_consume_token (parser->lexer);
19393 location = cp_lexer_peek_token (parser->lexer)->location;
19394 /* NB: The @finally block needs to be wrapped in its own STATEMENT_LIST
19395 node, lest it get absorbed into the surrounding block. */
19396 stmt = push_stmt_list ();
19397 cp_parser_compound_statement (parser, NULL, false);
19398 objc_build_finally_clause (location, pop_stmt_list (stmt));
19401 return objc_finish_try_stmt ();
19404 /* Parse an Objective-C synchronized statement.
19406 objc-synchronized-stmt:
19407 @synchronized ( expression ) compound-statement
19409 Returns NULL_TREE. */
19412 cp_parser_objc_synchronized_statement (cp_parser *parser) {
19413 location_t location;
19416 cp_parser_require_keyword (parser, RID_AT_SYNCHRONIZED, "%<@synchronized%>");
19418 location = cp_lexer_peek_token (parser->lexer)->location;
19419 cp_parser_require (parser, CPP_OPEN_PAREN, "%<(%>");
19420 lock = cp_parser_expression (parser, false);
19421 cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>");
19423 /* NB: The @synchronized block needs to be wrapped in its own STATEMENT_LIST
19424 node, lest it get absorbed into the surrounding block. */
19425 stmt = push_stmt_list ();
19426 cp_parser_compound_statement (parser, NULL, false);
19428 return objc_build_synchronized (location, lock, pop_stmt_list (stmt));
19431 /* Parse an Objective-C throw statement.
19434 @throw assignment-expression [opt] ;
19436 Returns a constructed '@throw' statement. */
19439 cp_parser_objc_throw_statement (cp_parser *parser) {
19440 tree expr = NULL_TREE;
19442 cp_parser_require_keyword (parser, RID_AT_THROW, "%<@throw%>");
19444 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
19445 expr = cp_parser_assignment_expression (parser, false);
19447 cp_parser_consume_semicolon_at_end_of_statement (parser);
19449 return objc_build_throw_stmt (expr);
19452 /* Parse an Objective-C statement. */
19455 cp_parser_objc_statement (cp_parser * parser) {
19456 /* Try to figure out what kind of declaration is present. */
19457 cp_token *kwd = cp_lexer_peek_token (parser->lexer);
19459 switch (kwd->keyword)
19462 return cp_parser_objc_try_catch_finally_statement (parser);
19463 case RID_AT_SYNCHRONIZED:
19464 return cp_parser_objc_synchronized_statement (parser);
19466 return cp_parser_objc_throw_statement (parser);
19468 error ("misplaced %<@%D%> Objective-C++ construct", kwd->u.value);
19469 cp_parser_skip_to_end_of_block_or_statement (parser);
19472 return error_mark_node;
19475 /* OpenMP 2.5 parsing routines. */
19477 /* Returns name of the next clause.
19478 If the clause is not recognized PRAGMA_OMP_CLAUSE_NONE is returned and
19479 the token is not consumed. Otherwise appropriate pragma_omp_clause is
19480 returned and the token is consumed. */
19482 static pragma_omp_clause
19483 cp_parser_omp_clause_name (cp_parser *parser)
19485 pragma_omp_clause result = PRAGMA_OMP_CLAUSE_NONE;
19487 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_IF))
19488 result = PRAGMA_OMP_CLAUSE_IF;
19489 else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_DEFAULT))
19490 result = PRAGMA_OMP_CLAUSE_DEFAULT;
19491 else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_PRIVATE))
19492 result = PRAGMA_OMP_CLAUSE_PRIVATE;
19493 else if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
19495 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
19496 const char *p = IDENTIFIER_POINTER (id);
19501 if (!strcmp ("collapse", p))
19502 result = PRAGMA_OMP_CLAUSE_COLLAPSE;
19503 else if (!strcmp ("copyin", p))
19504 result = PRAGMA_OMP_CLAUSE_COPYIN;
19505 else if (!strcmp ("copyprivate", p))
19506 result = PRAGMA_OMP_CLAUSE_COPYPRIVATE;
19509 if (!strcmp ("firstprivate", p))
19510 result = PRAGMA_OMP_CLAUSE_FIRSTPRIVATE;
19513 if (!strcmp ("lastprivate", p))
19514 result = PRAGMA_OMP_CLAUSE_LASTPRIVATE;
19517 if (!strcmp ("nowait", p))
19518 result = PRAGMA_OMP_CLAUSE_NOWAIT;
19519 else if (!strcmp ("num_threads", p))
19520 result = PRAGMA_OMP_CLAUSE_NUM_THREADS;
19523 if (!strcmp ("ordered", p))
19524 result = PRAGMA_OMP_CLAUSE_ORDERED;
19527 if (!strcmp ("reduction", p))
19528 result = PRAGMA_OMP_CLAUSE_REDUCTION;
19531 if (!strcmp ("schedule", p))
19532 result = PRAGMA_OMP_CLAUSE_SCHEDULE;
19533 else if (!strcmp ("shared", p))
19534 result = PRAGMA_OMP_CLAUSE_SHARED;
19537 if (!strcmp ("untied", p))
19538 result = PRAGMA_OMP_CLAUSE_UNTIED;
19543 if (result != PRAGMA_OMP_CLAUSE_NONE)
19544 cp_lexer_consume_token (parser->lexer);
19549 /* Validate that a clause of the given type does not already exist. */
19552 check_no_duplicate_clause (tree clauses, enum tree_code code, const char *name)
19556 for (c = clauses; c ; c = OMP_CLAUSE_CHAIN (c))
19557 if (OMP_CLAUSE_CODE (c) == code)
19559 error ("too many %qs clauses", name);
19567 variable-list , identifier
19569 In addition, we match a closing parenthesis. An opening parenthesis
19570 will have been consumed by the caller.
19572 If KIND is nonzero, create the appropriate node and install the decl
19573 in OMP_CLAUSE_DECL and add the node to the head of the list.
19575 If KIND is zero, create a TREE_LIST with the decl in TREE_PURPOSE;
19576 return the list created. */
19579 cp_parser_omp_var_list_no_open (cp_parser *parser, enum omp_clause_code kind,
19586 name = cp_parser_id_expression (parser, /*template_p=*/false,
19587 /*check_dependency_p=*/true,
19588 /*template_p=*/NULL,
19589 /*declarator_p=*/false,
19590 /*optional_p=*/false);
19591 if (name == error_mark_node)
19594 decl = cp_parser_lookup_name_simple (parser, name);
19595 if (decl == error_mark_node)
19596 cp_parser_name_lookup_error (parser, name, decl, NULL);
19597 else if (kind != 0)
19599 tree u = build_omp_clause (kind);
19600 OMP_CLAUSE_DECL (u) = decl;
19601 OMP_CLAUSE_CHAIN (u) = list;
19605 list = tree_cons (decl, NULL_TREE, list);
19608 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
19610 cp_lexer_consume_token (parser->lexer);
19613 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>"))
19617 /* Try to resync to an unnested comma. Copied from
19618 cp_parser_parenthesized_expression_list. */
19620 ending = cp_parser_skip_to_closing_parenthesis (parser,
19621 /*recovering=*/true,
19623 /*consume_paren=*/true);
19631 /* Similarly, but expect leading and trailing parenthesis. This is a very
19632 common case for omp clauses. */
19635 cp_parser_omp_var_list (cp_parser *parser, enum omp_clause_code kind, tree list)
19637 if (cp_parser_require (parser, CPP_OPEN_PAREN, "%<(%>"))
19638 return cp_parser_omp_var_list_no_open (parser, kind, list);
19643 collapse ( constant-expression ) */
19646 cp_parser_omp_clause_collapse (cp_parser *parser, tree list)
19652 loc = cp_lexer_peek_token (parser->lexer)->location;
19653 if (!cp_parser_require (parser, CPP_OPEN_PAREN, "%<(%>"))
19656 num = cp_parser_constant_expression (parser, false, NULL);
19658 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>"))
19659 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
19660 /*or_comma=*/false,
19661 /*consume_paren=*/true);
19663 if (num == error_mark_node)
19665 num = fold_non_dependent_expr (num);
19666 if (!INTEGRAL_TYPE_P (TREE_TYPE (num))
19667 || !host_integerp (num, 0)
19668 || (n = tree_low_cst (num, 0)) <= 0
19671 error ("%Hcollapse argument needs positive constant integer expression", &loc);
19675 check_no_duplicate_clause (list, OMP_CLAUSE_COLLAPSE, "collapse");
19676 c = build_omp_clause (OMP_CLAUSE_COLLAPSE);
19677 OMP_CLAUSE_CHAIN (c) = list;
19678 OMP_CLAUSE_COLLAPSE_EXPR (c) = num;
19684 default ( shared | none ) */
19687 cp_parser_omp_clause_default (cp_parser *parser, tree list)
19689 enum omp_clause_default_kind kind = OMP_CLAUSE_DEFAULT_UNSPECIFIED;
19692 if (!cp_parser_require (parser, CPP_OPEN_PAREN, "%<(%>"))
19694 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
19696 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
19697 const char *p = IDENTIFIER_POINTER (id);
19702 if (strcmp ("none", p) != 0)
19704 kind = OMP_CLAUSE_DEFAULT_NONE;
19708 if (strcmp ("shared", p) != 0)
19710 kind = OMP_CLAUSE_DEFAULT_SHARED;
19717 cp_lexer_consume_token (parser->lexer);
19722 cp_parser_error (parser, "expected %<none%> or %<shared%>");
19725 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>"))
19726 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
19727 /*or_comma=*/false,
19728 /*consume_paren=*/true);
19730 if (kind == OMP_CLAUSE_DEFAULT_UNSPECIFIED)
19733 check_no_duplicate_clause (list, OMP_CLAUSE_DEFAULT, "default");
19734 c = build_omp_clause (OMP_CLAUSE_DEFAULT);
19735 OMP_CLAUSE_CHAIN (c) = list;
19736 OMP_CLAUSE_DEFAULT_KIND (c) = kind;
19742 if ( expression ) */
19745 cp_parser_omp_clause_if (cp_parser *parser, tree list)
19749 if (!cp_parser_require (parser, CPP_OPEN_PAREN, "%<(%>"))
19752 t = cp_parser_condition (parser);
19754 if (t == error_mark_node
19755 || !cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>"))
19756 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
19757 /*or_comma=*/false,
19758 /*consume_paren=*/true);
19760 check_no_duplicate_clause (list, OMP_CLAUSE_IF, "if");
19762 c = build_omp_clause (OMP_CLAUSE_IF);
19763 OMP_CLAUSE_IF_EXPR (c) = t;
19764 OMP_CLAUSE_CHAIN (c) = list;
19773 cp_parser_omp_clause_nowait (cp_parser *parser ATTRIBUTE_UNUSED, tree list)
19777 check_no_duplicate_clause (list, OMP_CLAUSE_NOWAIT, "nowait");
19779 c = build_omp_clause (OMP_CLAUSE_NOWAIT);
19780 OMP_CLAUSE_CHAIN (c) = list;
19785 num_threads ( expression ) */
19788 cp_parser_omp_clause_num_threads (cp_parser *parser, tree list)
19792 if (!cp_parser_require (parser, CPP_OPEN_PAREN, "%<(%>"))
19795 t = cp_parser_expression (parser, false);
19797 if (t == error_mark_node
19798 || !cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>"))
19799 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
19800 /*or_comma=*/false,
19801 /*consume_paren=*/true);
19803 check_no_duplicate_clause (list, OMP_CLAUSE_NUM_THREADS, "num_threads");
19805 c = build_omp_clause (OMP_CLAUSE_NUM_THREADS);
19806 OMP_CLAUSE_NUM_THREADS_EXPR (c) = t;
19807 OMP_CLAUSE_CHAIN (c) = list;
19816 cp_parser_omp_clause_ordered (cp_parser *parser ATTRIBUTE_UNUSED, tree list)
19820 check_no_duplicate_clause (list, OMP_CLAUSE_ORDERED, "ordered");
19822 c = build_omp_clause (OMP_CLAUSE_ORDERED);
19823 OMP_CLAUSE_CHAIN (c) = list;
19828 reduction ( reduction-operator : variable-list )
19830 reduction-operator:
19831 One of: + * - & ^ | && || */
19834 cp_parser_omp_clause_reduction (cp_parser *parser, tree list)
19836 enum tree_code code;
19839 if (!cp_parser_require (parser, CPP_OPEN_PAREN, "%<(%>"))
19842 switch (cp_lexer_peek_token (parser->lexer)->type)
19854 code = BIT_AND_EXPR;
19857 code = BIT_XOR_EXPR;
19860 code = BIT_IOR_EXPR;
19863 code = TRUTH_ANDIF_EXPR;
19866 code = TRUTH_ORIF_EXPR;
19869 cp_parser_error (parser, "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, "
19870 "%<|%>, %<&&%>, or %<||%>");
19872 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
19873 /*or_comma=*/false,
19874 /*consume_paren=*/true);
19877 cp_lexer_consume_token (parser->lexer);
19879 if (!cp_parser_require (parser, CPP_COLON, "%<:%>"))
19882 nlist = cp_parser_omp_var_list_no_open (parser, OMP_CLAUSE_REDUCTION, list);
19883 for (c = nlist; c != list; c = OMP_CLAUSE_CHAIN (c))
19884 OMP_CLAUSE_REDUCTION_CODE (c) = code;
19890 schedule ( schedule-kind )
19891 schedule ( schedule-kind , expression )
19894 static | dynamic | guided | runtime | auto */
19897 cp_parser_omp_clause_schedule (cp_parser *parser, tree list)
19901 if (!cp_parser_require (parser, CPP_OPEN_PAREN, "%<(%>"))
19904 c = build_omp_clause (OMP_CLAUSE_SCHEDULE);
19906 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
19908 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
19909 const char *p = IDENTIFIER_POINTER (id);
19914 if (strcmp ("dynamic", p) != 0)
19916 OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_DYNAMIC;
19920 if (strcmp ("guided", p) != 0)
19922 OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_GUIDED;
19926 if (strcmp ("runtime", p) != 0)
19928 OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_RUNTIME;
19935 else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_STATIC))
19936 OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_STATIC;
19937 else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_AUTO))
19938 OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_AUTO;
19941 cp_lexer_consume_token (parser->lexer);
19943 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
19945 cp_lexer_consume_token (parser->lexer);
19947 t = cp_parser_assignment_expression (parser, false);
19949 if (t == error_mark_node)
19951 else if (OMP_CLAUSE_SCHEDULE_KIND (c) == OMP_CLAUSE_SCHEDULE_RUNTIME)
19952 error ("schedule %<runtime%> does not take "
19953 "a %<chunk_size%> parameter");
19954 else if (OMP_CLAUSE_SCHEDULE_KIND (c) == OMP_CLAUSE_SCHEDULE_AUTO)
19955 error ("schedule %<auto%> does not take "
19956 "a %<chunk_size%> parameter");
19958 OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c) = t;
19960 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>"))
19963 else if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "%<,%> or %<)%>"))
19966 check_no_duplicate_clause (list, OMP_CLAUSE_SCHEDULE, "schedule");
19967 OMP_CLAUSE_CHAIN (c) = list;
19971 cp_parser_error (parser, "invalid schedule kind");
19973 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
19974 /*or_comma=*/false,
19975 /*consume_paren=*/true);
19983 cp_parser_omp_clause_untied (cp_parser *parser ATTRIBUTE_UNUSED, tree list)
19987 check_no_duplicate_clause (list, OMP_CLAUSE_UNTIED, "untied");
19989 c = build_omp_clause (OMP_CLAUSE_UNTIED);
19990 OMP_CLAUSE_CHAIN (c) = list;
19994 /* Parse all OpenMP clauses. The set clauses allowed by the directive
19995 is a bitmask in MASK. Return the list of clauses found; the result
19996 of clause default goes in *pdefault. */
19999 cp_parser_omp_all_clauses (cp_parser *parser, unsigned int mask,
20000 const char *where, cp_token *pragma_tok)
20002 tree clauses = NULL;
20005 while (cp_lexer_next_token_is_not (parser->lexer, CPP_PRAGMA_EOL))
20007 pragma_omp_clause c_kind;
20008 const char *c_name;
20009 tree prev = clauses;
20011 if (!first && cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
20012 cp_lexer_consume_token (parser->lexer);
20014 c_kind = cp_parser_omp_clause_name (parser);
20019 case PRAGMA_OMP_CLAUSE_COLLAPSE:
20020 clauses = cp_parser_omp_clause_collapse (parser, clauses);
20021 c_name = "collapse";
20023 case PRAGMA_OMP_CLAUSE_COPYIN:
20024 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_COPYIN, clauses);
20027 case PRAGMA_OMP_CLAUSE_COPYPRIVATE:
20028 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_COPYPRIVATE,
20030 c_name = "copyprivate";
20032 case PRAGMA_OMP_CLAUSE_DEFAULT:
20033 clauses = cp_parser_omp_clause_default (parser, clauses);
20034 c_name = "default";
20036 case PRAGMA_OMP_CLAUSE_FIRSTPRIVATE:
20037 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_FIRSTPRIVATE,
20039 c_name = "firstprivate";
20041 case PRAGMA_OMP_CLAUSE_IF:
20042 clauses = cp_parser_omp_clause_if (parser, clauses);
20045 case PRAGMA_OMP_CLAUSE_LASTPRIVATE:
20046 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_LASTPRIVATE,
20048 c_name = "lastprivate";
20050 case PRAGMA_OMP_CLAUSE_NOWAIT:
20051 clauses = cp_parser_omp_clause_nowait (parser, clauses);
20054 case PRAGMA_OMP_CLAUSE_NUM_THREADS:
20055 clauses = cp_parser_omp_clause_num_threads (parser, clauses);
20056 c_name = "num_threads";
20058 case PRAGMA_OMP_CLAUSE_ORDERED:
20059 clauses = cp_parser_omp_clause_ordered (parser, clauses);
20060 c_name = "ordered";
20062 case PRAGMA_OMP_CLAUSE_PRIVATE:
20063 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_PRIVATE,
20065 c_name = "private";
20067 case PRAGMA_OMP_CLAUSE_REDUCTION:
20068 clauses = cp_parser_omp_clause_reduction (parser, clauses);
20069 c_name = "reduction";
20071 case PRAGMA_OMP_CLAUSE_SCHEDULE:
20072 clauses = cp_parser_omp_clause_schedule (parser, clauses);
20073 c_name = "schedule";
20075 case PRAGMA_OMP_CLAUSE_SHARED:
20076 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_SHARED,
20080 case PRAGMA_OMP_CLAUSE_UNTIED:
20081 clauses = cp_parser_omp_clause_untied (parser, clauses);
20085 cp_parser_error (parser, "expected %<#pragma omp%> clause");
20089 if (((mask >> c_kind) & 1) == 0)
20091 /* Remove the invalid clause(s) from the list to avoid
20092 confusing the rest of the compiler. */
20094 error ("%qs is not valid for %qs", c_name, where);
20098 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
20099 return finish_omp_clauses (clauses);
20106 In practice, we're also interested in adding the statement to an
20107 outer node. So it is convenient if we work around the fact that
20108 cp_parser_statement calls add_stmt. */
20111 cp_parser_begin_omp_structured_block (cp_parser *parser)
20113 unsigned save = parser->in_statement;
20115 /* Only move the values to IN_OMP_BLOCK if they weren't false.
20116 This preserves the "not within loop or switch" style error messages
20117 for nonsense cases like
20123 if (parser->in_statement)
20124 parser->in_statement = IN_OMP_BLOCK;
20130 cp_parser_end_omp_structured_block (cp_parser *parser, unsigned save)
20132 parser->in_statement = save;
20136 cp_parser_omp_structured_block (cp_parser *parser)
20138 tree stmt = begin_omp_structured_block ();
20139 unsigned int save = cp_parser_begin_omp_structured_block (parser);
20141 cp_parser_statement (parser, NULL_TREE, false, NULL);
20143 cp_parser_end_omp_structured_block (parser, save);
20144 return finish_omp_structured_block (stmt);
20148 # pragma omp atomic new-line
20152 x binop= expr | x++ | ++x | x-- | --x
20154 +, *, -, /, &, ^, |, <<, >>
20156 where x is an lvalue expression with scalar type. */
20159 cp_parser_omp_atomic (cp_parser *parser, cp_token *pragma_tok)
20162 enum tree_code code;
20164 cp_parser_require_pragma_eol (parser, pragma_tok);
20166 lhs = cp_parser_unary_expression (parser, /*address_p=*/false,
20168 switch (TREE_CODE (lhs))
20173 case PREINCREMENT_EXPR:
20174 case POSTINCREMENT_EXPR:
20175 lhs = TREE_OPERAND (lhs, 0);
20177 rhs = integer_one_node;
20180 case PREDECREMENT_EXPR:
20181 case POSTDECREMENT_EXPR:
20182 lhs = TREE_OPERAND (lhs, 0);
20184 rhs = integer_one_node;
20188 switch (cp_lexer_peek_token (parser->lexer)->type)
20194 code = TRUNC_DIV_EXPR;
20202 case CPP_LSHIFT_EQ:
20203 code = LSHIFT_EXPR;
20205 case CPP_RSHIFT_EQ:
20206 code = RSHIFT_EXPR;
20209 code = BIT_AND_EXPR;
20212 code = BIT_IOR_EXPR;
20215 code = BIT_XOR_EXPR;
20218 cp_parser_error (parser,
20219 "invalid operator for %<#pragma omp atomic%>");
20222 cp_lexer_consume_token (parser->lexer);
20224 rhs = cp_parser_expression (parser, false);
20225 if (rhs == error_mark_node)
20229 finish_omp_atomic (code, lhs, rhs);
20230 cp_parser_consume_semicolon_at_end_of_statement (parser);
20234 cp_parser_skip_to_end_of_block_or_statement (parser);
20239 # pragma omp barrier new-line */
20242 cp_parser_omp_barrier (cp_parser *parser, cp_token *pragma_tok)
20244 cp_parser_require_pragma_eol (parser, pragma_tok);
20245 finish_omp_barrier ();
20249 # pragma omp critical [(name)] new-line
20250 structured-block */
20253 cp_parser_omp_critical (cp_parser *parser, cp_token *pragma_tok)
20255 tree stmt, name = NULL;
20257 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
20259 cp_lexer_consume_token (parser->lexer);
20261 name = cp_parser_identifier (parser);
20263 if (name == error_mark_node
20264 || !cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>"))
20265 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
20266 /*or_comma=*/false,
20267 /*consume_paren=*/true);
20268 if (name == error_mark_node)
20271 cp_parser_require_pragma_eol (parser, pragma_tok);
20273 stmt = cp_parser_omp_structured_block (parser);
20274 return c_finish_omp_critical (stmt, name);
20278 # pragma omp flush flush-vars[opt] new-line
20281 ( variable-list ) */
20284 cp_parser_omp_flush (cp_parser *parser, cp_token *pragma_tok)
20286 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
20287 (void) cp_parser_omp_var_list (parser, 0, NULL);
20288 cp_parser_require_pragma_eol (parser, pragma_tok);
20290 finish_omp_flush ();
20293 /* Helper function, to parse omp for increment expression. */
20296 cp_parser_omp_for_cond (cp_parser *parser, tree decl)
20298 tree lhs = cp_parser_cast_expression (parser, false, false), rhs;
20304 cp_parser_skip_to_end_of_statement (parser);
20305 return error_mark_node;
20308 token = cp_lexer_peek_token (parser->lexer);
20309 op = binops_by_token [token->type].tree_type;
20318 cp_parser_skip_to_end_of_statement (parser);
20319 return error_mark_node;
20322 cp_lexer_consume_token (parser->lexer);
20323 rhs = cp_parser_binary_expression (parser, false,
20324 PREC_RELATIONAL_EXPRESSION);
20325 if (rhs == error_mark_node
20326 || cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
20328 cp_parser_skip_to_end_of_statement (parser);
20329 return error_mark_node;
20332 return build2 (op, boolean_type_node, lhs, rhs);
20335 /* Helper function, to parse omp for increment expression. */
20338 cp_parser_omp_for_incr (cp_parser *parser, tree decl)
20340 cp_token *token = cp_lexer_peek_token (parser->lexer);
20346 if (token->type == CPP_PLUS_PLUS || token->type == CPP_MINUS_MINUS)
20348 op = (token->type == CPP_PLUS_PLUS
20349 ? PREINCREMENT_EXPR : PREDECREMENT_EXPR);
20350 cp_lexer_consume_token (parser->lexer);
20351 lhs = cp_parser_cast_expression (parser, false, false);
20353 return error_mark_node;
20354 return build2 (op, TREE_TYPE (decl), decl, NULL_TREE);
20357 lhs = cp_parser_primary_expression (parser, false, false, false, &idk);
20359 return error_mark_node;
20361 token = cp_lexer_peek_token (parser->lexer);
20362 if (token->type == CPP_PLUS_PLUS || token->type == CPP_MINUS_MINUS)
20364 op = (token->type == CPP_PLUS_PLUS
20365 ? POSTINCREMENT_EXPR : POSTDECREMENT_EXPR);
20366 cp_lexer_consume_token (parser->lexer);
20367 return build2 (op, TREE_TYPE (decl), decl, NULL_TREE);
20370 op = cp_parser_assignment_operator_opt (parser);
20371 if (op == ERROR_MARK)
20372 return error_mark_node;
20374 if (op != NOP_EXPR)
20376 rhs = cp_parser_assignment_expression (parser, false);
20377 rhs = build2 (op, TREE_TYPE (decl), decl, rhs);
20378 return build2 (MODIFY_EXPR, TREE_TYPE (decl), decl, rhs);
20381 lhs = cp_parser_binary_expression (parser, false,
20382 PREC_ADDITIVE_EXPRESSION);
20383 token = cp_lexer_peek_token (parser->lexer);
20384 decl_first = lhs == decl;
20387 if (token->type != CPP_PLUS
20388 && token->type != CPP_MINUS)
20389 return error_mark_node;
20393 op = token->type == CPP_PLUS ? PLUS_EXPR : MINUS_EXPR;
20394 cp_lexer_consume_token (parser->lexer);
20395 rhs = cp_parser_binary_expression (parser, false,
20396 PREC_ADDITIVE_EXPRESSION);
20397 token = cp_lexer_peek_token (parser->lexer);
20398 if (token->type == CPP_PLUS || token->type == CPP_MINUS || decl_first)
20400 if (lhs == NULL_TREE)
20402 if (op == PLUS_EXPR)
20405 lhs = build_x_unary_op (NEGATE_EXPR, rhs, tf_warning_or_error);
20408 lhs = build_x_binary_op (op, lhs, ERROR_MARK, rhs, ERROR_MARK,
20409 NULL, tf_warning_or_error);
20412 while (token->type == CPP_PLUS || token->type == CPP_MINUS);
20416 if (rhs != decl || op == MINUS_EXPR)
20417 return error_mark_node;
20418 rhs = build2 (op, TREE_TYPE (decl), lhs, decl);
20421 rhs = build2 (PLUS_EXPR, TREE_TYPE (decl), decl, lhs);
20423 return build2 (MODIFY_EXPR, TREE_TYPE (decl), decl, rhs);
20426 /* Parse the restricted form of the for statement allowed by OpenMP. */
20429 cp_parser_omp_for_loop (cp_parser *parser, tree clauses, tree *par_clauses)
20431 tree init, cond, incr, body, decl, pre_body = NULL_TREE, ret;
20432 tree for_block = NULL_TREE, real_decl, initv, condv, incrv, declv;
20433 tree this_pre_body, cl;
20434 location_t loc_first;
20435 bool collapse_err = false;
20436 int i, collapse = 1, nbraces = 0;
20438 for (cl = clauses; cl; cl = OMP_CLAUSE_CHAIN (cl))
20439 if (OMP_CLAUSE_CODE (cl) == OMP_CLAUSE_COLLAPSE)
20440 collapse = tree_low_cst (OMP_CLAUSE_COLLAPSE_EXPR (cl), 0);
20442 gcc_assert (collapse >= 1);
20444 declv = make_tree_vec (collapse);
20445 initv = make_tree_vec (collapse);
20446 condv = make_tree_vec (collapse);
20447 incrv = make_tree_vec (collapse);
20449 loc_first = cp_lexer_peek_token (parser->lexer)->location;
20451 for (i = 0; i < collapse; i++)
20453 int bracecount = 0;
20454 bool add_private_clause = false;
20457 if (!cp_lexer_next_token_is_keyword (parser->lexer, RID_FOR))
20459 cp_parser_error (parser, "for statement expected");
20462 loc = cp_lexer_consume_token (parser->lexer)->location;
20464 if (!cp_parser_require (parser, CPP_OPEN_PAREN, "%<(%>"))
20467 init = decl = real_decl = NULL;
20468 this_pre_body = push_stmt_list ();
20469 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
20471 cp_decl_specifier_seq type_specifiers;
20473 /* First, try to parse as an initialized declaration. See
20474 cp_parser_condition, from whence the bulk of this is copied. */
20476 cp_parser_parse_tentatively (parser);
20477 cp_parser_type_specifier_seq (parser, /*is_condition=*/false,
20479 if (!cp_parser_error_occurred (parser))
20481 tree asm_specification, attributes;
20482 cp_declarator *declarator;
20484 declarator = cp_parser_declarator (parser,
20485 CP_PARSER_DECLARATOR_NAMED,
20486 /*ctor_dtor_or_conv_p=*/NULL,
20487 /*parenthesized_p=*/NULL,
20488 /*member_p=*/false);
20489 attributes = cp_parser_attributes_opt (parser);
20490 asm_specification = cp_parser_asm_specification_opt (parser);
20492 if (cp_lexer_next_token_is_not (parser->lexer, CPP_EQ))
20493 cp_parser_require (parser, CPP_EQ, "%<=%>");
20494 if (cp_parser_parse_definitely (parser))
20498 decl = start_decl (declarator, &type_specifiers,
20499 /*initialized_p=*/false, attributes,
20500 /*prefix_attributes=*/NULL_TREE,
20503 if (CLASS_TYPE_P (TREE_TYPE (decl))
20504 || type_dependent_expression_p (decl))
20506 bool is_parenthesized_init, is_non_constant_init;
20508 init = cp_parser_initializer (parser,
20509 &is_parenthesized_init,
20510 &is_non_constant_init);
20512 cp_finish_decl (decl, init, !is_non_constant_init,
20514 LOOKUP_ONLYCONVERTING);
20515 if (CLASS_TYPE_P (TREE_TYPE (decl)))
20518 = tree_cons (NULL, this_pre_body, for_block);
20522 init = pop_stmt_list (this_pre_body);
20523 this_pre_body = NULL_TREE;
20527 cp_parser_require (parser, CPP_EQ, "%<=%>");
20528 init = cp_parser_assignment_expression (parser, false);
20530 if (TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE)
20531 init = error_mark_node;
20533 cp_finish_decl (decl, NULL_TREE,
20534 /*init_const_expr_p=*/false,
20536 LOOKUP_ONLYCONVERTING);
20540 pop_scope (pushed_scope);
20544 cp_parser_abort_tentative_parse (parser);
20546 /* If parsing as an initialized declaration failed, try again as
20547 a simple expression. */
20551 cp_parser_parse_tentatively (parser);
20552 decl = cp_parser_primary_expression (parser, false, false,
20554 if (!cp_parser_error_occurred (parser)
20557 && CLASS_TYPE_P (TREE_TYPE (decl)))
20561 cp_parser_parse_definitely (parser);
20562 cp_parser_require (parser, CPP_EQ, "%<=%>");
20563 rhs = cp_parser_assignment_expression (parser, false);
20564 finish_expr_stmt (build_x_modify_expr (decl, NOP_EXPR,
20566 tf_warning_or_error));
20567 add_private_clause = true;
20572 cp_parser_abort_tentative_parse (parser);
20573 init = cp_parser_expression (parser, false);
20576 if (TREE_CODE (init) == MODIFY_EXPR
20577 || TREE_CODE (init) == MODOP_EXPR)
20578 real_decl = TREE_OPERAND (init, 0);
20583 cp_parser_require (parser, CPP_SEMICOLON, "%<;%>");
20586 this_pre_body = pop_stmt_list (this_pre_body);
20590 pre_body = push_stmt_list ();
20592 add_stmt (this_pre_body);
20593 pre_body = pop_stmt_list (pre_body);
20596 pre_body = this_pre_body;
20601 if (par_clauses != NULL && real_decl != NULL_TREE)
20604 for (c = par_clauses; *c ; )
20605 if (OMP_CLAUSE_CODE (*c) == OMP_CLAUSE_FIRSTPRIVATE
20606 && OMP_CLAUSE_DECL (*c) == real_decl)
20608 error ("%Hiteration variable %qD should not be firstprivate",
20610 *c = OMP_CLAUSE_CHAIN (*c);
20612 else if (OMP_CLAUSE_CODE (*c) == OMP_CLAUSE_LASTPRIVATE
20613 && OMP_CLAUSE_DECL (*c) == real_decl)
20615 /* Add lastprivate (decl) clause to OMP_FOR_CLAUSES,
20616 change it to shared (decl) in OMP_PARALLEL_CLAUSES. */
20617 tree l = build_omp_clause (OMP_CLAUSE_LASTPRIVATE);
20618 OMP_CLAUSE_DECL (l) = real_decl;
20619 OMP_CLAUSE_CHAIN (l) = clauses;
20620 CP_OMP_CLAUSE_INFO (l) = CP_OMP_CLAUSE_INFO (*c);
20622 OMP_CLAUSE_SET_CODE (*c, OMP_CLAUSE_SHARED);
20623 CP_OMP_CLAUSE_INFO (*c) = NULL;
20624 add_private_clause = false;
20628 if (OMP_CLAUSE_CODE (*c) == OMP_CLAUSE_PRIVATE
20629 && OMP_CLAUSE_DECL (*c) == real_decl)
20630 add_private_clause = false;
20631 c = &OMP_CLAUSE_CHAIN (*c);
20635 if (add_private_clause)
20638 for (c = clauses; c ; c = OMP_CLAUSE_CHAIN (c))
20640 if ((OMP_CLAUSE_CODE (c) == OMP_CLAUSE_PRIVATE
20641 || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LASTPRIVATE)
20642 && OMP_CLAUSE_DECL (c) == decl)
20644 else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_FIRSTPRIVATE
20645 && OMP_CLAUSE_DECL (c) == decl)
20646 error ("%Hiteration variable %qD should not be firstprivate",
20648 else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION
20649 && OMP_CLAUSE_DECL (c) == decl)
20650 error ("%Hiteration variable %qD should not be reduction",
20655 c = build_omp_clause (OMP_CLAUSE_PRIVATE);
20656 OMP_CLAUSE_DECL (c) = decl;
20657 c = finish_omp_clauses (c);
20660 OMP_CLAUSE_CHAIN (c) = clauses;
20667 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
20669 /* If decl is an iterator, preserve LHS and RHS of the relational
20670 expr until finish_omp_for. */
20672 && (type_dependent_expression_p (decl)
20673 || CLASS_TYPE_P (TREE_TYPE (decl))))
20674 cond = cp_parser_omp_for_cond (parser, decl);
20676 cond = cp_parser_condition (parser);
20678 cp_parser_require (parser, CPP_SEMICOLON, "%<;%>");
20681 if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
20683 /* If decl is an iterator, preserve the operator on decl
20684 until finish_omp_for. */
20686 && (type_dependent_expression_p (decl)
20687 || CLASS_TYPE_P (TREE_TYPE (decl))))
20688 incr = cp_parser_omp_for_incr (parser, decl);
20690 incr = cp_parser_expression (parser, false);
20693 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>"))
20694 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
20695 /*or_comma=*/false,
20696 /*consume_paren=*/true);
20698 TREE_VEC_ELT (declv, i) = decl;
20699 TREE_VEC_ELT (initv, i) = init;
20700 TREE_VEC_ELT (condv, i) = cond;
20701 TREE_VEC_ELT (incrv, i) = incr;
20703 if (i == collapse - 1)
20706 /* FIXME: OpenMP 3.0 draft isn't very clear on what exactly is allowed
20707 in between the collapsed for loops to be still considered perfectly
20708 nested. Hopefully the final version clarifies this.
20709 For now handle (multiple) {'s and empty statements. */
20710 cp_parser_parse_tentatively (parser);
20713 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_FOR))
20715 else if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
20717 cp_lexer_consume_token (parser->lexer);
20720 else if (bracecount
20721 && cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
20722 cp_lexer_consume_token (parser->lexer);
20725 loc = cp_lexer_peek_token (parser->lexer)->location;
20726 error ("%Hnot enough collapsed for loops", &loc);
20727 collapse_err = true;
20728 cp_parser_abort_tentative_parse (parser);
20737 cp_parser_parse_definitely (parser);
20738 nbraces += bracecount;
20742 /* Note that we saved the original contents of this flag when we entered
20743 the structured block, and so we don't need to re-save it here. */
20744 parser->in_statement = IN_OMP_FOR;
20746 /* Note that the grammar doesn't call for a structured block here,
20747 though the loop as a whole is a structured block. */
20748 body = push_stmt_list ();
20749 cp_parser_statement (parser, NULL_TREE, false, NULL);
20750 body = pop_stmt_list (body);
20752 if (declv == NULL_TREE)
20755 ret = finish_omp_for (loc_first, declv, initv, condv, incrv, body,
20756 pre_body, clauses);
20760 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
20762 cp_lexer_consume_token (parser->lexer);
20765 else if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
20766 cp_lexer_consume_token (parser->lexer);
20770 error ("collapsed loops not perfectly nested");
20771 collapse_err = true;
20772 cp_parser_statement_seq_opt (parser, NULL);
20773 cp_parser_require (parser, CPP_CLOSE_BRACE, "%<}%>");
20779 add_stmt (pop_stmt_list (TREE_VALUE (for_block)));
20780 for_block = TREE_CHAIN (for_block);
20787 #pragma omp for for-clause[optseq] new-line
20790 #define OMP_FOR_CLAUSE_MASK \
20791 ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
20792 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
20793 | (1u << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
20794 | (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \
20795 | (1u << PRAGMA_OMP_CLAUSE_ORDERED) \
20796 | (1u << PRAGMA_OMP_CLAUSE_SCHEDULE) \
20797 | (1u << PRAGMA_OMP_CLAUSE_NOWAIT) \
20798 | (1u << PRAGMA_OMP_CLAUSE_COLLAPSE))
20801 cp_parser_omp_for (cp_parser *parser, cp_token *pragma_tok)
20803 tree clauses, sb, ret;
20806 clauses = cp_parser_omp_all_clauses (parser, OMP_FOR_CLAUSE_MASK,
20807 "#pragma omp for", pragma_tok);
20809 sb = begin_omp_structured_block ();
20810 save = cp_parser_begin_omp_structured_block (parser);
20812 ret = cp_parser_omp_for_loop (parser, clauses, NULL);
20814 cp_parser_end_omp_structured_block (parser, save);
20815 add_stmt (finish_omp_structured_block (sb));
20821 # pragma omp master new-line
20822 structured-block */
20825 cp_parser_omp_master (cp_parser *parser, cp_token *pragma_tok)
20827 cp_parser_require_pragma_eol (parser, pragma_tok);
20828 return c_finish_omp_master (cp_parser_omp_structured_block (parser));
20832 # pragma omp ordered new-line
20833 structured-block */
20836 cp_parser_omp_ordered (cp_parser *parser, cp_token *pragma_tok)
20838 cp_parser_require_pragma_eol (parser, pragma_tok);
20839 return c_finish_omp_ordered (cp_parser_omp_structured_block (parser));
20845 { section-sequence }
20848 section-directive[opt] structured-block
20849 section-sequence section-directive structured-block */
20852 cp_parser_omp_sections_scope (cp_parser *parser)
20854 tree stmt, substmt;
20855 bool error_suppress = false;
20858 if (!cp_parser_require (parser, CPP_OPEN_BRACE, "%<{%>"))
20861 stmt = push_stmt_list ();
20863 if (cp_lexer_peek_token (parser->lexer)->pragma_kind != PRAGMA_OMP_SECTION)
20867 substmt = begin_omp_structured_block ();
20868 save = cp_parser_begin_omp_structured_block (parser);
20872 cp_parser_statement (parser, NULL_TREE, false, NULL);
20874 tok = cp_lexer_peek_token (parser->lexer);
20875 if (tok->pragma_kind == PRAGMA_OMP_SECTION)
20877 if (tok->type == CPP_CLOSE_BRACE)
20879 if (tok->type == CPP_EOF)
20883 cp_parser_end_omp_structured_block (parser, save);
20884 substmt = finish_omp_structured_block (substmt);
20885 substmt = build1 (OMP_SECTION, void_type_node, substmt);
20886 add_stmt (substmt);
20891 tok = cp_lexer_peek_token (parser->lexer);
20892 if (tok->type == CPP_CLOSE_BRACE)
20894 if (tok->type == CPP_EOF)
20897 if (tok->pragma_kind == PRAGMA_OMP_SECTION)
20899 cp_lexer_consume_token (parser->lexer);
20900 cp_parser_require_pragma_eol (parser, tok);
20901 error_suppress = false;
20903 else if (!error_suppress)
20905 cp_parser_error (parser, "expected %<#pragma omp section%> or %<}%>");
20906 error_suppress = true;
20909 substmt = cp_parser_omp_structured_block (parser);
20910 substmt = build1 (OMP_SECTION, void_type_node, substmt);
20911 add_stmt (substmt);
20913 cp_parser_require (parser, CPP_CLOSE_BRACE, "%<}%>");
20915 substmt = pop_stmt_list (stmt);
20917 stmt = make_node (OMP_SECTIONS);
20918 TREE_TYPE (stmt) = void_type_node;
20919 OMP_SECTIONS_BODY (stmt) = substmt;
20926 # pragma omp sections sections-clause[optseq] newline
20929 #define OMP_SECTIONS_CLAUSE_MASK \
20930 ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
20931 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
20932 | (1u << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
20933 | (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \
20934 | (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
20937 cp_parser_omp_sections (cp_parser *parser, cp_token *pragma_tok)
20941 clauses = cp_parser_omp_all_clauses (parser, OMP_SECTIONS_CLAUSE_MASK,
20942 "#pragma omp sections", pragma_tok);
20944 ret = cp_parser_omp_sections_scope (parser);
20946 OMP_SECTIONS_CLAUSES (ret) = clauses;
20952 # pragma parallel parallel-clause new-line
20953 # pragma parallel for parallel-for-clause new-line
20954 # pragma parallel sections parallel-sections-clause new-line */
20956 #define OMP_PARALLEL_CLAUSE_MASK \
20957 ( (1u << PRAGMA_OMP_CLAUSE_IF) \
20958 | (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
20959 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
20960 | (1u << PRAGMA_OMP_CLAUSE_DEFAULT) \
20961 | (1u << PRAGMA_OMP_CLAUSE_SHARED) \
20962 | (1u << PRAGMA_OMP_CLAUSE_COPYIN) \
20963 | (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \
20964 | (1u << PRAGMA_OMP_CLAUSE_NUM_THREADS))
20967 cp_parser_omp_parallel (cp_parser *parser, cp_token *pragma_tok)
20969 enum pragma_kind p_kind = PRAGMA_OMP_PARALLEL;
20970 const char *p_name = "#pragma omp parallel";
20971 tree stmt, clauses, par_clause, ws_clause, block;
20972 unsigned int mask = OMP_PARALLEL_CLAUSE_MASK;
20975 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_FOR))
20977 cp_lexer_consume_token (parser->lexer);
20978 p_kind = PRAGMA_OMP_PARALLEL_FOR;
20979 p_name = "#pragma omp parallel for";
20980 mask |= OMP_FOR_CLAUSE_MASK;
20981 mask &= ~(1u << PRAGMA_OMP_CLAUSE_NOWAIT);
20983 else if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
20985 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
20986 const char *p = IDENTIFIER_POINTER (id);
20987 if (strcmp (p, "sections") == 0)
20989 cp_lexer_consume_token (parser->lexer);
20990 p_kind = PRAGMA_OMP_PARALLEL_SECTIONS;
20991 p_name = "#pragma omp parallel sections";
20992 mask |= OMP_SECTIONS_CLAUSE_MASK;
20993 mask &= ~(1u << PRAGMA_OMP_CLAUSE_NOWAIT);
20997 clauses = cp_parser_omp_all_clauses (parser, mask, p_name, pragma_tok);
20998 block = begin_omp_parallel ();
20999 save = cp_parser_begin_omp_structured_block (parser);
21003 case PRAGMA_OMP_PARALLEL:
21004 cp_parser_statement (parser, NULL_TREE, false, NULL);
21005 par_clause = clauses;
21008 case PRAGMA_OMP_PARALLEL_FOR:
21009 c_split_parallel_clauses (clauses, &par_clause, &ws_clause);
21010 cp_parser_omp_for_loop (parser, ws_clause, &par_clause);
21013 case PRAGMA_OMP_PARALLEL_SECTIONS:
21014 c_split_parallel_clauses (clauses, &par_clause, &ws_clause);
21015 stmt = cp_parser_omp_sections_scope (parser);
21017 OMP_SECTIONS_CLAUSES (stmt) = ws_clause;
21021 gcc_unreachable ();
21024 cp_parser_end_omp_structured_block (parser, save);
21025 stmt = finish_omp_parallel (par_clause, block);
21026 if (p_kind != PRAGMA_OMP_PARALLEL)
21027 OMP_PARALLEL_COMBINED (stmt) = 1;
21032 # pragma omp single single-clause[optseq] new-line
21033 structured-block */
21035 #define OMP_SINGLE_CLAUSE_MASK \
21036 ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
21037 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
21038 | (1u << PRAGMA_OMP_CLAUSE_COPYPRIVATE) \
21039 | (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
21042 cp_parser_omp_single (cp_parser *parser, cp_token *pragma_tok)
21044 tree stmt = make_node (OMP_SINGLE);
21045 TREE_TYPE (stmt) = void_type_node;
21047 OMP_SINGLE_CLAUSES (stmt)
21048 = cp_parser_omp_all_clauses (parser, OMP_SINGLE_CLAUSE_MASK,
21049 "#pragma omp single", pragma_tok);
21050 OMP_SINGLE_BODY (stmt) = cp_parser_omp_structured_block (parser);
21052 return add_stmt (stmt);
21056 # pragma omp task task-clause[optseq] new-line
21057 structured-block */
21059 #define OMP_TASK_CLAUSE_MASK \
21060 ( (1u << PRAGMA_OMP_CLAUSE_IF) \
21061 | (1u << PRAGMA_OMP_CLAUSE_UNTIED) \
21062 | (1u << PRAGMA_OMP_CLAUSE_DEFAULT) \
21063 | (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
21064 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
21065 | (1u << PRAGMA_OMP_CLAUSE_SHARED))
21068 cp_parser_omp_task (cp_parser *parser, cp_token *pragma_tok)
21070 tree clauses, block;
21073 clauses = cp_parser_omp_all_clauses (parser, OMP_TASK_CLAUSE_MASK,
21074 "#pragma omp task", pragma_tok);
21075 block = begin_omp_task ();
21076 save = cp_parser_begin_omp_structured_block (parser);
21077 cp_parser_statement (parser, NULL_TREE, false, NULL);
21078 cp_parser_end_omp_structured_block (parser, save);
21079 return finish_omp_task (clauses, block);
21083 # pragma omp taskwait new-line */
21086 cp_parser_omp_taskwait (cp_parser *parser, cp_token *pragma_tok)
21088 cp_parser_require_pragma_eol (parser, pragma_tok);
21089 finish_omp_taskwait ();
21093 # pragma omp threadprivate (variable-list) */
21096 cp_parser_omp_threadprivate (cp_parser *parser, cp_token *pragma_tok)
21100 vars = cp_parser_omp_var_list (parser, 0, NULL);
21101 cp_parser_require_pragma_eol (parser, pragma_tok);
21103 finish_omp_threadprivate (vars);
21106 /* Main entry point to OpenMP statement pragmas. */
21109 cp_parser_omp_construct (cp_parser *parser, cp_token *pragma_tok)
21113 switch (pragma_tok->pragma_kind)
21115 case PRAGMA_OMP_ATOMIC:
21116 cp_parser_omp_atomic (parser, pragma_tok);
21118 case PRAGMA_OMP_CRITICAL:
21119 stmt = cp_parser_omp_critical (parser, pragma_tok);
21121 case PRAGMA_OMP_FOR:
21122 stmt = cp_parser_omp_for (parser, pragma_tok);
21124 case PRAGMA_OMP_MASTER:
21125 stmt = cp_parser_omp_master (parser, pragma_tok);
21127 case PRAGMA_OMP_ORDERED:
21128 stmt = cp_parser_omp_ordered (parser, pragma_tok);
21130 case PRAGMA_OMP_PARALLEL:
21131 stmt = cp_parser_omp_parallel (parser, pragma_tok);
21133 case PRAGMA_OMP_SECTIONS:
21134 stmt = cp_parser_omp_sections (parser, pragma_tok);
21136 case PRAGMA_OMP_SINGLE:
21137 stmt = cp_parser_omp_single (parser, pragma_tok);
21139 case PRAGMA_OMP_TASK:
21140 stmt = cp_parser_omp_task (parser, pragma_tok);
21143 gcc_unreachable ();
21147 SET_EXPR_LOCATION (stmt, pragma_tok->location);
21152 static GTY (()) cp_parser *the_parser;
21155 /* Special handling for the first token or line in the file. The first
21156 thing in the file might be #pragma GCC pch_preprocess, which loads a
21157 PCH file, which is a GC collection point. So we need to handle this
21158 first pragma without benefit of an existing lexer structure.
21160 Always returns one token to the caller in *FIRST_TOKEN. This is
21161 either the true first token of the file, or the first token after
21162 the initial pragma. */
21165 cp_parser_initial_pragma (cp_token *first_token)
21169 cp_lexer_get_preprocessor_token (NULL, first_token);
21170 if (first_token->pragma_kind != PRAGMA_GCC_PCH_PREPROCESS)
21173 cp_lexer_get_preprocessor_token (NULL, first_token);
21174 if (first_token->type == CPP_STRING)
21176 name = first_token->u.value;
21178 cp_lexer_get_preprocessor_token (NULL, first_token);
21179 if (first_token->type != CPP_PRAGMA_EOL)
21180 error ("junk at end of %<#pragma GCC pch_preprocess%>");
21183 error ("expected string literal");
21185 /* Skip to the end of the pragma. */
21186 while (first_token->type != CPP_PRAGMA_EOL && first_token->type != CPP_EOF)
21187 cp_lexer_get_preprocessor_token (NULL, first_token);
21189 /* Now actually load the PCH file. */
21191 c_common_pch_pragma (parse_in, TREE_STRING_POINTER (name));
21193 /* Read one more token to return to our caller. We have to do this
21194 after reading the PCH file in, since its pointers have to be
21196 cp_lexer_get_preprocessor_token (NULL, first_token);
21199 /* Normal parsing of a pragma token. Here we can (and must) use the
21203 cp_parser_pragma (cp_parser *parser, enum pragma_context context)
21205 cp_token *pragma_tok;
21208 pragma_tok = cp_lexer_consume_token (parser->lexer);
21209 gcc_assert (pragma_tok->type == CPP_PRAGMA);
21210 parser->lexer->in_pragma = true;
21212 id = pragma_tok->pragma_kind;
21215 case PRAGMA_GCC_PCH_PREPROCESS:
21216 error ("%<#pragma GCC pch_preprocess%> must be first");
21219 case PRAGMA_OMP_BARRIER:
21222 case pragma_compound:
21223 cp_parser_omp_barrier (parser, pragma_tok);
21226 error ("%<#pragma omp barrier%> may only be "
21227 "used in compound statements");
21234 case PRAGMA_OMP_FLUSH:
21237 case pragma_compound:
21238 cp_parser_omp_flush (parser, pragma_tok);
21241 error ("%<#pragma omp flush%> may only be "
21242 "used in compound statements");
21249 case PRAGMA_OMP_TASKWAIT:
21252 case pragma_compound:
21253 cp_parser_omp_taskwait (parser, pragma_tok);
21256 error ("%<#pragma omp taskwait%> may only be "
21257 "used in compound statements");
21264 case PRAGMA_OMP_THREADPRIVATE:
21265 cp_parser_omp_threadprivate (parser, pragma_tok);
21268 case PRAGMA_OMP_ATOMIC:
21269 case PRAGMA_OMP_CRITICAL:
21270 case PRAGMA_OMP_FOR:
21271 case PRAGMA_OMP_MASTER:
21272 case PRAGMA_OMP_ORDERED:
21273 case PRAGMA_OMP_PARALLEL:
21274 case PRAGMA_OMP_SECTIONS:
21275 case PRAGMA_OMP_SINGLE:
21276 case PRAGMA_OMP_TASK:
21277 if (context == pragma_external)
21279 cp_parser_omp_construct (parser, pragma_tok);
21282 case PRAGMA_OMP_SECTION:
21283 error ("%<#pragma omp section%> may only be used in "
21284 "%<#pragma omp sections%> construct");
21288 gcc_assert (id >= PRAGMA_FIRST_EXTERNAL);
21289 c_invoke_pragma_handler (id);
21293 cp_parser_error (parser, "expected declaration specifiers");
21297 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
21301 /* The interface the pragma parsers have to the lexer. */
21304 pragma_lex (tree *value)
21307 enum cpp_ttype ret;
21309 tok = cp_lexer_peek_token (the_parser->lexer);
21312 *value = tok->u.value;
21314 if (ret == CPP_PRAGMA_EOL || ret == CPP_EOF)
21316 else if (ret == CPP_STRING)
21317 *value = cp_parser_string_literal (the_parser, false, false);
21320 cp_lexer_consume_token (the_parser->lexer);
21321 if (ret == CPP_KEYWORD)
21329 /* External interface. */
21331 /* Parse one entire translation unit. */
21334 c_parse_file (void)
21336 bool error_occurred;
21337 static bool already_called = false;
21339 if (already_called)
21341 sorry ("inter-module optimizations not implemented for C++");
21344 already_called = true;
21346 the_parser = cp_parser_new ();
21347 push_deferring_access_checks (flag_access_control
21348 ? dk_no_deferred : dk_no_check);
21349 error_occurred = cp_parser_translation_unit (the_parser);
21353 #include "gt-cp-parser.h"