2 Copyright (C) 2000, 2001, 2002, 2003, 2004,
3 2005 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 2, 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 COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
25 #include "coretypes.h"
27 #include "dyn-string.h"
35 #include "diagnostic.h"
45 /* The cp_lexer_* routines mediate between the lexer proper (in libcpp
46 and c-lex.c) and the C++ parser. */
48 /* A token's value and its associated deferred access checks and
51 struct tree_check GTY(())
53 /* The value associated with the token. */
55 /* The checks that have been associated with value. */
56 VEC (deferred_access_check, gc)* checks;
57 /* The token's qualifying scope (used when it is a
58 CPP_NESTED_NAME_SPECIFIER). */
59 tree qualifying_scope;
64 typedef struct cp_token GTY (())
66 /* The kind of token. */
67 ENUM_BITFIELD (cpp_ttype) type : 8;
68 /* If this token is a keyword, this value indicates which keyword.
69 Otherwise, this value is RID_MAX. */
70 ENUM_BITFIELD (rid) keyword : 8;
73 /* Identifier for the pragma. */
74 ENUM_BITFIELD (pragma_kind) pragma_kind : 6;
75 /* True if this token is from a system header. */
76 BOOL_BITFIELD in_system_header : 1;
77 /* True if this token is from a context where it is implicitly extern "C" */
78 BOOL_BITFIELD implicit_extern_c : 1;
79 /* True for a CPP_NAME token that is not a keyword (i.e., for which
80 KEYWORD is RID_MAX) iff this name was looked up and found to be
81 ambiguous. An error has already been reported. */
82 BOOL_BITFIELD ambiguous_p : 1;
83 /* The input file stack index at which this token was found. */
84 unsigned input_file_stack_index : INPUT_FILE_STACK_BITS;
85 /* The value associated with this token, if any. */
86 union cp_token_value {
87 /* Used for CPP_NESTED_NAME_SPECIFIER and CPP_TEMPLATE_ID. */
88 struct tree_check* GTY((tag ("1"))) tree_check_value;
89 /* Use for all other tokens. */
90 tree GTY((tag ("0"))) value;
91 } GTY((desc ("(%1.type == CPP_TEMPLATE_ID) || (%1.type == CPP_NESTED_NAME_SPECIFIER)"))) u;
92 /* The location at which this token was found. */
96 /* We use a stack of token pointer for saving token sets. */
97 typedef struct cp_token *cp_token_position;
98 DEF_VEC_P (cp_token_position);
99 DEF_VEC_ALLOC_P (cp_token_position,heap);
101 static const cp_token eof_token =
103 CPP_EOF, RID_MAX, 0, PRAGMA_NONE, 0, 0, false, 0, { NULL },
104 #if USE_MAPPED_LOCATION
111 /* The cp_lexer structure represents the C++ lexer. It is responsible
112 for managing the token stream from the preprocessor and supplying
113 it to the parser. Tokens are never added to the cp_lexer after
116 typedef struct cp_lexer GTY (())
118 /* The memory allocated for the buffer. NULL if this lexer does not
119 own the token buffer. */
120 cp_token * GTY ((length ("%h.buffer_length"))) buffer;
121 /* If the lexer owns the buffer, this is the number of tokens in the
123 size_t buffer_length;
125 /* A pointer just past the last available token. The tokens
126 in this lexer are [buffer, last_token). */
127 cp_token_position GTY ((skip)) last_token;
129 /* The next available token. If NEXT_TOKEN is &eof_token, then there are
130 no more available tokens. */
131 cp_token_position GTY ((skip)) next_token;
133 /* A stack indicating positions at which cp_lexer_save_tokens was
134 called. The top entry is the most recent position at which we
135 began saving tokens. If the stack is non-empty, we are saving
137 VEC(cp_token_position,heap) *GTY ((skip)) saved_tokens;
139 /* The next lexer in a linked list of lexers. */
140 struct cp_lexer *next;
142 /* True if we should output debugging information. */
145 /* True if we're in the context of parsing a pragma, and should not
146 increment past the end-of-line marker. */
150 /* cp_token_cache is a range of tokens. There is no need to represent
151 allocate heap memory for it, since tokens are never removed from the
152 lexer's array. There is also no need for the GC to walk through
153 a cp_token_cache, since everything in here is referenced through
156 typedef struct cp_token_cache GTY(())
158 /* The beginning of the token range. */
159 cp_token * GTY((skip)) first;
161 /* Points immediately after the last token in the range. */
162 cp_token * GTY ((skip)) last;
167 static cp_lexer *cp_lexer_new_main
169 static cp_lexer *cp_lexer_new_from_tokens
170 (cp_token_cache *tokens);
171 static void cp_lexer_destroy
173 static int cp_lexer_saving_tokens
175 static cp_token_position cp_lexer_token_position
177 static cp_token *cp_lexer_token_at
178 (cp_lexer *, cp_token_position);
179 static void cp_lexer_get_preprocessor_token
180 (cp_lexer *, cp_token *);
181 static inline cp_token *cp_lexer_peek_token
183 static cp_token *cp_lexer_peek_nth_token
184 (cp_lexer *, size_t);
185 static inline bool cp_lexer_next_token_is
186 (cp_lexer *, enum cpp_ttype);
187 static bool cp_lexer_next_token_is_not
188 (cp_lexer *, enum cpp_ttype);
189 static bool cp_lexer_next_token_is_keyword
190 (cp_lexer *, enum rid);
191 static cp_token *cp_lexer_consume_token
193 static void cp_lexer_purge_token
195 static void cp_lexer_purge_tokens_after
196 (cp_lexer *, cp_token_position);
197 static void cp_lexer_save_tokens
199 static void cp_lexer_commit_tokens
201 static void cp_lexer_rollback_tokens
203 #ifdef ENABLE_CHECKING
204 static void cp_lexer_print_token
205 (FILE *, cp_token *);
206 static inline bool cp_lexer_debugging_p
208 static void cp_lexer_start_debugging
209 (cp_lexer *) ATTRIBUTE_UNUSED;
210 static void cp_lexer_stop_debugging
211 (cp_lexer *) ATTRIBUTE_UNUSED;
213 /* If we define cp_lexer_debug_stream to NULL it will provoke warnings
214 about passing NULL to functions that require non-NULL arguments
215 (fputs, fprintf). It will never be used, so all we need is a value
216 of the right type that's guaranteed not to be NULL. */
217 #define cp_lexer_debug_stream stdout
218 #define cp_lexer_print_token(str, tok) (void) 0
219 #define cp_lexer_debugging_p(lexer) 0
220 #endif /* ENABLE_CHECKING */
222 static cp_token_cache *cp_token_cache_new
223 (cp_token *, cp_token *);
225 static void cp_parser_initial_pragma
228 /* Manifest constants. */
229 #define CP_LEXER_BUFFER_SIZE ((256 * 1024) / sizeof (cp_token))
230 #define CP_SAVED_TOKEN_STACK 5
232 /* A token type for keywords, as opposed to ordinary identifiers. */
233 #define CPP_KEYWORD ((enum cpp_ttype) (N_TTYPES + 1))
235 /* A token type for template-ids. If a template-id is processed while
236 parsing tentatively, it is replaced with a CPP_TEMPLATE_ID token;
237 the value of the CPP_TEMPLATE_ID is whatever was returned by
238 cp_parser_template_id. */
239 #define CPP_TEMPLATE_ID ((enum cpp_ttype) (CPP_KEYWORD + 1))
241 /* A token type for nested-name-specifiers. If a
242 nested-name-specifier is processed while parsing tentatively, it is
243 replaced with a CPP_NESTED_NAME_SPECIFIER token; the value of the
244 CPP_NESTED_NAME_SPECIFIER is whatever was returned by
245 cp_parser_nested_name_specifier_opt. */
246 #define CPP_NESTED_NAME_SPECIFIER ((enum cpp_ttype) (CPP_TEMPLATE_ID + 1))
248 /* A token type for tokens that are not tokens at all; these are used
249 to represent slots in the array where there used to be a token
250 that has now been deleted. */
251 #define CPP_PURGED ((enum cpp_ttype) (CPP_NESTED_NAME_SPECIFIER + 1))
253 /* The number of token types, including C++-specific ones. */
254 #define N_CP_TTYPES ((int) (CPP_PURGED + 1))
258 #ifdef ENABLE_CHECKING
259 /* The stream to which debugging output should be written. */
260 static FILE *cp_lexer_debug_stream;
261 #endif /* ENABLE_CHECKING */
263 /* Create a new main C++ lexer, the lexer that gets tokens from the
267 cp_lexer_new_main (void)
269 cp_token first_token;
276 /* It's possible that parsing the first pragma will load a PCH file,
277 which is a GC collection point. So we have to do that before
278 allocating any memory. */
279 cp_parser_initial_pragma (&first_token);
281 /* Tell c_lex_with_flags not to merge string constants. */
282 c_lex_return_raw_strings = true;
284 c_common_no_more_pch ();
286 /* Allocate the memory. */
287 lexer = GGC_CNEW (cp_lexer);
289 #ifdef ENABLE_CHECKING
290 /* Initially we are not debugging. */
291 lexer->debugging_p = false;
292 #endif /* ENABLE_CHECKING */
293 lexer->saved_tokens = VEC_alloc (cp_token_position, heap,
294 CP_SAVED_TOKEN_STACK);
296 /* Create the buffer. */
297 alloc = CP_LEXER_BUFFER_SIZE;
298 buffer = GGC_NEWVEC (cp_token, alloc);
300 /* Put the first token in the buffer. */
305 /* Get the remaining tokens from the preprocessor. */
306 while (pos->type != CPP_EOF)
313 buffer = GGC_RESIZEVEC (cp_token, buffer, alloc);
314 pos = buffer + space;
316 cp_lexer_get_preprocessor_token (lexer, pos);
318 lexer->buffer = buffer;
319 lexer->buffer_length = alloc - space;
320 lexer->last_token = pos;
321 lexer->next_token = lexer->buffer_length ? buffer : (cp_token *)&eof_token;
323 /* Subsequent preprocessor diagnostics should use compiler
324 diagnostic functions to get the compiler source location. */
325 cpp_get_options (parse_in)->client_diagnostic = true;
326 cpp_get_callbacks (parse_in)->error = cp_cpp_error;
328 gcc_assert (lexer->next_token->type != CPP_PURGED);
332 /* Create a new lexer whose token stream is primed with the tokens in
333 CACHE. When these tokens are exhausted, no new tokens will be read. */
336 cp_lexer_new_from_tokens (cp_token_cache *cache)
338 cp_token *first = cache->first;
339 cp_token *last = cache->last;
340 cp_lexer *lexer = GGC_CNEW (cp_lexer);
342 /* We do not own the buffer. */
343 lexer->buffer = NULL;
344 lexer->buffer_length = 0;
345 lexer->next_token = first == last ? (cp_token *)&eof_token : first;
346 lexer->last_token = last;
348 lexer->saved_tokens = VEC_alloc (cp_token_position, heap,
349 CP_SAVED_TOKEN_STACK);
351 #ifdef ENABLE_CHECKING
352 /* Initially we are not debugging. */
353 lexer->debugging_p = false;
356 gcc_assert (lexer->next_token->type != CPP_PURGED);
360 /* Frees all resources associated with LEXER. */
363 cp_lexer_destroy (cp_lexer *lexer)
366 ggc_free (lexer->buffer);
367 VEC_free (cp_token_position, heap, lexer->saved_tokens);
371 /* Returns nonzero if debugging information should be output. */
373 #ifdef ENABLE_CHECKING
376 cp_lexer_debugging_p (cp_lexer *lexer)
378 return lexer->debugging_p;
381 #endif /* ENABLE_CHECKING */
383 static inline cp_token_position
384 cp_lexer_token_position (cp_lexer *lexer, bool previous_p)
386 gcc_assert (!previous_p || lexer->next_token != &eof_token);
388 return lexer->next_token - previous_p;
391 static inline cp_token *
392 cp_lexer_token_at (cp_lexer *lexer ATTRIBUTE_UNUSED, cp_token_position pos)
397 /* nonzero if we are presently saving tokens. */
400 cp_lexer_saving_tokens (const cp_lexer* lexer)
402 return VEC_length (cp_token_position, lexer->saved_tokens) != 0;
405 /* Store the next token from the preprocessor in *TOKEN. Return true
409 cp_lexer_get_preprocessor_token (cp_lexer *lexer ATTRIBUTE_UNUSED ,
412 static int is_extern_c = 0;
414 /* Get a new token from the preprocessor. */
416 = c_lex_with_flags (&token->u.value, &token->location, &token->flags);
417 token->input_file_stack_index = input_file_stack_tick;
418 token->keyword = RID_MAX;
419 token->pragma_kind = PRAGMA_NONE;
420 token->in_system_header = in_system_header;
422 /* On some systems, some header files are surrounded by an
423 implicit extern "C" block. Set a flag in the token if it
424 comes from such a header. */
425 is_extern_c += pending_lang_change;
426 pending_lang_change = 0;
427 token->implicit_extern_c = is_extern_c > 0;
429 /* Check to see if this token is a keyword. */
430 if (token->type == CPP_NAME)
432 if (C_IS_RESERVED_WORD (token->u.value))
434 /* Mark this token as a keyword. */
435 token->type = CPP_KEYWORD;
436 /* Record which keyword. */
437 token->keyword = C_RID_CODE (token->u.value);
438 /* Update the value. Some keywords are mapped to particular
439 entities, rather than simply having the value of the
440 corresponding IDENTIFIER_NODE. For example, `__const' is
441 mapped to `const'. */
442 token->u.value = ridpointers[token->keyword];
446 token->ambiguous_p = false;
447 token->keyword = RID_MAX;
450 /* Handle Objective-C++ keywords. */
451 else if (token->type == CPP_AT_NAME)
453 token->type = CPP_KEYWORD;
454 switch (C_RID_CODE (token->u.value))
456 /* Map 'class' to '@class', 'private' to '@private', etc. */
457 case RID_CLASS: token->keyword = RID_AT_CLASS; break;
458 case RID_PRIVATE: token->keyword = RID_AT_PRIVATE; break;
459 case RID_PROTECTED: token->keyword = RID_AT_PROTECTED; break;
460 case RID_PUBLIC: token->keyword = RID_AT_PUBLIC; break;
461 case RID_THROW: token->keyword = RID_AT_THROW; break;
462 case RID_TRY: token->keyword = RID_AT_TRY; break;
463 case RID_CATCH: token->keyword = RID_AT_CATCH; break;
464 default: token->keyword = C_RID_CODE (token->u.value);
467 else if (token->type == CPP_PRAGMA)
469 /* We smuggled the cpp_token->u.pragma value in an INTEGER_CST. */
470 token->pragma_kind = TREE_INT_CST_LOW (token->u.value);
471 token->u.value = NULL_TREE;
475 /* Update the globals input_location and in_system_header and the
476 input file stack from TOKEN. */
478 cp_lexer_set_source_position_from_token (cp_token *token)
480 if (token->type != CPP_EOF)
482 input_location = token->location;
483 in_system_header = token->in_system_header;
484 restore_input_file_stack (token->input_file_stack_index);
488 /* Return a pointer to the next token in the token stream, but do not
491 static inline cp_token *
492 cp_lexer_peek_token (cp_lexer *lexer)
494 if (cp_lexer_debugging_p (lexer))
496 fputs ("cp_lexer: peeking at token: ", cp_lexer_debug_stream);
497 cp_lexer_print_token (cp_lexer_debug_stream, lexer->next_token);
498 putc ('\n', cp_lexer_debug_stream);
500 return lexer->next_token;
503 /* Return true if the next token has the indicated TYPE. */
506 cp_lexer_next_token_is (cp_lexer* lexer, enum cpp_ttype type)
508 return cp_lexer_peek_token (lexer)->type == type;
511 /* Return true if the next token does not have the indicated TYPE. */
514 cp_lexer_next_token_is_not (cp_lexer* lexer, enum cpp_ttype type)
516 return !cp_lexer_next_token_is (lexer, type);
519 /* Return true if the next token is the indicated KEYWORD. */
522 cp_lexer_next_token_is_keyword (cp_lexer* lexer, enum rid keyword)
524 return cp_lexer_peek_token (lexer)->keyword == keyword;
527 /* Return true if the next token is a keyword for a decl-specifier. */
530 cp_lexer_next_token_is_decl_specifier_keyword (cp_lexer *lexer)
534 token = cp_lexer_peek_token (lexer);
535 switch (token->keyword)
537 /* Storage classes. */
544 /* Elaborated type specifiers. */
550 /* Simple type specifiers. */
562 /* GNU extensions. */
572 /* Return a pointer to the Nth token in the token stream. If N is 1,
573 then this is precisely equivalent to cp_lexer_peek_token (except
574 that it is not inline). One would like to disallow that case, but
575 there is one case (cp_parser_nth_token_starts_template_id) where
576 the caller passes a variable for N and it might be 1. */
579 cp_lexer_peek_nth_token (cp_lexer* lexer, size_t n)
583 /* N is 1-based, not zero-based. */
586 if (cp_lexer_debugging_p (lexer))
587 fprintf (cp_lexer_debug_stream,
588 "cp_lexer: peeking ahead %ld at token: ", (long)n);
591 token = lexer->next_token;
592 gcc_assert (!n || token != &eof_token);
596 if (token == lexer->last_token)
598 token = (cp_token *)&eof_token;
602 if (token->type != CPP_PURGED)
606 if (cp_lexer_debugging_p (lexer))
608 cp_lexer_print_token (cp_lexer_debug_stream, token);
609 putc ('\n', cp_lexer_debug_stream);
615 /* Return the next token, and advance the lexer's next_token pointer
616 to point to the next non-purged token. */
619 cp_lexer_consume_token (cp_lexer* lexer)
621 cp_token *token = lexer->next_token;
623 gcc_assert (token != &eof_token);
624 gcc_assert (!lexer->in_pragma || token->type != CPP_PRAGMA_EOL);
629 if (lexer->next_token == lexer->last_token)
631 lexer->next_token = (cp_token *)&eof_token;
636 while (lexer->next_token->type == CPP_PURGED);
638 cp_lexer_set_source_position_from_token (token);
640 /* Provide debugging output. */
641 if (cp_lexer_debugging_p (lexer))
643 fputs ("cp_lexer: consuming token: ", cp_lexer_debug_stream);
644 cp_lexer_print_token (cp_lexer_debug_stream, token);
645 putc ('\n', cp_lexer_debug_stream);
651 /* Permanently remove the next token from the token stream, and
652 advance the next_token pointer to refer to the next non-purged
656 cp_lexer_purge_token (cp_lexer *lexer)
658 cp_token *tok = lexer->next_token;
660 gcc_assert (tok != &eof_token);
661 tok->type = CPP_PURGED;
662 tok->location = UNKNOWN_LOCATION;
663 tok->u.value = NULL_TREE;
664 tok->keyword = RID_MAX;
669 if (tok == lexer->last_token)
671 tok = (cp_token *)&eof_token;
675 while (tok->type == CPP_PURGED);
676 lexer->next_token = tok;
679 /* Permanently remove all tokens after TOK, up to, but not
680 including, the token that will be returned next by
681 cp_lexer_peek_token. */
684 cp_lexer_purge_tokens_after (cp_lexer *lexer, cp_token *tok)
686 cp_token *peek = lexer->next_token;
688 if (peek == &eof_token)
689 peek = lexer->last_token;
691 gcc_assert (tok < peek);
693 for ( tok += 1; tok != peek; tok += 1)
695 tok->type = CPP_PURGED;
696 tok->location = UNKNOWN_LOCATION;
697 tok->u.value = NULL_TREE;
698 tok->keyword = RID_MAX;
702 /* Begin saving tokens. All tokens consumed after this point will be
706 cp_lexer_save_tokens (cp_lexer* lexer)
708 /* Provide debugging output. */
709 if (cp_lexer_debugging_p (lexer))
710 fprintf (cp_lexer_debug_stream, "cp_lexer: saving tokens\n");
712 VEC_safe_push (cp_token_position, heap,
713 lexer->saved_tokens, lexer->next_token);
716 /* Commit to the portion of the token stream most recently saved. */
719 cp_lexer_commit_tokens (cp_lexer* lexer)
721 /* Provide debugging output. */
722 if (cp_lexer_debugging_p (lexer))
723 fprintf (cp_lexer_debug_stream, "cp_lexer: committing tokens\n");
725 VEC_pop (cp_token_position, lexer->saved_tokens);
728 /* Return all tokens saved since the last call to cp_lexer_save_tokens
729 to the token stream. Stop saving tokens. */
732 cp_lexer_rollback_tokens (cp_lexer* lexer)
734 /* Provide debugging output. */
735 if (cp_lexer_debugging_p (lexer))
736 fprintf (cp_lexer_debug_stream, "cp_lexer: restoring tokens\n");
738 lexer->next_token = VEC_pop (cp_token_position, lexer->saved_tokens);
741 /* Print a representation of the TOKEN on the STREAM. */
743 #ifdef ENABLE_CHECKING
746 cp_lexer_print_token (FILE * stream, cp_token *token)
748 /* We don't use cpp_type2name here because the parser defines
749 a few tokens of its own. */
750 static const char *const token_names[] = {
751 /* cpplib-defined token types */
757 /* C++ parser token types - see "Manifest constants", above. */
760 "NESTED_NAME_SPECIFIER",
764 /* If we have a name for the token, print it out. Otherwise, we
765 simply give the numeric code. */
766 gcc_assert (token->type < ARRAY_SIZE(token_names));
767 fputs (token_names[token->type], stream);
769 /* For some tokens, print the associated data. */
773 /* Some keywords have a value that is not an IDENTIFIER_NODE.
774 For example, `struct' is mapped to an INTEGER_CST. */
775 if (TREE_CODE (token->u.value) != IDENTIFIER_NODE)
777 /* else fall through */
779 fputs (IDENTIFIER_POINTER (token->u.value), stream);
784 fprintf (stream, " \"%s\"", TREE_STRING_POINTER (token->u.value));
792 /* Start emitting debugging information. */
795 cp_lexer_start_debugging (cp_lexer* lexer)
797 lexer->debugging_p = true;
800 /* Stop emitting debugging information. */
803 cp_lexer_stop_debugging (cp_lexer* lexer)
805 lexer->debugging_p = false;
808 #endif /* ENABLE_CHECKING */
810 /* Create a new cp_token_cache, representing a range of tokens. */
812 static cp_token_cache *
813 cp_token_cache_new (cp_token *first, cp_token *last)
815 cp_token_cache *cache = GGC_NEW (cp_token_cache);
816 cache->first = first;
822 /* Decl-specifiers. */
824 /* Set *DECL_SPECS to represent an empty decl-specifier-seq. */
827 clear_decl_specs (cp_decl_specifier_seq *decl_specs)
829 memset (decl_specs, 0, sizeof (cp_decl_specifier_seq));
834 /* Nothing other than the parser should be creating declarators;
835 declarators are a semi-syntactic representation of C++ entities.
836 Other parts of the front end that need to create entities (like
837 VAR_DECLs or FUNCTION_DECLs) should do that directly. */
839 static cp_declarator *make_call_declarator
840 (cp_declarator *, cp_parameter_declarator *, cp_cv_quals, tree);
841 static cp_declarator *make_array_declarator
842 (cp_declarator *, tree);
843 static cp_declarator *make_pointer_declarator
844 (cp_cv_quals, cp_declarator *);
845 static cp_declarator *make_reference_declarator
846 (cp_cv_quals, cp_declarator *);
847 static cp_parameter_declarator *make_parameter_declarator
848 (cp_decl_specifier_seq *, cp_declarator *, tree);
849 static cp_declarator *make_ptrmem_declarator
850 (cp_cv_quals, tree, cp_declarator *);
852 /* An erroneous declarator. */
853 static cp_declarator *cp_error_declarator;
855 /* The obstack on which declarators and related data structures are
857 static struct obstack declarator_obstack;
859 /* Alloc BYTES from the declarator memory pool. */
862 alloc_declarator (size_t bytes)
864 return obstack_alloc (&declarator_obstack, bytes);
867 /* Allocate a declarator of the indicated KIND. Clear fields that are
868 common to all declarators. */
870 static cp_declarator *
871 make_declarator (cp_declarator_kind kind)
873 cp_declarator *declarator;
875 declarator = (cp_declarator *) alloc_declarator (sizeof (cp_declarator));
876 declarator->kind = kind;
877 declarator->attributes = NULL_TREE;
878 declarator->declarator = NULL;
883 /* Make a declarator for a generalized identifier. If
884 QUALIFYING_SCOPE is non-NULL, the identifier is
885 QUALIFYING_SCOPE::UNQUALIFIED_NAME; otherwise, it is just
886 UNQUALIFIED_NAME. SFK indicates the kind of special function this
889 static cp_declarator *
890 make_id_declarator (tree qualifying_scope, tree unqualified_name,
891 special_function_kind sfk)
893 cp_declarator *declarator;
895 /* It is valid to write:
897 class C { void f(); };
901 The standard is not clear about whether `typedef const C D' is
902 legal; as of 2002-09-15 the committee is considering that
903 question. EDG 3.0 allows that syntax. Therefore, we do as
905 if (qualifying_scope && TYPE_P (qualifying_scope))
906 qualifying_scope = TYPE_MAIN_VARIANT (qualifying_scope);
908 gcc_assert (TREE_CODE (unqualified_name) == IDENTIFIER_NODE
909 || TREE_CODE (unqualified_name) == BIT_NOT_EXPR
910 || TREE_CODE (unqualified_name) == TEMPLATE_ID_EXPR);
912 declarator = make_declarator (cdk_id);
913 declarator->u.id.qualifying_scope = qualifying_scope;
914 declarator->u.id.unqualified_name = unqualified_name;
915 declarator->u.id.sfk = sfk;
920 /* Make a declarator for a pointer to TARGET. CV_QUALIFIERS is a list
921 of modifiers such as const or volatile to apply to the pointer
922 type, represented as identifiers. */
925 make_pointer_declarator (cp_cv_quals cv_qualifiers, cp_declarator *target)
927 cp_declarator *declarator;
929 declarator = make_declarator (cdk_pointer);
930 declarator->declarator = target;
931 declarator->u.pointer.qualifiers = cv_qualifiers;
932 declarator->u.pointer.class_type = NULL_TREE;
937 /* Like make_pointer_declarator -- but for references. */
940 make_reference_declarator (cp_cv_quals cv_qualifiers, cp_declarator *target)
942 cp_declarator *declarator;
944 declarator = make_declarator (cdk_reference);
945 declarator->declarator = target;
946 declarator->u.pointer.qualifiers = cv_qualifiers;
947 declarator->u.pointer.class_type = NULL_TREE;
952 /* Like make_pointer_declarator -- but for a pointer to a non-static
953 member of CLASS_TYPE. */
956 make_ptrmem_declarator (cp_cv_quals cv_qualifiers, tree class_type,
957 cp_declarator *pointee)
959 cp_declarator *declarator;
961 declarator = make_declarator (cdk_ptrmem);
962 declarator->declarator = pointee;
963 declarator->u.pointer.qualifiers = cv_qualifiers;
964 declarator->u.pointer.class_type = class_type;
969 /* Make a declarator for the function given by TARGET, with the
970 indicated PARMS. The CV_QUALIFIERS aply to the function, as in
971 "const"-qualified member function. The EXCEPTION_SPECIFICATION
972 indicates what exceptions can be thrown. */
975 make_call_declarator (cp_declarator *target,
976 cp_parameter_declarator *parms,
977 cp_cv_quals cv_qualifiers,
978 tree exception_specification)
980 cp_declarator *declarator;
982 declarator = make_declarator (cdk_function);
983 declarator->declarator = target;
984 declarator->u.function.parameters = parms;
985 declarator->u.function.qualifiers = cv_qualifiers;
986 declarator->u.function.exception_specification = exception_specification;
991 /* Make a declarator for an array of BOUNDS elements, each of which is
992 defined by ELEMENT. */
995 make_array_declarator (cp_declarator *element, tree bounds)
997 cp_declarator *declarator;
999 declarator = make_declarator (cdk_array);
1000 declarator->declarator = element;
1001 declarator->u.array.bounds = bounds;
1006 cp_parameter_declarator *no_parameters;
1008 /* Create a parameter declarator with the indicated DECL_SPECIFIERS,
1009 DECLARATOR and DEFAULT_ARGUMENT. */
1011 cp_parameter_declarator *
1012 make_parameter_declarator (cp_decl_specifier_seq *decl_specifiers,
1013 cp_declarator *declarator,
1014 tree default_argument)
1016 cp_parameter_declarator *parameter;
1018 parameter = ((cp_parameter_declarator *)
1019 alloc_declarator (sizeof (cp_parameter_declarator)));
1020 parameter->next = NULL;
1021 if (decl_specifiers)
1022 parameter->decl_specifiers = *decl_specifiers;
1024 clear_decl_specs (¶meter->decl_specifiers);
1025 parameter->declarator = declarator;
1026 parameter->default_argument = default_argument;
1027 parameter->ellipsis_p = false;
1032 /* Returns true iff DECLARATOR is a declaration for a function. */
1035 function_declarator_p (const cp_declarator *declarator)
1039 if (declarator->kind == cdk_function
1040 && declarator->declarator->kind == cdk_id)
1042 if (declarator->kind == cdk_id
1043 || declarator->kind == cdk_error)
1045 declarator = declarator->declarator;
1055 A cp_parser parses the token stream as specified by the C++
1056 grammar. Its job is purely parsing, not semantic analysis. For
1057 example, the parser breaks the token stream into declarators,
1058 expressions, statements, and other similar syntactic constructs.
1059 It does not check that the types of the expressions on either side
1060 of an assignment-statement are compatible, or that a function is
1061 not declared with a parameter of type `void'.
1063 The parser invokes routines elsewhere in the compiler to perform
1064 semantic analysis and to build up the abstract syntax tree for the
1067 The parser (and the template instantiation code, which is, in a
1068 way, a close relative of parsing) are the only parts of the
1069 compiler that should be calling push_scope and pop_scope, or
1070 related functions. The parser (and template instantiation code)
1071 keeps track of what scope is presently active; everything else
1072 should simply honor that. (The code that generates static
1073 initializers may also need to set the scope, in order to check
1074 access control correctly when emitting the initializers.)
1079 The parser is of the standard recursive-descent variety. Upcoming
1080 tokens in the token stream are examined in order to determine which
1081 production to use when parsing a non-terminal. Some C++ constructs
1082 require arbitrary look ahead to disambiguate. For example, it is
1083 impossible, in the general case, to tell whether a statement is an
1084 expression or declaration without scanning the entire statement.
1085 Therefore, the parser is capable of "parsing tentatively." When the
1086 parser is not sure what construct comes next, it enters this mode.
1087 Then, while we attempt to parse the construct, the parser queues up
1088 error messages, rather than issuing them immediately, and saves the
1089 tokens it consumes. If the construct is parsed successfully, the
1090 parser "commits", i.e., it issues any queued error messages and
1091 the tokens that were being preserved are permanently discarded.
1092 If, however, the construct is not parsed successfully, the parser
1093 rolls back its state completely so that it can resume parsing using
1094 a different alternative.
1099 The performance of the parser could probably be improved substantially.
1100 We could often eliminate the need to parse tentatively by looking ahead
1101 a little bit. In some places, this approach might not entirely eliminate
1102 the need to parse tentatively, but it might still speed up the average
1105 /* Flags that are passed to some parsing functions. These values can
1106 be bitwise-ored together. */
1108 typedef enum cp_parser_flags
1111 CP_PARSER_FLAGS_NONE = 0x0,
1112 /* The construct is optional. If it is not present, then no error
1113 should be issued. */
1114 CP_PARSER_FLAGS_OPTIONAL = 0x1,
1115 /* When parsing a type-specifier, do not allow user-defined types. */
1116 CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES = 0x2
1119 /* The different kinds of declarators we want to parse. */
1121 typedef enum cp_parser_declarator_kind
1123 /* We want an abstract declarator. */
1124 CP_PARSER_DECLARATOR_ABSTRACT,
1125 /* We want a named declarator. */
1126 CP_PARSER_DECLARATOR_NAMED,
1127 /* We don't mind, but the name must be an unqualified-id. */
1128 CP_PARSER_DECLARATOR_EITHER
1129 } cp_parser_declarator_kind;
1131 /* The precedence values used to parse binary expressions. The minimum value
1132 of PREC must be 1, because zero is reserved to quickly discriminate
1133 binary operators from other tokens. */
1138 PREC_LOGICAL_OR_EXPRESSION,
1139 PREC_LOGICAL_AND_EXPRESSION,
1140 PREC_INCLUSIVE_OR_EXPRESSION,
1141 PREC_EXCLUSIVE_OR_EXPRESSION,
1142 PREC_AND_EXPRESSION,
1143 PREC_EQUALITY_EXPRESSION,
1144 PREC_RELATIONAL_EXPRESSION,
1145 PREC_SHIFT_EXPRESSION,
1146 PREC_ADDITIVE_EXPRESSION,
1147 PREC_MULTIPLICATIVE_EXPRESSION,
1149 NUM_PREC_VALUES = PREC_PM_EXPRESSION
1152 /* A mapping from a token type to a corresponding tree node type, with a
1153 precedence value. */
1155 typedef struct cp_parser_binary_operations_map_node
1157 /* The token type. */
1158 enum cpp_ttype token_type;
1159 /* The corresponding tree code. */
1160 enum tree_code tree_type;
1161 /* The precedence of this operator. */
1162 enum cp_parser_prec prec;
1163 } cp_parser_binary_operations_map_node;
1165 /* The status of a tentative parse. */
1167 typedef enum cp_parser_status_kind
1169 /* No errors have occurred. */
1170 CP_PARSER_STATUS_KIND_NO_ERROR,
1171 /* An error has occurred. */
1172 CP_PARSER_STATUS_KIND_ERROR,
1173 /* We are committed to this tentative parse, whether or not an error
1175 CP_PARSER_STATUS_KIND_COMMITTED
1176 } cp_parser_status_kind;
1178 typedef struct cp_parser_expression_stack_entry
1180 /* Left hand side of the binary operation we are currently
1183 /* Original tree code for left hand side, if it was a binary
1184 expression itself (used for -Wparentheses). */
1185 enum tree_code lhs_type;
1186 /* Tree code for the binary operation we are parsing. */
1187 enum tree_code tree_type;
1188 /* Precedence of the binary operation we are parsing. */
1190 } cp_parser_expression_stack_entry;
1192 /* The stack for storing partial expressions. We only need NUM_PREC_VALUES
1193 entries because precedence levels on the stack are monotonically
1195 typedef struct cp_parser_expression_stack_entry
1196 cp_parser_expression_stack[NUM_PREC_VALUES];
1198 /* Context that is saved and restored when parsing tentatively. */
1199 typedef struct cp_parser_context GTY (())
1201 /* If this is a tentative parsing context, the status of the
1203 enum cp_parser_status_kind status;
1204 /* If non-NULL, we have just seen a `x->' or `x.' expression. Names
1205 that are looked up in this context must be looked up both in the
1206 scope given by OBJECT_TYPE (the type of `x' or `*x') and also in
1207 the context of the containing expression. */
1210 /* The next parsing context in the stack. */
1211 struct cp_parser_context *next;
1212 } cp_parser_context;
1216 /* Constructors and destructors. */
1218 static cp_parser_context *cp_parser_context_new
1219 (cp_parser_context *);
1221 /* Class variables. */
1223 static GTY((deletable)) cp_parser_context* cp_parser_context_free_list;
1225 /* The operator-precedence table used by cp_parser_binary_expression.
1226 Transformed into an associative array (binops_by_token) by
1229 static const cp_parser_binary_operations_map_node binops[] = {
1230 { CPP_DEREF_STAR, MEMBER_REF, PREC_PM_EXPRESSION },
1231 { CPP_DOT_STAR, DOTSTAR_EXPR, PREC_PM_EXPRESSION },
1233 { CPP_MULT, MULT_EXPR, PREC_MULTIPLICATIVE_EXPRESSION },
1234 { CPP_DIV, TRUNC_DIV_EXPR, PREC_MULTIPLICATIVE_EXPRESSION },
1235 { CPP_MOD, TRUNC_MOD_EXPR, PREC_MULTIPLICATIVE_EXPRESSION },
1237 { CPP_PLUS, PLUS_EXPR, PREC_ADDITIVE_EXPRESSION },
1238 { CPP_MINUS, MINUS_EXPR, PREC_ADDITIVE_EXPRESSION },
1240 { CPP_LSHIFT, LSHIFT_EXPR, PREC_SHIFT_EXPRESSION },
1241 { CPP_RSHIFT, RSHIFT_EXPR, PREC_SHIFT_EXPRESSION },
1243 { CPP_LESS, LT_EXPR, PREC_RELATIONAL_EXPRESSION },
1244 { CPP_GREATER, GT_EXPR, PREC_RELATIONAL_EXPRESSION },
1245 { CPP_LESS_EQ, LE_EXPR, PREC_RELATIONAL_EXPRESSION },
1246 { CPP_GREATER_EQ, GE_EXPR, PREC_RELATIONAL_EXPRESSION },
1248 { CPP_EQ_EQ, EQ_EXPR, PREC_EQUALITY_EXPRESSION },
1249 { CPP_NOT_EQ, NE_EXPR, PREC_EQUALITY_EXPRESSION },
1251 { CPP_AND, BIT_AND_EXPR, PREC_AND_EXPRESSION },
1253 { CPP_XOR, BIT_XOR_EXPR, PREC_EXCLUSIVE_OR_EXPRESSION },
1255 { CPP_OR, BIT_IOR_EXPR, PREC_INCLUSIVE_OR_EXPRESSION },
1257 { CPP_AND_AND, TRUTH_ANDIF_EXPR, PREC_LOGICAL_AND_EXPRESSION },
1259 { CPP_OR_OR, TRUTH_ORIF_EXPR, PREC_LOGICAL_OR_EXPRESSION }
1262 /* The same as binops, but initialized by cp_parser_new so that
1263 binops_by_token[N].token_type == N. Used in cp_parser_binary_expression
1265 static cp_parser_binary_operations_map_node binops_by_token[N_CP_TTYPES];
1267 /* Constructors and destructors. */
1269 /* Construct a new context. The context below this one on the stack
1270 is given by NEXT. */
1272 static cp_parser_context *
1273 cp_parser_context_new (cp_parser_context* next)
1275 cp_parser_context *context;
1277 /* Allocate the storage. */
1278 if (cp_parser_context_free_list != NULL)
1280 /* Pull the first entry from the free list. */
1281 context = cp_parser_context_free_list;
1282 cp_parser_context_free_list = context->next;
1283 memset (context, 0, sizeof (*context));
1286 context = GGC_CNEW (cp_parser_context);
1288 /* No errors have occurred yet in this context. */
1289 context->status = CP_PARSER_STATUS_KIND_NO_ERROR;
1290 /* If this is not the bottomost context, copy information that we
1291 need from the previous context. */
1294 /* If, in the NEXT context, we are parsing an `x->' or `x.'
1295 expression, then we are parsing one in this context, too. */
1296 context->object_type = next->object_type;
1297 /* Thread the stack. */
1298 context->next = next;
1304 /* The cp_parser structure represents the C++ parser. */
1306 typedef struct cp_parser GTY(())
1308 /* The lexer from which we are obtaining tokens. */
1311 /* The scope in which names should be looked up. If NULL_TREE, then
1312 we look up names in the scope that is currently open in the
1313 source program. If non-NULL, this is either a TYPE or
1314 NAMESPACE_DECL for the scope in which we should look. It can
1315 also be ERROR_MARK, when we've parsed a bogus scope.
1317 This value is not cleared automatically after a name is looked
1318 up, so we must be careful to clear it before starting a new look
1319 up sequence. (If it is not cleared, then `X::Y' followed by `Z'
1320 will look up `Z' in the scope of `X', rather than the current
1321 scope.) Unfortunately, it is difficult to tell when name lookup
1322 is complete, because we sometimes peek at a token, look it up,
1323 and then decide not to consume it. */
1326 /* OBJECT_SCOPE and QUALIFYING_SCOPE give the scopes in which the
1327 last lookup took place. OBJECT_SCOPE is used if an expression
1328 like "x->y" or "x.y" was used; it gives the type of "*x" or "x",
1329 respectively. QUALIFYING_SCOPE is used for an expression of the
1330 form "X::Y"; it refers to X. */
1332 tree qualifying_scope;
1334 /* A stack of parsing contexts. All but the bottom entry on the
1335 stack will be tentative contexts.
1337 We parse tentatively in order to determine which construct is in
1338 use in some situations. For example, in order to determine
1339 whether a statement is an expression-statement or a
1340 declaration-statement we parse it tentatively as a
1341 declaration-statement. If that fails, we then reparse the same
1342 token stream as an expression-statement. */
1343 cp_parser_context *context;
1345 /* True if we are parsing GNU C++. If this flag is not set, then
1346 GNU extensions are not recognized. */
1347 bool allow_gnu_extensions_p;
1349 /* TRUE if the `>' token should be interpreted as the greater-than
1350 operator. FALSE if it is the end of a template-id or
1351 template-parameter-list. */
1352 bool greater_than_is_operator_p;
1354 /* TRUE if default arguments are allowed within a parameter list
1355 that starts at this point. FALSE if only a gnu extension makes
1356 them permissible. */
1357 bool default_arg_ok_p;
1359 /* TRUE if we are parsing an integral constant-expression. See
1360 [expr.const] for a precise definition. */
1361 bool integral_constant_expression_p;
1363 /* TRUE if we are parsing an integral constant-expression -- but a
1364 non-constant expression should be permitted as well. This flag
1365 is used when parsing an array bound so that GNU variable-length
1366 arrays are tolerated. */
1367 bool allow_non_integral_constant_expression_p;
1369 /* TRUE if ALLOW_NON_CONSTANT_EXPRESSION_P is TRUE and something has
1370 been seen that makes the expression non-constant. */
1371 bool non_integral_constant_expression_p;
1373 /* TRUE if local variable names and `this' are forbidden in the
1375 bool local_variables_forbidden_p;
1377 /* TRUE if the declaration we are parsing is part of a
1378 linkage-specification of the form `extern string-literal
1380 bool in_unbraced_linkage_specification_p;
1382 /* TRUE if we are presently parsing a declarator, after the
1383 direct-declarator. */
1384 bool in_declarator_p;
1386 /* TRUE if we are presently parsing a template-argument-list. */
1387 bool in_template_argument_list_p;
1389 /* Set to IN_ITERATION_STMT if parsing an iteration-statement,
1390 to IN_OMP_BLOCK if parsing OpenMP structured block and
1391 IN_OMP_FOR if parsing OpenMP loop. If parsing a switch statement,
1392 this is bitwise ORed with IN_SWITCH_STMT, unless parsing an
1393 iteration-statement, OpenMP block or loop within that switch. */
1394 #define IN_SWITCH_STMT 1
1395 #define IN_ITERATION_STMT 2
1396 #define IN_OMP_BLOCK 4
1397 #define IN_OMP_FOR 8
1398 unsigned char in_statement;
1400 /* TRUE if we are presently parsing the body of a switch statement.
1401 Note that this doesn't quite overlap with in_statement above.
1402 The difference relates to giving the right sets of error messages:
1403 "case not in switch" vs "break statement used with OpenMP...". */
1404 bool in_switch_statement_p;
1406 /* TRUE if we are parsing a type-id in an expression context. In
1407 such a situation, both "type (expr)" and "type (type)" are valid
1409 bool in_type_id_in_expr_p;
1411 /* TRUE if we are currently in a header file where declarations are
1412 implicitly extern "C". */
1413 bool implicit_extern_c;
1415 /* TRUE if strings in expressions should be translated to the execution
1417 bool translate_strings_p;
1419 /* TRUE if we are presently parsing the body of a function, but not
1421 bool in_function_body;
1423 /* If non-NULL, then we are parsing a construct where new type
1424 definitions are not permitted. The string stored here will be
1425 issued as an error message if a type is defined. */
1426 const char *type_definition_forbidden_message;
1428 /* A list of lists. The outer list is a stack, used for member
1429 functions of local classes. At each level there are two sub-list,
1430 one on TREE_VALUE and one on TREE_PURPOSE. Each of those
1431 sub-lists has a FUNCTION_DECL or TEMPLATE_DECL on their
1432 TREE_VALUE's. The functions are chained in reverse declaration
1435 The TREE_PURPOSE sublist contains those functions with default
1436 arguments that need post processing, and the TREE_VALUE sublist
1437 contains those functions with definitions that need post
1440 These lists can only be processed once the outermost class being
1441 defined is complete. */
1442 tree unparsed_functions_queues;
1444 /* The number of classes whose definitions are currently in
1446 unsigned num_classes_being_defined;
1448 /* The number of template parameter lists that apply directly to the
1449 current declaration. */
1450 unsigned num_template_parameter_lists;
1455 /* Constructors and destructors. */
1457 static cp_parser *cp_parser_new
1460 /* Routines to parse various constructs.
1462 Those that return `tree' will return the error_mark_node (rather
1463 than NULL_TREE) if a parse error occurs, unless otherwise noted.
1464 Sometimes, they will return an ordinary node if error-recovery was
1465 attempted, even though a parse error occurred. So, to check
1466 whether or not a parse error occurred, you should always use
1467 cp_parser_error_occurred. If the construct is optional (indicated
1468 either by an `_opt' in the name of the function that does the
1469 parsing or via a FLAGS parameter), then NULL_TREE is returned if
1470 the construct is not present. */
1472 /* Lexical conventions [gram.lex] */
1474 static tree cp_parser_identifier
1476 static tree cp_parser_string_literal
1477 (cp_parser *, bool, bool);
1479 /* Basic concepts [gram.basic] */
1481 static bool cp_parser_translation_unit
1484 /* Expressions [gram.expr] */
1486 static tree cp_parser_primary_expression
1487 (cp_parser *, bool, bool, bool, cp_id_kind *);
1488 static tree cp_parser_id_expression
1489 (cp_parser *, bool, bool, bool *, bool, bool);
1490 static tree cp_parser_unqualified_id
1491 (cp_parser *, bool, bool, bool, bool);
1492 static tree cp_parser_nested_name_specifier_opt
1493 (cp_parser *, bool, bool, bool, bool);
1494 static tree cp_parser_nested_name_specifier
1495 (cp_parser *, bool, bool, bool, bool);
1496 static tree cp_parser_class_or_namespace_name
1497 (cp_parser *, bool, bool, bool, bool, bool);
1498 static tree cp_parser_postfix_expression
1499 (cp_parser *, bool, bool);
1500 static tree cp_parser_postfix_open_square_expression
1501 (cp_parser *, tree, bool);
1502 static tree cp_parser_postfix_dot_deref_expression
1503 (cp_parser *, enum cpp_ttype, tree, bool, cp_id_kind *);
1504 static tree cp_parser_parenthesized_expression_list
1505 (cp_parser *, bool, bool, bool *);
1506 static void cp_parser_pseudo_destructor_name
1507 (cp_parser *, tree *, tree *);
1508 static tree cp_parser_unary_expression
1509 (cp_parser *, bool, bool);
1510 static enum tree_code cp_parser_unary_operator
1512 static tree cp_parser_new_expression
1514 static tree cp_parser_new_placement
1516 static tree cp_parser_new_type_id
1517 (cp_parser *, tree *);
1518 static cp_declarator *cp_parser_new_declarator_opt
1520 static cp_declarator *cp_parser_direct_new_declarator
1522 static tree cp_parser_new_initializer
1524 static tree cp_parser_delete_expression
1526 static tree cp_parser_cast_expression
1527 (cp_parser *, bool, bool);
1528 static tree cp_parser_binary_expression
1529 (cp_parser *, bool);
1530 static tree cp_parser_question_colon_clause
1531 (cp_parser *, tree);
1532 static tree cp_parser_assignment_expression
1533 (cp_parser *, bool);
1534 static enum tree_code cp_parser_assignment_operator_opt
1536 static tree cp_parser_expression
1537 (cp_parser *, bool);
1538 static tree cp_parser_constant_expression
1539 (cp_parser *, bool, bool *);
1540 static tree cp_parser_builtin_offsetof
1543 /* Statements [gram.stmt.stmt] */
1545 static void cp_parser_statement
1546 (cp_parser *, tree, bool, bool *);
1547 static void cp_parser_label_for_labeled_statement
1549 static tree cp_parser_expression_statement
1550 (cp_parser *, tree);
1551 static tree cp_parser_compound_statement
1552 (cp_parser *, tree, bool);
1553 static void cp_parser_statement_seq_opt
1554 (cp_parser *, tree);
1555 static tree cp_parser_selection_statement
1556 (cp_parser *, bool *);
1557 static tree cp_parser_condition
1559 static tree cp_parser_iteration_statement
1561 static void cp_parser_for_init_statement
1563 static tree cp_parser_jump_statement
1565 static void cp_parser_declaration_statement
1568 static tree cp_parser_implicitly_scoped_statement
1569 (cp_parser *, bool *);
1570 static void cp_parser_already_scoped_statement
1573 /* Declarations [gram.dcl.dcl] */
1575 static void cp_parser_declaration_seq_opt
1577 static void cp_parser_declaration
1579 static void cp_parser_block_declaration
1580 (cp_parser *, bool);
1581 static void cp_parser_simple_declaration
1582 (cp_parser *, bool);
1583 static void cp_parser_decl_specifier_seq
1584 (cp_parser *, cp_parser_flags, cp_decl_specifier_seq *, int *);
1585 static tree cp_parser_storage_class_specifier_opt
1587 static tree cp_parser_function_specifier_opt
1588 (cp_parser *, cp_decl_specifier_seq *);
1589 static tree cp_parser_type_specifier
1590 (cp_parser *, cp_parser_flags, cp_decl_specifier_seq *, bool,
1592 static tree cp_parser_simple_type_specifier
1593 (cp_parser *, cp_decl_specifier_seq *, cp_parser_flags);
1594 static tree cp_parser_type_name
1596 static tree cp_parser_elaborated_type_specifier
1597 (cp_parser *, bool, bool);
1598 static tree cp_parser_enum_specifier
1600 static void cp_parser_enumerator_list
1601 (cp_parser *, tree);
1602 static void cp_parser_enumerator_definition
1603 (cp_parser *, tree);
1604 static tree cp_parser_namespace_name
1606 static void cp_parser_namespace_definition
1608 static void cp_parser_namespace_body
1610 static tree cp_parser_qualified_namespace_specifier
1612 static void cp_parser_namespace_alias_definition
1614 static bool cp_parser_using_declaration
1615 (cp_parser *, bool);
1616 static void cp_parser_using_directive
1618 static void cp_parser_asm_definition
1620 static void cp_parser_linkage_specification
1622 static void cp_parser_static_assert
1623 (cp_parser *, bool);
1625 /* Declarators [gram.dcl.decl] */
1627 static tree cp_parser_init_declarator
1628 (cp_parser *, cp_decl_specifier_seq *, VEC (deferred_access_check,gc)*, bool, bool, int, bool *);
1629 static cp_declarator *cp_parser_declarator
1630 (cp_parser *, cp_parser_declarator_kind, int *, bool *, bool);
1631 static cp_declarator *cp_parser_direct_declarator
1632 (cp_parser *, cp_parser_declarator_kind, int *, bool);
1633 static enum tree_code cp_parser_ptr_operator
1634 (cp_parser *, tree *, cp_cv_quals *);
1635 static cp_cv_quals cp_parser_cv_qualifier_seq_opt
1637 static tree cp_parser_declarator_id
1638 (cp_parser *, bool);
1639 static tree cp_parser_type_id
1641 static void cp_parser_type_specifier_seq
1642 (cp_parser *, bool, cp_decl_specifier_seq *);
1643 static cp_parameter_declarator *cp_parser_parameter_declaration_clause
1645 static cp_parameter_declarator *cp_parser_parameter_declaration_list
1646 (cp_parser *, bool *);
1647 static cp_parameter_declarator *cp_parser_parameter_declaration
1648 (cp_parser *, bool, bool *);
1649 static void cp_parser_function_body
1651 static tree cp_parser_initializer
1652 (cp_parser *, bool *, bool *);
1653 static tree cp_parser_initializer_clause
1654 (cp_parser *, bool *);
1655 static VEC(constructor_elt,gc) *cp_parser_initializer_list
1656 (cp_parser *, bool *);
1658 static bool cp_parser_ctor_initializer_opt_and_function_body
1661 /* Classes [gram.class] */
1663 static tree cp_parser_class_name
1664 (cp_parser *, bool, bool, enum tag_types, bool, bool, bool);
1665 static tree cp_parser_class_specifier
1667 static tree cp_parser_class_head
1668 (cp_parser *, bool *, tree *, tree *);
1669 static enum tag_types cp_parser_class_key
1671 static void cp_parser_member_specification_opt
1673 static void cp_parser_member_declaration
1675 static tree cp_parser_pure_specifier
1677 static tree cp_parser_constant_initializer
1680 /* Derived classes [gram.class.derived] */
1682 static tree cp_parser_base_clause
1684 static tree cp_parser_base_specifier
1687 /* Special member functions [gram.special] */
1689 static tree cp_parser_conversion_function_id
1691 static tree cp_parser_conversion_type_id
1693 static cp_declarator *cp_parser_conversion_declarator_opt
1695 static bool cp_parser_ctor_initializer_opt
1697 static void cp_parser_mem_initializer_list
1699 static tree cp_parser_mem_initializer
1701 static tree cp_parser_mem_initializer_id
1704 /* Overloading [gram.over] */
1706 static tree cp_parser_operator_function_id
1708 static tree cp_parser_operator
1711 /* Templates [gram.temp] */
1713 static void cp_parser_template_declaration
1714 (cp_parser *, bool);
1715 static tree cp_parser_template_parameter_list
1717 static tree cp_parser_template_parameter
1718 (cp_parser *, bool *);
1719 static tree cp_parser_type_parameter
1721 static tree cp_parser_template_id
1722 (cp_parser *, bool, bool, bool);
1723 static tree cp_parser_template_name
1724 (cp_parser *, bool, bool, bool, bool *);
1725 static tree cp_parser_template_argument_list
1727 static tree cp_parser_template_argument
1729 static void cp_parser_explicit_instantiation
1731 static void cp_parser_explicit_specialization
1734 /* Exception handling [gram.exception] */
1736 static tree cp_parser_try_block
1738 static bool cp_parser_function_try_block
1740 static void cp_parser_handler_seq
1742 static void cp_parser_handler
1744 static tree cp_parser_exception_declaration
1746 static tree cp_parser_throw_expression
1748 static tree cp_parser_exception_specification_opt
1750 static tree cp_parser_type_id_list
1753 /* GNU Extensions */
1755 static tree cp_parser_asm_specification_opt
1757 static tree cp_parser_asm_operand_list
1759 static tree cp_parser_asm_clobber_list
1761 static tree cp_parser_attributes_opt
1763 static tree cp_parser_attribute_list
1765 static bool cp_parser_extension_opt
1766 (cp_parser *, int *);
1767 static void cp_parser_label_declaration
1770 enum pragma_context { pragma_external, pragma_stmt, pragma_compound };
1771 static bool cp_parser_pragma
1772 (cp_parser *, enum pragma_context);
1774 /* Objective-C++ Productions */
1776 static tree cp_parser_objc_message_receiver
1778 static tree cp_parser_objc_message_args
1780 static tree cp_parser_objc_message_expression
1782 static tree cp_parser_objc_encode_expression
1784 static tree cp_parser_objc_defs_expression
1786 static tree cp_parser_objc_protocol_expression
1788 static tree cp_parser_objc_selector_expression
1790 static tree cp_parser_objc_expression
1792 static bool cp_parser_objc_selector_p
1794 static tree cp_parser_objc_selector
1796 static tree cp_parser_objc_protocol_refs_opt
1798 static void cp_parser_objc_declaration
1800 static tree cp_parser_objc_statement
1803 /* Utility Routines */
1805 static tree cp_parser_lookup_name
1806 (cp_parser *, tree, enum tag_types, bool, bool, bool, tree *);
1807 static tree cp_parser_lookup_name_simple
1808 (cp_parser *, tree);
1809 static tree cp_parser_maybe_treat_template_as_class
1811 static bool cp_parser_check_declarator_template_parameters
1812 (cp_parser *, cp_declarator *);
1813 static bool cp_parser_check_template_parameters
1814 (cp_parser *, unsigned);
1815 static tree cp_parser_simple_cast_expression
1817 static tree cp_parser_global_scope_opt
1818 (cp_parser *, bool);
1819 static bool cp_parser_constructor_declarator_p
1820 (cp_parser *, bool);
1821 static tree cp_parser_function_definition_from_specifiers_and_declarator
1822 (cp_parser *, cp_decl_specifier_seq *, tree, const cp_declarator *);
1823 static tree cp_parser_function_definition_after_declarator
1824 (cp_parser *, bool);
1825 static void cp_parser_template_declaration_after_export
1826 (cp_parser *, bool);
1827 static void cp_parser_perform_template_parameter_access_checks
1828 (VEC (deferred_access_check,gc)*);
1829 static tree cp_parser_single_declaration
1830 (cp_parser *, VEC (deferred_access_check,gc)*, bool, bool *);
1831 static tree cp_parser_functional_cast
1832 (cp_parser *, tree);
1833 static tree cp_parser_save_member_function_body
1834 (cp_parser *, cp_decl_specifier_seq *, cp_declarator *, tree);
1835 static tree cp_parser_enclosed_template_argument_list
1837 static void cp_parser_save_default_args
1838 (cp_parser *, tree);
1839 static void cp_parser_late_parsing_for_member
1840 (cp_parser *, tree);
1841 static void cp_parser_late_parsing_default_args
1842 (cp_parser *, tree);
1843 static tree cp_parser_sizeof_operand
1844 (cp_parser *, enum rid);
1845 static bool cp_parser_declares_only_class_p
1847 static void cp_parser_set_storage_class
1848 (cp_parser *, cp_decl_specifier_seq *, enum rid);
1849 static void cp_parser_set_decl_spec_type
1850 (cp_decl_specifier_seq *, tree, bool);
1851 static bool cp_parser_friend_p
1852 (const cp_decl_specifier_seq *);
1853 static cp_token *cp_parser_require
1854 (cp_parser *, enum cpp_ttype, const char *);
1855 static cp_token *cp_parser_require_keyword
1856 (cp_parser *, enum rid, const char *);
1857 static bool cp_parser_token_starts_function_definition_p
1859 static bool cp_parser_next_token_starts_class_definition_p
1861 static bool cp_parser_next_token_ends_template_argument_p
1863 static bool cp_parser_nth_token_starts_template_argument_list_p
1864 (cp_parser *, size_t);
1865 static enum tag_types cp_parser_token_is_class_key
1867 static void cp_parser_check_class_key
1868 (enum tag_types, tree type);
1869 static void cp_parser_check_access_in_redeclaration
1871 static bool cp_parser_optional_template_keyword
1873 static void cp_parser_pre_parsed_nested_name_specifier
1875 static void cp_parser_cache_group
1876 (cp_parser *, enum cpp_ttype, unsigned);
1877 static void cp_parser_parse_tentatively
1879 static void cp_parser_commit_to_tentative_parse
1881 static void cp_parser_abort_tentative_parse
1883 static bool cp_parser_parse_definitely
1885 static inline bool cp_parser_parsing_tentatively
1887 static bool cp_parser_uncommitted_to_tentative_parse_p
1889 static void cp_parser_error
1890 (cp_parser *, const char *);
1891 static void cp_parser_name_lookup_error
1892 (cp_parser *, tree, tree, const char *);
1893 static bool cp_parser_simulate_error
1895 static bool cp_parser_check_type_definition
1897 static void cp_parser_check_for_definition_in_return_type
1898 (cp_declarator *, tree);
1899 static void cp_parser_check_for_invalid_template_id
1900 (cp_parser *, tree);
1901 static bool cp_parser_non_integral_constant_expression
1902 (cp_parser *, const char *);
1903 static void cp_parser_diagnose_invalid_type_name
1904 (cp_parser *, tree, tree);
1905 static bool cp_parser_parse_and_diagnose_invalid_type_name
1907 static int cp_parser_skip_to_closing_parenthesis
1908 (cp_parser *, bool, bool, bool);
1909 static void cp_parser_skip_to_end_of_statement
1911 static void cp_parser_consume_semicolon_at_end_of_statement
1913 static void cp_parser_skip_to_end_of_block_or_statement
1915 static void cp_parser_skip_to_closing_brace
1917 static void cp_parser_skip_to_end_of_template_parameter_list
1919 static void cp_parser_skip_to_pragma_eol
1920 (cp_parser*, cp_token *);
1921 static bool cp_parser_error_occurred
1923 static bool cp_parser_allow_gnu_extensions_p
1925 static bool cp_parser_is_string_literal
1927 static bool cp_parser_is_keyword
1928 (cp_token *, enum rid);
1929 static tree cp_parser_make_typename_type
1930 (cp_parser *, tree, tree);
1932 /* Returns nonzero if we are parsing tentatively. */
1935 cp_parser_parsing_tentatively (cp_parser* parser)
1937 return parser->context->next != NULL;
1940 /* Returns nonzero if TOKEN is a string literal. */
1943 cp_parser_is_string_literal (cp_token* token)
1945 return (token->type == CPP_STRING || token->type == CPP_WSTRING);
1948 /* Returns nonzero if TOKEN is the indicated KEYWORD. */
1951 cp_parser_is_keyword (cp_token* token, enum rid keyword)
1953 return token->keyword == keyword;
1956 /* If not parsing tentatively, issue a diagnostic of the form
1957 FILE:LINE: MESSAGE before TOKEN
1958 where TOKEN is the next token in the input stream. MESSAGE
1959 (specified by the caller) is usually of the form "expected
1963 cp_parser_error (cp_parser* parser, const char* message)
1965 if (!cp_parser_simulate_error (parser))
1967 cp_token *token = cp_lexer_peek_token (parser->lexer);
1968 /* This diagnostic makes more sense if it is tagged to the line
1969 of the token we just peeked at. */
1970 cp_lexer_set_source_position_from_token (token);
1972 if (token->type == CPP_PRAGMA)
1974 error ("%<#pragma%> is not allowed here");
1975 cp_parser_skip_to_pragma_eol (parser, token);
1979 c_parse_error (message,
1980 /* Because c_parser_error does not understand
1981 CPP_KEYWORD, keywords are treated like
1983 (token->type == CPP_KEYWORD ? CPP_NAME : token->type),
1988 /* Issue an error about name-lookup failing. NAME is the
1989 IDENTIFIER_NODE DECL is the result of
1990 the lookup (as returned from cp_parser_lookup_name). DESIRED is
1991 the thing that we hoped to find. */
1994 cp_parser_name_lookup_error (cp_parser* parser,
1997 const char* desired)
1999 /* If name lookup completely failed, tell the user that NAME was not
2001 if (decl == error_mark_node)
2003 if (parser->scope && parser->scope != global_namespace)
2004 error ("%<%D::%D%> has not been declared",
2005 parser->scope, name);
2006 else if (parser->scope == global_namespace)
2007 error ("%<::%D%> has not been declared", name);
2008 else if (parser->object_scope
2009 && !CLASS_TYPE_P (parser->object_scope))
2010 error ("request for member %qD in non-class type %qT",
2011 name, parser->object_scope);
2012 else if (parser->object_scope)
2013 error ("%<%T::%D%> has not been declared",
2014 parser->object_scope, name);
2016 error ("%qD has not been declared", name);
2018 else if (parser->scope && parser->scope != global_namespace)
2019 error ("%<%D::%D%> %s", parser->scope, name, desired);
2020 else if (parser->scope == global_namespace)
2021 error ("%<::%D%> %s", name, desired);
2023 error ("%qD %s", name, desired);
2026 /* If we are parsing tentatively, remember that an error has occurred
2027 during this tentative parse. Returns true if the error was
2028 simulated; false if a message should be issued by the caller. */
2031 cp_parser_simulate_error (cp_parser* parser)
2033 if (cp_parser_uncommitted_to_tentative_parse_p (parser))
2035 parser->context->status = CP_PARSER_STATUS_KIND_ERROR;
2041 /* Check for repeated decl-specifiers. */
2044 cp_parser_check_decl_spec (cp_decl_specifier_seq *decl_specs)
2048 for (ds = ds_first; ds != ds_last; ++ds)
2050 unsigned count = decl_specs->specs[(int)ds];
2053 /* The "long" specifier is a special case because of "long long". */
2057 error ("%<long long long%> is too long for GCC");
2058 else if (pedantic && !in_system_header && warn_long_long)
2059 pedwarn ("ISO C++ does not support %<long long%>");
2063 static const char *const decl_spec_names[] = {
2079 error ("duplicate %qs", decl_spec_names[(int)ds]);
2084 /* This function is called when a type is defined. If type
2085 definitions are forbidden at this point, an error message is
2089 cp_parser_check_type_definition (cp_parser* parser)
2091 /* If types are forbidden here, issue a message. */
2092 if (parser->type_definition_forbidden_message)
2094 /* Use `%s' to print the string in case there are any escape
2095 characters in the message. */
2096 error ("%s", parser->type_definition_forbidden_message);
2102 /* This function is called when the DECLARATOR is processed. The TYPE
2103 was a type defined in the decl-specifiers. If it is invalid to
2104 define a type in the decl-specifiers for DECLARATOR, an error is
2108 cp_parser_check_for_definition_in_return_type (cp_declarator *declarator,
2111 /* [dcl.fct] forbids type definitions in return types.
2112 Unfortunately, it's not easy to know whether or not we are
2113 processing a return type until after the fact. */
2115 && (declarator->kind == cdk_pointer
2116 || declarator->kind == cdk_reference
2117 || declarator->kind == cdk_ptrmem))
2118 declarator = declarator->declarator;
2120 && declarator->kind == cdk_function)
2122 error ("new types may not be defined in a return type");
2123 inform ("(perhaps a semicolon is missing after the definition of %qT)",
2128 /* A type-specifier (TYPE) has been parsed which cannot be followed by
2129 "<" in any valid C++ program. If the next token is indeed "<",
2130 issue a message warning the user about what appears to be an
2131 invalid attempt to form a template-id. */
2134 cp_parser_check_for_invalid_template_id (cp_parser* parser,
2137 cp_token_position start = 0;
2139 if (cp_lexer_next_token_is (parser->lexer, CPP_LESS))
2142 error ("%qT is not a template", type);
2143 else if (TREE_CODE (type) == IDENTIFIER_NODE)
2144 error ("%qE is not a template", type);
2146 error ("invalid template-id");
2147 /* Remember the location of the invalid "<". */
2148 if (cp_parser_uncommitted_to_tentative_parse_p (parser))
2149 start = cp_lexer_token_position (parser->lexer, true);
2150 /* Consume the "<". */
2151 cp_lexer_consume_token (parser->lexer);
2152 /* Parse the template arguments. */
2153 cp_parser_enclosed_template_argument_list (parser);
2154 /* Permanently remove the invalid template arguments so that
2155 this error message is not issued again. */
2157 cp_lexer_purge_tokens_after (parser->lexer, start);
2161 /* If parsing an integral constant-expression, issue an error message
2162 about the fact that THING appeared and return true. Otherwise,
2163 return false. In either case, set
2164 PARSER->NON_INTEGRAL_CONSTANT_EXPRESSION_P. */
2167 cp_parser_non_integral_constant_expression (cp_parser *parser,
2170 parser->non_integral_constant_expression_p = true;
2171 if (parser->integral_constant_expression_p)
2173 if (!parser->allow_non_integral_constant_expression_p)
2175 error ("%s cannot appear in a constant-expression", thing);
2182 /* Emit a diagnostic for an invalid type name. SCOPE is the
2183 qualifying scope (or NULL, if none) for ID. This function commits
2184 to the current active tentative parse, if any. (Otherwise, the
2185 problematic construct might be encountered again later, resulting
2186 in duplicate error messages.) */
2189 cp_parser_diagnose_invalid_type_name (cp_parser *parser, tree scope, tree id)
2191 tree decl, old_scope;
2192 /* Try to lookup the identifier. */
2193 old_scope = parser->scope;
2194 parser->scope = scope;
2195 decl = cp_parser_lookup_name_simple (parser, id);
2196 parser->scope = old_scope;
2197 /* If the lookup found a template-name, it means that the user forgot
2198 to specify an argument list. Emit a useful error message. */
2199 if (TREE_CODE (decl) == TEMPLATE_DECL)
2200 error ("invalid use of template-name %qE without an argument list", decl);
2201 else if (TREE_CODE (id) == BIT_NOT_EXPR)
2202 error ("invalid use of destructor %qD as a type", id);
2203 else if (TREE_CODE (decl) == TYPE_DECL)
2204 /* Something like 'unsigned A a;' */
2205 error ("invalid combination of multiple type-specifiers");
2206 else if (!parser->scope)
2208 /* Issue an error message. */
2209 error ("%qE does not name a type", id);
2210 /* If we're in a template class, it's possible that the user was
2211 referring to a type from a base class. For example:
2213 template <typename T> struct A { typedef T X; };
2214 template <typename T> struct B : public A<T> { X x; };
2216 The user should have said "typename A<T>::X". */
2217 if (processing_template_decl && current_class_type
2218 && TYPE_BINFO (current_class_type))
2222 for (b = TREE_CHAIN (TYPE_BINFO (current_class_type));
2226 tree base_type = BINFO_TYPE (b);
2227 if (CLASS_TYPE_P (base_type)
2228 && dependent_type_p (base_type))
2231 /* Go from a particular instantiation of the
2232 template (which will have an empty TYPE_FIELDs),
2233 to the main version. */
2234 base_type = CLASSTYPE_PRIMARY_TEMPLATE_TYPE (base_type);
2235 for (field = TYPE_FIELDS (base_type);
2237 field = TREE_CHAIN (field))
2238 if (TREE_CODE (field) == TYPE_DECL
2239 && DECL_NAME (field) == id)
2241 inform ("(perhaps %<typename %T::%E%> was intended)",
2242 BINFO_TYPE (b), id);
2251 /* Here we diagnose qualified-ids where the scope is actually correct,
2252 but the identifier does not resolve to a valid type name. */
2253 else if (parser->scope != error_mark_node)
2255 if (TREE_CODE (parser->scope) == NAMESPACE_DECL)
2256 error ("%qE in namespace %qE does not name a type",
2258 else if (TYPE_P (parser->scope))
2259 error ("%qE in class %qT does not name a type", id, parser->scope);
2263 cp_parser_commit_to_tentative_parse (parser);
2266 /* Check for a common situation where a type-name should be present,
2267 but is not, and issue a sensible error message. Returns true if an
2268 invalid type-name was detected.
2270 The situation handled by this function are variable declarations of the
2271 form `ID a', where `ID' is an id-expression and `a' is a plain identifier.
2272 Usually, `ID' should name a type, but if we got here it means that it
2273 does not. We try to emit the best possible error message depending on
2274 how exactly the id-expression looks like. */
2277 cp_parser_parse_and_diagnose_invalid_type_name (cp_parser *parser)
2281 cp_parser_parse_tentatively (parser);
2282 id = cp_parser_id_expression (parser,
2283 /*template_keyword_p=*/false,
2284 /*check_dependency_p=*/true,
2285 /*template_p=*/NULL,
2286 /*declarator_p=*/true,
2287 /*optional_p=*/false);
2288 /* After the id-expression, there should be a plain identifier,
2289 otherwise this is not a simple variable declaration. Also, if
2290 the scope is dependent, we cannot do much. */
2291 if (!cp_lexer_next_token_is (parser->lexer, CPP_NAME)
2292 || (parser->scope && TYPE_P (parser->scope)
2293 && dependent_type_p (parser->scope)))
2295 cp_parser_abort_tentative_parse (parser);
2298 if (!cp_parser_parse_definitely (parser) || TREE_CODE (id) == TYPE_DECL)
2301 /* Emit a diagnostic for the invalid type. */
2302 cp_parser_diagnose_invalid_type_name (parser, parser->scope, id);
2303 /* Skip to the end of the declaration; there's no point in
2304 trying to process it. */
2305 cp_parser_skip_to_end_of_block_or_statement (parser);
2309 /* Consume tokens up to, and including, the next non-nested closing `)'.
2310 Returns 1 iff we found a closing `)'. RECOVERING is true, if we
2311 are doing error recovery. Returns -1 if OR_COMMA is true and we
2312 found an unnested comma. */
2315 cp_parser_skip_to_closing_parenthesis (cp_parser *parser,
2320 unsigned paren_depth = 0;
2321 unsigned brace_depth = 0;
2323 if (recovering && !or_comma
2324 && cp_parser_uncommitted_to_tentative_parse_p (parser))
2329 cp_token * token = cp_lexer_peek_token (parser->lexer);
2331 switch (token->type)
2334 case CPP_PRAGMA_EOL:
2335 /* If we've run out of tokens, then there is no closing `)'. */
2339 /* This matches the processing in skip_to_end_of_statement. */
2344 case CPP_OPEN_BRACE:
2347 case CPP_CLOSE_BRACE:
2353 if (recovering && or_comma && !brace_depth && !paren_depth)
2357 case CPP_OPEN_PAREN:
2362 case CPP_CLOSE_PAREN:
2363 if (!brace_depth && !paren_depth--)
2366 cp_lexer_consume_token (parser->lexer);
2375 /* Consume the token. */
2376 cp_lexer_consume_token (parser->lexer);
2380 /* Consume tokens until we reach the end of the current statement.
2381 Normally, that will be just before consuming a `;'. However, if a
2382 non-nested `}' comes first, then we stop before consuming that. */
2385 cp_parser_skip_to_end_of_statement (cp_parser* parser)
2387 unsigned nesting_depth = 0;
2391 cp_token *token = cp_lexer_peek_token (parser->lexer);
2393 switch (token->type)
2396 case CPP_PRAGMA_EOL:
2397 /* If we've run out of tokens, stop. */
2401 /* If the next token is a `;', we have reached the end of the
2407 case CPP_CLOSE_BRACE:
2408 /* If this is a non-nested '}', stop before consuming it.
2409 That way, when confronted with something like:
2413 we stop before consuming the closing '}', even though we
2414 have not yet reached a `;'. */
2415 if (nesting_depth == 0)
2418 /* If it is the closing '}' for a block that we have
2419 scanned, stop -- but only after consuming the token.
2425 we will stop after the body of the erroneously declared
2426 function, but before consuming the following `typedef'
2428 if (--nesting_depth == 0)
2430 cp_lexer_consume_token (parser->lexer);
2434 case CPP_OPEN_BRACE:
2442 /* Consume the token. */
2443 cp_lexer_consume_token (parser->lexer);
2447 /* This function is called at the end of a statement or declaration.
2448 If the next token is a semicolon, it is consumed; otherwise, error
2449 recovery is attempted. */
2452 cp_parser_consume_semicolon_at_end_of_statement (cp_parser *parser)
2454 /* Look for the trailing `;'. */
2455 if (!cp_parser_require (parser, CPP_SEMICOLON, "`;'"))
2457 /* If there is additional (erroneous) input, skip to the end of
2459 cp_parser_skip_to_end_of_statement (parser);
2460 /* If the next token is now a `;', consume it. */
2461 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
2462 cp_lexer_consume_token (parser->lexer);
2466 /* Skip tokens until we have consumed an entire block, or until we
2467 have consumed a non-nested `;'. */
2470 cp_parser_skip_to_end_of_block_or_statement (cp_parser* parser)
2472 int nesting_depth = 0;
2474 while (nesting_depth >= 0)
2476 cp_token *token = cp_lexer_peek_token (parser->lexer);
2478 switch (token->type)
2481 case CPP_PRAGMA_EOL:
2482 /* If we've run out of tokens, stop. */
2486 /* Stop if this is an unnested ';'. */
2491 case CPP_CLOSE_BRACE:
2492 /* Stop if this is an unnested '}', or closes the outermost
2499 case CPP_OPEN_BRACE:
2508 /* Consume the token. */
2509 cp_lexer_consume_token (parser->lexer);
2513 /* Skip tokens until a non-nested closing curly brace is the next
2517 cp_parser_skip_to_closing_brace (cp_parser *parser)
2519 unsigned nesting_depth = 0;
2523 cp_token *token = cp_lexer_peek_token (parser->lexer);
2525 switch (token->type)
2528 case CPP_PRAGMA_EOL:
2529 /* If we've run out of tokens, stop. */
2532 case CPP_CLOSE_BRACE:
2533 /* If the next token is a non-nested `}', then we have reached
2534 the end of the current block. */
2535 if (nesting_depth-- == 0)
2539 case CPP_OPEN_BRACE:
2540 /* If it the next token is a `{', then we are entering a new
2541 block. Consume the entire block. */
2549 /* Consume the token. */
2550 cp_lexer_consume_token (parser->lexer);
2554 /* Consume tokens until we reach the end of the pragma. The PRAGMA_TOK
2555 parameter is the PRAGMA token, allowing us to purge the entire pragma
2559 cp_parser_skip_to_pragma_eol (cp_parser* parser, cp_token *pragma_tok)
2563 parser->lexer->in_pragma = false;
2566 token = cp_lexer_consume_token (parser->lexer);
2567 while (token->type != CPP_PRAGMA_EOL && token->type != CPP_EOF);
2569 /* Ensure that the pragma is not parsed again. */
2570 cp_lexer_purge_tokens_after (parser->lexer, pragma_tok);
2573 /* Require pragma end of line, resyncing with it as necessary. The
2574 arguments are as for cp_parser_skip_to_pragma_eol. */
2577 cp_parser_require_pragma_eol (cp_parser *parser, cp_token *pragma_tok)
2579 parser->lexer->in_pragma = false;
2580 if (!cp_parser_require (parser, CPP_PRAGMA_EOL, "end of line"))
2581 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
2584 /* This is a simple wrapper around make_typename_type. When the id is
2585 an unresolved identifier node, we can provide a superior diagnostic
2586 using cp_parser_diagnose_invalid_type_name. */
2589 cp_parser_make_typename_type (cp_parser *parser, tree scope, tree id)
2592 if (TREE_CODE (id) == IDENTIFIER_NODE)
2594 result = make_typename_type (scope, id, typename_type,
2595 /*complain=*/tf_none);
2596 if (result == error_mark_node)
2597 cp_parser_diagnose_invalid_type_name (parser, scope, id);
2600 return make_typename_type (scope, id, typename_type, tf_error);
2604 /* Create a new C++ parser. */
2607 cp_parser_new (void)
2613 /* cp_lexer_new_main is called before calling ggc_alloc because
2614 cp_lexer_new_main might load a PCH file. */
2615 lexer = cp_lexer_new_main ();
2617 /* Initialize the binops_by_token so that we can get the tree
2618 directly from the token. */
2619 for (i = 0; i < sizeof (binops) / sizeof (binops[0]); i++)
2620 binops_by_token[binops[i].token_type] = binops[i];
2622 parser = GGC_CNEW (cp_parser);
2623 parser->lexer = lexer;
2624 parser->context = cp_parser_context_new (NULL);
2626 /* For now, we always accept GNU extensions. */
2627 parser->allow_gnu_extensions_p = 1;
2629 /* The `>' token is a greater-than operator, not the end of a
2631 parser->greater_than_is_operator_p = true;
2633 parser->default_arg_ok_p = true;
2635 /* We are not parsing a constant-expression. */
2636 parser->integral_constant_expression_p = false;
2637 parser->allow_non_integral_constant_expression_p = false;
2638 parser->non_integral_constant_expression_p = false;
2640 /* Local variable names are not forbidden. */
2641 parser->local_variables_forbidden_p = false;
2643 /* We are not processing an `extern "C"' declaration. */
2644 parser->in_unbraced_linkage_specification_p = false;
2646 /* We are not processing a declarator. */
2647 parser->in_declarator_p = false;
2649 /* We are not processing a template-argument-list. */
2650 parser->in_template_argument_list_p = false;
2652 /* We are not in an iteration statement. */
2653 parser->in_statement = 0;
2655 /* We are not in a switch statement. */
2656 parser->in_switch_statement_p = false;
2658 /* We are not parsing a type-id inside an expression. */
2659 parser->in_type_id_in_expr_p = false;
2661 /* Declarations aren't implicitly extern "C". */
2662 parser->implicit_extern_c = false;
2664 /* String literals should be translated to the execution character set. */
2665 parser->translate_strings_p = true;
2667 /* We are not parsing a function body. */
2668 parser->in_function_body = false;
2670 /* The unparsed function queue is empty. */
2671 parser->unparsed_functions_queues = build_tree_list (NULL_TREE, NULL_TREE);
2673 /* There are no classes being defined. */
2674 parser->num_classes_being_defined = 0;
2676 /* No template parameters apply. */
2677 parser->num_template_parameter_lists = 0;
2682 /* Create a cp_lexer structure which will emit the tokens in CACHE
2683 and push it onto the parser's lexer stack. This is used for delayed
2684 parsing of in-class method bodies and default arguments, and should
2685 not be confused with tentative parsing. */
2687 cp_parser_push_lexer_for_tokens (cp_parser *parser, cp_token_cache *cache)
2689 cp_lexer *lexer = cp_lexer_new_from_tokens (cache);
2690 lexer->next = parser->lexer;
2691 parser->lexer = lexer;
2693 /* Move the current source position to that of the first token in the
2695 cp_lexer_set_source_position_from_token (lexer->next_token);
2698 /* Pop the top lexer off the parser stack. This is never used for the
2699 "main" lexer, only for those pushed by cp_parser_push_lexer_for_tokens. */
2701 cp_parser_pop_lexer (cp_parser *parser)
2703 cp_lexer *lexer = parser->lexer;
2704 parser->lexer = lexer->next;
2705 cp_lexer_destroy (lexer);
2707 /* Put the current source position back where it was before this
2708 lexer was pushed. */
2709 cp_lexer_set_source_position_from_token (parser->lexer->next_token);
2712 /* Lexical conventions [gram.lex] */
2714 /* Parse an identifier. Returns an IDENTIFIER_NODE representing the
2718 cp_parser_identifier (cp_parser* parser)
2722 /* Look for the identifier. */
2723 token = cp_parser_require (parser, CPP_NAME, "identifier");
2724 /* Return the value. */
2725 return token ? token->u.value : error_mark_node;
2728 /* Parse a sequence of adjacent string constants. Returns a
2729 TREE_STRING representing the combined, nul-terminated string
2730 constant. If TRANSLATE is true, translate the string to the
2731 execution character set. If WIDE_OK is true, a wide string is
2734 C++98 [lex.string] says that if a narrow string literal token is
2735 adjacent to a wide string literal token, the behavior is undefined.
2736 However, C99 6.4.5p4 says that this results in a wide string literal.
2737 We follow C99 here, for consistency with the C front end.
2739 This code is largely lifted from lex_string() in c-lex.c.
2741 FUTURE: ObjC++ will need to handle @-strings here. */
2743 cp_parser_string_literal (cp_parser *parser, bool translate, bool wide_ok)
2748 struct obstack str_ob;
2749 cpp_string str, istr, *strs;
2752 tok = cp_lexer_peek_token (parser->lexer);
2753 if (!cp_parser_is_string_literal (tok))
2755 cp_parser_error (parser, "expected string-literal");
2756 return error_mark_node;
2759 /* Try to avoid the overhead of creating and destroying an obstack
2760 for the common case of just one string. */
2761 if (!cp_parser_is_string_literal
2762 (cp_lexer_peek_nth_token (parser->lexer, 2)))
2764 cp_lexer_consume_token (parser->lexer);
2766 str.text = (const unsigned char *)TREE_STRING_POINTER (tok->u.value);
2767 str.len = TREE_STRING_LENGTH (tok->u.value);
2769 if (tok->type == CPP_WSTRING)
2776 gcc_obstack_init (&str_ob);
2781 cp_lexer_consume_token (parser->lexer);
2783 str.text = (unsigned char *)TREE_STRING_POINTER (tok->u.value);
2784 str.len = TREE_STRING_LENGTH (tok->u.value);
2785 if (tok->type == CPP_WSTRING)
2788 obstack_grow (&str_ob, &str, sizeof (cpp_string));
2790 tok = cp_lexer_peek_token (parser->lexer);
2792 while (cp_parser_is_string_literal (tok));
2794 strs = (cpp_string *) obstack_finish (&str_ob);
2797 if (wide && !wide_ok)
2799 cp_parser_error (parser, "a wide string is invalid in this context");
2803 if ((translate ? cpp_interpret_string : cpp_interpret_string_notranslate)
2804 (parse_in, strs, count, &istr, wide))
2806 value = build_string (istr.len, (char *)istr.text);
2807 free ((void *)istr.text);
2809 TREE_TYPE (value) = wide ? wchar_array_type_node : char_array_type_node;
2810 value = fix_string_type (value);
2813 /* cpp_interpret_string has issued an error. */
2814 value = error_mark_node;
2817 obstack_free (&str_ob, 0);
2823 /* Basic concepts [gram.basic] */
2825 /* Parse a translation-unit.
2828 declaration-seq [opt]
2830 Returns TRUE if all went well. */
2833 cp_parser_translation_unit (cp_parser* parser)
2835 /* The address of the first non-permanent object on the declarator
2837 static void *declarator_obstack_base;
2841 /* Create the declarator obstack, if necessary. */
2842 if (!cp_error_declarator)
2844 gcc_obstack_init (&declarator_obstack);
2845 /* Create the error declarator. */
2846 cp_error_declarator = make_declarator (cdk_error);
2847 /* Create the empty parameter list. */
2848 no_parameters = make_parameter_declarator (NULL, NULL, NULL_TREE);
2849 /* Remember where the base of the declarator obstack lies. */
2850 declarator_obstack_base = obstack_next_free (&declarator_obstack);
2853 cp_parser_declaration_seq_opt (parser);
2855 /* If there are no tokens left then all went well. */
2856 if (cp_lexer_next_token_is (parser->lexer, CPP_EOF))
2858 /* Get rid of the token array; we don't need it any more. */
2859 cp_lexer_destroy (parser->lexer);
2860 parser->lexer = NULL;
2862 /* This file might have been a context that's implicitly extern
2863 "C". If so, pop the lang context. (Only relevant for PCH.) */
2864 if (parser->implicit_extern_c)
2866 pop_lang_context ();
2867 parser->implicit_extern_c = false;
2871 finish_translation_unit ();
2877 cp_parser_error (parser, "expected declaration");
2881 /* Make sure the declarator obstack was fully cleaned up. */
2882 gcc_assert (obstack_next_free (&declarator_obstack)
2883 == declarator_obstack_base);
2885 /* All went well. */
2889 /* Expressions [gram.expr] */
2891 /* Parse a primary-expression.
2902 ( compound-statement )
2903 __builtin_va_arg ( assignment-expression , type-id )
2904 __builtin_offsetof ( type-id , offsetof-expression )
2906 Objective-C++ Extension:
2914 ADDRESS_P is true iff this expression was immediately preceded by
2915 "&" and therefore might denote a pointer-to-member. CAST_P is true
2916 iff this expression is the target of a cast. TEMPLATE_ARG_P is
2917 true iff this expression is a template argument.
2919 Returns a representation of the expression. Upon return, *IDK
2920 indicates what kind of id-expression (if any) was present. */
2923 cp_parser_primary_expression (cp_parser *parser,
2926 bool template_arg_p,
2931 /* Assume the primary expression is not an id-expression. */
2932 *idk = CP_ID_KIND_NONE;
2934 /* Peek at the next token. */
2935 token = cp_lexer_peek_token (parser->lexer);
2936 switch (token->type)
2947 token = cp_lexer_consume_token (parser->lexer);
2948 /* Floating-point literals are only allowed in an integral
2949 constant expression if they are cast to an integral or
2950 enumeration type. */
2951 if (TREE_CODE (token->u.value) == REAL_CST
2952 && parser->integral_constant_expression_p
2955 /* CAST_P will be set even in invalid code like "int(2.7 +
2956 ...)". Therefore, we have to check that the next token
2957 is sure to end the cast. */
2960 cp_token *next_token;
2962 next_token = cp_lexer_peek_token (parser->lexer);
2963 if (/* The comma at the end of an
2964 enumerator-definition. */
2965 next_token->type != CPP_COMMA
2966 /* The curly brace at the end of an enum-specifier. */
2967 && next_token->type != CPP_CLOSE_BRACE
2968 /* The end of a statement. */
2969 && next_token->type != CPP_SEMICOLON
2970 /* The end of the cast-expression. */
2971 && next_token->type != CPP_CLOSE_PAREN
2972 /* The end of an array bound. */
2973 && next_token->type != CPP_CLOSE_SQUARE
2974 /* The closing ">" in a template-argument-list. */
2975 && (next_token->type != CPP_GREATER
2976 || parser->greater_than_is_operator_p))
2980 /* If we are within a cast, then the constraint that the
2981 cast is to an integral or enumeration type will be
2982 checked at that point. If we are not within a cast, then
2983 this code is invalid. */
2985 cp_parser_non_integral_constant_expression
2986 (parser, "floating-point literal");
2988 return token->u.value;
2992 /* ??? Should wide strings be allowed when parser->translate_strings_p
2993 is false (i.e. in attributes)? If not, we can kill the third
2994 argument to cp_parser_string_literal. */
2995 return cp_parser_string_literal (parser,
2996 parser->translate_strings_p,
2999 case CPP_OPEN_PAREN:
3002 bool saved_greater_than_is_operator_p;
3004 /* Consume the `('. */
3005 cp_lexer_consume_token (parser->lexer);
3006 /* Within a parenthesized expression, a `>' token is always
3007 the greater-than operator. */
3008 saved_greater_than_is_operator_p
3009 = parser->greater_than_is_operator_p;
3010 parser->greater_than_is_operator_p = true;
3011 /* If we see `( { ' then we are looking at the beginning of
3012 a GNU statement-expression. */
3013 if (cp_parser_allow_gnu_extensions_p (parser)
3014 && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
3016 /* Statement-expressions are not allowed by the standard. */
3018 pedwarn ("ISO C++ forbids braced-groups within expressions");
3020 /* And they're not allowed outside of a function-body; you
3021 cannot, for example, write:
3023 int i = ({ int j = 3; j + 1; });
3025 at class or namespace scope. */
3026 if (!parser->in_function_body)
3028 error ("statement-expressions are allowed only inside functions");
3029 cp_parser_skip_to_end_of_block_or_statement (parser);
3030 expr = error_mark_node;
3034 /* Start the statement-expression. */
3035 expr = begin_stmt_expr ();
3036 /* Parse the compound-statement. */
3037 cp_parser_compound_statement (parser, expr, false);
3039 expr = finish_stmt_expr (expr, false);
3044 /* Parse the parenthesized expression. */
3045 expr = cp_parser_expression (parser, cast_p);
3046 /* Let the front end know that this expression was
3047 enclosed in parentheses. This matters in case, for
3048 example, the expression is of the form `A::B', since
3049 `&A::B' might be a pointer-to-member, but `&(A::B)' is
3051 finish_parenthesized_expr (expr);
3053 /* The `>' token might be the end of a template-id or
3054 template-parameter-list now. */
3055 parser->greater_than_is_operator_p
3056 = saved_greater_than_is_operator_p;
3057 /* Consume the `)'. */
3058 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"))
3059 cp_parser_skip_to_end_of_statement (parser);
3065 switch (token->keyword)
3067 /* These two are the boolean literals. */
3069 cp_lexer_consume_token (parser->lexer);
3070 return boolean_true_node;
3072 cp_lexer_consume_token (parser->lexer);
3073 return boolean_false_node;
3075 /* The `__null' literal. */
3077 cp_lexer_consume_token (parser->lexer);
3080 /* Recognize the `this' keyword. */
3082 cp_lexer_consume_token (parser->lexer);
3083 if (parser->local_variables_forbidden_p)
3085 error ("%<this%> may not be used in this context");
3086 return error_mark_node;
3088 /* Pointers cannot appear in constant-expressions. */
3089 if (cp_parser_non_integral_constant_expression (parser,
3091 return error_mark_node;
3092 return finish_this_expr ();
3094 /* The `operator' keyword can be the beginning of an
3099 case RID_FUNCTION_NAME:
3100 case RID_PRETTY_FUNCTION_NAME:
3101 case RID_C99_FUNCTION_NAME:
3102 /* The symbols __FUNCTION__, __PRETTY_FUNCTION__, and
3103 __func__ are the names of variables -- but they are
3104 treated specially. Therefore, they are handled here,
3105 rather than relying on the generic id-expression logic
3106 below. Grammatically, these names are id-expressions.
3108 Consume the token. */
3109 token = cp_lexer_consume_token (parser->lexer);
3110 /* Look up the name. */
3111 return finish_fname (token->u.value);
3118 /* The `__builtin_va_arg' construct is used to handle
3119 `va_arg'. Consume the `__builtin_va_arg' token. */
3120 cp_lexer_consume_token (parser->lexer);
3121 /* Look for the opening `('. */
3122 cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
3123 /* Now, parse the assignment-expression. */
3124 expression = cp_parser_assignment_expression (parser,
3126 /* Look for the `,'. */
3127 cp_parser_require (parser, CPP_COMMA, "`,'");
3128 /* Parse the type-id. */
3129 type = cp_parser_type_id (parser);
3130 /* Look for the closing `)'. */
3131 cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
3132 /* Using `va_arg' in a constant-expression is not
3134 if (cp_parser_non_integral_constant_expression (parser,
3136 return error_mark_node;
3137 return build_x_va_arg (expression, type);
3141 return cp_parser_builtin_offsetof (parser);
3143 /* Objective-C++ expressions. */
3145 case RID_AT_PROTOCOL:
3146 case RID_AT_SELECTOR:
3147 return cp_parser_objc_expression (parser);
3150 cp_parser_error (parser, "expected primary-expression");
3151 return error_mark_node;
3154 /* An id-expression can start with either an identifier, a
3155 `::' as the beginning of a qualified-id, or the "operator"
3159 case CPP_TEMPLATE_ID:
3160 case CPP_NESTED_NAME_SPECIFIER:
3164 const char *error_msg;
3169 /* Parse the id-expression. */
3171 = cp_parser_id_expression (parser,
3172 /*template_keyword_p=*/false,
3173 /*check_dependency_p=*/true,
3175 /*declarator_p=*/false,
3176 /*optional_p=*/false);
3177 if (id_expression == error_mark_node)
3178 return error_mark_node;
3179 token = cp_lexer_peek_token (parser->lexer);
3180 done = (token->type != CPP_OPEN_SQUARE
3181 && token->type != CPP_OPEN_PAREN
3182 && token->type != CPP_DOT
3183 && token->type != CPP_DEREF
3184 && token->type != CPP_PLUS_PLUS
3185 && token->type != CPP_MINUS_MINUS);
3186 /* If we have a template-id, then no further lookup is
3187 required. If the template-id was for a template-class, we
3188 will sometimes have a TYPE_DECL at this point. */
3189 if (TREE_CODE (id_expression) == TEMPLATE_ID_EXPR
3190 || TREE_CODE (id_expression) == TYPE_DECL)
3191 decl = id_expression;
3192 /* Look up the name. */
3195 tree ambiguous_decls;
3197 decl = cp_parser_lookup_name (parser, id_expression,
3200 /*is_namespace=*/false,
3201 /*check_dependency=*/true,
3203 /* If the lookup was ambiguous, an error will already have
3205 if (ambiguous_decls)
3206 return error_mark_node;
3208 /* In Objective-C++, an instance variable (ivar) may be preferred
3209 to whatever cp_parser_lookup_name() found. */
3210 decl = objc_lookup_ivar (decl, id_expression);
3212 /* If name lookup gives us a SCOPE_REF, then the
3213 qualifying scope was dependent. */
3214 if (TREE_CODE (decl) == SCOPE_REF)
3216 /* Check to see if DECL is a local variable in a context
3217 where that is forbidden. */
3218 if (parser->local_variables_forbidden_p
3219 && local_variable_p (decl))
3221 /* It might be that we only found DECL because we are
3222 trying to be generous with pre-ISO scoping rules.
3223 For example, consider:
3227 for (int i = 0; i < 10; ++i) {}
3228 extern void f(int j = i);
3231 Here, name look up will originally find the out
3232 of scope `i'. We need to issue a warning message,
3233 but then use the global `i'. */
3234 decl = check_for_out_of_scope_variable (decl);
3235 if (local_variable_p (decl))
3237 error ("local variable %qD may not appear in this context",
3239 return error_mark_node;
3244 decl = (finish_id_expression
3245 (id_expression, decl, parser->scope,
3247 parser->integral_constant_expression_p,
3248 parser->allow_non_integral_constant_expression_p,
3249 &parser->non_integral_constant_expression_p,
3250 template_p, done, address_p,
3254 cp_parser_error (parser, error_msg);
3258 /* Anything else is an error. */
3260 /* ...unless we have an Objective-C++ message or string literal, that is. */
3261 if (c_dialect_objc ()
3262 && (token->type == CPP_OPEN_SQUARE || token->type == CPP_OBJC_STRING))
3263 return cp_parser_objc_expression (parser);
3265 cp_parser_error (parser, "expected primary-expression");
3266 return error_mark_node;
3270 /* Parse an id-expression.
3277 :: [opt] nested-name-specifier template [opt] unqualified-id
3279 :: operator-function-id
3282 Return a representation of the unqualified portion of the
3283 identifier. Sets PARSER->SCOPE to the qualifying scope if there is
3284 a `::' or nested-name-specifier.
3286 Often, if the id-expression was a qualified-id, the caller will
3287 want to make a SCOPE_REF to represent the qualified-id. This
3288 function does not do this in order to avoid wastefully creating
3289 SCOPE_REFs when they are not required.
3291 If TEMPLATE_KEYWORD_P is true, then we have just seen the
3294 If CHECK_DEPENDENCY_P is false, then names are looked up inside
3295 uninstantiated templates.
3297 If *TEMPLATE_P is non-NULL, it is set to true iff the
3298 `template' keyword is used to explicitly indicate that the entity
3299 named is a template.
3301 If DECLARATOR_P is true, the id-expression is appearing as part of
3302 a declarator, rather than as part of an expression. */
3305 cp_parser_id_expression (cp_parser *parser,
3306 bool template_keyword_p,
3307 bool check_dependency_p,
3312 bool global_scope_p;
3313 bool nested_name_specifier_p;
3315 /* Assume the `template' keyword was not used. */
3317 *template_p = template_keyword_p;
3319 /* Look for the optional `::' operator. */
3321 = (cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/false)
3323 /* Look for the optional nested-name-specifier. */
3324 nested_name_specifier_p
3325 = (cp_parser_nested_name_specifier_opt (parser,
3326 /*typename_keyword_p=*/false,
3331 /* If there is a nested-name-specifier, then we are looking at
3332 the first qualified-id production. */
3333 if (nested_name_specifier_p)
3336 tree saved_object_scope;
3337 tree saved_qualifying_scope;
3338 tree unqualified_id;
3341 /* See if the next token is the `template' keyword. */
3343 template_p = &is_template;
3344 *template_p = cp_parser_optional_template_keyword (parser);
3345 /* Name lookup we do during the processing of the
3346 unqualified-id might obliterate SCOPE. */
3347 saved_scope = parser->scope;
3348 saved_object_scope = parser->object_scope;
3349 saved_qualifying_scope = parser->qualifying_scope;
3350 /* Process the final unqualified-id. */
3351 unqualified_id = cp_parser_unqualified_id (parser, *template_p,
3354 /*optional_p=*/false);
3355 /* Restore the SAVED_SCOPE for our caller. */
3356 parser->scope = saved_scope;
3357 parser->object_scope = saved_object_scope;
3358 parser->qualifying_scope = saved_qualifying_scope;
3360 return unqualified_id;
3362 /* Otherwise, if we are in global scope, then we are looking at one
3363 of the other qualified-id productions. */
3364 else if (global_scope_p)
3369 /* Peek at the next token. */
3370 token = cp_lexer_peek_token (parser->lexer);
3372 /* If it's an identifier, and the next token is not a "<", then
3373 we can avoid the template-id case. This is an optimization
3374 for this common case. */
3375 if (token->type == CPP_NAME
3376 && !cp_parser_nth_token_starts_template_argument_list_p
3378 return cp_parser_identifier (parser);
3380 cp_parser_parse_tentatively (parser);
3381 /* Try a template-id. */
3382 id = cp_parser_template_id (parser,
3383 /*template_keyword_p=*/false,
3384 /*check_dependency_p=*/true,
3386 /* If that worked, we're done. */
3387 if (cp_parser_parse_definitely (parser))
3390 /* Peek at the next token. (Changes in the token buffer may
3391 have invalidated the pointer obtained above.) */
3392 token = cp_lexer_peek_token (parser->lexer);
3394 switch (token->type)
3397 return cp_parser_identifier (parser);
3400 if (token->keyword == RID_OPERATOR)
3401 return cp_parser_operator_function_id (parser);
3405 cp_parser_error (parser, "expected id-expression");
3406 return error_mark_node;
3410 return cp_parser_unqualified_id (parser, template_keyword_p,
3411 /*check_dependency_p=*/true,
3416 /* Parse an unqualified-id.
3420 operator-function-id
3421 conversion-function-id
3425 If TEMPLATE_KEYWORD_P is TRUE, we have just seen the `template'
3426 keyword, in a construct like `A::template ...'.
3428 Returns a representation of unqualified-id. For the `identifier'
3429 production, an IDENTIFIER_NODE is returned. For the `~ class-name'
3430 production a BIT_NOT_EXPR is returned; the operand of the
3431 BIT_NOT_EXPR is an IDENTIFIER_NODE for the class-name. For the
3432 other productions, see the documentation accompanying the
3433 corresponding parsing functions. If CHECK_DEPENDENCY_P is false,
3434 names are looked up in uninstantiated templates. If DECLARATOR_P
3435 is true, the unqualified-id is appearing as part of a declarator,
3436 rather than as part of an expression. */
3439 cp_parser_unqualified_id (cp_parser* parser,
3440 bool template_keyword_p,
3441 bool check_dependency_p,
3447 /* Peek at the next token. */
3448 token = cp_lexer_peek_token (parser->lexer);
3450 switch (token->type)
3456 /* We don't know yet whether or not this will be a
3458 cp_parser_parse_tentatively (parser);
3459 /* Try a template-id. */
3460 id = cp_parser_template_id (parser, template_keyword_p,
3463 /* If it worked, we're done. */
3464 if (cp_parser_parse_definitely (parser))
3466 /* Otherwise, it's an ordinary identifier. */
3467 return cp_parser_identifier (parser);
3470 case CPP_TEMPLATE_ID:
3471 return cp_parser_template_id (parser, template_keyword_p,
3478 tree qualifying_scope;
3483 /* Consume the `~' token. */
3484 cp_lexer_consume_token (parser->lexer);
3485 /* Parse the class-name. The standard, as written, seems to
3488 template <typename T> struct S { ~S (); };
3489 template <typename T> S<T>::~S() {}
3491 is invalid, since `~' must be followed by a class-name, but
3492 `S<T>' is dependent, and so not known to be a class.
3493 That's not right; we need to look in uninstantiated
3494 templates. A further complication arises from:
3496 template <typename T> void f(T t) {
3500 Here, it is not possible to look up `T' in the scope of `T'
3501 itself. We must look in both the current scope, and the
3502 scope of the containing complete expression.
3504 Yet another issue is:
3513 The standard does not seem to say that the `S' in `~S'
3514 should refer to the type `S' and not the data member
3517 /* DR 244 says that we look up the name after the "~" in the
3518 same scope as we looked up the qualifying name. That idea
3519 isn't fully worked out; it's more complicated than that. */
3520 scope = parser->scope;
3521 object_scope = parser->object_scope;
3522 qualifying_scope = parser->qualifying_scope;
3524 /* Check for invalid scopes. */
3525 if (scope == error_mark_node)
3527 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
3528 cp_lexer_consume_token (parser->lexer);
3529 return error_mark_node;
3531 if (scope && TREE_CODE (scope) == NAMESPACE_DECL)
3533 if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
3534 error ("scope %qT before %<~%> is not a class-name", scope);
3535 cp_parser_simulate_error (parser);
3536 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
3537 cp_lexer_consume_token (parser->lexer);
3538 return error_mark_node;
3540 gcc_assert (!scope || TYPE_P (scope));
3542 /* If the name is of the form "X::~X" it's OK. */
3543 token = cp_lexer_peek_token (parser->lexer);
3545 && token->type == CPP_NAME
3546 && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
3548 && constructor_name_p (token->u.value, scope))
3550 cp_lexer_consume_token (parser->lexer);
3551 return build_nt (BIT_NOT_EXPR, scope);
3554 /* If there was an explicit qualification (S::~T), first look
3555 in the scope given by the qualification (i.e., S). */
3557 type_decl = NULL_TREE;
3560 cp_parser_parse_tentatively (parser);
3561 type_decl = cp_parser_class_name (parser,
3562 /*typename_keyword_p=*/false,
3563 /*template_keyword_p=*/false,
3565 /*check_dependency=*/false,
3566 /*class_head_p=*/false,
3568 if (cp_parser_parse_definitely (parser))
3571 /* In "N::S::~S", look in "N" as well. */
3572 if (!done && scope && qualifying_scope)
3574 cp_parser_parse_tentatively (parser);
3575 parser->scope = qualifying_scope;
3576 parser->object_scope = NULL_TREE;
3577 parser->qualifying_scope = NULL_TREE;
3579 = cp_parser_class_name (parser,
3580 /*typename_keyword_p=*/false,
3581 /*template_keyword_p=*/false,
3583 /*check_dependency=*/false,
3584 /*class_head_p=*/false,
3586 if (cp_parser_parse_definitely (parser))
3589 /* In "p->S::~T", look in the scope given by "*p" as well. */
3590 else if (!done && object_scope)
3592 cp_parser_parse_tentatively (parser);
3593 parser->scope = object_scope;
3594 parser->object_scope = NULL_TREE;
3595 parser->qualifying_scope = NULL_TREE;
3597 = cp_parser_class_name (parser,
3598 /*typename_keyword_p=*/false,
3599 /*template_keyword_p=*/false,
3601 /*check_dependency=*/false,
3602 /*class_head_p=*/false,
3604 if (cp_parser_parse_definitely (parser))
3607 /* Look in the surrounding context. */
3610 parser->scope = NULL_TREE;
3611 parser->object_scope = NULL_TREE;
3612 parser->qualifying_scope = NULL_TREE;
3614 = cp_parser_class_name (parser,
3615 /*typename_keyword_p=*/false,
3616 /*template_keyword_p=*/false,
3618 /*check_dependency=*/false,
3619 /*class_head_p=*/false,
3622 /* If an error occurred, assume that the name of the
3623 destructor is the same as the name of the qualifying
3624 class. That allows us to keep parsing after running
3625 into ill-formed destructor names. */
3626 if (type_decl == error_mark_node && scope)
3627 return build_nt (BIT_NOT_EXPR, scope);
3628 else if (type_decl == error_mark_node)
3629 return error_mark_node;
3631 /* Check that destructor name and scope match. */
3632 if (declarator_p && scope && !check_dtor_name (scope, type_decl))
3634 if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
3635 error ("declaration of %<~%T%> as member of %qT",
3637 cp_parser_simulate_error (parser);
3638 return error_mark_node;
3643 A typedef-name that names a class shall not be used as the
3644 identifier in the declarator for a destructor declaration. */
3646 && !DECL_IMPLICIT_TYPEDEF_P (type_decl)
3647 && !DECL_SELF_REFERENCE_P (type_decl)
3648 && !cp_parser_uncommitted_to_tentative_parse_p (parser))
3649 error ("typedef-name %qD used as destructor declarator",
3652 return build_nt (BIT_NOT_EXPR, TREE_TYPE (type_decl));
3656 if (token->keyword == RID_OPERATOR)
3660 /* This could be a template-id, so we try that first. */
3661 cp_parser_parse_tentatively (parser);
3662 /* Try a template-id. */
3663 id = cp_parser_template_id (parser, template_keyword_p,
3664 /*check_dependency_p=*/true,
3666 /* If that worked, we're done. */
3667 if (cp_parser_parse_definitely (parser))
3669 /* We still don't know whether we're looking at an
3670 operator-function-id or a conversion-function-id. */
3671 cp_parser_parse_tentatively (parser);
3672 /* Try an operator-function-id. */
3673 id = cp_parser_operator_function_id (parser);
3674 /* If that didn't work, try a conversion-function-id. */
3675 if (!cp_parser_parse_definitely (parser))
3676 id = cp_parser_conversion_function_id (parser);
3685 cp_parser_error (parser, "expected unqualified-id");
3686 return error_mark_node;
3690 /* Parse an (optional) nested-name-specifier.
3692 nested-name-specifier:
3693 class-or-namespace-name :: nested-name-specifier [opt]
3694 class-or-namespace-name :: template nested-name-specifier [opt]
3696 PARSER->SCOPE should be set appropriately before this function is
3697 called. TYPENAME_KEYWORD_P is TRUE if the `typename' keyword is in
3698 effect. TYPE_P is TRUE if we non-type bindings should be ignored
3701 Sets PARSER->SCOPE to the class (TYPE) or namespace
3702 (NAMESPACE_DECL) specified by the nested-name-specifier, or leaves
3703 it unchanged if there is no nested-name-specifier. Returns the new
3704 scope iff there is a nested-name-specifier, or NULL_TREE otherwise.
3706 If IS_DECLARATION is TRUE, the nested-name-specifier is known to be
3707 part of a declaration and/or decl-specifier. */
3710 cp_parser_nested_name_specifier_opt (cp_parser *parser,
3711 bool typename_keyword_p,
3712 bool check_dependency_p,
3714 bool is_declaration)
3716 bool success = false;
3717 cp_token_position start = 0;
3720 /* Remember where the nested-name-specifier starts. */
3721 if (cp_parser_uncommitted_to_tentative_parse_p (parser))
3723 start = cp_lexer_token_position (parser->lexer, false);
3724 push_deferring_access_checks (dk_deferred);
3731 tree saved_qualifying_scope;
3732 bool template_keyword_p;
3734 /* Spot cases that cannot be the beginning of a
3735 nested-name-specifier. */
3736 token = cp_lexer_peek_token (parser->lexer);
3738 /* If the next token is CPP_NESTED_NAME_SPECIFIER, just process
3739 the already parsed nested-name-specifier. */
3740 if (token->type == CPP_NESTED_NAME_SPECIFIER)
3742 /* Grab the nested-name-specifier and continue the loop. */
3743 cp_parser_pre_parsed_nested_name_specifier (parser);
3744 /* If we originally encountered this nested-name-specifier
3745 with IS_DECLARATION set to false, we will not have
3746 resolved TYPENAME_TYPEs, so we must do so here. */
3748 && TREE_CODE (parser->scope) == TYPENAME_TYPE)
3750 new_scope = resolve_typename_type (parser->scope,
3751 /*only_current_p=*/false);
3752 if (new_scope != error_mark_node)
3753 parser->scope = new_scope;
3759 /* Spot cases that cannot be the beginning of a
3760 nested-name-specifier. On the second and subsequent times
3761 through the loop, we look for the `template' keyword. */
3762 if (success && token->keyword == RID_TEMPLATE)
3764 /* A template-id can start a nested-name-specifier. */
3765 else if (token->type == CPP_TEMPLATE_ID)
3769 /* If the next token is not an identifier, then it is
3770 definitely not a class-or-namespace-name. */
3771 if (token->type != CPP_NAME)
3773 /* If the following token is neither a `<' (to begin a
3774 template-id), nor a `::', then we are not looking at a
3775 nested-name-specifier. */
3776 token = cp_lexer_peek_nth_token (parser->lexer, 2);
3777 if (token->type != CPP_SCOPE
3778 && !cp_parser_nth_token_starts_template_argument_list_p
3783 /* The nested-name-specifier is optional, so we parse
3785 cp_parser_parse_tentatively (parser);
3787 /* Look for the optional `template' keyword, if this isn't the
3788 first time through the loop. */
3790 template_keyword_p = cp_parser_optional_template_keyword (parser);
3792 template_keyword_p = false;
3794 /* Save the old scope since the name lookup we are about to do
3795 might destroy it. */
3796 old_scope = parser->scope;
3797 saved_qualifying_scope = parser->qualifying_scope;
3798 /* In a declarator-id like "X<T>::I::Y<T>" we must be able to
3799 look up names in "X<T>::I" in order to determine that "Y" is
3800 a template. So, if we have a typename at this point, we make
3801 an effort to look through it. */
3803 && !typename_keyword_p
3805 && TREE_CODE (parser->scope) == TYPENAME_TYPE)
3806 parser->scope = resolve_typename_type (parser->scope,
3807 /*only_current_p=*/false);
3808 /* Parse the qualifying entity. */
3810 = cp_parser_class_or_namespace_name (parser,
3816 /* Look for the `::' token. */
3817 cp_parser_require (parser, CPP_SCOPE, "`::'");
3819 /* If we found what we wanted, we keep going; otherwise, we're
3821 if (!cp_parser_parse_definitely (parser))
3823 bool error_p = false;
3825 /* Restore the OLD_SCOPE since it was valid before the
3826 failed attempt at finding the last
3827 class-or-namespace-name. */
3828 parser->scope = old_scope;
3829 parser->qualifying_scope = saved_qualifying_scope;
3830 if (cp_parser_uncommitted_to_tentative_parse_p (parser))
3832 /* If the next token is an identifier, and the one after
3833 that is a `::', then any valid interpretation would have
3834 found a class-or-namespace-name. */
3835 while (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
3836 && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
3838 && (cp_lexer_peek_nth_token (parser->lexer, 3)->type
3841 token = cp_lexer_consume_token (parser->lexer);
3844 if (!token->ambiguous_p)
3847 tree ambiguous_decls;
3849 decl = cp_parser_lookup_name (parser, token->u.value,
3851 /*is_template=*/false,
3852 /*is_namespace=*/false,
3853 /*check_dependency=*/true,
3855 if (TREE_CODE (decl) == TEMPLATE_DECL)
3856 error ("%qD used without template parameters", decl);
3857 else if (ambiguous_decls)
3859 error ("reference to %qD is ambiguous",
3861 print_candidates (ambiguous_decls);
3862 decl = error_mark_node;
3865 cp_parser_name_lookup_error
3866 (parser, token->u.value, decl,
3867 "is not a class or namespace");
3869 parser->scope = error_mark_node;
3871 /* Treat this as a successful nested-name-specifier
3876 If the name found is not a class-name (clause
3877 _class_) or namespace-name (_namespace.def_), the
3878 program is ill-formed. */
3881 cp_lexer_consume_token (parser->lexer);
3885 /* We've found one valid nested-name-specifier. */
3887 /* Name lookup always gives us a DECL. */
3888 if (TREE_CODE (new_scope) == TYPE_DECL)
3889 new_scope = TREE_TYPE (new_scope);
3890 /* Uses of "template" must be followed by actual templates. */
3891 if (template_keyword_p
3892 && !(CLASS_TYPE_P (new_scope)
3893 && ((CLASSTYPE_USE_TEMPLATE (new_scope)
3894 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (new_scope)))
3895 || CLASSTYPE_IS_TEMPLATE (new_scope)))
3896 && !(TREE_CODE (new_scope) == TYPENAME_TYPE
3897 && (TREE_CODE (TYPENAME_TYPE_FULLNAME (new_scope))
3898 == TEMPLATE_ID_EXPR)))
3899 pedwarn (TYPE_P (new_scope)
3900 ? "%qT is not a template"
3901 : "%qD is not a template",
3903 /* If it is a class scope, try to complete it; we are about to
3904 be looking up names inside the class. */
3905 if (TYPE_P (new_scope)
3906 /* Since checking types for dependency can be expensive,
3907 avoid doing it if the type is already complete. */
3908 && !COMPLETE_TYPE_P (new_scope)
3909 /* Do not try to complete dependent types. */
3910 && !dependent_type_p (new_scope))
3911 new_scope = complete_type (new_scope);
3912 /* Make sure we look in the right scope the next time through
3914 parser->scope = new_scope;
3917 /* If parsing tentatively, replace the sequence of tokens that makes
3918 up the nested-name-specifier with a CPP_NESTED_NAME_SPECIFIER
3919 token. That way, should we re-parse the token stream, we will
3920 not have to repeat the effort required to do the parse, nor will
3921 we issue duplicate error messages. */
3922 if (success && start)
3926 token = cp_lexer_token_at (parser->lexer, start);
3927 /* Reset the contents of the START token. */
3928 token->type = CPP_NESTED_NAME_SPECIFIER;
3929 /* Retrieve any deferred checks. Do not pop this access checks yet
3930 so the memory will not be reclaimed during token replacing below. */
3931 token->u.tree_check_value = GGC_CNEW (struct tree_check);
3932 token->u.tree_check_value->value = parser->scope;
3933 token->u.tree_check_value->checks = get_deferred_access_checks ();
3934 token->u.tree_check_value->qualifying_scope =
3935 parser->qualifying_scope;
3936 token->keyword = RID_MAX;
3938 /* Purge all subsequent tokens. */
3939 cp_lexer_purge_tokens_after (parser->lexer, start);
3943 pop_to_parent_deferring_access_checks ();
3945 return success ? parser->scope : NULL_TREE;
3948 /* Parse a nested-name-specifier. See
3949 cp_parser_nested_name_specifier_opt for details. This function
3950 behaves identically, except that it will an issue an error if no
3951 nested-name-specifier is present. */
3954 cp_parser_nested_name_specifier (cp_parser *parser,
3955 bool typename_keyword_p,
3956 bool check_dependency_p,
3958 bool is_declaration)
3962 /* Look for the nested-name-specifier. */
3963 scope = cp_parser_nested_name_specifier_opt (parser,
3968 /* If it was not present, issue an error message. */
3971 cp_parser_error (parser, "expected nested-name-specifier");
3972 parser->scope = NULL_TREE;
3978 /* Parse a class-or-namespace-name.
3980 class-or-namespace-name:
3984 TYPENAME_KEYWORD_P is TRUE iff the `typename' keyword is in effect.
3985 TEMPLATE_KEYWORD_P is TRUE iff the `template' keyword is in effect.
3986 CHECK_DEPENDENCY_P is FALSE iff dependent names should be looked up.
3987 TYPE_P is TRUE iff the next name should be taken as a class-name,
3988 even the same name is declared to be another entity in the same
3991 Returns the class (TYPE_DECL) or namespace (NAMESPACE_DECL)
3992 specified by the class-or-namespace-name. If neither is found the
3993 ERROR_MARK_NODE is returned. */
3996 cp_parser_class_or_namespace_name (cp_parser *parser,
3997 bool typename_keyword_p,
3998 bool template_keyword_p,
3999 bool check_dependency_p,
4001 bool is_declaration)
4004 tree saved_qualifying_scope;
4005 tree saved_object_scope;
4009 /* Before we try to parse the class-name, we must save away the
4010 current PARSER->SCOPE since cp_parser_class_name will destroy
4012 saved_scope = parser->scope;
4013 saved_qualifying_scope = parser->qualifying_scope;
4014 saved_object_scope = parser->object_scope;
4015 /* Try for a class-name first. If the SAVED_SCOPE is a type, then
4016 there is no need to look for a namespace-name. */
4017 only_class_p = template_keyword_p || (saved_scope && TYPE_P (saved_scope));
4019 cp_parser_parse_tentatively (parser);
4020 scope = cp_parser_class_name (parser,
4023 type_p ? class_type : none_type,
4025 /*class_head_p=*/false,
4027 /* If that didn't work, try for a namespace-name. */
4028 if (!only_class_p && !cp_parser_parse_definitely (parser))
4030 /* Restore the saved scope. */
4031 parser->scope = saved_scope;
4032 parser->qualifying_scope = saved_qualifying_scope;
4033 parser->object_scope = saved_object_scope;
4034 /* If we are not looking at an identifier followed by the scope
4035 resolution operator, then this is not part of a
4036 nested-name-specifier. (Note that this function is only used
4037 to parse the components of a nested-name-specifier.) */
4038 if (cp_lexer_next_token_is_not (parser->lexer, CPP_NAME)
4039 || cp_lexer_peek_nth_token (parser->lexer, 2)->type != CPP_SCOPE)
4040 return error_mark_node;
4041 scope = cp_parser_namespace_name (parser);
4047 /* Parse a postfix-expression.
4051 postfix-expression [ expression ]
4052 postfix-expression ( expression-list [opt] )
4053 simple-type-specifier ( expression-list [opt] )
4054 typename :: [opt] nested-name-specifier identifier
4055 ( expression-list [opt] )
4056 typename :: [opt] nested-name-specifier template [opt] template-id
4057 ( expression-list [opt] )
4058 postfix-expression . template [opt] id-expression
4059 postfix-expression -> template [opt] id-expression
4060 postfix-expression . pseudo-destructor-name
4061 postfix-expression -> pseudo-destructor-name
4062 postfix-expression ++
4063 postfix-expression --
4064 dynamic_cast < type-id > ( expression )
4065 static_cast < type-id > ( expression )
4066 reinterpret_cast < type-id > ( expression )
4067 const_cast < type-id > ( expression )
4068 typeid ( expression )
4074 ( type-id ) { initializer-list , [opt] }
4076 This extension is a GNU version of the C99 compound-literal
4077 construct. (The C99 grammar uses `type-name' instead of `type-id',
4078 but they are essentially the same concept.)
4080 If ADDRESS_P is true, the postfix expression is the operand of the
4081 `&' operator. CAST_P is true if this expression is the target of a
4084 Returns a representation of the expression. */
4087 cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p)
4091 cp_id_kind idk = CP_ID_KIND_NONE;
4092 tree postfix_expression = NULL_TREE;
4094 /* Peek at the next token. */
4095 token = cp_lexer_peek_token (parser->lexer);
4096 /* Some of the productions are determined by keywords. */
4097 keyword = token->keyword;
4107 const char *saved_message;
4109 /* All of these can be handled in the same way from the point
4110 of view of parsing. Begin by consuming the token
4111 identifying the cast. */
4112 cp_lexer_consume_token (parser->lexer);
4114 /* New types cannot be defined in the cast. */
4115 saved_message = parser->type_definition_forbidden_message;
4116 parser->type_definition_forbidden_message
4117 = "types may not be defined in casts";
4119 /* Look for the opening `<'. */
4120 cp_parser_require (parser, CPP_LESS, "`<'");
4121 /* Parse the type to which we are casting. */
4122 type = cp_parser_type_id (parser);
4123 /* Look for the closing `>'. */
4124 cp_parser_require (parser, CPP_GREATER, "`>'");
4125 /* Restore the old message. */
4126 parser->type_definition_forbidden_message = saved_message;
4128 /* And the expression which is being cast. */
4129 cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
4130 expression = cp_parser_expression (parser, /*cast_p=*/true);
4131 cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
4133 /* Only type conversions to integral or enumeration types
4134 can be used in constant-expressions. */
4135 if (!cast_valid_in_integral_constant_expression_p (type)
4136 && (cp_parser_non_integral_constant_expression
4138 "a cast to a type other than an integral or "
4139 "enumeration type")))
4140 return error_mark_node;
4146 = build_dynamic_cast (type, expression);
4150 = build_static_cast (type, expression);
4154 = build_reinterpret_cast (type, expression);
4158 = build_const_cast (type, expression);
4169 const char *saved_message;
4170 bool saved_in_type_id_in_expr_p;
4172 /* Consume the `typeid' token. */
4173 cp_lexer_consume_token (parser->lexer);
4174 /* Look for the `(' token. */
4175 cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
4176 /* Types cannot be defined in a `typeid' expression. */
4177 saved_message = parser->type_definition_forbidden_message;
4178 parser->type_definition_forbidden_message
4179 = "types may not be defined in a `typeid\' expression";
4180 /* We can't be sure yet whether we're looking at a type-id or an
4182 cp_parser_parse_tentatively (parser);
4183 /* Try a type-id first. */
4184 saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p;
4185 parser->in_type_id_in_expr_p = true;
4186 type = cp_parser_type_id (parser);
4187 parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
4188 /* Look for the `)' token. Otherwise, we can't be sure that
4189 we're not looking at an expression: consider `typeid (int
4190 (3))', for example. */
4191 cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
4192 /* If all went well, simply lookup the type-id. */
4193 if (cp_parser_parse_definitely (parser))
4194 postfix_expression = get_typeid (type);
4195 /* Otherwise, fall back to the expression variant. */
4200 /* Look for an expression. */
4201 expression = cp_parser_expression (parser, /*cast_p=*/false);
4202 /* Compute its typeid. */
4203 postfix_expression = build_typeid (expression);
4204 /* Look for the `)' token. */
4205 cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
4207 /* Restore the saved message. */
4208 parser->type_definition_forbidden_message = saved_message;
4209 /* `typeid' may not appear in an integral constant expression. */
4210 if (cp_parser_non_integral_constant_expression(parser,
4211 "`typeid' operator"))
4212 return error_mark_node;
4219 /* The syntax permitted here is the same permitted for an
4220 elaborated-type-specifier. */
4221 type = cp_parser_elaborated_type_specifier (parser,
4222 /*is_friend=*/false,
4223 /*is_declaration=*/false);
4224 postfix_expression = cp_parser_functional_cast (parser, type);
4232 /* If the next thing is a simple-type-specifier, we may be
4233 looking at a functional cast. We could also be looking at
4234 an id-expression. So, we try the functional cast, and if
4235 that doesn't work we fall back to the primary-expression. */
4236 cp_parser_parse_tentatively (parser);
4237 /* Look for the simple-type-specifier. */
4238 type = cp_parser_simple_type_specifier (parser,
4239 /*decl_specs=*/NULL,
4240 CP_PARSER_FLAGS_NONE);
4241 /* Parse the cast itself. */
4242 if (!cp_parser_error_occurred (parser))
4244 = cp_parser_functional_cast (parser, type);
4245 /* If that worked, we're done. */
4246 if (cp_parser_parse_definitely (parser))
4249 /* If the functional-cast didn't work out, try a
4250 compound-literal. */
4251 if (cp_parser_allow_gnu_extensions_p (parser)
4252 && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
4254 VEC(constructor_elt,gc) *initializer_list = NULL;
4255 bool saved_in_type_id_in_expr_p;
4257 cp_parser_parse_tentatively (parser);
4258 /* Consume the `('. */
4259 cp_lexer_consume_token (parser->lexer);
4260 /* Parse the type. */
4261 saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p;
4262 parser->in_type_id_in_expr_p = true;
4263 type = cp_parser_type_id (parser);
4264 parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
4265 /* Look for the `)'. */
4266 cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
4267 /* Look for the `{'. */
4268 cp_parser_require (parser, CPP_OPEN_BRACE, "`{'");
4269 /* If things aren't going well, there's no need to
4271 if (!cp_parser_error_occurred (parser))
4273 bool non_constant_p;
4274 /* Parse the initializer-list. */
4276 = cp_parser_initializer_list (parser, &non_constant_p);
4277 /* Allow a trailing `,'. */
4278 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
4279 cp_lexer_consume_token (parser->lexer);
4280 /* Look for the final `}'. */
4281 cp_parser_require (parser, CPP_CLOSE_BRACE, "`}'");
4283 /* If that worked, we're definitely looking at a
4284 compound-literal expression. */
4285 if (cp_parser_parse_definitely (parser))
4287 /* Warn the user that a compound literal is not
4288 allowed in standard C++. */
4290 pedwarn ("ISO C++ forbids compound-literals");
4291 /* Form the representation of the compound-literal. */
4293 = finish_compound_literal (type, initializer_list);
4298 /* It must be a primary-expression. */
4300 = cp_parser_primary_expression (parser, address_p, cast_p,
4301 /*template_arg_p=*/false,
4307 /* Keep looping until the postfix-expression is complete. */
4310 if (idk == CP_ID_KIND_UNQUALIFIED
4311 && TREE_CODE (postfix_expression) == IDENTIFIER_NODE
4312 && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_PAREN))
4313 /* It is not a Koenig lookup function call. */
4315 = unqualified_name_lookup_error (postfix_expression);
4317 /* Peek at the next token. */
4318 token = cp_lexer_peek_token (parser->lexer);
4320 switch (token->type)
4322 case CPP_OPEN_SQUARE:
4324 = cp_parser_postfix_open_square_expression (parser,
4327 idk = CP_ID_KIND_NONE;
4330 case CPP_OPEN_PAREN:
4331 /* postfix-expression ( expression-list [opt] ) */
4334 bool is_builtin_constant_p;
4335 bool saved_integral_constant_expression_p = false;
4336 bool saved_non_integral_constant_expression_p = false;
4339 is_builtin_constant_p
4340 = DECL_IS_BUILTIN_CONSTANT_P (postfix_expression);
4341 if (is_builtin_constant_p)
4343 /* The whole point of __builtin_constant_p is to allow
4344 non-constant expressions to appear as arguments. */
4345 saved_integral_constant_expression_p
4346 = parser->integral_constant_expression_p;
4347 saved_non_integral_constant_expression_p
4348 = parser->non_integral_constant_expression_p;
4349 parser->integral_constant_expression_p = false;
4351 args = (cp_parser_parenthesized_expression_list
4352 (parser, /*is_attribute_list=*/false,
4354 /*non_constant_p=*/NULL));
4355 if (is_builtin_constant_p)
4357 parser->integral_constant_expression_p
4358 = saved_integral_constant_expression_p;
4359 parser->non_integral_constant_expression_p
4360 = saved_non_integral_constant_expression_p;
4363 if (args == error_mark_node)
4365 postfix_expression = error_mark_node;
4369 /* Function calls are not permitted in
4370 constant-expressions. */
4371 if (! builtin_valid_in_constant_expr_p (postfix_expression)
4372 && cp_parser_non_integral_constant_expression (parser,
4375 postfix_expression = error_mark_node;
4380 if (idk == CP_ID_KIND_UNQUALIFIED)
4382 if (TREE_CODE (postfix_expression) == IDENTIFIER_NODE)
4388 = perform_koenig_lookup (postfix_expression, args);
4392 = unqualified_fn_lookup_error (postfix_expression);
4394 /* We do not perform argument-dependent lookup if
4395 normal lookup finds a non-function, in accordance
4396 with the expected resolution of DR 218. */
4397 else if (args && is_overloaded_fn (postfix_expression))
4399 tree fn = get_first_fn (postfix_expression);
4401 if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
4402 fn = OVL_CURRENT (TREE_OPERAND (fn, 0));
4404 /* Only do argument dependent lookup if regular
4405 lookup does not find a set of member functions.
4406 [basic.lookup.koenig]/2a */
4407 if (!DECL_FUNCTION_MEMBER_P (fn))
4411 = perform_koenig_lookup (postfix_expression, args);
4416 if (TREE_CODE (postfix_expression) == COMPONENT_REF)
4418 tree instance = TREE_OPERAND (postfix_expression, 0);
4419 tree fn = TREE_OPERAND (postfix_expression, 1);
4421 if (processing_template_decl
4422 && (type_dependent_expression_p (instance)
4423 || (!BASELINK_P (fn)
4424 && TREE_CODE (fn) != FIELD_DECL)
4425 || type_dependent_expression_p (fn)
4426 || any_type_dependent_arguments_p (args)))
4429 = build_min_nt (CALL_EXPR, postfix_expression,
4434 if (BASELINK_P (fn))
4436 = (build_new_method_call
4437 (instance, fn, args, NULL_TREE,
4438 (idk == CP_ID_KIND_QUALIFIED
4439 ? LOOKUP_NONVIRTUAL : LOOKUP_NORMAL),
4443 = finish_call_expr (postfix_expression, args,
4444 /*disallow_virtual=*/false,
4445 /*koenig_p=*/false);
4447 else if (TREE_CODE (postfix_expression) == OFFSET_REF
4448 || TREE_CODE (postfix_expression) == MEMBER_REF
4449 || TREE_CODE (postfix_expression) == DOTSTAR_EXPR)
4450 postfix_expression = (build_offset_ref_call_from_tree
4451 (postfix_expression, args));
4452 else if (idk == CP_ID_KIND_QUALIFIED)
4453 /* A call to a static class member, or a namespace-scope
4456 = finish_call_expr (postfix_expression, args,
4457 /*disallow_virtual=*/true,
4460 /* All other function calls. */
4462 = finish_call_expr (postfix_expression, args,
4463 /*disallow_virtual=*/false,
4466 /* The POSTFIX_EXPRESSION is certainly no longer an id. */
4467 idk = CP_ID_KIND_NONE;
4473 /* postfix-expression . template [opt] id-expression
4474 postfix-expression . pseudo-destructor-name
4475 postfix-expression -> template [opt] id-expression
4476 postfix-expression -> pseudo-destructor-name */
4478 /* Consume the `.' or `->' operator. */
4479 cp_lexer_consume_token (parser->lexer);
4482 = cp_parser_postfix_dot_deref_expression (parser, token->type,
4488 /* postfix-expression ++ */
4489 /* Consume the `++' token. */
4490 cp_lexer_consume_token (parser->lexer);
4491 /* Generate a representation for the complete expression. */
4493 = finish_increment_expr (postfix_expression,
4494 POSTINCREMENT_EXPR);
4495 /* Increments may not appear in constant-expressions. */
4496 if (cp_parser_non_integral_constant_expression (parser,
4498 postfix_expression = error_mark_node;
4499 idk = CP_ID_KIND_NONE;
4502 case CPP_MINUS_MINUS:
4503 /* postfix-expression -- */
4504 /* Consume the `--' token. */
4505 cp_lexer_consume_token (parser->lexer);
4506 /* Generate a representation for the complete expression. */
4508 = finish_increment_expr (postfix_expression,
4509 POSTDECREMENT_EXPR);
4510 /* Decrements may not appear in constant-expressions. */
4511 if (cp_parser_non_integral_constant_expression (parser,
4513 postfix_expression = error_mark_node;
4514 idk = CP_ID_KIND_NONE;
4518 return postfix_expression;
4522 /* We should never get here. */
4524 return error_mark_node;
4527 /* A subroutine of cp_parser_postfix_expression that also gets hijacked
4528 by cp_parser_builtin_offsetof. We're looking for
4530 postfix-expression [ expression ]
4532 FOR_OFFSETOF is set if we're being called in that context, which
4533 changes how we deal with integer constant expressions. */
4536 cp_parser_postfix_open_square_expression (cp_parser *parser,
4537 tree postfix_expression,
4542 /* Consume the `[' token. */
4543 cp_lexer_consume_token (parser->lexer);
4545 /* Parse the index expression. */
4546 /* ??? For offsetof, there is a question of what to allow here. If
4547 offsetof is not being used in an integral constant expression context,
4548 then we *could* get the right answer by computing the value at runtime.
4549 If we are in an integral constant expression context, then we might
4550 could accept any constant expression; hard to say without analysis.
4551 Rather than open the barn door too wide right away, allow only integer
4552 constant expressions here. */
4554 index = cp_parser_constant_expression (parser, false, NULL);
4556 index = cp_parser_expression (parser, /*cast_p=*/false);
4558 /* Look for the closing `]'. */
4559 cp_parser_require (parser, CPP_CLOSE_SQUARE, "`]'");
4561 /* Build the ARRAY_REF. */
4562 postfix_expression = grok_array_decl (postfix_expression, index);
4564 /* When not doing offsetof, array references are not permitted in
4565 constant-expressions. */
4567 && (cp_parser_non_integral_constant_expression
4568 (parser, "an array reference")))
4569 postfix_expression = error_mark_node;
4571 return postfix_expression;
4574 /* A subroutine of cp_parser_postfix_expression that also gets hijacked
4575 by cp_parser_builtin_offsetof. We're looking for
4577 postfix-expression . template [opt] id-expression
4578 postfix-expression . pseudo-destructor-name
4579 postfix-expression -> template [opt] id-expression
4580 postfix-expression -> pseudo-destructor-name
4582 FOR_OFFSETOF is set if we're being called in that context. That sorta
4583 limits what of the above we'll actually accept, but nevermind.
4584 TOKEN_TYPE is the "." or "->" token, which will already have been
4585 removed from the stream. */
4588 cp_parser_postfix_dot_deref_expression (cp_parser *parser,
4589 enum cpp_ttype token_type,
4590 tree postfix_expression,
4591 bool for_offsetof, cp_id_kind *idk)
4595 bool pseudo_destructor_p;
4596 tree scope = NULL_TREE;
4598 /* If this is a `->' operator, dereference the pointer. */
4599 if (token_type == CPP_DEREF)
4600 postfix_expression = build_x_arrow (postfix_expression);
4601 /* Check to see whether or not the expression is type-dependent. */
4602 dependent_p = type_dependent_expression_p (postfix_expression);
4603 /* The identifier following the `->' or `.' is not qualified. */
4604 parser->scope = NULL_TREE;
4605 parser->qualifying_scope = NULL_TREE;
4606 parser->object_scope = NULL_TREE;
4607 *idk = CP_ID_KIND_NONE;
4608 /* Enter the scope corresponding to the type of the object
4609 given by the POSTFIX_EXPRESSION. */
4610 if (!dependent_p && TREE_TYPE (postfix_expression) != NULL_TREE)
4612 scope = TREE_TYPE (postfix_expression);
4613 /* According to the standard, no expression should ever have
4614 reference type. Unfortunately, we do not currently match
4615 the standard in this respect in that our internal representation
4616 of an expression may have reference type even when the standard
4617 says it does not. Therefore, we have to manually obtain the
4618 underlying type here. */
4619 scope = non_reference (scope);
4620 /* The type of the POSTFIX_EXPRESSION must be complete. */
4621 if (scope == unknown_type_node)
4623 error ("%qE does not have class type", postfix_expression);
4627 scope = complete_type_or_else (scope, NULL_TREE);
4628 /* Let the name lookup machinery know that we are processing a
4629 class member access expression. */
4630 parser->context->object_type = scope;
4631 /* If something went wrong, we want to be able to discern that case,
4632 as opposed to the case where there was no SCOPE due to the type
4633 of expression being dependent. */
4635 scope = error_mark_node;
4636 /* If the SCOPE was erroneous, make the various semantic analysis
4637 functions exit quickly -- and without issuing additional error
4639 if (scope == error_mark_node)
4640 postfix_expression = error_mark_node;
4643 /* Assume this expression is not a pseudo-destructor access. */
4644 pseudo_destructor_p = false;
4646 /* If the SCOPE is a scalar type, then, if this is a valid program,
4647 we must be looking at a pseudo-destructor-name. */
4648 if (scope && SCALAR_TYPE_P (scope))
4653 cp_parser_parse_tentatively (parser);
4654 /* Parse the pseudo-destructor-name. */
4656 cp_parser_pseudo_destructor_name (parser, &s, &type);
4657 if (cp_parser_parse_definitely (parser))
4659 pseudo_destructor_p = true;
4661 = finish_pseudo_destructor_expr (postfix_expression,
4662 s, TREE_TYPE (type));
4666 if (!pseudo_destructor_p)
4668 /* If the SCOPE is not a scalar type, we are looking at an
4669 ordinary class member access expression, rather than a
4670 pseudo-destructor-name. */
4672 /* Parse the id-expression. */
4673 name = (cp_parser_id_expression
4675 cp_parser_optional_template_keyword (parser),
4676 /*check_dependency_p=*/true,
4678 /*declarator_p=*/false,
4679 /*optional_p=*/false));
4680 /* In general, build a SCOPE_REF if the member name is qualified.
4681 However, if the name was not dependent and has already been
4682 resolved; there is no need to build the SCOPE_REF. For example;
4684 struct X { void f(); };
4685 template <typename T> void f(T* t) { t->X::f(); }
4687 Even though "t" is dependent, "X::f" is not and has been resolved
4688 to a BASELINK; there is no need to include scope information. */
4690 /* But we do need to remember that there was an explicit scope for
4691 virtual function calls. */
4693 *idk = CP_ID_KIND_QUALIFIED;
4695 /* If the name is a template-id that names a type, we will get a
4696 TYPE_DECL here. That is invalid code. */
4697 if (TREE_CODE (name) == TYPE_DECL)
4699 error ("invalid use of %qD", name);
4700 postfix_expression = error_mark_node;
4704 if (name != error_mark_node && !BASELINK_P (name) && parser->scope)
4706 name = build_qualified_name (/*type=*/NULL_TREE,
4710 parser->scope = NULL_TREE;
4711 parser->qualifying_scope = NULL_TREE;
4712 parser->object_scope = NULL_TREE;
4714 if (scope && name && BASELINK_P (name))
4715 adjust_result_of_qualified_name_lookup
4716 (name, BINFO_TYPE (BASELINK_ACCESS_BINFO (name)), scope);
4718 = finish_class_member_access_expr (postfix_expression, name,
4723 /* We no longer need to look up names in the scope of the object on
4724 the left-hand side of the `.' or `->' operator. */
4725 parser->context->object_type = NULL_TREE;
4727 /* Outside of offsetof, these operators may not appear in
4728 constant-expressions. */
4730 && (cp_parser_non_integral_constant_expression
4731 (parser, token_type == CPP_DEREF ? "'->'" : "`.'")))
4732 postfix_expression = error_mark_node;
4734 return postfix_expression;
4737 /* Parse a parenthesized expression-list.
4740 assignment-expression
4741 expression-list, assignment-expression
4746 identifier, expression-list
4748 CAST_P is true if this expression is the target of a cast.
4750 Returns a TREE_LIST. The TREE_VALUE of each node is a
4751 representation of an assignment-expression. Note that a TREE_LIST
4752 is returned even if there is only a single expression in the list.
4753 error_mark_node is returned if the ( and or ) are
4754 missing. NULL_TREE is returned on no expressions. The parentheses
4755 are eaten. IS_ATTRIBUTE_LIST is true if this is really an attribute
4756 list being parsed. If NON_CONSTANT_P is non-NULL, *NON_CONSTANT_P
4757 indicates whether or not all of the expressions in the list were
4761 cp_parser_parenthesized_expression_list (cp_parser* parser,
4762 bool is_attribute_list,
4764 bool *non_constant_p)
4766 tree expression_list = NULL_TREE;
4767 bool fold_expr_p = is_attribute_list;
4768 tree identifier = NULL_TREE;
4770 /* Assume all the expressions will be constant. */
4772 *non_constant_p = false;
4774 if (!cp_parser_require (parser, CPP_OPEN_PAREN, "`('"))
4775 return error_mark_node;
4777 /* Consume expressions until there are no more. */
4778 if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
4783 /* At the beginning of attribute lists, check to see if the
4784 next token is an identifier. */
4785 if (is_attribute_list
4786 && cp_lexer_peek_token (parser->lexer)->type == CPP_NAME)
4790 /* Consume the identifier. */
4791 token = cp_lexer_consume_token (parser->lexer);
4792 /* Save the identifier. */
4793 identifier = token->u.value;
4797 /* Parse the next assignment-expression. */
4800 bool expr_non_constant_p;
4801 expr = (cp_parser_constant_expression
4802 (parser, /*allow_non_constant_p=*/true,
4803 &expr_non_constant_p));
4804 if (expr_non_constant_p)
4805 *non_constant_p = true;
4808 expr = cp_parser_assignment_expression (parser, cast_p);
4811 expr = fold_non_dependent_expr (expr);
4813 /* Add it to the list. We add error_mark_node
4814 expressions to the list, so that we can still tell if
4815 the correct form for a parenthesized expression-list
4816 is found. That gives better errors. */
4817 expression_list = tree_cons (NULL_TREE, expr, expression_list);
4819 if (expr == error_mark_node)
4823 /* After the first item, attribute lists look the same as
4824 expression lists. */
4825 is_attribute_list = false;
4828 /* If the next token isn't a `,', then we are done. */
4829 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
4832 /* Otherwise, consume the `,' and keep going. */
4833 cp_lexer_consume_token (parser->lexer);
4836 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"))
4841 /* We try and resync to an unnested comma, as that will give the
4842 user better diagnostics. */
4843 ending = cp_parser_skip_to_closing_parenthesis (parser,
4844 /*recovering=*/true,
4846 /*consume_paren=*/true);
4850 return error_mark_node;
4853 /* We built up the list in reverse order so we must reverse it now. */
4854 expression_list = nreverse (expression_list);
4856 expression_list = tree_cons (NULL_TREE, identifier, expression_list);
4858 return expression_list;
4861 /* Parse a pseudo-destructor-name.
4863 pseudo-destructor-name:
4864 :: [opt] nested-name-specifier [opt] type-name :: ~ type-name
4865 :: [opt] nested-name-specifier template template-id :: ~ type-name
4866 :: [opt] nested-name-specifier [opt] ~ type-name
4868 If either of the first two productions is used, sets *SCOPE to the
4869 TYPE specified before the final `::'. Otherwise, *SCOPE is set to
4870 NULL_TREE. *TYPE is set to the TYPE_DECL for the final type-name,
4871 or ERROR_MARK_NODE if the parse fails. */
4874 cp_parser_pseudo_destructor_name (cp_parser* parser,
4878 bool nested_name_specifier_p;
4880 /* Assume that things will not work out. */
4881 *type = error_mark_node;
4883 /* Look for the optional `::' operator. */
4884 cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/true);
4885 /* Look for the optional nested-name-specifier. */
4886 nested_name_specifier_p
4887 = (cp_parser_nested_name_specifier_opt (parser,
4888 /*typename_keyword_p=*/false,
4889 /*check_dependency_p=*/true,
4891 /*is_declaration=*/true)
4893 /* Now, if we saw a nested-name-specifier, we might be doing the
4894 second production. */
4895 if (nested_name_specifier_p
4896 && cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
4898 /* Consume the `template' keyword. */
4899 cp_lexer_consume_token (parser->lexer);
4900 /* Parse the template-id. */
4901 cp_parser_template_id (parser,
4902 /*template_keyword_p=*/true,
4903 /*check_dependency_p=*/false,
4904 /*is_declaration=*/true);
4905 /* Look for the `::' token. */
4906 cp_parser_require (parser, CPP_SCOPE, "`::'");
4908 /* If the next token is not a `~', then there might be some
4909 additional qualification. */
4910 else if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMPL))
4912 /* Look for the type-name. */
4913 *scope = TREE_TYPE (cp_parser_type_name (parser));
4915 if (*scope == error_mark_node)
4918 /* If we don't have ::~, then something has gone wrong. Since
4919 the only caller of this function is looking for something
4920 after `.' or `->' after a scalar type, most likely the
4921 program is trying to get a member of a non-aggregate
4923 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SCOPE)
4924 || cp_lexer_peek_nth_token (parser->lexer, 2)->type != CPP_COMPL)
4926 cp_parser_error (parser, "request for member of non-aggregate type");
4930 /* Look for the `::' token. */
4931 cp_parser_require (parser, CPP_SCOPE, "`::'");
4936 /* Look for the `~'. */
4937 cp_parser_require (parser, CPP_COMPL, "`~'");
4938 /* Look for the type-name again. We are not responsible for
4939 checking that it matches the first type-name. */
4940 *type = cp_parser_type_name (parser);
4943 /* Parse a unary-expression.
4949 unary-operator cast-expression
4950 sizeof unary-expression
4958 __extension__ cast-expression
4959 __alignof__ unary-expression
4960 __alignof__ ( type-id )
4961 __real__ cast-expression
4962 __imag__ cast-expression
4965 ADDRESS_P is true iff the unary-expression is appearing as the
4966 operand of the `&' operator. CAST_P is true if this expression is
4967 the target of a cast.
4969 Returns a representation of the expression. */
4972 cp_parser_unary_expression (cp_parser *parser, bool address_p, bool cast_p)
4975 enum tree_code unary_operator;
4977 /* Peek at the next token. */
4978 token = cp_lexer_peek_token (parser->lexer);
4979 /* Some keywords give away the kind of expression. */
4980 if (token->type == CPP_KEYWORD)
4982 enum rid keyword = token->keyword;
4992 op = keyword == RID_ALIGNOF ? ALIGNOF_EXPR : SIZEOF_EXPR;
4993 /* Consume the token. */
4994 cp_lexer_consume_token (parser->lexer);
4995 /* Parse the operand. */
4996 operand = cp_parser_sizeof_operand (parser, keyword);
4998 if (TYPE_P (operand))
4999 return cxx_sizeof_or_alignof_type (operand, op, true);
5001 return cxx_sizeof_or_alignof_expr (operand, op);
5005 return cp_parser_new_expression (parser);
5008 return cp_parser_delete_expression (parser);
5012 /* The saved value of the PEDANTIC flag. */
5016 /* Save away the PEDANTIC flag. */
5017 cp_parser_extension_opt (parser, &saved_pedantic);
5018 /* Parse the cast-expression. */
5019 expr = cp_parser_simple_cast_expression (parser);
5020 /* Restore the PEDANTIC flag. */
5021 pedantic = saved_pedantic;
5031 /* Consume the `__real__' or `__imag__' token. */
5032 cp_lexer_consume_token (parser->lexer);
5033 /* Parse the cast-expression. */
5034 expression = cp_parser_simple_cast_expression (parser);
5035 /* Create the complete representation. */
5036 return build_x_unary_op ((keyword == RID_REALPART
5037 ? REALPART_EXPR : IMAGPART_EXPR),
5047 /* Look for the `:: new' and `:: delete', which also signal the
5048 beginning of a new-expression, or delete-expression,
5049 respectively. If the next token is `::', then it might be one of
5051 if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
5055 /* See if the token after the `::' is one of the keywords in
5056 which we're interested. */
5057 keyword = cp_lexer_peek_nth_token (parser->lexer, 2)->keyword;
5058 /* If it's `new', we have a new-expression. */
5059 if (keyword == RID_NEW)
5060 return cp_parser_new_expression (parser);
5061 /* Similarly, for `delete'. */
5062 else if (keyword == RID_DELETE)
5063 return cp_parser_delete_expression (parser);
5066 /* Look for a unary operator. */
5067 unary_operator = cp_parser_unary_operator (token);
5068 /* The `++' and `--' operators can be handled similarly, even though
5069 they are not technically unary-operators in the grammar. */
5070 if (unary_operator == ERROR_MARK)
5072 if (token->type == CPP_PLUS_PLUS)
5073 unary_operator = PREINCREMENT_EXPR;
5074 else if (token->type == CPP_MINUS_MINUS)
5075 unary_operator = PREDECREMENT_EXPR;
5076 /* Handle the GNU address-of-label extension. */
5077 else if (cp_parser_allow_gnu_extensions_p (parser)
5078 && token->type == CPP_AND_AND)
5082 /* Consume the '&&' token. */
5083 cp_lexer_consume_token (parser->lexer);
5084 /* Look for the identifier. */
5085 identifier = cp_parser_identifier (parser);
5086 /* Create an expression representing the address. */
5087 return finish_label_address_expr (identifier);
5090 if (unary_operator != ERROR_MARK)
5092 tree cast_expression;
5093 tree expression = error_mark_node;
5094 const char *non_constant_p = NULL;
5096 /* Consume the operator token. */
5097 token = cp_lexer_consume_token (parser->lexer);
5098 /* Parse the cast-expression. */
5100 = cp_parser_cast_expression (parser,
5101 unary_operator == ADDR_EXPR,
5103 /* Now, build an appropriate representation. */
5104 switch (unary_operator)
5107 non_constant_p = "`*'";
5108 expression = build_x_indirect_ref (cast_expression, "unary *");
5112 non_constant_p = "`&'";
5115 expression = build_x_unary_op (unary_operator, cast_expression);
5118 case PREINCREMENT_EXPR:
5119 case PREDECREMENT_EXPR:
5120 non_constant_p = (unary_operator == PREINCREMENT_EXPR
5123 case UNARY_PLUS_EXPR:
5125 case TRUTH_NOT_EXPR:
5126 expression = finish_unary_op_expr (unary_operator, cast_expression);
5134 && cp_parser_non_integral_constant_expression (parser,
5136 expression = error_mark_node;
5141 return cp_parser_postfix_expression (parser, address_p, cast_p);
5144 /* Returns ERROR_MARK if TOKEN is not a unary-operator. If TOKEN is a
5145 unary-operator, the corresponding tree code is returned. */
5147 static enum tree_code
5148 cp_parser_unary_operator (cp_token* token)
5150 switch (token->type)
5153 return INDIRECT_REF;
5159 return UNARY_PLUS_EXPR;
5165 return TRUTH_NOT_EXPR;
5168 return BIT_NOT_EXPR;
5175 /* Parse a new-expression.
5178 :: [opt] new new-placement [opt] new-type-id new-initializer [opt]
5179 :: [opt] new new-placement [opt] ( type-id ) new-initializer [opt]
5181 Returns a representation of the expression. */
5184 cp_parser_new_expression (cp_parser* parser)
5186 bool global_scope_p;
5192 /* Look for the optional `::' operator. */
5194 = (cp_parser_global_scope_opt (parser,
5195 /*current_scope_valid_p=*/false)
5197 /* Look for the `new' operator. */
5198 cp_parser_require_keyword (parser, RID_NEW, "`new'");
5199 /* There's no easy way to tell a new-placement from the
5200 `( type-id )' construct. */
5201 cp_parser_parse_tentatively (parser);
5202 /* Look for a new-placement. */
5203 placement = cp_parser_new_placement (parser);
5204 /* If that didn't work out, there's no new-placement. */
5205 if (!cp_parser_parse_definitely (parser))
5206 placement = NULL_TREE;
5208 /* If the next token is a `(', then we have a parenthesized
5210 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
5212 /* Consume the `('. */
5213 cp_lexer_consume_token (parser->lexer);
5214 /* Parse the type-id. */
5215 type = cp_parser_type_id (parser);
5216 /* Look for the closing `)'. */
5217 cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
5218 /* There should not be a direct-new-declarator in this production,
5219 but GCC used to allowed this, so we check and emit a sensible error
5220 message for this case. */
5221 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
5223 error ("array bound forbidden after parenthesized type-id");
5224 inform ("try removing the parentheses around the type-id");
5225 cp_parser_direct_new_declarator (parser);
5229 /* Otherwise, there must be a new-type-id. */
5231 type = cp_parser_new_type_id (parser, &nelts);
5233 /* If the next token is a `(', then we have a new-initializer. */
5234 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
5235 initializer = cp_parser_new_initializer (parser);
5237 initializer = NULL_TREE;
5239 /* A new-expression may not appear in an integral constant
5241 if (cp_parser_non_integral_constant_expression (parser, "`new'"))
5242 return error_mark_node;
5244 /* Create a representation of the new-expression. */
5245 return build_new (placement, type, nelts, initializer, global_scope_p);
5248 /* Parse a new-placement.
5253 Returns the same representation as for an expression-list. */
5256 cp_parser_new_placement (cp_parser* parser)
5258 tree expression_list;
5260 /* Parse the expression-list. */
5261 expression_list = (cp_parser_parenthesized_expression_list
5262 (parser, false, /*cast_p=*/false,
5263 /*non_constant_p=*/NULL));
5265 return expression_list;
5268 /* Parse a new-type-id.
5271 type-specifier-seq new-declarator [opt]
5273 Returns the TYPE allocated. If the new-type-id indicates an array
5274 type, *NELTS is set to the number of elements in the last array
5275 bound; the TYPE will not include the last array bound. */
5278 cp_parser_new_type_id (cp_parser* parser, tree *nelts)
5280 cp_decl_specifier_seq type_specifier_seq;
5281 cp_declarator *new_declarator;
5282 cp_declarator *declarator;
5283 cp_declarator *outer_declarator;
5284 const char *saved_message;
5287 /* The type-specifier sequence must not contain type definitions.
5288 (It cannot contain declarations of new types either, but if they
5289 are not definitions we will catch that because they are not
5291 saved_message = parser->type_definition_forbidden_message;
5292 parser->type_definition_forbidden_message
5293 = "types may not be defined in a new-type-id";
5294 /* Parse the type-specifier-seq. */
5295 cp_parser_type_specifier_seq (parser, /*is_condition=*/false,
5296 &type_specifier_seq);
5297 /* Restore the old message. */
5298 parser->type_definition_forbidden_message = saved_message;
5299 /* Parse the new-declarator. */
5300 new_declarator = cp_parser_new_declarator_opt (parser);
5302 /* Determine the number of elements in the last array dimension, if
5305 /* Skip down to the last array dimension. */
5306 declarator = new_declarator;
5307 outer_declarator = NULL;
5308 while (declarator && (declarator->kind == cdk_pointer
5309 || declarator->kind == cdk_ptrmem))
5311 outer_declarator = declarator;
5312 declarator = declarator->declarator;
5315 && declarator->kind == cdk_array
5316 && declarator->declarator
5317 && declarator->declarator->kind == cdk_array)
5319 outer_declarator = declarator;
5320 declarator = declarator->declarator;
5323 if (declarator && declarator->kind == cdk_array)
5325 *nelts = declarator->u.array.bounds;
5326 if (*nelts == error_mark_node)
5327 *nelts = integer_one_node;
5329 if (outer_declarator)
5330 outer_declarator->declarator = declarator->declarator;
5332 new_declarator = NULL;
5335 type = groktypename (&type_specifier_seq, new_declarator);
5336 if (TREE_CODE (type) == ARRAY_TYPE && *nelts == NULL_TREE)
5338 *nelts = array_type_nelts_top (type);
5339 type = TREE_TYPE (type);
5344 /* Parse an (optional) new-declarator.
5347 ptr-operator new-declarator [opt]
5348 direct-new-declarator
5350 Returns the declarator. */
5352 static cp_declarator *
5353 cp_parser_new_declarator_opt (cp_parser* parser)
5355 enum tree_code code;
5357 cp_cv_quals cv_quals;
5359 /* We don't know if there's a ptr-operator next, or not. */
5360 cp_parser_parse_tentatively (parser);
5361 /* Look for a ptr-operator. */
5362 code = cp_parser_ptr_operator (parser, &type, &cv_quals);
5363 /* If that worked, look for more new-declarators. */
5364 if (cp_parser_parse_definitely (parser))
5366 cp_declarator *declarator;
5368 /* Parse another optional declarator. */
5369 declarator = cp_parser_new_declarator_opt (parser);
5371 /* Create the representation of the declarator. */
5373 declarator = make_ptrmem_declarator (cv_quals, type, declarator);
5374 else if (code == INDIRECT_REF)
5375 declarator = make_pointer_declarator (cv_quals, declarator);
5377 declarator = make_reference_declarator (cv_quals, declarator);
5382 /* If the next token is a `[', there is a direct-new-declarator. */
5383 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
5384 return cp_parser_direct_new_declarator (parser);
5389 /* Parse a direct-new-declarator.
5391 direct-new-declarator:
5393 direct-new-declarator [constant-expression]
5397 static cp_declarator *
5398 cp_parser_direct_new_declarator (cp_parser* parser)
5400 cp_declarator *declarator = NULL;
5406 /* Look for the opening `['. */
5407 cp_parser_require (parser, CPP_OPEN_SQUARE, "`['");
5408 /* The first expression is not required to be constant. */
5411 expression = cp_parser_expression (parser, /*cast_p=*/false);
5412 /* The standard requires that the expression have integral
5413 type. DR 74 adds enumeration types. We believe that the
5414 real intent is that these expressions be handled like the
5415 expression in a `switch' condition, which also allows
5416 classes with a single conversion to integral or
5417 enumeration type. */
5418 if (!processing_template_decl)
5421 = build_expr_type_conversion (WANT_INT | WANT_ENUM,
5426 error ("expression in new-declarator must have integral "
5427 "or enumeration type");
5428 expression = error_mark_node;
5432 /* But all the other expressions must be. */
5435 = cp_parser_constant_expression (parser,
5436 /*allow_non_constant=*/false,
5438 /* Look for the closing `]'. */
5439 cp_parser_require (parser, CPP_CLOSE_SQUARE, "`]'");
5441 /* Add this bound to the declarator. */
5442 declarator = make_array_declarator (declarator, expression);
5444 /* If the next token is not a `[', then there are no more
5446 if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_SQUARE))
5453 /* Parse a new-initializer.
5456 ( expression-list [opt] )
5458 Returns a representation of the expression-list. If there is no
5459 expression-list, VOID_ZERO_NODE is returned. */
5462 cp_parser_new_initializer (cp_parser* parser)
5464 tree expression_list;
5466 expression_list = (cp_parser_parenthesized_expression_list
5467 (parser, false, /*cast_p=*/false,
5468 /*non_constant_p=*/NULL));
5469 if (!expression_list)
5470 expression_list = void_zero_node;
5472 return expression_list;
5475 /* Parse a delete-expression.
5478 :: [opt] delete cast-expression
5479 :: [opt] delete [ ] cast-expression
5481 Returns a representation of the expression. */
5484 cp_parser_delete_expression (cp_parser* parser)
5486 bool global_scope_p;
5490 /* Look for the optional `::' operator. */
5492 = (cp_parser_global_scope_opt (parser,
5493 /*current_scope_valid_p=*/false)
5495 /* Look for the `delete' keyword. */
5496 cp_parser_require_keyword (parser, RID_DELETE, "`delete'");
5497 /* See if the array syntax is in use. */
5498 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
5500 /* Consume the `[' token. */
5501 cp_lexer_consume_token (parser->lexer);
5502 /* Look for the `]' token. */
5503 cp_parser_require (parser, CPP_CLOSE_SQUARE, "`]'");
5504 /* Remember that this is the `[]' construct. */
5510 /* Parse the cast-expression. */
5511 expression = cp_parser_simple_cast_expression (parser);
5513 /* A delete-expression may not appear in an integral constant
5515 if (cp_parser_non_integral_constant_expression (parser, "`delete'"))
5516 return error_mark_node;
5518 return delete_sanity (expression, NULL_TREE, array_p, global_scope_p);
5521 /* Parse a cast-expression.
5525 ( type-id ) cast-expression
5527 ADDRESS_P is true iff the unary-expression is appearing as the
5528 operand of the `&' operator. CAST_P is true if this expression is
5529 the target of a cast.
5531 Returns a representation of the expression. */
5534 cp_parser_cast_expression (cp_parser *parser, bool address_p, bool cast_p)
5536 /* If it's a `(', then we might be looking at a cast. */
5537 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
5539 tree type = NULL_TREE;
5540 tree expr = NULL_TREE;
5541 bool compound_literal_p;
5542 const char *saved_message;
5544 /* There's no way to know yet whether or not this is a cast.
5545 For example, `(int (3))' is a unary-expression, while `(int)
5546 3' is a cast. So, we resort to parsing tentatively. */
5547 cp_parser_parse_tentatively (parser);
5548 /* Types may not be defined in a cast. */
5549 saved_message = parser->type_definition_forbidden_message;
5550 parser->type_definition_forbidden_message
5551 = "types may not be defined in casts";
5552 /* Consume the `('. */
5553 cp_lexer_consume_token (parser->lexer);
5554 /* A very tricky bit is that `(struct S) { 3 }' is a
5555 compound-literal (which we permit in C++ as an extension).
5556 But, that construct is not a cast-expression -- it is a
5557 postfix-expression. (The reason is that `(struct S) { 3 }.i'
5558 is legal; if the compound-literal were a cast-expression,
5559 you'd need an extra set of parentheses.) But, if we parse
5560 the type-id, and it happens to be a class-specifier, then we
5561 will commit to the parse at that point, because we cannot
5562 undo the action that is done when creating a new class. So,
5563 then we cannot back up and do a postfix-expression.
5565 Therefore, we scan ahead to the closing `)', and check to see
5566 if the token after the `)' is a `{'. If so, we are not
5567 looking at a cast-expression.
5569 Save tokens so that we can put them back. */
5570 cp_lexer_save_tokens (parser->lexer);
5571 /* Skip tokens until the next token is a closing parenthesis.
5572 If we find the closing `)', and the next token is a `{', then
5573 we are looking at a compound-literal. */
5575 = (cp_parser_skip_to_closing_parenthesis (parser, false, false,
5576 /*consume_paren=*/true)
5577 && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE));
5578 /* Roll back the tokens we skipped. */
5579 cp_lexer_rollback_tokens (parser->lexer);
5580 /* If we were looking at a compound-literal, simulate an error
5581 so that the call to cp_parser_parse_definitely below will
5583 if (compound_literal_p)
5584 cp_parser_simulate_error (parser);
5587 bool saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p;
5588 parser->in_type_id_in_expr_p = true;
5589 /* Look for the type-id. */
5590 type = cp_parser_type_id (parser);
5591 /* Look for the closing `)'. */
5592 cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
5593 parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
5596 /* Restore the saved message. */
5597 parser->type_definition_forbidden_message = saved_message;
5599 /* If ok so far, parse the dependent expression. We cannot be
5600 sure it is a cast. Consider `(T ())'. It is a parenthesized
5601 ctor of T, but looks like a cast to function returning T
5602 without a dependent expression. */
5603 if (!cp_parser_error_occurred (parser))
5604 expr = cp_parser_cast_expression (parser,
5605 /*address_p=*/false,
5608 if (cp_parser_parse_definitely (parser))
5610 /* Warn about old-style casts, if so requested. */
5611 if (warn_old_style_cast
5612 && !in_system_header
5613 && !VOID_TYPE_P (type)
5614 && current_lang_name != lang_name_c)
5615 warning (OPT_Wold_style_cast, "use of old-style cast");
5617 /* Only type conversions to integral or enumeration types
5618 can be used in constant-expressions. */
5619 if (!cast_valid_in_integral_constant_expression_p (type)
5620 && (cp_parser_non_integral_constant_expression
5622 "a cast to a type other than an integral or "
5623 "enumeration type")))
5624 return error_mark_node;
5626 /* Perform the cast. */
5627 expr = build_c_cast (type, expr);
5632 /* If we get here, then it's not a cast, so it must be a
5633 unary-expression. */
5634 return cp_parser_unary_expression (parser, address_p, cast_p);
5637 /* Parse a binary expression of the general form:
5641 pm-expression .* cast-expression
5642 pm-expression ->* cast-expression
5644 multiplicative-expression:
5646 multiplicative-expression * pm-expression
5647 multiplicative-expression / pm-expression
5648 multiplicative-expression % pm-expression
5650 additive-expression:
5651 multiplicative-expression
5652 additive-expression + multiplicative-expression
5653 additive-expression - multiplicative-expression
5657 shift-expression << additive-expression
5658 shift-expression >> additive-expression
5660 relational-expression:
5662 relational-expression < shift-expression
5663 relational-expression > shift-expression
5664 relational-expression <= shift-expression
5665 relational-expression >= shift-expression
5669 relational-expression:
5670 relational-expression <? shift-expression
5671 relational-expression >? shift-expression
5673 equality-expression:
5674 relational-expression
5675 equality-expression == relational-expression
5676 equality-expression != relational-expression
5680 and-expression & equality-expression
5682 exclusive-or-expression:
5684 exclusive-or-expression ^ and-expression
5686 inclusive-or-expression:
5687 exclusive-or-expression
5688 inclusive-or-expression | exclusive-or-expression
5690 logical-and-expression:
5691 inclusive-or-expression
5692 logical-and-expression && inclusive-or-expression
5694 logical-or-expression:
5695 logical-and-expression
5696 logical-or-expression || logical-and-expression
5698 All these are implemented with a single function like:
5701 simple-cast-expression
5702 binary-expression <token> binary-expression
5704 CAST_P is true if this expression is the target of a cast.
5706 The binops_by_token map is used to get the tree codes for each <token> type.
5707 binary-expressions are associated according to a precedence table. */
5709 #define TOKEN_PRECEDENCE(token) \
5710 ((token->type == CPP_GREATER && !parser->greater_than_is_operator_p) \
5711 ? PREC_NOT_OPERATOR \
5712 : binops_by_token[token->type].prec)
5715 cp_parser_binary_expression (cp_parser* parser, bool cast_p)
5717 cp_parser_expression_stack stack;
5718 cp_parser_expression_stack_entry *sp = &stack[0];
5721 enum tree_code tree_type, lhs_type, rhs_type;
5722 enum cp_parser_prec prec = PREC_NOT_OPERATOR, new_prec, lookahead_prec;
5725 /* Parse the first expression. */
5726 lhs = cp_parser_cast_expression (parser, /*address_p=*/false, cast_p);
5727 lhs_type = ERROR_MARK;
5731 /* Get an operator token. */
5732 token = cp_lexer_peek_token (parser->lexer);
5734 new_prec = TOKEN_PRECEDENCE (token);
5736 /* Popping an entry off the stack means we completed a subexpression:
5737 - either we found a token which is not an operator (`>' where it is not
5738 an operator, or prec == PREC_NOT_OPERATOR), in which case popping
5739 will happen repeatedly;
5740 - or, we found an operator which has lower priority. This is the case
5741 where the recursive descent *ascends*, as in `3 * 4 + 5' after
5743 if (new_prec <= prec)
5752 tree_type = binops_by_token[token->type].tree_type;
5754 /* We used the operator token. */
5755 cp_lexer_consume_token (parser->lexer);
5757 /* Extract another operand. It may be the RHS of this expression
5758 or the LHS of a new, higher priority expression. */
5759 rhs = cp_parser_simple_cast_expression (parser);
5760 rhs_type = ERROR_MARK;
5762 /* Get another operator token. Look up its precedence to avoid
5763 building a useless (immediately popped) stack entry for common
5764 cases such as 3 + 4 + 5 or 3 * 4 + 5. */
5765 token = cp_lexer_peek_token (parser->lexer);
5766 lookahead_prec = TOKEN_PRECEDENCE (token);
5767 if (lookahead_prec > new_prec)
5769 /* ... and prepare to parse the RHS of the new, higher priority
5770 expression. Since precedence levels on the stack are
5771 monotonically increasing, we do not have to care about
5774 sp->tree_type = tree_type;
5776 sp->lhs_type = lhs_type;
5779 lhs_type = rhs_type;
5781 new_prec = lookahead_prec;
5785 /* If the stack is not empty, we have parsed into LHS the right side
5786 (`4' in the example above) of an expression we had suspended.
5787 We can use the information on the stack to recover the LHS (`3')
5788 from the stack together with the tree code (`MULT_EXPR'), and
5789 the precedence of the higher level subexpression
5790 (`PREC_ADDITIVE_EXPRESSION'). TOKEN is the CPP_PLUS token,
5791 which will be used to actually build the additive expression. */
5794 tree_type = sp->tree_type;
5796 rhs_type = lhs_type;
5798 lhs_type = sp->lhs_type;
5801 overloaded_p = false;
5802 lhs = build_x_binary_op (tree_type, lhs, lhs_type, rhs, rhs_type,
5804 lhs_type = tree_type;
5806 /* If the binary operator required the use of an overloaded operator,
5807 then this expression cannot be an integral constant-expression.
5808 An overloaded operator can be used even if both operands are
5809 otherwise permissible in an integral constant-expression if at
5810 least one of the operands is of enumeration type. */
5813 && (cp_parser_non_integral_constant_expression
5814 (parser, "calls to overloaded operators")))
5815 return error_mark_node;
5822 /* Parse the `? expression : assignment-expression' part of a
5823 conditional-expression. The LOGICAL_OR_EXPR is the
5824 logical-or-expression that started the conditional-expression.
5825 Returns a representation of the entire conditional-expression.
5827 This routine is used by cp_parser_assignment_expression.
5829 ? expression : assignment-expression
5833 ? : assignment-expression */
5836 cp_parser_question_colon_clause (cp_parser* parser, tree logical_or_expr)
5839 tree assignment_expr;
5841 /* Consume the `?' token. */
5842 cp_lexer_consume_token (parser->lexer);
5843 if (cp_parser_allow_gnu_extensions_p (parser)
5844 && cp_lexer_next_token_is (parser->lexer, CPP_COLON))
5845 /* Implicit true clause. */
5848 /* Parse the expression. */
5849 expr = cp_parser_expression (parser, /*cast_p=*/false);
5851 /* The next token should be a `:'. */
5852 cp_parser_require (parser, CPP_COLON, "`:'");
5853 /* Parse the assignment-expression. */
5854 assignment_expr = cp_parser_assignment_expression (parser, /*cast_p=*/false);
5856 /* Build the conditional-expression. */
5857 return build_x_conditional_expr (logical_or_expr,
5862 /* Parse an assignment-expression.
5864 assignment-expression:
5865 conditional-expression
5866 logical-or-expression assignment-operator assignment_expression
5869 CAST_P is true if this expression is the target of a cast.
5871 Returns a representation for the expression. */
5874 cp_parser_assignment_expression (cp_parser* parser, bool cast_p)
5878 /* If the next token is the `throw' keyword, then we're looking at
5879 a throw-expression. */
5880 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_THROW))
5881 expr = cp_parser_throw_expression (parser);
5882 /* Otherwise, it must be that we are looking at a
5883 logical-or-expression. */
5886 /* Parse the binary expressions (logical-or-expression). */
5887 expr = cp_parser_binary_expression (parser, cast_p);
5888 /* If the next token is a `?' then we're actually looking at a
5889 conditional-expression. */
5890 if (cp_lexer_next_token_is (parser->lexer, CPP_QUERY))
5891 return cp_parser_question_colon_clause (parser, expr);
5894 enum tree_code assignment_operator;
5896 /* If it's an assignment-operator, we're using the second
5899 = cp_parser_assignment_operator_opt (parser);
5900 if (assignment_operator != ERROR_MARK)
5904 /* Parse the right-hand side of the assignment. */
5905 rhs = cp_parser_assignment_expression (parser, cast_p);
5906 /* An assignment may not appear in a
5907 constant-expression. */
5908 if (cp_parser_non_integral_constant_expression (parser,
5910 return error_mark_node;
5911 /* Build the assignment expression. */
5912 expr = build_x_modify_expr (expr,
5913 assignment_operator,
5922 /* Parse an (optional) assignment-operator.
5924 assignment-operator: one of
5925 = *= /= %= += -= >>= <<= &= ^= |=
5929 assignment-operator: one of
5932 If the next token is an assignment operator, the corresponding tree
5933 code is returned, and the token is consumed. For example, for
5934 `+=', PLUS_EXPR is returned. For `=' itself, the code returned is
5935 NOP_EXPR. For `/', TRUNC_DIV_EXPR is returned; for `%',
5936 TRUNC_MOD_EXPR is returned. If TOKEN is not an assignment
5937 operator, ERROR_MARK is returned. */
5939 static enum tree_code
5940 cp_parser_assignment_operator_opt (cp_parser* parser)
5945 /* Peek at the next toen. */
5946 token = cp_lexer_peek_token (parser->lexer);
5948 switch (token->type)
5959 op = TRUNC_DIV_EXPR;
5963 op = TRUNC_MOD_EXPR;
5995 /* Nothing else is an assignment operator. */
5999 /* If it was an assignment operator, consume it. */
6000 if (op != ERROR_MARK)
6001 cp_lexer_consume_token (parser->lexer);
6006 /* Parse an expression.
6009 assignment-expression
6010 expression , assignment-expression
6012 CAST_P is true if this expression is the target of a cast.
6014 Returns a representation of the expression. */
6017 cp_parser_expression (cp_parser* parser, bool cast_p)
6019 tree expression = NULL_TREE;
6023 tree assignment_expression;
6025 /* Parse the next assignment-expression. */
6026 assignment_expression
6027 = cp_parser_assignment_expression (parser, cast_p);
6028 /* If this is the first assignment-expression, we can just
6031 expression = assignment_expression;
6033 expression = build_x_compound_expr (expression,
6034 assignment_expression);
6035 /* If the next token is not a comma, then we are done with the
6037 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
6039 /* Consume the `,'. */
6040 cp_lexer_consume_token (parser->lexer);
6041 /* A comma operator cannot appear in a constant-expression. */
6042 if (cp_parser_non_integral_constant_expression (parser,
6043 "a comma operator"))
6044 expression = error_mark_node;
6050 /* Parse a constant-expression.
6052 constant-expression:
6053 conditional-expression
6055 If ALLOW_NON_CONSTANT_P a non-constant expression is silently
6056 accepted. If ALLOW_NON_CONSTANT_P is true and the expression is not
6057 constant, *NON_CONSTANT_P is set to TRUE. If ALLOW_NON_CONSTANT_P
6058 is false, NON_CONSTANT_P should be NULL. */
6061 cp_parser_constant_expression (cp_parser* parser,
6062 bool allow_non_constant_p,
6063 bool *non_constant_p)
6065 bool saved_integral_constant_expression_p;
6066 bool saved_allow_non_integral_constant_expression_p;
6067 bool saved_non_integral_constant_expression_p;
6070 /* It might seem that we could simply parse the
6071 conditional-expression, and then check to see if it were
6072 TREE_CONSTANT. However, an expression that is TREE_CONSTANT is
6073 one that the compiler can figure out is constant, possibly after
6074 doing some simplifications or optimizations. The standard has a
6075 precise definition of constant-expression, and we must honor
6076 that, even though it is somewhat more restrictive.
6082 is not a legal declaration, because `(2, 3)' is not a
6083 constant-expression. The `,' operator is forbidden in a
6084 constant-expression. However, GCC's constant-folding machinery
6085 will fold this operation to an INTEGER_CST for `3'. */
6087 /* Save the old settings. */
6088 saved_integral_constant_expression_p = parser->integral_constant_expression_p;
6089 saved_allow_non_integral_constant_expression_p
6090 = parser->allow_non_integral_constant_expression_p;
6091 saved_non_integral_constant_expression_p = parser->non_integral_constant_expression_p;
6092 /* We are now parsing a constant-expression. */
6093 parser->integral_constant_expression_p = true;
6094 parser->allow_non_integral_constant_expression_p = allow_non_constant_p;
6095 parser->non_integral_constant_expression_p = false;
6096 integral_constant_expr_p = true;
6097 /* Although the grammar says "conditional-expression", we parse an
6098 "assignment-expression", which also permits "throw-expression"
6099 and the use of assignment operators. In the case that
6100 ALLOW_NON_CONSTANT_P is false, we get better errors than we would
6101 otherwise. In the case that ALLOW_NON_CONSTANT_P is true, it is
6102 actually essential that we look for an assignment-expression.
6103 For example, cp_parser_initializer_clauses uses this function to
6104 determine whether a particular assignment-expression is in fact
6106 expression = cp_parser_assignment_expression (parser, /*cast_p=*/false);
6107 /* Restore the old settings. */
6108 integral_constant_expr_p = false;
6109 parser->integral_constant_expression_p
6110 = saved_integral_constant_expression_p;
6111 parser->allow_non_integral_constant_expression_p
6112 = saved_allow_non_integral_constant_expression_p;
6113 if (allow_non_constant_p)
6114 *non_constant_p = parser->non_integral_constant_expression_p;
6115 else if (parser->non_integral_constant_expression_p)
6116 expression = error_mark_node;
6117 parser->non_integral_constant_expression_p
6118 = saved_non_integral_constant_expression_p;
6123 /* Parse __builtin_offsetof.
6125 offsetof-expression:
6126 "__builtin_offsetof" "(" type-id "," offsetof-member-designator ")"
6128 offsetof-member-designator:
6130 | offsetof-member-designator "." id-expression
6131 | offsetof-member-designator "[" expression "]" */
6134 cp_parser_builtin_offsetof (cp_parser *parser)
6136 int save_ice_p, save_non_ice_p;
6140 /* We're about to accept non-integral-constant things, but will
6141 definitely yield an integral constant expression. Save and
6142 restore these values around our local parsing. */
6143 save_ice_p = parser->integral_constant_expression_p;
6144 save_non_ice_p = parser->non_integral_constant_expression_p;
6146 /* Consume the "__builtin_offsetof" token. */
6147 cp_lexer_consume_token (parser->lexer);
6148 /* Consume the opening `('. */
6149 cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
6150 /* Parse the type-id. */
6151 type = cp_parser_type_id (parser);
6152 /* Look for the `,'. */
6153 cp_parser_require (parser, CPP_COMMA, "`,'");
6155 /* Build the (type *)null that begins the traditional offsetof macro. */
6156 expr = build_static_cast (build_pointer_type (type), null_pointer_node);
6158 /* Parse the offsetof-member-designator. We begin as if we saw "expr->". */
6159 expr = cp_parser_postfix_dot_deref_expression (parser, CPP_DEREF, expr,
6163 cp_token *token = cp_lexer_peek_token (parser->lexer);
6164 switch (token->type)
6166 case CPP_OPEN_SQUARE:
6167 /* offsetof-member-designator "[" expression "]" */
6168 expr = cp_parser_postfix_open_square_expression (parser, expr, true);
6172 /* offsetof-member-designator "." identifier */
6173 cp_lexer_consume_token (parser->lexer);
6174 expr = cp_parser_postfix_dot_deref_expression (parser, CPP_DOT, expr,
6178 case CPP_CLOSE_PAREN:
6179 /* Consume the ")" token. */
6180 cp_lexer_consume_token (parser->lexer);
6184 /* Error. We know the following require will fail, but
6185 that gives the proper error message. */
6186 cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
6187 cp_parser_skip_to_closing_parenthesis (parser, true, false, true);
6188 expr = error_mark_node;
6194 /* If we're processing a template, we can't finish the semantics yet.
6195 Otherwise we can fold the entire expression now. */
6196 if (processing_template_decl)
6197 expr = build1 (OFFSETOF_EXPR, size_type_node, expr);
6199 expr = finish_offsetof (expr);
6202 parser->integral_constant_expression_p = save_ice_p;
6203 parser->non_integral_constant_expression_p = save_non_ice_p;
6208 /* Statements [gram.stmt.stmt] */
6210 /* Parse a statement.
6214 expression-statement
6219 declaration-statement
6222 IN_COMPOUND is true when the statement is nested inside a
6223 cp_parser_compound_statement; this matters for certain pragmas.
6225 If IF_P is not NULL, *IF_P is set to indicate whether the statement
6226 is a (possibly labeled) if statement which is not enclosed in braces
6227 and has an else clause. This is used to implement -Wparentheses. */
6230 cp_parser_statement (cp_parser* parser, tree in_statement_expr,
6231 bool in_compound, bool *if_p)
6235 location_t statement_location;
6240 /* There is no statement yet. */
6241 statement = NULL_TREE;
6242 /* Peek at the next token. */
6243 token = cp_lexer_peek_token (parser->lexer);
6244 /* Remember the location of the first token in the statement. */
6245 statement_location = token->location;
6246 /* If this is a keyword, then that will often determine what kind of
6247 statement we have. */
6248 if (token->type == CPP_KEYWORD)
6250 enum rid keyword = token->keyword;
6256 /* Looks like a labeled-statement with a case label.
6257 Parse the label, and then use tail recursion to parse
6259 cp_parser_label_for_labeled_statement (parser);
6264 statement = cp_parser_selection_statement (parser, if_p);
6270 statement = cp_parser_iteration_statement (parser);
6277 statement = cp_parser_jump_statement (parser);
6280 /* Objective-C++ exception-handling constructs. */
6283 case RID_AT_FINALLY:
6284 case RID_AT_SYNCHRONIZED:
6286 statement = cp_parser_objc_statement (parser);
6290 statement = cp_parser_try_block (parser);
6294 /* It might be a keyword like `int' that can start a
6295 declaration-statement. */
6299 else if (token->type == CPP_NAME)
6301 /* If the next token is a `:', then we are looking at a
6302 labeled-statement. */
6303 token = cp_lexer_peek_nth_token (parser->lexer, 2);
6304 if (token->type == CPP_COLON)
6306 /* Looks like a labeled-statement with an ordinary label.
6307 Parse the label, and then use tail recursion to parse
6309 cp_parser_label_for_labeled_statement (parser);
6313 /* Anything that starts with a `{' must be a compound-statement. */
6314 else if (token->type == CPP_OPEN_BRACE)
6315 statement = cp_parser_compound_statement (parser, NULL, false);
6316 /* CPP_PRAGMA is a #pragma inside a function body, which constitutes
6317 a statement all its own. */
6318 else if (token->type == CPP_PRAGMA)
6320 /* Only certain OpenMP pragmas are attached to statements, and thus
6321 are considered statements themselves. All others are not. In
6322 the context of a compound, accept the pragma as a "statement" and
6323 return so that we can check for a close brace. Otherwise we
6324 require a real statement and must go back and read one. */
6326 cp_parser_pragma (parser, pragma_compound);
6327 else if (!cp_parser_pragma (parser, pragma_stmt))
6331 else if (token->type == CPP_EOF)
6333 cp_parser_error (parser, "expected statement");
6337 /* Everything else must be a declaration-statement or an
6338 expression-statement. Try for the declaration-statement
6339 first, unless we are looking at a `;', in which case we know that
6340 we have an expression-statement. */
6343 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
6345 cp_parser_parse_tentatively (parser);
6346 /* Try to parse the declaration-statement. */
6347 cp_parser_declaration_statement (parser);
6348 /* If that worked, we're done. */
6349 if (cp_parser_parse_definitely (parser))
6352 /* Look for an expression-statement instead. */
6353 statement = cp_parser_expression_statement (parser, in_statement_expr);
6356 /* Set the line number for the statement. */
6357 if (statement && STATEMENT_CODE_P (TREE_CODE (statement)))
6358 SET_EXPR_LOCATION (statement, statement_location);
6361 /* Parse the label for a labeled-statement, i.e.
6364 case constant-expression :
6368 case constant-expression ... constant-expression : statement
6370 When a label is parsed without errors, the label is added to the
6371 parse tree by the finish_* functions, so this function doesn't
6372 have to return the label. */
6375 cp_parser_label_for_labeled_statement (cp_parser* parser)
6379 /* The next token should be an identifier. */
6380 token = cp_lexer_peek_token (parser->lexer);
6381 if (token->type != CPP_NAME
6382 && token->type != CPP_KEYWORD)
6384 cp_parser_error (parser, "expected labeled-statement");
6388 switch (token->keyword)
6395 /* Consume the `case' token. */
6396 cp_lexer_consume_token (parser->lexer);
6397 /* Parse the constant-expression. */
6398 expr = cp_parser_constant_expression (parser,
6399 /*allow_non_constant_p=*/false,
6402 ellipsis = cp_lexer_peek_token (parser->lexer);
6403 if (ellipsis->type == CPP_ELLIPSIS)
6405 /* Consume the `...' token. */
6406 cp_lexer_consume_token (parser->lexer);
6408 cp_parser_constant_expression (parser,
6409 /*allow_non_constant_p=*/false,
6411 /* We don't need to emit warnings here, as the common code
6412 will do this for us. */
6415 expr_hi = NULL_TREE;
6417 if (parser->in_switch_statement_p)
6418 finish_case_label (expr, expr_hi);
6420 error ("case label %qE not within a switch statement", expr);
6425 /* Consume the `default' token. */
6426 cp_lexer_consume_token (parser->lexer);
6428 if (parser->in_switch_statement_p)
6429 finish_case_label (NULL_TREE, NULL_TREE);
6431 error ("case label not within a switch statement");
6435 /* Anything else must be an ordinary label. */
6436 finish_label_stmt (cp_parser_identifier (parser));
6440 /* Require the `:' token. */
6441 cp_parser_require (parser, CPP_COLON, "`:'");
6444 /* Parse an expression-statement.
6446 expression-statement:
6449 Returns the new EXPR_STMT -- or NULL_TREE if the expression
6450 statement consists of nothing more than an `;'. IN_STATEMENT_EXPR_P
6451 indicates whether this expression-statement is part of an
6452 expression statement. */
6455 cp_parser_expression_statement (cp_parser* parser, tree in_statement_expr)
6457 tree statement = NULL_TREE;
6459 /* If the next token is a ';', then there is no expression
6461 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
6462 statement = cp_parser_expression (parser, /*cast_p=*/false);
6464 /* Consume the final `;'. */
6465 cp_parser_consume_semicolon_at_end_of_statement (parser);
6467 if (in_statement_expr
6468 && cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
6469 /* This is the final expression statement of a statement
6471 statement = finish_stmt_expr_expr (statement, in_statement_expr);
6473 statement = finish_expr_stmt (statement);
6480 /* Parse a compound-statement.
6483 { statement-seq [opt] }
6485 Returns a tree representing the statement. */
6488 cp_parser_compound_statement (cp_parser *parser, tree in_statement_expr,
6493 /* Consume the `{'. */
6494 if (!cp_parser_require (parser, CPP_OPEN_BRACE, "`{'"))
6495 return error_mark_node;
6496 /* Begin the compound-statement. */
6497 compound_stmt = begin_compound_stmt (in_try ? BCS_TRY_BLOCK : 0);
6498 /* Parse an (optional) statement-seq. */
6499 cp_parser_statement_seq_opt (parser, in_statement_expr);
6500 /* Finish the compound-statement. */
6501 finish_compound_stmt (compound_stmt);
6502 /* Consume the `}'. */
6503 cp_parser_require (parser, CPP_CLOSE_BRACE, "`}'");
6505 return compound_stmt;
6508 /* Parse an (optional) statement-seq.
6512 statement-seq [opt] statement */
6515 cp_parser_statement_seq_opt (cp_parser* parser, tree in_statement_expr)
6517 /* Scan statements until there aren't any more. */
6520 cp_token *token = cp_lexer_peek_token (parser->lexer);
6522 /* If we're looking at a `}', then we've run out of statements. */
6523 if (token->type == CPP_CLOSE_BRACE
6524 || token->type == CPP_EOF
6525 || token->type == CPP_PRAGMA_EOL)
6528 /* Parse the statement. */
6529 cp_parser_statement (parser, in_statement_expr, true, NULL);
6533 /* Parse a selection-statement.
6535 selection-statement:
6536 if ( condition ) statement
6537 if ( condition ) statement else statement
6538 switch ( condition ) statement
6540 Returns the new IF_STMT or SWITCH_STMT.
6542 If IF_P is not NULL, *IF_P is set to indicate whether the statement
6543 is a (possibly labeled) if statement which is not enclosed in
6544 braces and has an else clause. This is used to implement
6548 cp_parser_selection_statement (cp_parser* parser, bool *if_p)
6556 /* Peek at the next token. */
6557 token = cp_parser_require (parser, CPP_KEYWORD, "selection-statement");
6559 /* See what kind of keyword it is. */
6560 keyword = token->keyword;
6569 /* Look for the `('. */
6570 if (!cp_parser_require (parser, CPP_OPEN_PAREN, "`('"))
6572 cp_parser_skip_to_end_of_statement (parser);
6573 return error_mark_node;
6576 /* Begin the selection-statement. */
6577 if (keyword == RID_IF)
6578 statement = begin_if_stmt ();
6580 statement = begin_switch_stmt ();
6582 /* Parse the condition. */
6583 condition = cp_parser_condition (parser);
6584 /* Look for the `)'. */
6585 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"))
6586 cp_parser_skip_to_closing_parenthesis (parser, true, false,
6587 /*consume_paren=*/true);
6589 if (keyword == RID_IF)
6593 /* Add the condition. */
6594 finish_if_stmt_cond (condition, statement);
6596 /* Parse the then-clause. */
6597 cp_parser_implicitly_scoped_statement (parser, &nested_if);
6598 finish_then_clause (statement);
6600 /* If the next token is `else', parse the else-clause. */
6601 if (cp_lexer_next_token_is_keyword (parser->lexer,
6604 /* Consume the `else' keyword. */
6605 cp_lexer_consume_token (parser->lexer);
6606 begin_else_clause (statement);
6607 /* Parse the else-clause. */
6608 cp_parser_implicitly_scoped_statement (parser, NULL);
6609 finish_else_clause (statement);
6611 /* If we are currently parsing a then-clause, then
6612 IF_P will not be NULL. We set it to true to
6613 indicate that this if statement has an else clause.
6614 This may trigger the Wparentheses warning below
6615 when we get back up to the parent if statement. */
6621 /* This if statement does not have an else clause. If
6622 NESTED_IF is true, then the then-clause is an if
6623 statement which does have an else clause. We warn
6624 about the potential ambiguity. */
6626 warning (OPT_Wparentheses,
6627 ("%Hsuggest explicit braces "
6628 "to avoid ambiguous %<else%>"),
6629 EXPR_LOCUS (statement));
6632 /* Now we're all done with the if-statement. */
6633 finish_if_stmt (statement);
6637 bool in_switch_statement_p;
6638 unsigned char in_statement;
6640 /* Add the condition. */
6641 finish_switch_cond (condition, statement);
6643 /* Parse the body of the switch-statement. */
6644 in_switch_statement_p = parser->in_switch_statement_p;
6645 in_statement = parser->in_statement;
6646 parser->in_switch_statement_p = true;
6647 parser->in_statement |= IN_SWITCH_STMT;
6648 cp_parser_implicitly_scoped_statement (parser, NULL);
6649 parser->in_switch_statement_p = in_switch_statement_p;
6650 parser->in_statement = in_statement;
6652 /* Now we're all done with the switch-statement. */
6653 finish_switch_stmt (statement);
6661 cp_parser_error (parser, "expected selection-statement");
6662 return error_mark_node;
6666 /* Parse a condition.
6670 type-specifier-seq declarator = assignment-expression
6675 type-specifier-seq declarator asm-specification [opt]
6676 attributes [opt] = assignment-expression
6678 Returns the expression that should be tested. */
6681 cp_parser_condition (cp_parser* parser)
6683 cp_decl_specifier_seq type_specifiers;
6684 const char *saved_message;
6686 /* Try the declaration first. */
6687 cp_parser_parse_tentatively (parser);
6688 /* New types are not allowed in the type-specifier-seq for a
6690 saved_message = parser->type_definition_forbidden_message;
6691 parser->type_definition_forbidden_message
6692 = "types may not be defined in conditions";
6693 /* Parse the type-specifier-seq. */
6694 cp_parser_type_specifier_seq (parser, /*is_condition==*/true,
6696 /* Restore the saved message. */
6697 parser->type_definition_forbidden_message = saved_message;
6698 /* If all is well, we might be looking at a declaration. */
6699 if (!cp_parser_error_occurred (parser))
6702 tree asm_specification;
6704 cp_declarator *declarator;
6705 tree initializer = NULL_TREE;
6707 /* Parse the declarator. */
6708 declarator = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
6709 /*ctor_dtor_or_conv_p=*/NULL,
6710 /*parenthesized_p=*/NULL,
6711 /*member_p=*/false);
6712 /* Parse the attributes. */
6713 attributes = cp_parser_attributes_opt (parser);
6714 /* Parse the asm-specification. */
6715 asm_specification = cp_parser_asm_specification_opt (parser);
6716 /* If the next token is not an `=', then we might still be
6717 looking at an expression. For example:
6721 looks like a decl-specifier-seq and a declarator -- but then
6722 there is no `=', so this is an expression. */
6723 cp_parser_require (parser, CPP_EQ, "`='");
6724 /* If we did see an `=', then we are looking at a declaration
6726 if (cp_parser_parse_definitely (parser))
6729 bool non_constant_p;
6731 /* Create the declaration. */
6732 decl = start_decl (declarator, &type_specifiers,
6733 /*initialized_p=*/true,
6734 attributes, /*prefix_attributes=*/NULL_TREE,
6736 /* Parse the assignment-expression. */
6738 = cp_parser_constant_expression (parser,
6739 /*allow_non_constant_p=*/true,
6741 if (!non_constant_p)
6742 initializer = fold_non_dependent_expr (initializer);
6744 /* Process the initializer. */
6745 cp_finish_decl (decl,
6746 initializer, !non_constant_p,
6748 LOOKUP_ONLYCONVERTING);
6751 pop_scope (pushed_scope);
6753 return convert_from_reference (decl);
6756 /* If we didn't even get past the declarator successfully, we are
6757 definitely not looking at a declaration. */
6759 cp_parser_abort_tentative_parse (parser);
6761 /* Otherwise, we are looking at an expression. */
6762 return cp_parser_expression (parser, /*cast_p=*/false);
6765 /* Parse an iteration-statement.
6767 iteration-statement:
6768 while ( condition ) statement
6769 do statement while ( expression ) ;
6770 for ( for-init-statement condition [opt] ; expression [opt] )
6773 Returns the new WHILE_STMT, DO_STMT, or FOR_STMT. */
6776 cp_parser_iteration_statement (cp_parser* parser)
6781 unsigned char in_statement;
6783 /* Peek at the next token. */
6784 token = cp_parser_require (parser, CPP_KEYWORD, "iteration-statement");
6786 return error_mark_node;
6788 /* Remember whether or not we are already within an iteration
6790 in_statement = parser->in_statement;
6792 /* See what kind of keyword it is. */
6793 keyword = token->keyword;
6800 /* Begin the while-statement. */
6801 statement = begin_while_stmt ();
6802 /* Look for the `('. */
6803 cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
6804 /* Parse the condition. */
6805 condition = cp_parser_condition (parser);
6806 finish_while_stmt_cond (condition, statement);
6807 /* Look for the `)'. */
6808 cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
6809 /* Parse the dependent statement. */
6810 parser->in_statement = IN_ITERATION_STMT;
6811 cp_parser_already_scoped_statement (parser);
6812 parser->in_statement = in_statement;
6813 /* We're done with the while-statement. */
6814 finish_while_stmt (statement);
6822 /* Begin the do-statement. */
6823 statement = begin_do_stmt ();
6824 /* Parse the body of the do-statement. */
6825 parser->in_statement = IN_ITERATION_STMT;
6826 cp_parser_implicitly_scoped_statement (parser, NULL);
6827 parser->in_statement = in_statement;
6828 finish_do_body (statement);
6829 /* Look for the `while' keyword. */
6830 cp_parser_require_keyword (parser, RID_WHILE, "`while'");
6831 /* Look for the `('. */
6832 cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
6833 /* Parse the expression. */
6834 expression = cp_parser_expression (parser, /*cast_p=*/false);
6835 /* We're done with the do-statement. */
6836 finish_do_stmt (expression, statement);
6837 /* Look for the `)'. */
6838 cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
6839 /* Look for the `;'. */
6840 cp_parser_require (parser, CPP_SEMICOLON, "`;'");
6846 tree condition = NULL_TREE;
6847 tree expression = NULL_TREE;
6849 /* Begin the for-statement. */
6850 statement = begin_for_stmt ();
6851 /* Look for the `('. */
6852 cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
6853 /* Parse the initialization. */
6854 cp_parser_for_init_statement (parser);
6855 finish_for_init_stmt (statement);
6857 /* If there's a condition, process it. */
6858 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
6859 condition = cp_parser_condition (parser);
6860 finish_for_cond (condition, statement);
6861 /* Look for the `;'. */
6862 cp_parser_require (parser, CPP_SEMICOLON, "`;'");
6864 /* If there's an expression, process it. */
6865 if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
6866 expression = cp_parser_expression (parser, /*cast_p=*/false);
6867 finish_for_expr (expression, statement);
6868 /* Look for the `)'. */
6869 cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
6871 /* Parse the body of the for-statement. */
6872 parser->in_statement = IN_ITERATION_STMT;
6873 cp_parser_already_scoped_statement (parser);
6874 parser->in_statement = in_statement;
6876 /* We're done with the for-statement. */
6877 finish_for_stmt (statement);
6882 cp_parser_error (parser, "expected iteration-statement");
6883 statement = error_mark_node;
6890 /* Parse a for-init-statement.
6893 expression-statement
6894 simple-declaration */
6897 cp_parser_for_init_statement (cp_parser* parser)
6899 /* If the next token is a `;', then we have an empty
6900 expression-statement. Grammatically, this is also a
6901 simple-declaration, but an invalid one, because it does not
6902 declare anything. Therefore, if we did not handle this case
6903 specially, we would issue an error message about an invalid
6905 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
6907 /* We're going to speculatively look for a declaration, falling back
6908 to an expression, if necessary. */
6909 cp_parser_parse_tentatively (parser);
6910 /* Parse the declaration. */
6911 cp_parser_simple_declaration (parser,
6912 /*function_definition_allowed_p=*/false);
6913 /* If the tentative parse failed, then we shall need to look for an
6914 expression-statement. */
6915 if (cp_parser_parse_definitely (parser))
6919 cp_parser_expression_statement (parser, false);
6922 /* Parse a jump-statement.
6927 return expression [opt] ;
6935 Returns the new BREAK_STMT, CONTINUE_STMT, RETURN_EXPR, or GOTO_EXPR. */
6938 cp_parser_jump_statement (cp_parser* parser)
6940 tree statement = error_mark_node;
6944 /* Peek at the next token. */
6945 token = cp_parser_require (parser, CPP_KEYWORD, "jump-statement");
6947 return error_mark_node;
6949 /* See what kind of keyword it is. */
6950 keyword = token->keyword;
6954 switch (parser->in_statement)
6957 error ("break statement not within loop or switch");
6960 gcc_assert ((parser->in_statement & IN_SWITCH_STMT)
6961 || parser->in_statement == IN_ITERATION_STMT);
6962 statement = finish_break_stmt ();
6965 error ("invalid exit from OpenMP structured block");
6968 error ("break statement used with OpenMP for loop");
6971 cp_parser_require (parser, CPP_SEMICOLON, "%<;%>");
6975 switch (parser->in_statement & ~IN_SWITCH_STMT)
6978 error ("continue statement not within a loop");
6980 case IN_ITERATION_STMT:
6982 statement = finish_continue_stmt ();
6985 error ("invalid exit from OpenMP structured block");
6990 cp_parser_require (parser, CPP_SEMICOLON, "%<;%>");
6997 /* If the next token is a `;', then there is no
6999 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
7000 expr = cp_parser_expression (parser, /*cast_p=*/false);
7003 /* Build the return-statement. */
7004 statement = finish_return_stmt (expr);
7005 /* Look for the final `;'. */
7006 cp_parser_require (parser, CPP_SEMICOLON, "%<;%>");
7011 /* Create the goto-statement. */
7012 if (cp_lexer_next_token_is (parser->lexer, CPP_MULT))
7014 /* Issue a warning about this use of a GNU extension. */
7016 pedwarn ("ISO C++ forbids computed gotos");
7017 /* Consume the '*' token. */
7018 cp_lexer_consume_token (parser->lexer);
7019 /* Parse the dependent expression. */
7020 finish_goto_stmt (cp_parser_expression (parser, /*cast_p=*/false));
7023 finish_goto_stmt (cp_parser_identifier (parser));
7024 /* Look for the final `;'. */
7025 cp_parser_require (parser, CPP_SEMICOLON, "%<;%>");
7029 cp_parser_error (parser, "expected jump-statement");
7036 /* Parse a declaration-statement.
7038 declaration-statement:
7039 block-declaration */
7042 cp_parser_declaration_statement (cp_parser* parser)
7046 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
7047 p = obstack_alloc (&declarator_obstack, 0);
7049 /* Parse the block-declaration. */
7050 cp_parser_block_declaration (parser, /*statement_p=*/true);
7052 /* Free any declarators allocated. */
7053 obstack_free (&declarator_obstack, p);
7055 /* Finish off the statement. */
7059 /* Some dependent statements (like `if (cond) statement'), are
7060 implicitly in their own scope. In other words, if the statement is
7061 a single statement (as opposed to a compound-statement), it is
7062 none-the-less treated as if it were enclosed in braces. Any
7063 declarations appearing in the dependent statement are out of scope
7064 after control passes that point. This function parses a statement,
7065 but ensures that is in its own scope, even if it is not a
7068 If IF_P is not NULL, *IF_P is set to indicate whether the statement
7069 is a (possibly labeled) if statement which is not enclosed in
7070 braces and has an else clause. This is used to implement
7073 Returns the new statement. */
7076 cp_parser_implicitly_scoped_statement (cp_parser* parser, bool *if_p)
7083 /* Mark if () ; with a special NOP_EXPR. */
7084 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
7086 cp_lexer_consume_token (parser->lexer);
7087 statement = add_stmt (build_empty_stmt ());
7089 /* if a compound is opened, we simply parse the statement directly. */
7090 else if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
7091 statement = cp_parser_compound_statement (parser, NULL, false);
7092 /* If the token is not a `{', then we must take special action. */
7095 /* Create a compound-statement. */
7096 statement = begin_compound_stmt (0);
7097 /* Parse the dependent-statement. */
7098 cp_parser_statement (parser, NULL_TREE, false, if_p);
7099 /* Finish the dummy compound-statement. */
7100 finish_compound_stmt (statement);
7103 /* Return the statement. */
7107 /* For some dependent statements (like `while (cond) statement'), we
7108 have already created a scope. Therefore, even if the dependent
7109 statement is a compound-statement, we do not want to create another
7113 cp_parser_already_scoped_statement (cp_parser* parser)
7115 /* If the token is a `{', then we must take special action. */
7116 if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE))
7117 cp_parser_statement (parser, NULL_TREE, false, NULL);
7120 /* Avoid calling cp_parser_compound_statement, so that we
7121 don't create a new scope. Do everything else by hand. */
7122 cp_parser_require (parser, CPP_OPEN_BRACE, "`{'");
7123 cp_parser_statement_seq_opt (parser, NULL_TREE);
7124 cp_parser_require (parser, CPP_CLOSE_BRACE, "`}'");
7128 /* Declarations [gram.dcl.dcl] */
7130 /* Parse an optional declaration-sequence.
7134 declaration-seq declaration */
7137 cp_parser_declaration_seq_opt (cp_parser* parser)
7143 token = cp_lexer_peek_token (parser->lexer);
7145 if (token->type == CPP_CLOSE_BRACE
7146 || token->type == CPP_EOF
7147 || token->type == CPP_PRAGMA_EOL)
7150 if (token->type == CPP_SEMICOLON)
7152 /* A declaration consisting of a single semicolon is
7153 invalid. Allow it unless we're being pedantic. */
7154 cp_lexer_consume_token (parser->lexer);
7155 if (pedantic && !in_system_header)
7156 pedwarn ("extra %<;%>");
7160 /* If we're entering or exiting a region that's implicitly
7161 extern "C", modify the lang context appropriately. */
7162 if (!parser->implicit_extern_c && token->implicit_extern_c)
7164 push_lang_context (lang_name_c);
7165 parser->implicit_extern_c = true;
7167 else if (parser->implicit_extern_c && !token->implicit_extern_c)
7169 pop_lang_context ();
7170 parser->implicit_extern_c = false;
7173 if (token->type == CPP_PRAGMA)
7175 /* A top-level declaration can consist solely of a #pragma.
7176 A nested declaration cannot, so this is done here and not
7177 in cp_parser_declaration. (A #pragma at block scope is
7178 handled in cp_parser_statement.) */
7179 cp_parser_pragma (parser, pragma_external);
7183 /* Parse the declaration itself. */
7184 cp_parser_declaration (parser);
7188 /* Parse a declaration.
7193 template-declaration
7194 explicit-instantiation
7195 explicit-specialization
7196 linkage-specification
7197 namespace-definition
7202 __extension__ declaration */
7205 cp_parser_declaration (cp_parser* parser)
7212 /* Check for the `__extension__' keyword. */
7213 if (cp_parser_extension_opt (parser, &saved_pedantic))
7215 /* Parse the qualified declaration. */
7216 cp_parser_declaration (parser);
7217 /* Restore the PEDANTIC flag. */
7218 pedantic = saved_pedantic;
7223 /* Try to figure out what kind of declaration is present. */
7224 token1 = *cp_lexer_peek_token (parser->lexer);
7226 if (token1.type != CPP_EOF)
7227 token2 = *cp_lexer_peek_nth_token (parser->lexer, 2);
7230 token2.type = CPP_EOF;
7231 token2.keyword = RID_MAX;
7234 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
7235 p = obstack_alloc (&declarator_obstack, 0);
7237 /* If the next token is `extern' and the following token is a string
7238 literal, then we have a linkage specification. */
7239 if (token1.keyword == RID_EXTERN
7240 && cp_parser_is_string_literal (&token2))
7241 cp_parser_linkage_specification (parser);
7242 /* If the next token is `template', then we have either a template
7243 declaration, an explicit instantiation, or an explicit
7245 else if (token1.keyword == RID_TEMPLATE)
7247 /* `template <>' indicates a template specialization. */
7248 if (token2.type == CPP_LESS
7249 && cp_lexer_peek_nth_token (parser->lexer, 3)->type == CPP_GREATER)
7250 cp_parser_explicit_specialization (parser);
7251 /* `template <' indicates a template declaration. */
7252 else if (token2.type == CPP_LESS)
7253 cp_parser_template_declaration (parser, /*member_p=*/false);
7254 /* Anything else must be an explicit instantiation. */
7256 cp_parser_explicit_instantiation (parser);
7258 /* If the next token is `export', then we have a template
7260 else if (token1.keyword == RID_EXPORT)
7261 cp_parser_template_declaration (parser, /*member_p=*/false);
7262 /* If the next token is `extern', 'static' or 'inline' and the one
7263 after that is `template', we have a GNU extended explicit
7264 instantiation directive. */
7265 else if (cp_parser_allow_gnu_extensions_p (parser)
7266 && (token1.keyword == RID_EXTERN
7267 || token1.keyword == RID_STATIC
7268 || token1.keyword == RID_INLINE)
7269 && token2.keyword == RID_TEMPLATE)
7270 cp_parser_explicit_instantiation (parser);
7271 /* If the next token is `namespace', check for a named or unnamed
7272 namespace definition. */
7273 else if (token1.keyword == RID_NAMESPACE
7274 && (/* A named namespace definition. */
7275 (token2.type == CPP_NAME
7276 && (cp_lexer_peek_nth_token (parser->lexer, 3)->type
7278 /* An unnamed namespace definition. */
7279 || token2.type == CPP_OPEN_BRACE
7280 || token2.keyword == RID_ATTRIBUTE))
7281 cp_parser_namespace_definition (parser);
7282 /* Objective-C++ declaration/definition. */
7283 else if (c_dialect_objc () && OBJC_IS_AT_KEYWORD (token1.keyword))
7284 cp_parser_objc_declaration (parser);
7285 /* We must have either a block declaration or a function
7288 /* Try to parse a block-declaration, or a function-definition. */
7289 cp_parser_block_declaration (parser, /*statement_p=*/false);
7291 /* Free any declarators allocated. */
7292 obstack_free (&declarator_obstack, p);
7295 /* Parse a block-declaration.
7300 namespace-alias-definition
7307 __extension__ block-declaration
7313 static_assert-declaration
7315 If STATEMENT_P is TRUE, then this block-declaration is occurring as
7316 part of a declaration-statement. */
7319 cp_parser_block_declaration (cp_parser *parser,
7325 /* Check for the `__extension__' keyword. */
7326 if (cp_parser_extension_opt (parser, &saved_pedantic))
7328 /* Parse the qualified declaration. */
7329 cp_parser_block_declaration (parser, statement_p);
7330 /* Restore the PEDANTIC flag. */
7331 pedantic = saved_pedantic;
7336 /* Peek at the next token to figure out which kind of declaration is
7338 token1 = cp_lexer_peek_token (parser->lexer);
7340 /* If the next keyword is `asm', we have an asm-definition. */
7341 if (token1->keyword == RID_ASM)
7344 cp_parser_commit_to_tentative_parse (parser);
7345 cp_parser_asm_definition (parser);
7347 /* If the next keyword is `namespace', we have a
7348 namespace-alias-definition. */
7349 else if (token1->keyword == RID_NAMESPACE)
7350 cp_parser_namespace_alias_definition (parser);
7351 /* If the next keyword is `using', we have either a
7352 using-declaration or a using-directive. */
7353 else if (token1->keyword == RID_USING)
7358 cp_parser_commit_to_tentative_parse (parser);
7359 /* If the token after `using' is `namespace', then we have a
7361 token2 = cp_lexer_peek_nth_token (parser->lexer, 2);
7362 if (token2->keyword == RID_NAMESPACE)
7363 cp_parser_using_directive (parser);
7364 /* Otherwise, it's a using-declaration. */
7366 cp_parser_using_declaration (parser,
7367 /*access_declaration_p=*/false);
7369 /* If the next keyword is `__label__' we have a label declaration. */
7370 else if (token1->keyword == RID_LABEL)
7373 cp_parser_commit_to_tentative_parse (parser);
7374 cp_parser_label_declaration (parser);
7376 /* If the next token is `static_assert' we have a static assertion. */
7377 else if (token1->keyword == RID_STATIC_ASSERT)
7378 cp_parser_static_assert (parser, /*member_p=*/false);
7379 /* Anything else must be a simple-declaration. */
7381 cp_parser_simple_declaration (parser, !statement_p);
7384 /* Parse a simple-declaration.
7387 decl-specifier-seq [opt] init-declarator-list [opt] ;
7389 init-declarator-list:
7391 init-declarator-list , init-declarator
7393 If FUNCTION_DEFINITION_ALLOWED_P is TRUE, then we also recognize a
7394 function-definition as a simple-declaration. */
7397 cp_parser_simple_declaration (cp_parser* parser,
7398 bool function_definition_allowed_p)
7400 cp_decl_specifier_seq decl_specifiers;
7401 int declares_class_or_enum;
7402 bool saw_declarator;
7404 /* Defer access checks until we know what is being declared; the
7405 checks for names appearing in the decl-specifier-seq should be
7406 done as if we were in the scope of the thing being declared. */
7407 push_deferring_access_checks (dk_deferred);
7409 /* Parse the decl-specifier-seq. We have to keep track of whether
7410 or not the decl-specifier-seq declares a named class or
7411 enumeration type, since that is the only case in which the
7412 init-declarator-list is allowed to be empty.
7416 In a simple-declaration, the optional init-declarator-list can be
7417 omitted only when declaring a class or enumeration, that is when
7418 the decl-specifier-seq contains either a class-specifier, an
7419 elaborated-type-specifier, or an enum-specifier. */
7420 cp_parser_decl_specifier_seq (parser,
7421 CP_PARSER_FLAGS_OPTIONAL,
7423 &declares_class_or_enum);
7424 /* We no longer need to defer access checks. */
7425 stop_deferring_access_checks ();
7427 /* In a block scope, a valid declaration must always have a
7428 decl-specifier-seq. By not trying to parse declarators, we can
7429 resolve the declaration/expression ambiguity more quickly. */
7430 if (!function_definition_allowed_p
7431 && !decl_specifiers.any_specifiers_p)
7433 cp_parser_error (parser, "expected declaration");
7437 /* If the next two tokens are both identifiers, the code is
7438 erroneous. The usual cause of this situation is code like:
7442 where "T" should name a type -- but does not. */
7443 if (!decl_specifiers.type
7444 && cp_parser_parse_and_diagnose_invalid_type_name (parser))
7446 /* If parsing tentatively, we should commit; we really are
7447 looking at a declaration. */
7448 cp_parser_commit_to_tentative_parse (parser);
7453 /* If we have seen at least one decl-specifier, and the next token
7454 is not a parenthesis, then we must be looking at a declaration.
7455 (After "int (" we might be looking at a functional cast.) */
7456 if (decl_specifiers.any_specifiers_p
7457 && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_PAREN))
7458 cp_parser_commit_to_tentative_parse (parser);
7460 /* Keep going until we hit the `;' at the end of the simple
7462 saw_declarator = false;
7463 while (cp_lexer_next_token_is_not (parser->lexer,
7467 bool function_definition_p;
7472 /* If we are processing next declarator, coma is expected */
7473 token = cp_lexer_peek_token (parser->lexer);
7474 gcc_assert (token->type == CPP_COMMA);
7475 cp_lexer_consume_token (parser->lexer);
7478 saw_declarator = true;
7480 /* Parse the init-declarator. */
7481 decl = cp_parser_init_declarator (parser, &decl_specifiers,
7483 function_definition_allowed_p,
7485 declares_class_or_enum,
7486 &function_definition_p);
7487 /* If an error occurred while parsing tentatively, exit quickly.
7488 (That usually happens when in the body of a function; each
7489 statement is treated as a declaration-statement until proven
7491 if (cp_parser_error_occurred (parser))
7493 /* Handle function definitions specially. */
7494 if (function_definition_p)
7496 /* If the next token is a `,', then we are probably
7497 processing something like:
7501 which is erroneous. */
7502 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
7503 error ("mixing declarations and function-definitions is forbidden");
7504 /* Otherwise, we're done with the list of declarators. */
7507 pop_deferring_access_checks ();
7511 /* The next token should be either a `,' or a `;'. */
7512 token = cp_lexer_peek_token (parser->lexer);
7513 /* If it's a `,', there are more declarators to come. */
7514 if (token->type == CPP_COMMA)
7515 /* will be consumed next time around */;
7516 /* If it's a `;', we are done. */
7517 else if (token->type == CPP_SEMICOLON)
7519 /* Anything else is an error. */
7522 /* If we have already issued an error message we don't need
7523 to issue another one. */
7524 if (decl != error_mark_node
7525 || cp_parser_uncommitted_to_tentative_parse_p (parser))
7526 cp_parser_error (parser, "expected %<,%> or %<;%>");
7527 /* Skip tokens until we reach the end of the statement. */
7528 cp_parser_skip_to_end_of_statement (parser);
7529 /* If the next token is now a `;', consume it. */
7530 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
7531 cp_lexer_consume_token (parser->lexer);
7534 /* After the first time around, a function-definition is not
7535 allowed -- even if it was OK at first. For example:
7540 function_definition_allowed_p = false;
7543 /* Issue an error message if no declarators are present, and the
7544 decl-specifier-seq does not itself declare a class or
7546 if (!saw_declarator)
7548 if (cp_parser_declares_only_class_p (parser))
7549 shadow_tag (&decl_specifiers);
7550 /* Perform any deferred access checks. */
7551 perform_deferred_access_checks ();
7554 /* Consume the `;'. */
7555 cp_parser_require (parser, CPP_SEMICOLON, "`;'");
7558 pop_deferring_access_checks ();
7561 /* Parse a decl-specifier-seq.
7564 decl-specifier-seq [opt] decl-specifier
7567 storage-class-specifier
7578 Set *DECL_SPECS to a representation of the decl-specifier-seq.
7580 The parser flags FLAGS is used to control type-specifier parsing.
7582 *DECLARES_CLASS_OR_ENUM is set to the bitwise or of the following
7585 1: one of the decl-specifiers is an elaborated-type-specifier
7586 (i.e., a type declaration)
7587 2: one of the decl-specifiers is an enum-specifier or a
7588 class-specifier (i.e., a type definition)
7593 cp_parser_decl_specifier_seq (cp_parser* parser,
7594 cp_parser_flags flags,
7595 cp_decl_specifier_seq *decl_specs,
7596 int* declares_class_or_enum)
7598 bool constructor_possible_p = !parser->in_declarator_p;
7600 /* Clear DECL_SPECS. */
7601 clear_decl_specs (decl_specs);
7603 /* Assume no class or enumeration type is declared. */
7604 *declares_class_or_enum = 0;
7606 /* Keep reading specifiers until there are no more to read. */
7610 bool found_decl_spec;
7613 /* Peek at the next token. */
7614 token = cp_lexer_peek_token (parser->lexer);
7615 /* Handle attributes. */
7616 if (token->keyword == RID_ATTRIBUTE)
7618 /* Parse the attributes. */
7619 decl_specs->attributes
7620 = chainon (decl_specs->attributes,
7621 cp_parser_attributes_opt (parser));
7624 /* Assume we will find a decl-specifier keyword. */
7625 found_decl_spec = true;
7626 /* If the next token is an appropriate keyword, we can simply
7627 add it to the list. */
7628 switch (token->keyword)
7633 if (!at_class_scope_p ())
7635 error ("%<friend%> used outside of class");
7636 cp_lexer_purge_token (parser->lexer);
7640 ++decl_specs->specs[(int) ds_friend];
7641 /* Consume the token. */
7642 cp_lexer_consume_token (parser->lexer);
7646 /* function-specifier:
7653 cp_parser_function_specifier_opt (parser, decl_specs);
7659 ++decl_specs->specs[(int) ds_typedef];
7660 /* Consume the token. */
7661 cp_lexer_consume_token (parser->lexer);
7662 /* A constructor declarator cannot appear in a typedef. */
7663 constructor_possible_p = false;
7664 /* The "typedef" keyword can only occur in a declaration; we
7665 may as well commit at this point. */
7666 cp_parser_commit_to_tentative_parse (parser);
7668 if (decl_specs->storage_class != sc_none)
7669 decl_specs->conflicting_specifiers_p = true;
7672 /* storage-class-specifier:
7686 /* Consume the token. */
7687 cp_lexer_consume_token (parser->lexer);
7688 cp_parser_set_storage_class (parser, decl_specs, token->keyword);
7691 /* Consume the token. */
7692 cp_lexer_consume_token (parser->lexer);
7693 ++decl_specs->specs[(int) ds_thread];
7697 /* We did not yet find a decl-specifier yet. */
7698 found_decl_spec = false;
7702 /* Constructors are a special case. The `S' in `S()' is not a
7703 decl-specifier; it is the beginning of the declarator. */
7706 && constructor_possible_p
7707 && (cp_parser_constructor_declarator_p
7708 (parser, decl_specs->specs[(int) ds_friend] != 0)));
7710 /* If we don't have a DECL_SPEC yet, then we must be looking at
7711 a type-specifier. */
7712 if (!found_decl_spec && !constructor_p)
7714 int decl_spec_declares_class_or_enum;
7715 bool is_cv_qualifier;
7719 = cp_parser_type_specifier (parser, flags,
7721 /*is_declaration=*/true,
7722 &decl_spec_declares_class_or_enum,
7725 *declares_class_or_enum |= decl_spec_declares_class_or_enum;
7727 /* If this type-specifier referenced a user-defined type
7728 (a typedef, class-name, etc.), then we can't allow any
7729 more such type-specifiers henceforth.
7733 The longest sequence of decl-specifiers that could
7734 possibly be a type name is taken as the
7735 decl-specifier-seq of a declaration. The sequence shall
7736 be self-consistent as described below.
7740 As a general rule, at most one type-specifier is allowed
7741 in the complete decl-specifier-seq of a declaration. The
7742 only exceptions are the following:
7744 -- const or volatile can be combined with any other
7747 -- signed or unsigned can be combined with char, long,
7755 void g (const int Pc);
7757 Here, Pc is *not* part of the decl-specifier seq; it's
7758 the declarator. Therefore, once we see a type-specifier
7759 (other than a cv-qualifier), we forbid any additional
7760 user-defined types. We *do* still allow things like `int
7761 int' to be considered a decl-specifier-seq, and issue the
7762 error message later. */
7763 if (type_spec && !is_cv_qualifier)
7764 flags |= CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES;
7765 /* A constructor declarator cannot follow a type-specifier. */
7768 constructor_possible_p = false;
7769 found_decl_spec = true;
7773 /* If we still do not have a DECL_SPEC, then there are no more
7775 if (!found_decl_spec)
7778 decl_specs->any_specifiers_p = true;
7779 /* After we see one decl-specifier, further decl-specifiers are
7781 flags |= CP_PARSER_FLAGS_OPTIONAL;
7784 cp_parser_check_decl_spec (decl_specs);
7786 /* Don't allow a friend specifier with a class definition. */
7787 if (decl_specs->specs[(int) ds_friend] != 0
7788 && (*declares_class_or_enum & 2))
7789 error ("class definition may not be declared a friend");
7792 /* Parse an (optional) storage-class-specifier.
7794 storage-class-specifier:
7803 storage-class-specifier:
7806 Returns an IDENTIFIER_NODE corresponding to the keyword used. */
7809 cp_parser_storage_class_specifier_opt (cp_parser* parser)
7811 switch (cp_lexer_peek_token (parser->lexer)->keyword)
7819 /* Consume the token. */
7820 return cp_lexer_consume_token (parser->lexer)->u.value;
7827 /* Parse an (optional) function-specifier.
7834 Returns an IDENTIFIER_NODE corresponding to the keyword used.
7835 Updates DECL_SPECS, if it is non-NULL. */
7838 cp_parser_function_specifier_opt (cp_parser* parser,
7839 cp_decl_specifier_seq *decl_specs)
7841 switch (cp_lexer_peek_token (parser->lexer)->keyword)
7845 ++decl_specs->specs[(int) ds_inline];
7849 /* 14.5.2.3 [temp.mem]
7851 A member function template shall not be virtual. */
7852 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
7853 error ("templates may not be %<virtual%>");
7854 else if (decl_specs)
7855 ++decl_specs->specs[(int) ds_virtual];
7860 ++decl_specs->specs[(int) ds_explicit];
7867 /* Consume the token. */
7868 return cp_lexer_consume_token (parser->lexer)->u.value;
7871 /* Parse a linkage-specification.
7873 linkage-specification:
7874 extern string-literal { declaration-seq [opt] }
7875 extern string-literal declaration */
7878 cp_parser_linkage_specification (cp_parser* parser)
7882 /* Look for the `extern' keyword. */
7883 cp_parser_require_keyword (parser, RID_EXTERN, "`extern'");
7885 /* Look for the string-literal. */
7886 linkage = cp_parser_string_literal (parser, false, false);
7888 /* Transform the literal into an identifier. If the literal is a
7889 wide-character string, or contains embedded NULs, then we can't
7890 handle it as the user wants. */
7891 if (strlen (TREE_STRING_POINTER (linkage))
7892 != (size_t) (TREE_STRING_LENGTH (linkage) - 1))
7894 cp_parser_error (parser, "invalid linkage-specification");
7895 /* Assume C++ linkage. */
7896 linkage = lang_name_cplusplus;
7899 linkage = get_identifier (TREE_STRING_POINTER (linkage));
7901 /* We're now using the new linkage. */
7902 push_lang_context (linkage);
7904 /* If the next token is a `{', then we're using the first
7906 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
7908 /* Consume the `{' token. */
7909 cp_lexer_consume_token (parser->lexer);
7910 /* Parse the declarations. */
7911 cp_parser_declaration_seq_opt (parser);
7912 /* Look for the closing `}'. */
7913 cp_parser_require (parser, CPP_CLOSE_BRACE, "`}'");
7915 /* Otherwise, there's just one declaration. */
7918 bool saved_in_unbraced_linkage_specification_p;
7920 saved_in_unbraced_linkage_specification_p
7921 = parser->in_unbraced_linkage_specification_p;
7922 parser->in_unbraced_linkage_specification_p = true;
7923 cp_parser_declaration (parser);
7924 parser->in_unbraced_linkage_specification_p
7925 = saved_in_unbraced_linkage_specification_p;
7928 /* We're done with the linkage-specification. */
7929 pop_lang_context ();
7932 /* Parse a static_assert-declaration.
7934 static_assert-declaration:
7935 static_assert ( constant-expression , string-literal ) ;
7937 If MEMBER_P, this static_assert is a class member. */
7940 cp_parser_static_assert(cp_parser *parser, bool member_p)
7945 location_t saved_loc;
7947 /* Peek at the `static_assert' token so we can keep track of exactly
7948 where the static assertion started. */
7949 token = cp_lexer_peek_token (parser->lexer);
7950 saved_loc = token->location;
7952 /* Look for the `static_assert' keyword. */
7953 if (!cp_parser_require_keyword (parser, RID_STATIC_ASSERT,
7957 /* We know we are in a static assertion; commit to any tentative
7959 if (cp_parser_parsing_tentatively (parser))
7960 cp_parser_commit_to_tentative_parse (parser);
7962 /* Parse the `(' starting the static assertion condition. */
7963 cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
7965 /* Parse the constant-expression. */
7967 cp_parser_constant_expression (parser,
7968 /*allow_non_constant_p=*/false,
7969 /*non_constant_p=*/NULL);
7971 /* Parse the separating `,'. */
7972 cp_parser_require (parser, CPP_COMMA, "`,'");
7974 /* Parse the string-literal message. */
7975 message = cp_parser_string_literal (parser,
7976 /*translate=*/false,
7979 /* A `)' completes the static assertion. */
7980 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"))
7981 cp_parser_skip_to_closing_parenthesis (parser,
7982 /*recovering=*/true,
7984 /*consume_paren=*/true);
7986 /* A semicolon terminates the declaration. */
7987 cp_parser_require (parser, CPP_SEMICOLON, "`;'");
7989 /* Complete the static assertion, which may mean either processing
7990 the static assert now or saving it for template instantiation. */
7991 finish_static_assert (condition, message, saved_loc, member_p);
7994 /* Special member functions [gram.special] */
7996 /* Parse a conversion-function-id.
7998 conversion-function-id:
7999 operator conversion-type-id
8001 Returns an IDENTIFIER_NODE representing the operator. */
8004 cp_parser_conversion_function_id (cp_parser* parser)
8008 tree saved_qualifying_scope;
8009 tree saved_object_scope;
8010 tree pushed_scope = NULL_TREE;
8012 /* Look for the `operator' token. */
8013 if (!cp_parser_require_keyword (parser, RID_OPERATOR, "`operator'"))
8014 return error_mark_node;
8015 /* When we parse the conversion-type-id, the current scope will be
8016 reset. However, we need that information in able to look up the
8017 conversion function later, so we save it here. */
8018 saved_scope = parser->scope;
8019 saved_qualifying_scope = parser->qualifying_scope;
8020 saved_object_scope = parser->object_scope;
8021 /* We must enter the scope of the class so that the names of
8022 entities declared within the class are available in the
8023 conversion-type-id. For example, consider:
8030 S::operator I() { ... }
8032 In order to see that `I' is a type-name in the definition, we
8033 must be in the scope of `S'. */
8035 pushed_scope = push_scope (saved_scope);
8036 /* Parse the conversion-type-id. */
8037 type = cp_parser_conversion_type_id (parser);
8038 /* Leave the scope of the class, if any. */
8040 pop_scope (pushed_scope);
8041 /* Restore the saved scope. */
8042 parser->scope = saved_scope;
8043 parser->qualifying_scope = saved_qualifying_scope;
8044 parser->object_scope = saved_object_scope;
8045 /* If the TYPE is invalid, indicate failure. */
8046 if (type == error_mark_node)
8047 return error_mark_node;
8048 return mangle_conv_op_name_for_type (type);
8051 /* Parse a conversion-type-id:
8054 type-specifier-seq conversion-declarator [opt]
8056 Returns the TYPE specified. */
8059 cp_parser_conversion_type_id (cp_parser* parser)
8062 cp_decl_specifier_seq type_specifiers;
8063 cp_declarator *declarator;
8064 tree type_specified;
8066 /* Parse the attributes. */
8067 attributes = cp_parser_attributes_opt (parser);
8068 /* Parse the type-specifiers. */
8069 cp_parser_type_specifier_seq (parser, /*is_condition=*/false,
8071 /* If that didn't work, stop. */
8072 if (type_specifiers.type == error_mark_node)
8073 return error_mark_node;
8074 /* Parse the conversion-declarator. */
8075 declarator = cp_parser_conversion_declarator_opt (parser);
8077 type_specified = grokdeclarator (declarator, &type_specifiers, TYPENAME,
8078 /*initialized=*/0, &attributes);
8080 cplus_decl_attributes (&type_specified, attributes, /*flags=*/0);
8081 return type_specified;
8084 /* Parse an (optional) conversion-declarator.
8086 conversion-declarator:
8087 ptr-operator conversion-declarator [opt]
8091 static cp_declarator *
8092 cp_parser_conversion_declarator_opt (cp_parser* parser)
8094 enum tree_code code;
8096 cp_cv_quals cv_quals;
8098 /* We don't know if there's a ptr-operator next, or not. */
8099 cp_parser_parse_tentatively (parser);
8100 /* Try the ptr-operator. */
8101 code = cp_parser_ptr_operator (parser, &class_type, &cv_quals);
8102 /* If it worked, look for more conversion-declarators. */
8103 if (cp_parser_parse_definitely (parser))
8105 cp_declarator *declarator;
8107 /* Parse another optional declarator. */
8108 declarator = cp_parser_conversion_declarator_opt (parser);
8110 /* Create the representation of the declarator. */
8112 declarator = make_ptrmem_declarator (cv_quals, class_type,
8114 else if (code == INDIRECT_REF)
8115 declarator = make_pointer_declarator (cv_quals, declarator);
8117 declarator = make_reference_declarator (cv_quals, declarator);
8125 /* Parse an (optional) ctor-initializer.
8128 : mem-initializer-list
8130 Returns TRUE iff the ctor-initializer was actually present. */
8133 cp_parser_ctor_initializer_opt (cp_parser* parser)
8135 /* If the next token is not a `:', then there is no
8136 ctor-initializer. */
8137 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COLON))
8139 /* Do default initialization of any bases and members. */
8140 if (DECL_CONSTRUCTOR_P (current_function_decl))
8141 finish_mem_initializers (NULL_TREE);
8146 /* Consume the `:' token. */
8147 cp_lexer_consume_token (parser->lexer);
8148 /* And the mem-initializer-list. */
8149 cp_parser_mem_initializer_list (parser);
8154 /* Parse a mem-initializer-list.
8156 mem-initializer-list:
8158 mem-initializer , mem-initializer-list */
8161 cp_parser_mem_initializer_list (cp_parser* parser)
8163 tree mem_initializer_list = NULL_TREE;
8165 /* Let the semantic analysis code know that we are starting the
8166 mem-initializer-list. */
8167 if (!DECL_CONSTRUCTOR_P (current_function_decl))
8168 error ("only constructors take base initializers");
8170 /* Loop through the list. */
8173 tree mem_initializer;
8175 /* Parse the mem-initializer. */
8176 mem_initializer = cp_parser_mem_initializer (parser);
8177 /* Add it to the list, unless it was erroneous. */
8178 if (mem_initializer != error_mark_node)
8180 TREE_CHAIN (mem_initializer) = mem_initializer_list;
8181 mem_initializer_list = mem_initializer;
8183 /* If the next token is not a `,', we're done. */
8184 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
8186 /* Consume the `,' token. */
8187 cp_lexer_consume_token (parser->lexer);
8190 /* Perform semantic analysis. */
8191 if (DECL_CONSTRUCTOR_P (current_function_decl))
8192 finish_mem_initializers (mem_initializer_list);
8195 /* Parse a mem-initializer.
8198 mem-initializer-id ( expression-list [opt] )
8203 ( expression-list [opt] )
8205 Returns a TREE_LIST. The TREE_PURPOSE is the TYPE (for a base
8206 class) or FIELD_DECL (for a non-static data member) to initialize;
8207 the TREE_VALUE is the expression-list. An empty initialization
8208 list is represented by void_list_node. */
8211 cp_parser_mem_initializer (cp_parser* parser)
8213 tree mem_initializer_id;
8214 tree expression_list;
8217 /* Find out what is being initialized. */
8218 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
8220 pedwarn ("anachronistic old-style base class initializer");
8221 mem_initializer_id = NULL_TREE;
8224 mem_initializer_id = cp_parser_mem_initializer_id (parser);
8225 member = expand_member_init (mem_initializer_id);
8226 if (member && !DECL_P (member))
8227 in_base_initializer = 1;
8230 = cp_parser_parenthesized_expression_list (parser, false,
8232 /*non_constant_p=*/NULL);
8233 if (expression_list == error_mark_node)
8234 return error_mark_node;
8235 if (!expression_list)
8236 expression_list = void_type_node;
8238 in_base_initializer = 0;
8240 return member ? build_tree_list (member, expression_list) : error_mark_node;
8243 /* Parse a mem-initializer-id.
8246 :: [opt] nested-name-specifier [opt] class-name
8249 Returns a TYPE indicating the class to be initializer for the first
8250 production. Returns an IDENTIFIER_NODE indicating the data member
8251 to be initialized for the second production. */
8254 cp_parser_mem_initializer_id (cp_parser* parser)
8256 bool global_scope_p;
8257 bool nested_name_specifier_p;
8258 bool template_p = false;
8261 /* `typename' is not allowed in this context ([temp.res]). */
8262 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TYPENAME))
8264 error ("keyword %<typename%> not allowed in this context (a qualified "
8265 "member initializer is implicitly a type)");
8266 cp_lexer_consume_token (parser->lexer);
8268 /* Look for the optional `::' operator. */
8270 = (cp_parser_global_scope_opt (parser,
8271 /*current_scope_valid_p=*/false)
8273 /* Look for the optional nested-name-specifier. The simplest way to
8278 The keyword `typename' is not permitted in a base-specifier or
8279 mem-initializer; in these contexts a qualified name that
8280 depends on a template-parameter is implicitly assumed to be a
8283 is to assume that we have seen the `typename' keyword at this
8285 nested_name_specifier_p
8286 = (cp_parser_nested_name_specifier_opt (parser,
8287 /*typename_keyword_p=*/true,
8288 /*check_dependency_p=*/true,
8290 /*is_declaration=*/true)
8292 if (nested_name_specifier_p)
8293 template_p = cp_parser_optional_template_keyword (parser);
8294 /* If there is a `::' operator or a nested-name-specifier, then we
8295 are definitely looking for a class-name. */
8296 if (global_scope_p || nested_name_specifier_p)
8297 return cp_parser_class_name (parser,
8298 /*typename_keyword_p=*/true,
8299 /*template_keyword_p=*/template_p,
8301 /*check_dependency_p=*/true,
8302 /*class_head_p=*/false,
8303 /*is_declaration=*/true);
8304 /* Otherwise, we could also be looking for an ordinary identifier. */
8305 cp_parser_parse_tentatively (parser);
8306 /* Try a class-name. */
8307 id = cp_parser_class_name (parser,
8308 /*typename_keyword_p=*/true,
8309 /*template_keyword_p=*/false,
8311 /*check_dependency_p=*/true,
8312 /*class_head_p=*/false,
8313 /*is_declaration=*/true);
8314 /* If we found one, we're done. */
8315 if (cp_parser_parse_definitely (parser))
8317 /* Otherwise, look for an ordinary identifier. */
8318 return cp_parser_identifier (parser);
8321 /* Overloading [gram.over] */
8323 /* Parse an operator-function-id.
8325 operator-function-id:
8328 Returns an IDENTIFIER_NODE for the operator which is a
8329 human-readable spelling of the identifier, e.g., `operator +'. */
8332 cp_parser_operator_function_id (cp_parser* parser)
8334 /* Look for the `operator' keyword. */
8335 if (!cp_parser_require_keyword (parser, RID_OPERATOR, "`operator'"))
8336 return error_mark_node;
8337 /* And then the name of the operator itself. */
8338 return cp_parser_operator (parser);
8341 /* Parse an operator.
8344 new delete new[] delete[] + - * / % ^ & | ~ ! = < >
8345 += -= *= /= %= ^= &= |= << >> >>= <<= == != <= >= &&
8346 || ++ -- , ->* -> () []
8353 Returns an IDENTIFIER_NODE for the operator which is a
8354 human-readable spelling of the identifier, e.g., `operator +'. */
8357 cp_parser_operator (cp_parser* parser)
8359 tree id = NULL_TREE;
8362 /* Peek at the next token. */
8363 token = cp_lexer_peek_token (parser->lexer);
8364 /* Figure out which operator we have. */
8365 switch (token->type)
8371 /* The keyword should be either `new' or `delete'. */
8372 if (token->keyword == RID_NEW)
8374 else if (token->keyword == RID_DELETE)
8379 /* Consume the `new' or `delete' token. */
8380 cp_lexer_consume_token (parser->lexer);
8382 /* Peek at the next token. */
8383 token = cp_lexer_peek_token (parser->lexer);
8384 /* If it's a `[' token then this is the array variant of the
8386 if (token->type == CPP_OPEN_SQUARE)
8388 /* Consume the `[' token. */
8389 cp_lexer_consume_token (parser->lexer);
8390 /* Look for the `]' token. */
8391 cp_parser_require (parser, CPP_CLOSE_SQUARE, "`]'");
8392 id = ansi_opname (op == NEW_EXPR
8393 ? VEC_NEW_EXPR : VEC_DELETE_EXPR);
8395 /* Otherwise, we have the non-array variant. */
8397 id = ansi_opname (op);
8403 id = ansi_opname (PLUS_EXPR);
8407 id = ansi_opname (MINUS_EXPR);
8411 id = ansi_opname (MULT_EXPR);
8415 id = ansi_opname (TRUNC_DIV_EXPR);
8419 id = ansi_opname (TRUNC_MOD_EXPR);
8423 id = ansi_opname (BIT_XOR_EXPR);
8427 id = ansi_opname (BIT_AND_EXPR);
8431 id = ansi_opname (BIT_IOR_EXPR);
8435 id = ansi_opname (BIT_NOT_EXPR);
8439 id = ansi_opname (TRUTH_NOT_EXPR);
8443 id = ansi_assopname (NOP_EXPR);
8447 id = ansi_opname (LT_EXPR);
8451 id = ansi_opname (GT_EXPR);
8455 id = ansi_assopname (PLUS_EXPR);
8459 id = ansi_assopname (MINUS_EXPR);
8463 id = ansi_assopname (MULT_EXPR);
8467 id = ansi_assopname (TRUNC_DIV_EXPR);
8471 id = ansi_assopname (TRUNC_MOD_EXPR);
8475 id = ansi_assopname (BIT_XOR_EXPR);
8479 id = ansi_assopname (BIT_AND_EXPR);
8483 id = ansi_assopname (BIT_IOR_EXPR);
8487 id = ansi_opname (LSHIFT_EXPR);
8491 id = ansi_opname (RSHIFT_EXPR);
8495 id = ansi_assopname (LSHIFT_EXPR);
8499 id = ansi_assopname (RSHIFT_EXPR);
8503 id = ansi_opname (EQ_EXPR);
8507 id = ansi_opname (NE_EXPR);
8511 id = ansi_opname (LE_EXPR);
8514 case CPP_GREATER_EQ:
8515 id = ansi_opname (GE_EXPR);
8519 id = ansi_opname (TRUTH_ANDIF_EXPR);
8523 id = ansi_opname (TRUTH_ORIF_EXPR);
8527 id = ansi_opname (POSTINCREMENT_EXPR);
8530 case CPP_MINUS_MINUS:
8531 id = ansi_opname (PREDECREMENT_EXPR);
8535 id = ansi_opname (COMPOUND_EXPR);
8538 case CPP_DEREF_STAR:
8539 id = ansi_opname (MEMBER_REF);
8543 id = ansi_opname (COMPONENT_REF);
8546 case CPP_OPEN_PAREN:
8547 /* Consume the `('. */
8548 cp_lexer_consume_token (parser->lexer);
8549 /* Look for the matching `)'. */
8550 cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
8551 return ansi_opname (CALL_EXPR);
8553 case CPP_OPEN_SQUARE:
8554 /* Consume the `['. */
8555 cp_lexer_consume_token (parser->lexer);
8556 /* Look for the matching `]'. */
8557 cp_parser_require (parser, CPP_CLOSE_SQUARE, "`]'");
8558 return ansi_opname (ARRAY_REF);
8561 /* Anything else is an error. */
8565 /* If we have selected an identifier, we need to consume the
8568 cp_lexer_consume_token (parser->lexer);
8569 /* Otherwise, no valid operator name was present. */
8572 cp_parser_error (parser, "expected operator");
8573 id = error_mark_node;
8579 /* Parse a template-declaration.
8581 template-declaration:
8582 export [opt] template < template-parameter-list > declaration
8584 If MEMBER_P is TRUE, this template-declaration occurs within a
8587 The grammar rule given by the standard isn't correct. What
8590 template-declaration:
8591 export [opt] template-parameter-list-seq
8592 decl-specifier-seq [opt] init-declarator [opt] ;
8593 export [opt] template-parameter-list-seq
8596 template-parameter-list-seq:
8597 template-parameter-list-seq [opt]
8598 template < template-parameter-list > */
8601 cp_parser_template_declaration (cp_parser* parser, bool member_p)
8603 /* Check for `export'. */
8604 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_EXPORT))
8606 /* Consume the `export' token. */
8607 cp_lexer_consume_token (parser->lexer);
8608 /* Warn that we do not support `export'. */
8609 warning (0, "keyword %<export%> not implemented, and will be ignored");
8612 cp_parser_template_declaration_after_export (parser, member_p);
8615 /* Parse a template-parameter-list.
8617 template-parameter-list:
8619 template-parameter-list , template-parameter
8621 Returns a TREE_LIST. Each node represents a template parameter.
8622 The nodes are connected via their TREE_CHAINs. */
8625 cp_parser_template_parameter_list (cp_parser* parser)
8627 tree parameter_list = NULL_TREE;
8629 begin_template_parm_list ();
8636 /* Parse the template-parameter. */
8637 parameter = cp_parser_template_parameter (parser, &is_non_type);
8638 /* Add it to the list. */
8639 if (parameter != error_mark_node)
8640 parameter_list = process_template_parm (parameter_list,
8645 tree err_parm = build_tree_list (parameter, parameter);
8646 TREE_VALUE (err_parm) = error_mark_node;
8647 parameter_list = chainon (parameter_list, err_parm);
8650 /* Peek at the next token. */
8651 token = cp_lexer_peek_token (parser->lexer);
8652 /* If it's not a `,', we're done. */
8653 if (token->type != CPP_COMMA)
8655 /* Otherwise, consume the `,' token. */
8656 cp_lexer_consume_token (parser->lexer);
8659 return end_template_parm_list (parameter_list);
8662 /* Parse a template-parameter.
8666 parameter-declaration
8668 If all goes well, returns a TREE_LIST. The TREE_VALUE represents
8669 the parameter. The TREE_PURPOSE is the default value, if any.
8670 Returns ERROR_MARK_NODE on failure. *IS_NON_TYPE is set to true
8671 iff this parameter is a non-type parameter. */
8674 cp_parser_template_parameter (cp_parser* parser, bool *is_non_type)
8677 cp_parameter_declarator *parameter_declarator;
8680 /* Assume it is a type parameter or a template parameter. */
8681 *is_non_type = false;
8682 /* Peek at the next token. */
8683 token = cp_lexer_peek_token (parser->lexer);
8684 /* If it is `class' or `template', we have a type-parameter. */
8685 if (token->keyword == RID_TEMPLATE)
8686 return cp_parser_type_parameter (parser);
8687 /* If it is `class' or `typename' we do not know yet whether it is a
8688 type parameter or a non-type parameter. Consider:
8690 template <typename T, typename T::X X> ...
8694 template <class C, class D*> ...
8696 Here, the first parameter is a type parameter, and the second is
8697 a non-type parameter. We can tell by looking at the token after
8698 the identifier -- if it is a `,', `=', or `>' then we have a type
8700 if (token->keyword == RID_TYPENAME || token->keyword == RID_CLASS)
8702 /* Peek at the token after `class' or `typename'. */
8703 token = cp_lexer_peek_nth_token (parser->lexer, 2);
8704 /* If it's an identifier, skip it. */
8705 if (token->type == CPP_NAME)
8706 token = cp_lexer_peek_nth_token (parser->lexer, 3);
8707 /* Now, see if the token looks like the end of a template
8709 if (token->type == CPP_COMMA
8710 || token->type == CPP_EQ
8711 || token->type == CPP_GREATER)
8712 return cp_parser_type_parameter (parser);
8715 /* Otherwise, it is a non-type parameter.
8719 When parsing a default template-argument for a non-type
8720 template-parameter, the first non-nested `>' is taken as the end
8721 of the template parameter-list rather than a greater-than
8723 *is_non_type = true;
8724 parameter_declarator
8725 = cp_parser_parameter_declaration (parser, /*template_parm_p=*/true,
8726 /*parenthesized_p=*/NULL);
8727 parm = grokdeclarator (parameter_declarator->declarator,
8728 ¶meter_declarator->decl_specifiers,
8729 PARM, /*initialized=*/0,
8731 if (parm == error_mark_node)
8732 return error_mark_node;
8733 return build_tree_list (parameter_declarator->default_argument, parm);
8736 /* Parse a type-parameter.
8739 class identifier [opt]
8740 class identifier [opt] = type-id
8741 typename identifier [opt]
8742 typename identifier [opt] = type-id
8743 template < template-parameter-list > class identifier [opt]
8744 template < template-parameter-list > class identifier [opt]
8747 Returns a TREE_LIST. The TREE_VALUE is itself a TREE_LIST. The
8748 TREE_PURPOSE is the default-argument, if any. The TREE_VALUE is
8749 the declaration of the parameter. */
8752 cp_parser_type_parameter (cp_parser* parser)
8757 /* Look for a keyword to tell us what kind of parameter this is. */
8758 token = cp_parser_require (parser, CPP_KEYWORD,
8759 "`class', `typename', or `template'");
8761 return error_mark_node;
8763 switch (token->keyword)
8769 tree default_argument;
8771 /* If the next token is an identifier, then it names the
8773 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
8774 identifier = cp_parser_identifier (parser);
8776 identifier = NULL_TREE;
8778 /* Create the parameter. */
8779 parameter = finish_template_type_parm (class_type_node, identifier);
8781 /* If the next token is an `=', we have a default argument. */
8782 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
8784 /* Consume the `=' token. */
8785 cp_lexer_consume_token (parser->lexer);
8786 /* Parse the default-argument. */
8787 push_deferring_access_checks (dk_no_deferred);
8788 default_argument = cp_parser_type_id (parser);
8789 pop_deferring_access_checks ();
8792 default_argument = NULL_TREE;
8794 /* Create the combined representation of the parameter and the
8795 default argument. */
8796 parameter = build_tree_list (default_argument, parameter);
8802 tree parameter_list;
8804 tree default_argument;
8806 /* Look for the `<'. */
8807 cp_parser_require (parser, CPP_LESS, "`<'");
8808 /* Parse the template-parameter-list. */
8809 parameter_list = cp_parser_template_parameter_list (parser);
8810 /* Look for the `>'. */
8811 cp_parser_require (parser, CPP_GREATER, "`>'");
8812 /* Look for the `class' keyword. */
8813 cp_parser_require_keyword (parser, RID_CLASS, "`class'");
8814 /* If the next token is an `=', then there is a
8815 default-argument. If the next token is a `>', we are at
8816 the end of the parameter-list. If the next token is a `,',
8817 then we are at the end of this parameter. */
8818 if (cp_lexer_next_token_is_not (parser->lexer, CPP_EQ)
8819 && cp_lexer_next_token_is_not (parser->lexer, CPP_GREATER)
8820 && cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
8822 identifier = cp_parser_identifier (parser);
8823 /* Treat invalid names as if the parameter were nameless. */
8824 if (identifier == error_mark_node)
8825 identifier = NULL_TREE;
8828 identifier = NULL_TREE;
8830 /* Create the template parameter. */
8831 parameter = finish_template_template_parm (class_type_node,
8834 /* If the next token is an `=', then there is a
8835 default-argument. */
8836 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
8840 /* Consume the `='. */
8841 cp_lexer_consume_token (parser->lexer);
8842 /* Parse the id-expression. */
8843 push_deferring_access_checks (dk_no_deferred);
8845 = cp_parser_id_expression (parser,
8846 /*template_keyword_p=*/false,
8847 /*check_dependency_p=*/true,
8848 /*template_p=*/&is_template,
8849 /*declarator_p=*/false,
8850 /*optional_p=*/false);
8851 if (TREE_CODE (default_argument) == TYPE_DECL)
8852 /* If the id-expression was a template-id that refers to
8853 a template-class, we already have the declaration here,
8854 so no further lookup is needed. */
8857 /* Look up the name. */
8859 = cp_parser_lookup_name (parser, default_argument,
8861 /*is_template=*/is_template,
8862 /*is_namespace=*/false,
8863 /*check_dependency=*/true,
8864 /*ambiguous_decls=*/NULL);
8865 /* See if the default argument is valid. */
8867 = check_template_template_default_arg (default_argument);
8868 pop_deferring_access_checks ();
8871 default_argument = NULL_TREE;
8873 /* Create the combined representation of the parameter and the
8874 default argument. */
8875 parameter = build_tree_list (default_argument, parameter);
8887 /* Parse a template-id.
8890 template-name < template-argument-list [opt] >
8892 If TEMPLATE_KEYWORD_P is TRUE, then we have just seen the
8893 `template' keyword. In this case, a TEMPLATE_ID_EXPR will be
8894 returned. Otherwise, if the template-name names a function, or set
8895 of functions, returns a TEMPLATE_ID_EXPR. If the template-name
8896 names a class, returns a TYPE_DECL for the specialization.
8898 If CHECK_DEPENDENCY_P is FALSE, names are looked up in
8899 uninstantiated templates. */
8902 cp_parser_template_id (cp_parser *parser,
8903 bool template_keyword_p,
8904 bool check_dependency_p,
8905 bool is_declaration)
8911 cp_token_position start_of_id = 0;
8912 deferred_access_check *chk;
8913 VEC (deferred_access_check,gc) *access_check;
8914 cp_token *next_token, *next_token_2;
8917 /* If the next token corresponds to a template-id, there is no need
8919 next_token = cp_lexer_peek_token (parser->lexer);
8920 if (next_token->type == CPP_TEMPLATE_ID)
8922 struct tree_check *check_value;
8924 /* Get the stored value. */
8925 check_value = cp_lexer_consume_token (parser->lexer)->u.tree_check_value;
8926 /* Perform any access checks that were deferred. */
8927 access_check = check_value->checks;
8931 VEC_iterate (deferred_access_check, access_check, i, chk) ;
8934 perform_or_defer_access_check (chk->binfo,
8939 /* Return the stored value. */
8940 return check_value->value;
8943 /* Avoid performing name lookup if there is no possibility of
8944 finding a template-id. */
8945 if ((next_token->type != CPP_NAME && next_token->keyword != RID_OPERATOR)
8946 || (next_token->type == CPP_NAME
8947 && !cp_parser_nth_token_starts_template_argument_list_p
8950 cp_parser_error (parser, "expected template-id");
8951 return error_mark_node;
8954 /* Remember where the template-id starts. */
8955 if (cp_parser_uncommitted_to_tentative_parse_p (parser))
8956 start_of_id = cp_lexer_token_position (parser->lexer, false);
8958 push_deferring_access_checks (dk_deferred);
8960 /* Parse the template-name. */
8961 is_identifier = false;
8962 template = cp_parser_template_name (parser, template_keyword_p,
8966 if (template == error_mark_node || is_identifier)
8968 pop_deferring_access_checks ();
8972 /* If we find the sequence `[:' after a template-name, it's probably
8973 a digraph-typo for `< ::'. Substitute the tokens and check if we can
8974 parse correctly the argument list. */
8975 next_token = cp_lexer_peek_token (parser->lexer);
8976 next_token_2 = cp_lexer_peek_nth_token (parser->lexer, 2);
8977 if (next_token->type == CPP_OPEN_SQUARE
8978 && next_token->flags & DIGRAPH
8979 && next_token_2->type == CPP_COLON
8980 && !(next_token_2->flags & PREV_WHITE))
8982 cp_parser_parse_tentatively (parser);
8983 /* Change `:' into `::'. */
8984 next_token_2->type = CPP_SCOPE;
8985 /* Consume the first token (CPP_OPEN_SQUARE - which we pretend it is
8987 cp_lexer_consume_token (parser->lexer);
8988 /* Parse the arguments. */
8989 arguments = cp_parser_enclosed_template_argument_list (parser);
8990 if (!cp_parser_parse_definitely (parser))
8992 /* If we couldn't parse an argument list, then we revert our changes
8993 and return simply an error. Maybe this is not a template-id
8995 next_token_2->type = CPP_COLON;
8996 cp_parser_error (parser, "expected %<<%>");
8997 pop_deferring_access_checks ();
8998 return error_mark_node;
9000 /* Otherwise, emit an error about the invalid digraph, but continue
9001 parsing because we got our argument list. */
9002 pedwarn ("%<<::%> cannot begin a template-argument list");
9003 inform ("%<<:%> is an alternate spelling for %<[%>. Insert whitespace "
9004 "between %<<%> and %<::%>");
9005 if (!flag_permissive)
9010 inform ("(if you use -fpermissive G++ will accept your code)");
9017 /* Look for the `<' that starts the template-argument-list. */
9018 if (!cp_parser_require (parser, CPP_LESS, "`<'"))
9020 pop_deferring_access_checks ();
9021 return error_mark_node;
9023 /* Parse the arguments. */
9024 arguments = cp_parser_enclosed_template_argument_list (parser);
9027 /* Build a representation of the specialization. */
9028 if (TREE_CODE (template) == IDENTIFIER_NODE)
9029 template_id = build_min_nt (TEMPLATE_ID_EXPR, template, arguments);
9030 else if (DECL_CLASS_TEMPLATE_P (template)
9031 || DECL_TEMPLATE_TEMPLATE_PARM_P (template))
9033 bool entering_scope;
9034 /* In "template <typename T> ... A<T>::", A<T> is the abstract A
9035 template (rather than some instantiation thereof) only if
9036 is not nested within some other construct. For example, in
9037 "template <typename T> void f(T) { A<T>::", A<T> is just an
9038 instantiation of A. */
9039 entering_scope = (template_parm_scope_p ()
9040 && cp_lexer_next_token_is (parser->lexer,
9043 = finish_template_type (template, arguments, entering_scope);
9047 /* If it's not a class-template or a template-template, it should be
9048 a function-template. */
9049 gcc_assert ((DECL_FUNCTION_TEMPLATE_P (template)
9050 || TREE_CODE (template) == OVERLOAD
9051 || BASELINK_P (template)));
9053 template_id = lookup_template_function (template, arguments);
9056 /* If parsing tentatively, replace the sequence of tokens that makes
9057 up the template-id with a CPP_TEMPLATE_ID token. That way,
9058 should we re-parse the token stream, we will not have to repeat
9059 the effort required to do the parse, nor will we issue duplicate
9060 error messages about problems during instantiation of the
9064 cp_token *token = cp_lexer_token_at (parser->lexer, start_of_id);
9066 /* Reset the contents of the START_OF_ID token. */
9067 token->type = CPP_TEMPLATE_ID;
9068 /* Retrieve any deferred checks. Do not pop this access checks yet
9069 so the memory will not be reclaimed during token replacing below. */
9070 token->u.tree_check_value = GGC_CNEW (struct tree_check);
9071 token->u.tree_check_value->value = template_id;
9072 token->u.tree_check_value->checks = get_deferred_access_checks ();
9073 token->keyword = RID_MAX;
9075 /* Purge all subsequent tokens. */
9076 cp_lexer_purge_tokens_after (parser->lexer, start_of_id);
9078 /* ??? Can we actually assume that, if template_id ==
9079 error_mark_node, we will have issued a diagnostic to the
9080 user, as opposed to simply marking the tentative parse as
9082 if (cp_parser_error_occurred (parser) && template_id != error_mark_node)
9083 error ("parse error in template argument list");
9086 pop_deferring_access_checks ();
9090 /* Parse a template-name.
9095 The standard should actually say:
9099 operator-function-id
9101 A defect report has been filed about this issue.
9103 A conversion-function-id cannot be a template name because they cannot
9104 be part of a template-id. In fact, looking at this code:
9108 the conversion-function-id is "operator K<int>", and K<int> is a type-id.
9109 It is impossible to call a templated conversion-function-id with an
9110 explicit argument list, since the only allowed template parameter is
9111 the type to which it is converting.
9113 If TEMPLATE_KEYWORD_P is true, then we have just seen the
9114 `template' keyword, in a construction like:
9118 In that case `f' is taken to be a template-name, even though there
9119 is no way of knowing for sure.
9121 Returns the TEMPLATE_DECL for the template, or an OVERLOAD if the
9122 name refers to a set of overloaded functions, at least one of which
9123 is a template, or an IDENTIFIER_NODE with the name of the template,
9124 if TEMPLATE_KEYWORD_P is true. If CHECK_DEPENDENCY_P is FALSE,
9125 names are looked up inside uninstantiated templates. */
9128 cp_parser_template_name (cp_parser* parser,
9129 bool template_keyword_p,
9130 bool check_dependency_p,
9131 bool is_declaration,
9132 bool *is_identifier)
9138 /* If the next token is `operator', then we have either an
9139 operator-function-id or a conversion-function-id. */
9140 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_OPERATOR))
9142 /* We don't know whether we're looking at an
9143 operator-function-id or a conversion-function-id. */
9144 cp_parser_parse_tentatively (parser);
9145 /* Try an operator-function-id. */
9146 identifier = cp_parser_operator_function_id (parser);
9147 /* If that didn't work, try a conversion-function-id. */
9148 if (!cp_parser_parse_definitely (parser))
9150 cp_parser_error (parser, "expected template-name");
9151 return error_mark_node;
9154 /* Look for the identifier. */
9156 identifier = cp_parser_identifier (parser);
9158 /* If we didn't find an identifier, we don't have a template-id. */
9159 if (identifier == error_mark_node)
9160 return error_mark_node;
9162 /* If the name immediately followed the `template' keyword, then it
9163 is a template-name. However, if the next token is not `<', then
9164 we do not treat it as a template-name, since it is not being used
9165 as part of a template-id. This enables us to handle constructs
9168 template <typename T> struct S { S(); };
9169 template <typename T> S<T>::S();
9171 correctly. We would treat `S' as a template -- if it were `S<T>'
9172 -- but we do not if there is no `<'. */
9174 if (processing_template_decl
9175 && cp_parser_nth_token_starts_template_argument_list_p (parser, 1))
9177 /* In a declaration, in a dependent context, we pretend that the
9178 "template" keyword was present in order to improve error
9179 recovery. For example, given:
9181 template <typename T> void f(T::X<int>);
9183 we want to treat "X<int>" as a template-id. */
9185 && !template_keyword_p
9186 && parser->scope && TYPE_P (parser->scope)
9187 && check_dependency_p
9188 && dependent_type_p (parser->scope)
9189 /* Do not do this for dtors (or ctors), since they never
9190 need the template keyword before their name. */
9191 && !constructor_name_p (identifier, parser->scope))
9193 cp_token_position start = 0;
9195 /* Explain what went wrong. */
9196 error ("non-template %qD used as template", identifier);
9197 inform ("use %<%T::template %D%> to indicate that it is a template",
9198 parser->scope, identifier);
9199 /* If parsing tentatively, find the location of the "<" token. */
9200 if (cp_parser_simulate_error (parser))
9201 start = cp_lexer_token_position (parser->lexer, true);
9202 /* Parse the template arguments so that we can issue error
9203 messages about them. */
9204 cp_lexer_consume_token (parser->lexer);
9205 cp_parser_enclosed_template_argument_list (parser);
9206 /* Skip tokens until we find a good place from which to
9207 continue parsing. */
9208 cp_parser_skip_to_closing_parenthesis (parser,
9209 /*recovering=*/true,
9211 /*consume_paren=*/false);
9212 /* If parsing tentatively, permanently remove the
9213 template argument list. That will prevent duplicate
9214 error messages from being issued about the missing
9215 "template" keyword. */
9217 cp_lexer_purge_tokens_after (parser->lexer, start);
9219 *is_identifier = true;
9223 /* If the "template" keyword is present, then there is generally
9224 no point in doing name-lookup, so we just return IDENTIFIER.
9225 But, if the qualifying scope is non-dependent then we can
9226 (and must) do name-lookup normally. */
9227 if (template_keyword_p
9229 || (TYPE_P (parser->scope)
9230 && dependent_type_p (parser->scope))))
9234 /* Look up the name. */
9235 decl = cp_parser_lookup_name (parser, identifier,
9237 /*is_template=*/false,
9238 /*is_namespace=*/false,
9240 /*ambiguous_decls=*/NULL);
9241 decl = maybe_get_template_decl_from_type_decl (decl);
9243 /* If DECL is a template, then the name was a template-name. */
9244 if (TREE_CODE (decl) == TEMPLATE_DECL)
9248 tree fn = NULL_TREE;
9250 /* The standard does not explicitly indicate whether a name that
9251 names a set of overloaded declarations, some of which are
9252 templates, is a template-name. However, such a name should
9253 be a template-name; otherwise, there is no way to form a
9254 template-id for the overloaded templates. */
9255 fns = BASELINK_P (decl) ? BASELINK_FUNCTIONS (decl) : decl;
9256 if (TREE_CODE (fns) == OVERLOAD)
9257 for (fn = fns; fn; fn = OVL_NEXT (fn))
9258 if (TREE_CODE (OVL_CURRENT (fn)) == TEMPLATE_DECL)
9263 /* The name does not name a template. */
9264 cp_parser_error (parser, "expected template-name");
9265 return error_mark_node;
9269 /* If DECL is dependent, and refers to a function, then just return
9270 its name; we will look it up again during template instantiation. */
9271 if (DECL_FUNCTION_TEMPLATE_P (decl) || !DECL_P (decl))
9273 tree scope = CP_DECL_CONTEXT (get_first_fn (decl));
9274 if (TYPE_P (scope) && dependent_type_p (scope))
9281 /* Parse a template-argument-list.
9283 template-argument-list:
9285 template-argument-list , template-argument
9287 Returns a TREE_VEC containing the arguments. */
9290 cp_parser_template_argument_list (cp_parser* parser)
9292 tree fixed_args[10];
9293 unsigned n_args = 0;
9294 unsigned alloced = 10;
9295 tree *arg_ary = fixed_args;
9297 bool saved_in_template_argument_list_p;
9299 bool saved_non_ice_p;
9301 saved_in_template_argument_list_p = parser->in_template_argument_list_p;
9302 parser->in_template_argument_list_p = true;
9303 /* Even if the template-id appears in an integral
9304 constant-expression, the contents of the argument list do
9306 saved_ice_p = parser->integral_constant_expression_p;
9307 parser->integral_constant_expression_p = false;
9308 saved_non_ice_p = parser->non_integral_constant_expression_p;
9309 parser->non_integral_constant_expression_p = false;
9310 /* Parse the arguments. */
9316 /* Consume the comma. */
9317 cp_lexer_consume_token (parser->lexer);
9319 /* Parse the template-argument. */
9320 argument = cp_parser_template_argument (parser);
9321 if (n_args == alloced)
9325 if (arg_ary == fixed_args)
9327 arg_ary = XNEWVEC (tree, alloced);
9328 memcpy (arg_ary, fixed_args, sizeof (tree) * n_args);
9331 arg_ary = XRESIZEVEC (tree, arg_ary, alloced);
9333 arg_ary[n_args++] = argument;
9335 while (cp_lexer_next_token_is (parser->lexer, CPP_COMMA));
9337 vec = make_tree_vec (n_args);
9340 TREE_VEC_ELT (vec, n_args) = arg_ary[n_args];
9342 if (arg_ary != fixed_args)
9344 parser->non_integral_constant_expression_p = saved_non_ice_p;
9345 parser->integral_constant_expression_p = saved_ice_p;
9346 parser->in_template_argument_list_p = saved_in_template_argument_list_p;
9350 /* Parse a template-argument.
9353 assignment-expression
9357 The representation is that of an assignment-expression, type-id, or
9358 id-expression -- except that the qualified id-expression is
9359 evaluated, so that the value returned is either a DECL or an
9362 Although the standard says "assignment-expression", it forbids
9363 throw-expressions or assignments in the template argument.
9364 Therefore, we use "conditional-expression" instead. */
9367 cp_parser_template_argument (cp_parser* parser)
9372 bool maybe_type_id = false;
9376 /* There's really no way to know what we're looking at, so we just
9377 try each alternative in order.
9381 In a template-argument, an ambiguity between a type-id and an
9382 expression is resolved to a type-id, regardless of the form of
9383 the corresponding template-parameter.
9385 Therefore, we try a type-id first. */
9386 cp_parser_parse_tentatively (parser);
9387 argument = cp_parser_type_id (parser);
9388 /* If there was no error parsing the type-id but the next token is a '>>',
9389 we probably found a typo for '> >'. But there are type-id which are
9390 also valid expressions. For instance:
9392 struct X { int operator >> (int); };
9393 template <int V> struct Foo {};
9396 Here 'X()' is a valid type-id of a function type, but the user just
9397 wanted to write the expression "X() >> 5". Thus, we remember that we
9398 found a valid type-id, but we still try to parse the argument as an
9399 expression to see what happens. */
9400 if (!cp_parser_error_occurred (parser)
9401 && cp_lexer_next_token_is (parser->lexer, CPP_RSHIFT))
9403 maybe_type_id = true;
9404 cp_parser_abort_tentative_parse (parser);
9408 /* If the next token isn't a `,' or a `>', then this argument wasn't
9409 really finished. This means that the argument is not a valid
9411 if (!cp_parser_next_token_ends_template_argument_p (parser))
9412 cp_parser_error (parser, "expected template-argument");
9413 /* If that worked, we're done. */
9414 if (cp_parser_parse_definitely (parser))
9417 /* We're still not sure what the argument will be. */
9418 cp_parser_parse_tentatively (parser);
9419 /* Try a template. */
9420 argument = cp_parser_id_expression (parser,
9421 /*template_keyword_p=*/false,
9422 /*check_dependency_p=*/true,
9424 /*declarator_p=*/false,
9425 /*optional_p=*/false);
9426 /* If the next token isn't a `,' or a `>', then this argument wasn't
9428 if (!cp_parser_next_token_ends_template_argument_p (parser))
9429 cp_parser_error (parser, "expected template-argument");
9430 if (!cp_parser_error_occurred (parser))
9432 /* Figure out what is being referred to. If the id-expression
9433 was for a class template specialization, then we will have a
9434 TYPE_DECL at this point. There is no need to do name lookup
9435 at this point in that case. */
9436 if (TREE_CODE (argument) != TYPE_DECL)
9437 argument = cp_parser_lookup_name (parser, argument,
9439 /*is_template=*/template_p,
9440 /*is_namespace=*/false,
9441 /*check_dependency=*/true,
9442 /*ambiguous_decls=*/NULL);
9443 if (TREE_CODE (argument) != TEMPLATE_DECL
9444 && TREE_CODE (argument) != UNBOUND_CLASS_TEMPLATE)
9445 cp_parser_error (parser, "expected template-name");
9447 if (cp_parser_parse_definitely (parser))
9449 /* It must be a non-type argument. There permitted cases are given
9450 in [temp.arg.nontype]:
9452 -- an integral constant-expression of integral or enumeration
9455 -- the name of a non-type template-parameter; or
9457 -- the name of an object or function with external linkage...
9459 -- the address of an object or function with external linkage...
9461 -- a pointer to member... */
9462 /* Look for a non-type template parameter. */
9463 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
9465 cp_parser_parse_tentatively (parser);
9466 argument = cp_parser_primary_expression (parser,
9469 /*template_arg_p=*/true,
9471 if (TREE_CODE (argument) != TEMPLATE_PARM_INDEX
9472 || !cp_parser_next_token_ends_template_argument_p (parser))
9473 cp_parser_simulate_error (parser);
9474 if (cp_parser_parse_definitely (parser))
9478 /* If the next token is "&", the argument must be the address of an
9479 object or function with external linkage. */
9480 address_p = cp_lexer_next_token_is (parser->lexer, CPP_AND);
9482 cp_lexer_consume_token (parser->lexer);
9483 /* See if we might have an id-expression. */
9484 token = cp_lexer_peek_token (parser->lexer);
9485 if (token->type == CPP_NAME
9486 || token->keyword == RID_OPERATOR
9487 || token->type == CPP_SCOPE
9488 || token->type == CPP_TEMPLATE_ID
9489 || token->type == CPP_NESTED_NAME_SPECIFIER)
9491 cp_parser_parse_tentatively (parser);
9492 argument = cp_parser_primary_expression (parser,
9495 /*template_arg_p=*/true,
9497 if (cp_parser_error_occurred (parser)
9498 || !cp_parser_next_token_ends_template_argument_p (parser))
9499 cp_parser_abort_tentative_parse (parser);
9502 if (TREE_CODE (argument) == INDIRECT_REF)
9504 gcc_assert (REFERENCE_REF_P (argument));
9505 argument = TREE_OPERAND (argument, 0);
9508 if (TREE_CODE (argument) == VAR_DECL)
9510 /* A variable without external linkage might still be a
9511 valid constant-expression, so no error is issued here
9512 if the external-linkage check fails. */
9513 if (!address_p && !DECL_EXTERNAL_LINKAGE_P (argument))
9514 cp_parser_simulate_error (parser);
9516 else if (is_overloaded_fn (argument))
9517 /* All overloaded functions are allowed; if the external
9518 linkage test does not pass, an error will be issued
9522 && (TREE_CODE (argument) == OFFSET_REF
9523 || TREE_CODE (argument) == SCOPE_REF))
9524 /* A pointer-to-member. */
9526 else if (TREE_CODE (argument) == TEMPLATE_PARM_INDEX)
9529 cp_parser_simulate_error (parser);
9531 if (cp_parser_parse_definitely (parser))
9534 argument = build_x_unary_op (ADDR_EXPR, argument);
9539 /* If the argument started with "&", there are no other valid
9540 alternatives at this point. */
9543 cp_parser_error (parser, "invalid non-type template argument");
9544 return error_mark_node;
9547 /* If the argument wasn't successfully parsed as a type-id followed
9548 by '>>', the argument can only be a constant expression now.
9549 Otherwise, we try parsing the constant-expression tentatively,
9550 because the argument could really be a type-id. */
9552 cp_parser_parse_tentatively (parser);
9553 argument = cp_parser_constant_expression (parser,
9554 /*allow_non_constant_p=*/false,
9555 /*non_constant_p=*/NULL);
9556 argument = fold_non_dependent_expr (argument);
9559 if (!cp_parser_next_token_ends_template_argument_p (parser))
9560 cp_parser_error (parser, "expected template-argument");
9561 if (cp_parser_parse_definitely (parser))
9563 /* We did our best to parse the argument as a non type-id, but that
9564 was the only alternative that matched (albeit with a '>' after
9565 it). We can assume it's just a typo from the user, and a
9566 diagnostic will then be issued. */
9567 return cp_parser_type_id (parser);
9570 /* Parse an explicit-instantiation.
9572 explicit-instantiation:
9573 template declaration
9575 Although the standard says `declaration', what it really means is:
9577 explicit-instantiation:
9578 template decl-specifier-seq [opt] declarator [opt] ;
9580 Things like `template int S<int>::i = 5, int S<double>::j;' are not
9581 supposed to be allowed. A defect report has been filed about this
9586 explicit-instantiation:
9587 storage-class-specifier template
9588 decl-specifier-seq [opt] declarator [opt] ;
9589 function-specifier template
9590 decl-specifier-seq [opt] declarator [opt] ; */
9593 cp_parser_explicit_instantiation (cp_parser* parser)
9595 int declares_class_or_enum;
9596 cp_decl_specifier_seq decl_specifiers;
9597 tree extension_specifier = NULL_TREE;
9599 /* Look for an (optional) storage-class-specifier or
9600 function-specifier. */
9601 if (cp_parser_allow_gnu_extensions_p (parser))
9604 = cp_parser_storage_class_specifier_opt (parser);
9605 if (!extension_specifier)
9607 = cp_parser_function_specifier_opt (parser,
9608 /*decl_specs=*/NULL);
9611 /* Look for the `template' keyword. */
9612 cp_parser_require_keyword (parser, RID_TEMPLATE, "`template'");
9613 /* Let the front end know that we are processing an explicit
9615 begin_explicit_instantiation ();
9616 /* [temp.explicit] says that we are supposed to ignore access
9617 control while processing explicit instantiation directives. */
9618 push_deferring_access_checks (dk_no_check);
9619 /* Parse a decl-specifier-seq. */
9620 cp_parser_decl_specifier_seq (parser,
9621 CP_PARSER_FLAGS_OPTIONAL,
9623 &declares_class_or_enum);
9624 /* If there was exactly one decl-specifier, and it declared a class,
9625 and there's no declarator, then we have an explicit type
9627 if (declares_class_or_enum && cp_parser_declares_only_class_p (parser))
9631 type = check_tag_decl (&decl_specifiers);
9632 /* Turn access control back on for names used during
9633 template instantiation. */
9634 pop_deferring_access_checks ();
9636 do_type_instantiation (type, extension_specifier,
9637 /*complain=*/tf_error);
9641 cp_declarator *declarator;
9644 /* Parse the declarator. */
9646 = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
9647 /*ctor_dtor_or_conv_p=*/NULL,
9648 /*parenthesized_p=*/NULL,
9649 /*member_p=*/false);
9650 if (declares_class_or_enum & 2)
9651 cp_parser_check_for_definition_in_return_type (declarator,
9652 decl_specifiers.type);
9653 if (declarator != cp_error_declarator)
9655 decl = grokdeclarator (declarator, &decl_specifiers,
9656 NORMAL, 0, &decl_specifiers.attributes);
9657 /* Turn access control back on for names used during
9658 template instantiation. */
9659 pop_deferring_access_checks ();
9660 /* Do the explicit instantiation. */
9661 do_decl_instantiation (decl, extension_specifier);
9665 pop_deferring_access_checks ();
9666 /* Skip the body of the explicit instantiation. */
9667 cp_parser_skip_to_end_of_statement (parser);
9670 /* We're done with the instantiation. */
9671 end_explicit_instantiation ();
9673 cp_parser_consume_semicolon_at_end_of_statement (parser);
9676 /* Parse an explicit-specialization.
9678 explicit-specialization:
9679 template < > declaration
9681 Although the standard says `declaration', what it really means is:
9683 explicit-specialization:
9684 template <> decl-specifier [opt] init-declarator [opt] ;
9685 template <> function-definition
9686 template <> explicit-specialization
9687 template <> template-declaration */
9690 cp_parser_explicit_specialization (cp_parser* parser)
9693 /* Look for the `template' keyword. */
9694 cp_parser_require_keyword (parser, RID_TEMPLATE, "`template'");
9695 /* Look for the `<'. */
9696 cp_parser_require (parser, CPP_LESS, "`<'");
9697 /* Look for the `>'. */
9698 cp_parser_require (parser, CPP_GREATER, "`>'");
9699 /* We have processed another parameter list. */
9700 ++parser->num_template_parameter_lists;
9703 A template ... explicit specialization ... shall not have C
9705 if (current_lang_name == lang_name_c)
9707 error ("template specialization with C linkage");
9708 /* Give it C++ linkage to avoid confusing other parts of the
9710 push_lang_context (lang_name_cplusplus);
9711 need_lang_pop = true;
9714 need_lang_pop = false;
9715 /* Let the front end know that we are beginning a specialization. */
9716 if (!begin_specialization ())
9718 end_specialization ();
9719 cp_parser_skip_to_end_of_block_or_statement (parser);
9723 /* If the next keyword is `template', we need to figure out whether
9724 or not we're looking a template-declaration. */
9725 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
9727 if (cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_LESS
9728 && cp_lexer_peek_nth_token (parser->lexer, 3)->type != CPP_GREATER)
9729 cp_parser_template_declaration_after_export (parser,
9730 /*member_p=*/false);
9732 cp_parser_explicit_specialization (parser);
9735 /* Parse the dependent declaration. */
9736 cp_parser_single_declaration (parser,
9740 /* We're done with the specialization. */
9741 end_specialization ();
9742 /* For the erroneous case of a template with C linkage, we pushed an
9743 implicit C++ linkage scope; exit that scope now. */
9745 pop_lang_context ();
9746 /* We're done with this parameter list. */
9747 --parser->num_template_parameter_lists;
9750 /* Parse a type-specifier.
9753 simple-type-specifier
9756 elaborated-type-specifier
9764 Returns a representation of the type-specifier. For a
9765 class-specifier, enum-specifier, or elaborated-type-specifier, a
9766 TREE_TYPE is returned; otherwise, a TYPE_DECL is returned.
9768 The parser flags FLAGS is used to control type-specifier parsing.
9770 If IS_DECLARATION is TRUE, then this type-specifier is appearing
9771 in a decl-specifier-seq.
9773 If DECLARES_CLASS_OR_ENUM is non-NULL, and the type-specifier is a
9774 class-specifier, enum-specifier, or elaborated-type-specifier, then
9775 *DECLARES_CLASS_OR_ENUM is set to a nonzero value. The value is 1
9776 if a type is declared; 2 if it is defined. Otherwise, it is set to
9779 If IS_CV_QUALIFIER is non-NULL, and the type-specifier is a
9780 cv-qualifier, then IS_CV_QUALIFIER is set to TRUE. Otherwise, it
9784 cp_parser_type_specifier (cp_parser* parser,
9785 cp_parser_flags flags,
9786 cp_decl_specifier_seq *decl_specs,
9787 bool is_declaration,
9788 int* declares_class_or_enum,
9789 bool* is_cv_qualifier)
9791 tree type_spec = NULL_TREE;
9794 cp_decl_spec ds = ds_last;
9796 /* Assume this type-specifier does not declare a new type. */
9797 if (declares_class_or_enum)
9798 *declares_class_or_enum = 0;
9799 /* And that it does not specify a cv-qualifier. */
9800 if (is_cv_qualifier)
9801 *is_cv_qualifier = false;
9802 /* Peek at the next token. */
9803 token = cp_lexer_peek_token (parser->lexer);
9805 /* If we're looking at a keyword, we can use that to guide the
9806 production we choose. */
9807 keyword = token->keyword;
9811 /* Look for the enum-specifier. */
9812 type_spec = cp_parser_enum_specifier (parser);
9813 /* If that worked, we're done. */
9816 if (declares_class_or_enum)
9817 *declares_class_or_enum = 2;
9819 cp_parser_set_decl_spec_type (decl_specs,
9821 /*user_defined_p=*/true);
9825 goto elaborated_type_specifier;
9827 /* Any of these indicate either a class-specifier, or an
9828 elaborated-type-specifier. */
9832 /* Parse tentatively so that we can back up if we don't find a
9834 cp_parser_parse_tentatively (parser);
9835 /* Look for the class-specifier. */
9836 type_spec = cp_parser_class_specifier (parser);
9837 /* If that worked, we're done. */
9838 if (cp_parser_parse_definitely (parser))
9840 if (declares_class_or_enum)
9841 *declares_class_or_enum = 2;
9843 cp_parser_set_decl_spec_type (decl_specs,
9845 /*user_defined_p=*/true);
9850 elaborated_type_specifier:
9851 /* We're declaring (not defining) a class or enum. */
9852 if (declares_class_or_enum)
9853 *declares_class_or_enum = 1;
9857 /* Look for an elaborated-type-specifier. */
9859 = (cp_parser_elaborated_type_specifier
9861 decl_specs && decl_specs->specs[(int) ds_friend],
9864 cp_parser_set_decl_spec_type (decl_specs,
9866 /*user_defined_p=*/true);
9871 if (is_cv_qualifier)
9872 *is_cv_qualifier = true;
9877 if (is_cv_qualifier)
9878 *is_cv_qualifier = true;
9883 if (is_cv_qualifier)
9884 *is_cv_qualifier = true;
9888 /* The `__complex__' keyword is a GNU extension. */
9896 /* Handle simple keywords. */
9901 ++decl_specs->specs[(int)ds];
9902 decl_specs->any_specifiers_p = true;
9904 return cp_lexer_consume_token (parser->lexer)->u.value;
9907 /* If we do not already have a type-specifier, assume we are looking
9908 at a simple-type-specifier. */
9909 type_spec = cp_parser_simple_type_specifier (parser,
9913 /* If we didn't find a type-specifier, and a type-specifier was not
9914 optional in this context, issue an error message. */
9915 if (!type_spec && !(flags & CP_PARSER_FLAGS_OPTIONAL))
9917 cp_parser_error (parser, "expected type specifier");
9918 return error_mark_node;
9924 /* Parse a simple-type-specifier.
9926 simple-type-specifier:
9927 :: [opt] nested-name-specifier [opt] type-name
9928 :: [opt] nested-name-specifier template template-id
9943 simple-type-specifier:
9944 __typeof__ unary-expression
9945 __typeof__ ( type-id )
9947 Returns the indicated TYPE_DECL. If DECL_SPECS is not NULL, it is
9948 appropriately updated. */
9951 cp_parser_simple_type_specifier (cp_parser* parser,
9952 cp_decl_specifier_seq *decl_specs,
9953 cp_parser_flags flags)
9955 tree type = NULL_TREE;
9958 /* Peek at the next token. */
9959 token = cp_lexer_peek_token (parser->lexer);
9961 /* If we're looking at a keyword, things are easy. */
9962 switch (token->keyword)
9966 decl_specs->explicit_char_p = true;
9967 type = char_type_node;
9970 type = wchar_type_node;
9973 type = boolean_type_node;
9977 ++decl_specs->specs[(int) ds_short];
9978 type = short_integer_type_node;
9982 decl_specs->explicit_int_p = true;
9983 type = integer_type_node;
9987 ++decl_specs->specs[(int) ds_long];
9988 type = long_integer_type_node;
9992 ++decl_specs->specs[(int) ds_signed];
9993 type = integer_type_node;
9997 ++decl_specs->specs[(int) ds_unsigned];
9998 type = unsigned_type_node;
10001 type = float_type_node;
10004 type = double_type_node;
10007 type = void_type_node;
10011 /* Consume the `typeof' token. */
10012 cp_lexer_consume_token (parser->lexer);
10013 /* Parse the operand to `typeof'. */
10014 type = cp_parser_sizeof_operand (parser, RID_TYPEOF);
10015 /* If it is not already a TYPE, take its type. */
10016 if (!TYPE_P (type))
10017 type = finish_typeof (type);
10020 cp_parser_set_decl_spec_type (decl_specs, type,
10021 /*user_defined_p=*/true);
10029 /* If the type-specifier was for a built-in type, we're done. */
10034 /* Record the type. */
10036 && (token->keyword != RID_SIGNED
10037 && token->keyword != RID_UNSIGNED
10038 && token->keyword != RID_SHORT
10039 && token->keyword != RID_LONG))
10040 cp_parser_set_decl_spec_type (decl_specs,
10042 /*user_defined=*/false);
10044 decl_specs->any_specifiers_p = true;
10046 /* Consume the token. */
10047 id = cp_lexer_consume_token (parser->lexer)->u.value;
10049 /* There is no valid C++ program where a non-template type is
10050 followed by a "<". That usually indicates that the user thought
10051 that the type was a template. */
10052 cp_parser_check_for_invalid_template_id (parser, type);
10054 return TYPE_NAME (type);
10057 /* The type-specifier must be a user-defined type. */
10058 if (!(flags & CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES))
10063 /* Don't gobble tokens or issue error messages if this is an
10064 optional type-specifier. */
10065 if (flags & CP_PARSER_FLAGS_OPTIONAL)
10066 cp_parser_parse_tentatively (parser);
10068 /* Look for the optional `::' operator. */
10070 = (cp_parser_global_scope_opt (parser,
10071 /*current_scope_valid_p=*/false)
10073 /* Look for the nested-name specifier. */
10075 = (cp_parser_nested_name_specifier_opt (parser,
10076 /*typename_keyword_p=*/false,
10077 /*check_dependency_p=*/true,
10079 /*is_declaration=*/false)
10081 /* If we have seen a nested-name-specifier, and the next token
10082 is `template', then we are using the template-id production. */
10084 && cp_parser_optional_template_keyword (parser))
10086 /* Look for the template-id. */
10087 type = cp_parser_template_id (parser,
10088 /*template_keyword_p=*/true,
10089 /*check_dependency_p=*/true,
10090 /*is_declaration=*/false);
10091 /* If the template-id did not name a type, we are out of
10093 if (TREE_CODE (type) != TYPE_DECL)
10095 cp_parser_error (parser, "expected template-id for type");
10099 /* Otherwise, look for a type-name. */
10101 type = cp_parser_type_name (parser);
10102 /* Keep track of all name-lookups performed in class scopes. */
10106 && TREE_CODE (type) == TYPE_DECL
10107 && TREE_CODE (DECL_NAME (type)) == IDENTIFIER_NODE)
10108 maybe_note_name_used_in_class (DECL_NAME (type), type);
10109 /* If it didn't work out, we don't have a TYPE. */
10110 if ((flags & CP_PARSER_FLAGS_OPTIONAL)
10111 && !cp_parser_parse_definitely (parser))
10113 if (type && decl_specs)
10114 cp_parser_set_decl_spec_type (decl_specs, type,
10115 /*user_defined=*/true);
10118 /* If we didn't get a type-name, issue an error message. */
10119 if (!type && !(flags & CP_PARSER_FLAGS_OPTIONAL))
10121 cp_parser_error (parser, "expected type-name");
10122 return error_mark_node;
10125 /* There is no valid C++ program where a non-template type is
10126 followed by a "<". That usually indicates that the user thought
10127 that the type was a template. */
10128 if (type && type != error_mark_node)
10130 /* As a last-ditch effort, see if TYPE is an Objective-C type.
10131 If it is, then the '<'...'>' enclose protocol names rather than
10132 template arguments, and so everything is fine. */
10133 if (c_dialect_objc ()
10134 && (objc_is_id (type) || objc_is_class_name (type)))
10136 tree protos = cp_parser_objc_protocol_refs_opt (parser);
10137 tree qual_type = objc_get_protocol_qualified_type (type, protos);
10139 /* Clobber the "unqualified" type previously entered into
10140 DECL_SPECS with the new, improved protocol-qualified version. */
10142 decl_specs->type = qual_type;
10147 cp_parser_check_for_invalid_template_id (parser, TREE_TYPE (type));
10153 /* Parse a type-name.
10166 Returns a TYPE_DECL for the type. */
10169 cp_parser_type_name (cp_parser* parser)
10174 /* We can't know yet whether it is a class-name or not. */
10175 cp_parser_parse_tentatively (parser);
10176 /* Try a class-name. */
10177 type_decl = cp_parser_class_name (parser,
10178 /*typename_keyword_p=*/false,
10179 /*template_keyword_p=*/false,
10181 /*check_dependency_p=*/true,
10182 /*class_head_p=*/false,
10183 /*is_declaration=*/false);
10184 /* If it's not a class-name, keep looking. */
10185 if (!cp_parser_parse_definitely (parser))
10187 /* It must be a typedef-name or an enum-name. */
10188 identifier = cp_parser_identifier (parser);
10189 if (identifier == error_mark_node)
10190 return error_mark_node;
10192 /* Look up the type-name. */
10193 type_decl = cp_parser_lookup_name_simple (parser, identifier);
10195 if (TREE_CODE (type_decl) != TYPE_DECL
10196 && (objc_is_id (identifier) || objc_is_class_name (identifier)))
10198 /* See if this is an Objective-C type. */
10199 tree protos = cp_parser_objc_protocol_refs_opt (parser);
10200 tree type = objc_get_protocol_qualified_type (identifier, protos);
10202 type_decl = TYPE_NAME (type);
10205 /* Issue an error if we did not find a type-name. */
10206 if (TREE_CODE (type_decl) != TYPE_DECL)
10208 if (!cp_parser_simulate_error (parser))
10209 cp_parser_name_lookup_error (parser, identifier, type_decl,
10211 type_decl = error_mark_node;
10213 /* Remember that the name was used in the definition of the
10214 current class so that we can check later to see if the
10215 meaning would have been different after the class was
10216 entirely defined. */
10217 else if (type_decl != error_mark_node
10219 maybe_note_name_used_in_class (identifier, type_decl);
10226 /* Parse an elaborated-type-specifier. Note that the grammar given
10227 here incorporates the resolution to DR68.
10229 elaborated-type-specifier:
10230 class-key :: [opt] nested-name-specifier [opt] identifier
10231 class-key :: [opt] nested-name-specifier [opt] template [opt] template-id
10232 enum :: [opt] nested-name-specifier [opt] identifier
10233 typename :: [opt] nested-name-specifier identifier
10234 typename :: [opt] nested-name-specifier template [opt]
10239 elaborated-type-specifier:
10240 class-key attributes :: [opt] nested-name-specifier [opt] identifier
10241 class-key attributes :: [opt] nested-name-specifier [opt]
10242 template [opt] template-id
10243 enum attributes :: [opt] nested-name-specifier [opt] identifier
10245 If IS_FRIEND is TRUE, then this elaborated-type-specifier is being
10246 declared `friend'. If IS_DECLARATION is TRUE, then this
10247 elaborated-type-specifier appears in a decl-specifiers-seq, i.e.,
10248 something is being declared.
10250 Returns the TYPE specified. */
10253 cp_parser_elaborated_type_specifier (cp_parser* parser,
10255 bool is_declaration)
10257 enum tag_types tag_type;
10259 tree type = NULL_TREE;
10260 tree attributes = NULL_TREE;
10262 /* See if we're looking at the `enum' keyword. */
10263 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_ENUM))
10265 /* Consume the `enum' token. */
10266 cp_lexer_consume_token (parser->lexer);
10267 /* Remember that it's an enumeration type. */
10268 tag_type = enum_type;
10269 /* Parse the attributes. */
10270 attributes = cp_parser_attributes_opt (parser);
10272 /* Or, it might be `typename'. */
10273 else if (cp_lexer_next_token_is_keyword (parser->lexer,
10276 /* Consume the `typename' token. */
10277 cp_lexer_consume_token (parser->lexer);
10278 /* Remember that it's a `typename' type. */
10279 tag_type = typename_type;
10280 /* The `typename' keyword is only allowed in templates. */
10281 if (!processing_template_decl)
10282 pedwarn ("using %<typename%> outside of template");
10284 /* Otherwise it must be a class-key. */
10287 tag_type = cp_parser_class_key (parser);
10288 if (tag_type == none_type)
10289 return error_mark_node;
10290 /* Parse the attributes. */
10291 attributes = cp_parser_attributes_opt (parser);
10294 /* Look for the `::' operator. */
10295 cp_parser_global_scope_opt (parser,
10296 /*current_scope_valid_p=*/false);
10297 /* Look for the nested-name-specifier. */
10298 if (tag_type == typename_type)
10300 if (!cp_parser_nested_name_specifier (parser,
10301 /*typename_keyword_p=*/true,
10302 /*check_dependency_p=*/true,
10305 return error_mark_node;
10308 /* Even though `typename' is not present, the proposed resolution
10309 to Core Issue 180 says that in `class A<T>::B', `B' should be
10310 considered a type-name, even if `A<T>' is dependent. */
10311 cp_parser_nested_name_specifier_opt (parser,
10312 /*typename_keyword_p=*/true,
10313 /*check_dependency_p=*/true,
10316 /* For everything but enumeration types, consider a template-id.
10317 For an enumeration type, consider only a plain identifier. */
10318 if (tag_type != enum_type)
10320 bool template_p = false;
10323 /* Allow the `template' keyword. */
10324 template_p = cp_parser_optional_template_keyword (parser);
10325 /* If we didn't see `template', we don't know if there's a
10326 template-id or not. */
10328 cp_parser_parse_tentatively (parser);
10329 /* Parse the template-id. */
10330 decl = cp_parser_template_id (parser, template_p,
10331 /*check_dependency_p=*/true,
10333 /* If we didn't find a template-id, look for an ordinary
10335 if (!template_p && !cp_parser_parse_definitely (parser))
10337 /* If DECL is a TEMPLATE_ID_EXPR, and the `typename' keyword is
10338 in effect, then we must assume that, upon instantiation, the
10339 template will correspond to a class. */
10340 else if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
10341 && tag_type == typename_type)
10342 type = make_typename_type (parser->scope, decl,
10344 /*complain=*/tf_error);
10346 type = TREE_TYPE (decl);
10351 identifier = cp_parser_identifier (parser);
10353 if (identifier == error_mark_node)
10355 parser->scope = NULL_TREE;
10356 return error_mark_node;
10359 /* For a `typename', we needn't call xref_tag. */
10360 if (tag_type == typename_type
10361 && TREE_CODE (parser->scope) != NAMESPACE_DECL)
10362 return cp_parser_make_typename_type (parser, parser->scope,
10364 /* Look up a qualified name in the usual way. */
10369 decl = cp_parser_lookup_name (parser, identifier,
10371 /*is_template=*/false,
10372 /*is_namespace=*/false,
10373 /*check_dependency=*/true,
10374 /*ambiguous_decls=*/NULL);
10376 /* If we are parsing friend declaration, DECL may be a
10377 TEMPLATE_DECL tree node here. However, we need to check
10378 whether this TEMPLATE_DECL results in valid code. Consider
10379 the following example:
10382 template <class T> class C {};
10385 template <class T> friend class N::C; // #1, valid code
10387 template <class T> class Y {
10388 friend class N::C; // #2, invalid code
10391 For both case #1 and #2, we arrive at a TEMPLATE_DECL after
10392 name lookup of `N::C'. We see that friend declaration must
10393 be template for the code to be valid. Note that
10394 processing_template_decl does not work here since it is
10395 always 1 for the above two cases. */
10397 decl = (cp_parser_maybe_treat_template_as_class
10398 (decl, /*tag_name_p=*/is_friend
10399 && parser->num_template_parameter_lists));
10401 if (TREE_CODE (decl) != TYPE_DECL)
10403 cp_parser_diagnose_invalid_type_name (parser,
10406 return error_mark_node;
10409 if (TREE_CODE (TREE_TYPE (decl)) != TYPENAME_TYPE)
10411 bool allow_template = (parser->num_template_parameter_lists
10412 || DECL_SELF_REFERENCE_P (decl));
10413 type = check_elaborated_type_specifier (tag_type, decl,
10416 if (type == error_mark_node)
10417 return error_mark_node;
10420 type = TREE_TYPE (decl);
10424 /* An elaborated-type-specifier sometimes introduces a new type and
10425 sometimes names an existing type. Normally, the rule is that it
10426 introduces a new type only if there is not an existing type of
10427 the same name already in scope. For example, given:
10430 void f() { struct S s; }
10432 the `struct S' in the body of `f' is the same `struct S' as in
10433 the global scope; the existing definition is used. However, if
10434 there were no global declaration, this would introduce a new
10435 local class named `S'.
10437 An exception to this rule applies to the following code:
10439 namespace N { struct S; }
10441 Here, the elaborated-type-specifier names a new type
10442 unconditionally; even if there is already an `S' in the
10443 containing scope this declaration names a new type.
10444 This exception only applies if the elaborated-type-specifier
10445 forms the complete declaration:
10449 A declaration consisting solely of `class-key identifier ;' is
10450 either a redeclaration of the name in the current scope or a
10451 forward declaration of the identifier as a class name. It
10452 introduces the name into the current scope.
10454 We are in this situation precisely when the next token is a `;'.
10456 An exception to the exception is that a `friend' declaration does
10457 *not* name a new type; i.e., given:
10459 struct S { friend struct T; };
10461 `T' is not a new type in the scope of `S'.
10463 Also, `new struct S' or `sizeof (struct S)' never results in the
10464 definition of a new type; a new type can only be declared in a
10465 declaration context. */
10471 /* Friends have special name lookup rules. */
10472 ts = ts_within_enclosing_non_class;
10473 else if (is_declaration
10474 && cp_lexer_next_token_is (parser->lexer,
10476 /* This is a `class-key identifier ;' */
10482 (parser->num_template_parameter_lists
10483 && (cp_parser_next_token_starts_class_definition_p (parser)
10484 || cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)));
10485 /* An unqualified name was used to reference this type, so
10486 there were no qualifying templates. */
10487 if (!cp_parser_check_template_parameters (parser,
10488 /*num_templates=*/0))
10489 return error_mark_node;
10490 type = xref_tag (tag_type, identifier, ts, template_p);
10494 if (type == error_mark_node)
10495 return error_mark_node;
10497 /* Allow attributes on forward declarations of classes. */
10500 if (TREE_CODE (type) == TYPENAME_TYPE)
10501 warning (OPT_Wattributes,
10502 "attributes ignored on uninstantiated type");
10503 else if (tag_type != enum_type && CLASSTYPE_TEMPLATE_INSTANTIATION (type)
10504 && ! processing_explicit_instantiation)
10505 warning (OPT_Wattributes,
10506 "attributes ignored on template instantiation");
10507 else if (is_declaration && cp_parser_declares_only_class_p (parser))
10508 cplus_decl_attributes (&type, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
10510 warning (OPT_Wattributes,
10511 "attributes ignored on elaborated-type-specifier that is not a forward declaration");
10514 if (tag_type != enum_type)
10515 cp_parser_check_class_key (tag_type, type);
10517 /* A "<" cannot follow an elaborated type specifier. If that
10518 happens, the user was probably trying to form a template-id. */
10519 cp_parser_check_for_invalid_template_id (parser, type);
10524 /* Parse an enum-specifier.
10527 enum identifier [opt] { enumerator-list [opt] }
10530 enum attributes[opt] identifier [opt] { enumerator-list [opt] }
10533 Returns an ENUM_TYPE representing the enumeration, or NULL_TREE
10534 if the token stream isn't an enum-specifier after all. */
10537 cp_parser_enum_specifier (cp_parser* parser)
10543 /* Parse tentatively so that we can back up if we don't find a
10545 cp_parser_parse_tentatively (parser);
10547 /* Caller guarantees that the current token is 'enum', an identifier
10548 possibly follows, and the token after that is an opening brace.
10549 If we don't have an identifier, fabricate an anonymous name for
10550 the enumeration being defined. */
10551 cp_lexer_consume_token (parser->lexer);
10553 attributes = cp_parser_attributes_opt (parser);
10555 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
10556 identifier = cp_parser_identifier (parser);
10558 identifier = make_anon_name ();
10560 /* Look for the `{' but don't consume it yet. */
10561 if (!cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
10562 cp_parser_simulate_error (parser);
10564 if (!cp_parser_parse_definitely (parser))
10567 /* Issue an error message if type-definitions are forbidden here. */
10568 if (!cp_parser_check_type_definition (parser))
10569 type = error_mark_node;
10571 /* Create the new type. We do this before consuming the opening
10572 brace so the enum will be recorded as being on the line of its
10573 tag (or the 'enum' keyword, if there is no tag). */
10574 type = start_enum (identifier);
10576 /* Consume the opening brace. */
10577 cp_lexer_consume_token (parser->lexer);
10579 if (type == error_mark_node)
10581 cp_parser_skip_to_end_of_block_or_statement (parser);
10582 return error_mark_node;
10585 /* If the next token is not '}', then there are some enumerators. */
10586 if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_BRACE))
10587 cp_parser_enumerator_list (parser, type);
10589 /* Consume the final '}'. */
10590 cp_parser_require (parser, CPP_CLOSE_BRACE, "`}'");
10592 /* Look for trailing attributes to apply to this enumeration, and
10593 apply them if appropriate. */
10594 if (cp_parser_allow_gnu_extensions_p (parser))
10596 tree trailing_attr = cp_parser_attributes_opt (parser);
10597 cplus_decl_attributes (&type,
10599 (int) ATTR_FLAG_TYPE_IN_PLACE);
10602 /* Finish up the enumeration. */
10603 finish_enum (type);
10608 /* Parse an enumerator-list. The enumerators all have the indicated
10612 enumerator-definition
10613 enumerator-list , enumerator-definition */
10616 cp_parser_enumerator_list (cp_parser* parser, tree type)
10620 /* Parse an enumerator-definition. */
10621 cp_parser_enumerator_definition (parser, type);
10623 /* If the next token is not a ',', we've reached the end of
10625 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
10627 /* Otherwise, consume the `,' and keep going. */
10628 cp_lexer_consume_token (parser->lexer);
10629 /* If the next token is a `}', there is a trailing comma. */
10630 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
10632 if (pedantic && !in_system_header)
10633 pedwarn ("comma at end of enumerator list");
10639 /* Parse an enumerator-definition. The enumerator has the indicated
10642 enumerator-definition:
10644 enumerator = constant-expression
10650 cp_parser_enumerator_definition (cp_parser* parser, tree type)
10655 /* Look for the identifier. */
10656 identifier = cp_parser_identifier (parser);
10657 if (identifier == error_mark_node)
10660 /* If the next token is an '=', then there is an explicit value. */
10661 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
10663 /* Consume the `=' token. */
10664 cp_lexer_consume_token (parser->lexer);
10665 /* Parse the value. */
10666 value = cp_parser_constant_expression (parser,
10667 /*allow_non_constant_p=*/false,
10673 /* Create the enumerator. */
10674 build_enumerator (identifier, value, type);
10677 /* Parse a namespace-name.
10680 original-namespace-name
10683 Returns the NAMESPACE_DECL for the namespace. */
10686 cp_parser_namespace_name (cp_parser* parser)
10689 tree namespace_decl;
10691 /* Get the name of the namespace. */
10692 identifier = cp_parser_identifier (parser);
10693 if (identifier == error_mark_node)
10694 return error_mark_node;
10696 /* Look up the identifier in the currently active scope. Look only
10697 for namespaces, due to:
10699 [basic.lookup.udir]
10701 When looking up a namespace-name in a using-directive or alias
10702 definition, only namespace names are considered.
10706 [basic.lookup.qual]
10708 During the lookup of a name preceding the :: scope resolution
10709 operator, object, function, and enumerator names are ignored.
10711 (Note that cp_parser_class_or_namespace_name only calls this
10712 function if the token after the name is the scope resolution
10714 namespace_decl = cp_parser_lookup_name (parser, identifier,
10716 /*is_template=*/false,
10717 /*is_namespace=*/true,
10718 /*check_dependency=*/true,
10719 /*ambiguous_decls=*/NULL);
10720 /* If it's not a namespace, issue an error. */
10721 if (namespace_decl == error_mark_node
10722 || TREE_CODE (namespace_decl) != NAMESPACE_DECL)
10724 if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
10725 error ("%qD is not a namespace-name", identifier);
10726 cp_parser_error (parser, "expected namespace-name");
10727 namespace_decl = error_mark_node;
10730 return namespace_decl;
10733 /* Parse a namespace-definition.
10735 namespace-definition:
10736 named-namespace-definition
10737 unnamed-namespace-definition
10739 named-namespace-definition:
10740 original-namespace-definition
10741 extension-namespace-definition
10743 original-namespace-definition:
10744 namespace identifier { namespace-body }
10746 extension-namespace-definition:
10747 namespace original-namespace-name { namespace-body }
10749 unnamed-namespace-definition:
10750 namespace { namespace-body } */
10753 cp_parser_namespace_definition (cp_parser* parser)
10755 tree identifier, attribs;
10757 /* Look for the `namespace' keyword. */
10758 cp_parser_require_keyword (parser, RID_NAMESPACE, "`namespace'");
10760 /* Get the name of the namespace. We do not attempt to distinguish
10761 between an original-namespace-definition and an
10762 extension-namespace-definition at this point. The semantic
10763 analysis routines are responsible for that. */
10764 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
10765 identifier = cp_parser_identifier (parser);
10767 identifier = NULL_TREE;
10769 /* Parse any specified attributes. */
10770 attribs = cp_parser_attributes_opt (parser);
10772 /* Look for the `{' to start the namespace. */
10773 cp_parser_require (parser, CPP_OPEN_BRACE, "`{'");
10774 /* Start the namespace. */
10775 push_namespace_with_attribs (identifier, attribs);
10776 /* Parse the body of the namespace. */
10777 cp_parser_namespace_body (parser);
10778 /* Finish the namespace. */
10780 /* Look for the final `}'. */
10781 cp_parser_require (parser, CPP_CLOSE_BRACE, "`}'");
10784 /* Parse a namespace-body.
10787 declaration-seq [opt] */
10790 cp_parser_namespace_body (cp_parser* parser)
10792 cp_parser_declaration_seq_opt (parser);
10795 /* Parse a namespace-alias-definition.
10797 namespace-alias-definition:
10798 namespace identifier = qualified-namespace-specifier ; */
10801 cp_parser_namespace_alias_definition (cp_parser* parser)
10804 tree namespace_specifier;
10806 /* Look for the `namespace' keyword. */
10807 cp_parser_require_keyword (parser, RID_NAMESPACE, "`namespace'");
10808 /* Look for the identifier. */
10809 identifier = cp_parser_identifier (parser);
10810 if (identifier == error_mark_node)
10812 /* Look for the `=' token. */
10813 cp_parser_require (parser, CPP_EQ, "`='");
10814 /* Look for the qualified-namespace-specifier. */
10815 namespace_specifier
10816 = cp_parser_qualified_namespace_specifier (parser);
10817 /* Look for the `;' token. */
10818 cp_parser_require (parser, CPP_SEMICOLON, "`;'");
10820 /* Register the alias in the symbol table. */
10821 do_namespace_alias (identifier, namespace_specifier);
10824 /* Parse a qualified-namespace-specifier.
10826 qualified-namespace-specifier:
10827 :: [opt] nested-name-specifier [opt] namespace-name
10829 Returns a NAMESPACE_DECL corresponding to the specified
10833 cp_parser_qualified_namespace_specifier (cp_parser* parser)
10835 /* Look for the optional `::'. */
10836 cp_parser_global_scope_opt (parser,
10837 /*current_scope_valid_p=*/false);
10839 /* Look for the optional nested-name-specifier. */
10840 cp_parser_nested_name_specifier_opt (parser,
10841 /*typename_keyword_p=*/false,
10842 /*check_dependency_p=*/true,
10844 /*is_declaration=*/true);
10846 return cp_parser_namespace_name (parser);
10849 /* Parse a using-declaration, or, if ACCESS_DECLARATION_P is true, an
10850 access declaration.
10853 using typename [opt] :: [opt] nested-name-specifier unqualified-id ;
10854 using :: unqualified-id ;
10856 access-declaration:
10862 cp_parser_using_declaration (cp_parser* parser,
10863 bool access_declaration_p)
10866 bool typename_p = false;
10867 bool global_scope_p;
10872 if (access_declaration_p)
10873 cp_parser_parse_tentatively (parser);
10876 /* Look for the `using' keyword. */
10877 cp_parser_require_keyword (parser, RID_USING, "`using'");
10879 /* Peek at the next token. */
10880 token = cp_lexer_peek_token (parser->lexer);
10881 /* See if it's `typename'. */
10882 if (token->keyword == RID_TYPENAME)
10884 /* Remember that we've seen it. */
10886 /* Consume the `typename' token. */
10887 cp_lexer_consume_token (parser->lexer);
10891 /* Look for the optional global scope qualification. */
10893 = (cp_parser_global_scope_opt (parser,
10894 /*current_scope_valid_p=*/false)
10897 /* If we saw `typename', or didn't see `::', then there must be a
10898 nested-name-specifier present. */
10899 if (typename_p || !global_scope_p)
10900 qscope = cp_parser_nested_name_specifier (parser, typename_p,
10901 /*check_dependency_p=*/true,
10903 /*is_declaration=*/true);
10904 /* Otherwise, we could be in either of the two productions. In that
10905 case, treat the nested-name-specifier as optional. */
10907 qscope = cp_parser_nested_name_specifier_opt (parser,
10908 /*typename_keyword_p=*/false,
10909 /*check_dependency_p=*/true,
10911 /*is_declaration=*/true);
10913 qscope = global_namespace;
10915 if (access_declaration_p && cp_parser_error_occurred (parser))
10916 /* Something has already gone wrong; there's no need to parse
10917 further. Since an error has occurred, the return value of
10918 cp_parser_parse_definitely will be false, as required. */
10919 return cp_parser_parse_definitely (parser);
10921 /* Parse the unqualified-id. */
10922 identifier = cp_parser_unqualified_id (parser,
10923 /*template_keyword_p=*/false,
10924 /*check_dependency_p=*/true,
10925 /*declarator_p=*/true,
10926 /*optional_p=*/false);
10928 if (access_declaration_p)
10930 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
10931 cp_parser_simulate_error (parser);
10932 if (!cp_parser_parse_definitely (parser))
10936 /* The function we call to handle a using-declaration is different
10937 depending on what scope we are in. */
10938 if (qscope == error_mark_node || identifier == error_mark_node)
10940 else if (TREE_CODE (identifier) != IDENTIFIER_NODE
10941 && TREE_CODE (identifier) != BIT_NOT_EXPR)
10942 /* [namespace.udecl]
10944 A using declaration shall not name a template-id. */
10945 error ("a template-id may not appear in a using-declaration");
10948 if (at_class_scope_p ())
10950 /* Create the USING_DECL. */
10951 decl = do_class_using_decl (parser->scope, identifier);
10952 /* Add it to the list of members in this class. */
10953 finish_member_declaration (decl);
10957 decl = cp_parser_lookup_name_simple (parser, identifier);
10958 if (decl == error_mark_node)
10959 cp_parser_name_lookup_error (parser, identifier, decl, NULL);
10960 else if (!at_namespace_scope_p ())
10961 do_local_using_decl (decl, qscope, identifier);
10963 do_toplevel_using_decl (decl, qscope, identifier);
10967 /* Look for the final `;'. */
10968 cp_parser_require (parser, CPP_SEMICOLON, "`;'");
10973 /* Parse a using-directive.
10976 using namespace :: [opt] nested-name-specifier [opt]
10977 namespace-name ; */
10980 cp_parser_using_directive (cp_parser* parser)
10982 tree namespace_decl;
10985 /* Look for the `using' keyword. */
10986 cp_parser_require_keyword (parser, RID_USING, "`using'");
10987 /* And the `namespace' keyword. */
10988 cp_parser_require_keyword (parser, RID_NAMESPACE, "`namespace'");
10989 /* Look for the optional `::' operator. */
10990 cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/false);
10991 /* And the optional nested-name-specifier. */
10992 cp_parser_nested_name_specifier_opt (parser,
10993 /*typename_keyword_p=*/false,
10994 /*check_dependency_p=*/true,
10996 /*is_declaration=*/true);
10997 /* Get the namespace being used. */
10998 namespace_decl = cp_parser_namespace_name (parser);
10999 /* And any specified attributes. */
11000 attribs = cp_parser_attributes_opt (parser);
11001 /* Update the symbol table. */
11002 parse_using_directive (namespace_decl, attribs);
11003 /* Look for the final `;'. */
11004 cp_parser_require (parser, CPP_SEMICOLON, "`;'");
11007 /* Parse an asm-definition.
11010 asm ( string-literal ) ;
11015 asm volatile [opt] ( string-literal ) ;
11016 asm volatile [opt] ( string-literal : asm-operand-list [opt] ) ;
11017 asm volatile [opt] ( string-literal : asm-operand-list [opt]
11018 : asm-operand-list [opt] ) ;
11019 asm volatile [opt] ( string-literal : asm-operand-list [opt]
11020 : asm-operand-list [opt]
11021 : asm-operand-list [opt] ) ; */
11024 cp_parser_asm_definition (cp_parser* parser)
11027 tree outputs = NULL_TREE;
11028 tree inputs = NULL_TREE;
11029 tree clobbers = NULL_TREE;
11031 bool volatile_p = false;
11032 bool extended_p = false;
11034 /* Look for the `asm' keyword. */
11035 cp_parser_require_keyword (parser, RID_ASM, "`asm'");
11036 /* See if the next token is `volatile'. */
11037 if (cp_parser_allow_gnu_extensions_p (parser)
11038 && cp_lexer_next_token_is_keyword (parser->lexer, RID_VOLATILE))
11040 /* Remember that we saw the `volatile' keyword. */
11042 /* Consume the token. */
11043 cp_lexer_consume_token (parser->lexer);
11045 /* Look for the opening `('. */
11046 if (!cp_parser_require (parser, CPP_OPEN_PAREN, "`('"))
11048 /* Look for the string. */
11049 string = cp_parser_string_literal (parser, false, false);
11050 if (string == error_mark_node)
11052 cp_parser_skip_to_closing_parenthesis (parser, true, false,
11053 /*consume_paren=*/true);
11057 /* If we're allowing GNU extensions, check for the extended assembly
11058 syntax. Unfortunately, the `:' tokens need not be separated by
11059 a space in C, and so, for compatibility, we tolerate that here
11060 too. Doing that means that we have to treat the `::' operator as
11062 if (cp_parser_allow_gnu_extensions_p (parser)
11063 && parser->in_function_body
11064 && (cp_lexer_next_token_is (parser->lexer, CPP_COLON)
11065 || cp_lexer_next_token_is (parser->lexer, CPP_SCOPE)))
11067 bool inputs_p = false;
11068 bool clobbers_p = false;
11070 /* The extended syntax was used. */
11073 /* Look for outputs. */
11074 if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
11076 /* Consume the `:'. */
11077 cp_lexer_consume_token (parser->lexer);
11078 /* Parse the output-operands. */
11079 if (cp_lexer_next_token_is_not (parser->lexer,
11081 && cp_lexer_next_token_is_not (parser->lexer,
11083 && cp_lexer_next_token_is_not (parser->lexer,
11085 outputs = cp_parser_asm_operand_list (parser);
11087 /* If the next token is `::', there are no outputs, and the
11088 next token is the beginning of the inputs. */
11089 else if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
11090 /* The inputs are coming next. */
11093 /* Look for inputs. */
11095 || cp_lexer_next_token_is (parser->lexer, CPP_COLON))
11097 /* Consume the `:' or `::'. */
11098 cp_lexer_consume_token (parser->lexer);
11099 /* Parse the output-operands. */
11100 if (cp_lexer_next_token_is_not (parser->lexer,
11102 && cp_lexer_next_token_is_not (parser->lexer,
11104 inputs = cp_parser_asm_operand_list (parser);
11106 else if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
11107 /* The clobbers are coming next. */
11110 /* Look for clobbers. */
11112 || cp_lexer_next_token_is (parser->lexer, CPP_COLON))
11114 /* Consume the `:' or `::'. */
11115 cp_lexer_consume_token (parser->lexer);
11116 /* Parse the clobbers. */
11117 if (cp_lexer_next_token_is_not (parser->lexer,
11119 clobbers = cp_parser_asm_clobber_list (parser);
11122 /* Look for the closing `)'. */
11123 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"))
11124 cp_parser_skip_to_closing_parenthesis (parser, true, false,
11125 /*consume_paren=*/true);
11126 cp_parser_require (parser, CPP_SEMICOLON, "`;'");
11128 /* Create the ASM_EXPR. */
11129 if (parser->in_function_body)
11131 asm_stmt = finish_asm_stmt (volatile_p, string, outputs,
11133 /* If the extended syntax was not used, mark the ASM_EXPR. */
11136 tree temp = asm_stmt;
11137 if (TREE_CODE (temp) == CLEANUP_POINT_EXPR)
11138 temp = TREE_OPERAND (temp, 0);
11140 ASM_INPUT_P (temp) = 1;
11144 cgraph_add_asm_node (string);
11147 /* Declarators [gram.dcl.decl] */
11149 /* Parse an init-declarator.
11152 declarator initializer [opt]
11157 declarator asm-specification [opt] attributes [opt] initializer [opt]
11159 function-definition:
11160 decl-specifier-seq [opt] declarator ctor-initializer [opt]
11162 decl-specifier-seq [opt] declarator function-try-block
11166 function-definition:
11167 __extension__ function-definition
11169 The DECL_SPECIFIERS apply to this declarator. Returns a
11170 representation of the entity declared. If MEMBER_P is TRUE, then
11171 this declarator appears in a class scope. The new DECL created by
11172 this declarator is returned.
11174 The CHECKS are access checks that should be performed once we know
11175 what entity is being declared (and, therefore, what classes have
11178 If FUNCTION_DEFINITION_ALLOWED_P then we handle the declarator and
11179 for a function-definition here as well. If the declarator is a
11180 declarator for a function-definition, *FUNCTION_DEFINITION_P will
11181 be TRUE upon return. By that point, the function-definition will
11182 have been completely parsed.
11184 FUNCTION_DEFINITION_P may be NULL if FUNCTION_DEFINITION_ALLOWED_P
11188 cp_parser_init_declarator (cp_parser* parser,
11189 cp_decl_specifier_seq *decl_specifiers,
11190 VEC (deferred_access_check,gc)* checks,
11191 bool function_definition_allowed_p,
11193 int declares_class_or_enum,
11194 bool* function_definition_p)
11197 cp_declarator *declarator;
11198 tree prefix_attributes;
11200 tree asm_specification;
11202 tree decl = NULL_TREE;
11204 bool is_initialized;
11205 /* Only valid if IS_INITIALIZED is true. In that case, CPP_EQ if
11206 initialized with "= ..", CPP_OPEN_PAREN if initialized with
11208 enum cpp_ttype initialization_kind;
11209 bool is_parenthesized_init = false;
11210 bool is_non_constant_init;
11211 int ctor_dtor_or_conv_p;
11213 tree pushed_scope = NULL;
11215 /* Gather the attributes that were provided with the
11216 decl-specifiers. */
11217 prefix_attributes = decl_specifiers->attributes;
11219 /* Assume that this is not the declarator for a function
11221 if (function_definition_p)
11222 *function_definition_p = false;
11224 /* Defer access checks while parsing the declarator; we cannot know
11225 what names are accessible until we know what is being
11227 resume_deferring_access_checks ();
11229 /* Parse the declarator. */
11231 = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
11232 &ctor_dtor_or_conv_p,
11233 /*parenthesized_p=*/NULL,
11234 /*member_p=*/false);
11235 /* Gather up the deferred checks. */
11236 stop_deferring_access_checks ();
11238 /* If the DECLARATOR was erroneous, there's no need to go
11240 if (declarator == cp_error_declarator)
11241 return error_mark_node;
11243 /* Check that the number of template-parameter-lists is OK. */
11244 if (!cp_parser_check_declarator_template_parameters (parser, declarator))
11245 return error_mark_node;
11247 if (declares_class_or_enum & 2)
11248 cp_parser_check_for_definition_in_return_type (declarator,
11249 decl_specifiers->type);
11251 /* Figure out what scope the entity declared by the DECLARATOR is
11252 located in. `grokdeclarator' sometimes changes the scope, so
11253 we compute it now. */
11254 scope = get_scope_of_declarator (declarator);
11256 /* If we're allowing GNU extensions, look for an asm-specification
11258 if (cp_parser_allow_gnu_extensions_p (parser))
11260 /* Look for an asm-specification. */
11261 asm_specification = cp_parser_asm_specification_opt (parser);
11262 /* And attributes. */
11263 attributes = cp_parser_attributes_opt (parser);
11267 asm_specification = NULL_TREE;
11268 attributes = NULL_TREE;
11271 /* Peek at the next token. */
11272 token = cp_lexer_peek_token (parser->lexer);
11273 /* Check to see if the token indicates the start of a
11274 function-definition. */
11275 if (cp_parser_token_starts_function_definition_p (token))
11277 if (!function_definition_allowed_p)
11279 /* If a function-definition should not appear here, issue an
11281 cp_parser_error (parser,
11282 "a function-definition is not allowed here");
11283 return error_mark_node;
11287 /* Neither attributes nor an asm-specification are allowed
11288 on a function-definition. */
11289 if (asm_specification)
11290 error ("an asm-specification is not allowed on a function-definition");
11292 error ("attributes are not allowed on a function-definition");
11293 /* This is a function-definition. */
11294 *function_definition_p = true;
11296 /* Parse the function definition. */
11298 decl = cp_parser_save_member_function_body (parser,
11301 prefix_attributes);
11304 = (cp_parser_function_definition_from_specifiers_and_declarator
11305 (parser, decl_specifiers, prefix_attributes, declarator));
11313 Only in function declarations for constructors, destructors, and
11314 type conversions can the decl-specifier-seq be omitted.
11316 We explicitly postpone this check past the point where we handle
11317 function-definitions because we tolerate function-definitions
11318 that are missing their return types in some modes. */
11319 if (!decl_specifiers->any_specifiers_p && ctor_dtor_or_conv_p <= 0)
11321 cp_parser_error (parser,
11322 "expected constructor, destructor, or type conversion");
11323 return error_mark_node;
11326 /* An `=' or an `(' indicates an initializer. */
11327 if (token->type == CPP_EQ
11328 || token->type == CPP_OPEN_PAREN)
11330 is_initialized = true;
11331 initialization_kind = token->type;
11335 /* If the init-declarator isn't initialized and isn't followed by a
11336 `,' or `;', it's not a valid init-declarator. */
11337 if (token->type != CPP_COMMA
11338 && token->type != CPP_SEMICOLON)
11340 cp_parser_error (parser, "expected initializer");
11341 return error_mark_node;
11343 is_initialized = false;
11344 initialization_kind = CPP_EOF;
11347 /* Because start_decl has side-effects, we should only call it if we
11348 know we're going ahead. By this point, we know that we cannot
11349 possibly be looking at any other construct. */
11350 cp_parser_commit_to_tentative_parse (parser);
11352 /* If the decl specifiers were bad, issue an error now that we're
11353 sure this was intended to be a declarator. Then continue
11354 declaring the variable(s), as int, to try to cut down on further
11356 if (decl_specifiers->any_specifiers_p
11357 && decl_specifiers->type == error_mark_node)
11359 cp_parser_error (parser, "invalid type in declaration");
11360 decl_specifiers->type = integer_type_node;
11363 /* Check to see whether or not this declaration is a friend. */
11364 friend_p = cp_parser_friend_p (decl_specifiers);
11366 /* Enter the newly declared entry in the symbol table. If we're
11367 processing a declaration in a class-specifier, we wait until
11368 after processing the initializer. */
11371 if (parser->in_unbraced_linkage_specification_p)
11372 decl_specifiers->storage_class = sc_extern;
11373 decl = start_decl (declarator, decl_specifiers,
11374 is_initialized, attributes, prefix_attributes,
11378 /* Enter the SCOPE. That way unqualified names appearing in the
11379 initializer will be looked up in SCOPE. */
11380 pushed_scope = push_scope (scope);
11382 /* Perform deferred access control checks, now that we know in which
11383 SCOPE the declared entity resides. */
11384 if (!member_p && decl)
11386 tree saved_current_function_decl = NULL_TREE;
11388 /* If the entity being declared is a function, pretend that we
11389 are in its scope. If it is a `friend', it may have access to
11390 things that would not otherwise be accessible. */
11391 if (TREE_CODE (decl) == FUNCTION_DECL)
11393 saved_current_function_decl = current_function_decl;
11394 current_function_decl = decl;
11397 /* Perform access checks for template parameters. */
11398 cp_parser_perform_template_parameter_access_checks (checks);
11400 /* Perform the access control checks for the declarator and the
11401 the decl-specifiers. */
11402 perform_deferred_access_checks ();
11404 /* Restore the saved value. */
11405 if (TREE_CODE (decl) == FUNCTION_DECL)
11406 current_function_decl = saved_current_function_decl;
11409 /* Parse the initializer. */
11410 initializer = NULL_TREE;
11411 is_parenthesized_init = false;
11412 is_non_constant_init = true;
11413 if (is_initialized)
11415 if (function_declarator_p (declarator))
11417 if (initialization_kind == CPP_EQ)
11418 initializer = cp_parser_pure_specifier (parser);
11421 /* If the declaration was erroneous, we don't really
11422 know what the user intended, so just silently
11423 consume the initializer. */
11424 if (decl != error_mark_node)
11425 error ("initializer provided for function");
11426 cp_parser_skip_to_closing_parenthesis (parser,
11427 /*recovering=*/true,
11428 /*or_comma=*/false,
11429 /*consume_paren=*/true);
11433 initializer = cp_parser_initializer (parser,
11434 &is_parenthesized_init,
11435 &is_non_constant_init);
11438 /* The old parser allows attributes to appear after a parenthesized
11439 initializer. Mark Mitchell proposed removing this functionality
11440 on the GCC mailing lists on 2002-08-13. This parser accepts the
11441 attributes -- but ignores them. */
11442 if (cp_parser_allow_gnu_extensions_p (parser) && is_parenthesized_init)
11443 if (cp_parser_attributes_opt (parser))
11444 warning (OPT_Wattributes,
11445 "attributes after parenthesized initializer ignored");
11447 /* For an in-class declaration, use `grokfield' to create the
11453 pop_scope (pushed_scope);
11454 pushed_scope = false;
11456 decl = grokfield (declarator, decl_specifiers,
11457 initializer, !is_non_constant_init,
11458 /*asmspec=*/NULL_TREE,
11459 prefix_attributes);
11460 if (decl && TREE_CODE (decl) == FUNCTION_DECL)
11461 cp_parser_save_default_args (parser, decl);
11464 /* Finish processing the declaration. But, skip friend
11466 if (!friend_p && decl && decl != error_mark_node)
11468 cp_finish_decl (decl,
11469 initializer, !is_non_constant_init,
11471 /* If the initializer is in parentheses, then this is
11472 a direct-initialization, which means that an
11473 `explicit' constructor is OK. Otherwise, an
11474 `explicit' constructor cannot be used. */
11475 ((is_parenthesized_init || !is_initialized)
11476 ? 0 : LOOKUP_ONLYCONVERTING));
11478 if (!friend_p && pushed_scope)
11479 pop_scope (pushed_scope);
11484 /* Parse a declarator.
11488 ptr-operator declarator
11490 abstract-declarator:
11491 ptr-operator abstract-declarator [opt]
11492 direct-abstract-declarator
11497 attributes [opt] direct-declarator
11498 attributes [opt] ptr-operator declarator
11500 abstract-declarator:
11501 attributes [opt] ptr-operator abstract-declarator [opt]
11502 attributes [opt] direct-abstract-declarator
11504 If CTOR_DTOR_OR_CONV_P is not NULL, *CTOR_DTOR_OR_CONV_P is used to
11505 detect constructor, destructor or conversion operators. It is set
11506 to -1 if the declarator is a name, and +1 if it is a
11507 function. Otherwise it is set to zero. Usually you just want to
11508 test for >0, but internally the negative value is used.
11510 (The reason for CTOR_DTOR_OR_CONV_P is that a declaration must have
11511 a decl-specifier-seq unless it declares a constructor, destructor,
11512 or conversion. It might seem that we could check this condition in
11513 semantic analysis, rather than parsing, but that makes it difficult
11514 to handle something like `f()'. We want to notice that there are
11515 no decl-specifiers, and therefore realize that this is an
11516 expression, not a declaration.)
11518 If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to true iff
11519 the declarator is a direct-declarator of the form "(...)".
11521 MEMBER_P is true iff this declarator is a member-declarator. */
11523 static cp_declarator *
11524 cp_parser_declarator (cp_parser* parser,
11525 cp_parser_declarator_kind dcl_kind,
11526 int* ctor_dtor_or_conv_p,
11527 bool* parenthesized_p,
11531 cp_declarator *declarator;
11532 enum tree_code code;
11533 cp_cv_quals cv_quals;
11535 tree attributes = NULL_TREE;
11537 /* Assume this is not a constructor, destructor, or type-conversion
11539 if (ctor_dtor_or_conv_p)
11540 *ctor_dtor_or_conv_p = 0;
11542 if (cp_parser_allow_gnu_extensions_p (parser))
11543 attributes = cp_parser_attributes_opt (parser);
11545 /* Peek at the next token. */
11546 token = cp_lexer_peek_token (parser->lexer);
11548 /* Check for the ptr-operator production. */
11549 cp_parser_parse_tentatively (parser);
11550 /* Parse the ptr-operator. */
11551 code = cp_parser_ptr_operator (parser,
11554 /* If that worked, then we have a ptr-operator. */
11555 if (cp_parser_parse_definitely (parser))
11557 /* If a ptr-operator was found, then this declarator was not
11559 if (parenthesized_p)
11560 *parenthesized_p = true;
11561 /* The dependent declarator is optional if we are parsing an
11562 abstract-declarator. */
11563 if (dcl_kind != CP_PARSER_DECLARATOR_NAMED)
11564 cp_parser_parse_tentatively (parser);
11566 /* Parse the dependent declarator. */
11567 declarator = cp_parser_declarator (parser, dcl_kind,
11568 /*ctor_dtor_or_conv_p=*/NULL,
11569 /*parenthesized_p=*/NULL,
11570 /*member_p=*/false);
11572 /* If we are parsing an abstract-declarator, we must handle the
11573 case where the dependent declarator is absent. */
11574 if (dcl_kind != CP_PARSER_DECLARATOR_NAMED
11575 && !cp_parser_parse_definitely (parser))
11578 /* Build the representation of the ptr-operator. */
11580 declarator = make_ptrmem_declarator (cv_quals,
11583 else if (code == INDIRECT_REF)
11584 declarator = make_pointer_declarator (cv_quals, declarator);
11586 declarator = make_reference_declarator (cv_quals, declarator);
11588 /* Everything else is a direct-declarator. */
11591 if (parenthesized_p)
11592 *parenthesized_p = cp_lexer_next_token_is (parser->lexer,
11594 declarator = cp_parser_direct_declarator (parser, dcl_kind,
11595 ctor_dtor_or_conv_p,
11599 if (attributes && declarator && declarator != cp_error_declarator)
11600 declarator->attributes = attributes;
11605 /* Parse a direct-declarator or direct-abstract-declarator.
11609 direct-declarator ( parameter-declaration-clause )
11610 cv-qualifier-seq [opt]
11611 exception-specification [opt]
11612 direct-declarator [ constant-expression [opt] ]
11615 direct-abstract-declarator:
11616 direct-abstract-declarator [opt]
11617 ( parameter-declaration-clause )
11618 cv-qualifier-seq [opt]
11619 exception-specification [opt]
11620 direct-abstract-declarator [opt] [ constant-expression [opt] ]
11621 ( abstract-declarator )
11623 Returns a representation of the declarator. DCL_KIND is
11624 CP_PARSER_DECLARATOR_ABSTRACT, if we are parsing a
11625 direct-abstract-declarator. It is CP_PARSER_DECLARATOR_NAMED, if
11626 we are parsing a direct-declarator. It is
11627 CP_PARSER_DECLARATOR_EITHER, if we can accept either - in the case
11628 of ambiguity we prefer an abstract declarator, as per
11629 [dcl.ambig.res]. CTOR_DTOR_OR_CONV_P and MEMBER_P are as for
11630 cp_parser_declarator. */
11632 static cp_declarator *
11633 cp_parser_direct_declarator (cp_parser* parser,
11634 cp_parser_declarator_kind dcl_kind,
11635 int* ctor_dtor_or_conv_p,
11639 cp_declarator *declarator = NULL;
11640 tree scope = NULL_TREE;
11641 bool saved_default_arg_ok_p = parser->default_arg_ok_p;
11642 bool saved_in_declarator_p = parser->in_declarator_p;
11644 tree pushed_scope = NULL_TREE;
11648 /* Peek at the next token. */
11649 token = cp_lexer_peek_token (parser->lexer);
11650 if (token->type == CPP_OPEN_PAREN)
11652 /* This is either a parameter-declaration-clause, or a
11653 parenthesized declarator. When we know we are parsing a
11654 named declarator, it must be a parenthesized declarator
11655 if FIRST is true. For instance, `(int)' is a
11656 parameter-declaration-clause, with an omitted
11657 direct-abstract-declarator. But `((*))', is a
11658 parenthesized abstract declarator. Finally, when T is a
11659 template parameter `(T)' is a
11660 parameter-declaration-clause, and not a parenthesized
11663 We first try and parse a parameter-declaration-clause,
11664 and then try a nested declarator (if FIRST is true).
11666 It is not an error for it not to be a
11667 parameter-declaration-clause, even when FIRST is
11673 The first is the declaration of a function while the
11674 second is a the definition of a variable, including its
11677 Having seen only the parenthesis, we cannot know which of
11678 these two alternatives should be selected. Even more
11679 complex are examples like:
11684 The former is a function-declaration; the latter is a
11685 variable initialization.
11687 Thus again, we try a parameter-declaration-clause, and if
11688 that fails, we back out and return. */
11690 if (!first || dcl_kind != CP_PARSER_DECLARATOR_NAMED)
11692 cp_parameter_declarator *params;
11693 unsigned saved_num_template_parameter_lists;
11695 /* In a member-declarator, the only valid interpretation
11696 of a parenthesis is the start of a
11697 parameter-declaration-clause. (It is invalid to
11698 initialize a static data member with a parenthesized
11699 initializer; only the "=" form of initialization is
11702 cp_parser_parse_tentatively (parser);
11704 /* Consume the `('. */
11705 cp_lexer_consume_token (parser->lexer);
11708 /* If this is going to be an abstract declarator, we're
11709 in a declarator and we can't have default args. */
11710 parser->default_arg_ok_p = false;
11711 parser->in_declarator_p = true;
11714 /* Inside the function parameter list, surrounding
11715 template-parameter-lists do not apply. */
11716 saved_num_template_parameter_lists
11717 = parser->num_template_parameter_lists;
11718 parser->num_template_parameter_lists = 0;
11720 /* Parse the parameter-declaration-clause. */
11721 params = cp_parser_parameter_declaration_clause (parser);
11723 parser->num_template_parameter_lists
11724 = saved_num_template_parameter_lists;
11726 /* If all went well, parse the cv-qualifier-seq and the
11727 exception-specification. */
11728 if (member_p || cp_parser_parse_definitely (parser))
11730 cp_cv_quals cv_quals;
11731 tree exception_specification;
11733 if (ctor_dtor_or_conv_p)
11734 *ctor_dtor_or_conv_p = *ctor_dtor_or_conv_p < 0;
11736 /* Consume the `)'. */
11737 cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
11739 /* Parse the cv-qualifier-seq. */
11740 cv_quals = cp_parser_cv_qualifier_seq_opt (parser);
11741 /* And the exception-specification. */
11742 exception_specification
11743 = cp_parser_exception_specification_opt (parser);
11745 /* Create the function-declarator. */
11746 declarator = make_call_declarator (declarator,
11749 exception_specification);
11750 /* Any subsequent parameter lists are to do with
11751 return type, so are not those of the declared
11753 parser->default_arg_ok_p = false;
11755 /* Repeat the main loop. */
11760 /* If this is the first, we can try a parenthesized
11764 bool saved_in_type_id_in_expr_p;
11766 parser->default_arg_ok_p = saved_default_arg_ok_p;
11767 parser->in_declarator_p = saved_in_declarator_p;
11769 /* Consume the `('. */
11770 cp_lexer_consume_token (parser->lexer);
11771 /* Parse the nested declarator. */
11772 saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p;
11773 parser->in_type_id_in_expr_p = true;
11775 = cp_parser_declarator (parser, dcl_kind, ctor_dtor_or_conv_p,
11776 /*parenthesized_p=*/NULL,
11778 parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
11780 /* Expect a `)'. */
11781 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"))
11782 declarator = cp_error_declarator;
11783 if (declarator == cp_error_declarator)
11786 goto handle_declarator;
11788 /* Otherwise, we must be done. */
11792 else if ((!first || dcl_kind != CP_PARSER_DECLARATOR_NAMED)
11793 && token->type == CPP_OPEN_SQUARE)
11795 /* Parse an array-declarator. */
11798 if (ctor_dtor_or_conv_p)
11799 *ctor_dtor_or_conv_p = 0;
11802 parser->default_arg_ok_p = false;
11803 parser->in_declarator_p = true;
11804 /* Consume the `['. */
11805 cp_lexer_consume_token (parser->lexer);
11806 /* Peek at the next token. */
11807 token = cp_lexer_peek_token (parser->lexer);
11808 /* If the next token is `]', then there is no
11809 constant-expression. */
11810 if (token->type != CPP_CLOSE_SQUARE)
11812 bool non_constant_p;
11815 = cp_parser_constant_expression (parser,
11816 /*allow_non_constant=*/true,
11818 if (!non_constant_p)
11819 bounds = fold_non_dependent_expr (bounds);
11820 /* Normally, the array bound must be an integral constant
11821 expression. However, as an extension, we allow VLAs
11822 in function scopes. */
11823 else if (!parser->in_function_body)
11825 error ("array bound is not an integer constant");
11826 bounds = error_mark_node;
11830 bounds = NULL_TREE;
11831 /* Look for the closing `]'. */
11832 if (!cp_parser_require (parser, CPP_CLOSE_SQUARE, "`]'"))
11834 declarator = cp_error_declarator;
11838 declarator = make_array_declarator (declarator, bounds);
11840 else if (first && dcl_kind != CP_PARSER_DECLARATOR_ABSTRACT)
11842 tree qualifying_scope;
11843 tree unqualified_name;
11844 special_function_kind sfk;
11847 /* Parse a declarator-id */
11848 abstract_ok = (dcl_kind == CP_PARSER_DECLARATOR_EITHER);
11850 cp_parser_parse_tentatively (parser);
11852 = cp_parser_declarator_id (parser, /*optional_p=*/abstract_ok);
11853 qualifying_scope = parser->scope;
11856 if (!cp_parser_parse_definitely (parser))
11857 unqualified_name = error_mark_node;
11858 else if (unqualified_name
11859 && (qualifying_scope
11860 || (TREE_CODE (unqualified_name)
11861 != IDENTIFIER_NODE)))
11863 cp_parser_error (parser, "expected unqualified-id");
11864 unqualified_name = error_mark_node;
11868 if (!unqualified_name)
11870 if (unqualified_name == error_mark_node)
11872 declarator = cp_error_declarator;
11876 if (qualifying_scope && at_namespace_scope_p ()
11877 && TREE_CODE (qualifying_scope) == TYPENAME_TYPE)
11879 /* In the declaration of a member of a template class
11880 outside of the class itself, the SCOPE will sometimes
11881 be a TYPENAME_TYPE. For example, given:
11883 template <typename T>
11884 int S<T>::R::i = 3;
11886 the SCOPE will be a TYPENAME_TYPE for `S<T>::R'. In
11887 this context, we must resolve S<T>::R to an ordinary
11888 type, rather than a typename type.
11890 The reason we normally avoid resolving TYPENAME_TYPEs
11891 is that a specialization of `S' might render
11892 `S<T>::R' not a type. However, if `S' is
11893 specialized, then this `i' will not be used, so there
11894 is no harm in resolving the types here. */
11897 /* Resolve the TYPENAME_TYPE. */
11898 type = resolve_typename_type (qualifying_scope,
11899 /*only_current_p=*/false);
11900 /* If that failed, the declarator is invalid. */
11901 if (type == error_mark_node)
11902 error ("%<%T::%D%> is not a type",
11903 TYPE_CONTEXT (qualifying_scope),
11904 TYPE_IDENTIFIER (qualifying_scope));
11905 qualifying_scope = type;
11909 if (unqualified_name)
11913 if (qualifying_scope
11914 && CLASS_TYPE_P (qualifying_scope))
11915 class_type = qualifying_scope;
11917 class_type = current_class_type;
11919 if (TREE_CODE (unqualified_name) == TYPE_DECL)
11921 tree name_type = TREE_TYPE (unqualified_name);
11922 if (class_type && same_type_p (name_type, class_type))
11924 if (qualifying_scope
11925 && CLASSTYPE_USE_TEMPLATE (name_type))
11927 error ("invalid use of constructor as a template");
11928 inform ("use %<%T::%D%> instead of %<%T::%D%> to "
11929 "name the constructor in a qualified name",
11931 DECL_NAME (TYPE_TI_TEMPLATE (class_type)),
11932 class_type, name_type);
11933 declarator = cp_error_declarator;
11937 unqualified_name = constructor_name (class_type);
11941 /* We do not attempt to print the declarator
11942 here because we do not have enough
11943 information about its original syntactic
11945 cp_parser_error (parser, "invalid declarator");
11946 declarator = cp_error_declarator;
11953 if (TREE_CODE (unqualified_name) == BIT_NOT_EXPR)
11954 sfk = sfk_destructor;
11955 else if (IDENTIFIER_TYPENAME_P (unqualified_name))
11956 sfk = sfk_conversion;
11957 else if (/* There's no way to declare a constructor
11958 for an anonymous type, even if the type
11959 got a name for linkage purposes. */
11960 !TYPE_WAS_ANONYMOUS (class_type)
11961 && constructor_name_p (unqualified_name,
11964 unqualified_name = constructor_name (class_type);
11965 sfk = sfk_constructor;
11968 if (ctor_dtor_or_conv_p && sfk != sfk_none)
11969 *ctor_dtor_or_conv_p = -1;
11972 declarator = make_id_declarator (qualifying_scope,
11975 declarator->id_loc = token->location;
11977 handle_declarator:;
11978 scope = get_scope_of_declarator (declarator);
11980 /* Any names that appear after the declarator-id for a
11981 member are looked up in the containing scope. */
11982 pushed_scope = push_scope (scope);
11983 parser->in_declarator_p = true;
11984 if ((ctor_dtor_or_conv_p && *ctor_dtor_or_conv_p)
11985 || (declarator && declarator->kind == cdk_id))
11986 /* Default args are only allowed on function
11988 parser->default_arg_ok_p = saved_default_arg_ok_p;
11990 parser->default_arg_ok_p = false;
11999 /* For an abstract declarator, we might wind up with nothing at this
12000 point. That's an error; the declarator is not optional. */
12002 cp_parser_error (parser, "expected declarator");
12004 /* If we entered a scope, we must exit it now. */
12006 pop_scope (pushed_scope);
12008 parser->default_arg_ok_p = saved_default_arg_ok_p;
12009 parser->in_declarator_p = saved_in_declarator_p;
12014 /* Parse a ptr-operator.
12017 * cv-qualifier-seq [opt]
12019 :: [opt] nested-name-specifier * cv-qualifier-seq [opt]
12024 & cv-qualifier-seq [opt]
12026 Returns INDIRECT_REF if a pointer, or pointer-to-member, was used.
12027 Returns ADDR_EXPR if a reference was used. In the case of a
12028 pointer-to-member, *TYPE is filled in with the TYPE containing the
12029 member. *CV_QUALS is filled in with the cv-qualifier-seq, or
12030 TYPE_UNQUALIFIED, if there are no cv-qualifiers. Returns
12031 ERROR_MARK if an error occurred. */
12033 static enum tree_code
12034 cp_parser_ptr_operator (cp_parser* parser,
12036 cp_cv_quals *cv_quals)
12038 enum tree_code code = ERROR_MARK;
12041 /* Assume that it's not a pointer-to-member. */
12043 /* And that there are no cv-qualifiers. */
12044 *cv_quals = TYPE_UNQUALIFIED;
12046 /* Peek at the next token. */
12047 token = cp_lexer_peek_token (parser->lexer);
12048 /* If it's a `*' or `&' we have a pointer or reference. */
12049 if (token->type == CPP_MULT || token->type == CPP_AND)
12051 /* Remember which ptr-operator we were processing. */
12052 code = (token->type == CPP_AND ? ADDR_EXPR : INDIRECT_REF);
12054 /* Consume the `*' or `&'. */
12055 cp_lexer_consume_token (parser->lexer);
12057 /* A `*' can be followed by a cv-qualifier-seq, and so can a
12058 `&', if we are allowing GNU extensions. (The only qualifier
12059 that can legally appear after `&' is `restrict', but that is
12060 enforced during semantic analysis. */
12061 if (code == INDIRECT_REF
12062 || cp_parser_allow_gnu_extensions_p (parser))
12063 *cv_quals = cp_parser_cv_qualifier_seq_opt (parser);
12067 /* Try the pointer-to-member case. */
12068 cp_parser_parse_tentatively (parser);
12069 /* Look for the optional `::' operator. */
12070 cp_parser_global_scope_opt (parser,
12071 /*current_scope_valid_p=*/false);
12072 /* Look for the nested-name specifier. */
12073 cp_parser_nested_name_specifier (parser,
12074 /*typename_keyword_p=*/false,
12075 /*check_dependency_p=*/true,
12077 /*is_declaration=*/false);
12078 /* If we found it, and the next token is a `*', then we are
12079 indeed looking at a pointer-to-member operator. */
12080 if (!cp_parser_error_occurred (parser)
12081 && cp_parser_require (parser, CPP_MULT, "`*'"))
12083 /* Indicate that the `*' operator was used. */
12084 code = INDIRECT_REF;
12086 if (TREE_CODE (parser->scope) == NAMESPACE_DECL)
12087 error ("%qD is a namespace", parser->scope);
12090 /* The type of which the member is a member is given by the
12092 *type = parser->scope;
12093 /* The next name will not be qualified. */
12094 parser->scope = NULL_TREE;
12095 parser->qualifying_scope = NULL_TREE;
12096 parser->object_scope = NULL_TREE;
12097 /* Look for the optional cv-qualifier-seq. */
12098 *cv_quals = cp_parser_cv_qualifier_seq_opt (parser);
12101 /* If that didn't work we don't have a ptr-operator. */
12102 if (!cp_parser_parse_definitely (parser))
12103 cp_parser_error (parser, "expected ptr-operator");
12109 /* Parse an (optional) cv-qualifier-seq.
12112 cv-qualifier cv-qualifier-seq [opt]
12123 Returns a bitmask representing the cv-qualifiers. */
12126 cp_parser_cv_qualifier_seq_opt (cp_parser* parser)
12128 cp_cv_quals cv_quals = TYPE_UNQUALIFIED;
12133 cp_cv_quals cv_qualifier;
12135 /* Peek at the next token. */
12136 token = cp_lexer_peek_token (parser->lexer);
12137 /* See if it's a cv-qualifier. */
12138 switch (token->keyword)
12141 cv_qualifier = TYPE_QUAL_CONST;
12145 cv_qualifier = TYPE_QUAL_VOLATILE;
12149 cv_qualifier = TYPE_QUAL_RESTRICT;
12153 cv_qualifier = TYPE_UNQUALIFIED;
12160 if (cv_quals & cv_qualifier)
12162 error ("duplicate cv-qualifier");
12163 cp_lexer_purge_token (parser->lexer);
12167 cp_lexer_consume_token (parser->lexer);
12168 cv_quals |= cv_qualifier;
12175 /* Parse a declarator-id.
12179 :: [opt] nested-name-specifier [opt] type-name
12181 In the `id-expression' case, the value returned is as for
12182 cp_parser_id_expression if the id-expression was an unqualified-id.
12183 If the id-expression was a qualified-id, then a SCOPE_REF is
12184 returned. The first operand is the scope (either a NAMESPACE_DECL
12185 or TREE_TYPE), but the second is still just a representation of an
12189 cp_parser_declarator_id (cp_parser* parser, bool optional_p)
12192 /* The expression must be an id-expression. Assume that qualified
12193 names are the names of types so that:
12196 int S<T>::R::i = 3;
12198 will work; we must treat `S<T>::R' as the name of a type.
12199 Similarly, assume that qualified names are templates, where
12203 int S<T>::R<T>::i = 3;
12206 id = cp_parser_id_expression (parser,
12207 /*template_keyword_p=*/false,
12208 /*check_dependency_p=*/false,
12209 /*template_p=*/NULL,
12210 /*declarator_p=*/true,
12212 if (id && BASELINK_P (id))
12213 id = BASELINK_FUNCTIONS (id);
12217 /* Parse a type-id.
12220 type-specifier-seq abstract-declarator [opt]
12222 Returns the TYPE specified. */
12225 cp_parser_type_id (cp_parser* parser)
12227 cp_decl_specifier_seq type_specifier_seq;
12228 cp_declarator *abstract_declarator;
12230 /* Parse the type-specifier-seq. */
12231 cp_parser_type_specifier_seq (parser, /*is_condition=*/false,
12232 &type_specifier_seq);
12233 if (type_specifier_seq.type == error_mark_node)
12234 return error_mark_node;
12236 /* There might or might not be an abstract declarator. */
12237 cp_parser_parse_tentatively (parser);
12238 /* Look for the declarator. */
12239 abstract_declarator
12240 = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_ABSTRACT, NULL,
12241 /*parenthesized_p=*/NULL,
12242 /*member_p=*/false);
12243 /* Check to see if there really was a declarator. */
12244 if (!cp_parser_parse_definitely (parser))
12245 abstract_declarator = NULL;
12247 return groktypename (&type_specifier_seq, abstract_declarator);
12250 /* Parse a type-specifier-seq.
12252 type-specifier-seq:
12253 type-specifier type-specifier-seq [opt]
12257 type-specifier-seq:
12258 attributes type-specifier-seq [opt]
12260 If IS_CONDITION is true, we are at the start of a "condition",
12261 e.g., we've just seen "if (".
12263 Sets *TYPE_SPECIFIER_SEQ to represent the sequence. */
12266 cp_parser_type_specifier_seq (cp_parser* parser,
12268 cp_decl_specifier_seq *type_specifier_seq)
12270 bool seen_type_specifier = false;
12271 cp_parser_flags flags = CP_PARSER_FLAGS_OPTIONAL;
12273 /* Clear the TYPE_SPECIFIER_SEQ. */
12274 clear_decl_specs (type_specifier_seq);
12276 /* Parse the type-specifiers and attributes. */
12279 tree type_specifier;
12280 bool is_cv_qualifier;
12282 /* Check for attributes first. */
12283 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_ATTRIBUTE))
12285 type_specifier_seq->attributes =
12286 chainon (type_specifier_seq->attributes,
12287 cp_parser_attributes_opt (parser));
12291 /* Look for the type-specifier. */
12292 type_specifier = cp_parser_type_specifier (parser,
12294 type_specifier_seq,
12295 /*is_declaration=*/false,
12298 if (!type_specifier)
12300 /* If the first type-specifier could not be found, this is not a
12301 type-specifier-seq at all. */
12302 if (!seen_type_specifier)
12304 cp_parser_error (parser, "expected type-specifier");
12305 type_specifier_seq->type = error_mark_node;
12308 /* If subsequent type-specifiers could not be found, the
12309 type-specifier-seq is complete. */
12313 seen_type_specifier = true;
12314 /* The standard says that a condition can be:
12316 type-specifier-seq declarator = assignment-expression
12323 we should treat the "S" as a declarator, not as a
12324 type-specifier. The standard doesn't say that explicitly for
12325 type-specifier-seq, but it does say that for
12326 decl-specifier-seq in an ordinary declaration. Perhaps it
12327 would be clearer just to allow a decl-specifier-seq here, and
12328 then add a semantic restriction that if any decl-specifiers
12329 that are not type-specifiers appear, the program is invalid. */
12330 if (is_condition && !is_cv_qualifier)
12331 flags |= CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES;
12334 cp_parser_check_decl_spec (type_specifier_seq);
12337 /* Parse a parameter-declaration-clause.
12339 parameter-declaration-clause:
12340 parameter-declaration-list [opt] ... [opt]
12341 parameter-declaration-list , ...
12343 Returns a representation for the parameter declarations. A return
12344 value of NULL indicates a parameter-declaration-clause consisting
12345 only of an ellipsis. */
12347 static cp_parameter_declarator *
12348 cp_parser_parameter_declaration_clause (cp_parser* parser)
12350 cp_parameter_declarator *parameters;
12355 /* Peek at the next token. */
12356 token = cp_lexer_peek_token (parser->lexer);
12357 /* Check for trivial parameter-declaration-clauses. */
12358 if (token->type == CPP_ELLIPSIS)
12360 /* Consume the `...' token. */
12361 cp_lexer_consume_token (parser->lexer);
12364 else if (token->type == CPP_CLOSE_PAREN)
12365 /* There are no parameters. */
12367 #ifndef NO_IMPLICIT_EXTERN_C
12368 if (in_system_header && current_class_type == NULL
12369 && current_lang_name == lang_name_c)
12373 return no_parameters;
12375 /* Check for `(void)', too, which is a special case. */
12376 else if (token->keyword == RID_VOID
12377 && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
12378 == CPP_CLOSE_PAREN))
12380 /* Consume the `void' token. */
12381 cp_lexer_consume_token (parser->lexer);
12382 /* There are no parameters. */
12383 return no_parameters;
12386 /* Parse the parameter-declaration-list. */
12387 parameters = cp_parser_parameter_declaration_list (parser, &is_error);
12388 /* If a parse error occurred while parsing the
12389 parameter-declaration-list, then the entire
12390 parameter-declaration-clause is erroneous. */
12394 /* Peek at the next token. */
12395 token = cp_lexer_peek_token (parser->lexer);
12396 /* If it's a `,', the clause should terminate with an ellipsis. */
12397 if (token->type == CPP_COMMA)
12399 /* Consume the `,'. */
12400 cp_lexer_consume_token (parser->lexer);
12401 /* Expect an ellipsis. */
12403 = (cp_parser_require (parser, CPP_ELLIPSIS, "`...'") != NULL);
12405 /* It might also be `...' if the optional trailing `,' was
12407 else if (token->type == CPP_ELLIPSIS)
12409 /* Consume the `...' token. */
12410 cp_lexer_consume_token (parser->lexer);
12411 /* And remember that we saw it. */
12415 ellipsis_p = false;
12417 /* Finish the parameter list. */
12418 if (parameters && ellipsis_p)
12419 parameters->ellipsis_p = true;
12424 /* Parse a parameter-declaration-list.
12426 parameter-declaration-list:
12427 parameter-declaration
12428 parameter-declaration-list , parameter-declaration
12430 Returns a representation of the parameter-declaration-list, as for
12431 cp_parser_parameter_declaration_clause. However, the
12432 `void_list_node' is never appended to the list. Upon return,
12433 *IS_ERROR will be true iff an error occurred. */
12435 static cp_parameter_declarator *
12436 cp_parser_parameter_declaration_list (cp_parser* parser, bool *is_error)
12438 cp_parameter_declarator *parameters = NULL;
12439 cp_parameter_declarator **tail = ¶meters;
12440 bool saved_in_unbraced_linkage_specification_p;
12442 /* Assume all will go well. */
12444 /* The special considerations that apply to a function within an
12445 unbraced linkage specifications do not apply to the parameters
12446 to the function. */
12447 saved_in_unbraced_linkage_specification_p
12448 = parser->in_unbraced_linkage_specification_p;
12449 parser->in_unbraced_linkage_specification_p = false;
12451 /* Look for more parameters. */
12454 cp_parameter_declarator *parameter;
12455 bool parenthesized_p;
12456 /* Parse the parameter. */
12458 = cp_parser_parameter_declaration (parser,
12459 /*template_parm_p=*/false,
12462 /* If a parse error occurred parsing the parameter declaration,
12463 then the entire parameter-declaration-list is erroneous. */
12470 /* Add the new parameter to the list. */
12472 tail = ¶meter->next;
12474 /* Peek at the next token. */
12475 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN)
12476 || cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS)
12477 /* These are for Objective-C++ */
12478 || cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)
12479 || cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
12480 /* The parameter-declaration-list is complete. */
12482 else if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
12486 /* Peek at the next token. */
12487 token = cp_lexer_peek_nth_token (parser->lexer, 2);
12488 /* If it's an ellipsis, then the list is complete. */
12489 if (token->type == CPP_ELLIPSIS)
12491 /* Otherwise, there must be more parameters. Consume the
12493 cp_lexer_consume_token (parser->lexer);
12494 /* When parsing something like:
12496 int i(float f, double d)
12498 we can tell after seeing the declaration for "f" that we
12499 are not looking at an initialization of a variable "i",
12500 but rather at the declaration of a function "i".
12502 Due to the fact that the parsing of template arguments
12503 (as specified to a template-id) requires backtracking we
12504 cannot use this technique when inside a template argument
12506 if (!parser->in_template_argument_list_p
12507 && !parser->in_type_id_in_expr_p
12508 && cp_parser_uncommitted_to_tentative_parse_p (parser)
12509 /* However, a parameter-declaration of the form
12510 "foat(f)" (which is a valid declaration of a
12511 parameter "f") can also be interpreted as an
12512 expression (the conversion of "f" to "float"). */
12513 && !parenthesized_p)
12514 cp_parser_commit_to_tentative_parse (parser);
12518 cp_parser_error (parser, "expected %<,%> or %<...%>");
12519 if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
12520 cp_parser_skip_to_closing_parenthesis (parser,
12521 /*recovering=*/true,
12522 /*or_comma=*/false,
12523 /*consume_paren=*/false);
12528 parser->in_unbraced_linkage_specification_p
12529 = saved_in_unbraced_linkage_specification_p;
12534 /* Parse a parameter declaration.
12536 parameter-declaration:
12537 decl-specifier-seq declarator
12538 decl-specifier-seq declarator = assignment-expression
12539 decl-specifier-seq abstract-declarator [opt]
12540 decl-specifier-seq abstract-declarator [opt] = assignment-expression
12542 If TEMPLATE_PARM_P is TRUE, then this parameter-declaration
12543 declares a template parameter. (In that case, a non-nested `>'
12544 token encountered during the parsing of the assignment-expression
12545 is not interpreted as a greater-than operator.)
12547 Returns a representation of the parameter, or NULL if an error
12548 occurs. If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to
12549 true iff the declarator is of the form "(p)". */
12551 static cp_parameter_declarator *
12552 cp_parser_parameter_declaration (cp_parser *parser,
12553 bool template_parm_p,
12554 bool *parenthesized_p)
12556 int declares_class_or_enum;
12557 bool greater_than_is_operator_p;
12558 cp_decl_specifier_seq decl_specifiers;
12559 cp_declarator *declarator;
12560 tree default_argument;
12562 const char *saved_message;
12564 /* In a template parameter, `>' is not an operator.
12568 When parsing a default template-argument for a non-type
12569 template-parameter, the first non-nested `>' is taken as the end
12570 of the template parameter-list rather than a greater-than
12572 greater_than_is_operator_p = !template_parm_p;
12574 /* Type definitions may not appear in parameter types. */
12575 saved_message = parser->type_definition_forbidden_message;
12576 parser->type_definition_forbidden_message
12577 = "types may not be defined in parameter types";
12579 /* Parse the declaration-specifiers. */
12580 cp_parser_decl_specifier_seq (parser,
12581 CP_PARSER_FLAGS_NONE,
12583 &declares_class_or_enum);
12584 /* If an error occurred, there's no reason to attempt to parse the
12585 rest of the declaration. */
12586 if (cp_parser_error_occurred (parser))
12588 parser->type_definition_forbidden_message = saved_message;
12592 /* Peek at the next token. */
12593 token = cp_lexer_peek_token (parser->lexer);
12594 /* If the next token is a `)', `,', `=', `>', or `...', then there
12595 is no declarator. */
12596 if (token->type == CPP_CLOSE_PAREN
12597 || token->type == CPP_COMMA
12598 || token->type == CPP_EQ
12599 || token->type == CPP_ELLIPSIS
12600 || token->type == CPP_GREATER)
12603 if (parenthesized_p)
12604 *parenthesized_p = false;
12606 /* Otherwise, there should be a declarator. */
12609 bool saved_default_arg_ok_p = parser->default_arg_ok_p;
12610 parser->default_arg_ok_p = false;
12612 /* After seeing a decl-specifier-seq, if the next token is not a
12613 "(", there is no possibility that the code is a valid
12614 expression. Therefore, if parsing tentatively, we commit at
12616 if (!parser->in_template_argument_list_p
12617 /* In an expression context, having seen:
12621 we cannot be sure whether we are looking at a
12622 function-type (taking a "char" as a parameter) or a cast
12623 of some object of type "char" to "int". */
12624 && !parser->in_type_id_in_expr_p
12625 && cp_parser_uncommitted_to_tentative_parse_p (parser)
12626 && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_PAREN))
12627 cp_parser_commit_to_tentative_parse (parser);
12628 /* Parse the declarator. */
12629 declarator = cp_parser_declarator (parser,
12630 CP_PARSER_DECLARATOR_EITHER,
12631 /*ctor_dtor_or_conv_p=*/NULL,
12633 /*member_p=*/false);
12634 parser->default_arg_ok_p = saved_default_arg_ok_p;
12635 /* After the declarator, allow more attributes. */
12636 decl_specifiers.attributes
12637 = chainon (decl_specifiers.attributes,
12638 cp_parser_attributes_opt (parser));
12641 /* The restriction on defining new types applies only to the type
12642 of the parameter, not to the default argument. */
12643 parser->type_definition_forbidden_message = saved_message;
12645 /* If the next token is `=', then process a default argument. */
12646 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
12648 bool saved_greater_than_is_operator_p;
12649 /* Consume the `='. */
12650 cp_lexer_consume_token (parser->lexer);
12652 /* If we are defining a class, then the tokens that make up the
12653 default argument must be saved and processed later. */
12654 if (!template_parm_p && at_class_scope_p ()
12655 && TYPE_BEING_DEFINED (current_class_type))
12657 unsigned depth = 0;
12658 cp_token *first_token;
12661 /* Add tokens until we have processed the entire default
12662 argument. We add the range [first_token, token). */
12663 first_token = cp_lexer_peek_token (parser->lexer);
12668 /* Peek at the next token. */
12669 token = cp_lexer_peek_token (parser->lexer);
12670 /* What we do depends on what token we have. */
12671 switch (token->type)
12673 /* In valid code, a default argument must be
12674 immediately followed by a `,' `)', or `...'. */
12676 case CPP_CLOSE_PAREN:
12678 /* If we run into a non-nested `;', `}', or `]',
12679 then the code is invalid -- but the default
12680 argument is certainly over. */
12681 case CPP_SEMICOLON:
12682 case CPP_CLOSE_BRACE:
12683 case CPP_CLOSE_SQUARE:
12686 /* Update DEPTH, if necessary. */
12687 else if (token->type == CPP_CLOSE_PAREN
12688 || token->type == CPP_CLOSE_BRACE
12689 || token->type == CPP_CLOSE_SQUARE)
12693 case CPP_OPEN_PAREN:
12694 case CPP_OPEN_SQUARE:
12695 case CPP_OPEN_BRACE:
12700 /* If we see a non-nested `>', and `>' is not an
12701 operator, then it marks the end of the default
12703 if (!depth && !greater_than_is_operator_p)
12707 /* If we run out of tokens, issue an error message. */
12709 case CPP_PRAGMA_EOL:
12710 error ("file ends in default argument");
12716 /* In these cases, we should look for template-ids.
12717 For example, if the default argument is
12718 `X<int, double>()', we need to do name lookup to
12719 figure out whether or not `X' is a template; if
12720 so, the `,' does not end the default argument.
12722 That is not yet done. */
12729 /* If we've reached the end, stop. */
12733 /* Add the token to the token block. */
12734 token = cp_lexer_consume_token (parser->lexer);
12737 /* Create a DEFAULT_ARG to represented the unparsed default
12739 default_argument = make_node (DEFAULT_ARG);
12740 DEFARG_TOKENS (default_argument)
12741 = cp_token_cache_new (first_token, token);
12742 DEFARG_INSTANTIATIONS (default_argument) = NULL;
12744 /* Outside of a class definition, we can just parse the
12745 assignment-expression. */
12748 bool saved_local_variables_forbidden_p;
12750 /* Make sure that PARSER->GREATER_THAN_IS_OPERATOR_P is
12752 saved_greater_than_is_operator_p
12753 = parser->greater_than_is_operator_p;
12754 parser->greater_than_is_operator_p = greater_than_is_operator_p;
12755 /* Local variable names (and the `this' keyword) may not
12756 appear in a default argument. */
12757 saved_local_variables_forbidden_p
12758 = parser->local_variables_forbidden_p;
12759 parser->local_variables_forbidden_p = true;
12760 /* The default argument expression may cause implicitly
12761 defined member functions to be synthesized, which will
12762 result in garbage collection. We must treat this
12763 situation as if we were within the body of function so as
12764 to avoid collecting live data on the stack. */
12766 /* Parse the assignment-expression. */
12767 if (template_parm_p)
12768 push_deferring_access_checks (dk_no_deferred);
12770 = cp_parser_assignment_expression (parser, /*cast_p=*/false);
12771 if (template_parm_p)
12772 pop_deferring_access_checks ();
12773 /* Restore saved state. */
12775 parser->greater_than_is_operator_p
12776 = saved_greater_than_is_operator_p;
12777 parser->local_variables_forbidden_p
12778 = saved_local_variables_forbidden_p;
12780 if (!parser->default_arg_ok_p)
12782 if (!flag_pedantic_errors)
12783 warning (0, "deprecated use of default argument for parameter of non-function");
12786 error ("default arguments are only permitted for function parameters");
12787 default_argument = NULL_TREE;
12792 default_argument = NULL_TREE;
12794 return make_parameter_declarator (&decl_specifiers,
12799 /* Parse a function-body.
12802 compound_statement */
12805 cp_parser_function_body (cp_parser *parser)
12807 cp_parser_compound_statement (parser, NULL, false);
12810 /* Parse a ctor-initializer-opt followed by a function-body. Return
12811 true if a ctor-initializer was present. */
12814 cp_parser_ctor_initializer_opt_and_function_body (cp_parser *parser)
12817 bool ctor_initializer_p;
12819 /* Begin the function body. */
12820 body = begin_function_body ();
12821 /* Parse the optional ctor-initializer. */
12822 ctor_initializer_p = cp_parser_ctor_initializer_opt (parser);
12823 /* Parse the function-body. */
12824 cp_parser_function_body (parser);
12825 /* Finish the function body. */
12826 finish_function_body (body);
12828 return ctor_initializer_p;
12831 /* Parse an initializer.
12834 = initializer-clause
12835 ( expression-list )
12837 Returns an expression representing the initializer. If no
12838 initializer is present, NULL_TREE is returned.
12840 *IS_PARENTHESIZED_INIT is set to TRUE if the `( expression-list )'
12841 production is used, and zero otherwise. *IS_PARENTHESIZED_INIT is
12842 set to FALSE if there is no initializer present. If there is an
12843 initializer, and it is not a constant-expression, *NON_CONSTANT_P
12844 is set to true; otherwise it is set to false. */
12847 cp_parser_initializer (cp_parser* parser, bool* is_parenthesized_init,
12848 bool* non_constant_p)
12853 /* Peek at the next token. */
12854 token = cp_lexer_peek_token (parser->lexer);
12856 /* Let our caller know whether or not this initializer was
12858 *is_parenthesized_init = (token->type == CPP_OPEN_PAREN);
12859 /* Assume that the initializer is constant. */
12860 *non_constant_p = false;
12862 if (token->type == CPP_EQ)
12864 /* Consume the `='. */
12865 cp_lexer_consume_token (parser->lexer);
12866 /* Parse the initializer-clause. */
12867 init = cp_parser_initializer_clause (parser, non_constant_p);
12869 else if (token->type == CPP_OPEN_PAREN)
12870 init = cp_parser_parenthesized_expression_list (parser, false,
12875 /* Anything else is an error. */
12876 cp_parser_error (parser, "expected initializer");
12877 init = error_mark_node;
12883 /* Parse an initializer-clause.
12885 initializer-clause:
12886 assignment-expression
12887 { initializer-list , [opt] }
12890 Returns an expression representing the initializer.
12892 If the `assignment-expression' production is used the value
12893 returned is simply a representation for the expression.
12895 Otherwise, a CONSTRUCTOR is returned. The CONSTRUCTOR_ELTS will be
12896 the elements of the initializer-list (or NULL, if the last
12897 production is used). The TREE_TYPE for the CONSTRUCTOR will be
12898 NULL_TREE. There is no way to detect whether or not the optional
12899 trailing `,' was provided. NON_CONSTANT_P is as for
12900 cp_parser_initializer. */
12903 cp_parser_initializer_clause (cp_parser* parser, bool* non_constant_p)
12907 /* Assume the expression is constant. */
12908 *non_constant_p = false;
12910 /* If it is not a `{', then we are looking at an
12911 assignment-expression. */
12912 if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE))
12915 = cp_parser_constant_expression (parser,
12916 /*allow_non_constant_p=*/true,
12918 if (!*non_constant_p)
12919 initializer = fold_non_dependent_expr (initializer);
12923 /* Consume the `{' token. */
12924 cp_lexer_consume_token (parser->lexer);
12925 /* Create a CONSTRUCTOR to represent the braced-initializer. */
12926 initializer = make_node (CONSTRUCTOR);
12927 /* If it's not a `}', then there is a non-trivial initializer. */
12928 if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_BRACE))
12930 /* Parse the initializer list. */
12931 CONSTRUCTOR_ELTS (initializer)
12932 = cp_parser_initializer_list (parser, non_constant_p);
12933 /* A trailing `,' token is allowed. */
12934 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
12935 cp_lexer_consume_token (parser->lexer);
12937 /* Now, there should be a trailing `}'. */
12938 cp_parser_require (parser, CPP_CLOSE_BRACE, "`}'");
12941 return initializer;
12944 /* Parse an initializer-list.
12948 initializer-list , initializer-clause
12953 identifier : initializer-clause
12954 initializer-list, identifier : initializer-clause
12956 Returns a VEC of constructor_elt. The VALUE of each elt is an expression
12957 for the initializer. If the INDEX of the elt is non-NULL, it is the
12958 IDENTIFIER_NODE naming the field to initialize. NON_CONSTANT_P is
12959 as for cp_parser_initializer. */
12961 static VEC(constructor_elt,gc) *
12962 cp_parser_initializer_list (cp_parser* parser, bool* non_constant_p)
12964 VEC(constructor_elt,gc) *v = NULL;
12966 /* Assume all of the expressions are constant. */
12967 *non_constant_p = false;
12969 /* Parse the rest of the list. */
12975 bool clause_non_constant_p;
12977 /* If the next token is an identifier and the following one is a
12978 colon, we are looking at the GNU designated-initializer
12980 if (cp_parser_allow_gnu_extensions_p (parser)
12981 && cp_lexer_next_token_is (parser->lexer, CPP_NAME)
12982 && cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_COLON)
12984 /* Warn the user that they are using an extension. */
12986 pedwarn ("ISO C++ does not allow designated initializers");
12987 /* Consume the identifier. */
12988 identifier = cp_lexer_consume_token (parser->lexer)->u.value;
12989 /* Consume the `:'. */
12990 cp_lexer_consume_token (parser->lexer);
12993 identifier = NULL_TREE;
12995 /* Parse the initializer. */
12996 initializer = cp_parser_initializer_clause (parser,
12997 &clause_non_constant_p);
12998 /* If any clause is non-constant, so is the entire initializer. */
12999 if (clause_non_constant_p)
13000 *non_constant_p = true;
13002 /* Add it to the vector. */
13003 CONSTRUCTOR_APPEND_ELT(v, identifier, initializer);
13005 /* If the next token is not a comma, we have reached the end of
13007 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
13010 /* Peek at the next token. */
13011 token = cp_lexer_peek_nth_token (parser->lexer, 2);
13012 /* If the next token is a `}', then we're still done. An
13013 initializer-clause can have a trailing `,' after the
13014 initializer-list and before the closing `}'. */
13015 if (token->type == CPP_CLOSE_BRACE)
13018 /* Consume the `,' token. */
13019 cp_lexer_consume_token (parser->lexer);
13025 /* Classes [gram.class] */
13027 /* Parse a class-name.
13033 TYPENAME_KEYWORD_P is true iff the `typename' keyword has been used
13034 to indicate that names looked up in dependent types should be
13035 assumed to be types. TEMPLATE_KEYWORD_P is true iff the `template'
13036 keyword has been used to indicate that the name that appears next
13037 is a template. TAG_TYPE indicates the explicit tag given before
13038 the type name, if any. If CHECK_DEPENDENCY_P is FALSE, names are
13039 looked up in dependent scopes. If CLASS_HEAD_P is TRUE, this class
13040 is the class being defined in a class-head.
13042 Returns the TYPE_DECL representing the class. */
13045 cp_parser_class_name (cp_parser *parser,
13046 bool typename_keyword_p,
13047 bool template_keyword_p,
13048 enum tag_types tag_type,
13049 bool check_dependency_p,
13051 bool is_declaration)
13058 /* All class-names start with an identifier. */
13059 token = cp_lexer_peek_token (parser->lexer);
13060 if (token->type != CPP_NAME && token->type != CPP_TEMPLATE_ID)
13062 cp_parser_error (parser, "expected class-name");
13063 return error_mark_node;
13066 /* PARSER->SCOPE can be cleared when parsing the template-arguments
13067 to a template-id, so we save it here. */
13068 scope = parser->scope;
13069 if (scope == error_mark_node)
13070 return error_mark_node;
13072 /* Any name names a type if we're following the `typename' keyword
13073 in a qualified name where the enclosing scope is type-dependent. */
13074 typename_p = (typename_keyword_p && scope && TYPE_P (scope)
13075 && dependent_type_p (scope));
13076 /* Handle the common case (an identifier, but not a template-id)
13078 if (token->type == CPP_NAME
13079 && !cp_parser_nth_token_starts_template_argument_list_p (parser, 2))
13081 cp_token *identifier_token;
13085 /* Look for the identifier. */
13086 identifier_token = cp_lexer_peek_token (parser->lexer);
13087 ambiguous_p = identifier_token->ambiguous_p;
13088 identifier = cp_parser_identifier (parser);
13089 /* If the next token isn't an identifier, we are certainly not
13090 looking at a class-name. */
13091 if (identifier == error_mark_node)
13092 decl = error_mark_node;
13093 /* If we know this is a type-name, there's no need to look it
13095 else if (typename_p)
13099 tree ambiguous_decls;
13100 /* If we already know that this lookup is ambiguous, then
13101 we've already issued an error message; there's no reason
13105 cp_parser_simulate_error (parser);
13106 return error_mark_node;
13108 /* If the next token is a `::', then the name must be a type
13111 [basic.lookup.qual]
13113 During the lookup for a name preceding the :: scope
13114 resolution operator, object, function, and enumerator
13115 names are ignored. */
13116 if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
13117 tag_type = typename_type;
13118 /* Look up the name. */
13119 decl = cp_parser_lookup_name (parser, identifier,
13121 /*is_template=*/false,
13122 /*is_namespace=*/false,
13123 check_dependency_p,
13125 if (ambiguous_decls)
13127 error ("reference to %qD is ambiguous", identifier);
13128 print_candidates (ambiguous_decls);
13129 if (cp_parser_parsing_tentatively (parser))
13131 identifier_token->ambiguous_p = true;
13132 cp_parser_simulate_error (parser);
13134 return error_mark_node;
13140 /* Try a template-id. */
13141 decl = cp_parser_template_id (parser, template_keyword_p,
13142 check_dependency_p,
13144 if (decl == error_mark_node)
13145 return error_mark_node;
13148 decl = cp_parser_maybe_treat_template_as_class (decl, class_head_p);
13150 /* If this is a typename, create a TYPENAME_TYPE. */
13151 if (typename_p && decl != error_mark_node)
13153 decl = make_typename_type (scope, decl, typename_type,
13154 /*complain=*/tf_error);
13155 if (decl != error_mark_node)
13156 decl = TYPE_NAME (decl);
13159 /* Check to see that it is really the name of a class. */
13160 if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
13161 && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
13162 && cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
13163 /* Situations like this:
13165 template <typename T> struct A {
13166 typename T::template X<int>::I i;
13169 are problematic. Is `T::template X<int>' a class-name? The
13170 standard does not seem to be definitive, but there is no other
13171 valid interpretation of the following `::'. Therefore, those
13172 names are considered class-names. */
13174 decl = make_typename_type (scope, decl, tag_type, tf_error);
13175 if (decl != error_mark_node)
13176 decl = TYPE_NAME (decl);
13178 else if (TREE_CODE (decl) != TYPE_DECL
13179 || TREE_TYPE (decl) == error_mark_node
13180 || !IS_AGGR_TYPE (TREE_TYPE (decl)))
13181 decl = error_mark_node;
13183 if (decl == error_mark_node)
13184 cp_parser_error (parser, "expected class-name");
13189 /* Parse a class-specifier.
13192 class-head { member-specification [opt] }
13194 Returns the TREE_TYPE representing the class. */
13197 cp_parser_class_specifier (cp_parser* parser)
13201 tree attributes = NULL_TREE;
13202 int has_trailing_semicolon;
13203 bool nested_name_specifier_p;
13204 unsigned saved_num_template_parameter_lists;
13205 bool saved_in_function_body;
13206 tree old_scope = NULL_TREE;
13207 tree scope = NULL_TREE;
13210 push_deferring_access_checks (dk_no_deferred);
13212 /* Parse the class-head. */
13213 type = cp_parser_class_head (parser,
13214 &nested_name_specifier_p,
13217 /* If the class-head was a semantic disaster, skip the entire body
13221 cp_parser_skip_to_end_of_block_or_statement (parser);
13222 pop_deferring_access_checks ();
13223 return error_mark_node;
13226 /* Look for the `{'. */
13227 if (!cp_parser_require (parser, CPP_OPEN_BRACE, "`{'"))
13229 pop_deferring_access_checks ();
13230 return error_mark_node;
13233 /* Process the base classes. If they're invalid, skip the
13234 entire class body. */
13235 if (!xref_basetypes (type, bases))
13237 cp_parser_skip_to_closing_brace (parser);
13239 /* Consuming the closing brace yields better error messages
13241 cp_lexer_consume_token (parser->lexer);
13242 pop_deferring_access_checks ();
13243 return error_mark_node;
13246 /* Issue an error message if type-definitions are forbidden here. */
13247 cp_parser_check_type_definition (parser);
13248 /* Remember that we are defining one more class. */
13249 ++parser->num_classes_being_defined;
13250 /* Inside the class, surrounding template-parameter-lists do not
13252 saved_num_template_parameter_lists
13253 = parser->num_template_parameter_lists;
13254 parser->num_template_parameter_lists = 0;
13255 /* We are not in a function body. */
13256 saved_in_function_body = parser->in_function_body;
13257 parser->in_function_body = false;
13259 /* Start the class. */
13260 if (nested_name_specifier_p)
13262 scope = CP_DECL_CONTEXT (TYPE_MAIN_DECL (type));
13263 old_scope = push_inner_scope (scope);
13265 type = begin_class_definition (type, attributes);
13267 if (type == error_mark_node)
13268 /* If the type is erroneous, skip the entire body of the class. */
13269 cp_parser_skip_to_closing_brace (parser);
13271 /* Parse the member-specification. */
13272 cp_parser_member_specification_opt (parser);
13274 /* Look for the trailing `}'. */
13275 cp_parser_require (parser, CPP_CLOSE_BRACE, "`}'");
13276 /* We get better error messages by noticing a common problem: a
13277 missing trailing `;'. */
13278 token = cp_lexer_peek_token (parser->lexer);
13279 has_trailing_semicolon = (token->type == CPP_SEMICOLON);
13280 /* Look for trailing attributes to apply to this class. */
13281 if (cp_parser_allow_gnu_extensions_p (parser))
13282 attributes = cp_parser_attributes_opt (parser);
13283 if (type != error_mark_node)
13284 type = finish_struct (type, attributes);
13285 if (nested_name_specifier_p)
13286 pop_inner_scope (old_scope, scope);
13287 /* If this class is not itself within the scope of another class,
13288 then we need to parse the bodies of all of the queued function
13289 definitions. Note that the queued functions defined in a class
13290 are not always processed immediately following the
13291 class-specifier for that class. Consider:
13294 struct B { void f() { sizeof (A); } };
13297 If `f' were processed before the processing of `A' were
13298 completed, there would be no way to compute the size of `A'.
13299 Note that the nesting we are interested in here is lexical --
13300 not the semantic nesting given by TYPE_CONTEXT. In particular,
13303 struct A { struct B; };
13304 struct A::B { void f() { } };
13306 there is no need to delay the parsing of `A::B::f'. */
13307 if (--parser->num_classes_being_defined == 0)
13311 tree class_type = NULL_TREE;
13312 tree pushed_scope = NULL_TREE;
13314 /* In a first pass, parse default arguments to the functions.
13315 Then, in a second pass, parse the bodies of the functions.
13316 This two-phased approach handles cases like:
13324 for (TREE_PURPOSE (parser->unparsed_functions_queues)
13325 = nreverse (TREE_PURPOSE (parser->unparsed_functions_queues));
13326 (queue_entry = TREE_PURPOSE (parser->unparsed_functions_queues));
13327 TREE_PURPOSE (parser->unparsed_functions_queues)
13328 = TREE_CHAIN (TREE_PURPOSE (parser->unparsed_functions_queues)))
13330 fn = TREE_VALUE (queue_entry);
13331 /* If there are default arguments that have not yet been processed,
13332 take care of them now. */
13333 if (class_type != TREE_PURPOSE (queue_entry))
13336 pop_scope (pushed_scope);
13337 class_type = TREE_PURPOSE (queue_entry);
13338 pushed_scope = push_scope (class_type);
13340 /* Make sure that any template parameters are in scope. */
13341 maybe_begin_member_template_processing (fn);
13342 /* Parse the default argument expressions. */
13343 cp_parser_late_parsing_default_args (parser, fn);
13344 /* Remove any template parameters from the symbol table. */
13345 maybe_end_member_template_processing ();
13348 pop_scope (pushed_scope);
13349 /* Now parse the body of the functions. */
13350 for (TREE_VALUE (parser->unparsed_functions_queues)
13351 = nreverse (TREE_VALUE (parser->unparsed_functions_queues));
13352 (queue_entry = TREE_VALUE (parser->unparsed_functions_queues));
13353 TREE_VALUE (parser->unparsed_functions_queues)
13354 = TREE_CHAIN (TREE_VALUE (parser->unparsed_functions_queues)))
13356 /* Figure out which function we need to process. */
13357 fn = TREE_VALUE (queue_entry);
13358 /* Parse the function. */
13359 cp_parser_late_parsing_for_member (parser, fn);
13363 /* Put back any saved access checks. */
13364 pop_deferring_access_checks ();
13366 /* Restore saved state. */
13367 parser->in_function_body = saved_in_function_body;
13368 parser->num_template_parameter_lists
13369 = saved_num_template_parameter_lists;
13374 /* Parse a class-head.
13377 class-key identifier [opt] base-clause [opt]
13378 class-key nested-name-specifier identifier base-clause [opt]
13379 class-key nested-name-specifier [opt] template-id
13383 class-key attributes identifier [opt] base-clause [opt]
13384 class-key attributes nested-name-specifier identifier base-clause [opt]
13385 class-key attributes nested-name-specifier [opt] template-id
13388 Returns the TYPE of the indicated class. Sets
13389 *NESTED_NAME_SPECIFIER_P to TRUE iff one of the productions
13390 involving a nested-name-specifier was used, and FALSE otherwise.
13392 Returns error_mark_node if this is not a class-head.
13394 Returns NULL_TREE if the class-head is syntactically valid, but
13395 semantically invalid in a way that means we should skip the entire
13396 body of the class. */
13399 cp_parser_class_head (cp_parser* parser,
13400 bool* nested_name_specifier_p,
13401 tree *attributes_p,
13404 tree nested_name_specifier;
13405 enum tag_types class_key;
13406 tree id = NULL_TREE;
13407 tree type = NULL_TREE;
13409 bool template_id_p = false;
13410 bool qualified_p = false;
13411 bool invalid_nested_name_p = false;
13412 bool invalid_explicit_specialization_p = false;
13413 tree pushed_scope = NULL_TREE;
13414 unsigned num_templates;
13416 /* Assume no nested-name-specifier will be present. */
13417 *nested_name_specifier_p = false;
13418 /* Assume no template parameter lists will be used in defining the
13422 /* Look for the class-key. */
13423 class_key = cp_parser_class_key (parser);
13424 if (class_key == none_type)
13425 return error_mark_node;
13427 /* Parse the attributes. */
13428 attributes = cp_parser_attributes_opt (parser);
13430 /* If the next token is `::', that is invalid -- but sometimes
13431 people do try to write:
13435 Handle this gracefully by accepting the extra qualifier, and then
13436 issuing an error about it later if this really is a
13437 class-head. If it turns out just to be an elaborated type
13438 specifier, remain silent. */
13439 if (cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/false))
13440 qualified_p = true;
13442 push_deferring_access_checks (dk_no_check);
13444 /* Determine the name of the class. Begin by looking for an
13445 optional nested-name-specifier. */
13446 nested_name_specifier
13447 = cp_parser_nested_name_specifier_opt (parser,
13448 /*typename_keyword_p=*/false,
13449 /*check_dependency_p=*/false,
13451 /*is_declaration=*/false);
13452 /* If there was a nested-name-specifier, then there *must* be an
13454 if (nested_name_specifier)
13456 /* Although the grammar says `identifier', it really means
13457 `class-name' or `template-name'. You are only allowed to
13458 define a class that has already been declared with this
13461 The proposed resolution for Core Issue 180 says that wherever
13462 you see `class T::X' you should treat `X' as a type-name.
13464 It is OK to define an inaccessible class; for example:
13466 class A { class B; };
13469 We do not know if we will see a class-name, or a
13470 template-name. We look for a class-name first, in case the
13471 class-name is a template-id; if we looked for the
13472 template-name first we would stop after the template-name. */
13473 cp_parser_parse_tentatively (parser);
13474 type = cp_parser_class_name (parser,
13475 /*typename_keyword_p=*/false,
13476 /*template_keyword_p=*/false,
13478 /*check_dependency_p=*/false,
13479 /*class_head_p=*/true,
13480 /*is_declaration=*/false);
13481 /* If that didn't work, ignore the nested-name-specifier. */
13482 if (!cp_parser_parse_definitely (parser))
13484 invalid_nested_name_p = true;
13485 id = cp_parser_identifier (parser);
13486 if (id == error_mark_node)
13489 /* If we could not find a corresponding TYPE, treat this
13490 declaration like an unqualified declaration. */
13491 if (type == error_mark_node)
13492 nested_name_specifier = NULL_TREE;
13493 /* Otherwise, count the number of templates used in TYPE and its
13494 containing scopes. */
13499 for (scope = TREE_TYPE (type);
13500 scope && TREE_CODE (scope) != NAMESPACE_DECL;
13501 scope = (TYPE_P (scope)
13502 ? TYPE_CONTEXT (scope)
13503 : DECL_CONTEXT (scope)))
13505 && CLASS_TYPE_P (scope)
13506 && CLASSTYPE_TEMPLATE_INFO (scope)
13507 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (scope))
13508 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (scope))
13512 /* Otherwise, the identifier is optional. */
13515 /* We don't know whether what comes next is a template-id,
13516 an identifier, or nothing at all. */
13517 cp_parser_parse_tentatively (parser);
13518 /* Check for a template-id. */
13519 id = cp_parser_template_id (parser,
13520 /*template_keyword_p=*/false,
13521 /*check_dependency_p=*/true,
13522 /*is_declaration=*/true);
13523 /* If that didn't work, it could still be an identifier. */
13524 if (!cp_parser_parse_definitely (parser))
13526 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
13527 id = cp_parser_identifier (parser);
13533 template_id_p = true;
13538 pop_deferring_access_checks ();
13541 cp_parser_check_for_invalid_template_id (parser, id);
13543 /* If it's not a `:' or a `{' then we can't really be looking at a
13544 class-head, since a class-head only appears as part of a
13545 class-specifier. We have to detect this situation before calling
13546 xref_tag, since that has irreversible side-effects. */
13547 if (!cp_parser_next_token_starts_class_definition_p (parser))
13549 cp_parser_error (parser, "expected %<{%> or %<:%>");
13550 return error_mark_node;
13553 /* At this point, we're going ahead with the class-specifier, even
13554 if some other problem occurs. */
13555 cp_parser_commit_to_tentative_parse (parser);
13556 /* Issue the error about the overly-qualified name now. */
13558 cp_parser_error (parser,
13559 "global qualification of class name is invalid");
13560 else if (invalid_nested_name_p)
13561 cp_parser_error (parser,
13562 "qualified name does not name a class");
13563 else if (nested_name_specifier)
13567 /* Reject typedef-names in class heads. */
13568 if (!DECL_IMPLICIT_TYPEDEF_P (type))
13570 error ("invalid class name in declaration of %qD", type);
13575 /* Figure out in what scope the declaration is being placed. */
13576 scope = current_scope ();
13577 /* If that scope does not contain the scope in which the
13578 class was originally declared, the program is invalid. */
13579 if (scope && !is_ancestor (scope, nested_name_specifier))
13581 error ("declaration of %qD in %qD which does not enclose %qD",
13582 type, scope, nested_name_specifier);
13588 A declarator-id shall not be qualified exception of the
13589 definition of a ... nested class outside of its class
13590 ... [or] a the definition or explicit instantiation of a
13591 class member of a namespace outside of its namespace. */
13592 if (scope == nested_name_specifier)
13594 pedwarn ("extra qualification ignored");
13595 nested_name_specifier = NULL_TREE;
13599 /* An explicit-specialization must be preceded by "template <>". If
13600 it is not, try to recover gracefully. */
13601 if (at_namespace_scope_p ()
13602 && parser->num_template_parameter_lists == 0
13605 error ("an explicit specialization must be preceded by %<template <>%>");
13606 invalid_explicit_specialization_p = true;
13607 /* Take the same action that would have been taken by
13608 cp_parser_explicit_specialization. */
13609 ++parser->num_template_parameter_lists;
13610 begin_specialization ();
13612 /* There must be no "return" statements between this point and the
13613 end of this function; set "type "to the correct return value and
13614 use "goto done;" to return. */
13615 /* Make sure that the right number of template parameters were
13617 if (!cp_parser_check_template_parameters (parser, num_templates))
13619 /* If something went wrong, there is no point in even trying to
13620 process the class-definition. */
13625 /* Look up the type. */
13628 type = TREE_TYPE (id);
13629 type = maybe_process_partial_specialization (type);
13630 if (nested_name_specifier)
13631 pushed_scope = push_scope (nested_name_specifier);
13633 else if (nested_name_specifier)
13639 template <typename T> struct S { struct T };
13640 template <typename T> struct S<T>::T { };
13642 we will get a TYPENAME_TYPE when processing the definition of
13643 `S::T'. We need to resolve it to the actual type before we
13644 try to define it. */
13645 if (TREE_CODE (TREE_TYPE (type)) == TYPENAME_TYPE)
13647 class_type = resolve_typename_type (TREE_TYPE (type),
13648 /*only_current_p=*/false);
13649 if (class_type != error_mark_node)
13650 type = TYPE_NAME (class_type);
13653 cp_parser_error (parser, "could not resolve typename type");
13654 type = error_mark_node;
13658 maybe_process_partial_specialization (TREE_TYPE (type));
13659 class_type = current_class_type;
13660 /* Enter the scope indicated by the nested-name-specifier. */
13661 pushed_scope = push_scope (nested_name_specifier);
13662 /* Get the canonical version of this type. */
13663 type = TYPE_MAIN_DECL (TREE_TYPE (type));
13664 if (PROCESSING_REAL_TEMPLATE_DECL_P ()
13665 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (type)))
13667 type = push_template_decl (type);
13668 if (type == error_mark_node)
13675 type = TREE_TYPE (type);
13676 *nested_name_specifier_p = true;
13678 else /* The name is not a nested name. */
13680 /* If the class was unnamed, create a dummy name. */
13682 id = make_anon_name ();
13683 type = xref_tag (class_key, id, /*tag_scope=*/ts_current,
13684 parser->num_template_parameter_lists);
13687 /* Indicate whether this class was declared as a `class' or as a
13689 if (TREE_CODE (type) == RECORD_TYPE)
13690 CLASSTYPE_DECLARED_CLASS (type) = (class_key == class_type);
13691 cp_parser_check_class_key (class_key, type);
13693 /* If this type was already complete, and we see another definition,
13694 that's an error. */
13695 if (type != error_mark_node && COMPLETE_TYPE_P (type))
13697 error ("redefinition of %q#T", type);
13698 error ("previous definition of %q+#T", type);
13702 else if (type == error_mark_node)
13705 /* We will have entered the scope containing the class; the names of
13706 base classes should be looked up in that context. For example:
13708 struct A { struct B {}; struct C; };
13709 struct A::C : B {};
13712 *bases = NULL_TREE;
13714 /* Get the list of base-classes, if there is one. */
13715 if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
13716 *bases = cp_parser_base_clause (parser);
13719 /* Leave the scope given by the nested-name-specifier. We will
13720 enter the class scope itself while processing the members. */
13722 pop_scope (pushed_scope);
13724 if (invalid_explicit_specialization_p)
13726 end_specialization ();
13727 --parser->num_template_parameter_lists;
13729 *attributes_p = attributes;
13733 /* Parse a class-key.
13740 Returns the kind of class-key specified, or none_type to indicate
13743 static enum tag_types
13744 cp_parser_class_key (cp_parser* parser)
13747 enum tag_types tag_type;
13749 /* Look for the class-key. */
13750 token = cp_parser_require (parser, CPP_KEYWORD, "class-key");
13754 /* Check to see if the TOKEN is a class-key. */
13755 tag_type = cp_parser_token_is_class_key (token);
13757 cp_parser_error (parser, "expected class-key");
13761 /* Parse an (optional) member-specification.
13763 member-specification:
13764 member-declaration member-specification [opt]
13765 access-specifier : member-specification [opt] */
13768 cp_parser_member_specification_opt (cp_parser* parser)
13775 /* Peek at the next token. */
13776 token = cp_lexer_peek_token (parser->lexer);
13777 /* If it's a `}', or EOF then we've seen all the members. */
13778 if (token->type == CPP_CLOSE_BRACE
13779 || token->type == CPP_EOF
13780 || token->type == CPP_PRAGMA_EOL)
13783 /* See if this token is a keyword. */
13784 keyword = token->keyword;
13788 case RID_PROTECTED:
13790 /* Consume the access-specifier. */
13791 cp_lexer_consume_token (parser->lexer);
13792 /* Remember which access-specifier is active. */
13793 current_access_specifier = token->u.value;
13794 /* Look for the `:'. */
13795 cp_parser_require (parser, CPP_COLON, "`:'");
13799 /* Accept #pragmas at class scope. */
13800 if (token->type == CPP_PRAGMA)
13802 cp_parser_pragma (parser, pragma_external);
13806 /* Otherwise, the next construction must be a
13807 member-declaration. */
13808 cp_parser_member_declaration (parser);
13813 /* Parse a member-declaration.
13815 member-declaration:
13816 decl-specifier-seq [opt] member-declarator-list [opt] ;
13817 function-definition ; [opt]
13818 :: [opt] nested-name-specifier template [opt] unqualified-id ;
13820 template-declaration
13822 member-declarator-list:
13824 member-declarator-list , member-declarator
13827 declarator pure-specifier [opt]
13828 declarator constant-initializer [opt]
13829 identifier [opt] : constant-expression
13833 member-declaration:
13834 __extension__ member-declaration
13837 declarator attributes [opt] pure-specifier [opt]
13838 declarator attributes [opt] constant-initializer [opt]
13839 identifier [opt] attributes [opt] : constant-expression
13843 member-declaration:
13844 static_assert-declaration */
13847 cp_parser_member_declaration (cp_parser* parser)
13849 cp_decl_specifier_seq decl_specifiers;
13850 tree prefix_attributes;
13852 int declares_class_or_enum;
13855 int saved_pedantic;
13857 /* Check for the `__extension__' keyword. */
13858 if (cp_parser_extension_opt (parser, &saved_pedantic))
13861 cp_parser_member_declaration (parser);
13862 /* Restore the old value of the PEDANTIC flag. */
13863 pedantic = saved_pedantic;
13868 /* Check for a template-declaration. */
13869 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
13871 /* An explicit specialization here is an error condition, and we
13872 expect the specialization handler to detect and report this. */
13873 if (cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_LESS
13874 && cp_lexer_peek_nth_token (parser->lexer, 3)->type == CPP_GREATER)
13875 cp_parser_explicit_specialization (parser);
13877 cp_parser_template_declaration (parser, /*member_p=*/true);
13882 /* Check for a using-declaration. */
13883 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_USING))
13885 /* Parse the using-declaration. */
13886 cp_parser_using_declaration (parser,
13887 /*access_declaration_p=*/false);
13891 /* Check for @defs. */
13892 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_AT_DEFS))
13895 tree ivar_chains = cp_parser_objc_defs_expression (parser);
13896 ivar = ivar_chains;
13900 ivar = TREE_CHAIN (member);
13901 TREE_CHAIN (member) = NULL_TREE;
13902 finish_member_declaration (member);
13907 /* If the next token is `static_assert' we have a static assertion. */
13908 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_STATIC_ASSERT))
13910 cp_parser_static_assert (parser, /*member_p=*/true);
13914 if (cp_parser_using_declaration (parser, /*access_declaration=*/true))
13917 /* Parse the decl-specifier-seq. */
13918 cp_parser_decl_specifier_seq (parser,
13919 CP_PARSER_FLAGS_OPTIONAL,
13921 &declares_class_or_enum);
13922 prefix_attributes = decl_specifiers.attributes;
13923 decl_specifiers.attributes = NULL_TREE;
13924 /* Check for an invalid type-name. */
13925 if (!decl_specifiers.type
13926 && cp_parser_parse_and_diagnose_invalid_type_name (parser))
13928 /* If there is no declarator, then the decl-specifier-seq should
13930 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
13932 /* If there was no decl-specifier-seq, and the next token is a
13933 `;', then we have something like:
13939 Each member-declaration shall declare at least one member
13940 name of the class. */
13941 if (!decl_specifiers.any_specifiers_p)
13943 cp_token *token = cp_lexer_peek_token (parser->lexer);
13944 if (pedantic && !token->in_system_header)
13945 pedwarn ("%Hextra %<;%>", &token->location);
13951 /* See if this declaration is a friend. */
13952 friend_p = cp_parser_friend_p (&decl_specifiers);
13953 /* If there were decl-specifiers, check to see if there was
13954 a class-declaration. */
13955 type = check_tag_decl (&decl_specifiers);
13956 /* Nested classes have already been added to the class, but
13957 a `friend' needs to be explicitly registered. */
13960 /* If the `friend' keyword was present, the friend must
13961 be introduced with a class-key. */
13962 if (!declares_class_or_enum)
13963 error ("a class-key must be used when declaring a friend");
13966 template <typename T> struct A {
13967 friend struct A<T>::B;
13970 A<T>::B will be represented by a TYPENAME_TYPE, and
13971 therefore not recognized by check_tag_decl. */
13973 && decl_specifiers.type
13974 && TYPE_P (decl_specifiers.type))
13975 type = decl_specifiers.type;
13976 if (!type || !TYPE_P (type))
13977 error ("friend declaration does not name a class or "
13980 make_friend_class (current_class_type, type,
13981 /*complain=*/true);
13983 /* If there is no TYPE, an error message will already have
13985 else if (!type || type == error_mark_node)
13987 /* An anonymous aggregate has to be handled specially; such
13988 a declaration really declares a data member (with a
13989 particular type), as opposed to a nested class. */
13990 else if (ANON_AGGR_TYPE_P (type))
13992 /* Remove constructors and such from TYPE, now that we
13993 know it is an anonymous aggregate. */
13994 fixup_anonymous_aggr (type);
13995 /* And make the corresponding data member. */
13996 decl = build_decl (FIELD_DECL, NULL_TREE, type);
13997 /* Add it to the class. */
13998 finish_member_declaration (decl);
14001 cp_parser_check_access_in_redeclaration (TYPE_NAME (type));
14006 /* See if these declarations will be friends. */
14007 friend_p = cp_parser_friend_p (&decl_specifiers);
14009 /* Keep going until we hit the `;' at the end of the
14011 while (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
14013 tree attributes = NULL_TREE;
14014 tree first_attribute;
14016 /* Peek at the next token. */
14017 token = cp_lexer_peek_token (parser->lexer);
14019 /* Check for a bitfield declaration. */
14020 if (token->type == CPP_COLON
14021 || (token->type == CPP_NAME
14022 && cp_lexer_peek_nth_token (parser->lexer, 2)->type
14028 /* Get the name of the bitfield. Note that we cannot just
14029 check TOKEN here because it may have been invalidated by
14030 the call to cp_lexer_peek_nth_token above. */
14031 if (cp_lexer_peek_token (parser->lexer)->type != CPP_COLON)
14032 identifier = cp_parser_identifier (parser);
14034 identifier = NULL_TREE;
14036 /* Consume the `:' token. */
14037 cp_lexer_consume_token (parser->lexer);
14038 /* Get the width of the bitfield. */
14040 = cp_parser_constant_expression (parser,
14041 /*allow_non_constant=*/false,
14044 /* Look for attributes that apply to the bitfield. */
14045 attributes = cp_parser_attributes_opt (parser);
14046 /* Remember which attributes are prefix attributes and
14048 first_attribute = attributes;
14049 /* Combine the attributes. */
14050 attributes = chainon (prefix_attributes, attributes);
14052 /* Create the bitfield declaration. */
14053 decl = grokbitfield (identifier
14054 ? make_id_declarator (NULL_TREE,
14060 /* Apply the attributes. */
14061 cplus_decl_attributes (&decl, attributes, /*flags=*/0);
14065 cp_declarator *declarator;
14067 tree asm_specification;
14068 int ctor_dtor_or_conv_p;
14070 /* Parse the declarator. */
14072 = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
14073 &ctor_dtor_or_conv_p,
14074 /*parenthesized_p=*/NULL,
14075 /*member_p=*/true);
14077 /* If something went wrong parsing the declarator, make sure
14078 that we at least consume some tokens. */
14079 if (declarator == cp_error_declarator)
14081 /* Skip to the end of the statement. */
14082 cp_parser_skip_to_end_of_statement (parser);
14083 /* If the next token is not a semicolon, that is
14084 probably because we just skipped over the body of
14085 a function. So, we consume a semicolon if
14086 present, but do not issue an error message if it
14088 if (cp_lexer_next_token_is (parser->lexer,
14090 cp_lexer_consume_token (parser->lexer);
14094 if (declares_class_or_enum & 2)
14095 cp_parser_check_for_definition_in_return_type
14096 (declarator, decl_specifiers.type);
14098 /* Look for an asm-specification. */
14099 asm_specification = cp_parser_asm_specification_opt (parser);
14100 /* Look for attributes that apply to the declaration. */
14101 attributes = cp_parser_attributes_opt (parser);
14102 /* Remember which attributes are prefix attributes and
14104 first_attribute = attributes;
14105 /* Combine the attributes. */
14106 attributes = chainon (prefix_attributes, attributes);
14108 /* If it's an `=', then we have a constant-initializer or a
14109 pure-specifier. It is not correct to parse the
14110 initializer before registering the member declaration
14111 since the member declaration should be in scope while
14112 its initializer is processed. However, the rest of the
14113 front end does not yet provide an interface that allows
14114 us to handle this correctly. */
14115 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
14119 A pure-specifier shall be used only in the declaration of
14120 a virtual function.
14122 A member-declarator can contain a constant-initializer
14123 only if it declares a static member of integral or
14126 Therefore, if the DECLARATOR is for a function, we look
14127 for a pure-specifier; otherwise, we look for a
14128 constant-initializer. When we call `grokfield', it will
14129 perform more stringent semantics checks. */
14130 if (function_declarator_p (declarator))
14131 initializer = cp_parser_pure_specifier (parser);
14133 /* Parse the initializer. */
14134 initializer = cp_parser_constant_initializer (parser);
14136 /* Otherwise, there is no initializer. */
14138 initializer = NULL_TREE;
14140 /* See if we are probably looking at a function
14141 definition. We are certainly not looking at a
14142 member-declarator. Calling `grokfield' has
14143 side-effects, so we must not do it unless we are sure
14144 that we are looking at a member-declarator. */
14145 if (cp_parser_token_starts_function_definition_p
14146 (cp_lexer_peek_token (parser->lexer)))
14148 /* The grammar does not allow a pure-specifier to be
14149 used when a member function is defined. (It is
14150 possible that this fact is an oversight in the
14151 standard, since a pure function may be defined
14152 outside of the class-specifier. */
14154 error ("pure-specifier on function-definition");
14155 decl = cp_parser_save_member_function_body (parser,
14159 /* If the member was not a friend, declare it here. */
14161 finish_member_declaration (decl);
14162 /* Peek at the next token. */
14163 token = cp_lexer_peek_token (parser->lexer);
14164 /* If the next token is a semicolon, consume it. */
14165 if (token->type == CPP_SEMICOLON)
14166 cp_lexer_consume_token (parser->lexer);
14170 /* Create the declaration. */
14171 decl = grokfield (declarator, &decl_specifiers,
14172 initializer, /*init_const_expr_p=*/true,
14177 /* Reset PREFIX_ATTRIBUTES. */
14178 while (attributes && TREE_CHAIN (attributes) != first_attribute)
14179 attributes = TREE_CHAIN (attributes);
14181 TREE_CHAIN (attributes) = NULL_TREE;
14183 /* If there is any qualification still in effect, clear it
14184 now; we will be starting fresh with the next declarator. */
14185 parser->scope = NULL_TREE;
14186 parser->qualifying_scope = NULL_TREE;
14187 parser->object_scope = NULL_TREE;
14188 /* If it's a `,', then there are more declarators. */
14189 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
14190 cp_lexer_consume_token (parser->lexer);
14191 /* If the next token isn't a `;', then we have a parse error. */
14192 else if (cp_lexer_next_token_is_not (parser->lexer,
14195 cp_parser_error (parser, "expected %<;%>");
14196 /* Skip tokens until we find a `;'. */
14197 cp_parser_skip_to_end_of_statement (parser);
14204 /* Add DECL to the list of members. */
14206 finish_member_declaration (decl);
14208 if (TREE_CODE (decl) == FUNCTION_DECL)
14209 cp_parser_save_default_args (parser, decl);
14214 cp_parser_require (parser, CPP_SEMICOLON, "`;'");
14217 /* Parse a pure-specifier.
14222 Returns INTEGER_ZERO_NODE if a pure specifier is found.
14223 Otherwise, ERROR_MARK_NODE is returned. */
14226 cp_parser_pure_specifier (cp_parser* parser)
14230 /* Look for the `=' token. */
14231 if (!cp_parser_require (parser, CPP_EQ, "`='"))
14232 return error_mark_node;
14233 /* Look for the `0' token. */
14234 token = cp_lexer_consume_token (parser->lexer);
14235 /* c_lex_with_flags marks a single digit '0' with PURE_ZERO. */
14236 if (token->type != CPP_NUMBER || !(token->flags & PURE_ZERO))
14238 cp_parser_error (parser,
14239 "invalid pure specifier (only `= 0' is allowed)");
14240 cp_parser_skip_to_end_of_statement (parser);
14241 return error_mark_node;
14243 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
14245 error ("templates may not be %<virtual%>");
14246 return error_mark_node;
14249 return integer_zero_node;
14252 /* Parse a constant-initializer.
14254 constant-initializer:
14255 = constant-expression
14257 Returns a representation of the constant-expression. */
14260 cp_parser_constant_initializer (cp_parser* parser)
14262 /* Look for the `=' token. */
14263 if (!cp_parser_require (parser, CPP_EQ, "`='"))
14264 return error_mark_node;
14266 /* It is invalid to write:
14268 struct S { static const int i = { 7 }; };
14271 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
14273 cp_parser_error (parser,
14274 "a brace-enclosed initializer is not allowed here");
14275 /* Consume the opening brace. */
14276 cp_lexer_consume_token (parser->lexer);
14277 /* Skip the initializer. */
14278 cp_parser_skip_to_closing_brace (parser);
14279 /* Look for the trailing `}'. */
14280 cp_parser_require (parser, CPP_CLOSE_BRACE, "`}'");
14282 return error_mark_node;
14285 return cp_parser_constant_expression (parser,
14286 /*allow_non_constant=*/false,
14290 /* Derived classes [gram.class.derived] */
14292 /* Parse a base-clause.
14295 : base-specifier-list
14297 base-specifier-list:
14299 base-specifier-list , base-specifier
14301 Returns a TREE_LIST representing the base-classes, in the order in
14302 which they were declared. The representation of each node is as
14303 described by cp_parser_base_specifier.
14305 In the case that no bases are specified, this function will return
14306 NULL_TREE, not ERROR_MARK_NODE. */
14309 cp_parser_base_clause (cp_parser* parser)
14311 tree bases = NULL_TREE;
14313 /* Look for the `:' that begins the list. */
14314 cp_parser_require (parser, CPP_COLON, "`:'");
14316 /* Scan the base-specifier-list. */
14322 /* Look for the base-specifier. */
14323 base = cp_parser_base_specifier (parser);
14324 /* Add BASE to the front of the list. */
14325 if (base != error_mark_node)
14327 TREE_CHAIN (base) = bases;
14330 /* Peek at the next token. */
14331 token = cp_lexer_peek_token (parser->lexer);
14332 /* If it's not a comma, then the list is complete. */
14333 if (token->type != CPP_COMMA)
14335 /* Consume the `,'. */
14336 cp_lexer_consume_token (parser->lexer);
14339 /* PARSER->SCOPE may still be non-NULL at this point, if the last
14340 base class had a qualified name. However, the next name that
14341 appears is certainly not qualified. */
14342 parser->scope = NULL_TREE;
14343 parser->qualifying_scope = NULL_TREE;
14344 parser->object_scope = NULL_TREE;
14346 return nreverse (bases);
14349 /* Parse a base-specifier.
14352 :: [opt] nested-name-specifier [opt] class-name
14353 virtual access-specifier [opt] :: [opt] nested-name-specifier
14355 access-specifier virtual [opt] :: [opt] nested-name-specifier
14358 Returns a TREE_LIST. The TREE_PURPOSE will be one of
14359 ACCESS_{DEFAULT,PUBLIC,PROTECTED,PRIVATE}_[VIRTUAL]_NODE to
14360 indicate the specifiers provided. The TREE_VALUE will be a TYPE
14361 (or the ERROR_MARK_NODE) indicating the type that was specified. */
14364 cp_parser_base_specifier (cp_parser* parser)
14368 bool virtual_p = false;
14369 bool duplicate_virtual_error_issued_p = false;
14370 bool duplicate_access_error_issued_p = false;
14371 bool class_scope_p, template_p;
14372 tree access = access_default_node;
14375 /* Process the optional `virtual' and `access-specifier'. */
14378 /* Peek at the next token. */
14379 token = cp_lexer_peek_token (parser->lexer);
14380 /* Process `virtual'. */
14381 switch (token->keyword)
14384 /* If `virtual' appears more than once, issue an error. */
14385 if (virtual_p && !duplicate_virtual_error_issued_p)
14387 cp_parser_error (parser,
14388 "%<virtual%> specified more than once in base-specified");
14389 duplicate_virtual_error_issued_p = true;
14394 /* Consume the `virtual' token. */
14395 cp_lexer_consume_token (parser->lexer);
14400 case RID_PROTECTED:
14402 /* If more than one access specifier appears, issue an
14404 if (access != access_default_node
14405 && !duplicate_access_error_issued_p)
14407 cp_parser_error (parser,
14408 "more than one access specifier in base-specified");
14409 duplicate_access_error_issued_p = true;
14412 access = ridpointers[(int) token->keyword];
14414 /* Consume the access-specifier. */
14415 cp_lexer_consume_token (parser->lexer);
14424 /* It is not uncommon to see programs mechanically, erroneously, use
14425 the 'typename' keyword to denote (dependent) qualified types
14426 as base classes. */
14427 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TYPENAME))
14429 if (!processing_template_decl)
14430 error ("keyword %<typename%> not allowed outside of templates");
14432 error ("keyword %<typename%> not allowed in this context "
14433 "(the base class is implicitly a type)");
14434 cp_lexer_consume_token (parser->lexer);
14437 /* Look for the optional `::' operator. */
14438 cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/false);
14439 /* Look for the nested-name-specifier. The simplest way to
14444 The keyword `typename' is not permitted in a base-specifier or
14445 mem-initializer; in these contexts a qualified name that
14446 depends on a template-parameter is implicitly assumed to be a
14449 is to pretend that we have seen the `typename' keyword at this
14451 cp_parser_nested_name_specifier_opt (parser,
14452 /*typename_keyword_p=*/true,
14453 /*check_dependency_p=*/true,
14455 /*is_declaration=*/true);
14456 /* If the base class is given by a qualified name, assume that names
14457 we see are type names or templates, as appropriate. */
14458 class_scope_p = (parser->scope && TYPE_P (parser->scope));
14459 template_p = class_scope_p && cp_parser_optional_template_keyword (parser);
14461 /* Finally, look for the class-name. */
14462 type = cp_parser_class_name (parser,
14466 /*check_dependency_p=*/true,
14467 /*class_head_p=*/false,
14468 /*is_declaration=*/true);
14470 if (type == error_mark_node)
14471 return error_mark_node;
14473 return finish_base_specifier (TREE_TYPE (type), access, virtual_p);
14476 /* Exception handling [gram.exception] */
14478 /* Parse an (optional) exception-specification.
14480 exception-specification:
14481 throw ( type-id-list [opt] )
14483 Returns a TREE_LIST representing the exception-specification. The
14484 TREE_VALUE of each node is a type. */
14487 cp_parser_exception_specification_opt (cp_parser* parser)
14492 /* Peek at the next token. */
14493 token = cp_lexer_peek_token (parser->lexer);
14494 /* If it's not `throw', then there's no exception-specification. */
14495 if (!cp_parser_is_keyword (token, RID_THROW))
14498 /* Consume the `throw'. */
14499 cp_lexer_consume_token (parser->lexer);
14501 /* Look for the `('. */
14502 cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
14504 /* Peek at the next token. */
14505 token = cp_lexer_peek_token (parser->lexer);
14506 /* If it's not a `)', then there is a type-id-list. */
14507 if (token->type != CPP_CLOSE_PAREN)
14509 const char *saved_message;
14511 /* Types may not be defined in an exception-specification. */
14512 saved_message = parser->type_definition_forbidden_message;
14513 parser->type_definition_forbidden_message
14514 = "types may not be defined in an exception-specification";
14515 /* Parse the type-id-list. */
14516 type_id_list = cp_parser_type_id_list (parser);
14517 /* Restore the saved message. */
14518 parser->type_definition_forbidden_message = saved_message;
14521 type_id_list = empty_except_spec;
14523 /* Look for the `)'. */
14524 cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
14526 return type_id_list;
14529 /* Parse an (optional) type-id-list.
14533 type-id-list , type-id
14535 Returns a TREE_LIST. The TREE_VALUE of each node is a TYPE,
14536 in the order that the types were presented. */
14539 cp_parser_type_id_list (cp_parser* parser)
14541 tree types = NULL_TREE;
14548 /* Get the next type-id. */
14549 type = cp_parser_type_id (parser);
14550 /* Add it to the list. */
14551 types = add_exception_specifier (types, type, /*complain=*/1);
14552 /* Peek at the next token. */
14553 token = cp_lexer_peek_token (parser->lexer);
14554 /* If it is not a `,', we are done. */
14555 if (token->type != CPP_COMMA)
14557 /* Consume the `,'. */
14558 cp_lexer_consume_token (parser->lexer);
14561 return nreverse (types);
14564 /* Parse a try-block.
14567 try compound-statement handler-seq */
14570 cp_parser_try_block (cp_parser* parser)
14574 cp_parser_require_keyword (parser, RID_TRY, "`try'");
14575 try_block = begin_try_block ();
14576 cp_parser_compound_statement (parser, NULL, true);
14577 finish_try_block (try_block);
14578 cp_parser_handler_seq (parser);
14579 finish_handler_sequence (try_block);
14584 /* Parse a function-try-block.
14586 function-try-block:
14587 try ctor-initializer [opt] function-body handler-seq */
14590 cp_parser_function_try_block (cp_parser* parser)
14592 tree compound_stmt;
14594 bool ctor_initializer_p;
14596 /* Look for the `try' keyword. */
14597 if (!cp_parser_require_keyword (parser, RID_TRY, "`try'"))
14599 /* Let the rest of the front-end know where we are. */
14600 try_block = begin_function_try_block (&compound_stmt);
14601 /* Parse the function-body. */
14603 = cp_parser_ctor_initializer_opt_and_function_body (parser);
14604 /* We're done with the `try' part. */
14605 finish_function_try_block (try_block);
14606 /* Parse the handlers. */
14607 cp_parser_handler_seq (parser);
14608 /* We're done with the handlers. */
14609 finish_function_handler_sequence (try_block, compound_stmt);
14611 return ctor_initializer_p;
14614 /* Parse a handler-seq.
14617 handler handler-seq [opt] */
14620 cp_parser_handler_seq (cp_parser* parser)
14626 /* Parse the handler. */
14627 cp_parser_handler (parser);
14628 /* Peek at the next token. */
14629 token = cp_lexer_peek_token (parser->lexer);
14630 /* If it's not `catch' then there are no more handlers. */
14631 if (!cp_parser_is_keyword (token, RID_CATCH))
14636 /* Parse a handler.
14639 catch ( exception-declaration ) compound-statement */
14642 cp_parser_handler (cp_parser* parser)
14647 cp_parser_require_keyword (parser, RID_CATCH, "`catch'");
14648 handler = begin_handler ();
14649 cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
14650 declaration = cp_parser_exception_declaration (parser);
14651 finish_handler_parms (declaration, handler);
14652 cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
14653 cp_parser_compound_statement (parser, NULL, false);
14654 finish_handler (handler);
14657 /* Parse an exception-declaration.
14659 exception-declaration:
14660 type-specifier-seq declarator
14661 type-specifier-seq abstract-declarator
14665 Returns a VAR_DECL for the declaration, or NULL_TREE if the
14666 ellipsis variant is used. */
14669 cp_parser_exception_declaration (cp_parser* parser)
14671 cp_decl_specifier_seq type_specifiers;
14672 cp_declarator *declarator;
14673 const char *saved_message;
14675 /* If it's an ellipsis, it's easy to handle. */
14676 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
14678 /* Consume the `...' token. */
14679 cp_lexer_consume_token (parser->lexer);
14683 /* Types may not be defined in exception-declarations. */
14684 saved_message = parser->type_definition_forbidden_message;
14685 parser->type_definition_forbidden_message
14686 = "types may not be defined in exception-declarations";
14688 /* Parse the type-specifier-seq. */
14689 cp_parser_type_specifier_seq (parser, /*is_condition=*/false,
14691 /* If it's a `)', then there is no declarator. */
14692 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
14695 declarator = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_EITHER,
14696 /*ctor_dtor_or_conv_p=*/NULL,
14697 /*parenthesized_p=*/NULL,
14698 /*member_p=*/false);
14700 /* Restore the saved message. */
14701 parser->type_definition_forbidden_message = saved_message;
14703 if (!type_specifiers.any_specifiers_p)
14704 return error_mark_node;
14706 return grokdeclarator (declarator, &type_specifiers, CATCHPARM, 1, NULL);
14709 /* Parse a throw-expression.
14712 throw assignment-expression [opt]
14714 Returns a THROW_EXPR representing the throw-expression. */
14717 cp_parser_throw_expression (cp_parser* parser)
14722 cp_parser_require_keyword (parser, RID_THROW, "`throw'");
14723 token = cp_lexer_peek_token (parser->lexer);
14724 /* Figure out whether or not there is an assignment-expression
14725 following the "throw" keyword. */
14726 if (token->type == CPP_COMMA
14727 || token->type == CPP_SEMICOLON
14728 || token->type == CPP_CLOSE_PAREN
14729 || token->type == CPP_CLOSE_SQUARE
14730 || token->type == CPP_CLOSE_BRACE
14731 || token->type == CPP_COLON)
14732 expression = NULL_TREE;
14734 expression = cp_parser_assignment_expression (parser,
14737 return build_throw (expression);
14740 /* GNU Extensions */
14742 /* Parse an (optional) asm-specification.
14745 asm ( string-literal )
14747 If the asm-specification is present, returns a STRING_CST
14748 corresponding to the string-literal. Otherwise, returns
14752 cp_parser_asm_specification_opt (cp_parser* parser)
14755 tree asm_specification;
14757 /* Peek at the next token. */
14758 token = cp_lexer_peek_token (parser->lexer);
14759 /* If the next token isn't the `asm' keyword, then there's no
14760 asm-specification. */
14761 if (!cp_parser_is_keyword (token, RID_ASM))
14764 /* Consume the `asm' token. */
14765 cp_lexer_consume_token (parser->lexer);
14766 /* Look for the `('. */
14767 cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
14769 /* Look for the string-literal. */
14770 asm_specification = cp_parser_string_literal (parser, false, false);
14772 /* Look for the `)'. */
14773 cp_parser_require (parser, CPP_CLOSE_PAREN, "`('");
14775 return asm_specification;
14778 /* Parse an asm-operand-list.
14782 asm-operand-list , asm-operand
14785 string-literal ( expression )
14786 [ string-literal ] string-literal ( expression )
14788 Returns a TREE_LIST representing the operands. The TREE_VALUE of
14789 each node is the expression. The TREE_PURPOSE is itself a
14790 TREE_LIST whose TREE_PURPOSE is a STRING_CST for the bracketed
14791 string-literal (or NULL_TREE if not present) and whose TREE_VALUE
14792 is a STRING_CST for the string literal before the parenthesis. */
14795 cp_parser_asm_operand_list (cp_parser* parser)
14797 tree asm_operands = NULL_TREE;
14801 tree string_literal;
14805 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
14807 /* Consume the `[' token. */
14808 cp_lexer_consume_token (parser->lexer);
14809 /* Read the operand name. */
14810 name = cp_parser_identifier (parser);
14811 if (name != error_mark_node)
14812 name = build_string (IDENTIFIER_LENGTH (name),
14813 IDENTIFIER_POINTER (name));
14814 /* Look for the closing `]'. */
14815 cp_parser_require (parser, CPP_CLOSE_SQUARE, "`]'");
14819 /* Look for the string-literal. */
14820 string_literal = cp_parser_string_literal (parser, false, false);
14822 /* Look for the `('. */
14823 cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
14824 /* Parse the expression. */
14825 expression = cp_parser_expression (parser, /*cast_p=*/false);
14826 /* Look for the `)'. */
14827 cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
14829 /* Add this operand to the list. */
14830 asm_operands = tree_cons (build_tree_list (name, string_literal),
14833 /* If the next token is not a `,', there are no more
14835 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
14837 /* Consume the `,'. */
14838 cp_lexer_consume_token (parser->lexer);
14841 return nreverse (asm_operands);
14844 /* Parse an asm-clobber-list.
14848 asm-clobber-list , string-literal
14850 Returns a TREE_LIST, indicating the clobbers in the order that they
14851 appeared. The TREE_VALUE of each node is a STRING_CST. */
14854 cp_parser_asm_clobber_list (cp_parser* parser)
14856 tree clobbers = NULL_TREE;
14860 tree string_literal;
14862 /* Look for the string literal. */
14863 string_literal = cp_parser_string_literal (parser, false, false);
14864 /* Add it to the list. */
14865 clobbers = tree_cons (NULL_TREE, string_literal, clobbers);
14866 /* If the next token is not a `,', then the list is
14868 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
14870 /* Consume the `,' token. */
14871 cp_lexer_consume_token (parser->lexer);
14877 /* Parse an (optional) series of attributes.
14880 attributes attribute
14883 __attribute__ (( attribute-list [opt] ))
14885 The return value is as for cp_parser_attribute_list. */
14888 cp_parser_attributes_opt (cp_parser* parser)
14890 tree attributes = NULL_TREE;
14895 tree attribute_list;
14897 /* Peek at the next token. */
14898 token = cp_lexer_peek_token (parser->lexer);
14899 /* If it's not `__attribute__', then we're done. */
14900 if (token->keyword != RID_ATTRIBUTE)
14903 /* Consume the `__attribute__' keyword. */
14904 cp_lexer_consume_token (parser->lexer);
14905 /* Look for the two `(' tokens. */
14906 cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
14907 cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
14909 /* Peek at the next token. */
14910 token = cp_lexer_peek_token (parser->lexer);
14911 if (token->type != CPP_CLOSE_PAREN)
14912 /* Parse the attribute-list. */
14913 attribute_list = cp_parser_attribute_list (parser);
14915 /* If the next token is a `)', then there is no attribute
14917 attribute_list = NULL;
14919 /* Look for the two `)' tokens. */
14920 cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
14921 cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
14923 /* Add these new attributes to the list. */
14924 attributes = chainon (attributes, attribute_list);
14930 /* Parse an attribute-list.
14934 attribute-list , attribute
14938 identifier ( identifier )
14939 identifier ( identifier , expression-list )
14940 identifier ( expression-list )
14942 Returns a TREE_LIST, or NULL_TREE on error. Each node corresponds
14943 to an attribute. The TREE_PURPOSE of each node is the identifier
14944 indicating which attribute is in use. The TREE_VALUE represents
14945 the arguments, if any. */
14948 cp_parser_attribute_list (cp_parser* parser)
14950 tree attribute_list = NULL_TREE;
14951 bool save_translate_strings_p = parser->translate_strings_p;
14953 parser->translate_strings_p = false;
14960 /* Look for the identifier. We also allow keywords here; for
14961 example `__attribute__ ((const))' is legal. */
14962 token = cp_lexer_peek_token (parser->lexer);
14963 if (token->type == CPP_NAME
14964 || token->type == CPP_KEYWORD)
14966 tree arguments = NULL_TREE;
14968 /* Consume the token. */
14969 token = cp_lexer_consume_token (parser->lexer);
14971 /* Save away the identifier that indicates which attribute
14973 identifier = token->u.value;
14974 attribute = build_tree_list (identifier, NULL_TREE);
14976 /* Peek at the next token. */
14977 token = cp_lexer_peek_token (parser->lexer);
14978 /* If it's an `(', then parse the attribute arguments. */
14979 if (token->type == CPP_OPEN_PAREN)
14981 arguments = cp_parser_parenthesized_expression_list
14982 (parser, true, /*cast_p=*/false,
14983 /*non_constant_p=*/NULL);
14984 /* Save the arguments away. */
14985 TREE_VALUE (attribute) = arguments;
14988 if (arguments != error_mark_node)
14990 /* Add this attribute to the list. */
14991 TREE_CHAIN (attribute) = attribute_list;
14992 attribute_list = attribute;
14995 token = cp_lexer_peek_token (parser->lexer);
14997 /* Now, look for more attributes. If the next token isn't a
14998 `,', we're done. */
14999 if (token->type != CPP_COMMA)
15002 /* Consume the comma and keep going. */
15003 cp_lexer_consume_token (parser->lexer);
15005 parser->translate_strings_p = save_translate_strings_p;
15007 /* We built up the list in reverse order. */
15008 return nreverse (attribute_list);
15011 /* Parse an optional `__extension__' keyword. Returns TRUE if it is
15012 present, and FALSE otherwise. *SAVED_PEDANTIC is set to the
15013 current value of the PEDANTIC flag, regardless of whether or not
15014 the `__extension__' keyword is present. The caller is responsible
15015 for restoring the value of the PEDANTIC flag. */
15018 cp_parser_extension_opt (cp_parser* parser, int* saved_pedantic)
15020 /* Save the old value of the PEDANTIC flag. */
15021 *saved_pedantic = pedantic;
15023 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_EXTENSION))
15025 /* Consume the `__extension__' token. */
15026 cp_lexer_consume_token (parser->lexer);
15027 /* We're not being pedantic while the `__extension__' keyword is
15037 /* Parse a label declaration.
15040 __label__ label-declarator-seq ;
15042 label-declarator-seq:
15043 identifier , label-declarator-seq
15047 cp_parser_label_declaration (cp_parser* parser)
15049 /* Look for the `__label__' keyword. */
15050 cp_parser_require_keyword (parser, RID_LABEL, "`__label__'");
15056 /* Look for an identifier. */
15057 identifier = cp_parser_identifier (parser);
15058 /* If we failed, stop. */
15059 if (identifier == error_mark_node)
15061 /* Declare it as a label. */
15062 finish_label_decl (identifier);
15063 /* If the next token is a `;', stop. */
15064 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
15066 /* Look for the `,' separating the label declarations. */
15067 cp_parser_require (parser, CPP_COMMA, "`,'");
15070 /* Look for the final `;'. */
15071 cp_parser_require (parser, CPP_SEMICOLON, "`;'");
15074 /* Support Functions */
15076 /* Looks up NAME in the current scope, as given by PARSER->SCOPE.
15077 NAME should have one of the representations used for an
15078 id-expression. If NAME is the ERROR_MARK_NODE, the ERROR_MARK_NODE
15079 is returned. If PARSER->SCOPE is a dependent type, then a
15080 SCOPE_REF is returned.
15082 If NAME is a TEMPLATE_ID_EXPR, then it will be immediately
15083 returned; the name was already resolved when the TEMPLATE_ID_EXPR
15084 was formed. Abstractly, such entities should not be passed to this
15085 function, because they do not need to be looked up, but it is
15086 simpler to check for this special case here, rather than at the
15089 In cases not explicitly covered above, this function returns a
15090 DECL, OVERLOAD, or baselink representing the result of the lookup.
15091 If there was no entity with the indicated NAME, the ERROR_MARK_NODE
15094 If TAG_TYPE is not NONE_TYPE, it indicates an explicit type keyword
15095 (e.g., "struct") that was used. In that case bindings that do not
15096 refer to types are ignored.
15098 If IS_TEMPLATE is TRUE, bindings that do not refer to templates are
15101 If IS_NAMESPACE is TRUE, bindings that do not refer to namespaces
15104 If CHECK_DEPENDENCY is TRUE, names are not looked up in dependent
15107 If AMBIGUOUS_DECLS is non-NULL, *AMBIGUOUS_DECLS is set to a
15108 TREE_LIST of candidates if name-lookup results in an ambiguity, and
15109 NULL_TREE otherwise. */
15112 cp_parser_lookup_name (cp_parser *parser, tree name,
15113 enum tag_types tag_type,
15116 bool check_dependency,
15117 tree *ambiguous_decls)
15121 tree object_type = parser->context->object_type;
15123 if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
15124 flags |= LOOKUP_COMPLAIN;
15126 /* Assume that the lookup will be unambiguous. */
15127 if (ambiguous_decls)
15128 *ambiguous_decls = NULL_TREE;
15130 /* Now that we have looked up the name, the OBJECT_TYPE (if any) is
15131 no longer valid. Note that if we are parsing tentatively, and
15132 the parse fails, OBJECT_TYPE will be automatically restored. */
15133 parser->context->object_type = NULL_TREE;
15135 if (name == error_mark_node)
15136 return error_mark_node;
15138 /* A template-id has already been resolved; there is no lookup to
15140 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
15142 if (BASELINK_P (name))
15144 gcc_assert (TREE_CODE (BASELINK_FUNCTIONS (name))
15145 == TEMPLATE_ID_EXPR);
15149 /* A BIT_NOT_EXPR is used to represent a destructor. By this point,
15150 it should already have been checked to make sure that the name
15151 used matches the type being destroyed. */
15152 if (TREE_CODE (name) == BIT_NOT_EXPR)
15156 /* Figure out to which type this destructor applies. */
15158 type = parser->scope;
15159 else if (object_type)
15160 type = object_type;
15162 type = current_class_type;
15163 /* If that's not a class type, there is no destructor. */
15164 if (!type || !CLASS_TYPE_P (type))
15165 return error_mark_node;
15166 if (CLASSTYPE_LAZY_DESTRUCTOR (type))
15167 lazily_declare_fn (sfk_destructor, type);
15168 if (!CLASSTYPE_DESTRUCTORS (type))
15169 return error_mark_node;
15170 /* If it was a class type, return the destructor. */
15171 return CLASSTYPE_DESTRUCTORS (type);
15174 /* By this point, the NAME should be an ordinary identifier. If
15175 the id-expression was a qualified name, the qualifying scope is
15176 stored in PARSER->SCOPE at this point. */
15177 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
15179 /* Perform the lookup. */
15184 if (parser->scope == error_mark_node)
15185 return error_mark_node;
15187 /* If the SCOPE is dependent, the lookup must be deferred until
15188 the template is instantiated -- unless we are explicitly
15189 looking up names in uninstantiated templates. Even then, we
15190 cannot look up the name if the scope is not a class type; it
15191 might, for example, be a template type parameter. */
15192 dependent_p = (TYPE_P (parser->scope)
15193 && !(parser->in_declarator_p
15194 && currently_open_class (parser->scope))
15195 && dependent_type_p (parser->scope));
15196 if ((check_dependency || !CLASS_TYPE_P (parser->scope))
15203 /* The resolution to Core Issue 180 says that `struct
15204 A::B' should be considered a type-name, even if `A'
15206 type = make_typename_type (parser->scope, name, tag_type,
15207 /*complain=*/tf_error);
15208 decl = TYPE_NAME (type);
15210 else if (is_template
15211 && (cp_parser_next_token_ends_template_argument_p (parser)
15212 || cp_lexer_next_token_is (parser->lexer,
15214 decl = make_unbound_class_template (parser->scope,
15216 /*complain=*/tf_error);
15218 decl = build_qualified_name (/*type=*/NULL_TREE,
15219 parser->scope, name,
15224 tree pushed_scope = NULL_TREE;
15226 /* If PARSER->SCOPE is a dependent type, then it must be a
15227 class type, and we must not be checking dependencies;
15228 otherwise, we would have processed this lookup above. So
15229 that PARSER->SCOPE is not considered a dependent base by
15230 lookup_member, we must enter the scope here. */
15232 pushed_scope = push_scope (parser->scope);
15233 /* If the PARSER->SCOPE is a template specialization, it
15234 may be instantiated during name lookup. In that case,
15235 errors may be issued. Even if we rollback the current
15236 tentative parse, those errors are valid. */
15237 decl = lookup_qualified_name (parser->scope, name,
15238 tag_type != none_type,
15239 /*complain=*/true);
15241 pop_scope (pushed_scope);
15243 parser->qualifying_scope = parser->scope;
15244 parser->object_scope = NULL_TREE;
15246 else if (object_type)
15248 tree object_decl = NULL_TREE;
15249 /* Look up the name in the scope of the OBJECT_TYPE, unless the
15250 OBJECT_TYPE is not a class. */
15251 if (CLASS_TYPE_P (object_type))
15252 /* If the OBJECT_TYPE is a template specialization, it may
15253 be instantiated during name lookup. In that case, errors
15254 may be issued. Even if we rollback the current tentative
15255 parse, those errors are valid. */
15256 object_decl = lookup_member (object_type,
15259 tag_type != none_type);
15260 /* Look it up in the enclosing context, too. */
15261 decl = lookup_name_real (name, tag_type != none_type,
15263 /*block_p=*/true, is_namespace, flags);
15264 parser->object_scope = object_type;
15265 parser->qualifying_scope = NULL_TREE;
15267 decl = object_decl;
15271 decl = lookup_name_real (name, tag_type != none_type,
15273 /*block_p=*/true, is_namespace, flags);
15274 parser->qualifying_scope = NULL_TREE;
15275 parser->object_scope = NULL_TREE;
15278 /* If the lookup failed, let our caller know. */
15279 if (!decl || decl == error_mark_node)
15280 return error_mark_node;
15282 /* If it's a TREE_LIST, the result of the lookup was ambiguous. */
15283 if (TREE_CODE (decl) == TREE_LIST)
15285 if (ambiguous_decls)
15286 *ambiguous_decls = decl;
15287 /* The error message we have to print is too complicated for
15288 cp_parser_error, so we incorporate its actions directly. */
15289 if (!cp_parser_simulate_error (parser))
15291 error ("reference to %qD is ambiguous", name);
15292 print_candidates (decl);
15294 return error_mark_node;
15297 gcc_assert (DECL_P (decl)
15298 || TREE_CODE (decl) == OVERLOAD
15299 || TREE_CODE (decl) == SCOPE_REF
15300 || TREE_CODE (decl) == UNBOUND_CLASS_TEMPLATE
15301 || BASELINK_P (decl));
15303 /* If we have resolved the name of a member declaration, check to
15304 see if the declaration is accessible. When the name resolves to
15305 set of overloaded functions, accessibility is checked when
15306 overload resolution is done.
15308 During an explicit instantiation, access is not checked at all,
15309 as per [temp.explicit]. */
15311 check_accessibility_of_qualified_id (decl, object_type, parser->scope);
15316 /* Like cp_parser_lookup_name, but for use in the typical case where
15317 CHECK_ACCESS is TRUE, IS_TYPE is FALSE, IS_TEMPLATE is FALSE,
15318 IS_NAMESPACE is FALSE, and CHECK_DEPENDENCY is TRUE. */
15321 cp_parser_lookup_name_simple (cp_parser* parser, tree name)
15323 return cp_parser_lookup_name (parser, name,
15325 /*is_template=*/false,
15326 /*is_namespace=*/false,
15327 /*check_dependency=*/true,
15328 /*ambiguous_decls=*/NULL);
15331 /* If DECL is a TEMPLATE_DECL that can be treated like a TYPE_DECL in
15332 the current context, return the TYPE_DECL. If TAG_NAME_P is
15333 true, the DECL indicates the class being defined in a class-head,
15334 or declared in an elaborated-type-specifier.
15336 Otherwise, return DECL. */
15339 cp_parser_maybe_treat_template_as_class (tree decl, bool tag_name_p)
15341 /* If the TEMPLATE_DECL is being declared as part of a class-head,
15342 the translation from TEMPLATE_DECL to TYPE_DECL occurs:
15345 template <typename T> struct B;
15348 template <typename T> struct A::B {};
15350 Similarly, in an elaborated-type-specifier:
15352 namespace N { struct X{}; }
15355 template <typename T> friend struct N::X;
15358 However, if the DECL refers to a class type, and we are in
15359 the scope of the class, then the name lookup automatically
15360 finds the TYPE_DECL created by build_self_reference rather
15361 than a TEMPLATE_DECL. For example, in:
15363 template <class T> struct S {
15367 there is no need to handle such case. */
15369 if (DECL_CLASS_TEMPLATE_P (decl) && tag_name_p)
15370 return DECL_TEMPLATE_RESULT (decl);
15375 /* If too many, or too few, template-parameter lists apply to the
15376 declarator, issue an error message. Returns TRUE if all went well,
15377 and FALSE otherwise. */
15380 cp_parser_check_declarator_template_parameters (cp_parser* parser,
15381 cp_declarator *declarator)
15383 unsigned num_templates;
15385 /* We haven't seen any classes that involve template parameters yet. */
15388 switch (declarator->kind)
15391 if (declarator->u.id.qualifying_scope)
15396 scope = declarator->u.id.qualifying_scope;
15397 member = declarator->u.id.unqualified_name;
15399 while (scope && CLASS_TYPE_P (scope))
15401 /* You're supposed to have one `template <...>'
15402 for every template class, but you don't need one
15403 for a full specialization. For example:
15405 template <class T> struct S{};
15406 template <> struct S<int> { void f(); };
15407 void S<int>::f () {}
15409 is correct; there shouldn't be a `template <>' for
15410 the definition of `S<int>::f'. */
15411 if (!CLASSTYPE_TEMPLATE_INFO (scope))
15412 /* If SCOPE does not have template information of any
15413 kind, then it is not a template, nor is it nested
15414 within a template. */
15416 if (explicit_class_specialization_p (scope))
15418 if (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (scope)))
15421 scope = TYPE_CONTEXT (scope);
15424 else if (TREE_CODE (declarator->u.id.unqualified_name)
15425 == TEMPLATE_ID_EXPR)
15426 /* If the DECLARATOR has the form `X<y>' then it uses one
15427 additional level of template parameters. */
15430 return cp_parser_check_template_parameters (parser,
15436 case cdk_reference:
15438 return (cp_parser_check_declarator_template_parameters
15439 (parser, declarator->declarator));
15445 gcc_unreachable ();
15450 /* NUM_TEMPLATES were used in the current declaration. If that is
15451 invalid, return FALSE and issue an error messages. Otherwise,
15455 cp_parser_check_template_parameters (cp_parser* parser,
15456 unsigned num_templates)
15458 /* If there are more template classes than parameter lists, we have
15461 template <class T> void S<T>::R<T>::f (); */
15462 if (parser->num_template_parameter_lists < num_templates)
15464 error ("too few template-parameter-lists");
15467 /* If there are the same number of template classes and parameter
15468 lists, that's OK. */
15469 if (parser->num_template_parameter_lists == num_templates)
15471 /* If there are more, but only one more, then we are referring to a
15472 member template. That's OK too. */
15473 if (parser->num_template_parameter_lists == num_templates + 1)
15475 /* Otherwise, there are too many template parameter lists. We have
15478 template <class T> template <class U> void S::f(); */
15479 error ("too many template-parameter-lists");
15483 /* Parse an optional `::' token indicating that the following name is
15484 from the global namespace. If so, PARSER->SCOPE is set to the
15485 GLOBAL_NAMESPACE. Otherwise, PARSER->SCOPE is set to NULL_TREE,
15486 unless CURRENT_SCOPE_VALID_P is TRUE, in which case it is left alone.
15487 Returns the new value of PARSER->SCOPE, if the `::' token is
15488 present, and NULL_TREE otherwise. */
15491 cp_parser_global_scope_opt (cp_parser* parser, bool current_scope_valid_p)
15495 /* Peek at the next token. */
15496 token = cp_lexer_peek_token (parser->lexer);
15497 /* If we're looking at a `::' token then we're starting from the
15498 global namespace, not our current location. */
15499 if (token->type == CPP_SCOPE)
15501 /* Consume the `::' token. */
15502 cp_lexer_consume_token (parser->lexer);
15503 /* Set the SCOPE so that we know where to start the lookup. */
15504 parser->scope = global_namespace;
15505 parser->qualifying_scope = global_namespace;
15506 parser->object_scope = NULL_TREE;
15508 return parser->scope;
15510 else if (!current_scope_valid_p)
15512 parser->scope = NULL_TREE;
15513 parser->qualifying_scope = NULL_TREE;
15514 parser->object_scope = NULL_TREE;
15520 /* Returns TRUE if the upcoming token sequence is the start of a
15521 constructor declarator. If FRIEND_P is true, the declarator is
15522 preceded by the `friend' specifier. */
15525 cp_parser_constructor_declarator_p (cp_parser *parser, bool friend_p)
15527 bool constructor_p;
15528 tree type_decl = NULL_TREE;
15529 bool nested_name_p;
15530 cp_token *next_token;
15532 /* The common case is that this is not a constructor declarator, so
15533 try to avoid doing lots of work if at all possible. It's not
15534 valid declare a constructor at function scope. */
15535 if (parser->in_function_body)
15537 /* And only certain tokens can begin a constructor declarator. */
15538 next_token = cp_lexer_peek_token (parser->lexer);
15539 if (next_token->type != CPP_NAME
15540 && next_token->type != CPP_SCOPE
15541 && next_token->type != CPP_NESTED_NAME_SPECIFIER
15542 && next_token->type != CPP_TEMPLATE_ID)
15545 /* Parse tentatively; we are going to roll back all of the tokens
15547 cp_parser_parse_tentatively (parser);
15548 /* Assume that we are looking at a constructor declarator. */
15549 constructor_p = true;
15551 /* Look for the optional `::' operator. */
15552 cp_parser_global_scope_opt (parser,
15553 /*current_scope_valid_p=*/false);
15554 /* Look for the nested-name-specifier. */
15556 = (cp_parser_nested_name_specifier_opt (parser,
15557 /*typename_keyword_p=*/false,
15558 /*check_dependency_p=*/false,
15560 /*is_declaration=*/false)
15562 /* Outside of a class-specifier, there must be a
15563 nested-name-specifier. */
15564 if (!nested_name_p &&
15565 (!at_class_scope_p () || !TYPE_BEING_DEFINED (current_class_type)
15567 constructor_p = false;
15568 /* If we still think that this might be a constructor-declarator,
15569 look for a class-name. */
15574 template <typename T> struct S { S(); };
15575 template <typename T> S<T>::S ();
15577 we must recognize that the nested `S' names a class.
15580 template <typename T> S<T>::S<T> ();
15582 we must recognize that the nested `S' names a template. */
15583 type_decl = cp_parser_class_name (parser,
15584 /*typename_keyword_p=*/false,
15585 /*template_keyword_p=*/false,
15587 /*check_dependency_p=*/false,
15588 /*class_head_p=*/false,
15589 /*is_declaration=*/false);
15590 /* If there was no class-name, then this is not a constructor. */
15591 constructor_p = !cp_parser_error_occurred (parser);
15594 /* If we're still considering a constructor, we have to see a `(',
15595 to begin the parameter-declaration-clause, followed by either a
15596 `)', an `...', or a decl-specifier. We need to check for a
15597 type-specifier to avoid being fooled into thinking that:
15601 is a constructor. (It is actually a function named `f' that
15602 takes one parameter (of type `int') and returns a value of type
15605 && cp_parser_require (parser, CPP_OPEN_PAREN, "`('"))
15607 if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN)
15608 && cp_lexer_next_token_is_not (parser->lexer, CPP_ELLIPSIS)
15609 /* A parameter declaration begins with a decl-specifier,
15610 which is either the "attribute" keyword, a storage class
15611 specifier, or (usually) a type-specifier. */
15612 && !cp_lexer_next_token_is_decl_specifier_keyword (parser->lexer))
15615 tree pushed_scope = NULL_TREE;
15616 unsigned saved_num_template_parameter_lists;
15618 /* Names appearing in the type-specifier should be looked up
15619 in the scope of the class. */
15620 if (current_class_type)
15624 type = TREE_TYPE (type_decl);
15625 if (TREE_CODE (type) == TYPENAME_TYPE)
15627 type = resolve_typename_type (type,
15628 /*only_current_p=*/false);
15629 if (type == error_mark_node)
15631 cp_parser_abort_tentative_parse (parser);
15635 pushed_scope = push_scope (type);
15638 /* Inside the constructor parameter list, surrounding
15639 template-parameter-lists do not apply. */
15640 saved_num_template_parameter_lists
15641 = parser->num_template_parameter_lists;
15642 parser->num_template_parameter_lists = 0;
15644 /* Look for the type-specifier. */
15645 cp_parser_type_specifier (parser,
15646 CP_PARSER_FLAGS_NONE,
15647 /*decl_specs=*/NULL,
15648 /*is_declarator=*/true,
15649 /*declares_class_or_enum=*/NULL,
15650 /*is_cv_qualifier=*/NULL);
15652 parser->num_template_parameter_lists
15653 = saved_num_template_parameter_lists;
15655 /* Leave the scope of the class. */
15657 pop_scope (pushed_scope);
15659 constructor_p = !cp_parser_error_occurred (parser);
15663 constructor_p = false;
15664 /* We did not really want to consume any tokens. */
15665 cp_parser_abort_tentative_parse (parser);
15667 return constructor_p;
15670 /* Parse the definition of the function given by the DECL_SPECIFIERS,
15671 ATTRIBUTES, and DECLARATOR. The access checks have been deferred;
15672 they must be performed once we are in the scope of the function.
15674 Returns the function defined. */
15677 cp_parser_function_definition_from_specifiers_and_declarator
15678 (cp_parser* parser,
15679 cp_decl_specifier_seq *decl_specifiers,
15681 const cp_declarator *declarator)
15686 /* Begin the function-definition. */
15687 success_p = start_function (decl_specifiers, declarator, attributes);
15689 /* The things we're about to see are not directly qualified by any
15690 template headers we've seen thus far. */
15691 reset_specialization ();
15693 /* If there were names looked up in the decl-specifier-seq that we
15694 did not check, check them now. We must wait until we are in the
15695 scope of the function to perform the checks, since the function
15696 might be a friend. */
15697 perform_deferred_access_checks ();
15701 /* Skip the entire function. */
15702 cp_parser_skip_to_end_of_block_or_statement (parser);
15703 fn = error_mark_node;
15705 else if (DECL_INITIAL (current_function_decl) != error_mark_node)
15707 /* Seen already, skip it. An error message has already been output. */
15708 cp_parser_skip_to_end_of_block_or_statement (parser);
15709 fn = current_function_decl;
15710 current_function_decl = NULL_TREE;
15711 /* If this is a function from a class, pop the nested class. */
15712 if (current_class_name)
15713 pop_nested_class ();
15716 fn = cp_parser_function_definition_after_declarator (parser,
15717 /*inline_p=*/false);
15722 /* Parse the part of a function-definition that follows the
15723 declarator. INLINE_P is TRUE iff this function is an inline
15724 function defined with a class-specifier.
15726 Returns the function defined. */
15729 cp_parser_function_definition_after_declarator (cp_parser* parser,
15733 bool ctor_initializer_p = false;
15734 bool saved_in_unbraced_linkage_specification_p;
15735 bool saved_in_function_body;
15736 unsigned saved_num_template_parameter_lists;
15738 saved_in_function_body = parser->in_function_body;
15739 parser->in_function_body = true;
15740 /* If the next token is `return', then the code may be trying to
15741 make use of the "named return value" extension that G++ used to
15743 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_RETURN))
15745 /* Consume the `return' keyword. */
15746 cp_lexer_consume_token (parser->lexer);
15747 /* Look for the identifier that indicates what value is to be
15749 cp_parser_identifier (parser);
15750 /* Issue an error message. */
15751 error ("named return values are no longer supported");
15752 /* Skip tokens until we reach the start of the function body. */
15755 cp_token *token = cp_lexer_peek_token (parser->lexer);
15756 if (token->type == CPP_OPEN_BRACE
15757 || token->type == CPP_EOF
15758 || token->type == CPP_PRAGMA_EOL)
15760 cp_lexer_consume_token (parser->lexer);
15763 /* The `extern' in `extern "C" void f () { ... }' does not apply to
15764 anything declared inside `f'. */
15765 saved_in_unbraced_linkage_specification_p
15766 = parser->in_unbraced_linkage_specification_p;
15767 parser->in_unbraced_linkage_specification_p = false;
15768 /* Inside the function, surrounding template-parameter-lists do not
15770 saved_num_template_parameter_lists
15771 = parser->num_template_parameter_lists;
15772 parser->num_template_parameter_lists = 0;
15773 /* If the next token is `try', then we are looking at a
15774 function-try-block. */
15775 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TRY))
15776 ctor_initializer_p = cp_parser_function_try_block (parser);
15777 /* A function-try-block includes the function-body, so we only do
15778 this next part if we're not processing a function-try-block. */
15781 = cp_parser_ctor_initializer_opt_and_function_body (parser);
15783 /* Finish the function. */
15784 fn = finish_function ((ctor_initializer_p ? 1 : 0) |
15785 (inline_p ? 2 : 0));
15786 /* Generate code for it, if necessary. */
15787 expand_or_defer_fn (fn);
15788 /* Restore the saved values. */
15789 parser->in_unbraced_linkage_specification_p
15790 = saved_in_unbraced_linkage_specification_p;
15791 parser->num_template_parameter_lists
15792 = saved_num_template_parameter_lists;
15793 parser->in_function_body = saved_in_function_body;
15798 /* Parse a template-declaration, assuming that the `export' (and
15799 `extern') keywords, if present, has already been scanned. MEMBER_P
15800 is as for cp_parser_template_declaration. */
15803 cp_parser_template_declaration_after_export (cp_parser* parser, bool member_p)
15805 tree decl = NULL_TREE;
15806 VEC (deferred_access_check,gc) *checks;
15807 tree parameter_list;
15808 bool friend_p = false;
15809 bool need_lang_pop;
15811 /* Look for the `template' keyword. */
15812 if (!cp_parser_require_keyword (parser, RID_TEMPLATE, "`template'"))
15816 if (!cp_parser_require (parser, CPP_LESS, "`<'"))
15818 if (at_class_scope_p () && current_function_decl)
15820 /* 14.5.2.2 [temp.mem]
15822 A local class shall not have member templates. */
15823 error ("invalid declaration of member template in local class");
15824 cp_parser_skip_to_end_of_block_or_statement (parser);
15829 A template ... shall not have C linkage. */
15830 if (current_lang_name == lang_name_c)
15832 error ("template with C linkage");
15833 /* Give it C++ linkage to avoid confusing other parts of the
15835 push_lang_context (lang_name_cplusplus);
15836 need_lang_pop = true;
15839 need_lang_pop = false;
15841 /* We cannot perform access checks on the template parameter
15842 declarations until we know what is being declared, just as we
15843 cannot check the decl-specifier list. */
15844 push_deferring_access_checks (dk_deferred);
15846 /* If the next token is `>', then we have an invalid
15847 specialization. Rather than complain about an invalid template
15848 parameter, issue an error message here. */
15849 if (cp_lexer_next_token_is (parser->lexer, CPP_GREATER))
15851 cp_parser_error (parser, "invalid explicit specialization");
15852 begin_specialization ();
15853 parameter_list = NULL_TREE;
15856 /* Parse the template parameters. */
15857 parameter_list = cp_parser_template_parameter_list (parser);
15859 /* Get the deferred access checks from the parameter list. These
15860 will be checked once we know what is being declared, as for a
15861 member template the checks must be performed in the scope of the
15862 class containing the member. */
15863 checks = get_deferred_access_checks ();
15865 /* Look for the `>'. */
15866 cp_parser_skip_to_end_of_template_parameter_list (parser);
15867 /* We just processed one more parameter list. */
15868 ++parser->num_template_parameter_lists;
15869 /* If the next token is `template', there are more template
15871 if (cp_lexer_next_token_is_keyword (parser->lexer,
15873 cp_parser_template_declaration_after_export (parser, member_p);
15876 /* There are no access checks when parsing a template, as we do not
15877 know if a specialization will be a friend. */
15878 push_deferring_access_checks (dk_no_check);
15879 decl = cp_parser_single_declaration (parser,
15883 pop_deferring_access_checks ();
15885 /* If this is a member template declaration, let the front
15887 if (member_p && !friend_p && decl)
15889 if (TREE_CODE (decl) == TYPE_DECL)
15890 cp_parser_check_access_in_redeclaration (decl);
15892 decl = finish_member_template_decl (decl);
15894 else if (friend_p && decl && TREE_CODE (decl) == TYPE_DECL)
15895 make_friend_class (current_class_type, TREE_TYPE (decl),
15896 /*complain=*/true);
15898 /* We are done with the current parameter list. */
15899 --parser->num_template_parameter_lists;
15901 pop_deferring_access_checks ();
15904 finish_template_decl (parameter_list);
15906 /* Register member declarations. */
15907 if (member_p && !friend_p && decl && !DECL_CLASS_TEMPLATE_P (decl))
15908 finish_member_declaration (decl);
15909 /* For the erroneous case of a template with C linkage, we pushed an
15910 implicit C++ linkage scope; exit that scope now. */
15912 pop_lang_context ();
15913 /* If DECL is a function template, we must return to parse it later.
15914 (Even though there is no definition, there might be default
15915 arguments that need handling.) */
15916 if (member_p && decl
15917 && (TREE_CODE (decl) == FUNCTION_DECL
15918 || DECL_FUNCTION_TEMPLATE_P (decl)))
15919 TREE_VALUE (parser->unparsed_functions_queues)
15920 = tree_cons (NULL_TREE, decl,
15921 TREE_VALUE (parser->unparsed_functions_queues));
15924 /* Perform the deferred access checks from a template-parameter-list.
15925 CHECKS is a TREE_LIST of access checks, as returned by
15926 get_deferred_access_checks. */
15929 cp_parser_perform_template_parameter_access_checks (VEC (deferred_access_check,gc)* checks)
15931 ++processing_template_parmlist;
15932 perform_access_checks (checks);
15933 --processing_template_parmlist;
15936 /* Parse a `decl-specifier-seq [opt] init-declarator [opt] ;' or
15937 `function-definition' sequence. MEMBER_P is true, this declaration
15938 appears in a class scope.
15940 Returns the DECL for the declared entity. If FRIEND_P is non-NULL,
15941 *FRIEND_P is set to TRUE iff the declaration is a friend. */
15944 cp_parser_single_declaration (cp_parser* parser,
15945 VEC (deferred_access_check,gc)* checks,
15949 int declares_class_or_enum;
15950 tree decl = NULL_TREE;
15951 cp_decl_specifier_seq decl_specifiers;
15952 bool function_definition_p = false;
15954 /* This function is only used when processing a template
15956 gcc_assert (innermost_scope_kind () == sk_template_parms
15957 || innermost_scope_kind () == sk_template_spec);
15959 /* Defer access checks until we know what is being declared. */
15960 push_deferring_access_checks (dk_deferred);
15962 /* Try the `decl-specifier-seq [opt] init-declarator [opt]'
15964 cp_parser_decl_specifier_seq (parser,
15965 CP_PARSER_FLAGS_OPTIONAL,
15967 &declares_class_or_enum);
15969 *friend_p = cp_parser_friend_p (&decl_specifiers);
15971 /* There are no template typedefs. */
15972 if (decl_specifiers.specs[(int) ds_typedef])
15974 error ("template declaration of %qs", "typedef");
15975 decl = error_mark_node;
15978 /* Gather up the access checks that occurred the
15979 decl-specifier-seq. */
15980 stop_deferring_access_checks ();
15982 /* Check for the declaration of a template class. */
15983 if (declares_class_or_enum)
15985 if (cp_parser_declares_only_class_p (parser))
15987 decl = shadow_tag (&decl_specifiers);
15992 friend template <typename T> struct A<T>::B;
15995 A<T>::B will be represented by a TYPENAME_TYPE, and
15996 therefore not recognized by shadow_tag. */
15997 if (friend_p && *friend_p
15999 && decl_specifiers.type
16000 && TYPE_P (decl_specifiers.type))
16001 decl = decl_specifiers.type;
16003 if (decl && decl != error_mark_node)
16004 decl = TYPE_NAME (decl);
16006 decl = error_mark_node;
16008 /* Perform access checks for template parameters. */
16009 cp_parser_perform_template_parameter_access_checks (checks);
16012 /* If it's not a template class, try for a template function. If
16013 the next token is a `;', then this declaration does not declare
16014 anything. But, if there were errors in the decl-specifiers, then
16015 the error might well have come from an attempted class-specifier.
16016 In that case, there's no need to warn about a missing declarator. */
16018 && (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON)
16019 || decl_specifiers.type != error_mark_node))
16020 decl = cp_parser_init_declarator (parser,
16023 /*function_definition_allowed_p=*/true,
16025 declares_class_or_enum,
16026 &function_definition_p);
16028 pop_deferring_access_checks ();
16030 /* Clear any current qualification; whatever comes next is the start
16031 of something new. */
16032 parser->scope = NULL_TREE;
16033 parser->qualifying_scope = NULL_TREE;
16034 parser->object_scope = NULL_TREE;
16035 /* Look for a trailing `;' after the declaration. */
16036 if (!function_definition_p
16037 && (decl == error_mark_node
16038 || !cp_parser_require (parser, CPP_SEMICOLON, "`;'")))
16039 cp_parser_skip_to_end_of_block_or_statement (parser);
16044 /* Parse a cast-expression that is not the operand of a unary "&". */
16047 cp_parser_simple_cast_expression (cp_parser *parser)
16049 return cp_parser_cast_expression (parser, /*address_p=*/false,
16053 /* Parse a functional cast to TYPE. Returns an expression
16054 representing the cast. */
16057 cp_parser_functional_cast (cp_parser* parser, tree type)
16059 tree expression_list;
16063 = cp_parser_parenthesized_expression_list (parser, false,
16065 /*non_constant_p=*/NULL);
16067 cast = build_functional_cast (type, expression_list);
16068 /* [expr.const]/1: In an integral constant expression "only type
16069 conversions to integral or enumeration type can be used". */
16070 if (TREE_CODE (type) == TYPE_DECL)
16071 type = TREE_TYPE (type);
16072 if (cast != error_mark_node
16073 && !cast_valid_in_integral_constant_expression_p (type)
16074 && (cp_parser_non_integral_constant_expression
16075 (parser, "a call to a constructor")))
16076 return error_mark_node;
16080 /* Save the tokens that make up the body of a member function defined
16081 in a class-specifier. The DECL_SPECIFIERS and DECLARATOR have
16082 already been parsed. The ATTRIBUTES are any GNU "__attribute__"
16083 specifiers applied to the declaration. Returns the FUNCTION_DECL
16084 for the member function. */
16087 cp_parser_save_member_function_body (cp_parser* parser,
16088 cp_decl_specifier_seq *decl_specifiers,
16089 cp_declarator *declarator,
16096 /* Create the function-declaration. */
16097 fn = start_method (decl_specifiers, declarator, attributes);
16098 /* If something went badly wrong, bail out now. */
16099 if (fn == error_mark_node)
16101 /* If there's a function-body, skip it. */
16102 if (cp_parser_token_starts_function_definition_p
16103 (cp_lexer_peek_token (parser->lexer)))
16104 cp_parser_skip_to_end_of_block_or_statement (parser);
16105 return error_mark_node;
16108 /* Remember it, if there default args to post process. */
16109 cp_parser_save_default_args (parser, fn);
16111 /* Save away the tokens that make up the body of the
16113 first = parser->lexer->next_token;
16114 cp_parser_cache_group (parser, CPP_CLOSE_BRACE, /*depth=*/0);
16115 /* Handle function try blocks. */
16116 while (cp_lexer_next_token_is_keyword (parser->lexer, RID_CATCH))
16117 cp_parser_cache_group (parser, CPP_CLOSE_BRACE, /*depth=*/0);
16118 last = parser->lexer->next_token;
16120 /* Save away the inline definition; we will process it when the
16121 class is complete. */
16122 DECL_PENDING_INLINE_INFO (fn) = cp_token_cache_new (first, last);
16123 DECL_PENDING_INLINE_P (fn) = 1;
16125 /* We need to know that this was defined in the class, so that
16126 friend templates are handled correctly. */
16127 DECL_INITIALIZED_IN_CLASS_P (fn) = 1;
16129 /* We're done with the inline definition. */
16130 finish_method (fn);
16132 /* Add FN to the queue of functions to be parsed later. */
16133 TREE_VALUE (parser->unparsed_functions_queues)
16134 = tree_cons (NULL_TREE, fn,
16135 TREE_VALUE (parser->unparsed_functions_queues));
16140 /* Parse a template-argument-list, as well as the trailing ">" (but
16141 not the opening ">"). See cp_parser_template_argument_list for the
16145 cp_parser_enclosed_template_argument_list (cp_parser* parser)
16149 tree saved_qualifying_scope;
16150 tree saved_object_scope;
16151 bool saved_greater_than_is_operator_p;
16152 bool saved_skip_evaluation;
16156 When parsing a template-id, the first non-nested `>' is taken as
16157 the end of the template-argument-list rather than a greater-than
16159 saved_greater_than_is_operator_p
16160 = parser->greater_than_is_operator_p;
16161 parser->greater_than_is_operator_p = false;
16162 /* Parsing the argument list may modify SCOPE, so we save it
16164 saved_scope = parser->scope;
16165 saved_qualifying_scope = parser->qualifying_scope;
16166 saved_object_scope = parser->object_scope;
16167 /* We need to evaluate the template arguments, even though this
16168 template-id may be nested within a "sizeof". */
16169 saved_skip_evaluation = skip_evaluation;
16170 skip_evaluation = false;
16171 /* Parse the template-argument-list itself. */
16172 if (cp_lexer_next_token_is (parser->lexer, CPP_GREATER))
16173 arguments = NULL_TREE;
16175 arguments = cp_parser_template_argument_list (parser);
16176 /* Look for the `>' that ends the template-argument-list. If we find
16177 a '>>' instead, it's probably just a typo. */
16178 if (cp_lexer_next_token_is (parser->lexer, CPP_RSHIFT))
16180 if (!saved_greater_than_is_operator_p)
16182 /* If we're in a nested template argument list, the '>>' has
16183 to be a typo for '> >'. We emit the error message, but we
16184 continue parsing and we push a '>' as next token, so that
16185 the argument list will be parsed correctly. Note that the
16186 global source location is still on the token before the
16187 '>>', so we need to say explicitly where we want it. */
16188 cp_token *token = cp_lexer_peek_token (parser->lexer);
16189 error ("%H%<>>%> should be %<> >%> "
16190 "within a nested template argument list",
16193 /* ??? Proper recovery should terminate two levels of
16194 template argument list here. */
16195 token->type = CPP_GREATER;
16199 /* If this is not a nested template argument list, the '>>'
16200 is a typo for '>'. Emit an error message and continue.
16201 Same deal about the token location, but here we can get it
16202 right by consuming the '>>' before issuing the diagnostic. */
16203 cp_lexer_consume_token (parser->lexer);
16204 error ("spurious %<>>%>, use %<>%> to terminate "
16205 "a template argument list");
16209 cp_parser_skip_to_end_of_template_parameter_list (parser);
16210 /* The `>' token might be a greater-than operator again now. */
16211 parser->greater_than_is_operator_p
16212 = saved_greater_than_is_operator_p;
16213 /* Restore the SAVED_SCOPE. */
16214 parser->scope = saved_scope;
16215 parser->qualifying_scope = saved_qualifying_scope;
16216 parser->object_scope = saved_object_scope;
16217 skip_evaluation = saved_skip_evaluation;
16222 /* MEMBER_FUNCTION is a member function, or a friend. If default
16223 arguments, or the body of the function have not yet been parsed,
16227 cp_parser_late_parsing_for_member (cp_parser* parser, tree member_function)
16229 /* If this member is a template, get the underlying
16231 if (DECL_FUNCTION_TEMPLATE_P (member_function))
16232 member_function = DECL_TEMPLATE_RESULT (member_function);
16234 /* There should not be any class definitions in progress at this
16235 point; the bodies of members are only parsed outside of all class
16237 gcc_assert (parser->num_classes_being_defined == 0);
16238 /* While we're parsing the member functions we might encounter more
16239 classes. We want to handle them right away, but we don't want
16240 them getting mixed up with functions that are currently in the
16242 parser->unparsed_functions_queues
16243 = tree_cons (NULL_TREE, NULL_TREE, parser->unparsed_functions_queues);
16245 /* Make sure that any template parameters are in scope. */
16246 maybe_begin_member_template_processing (member_function);
16248 /* If the body of the function has not yet been parsed, parse it
16250 if (DECL_PENDING_INLINE_P (member_function))
16252 tree function_scope;
16253 cp_token_cache *tokens;
16255 /* The function is no longer pending; we are processing it. */
16256 tokens = DECL_PENDING_INLINE_INFO (member_function);
16257 DECL_PENDING_INLINE_INFO (member_function) = NULL;
16258 DECL_PENDING_INLINE_P (member_function) = 0;
16260 /* If this is a local class, enter the scope of the containing
16262 function_scope = current_function_decl;
16263 if (function_scope)
16264 push_function_context_to (function_scope);
16267 /* Push the body of the function onto the lexer stack. */
16268 cp_parser_push_lexer_for_tokens (parser, tokens);
16270 /* Let the front end know that we going to be defining this
16272 start_preparsed_function (member_function, NULL_TREE,
16273 SF_PRE_PARSED | SF_INCLASS_INLINE);
16275 /* Don't do access checking if it is a templated function. */
16276 if (processing_template_decl)
16277 push_deferring_access_checks (dk_no_check);
16279 /* Now, parse the body of the function. */
16280 cp_parser_function_definition_after_declarator (parser,
16281 /*inline_p=*/true);
16283 if (processing_template_decl)
16284 pop_deferring_access_checks ();
16286 /* Leave the scope of the containing function. */
16287 if (function_scope)
16288 pop_function_context_from (function_scope);
16289 cp_parser_pop_lexer (parser);
16292 /* Remove any template parameters from the symbol table. */
16293 maybe_end_member_template_processing ();
16295 /* Restore the queue. */
16296 parser->unparsed_functions_queues
16297 = TREE_CHAIN (parser->unparsed_functions_queues);
16300 /* If DECL contains any default args, remember it on the unparsed
16301 functions queue. */
16304 cp_parser_save_default_args (cp_parser* parser, tree decl)
16308 for (probe = TYPE_ARG_TYPES (TREE_TYPE (decl));
16310 probe = TREE_CHAIN (probe))
16311 if (TREE_PURPOSE (probe))
16313 TREE_PURPOSE (parser->unparsed_functions_queues)
16314 = tree_cons (current_class_type, decl,
16315 TREE_PURPOSE (parser->unparsed_functions_queues));
16320 /* FN is a FUNCTION_DECL which may contains a parameter with an
16321 unparsed DEFAULT_ARG. Parse the default args now. This function
16322 assumes that the current scope is the scope in which the default
16323 argument should be processed. */
16326 cp_parser_late_parsing_default_args (cp_parser *parser, tree fn)
16328 bool saved_local_variables_forbidden_p;
16331 /* While we're parsing the default args, we might (due to the
16332 statement expression extension) encounter more classes. We want
16333 to handle them right away, but we don't want them getting mixed
16334 up with default args that are currently in the queue. */
16335 parser->unparsed_functions_queues
16336 = tree_cons (NULL_TREE, NULL_TREE, parser->unparsed_functions_queues);
16338 /* Local variable names (and the `this' keyword) may not appear
16339 in a default argument. */
16340 saved_local_variables_forbidden_p = parser->local_variables_forbidden_p;
16341 parser->local_variables_forbidden_p = true;
16343 for (parm = TYPE_ARG_TYPES (TREE_TYPE (fn));
16345 parm = TREE_CHAIN (parm))
16347 cp_token_cache *tokens;
16348 tree default_arg = TREE_PURPOSE (parm);
16350 VEC(tree,gc) *insts;
16357 if (TREE_CODE (default_arg) != DEFAULT_ARG)
16358 /* This can happen for a friend declaration for a function
16359 already declared with default arguments. */
16362 /* Push the saved tokens for the default argument onto the parser's
16364 tokens = DEFARG_TOKENS (default_arg);
16365 cp_parser_push_lexer_for_tokens (parser, tokens);
16367 /* Parse the assignment-expression. */
16368 parsed_arg = cp_parser_assignment_expression (parser, /*cast_p=*/false);
16370 if (!processing_template_decl)
16371 parsed_arg = check_default_argument (TREE_VALUE (parm), parsed_arg);
16373 TREE_PURPOSE (parm) = parsed_arg;
16375 /* Update any instantiations we've already created. */
16376 for (insts = DEFARG_INSTANTIATIONS (default_arg), ix = 0;
16377 VEC_iterate (tree, insts, ix, copy); ix++)
16378 TREE_PURPOSE (copy) = parsed_arg;
16380 /* If the token stream has not been completely used up, then
16381 there was extra junk after the end of the default
16383 if (!cp_lexer_next_token_is (parser->lexer, CPP_EOF))
16384 cp_parser_error (parser, "expected %<,%>");
16386 /* Revert to the main lexer. */
16387 cp_parser_pop_lexer (parser);
16390 /* Make sure no default arg is missing. */
16391 check_default_args (fn);
16393 /* Restore the state of local_variables_forbidden_p. */
16394 parser->local_variables_forbidden_p = saved_local_variables_forbidden_p;
16396 /* Restore the queue. */
16397 parser->unparsed_functions_queues
16398 = TREE_CHAIN (parser->unparsed_functions_queues);
16401 /* Parse the operand of `sizeof' (or a similar operator). Returns
16402 either a TYPE or an expression, depending on the form of the
16403 input. The KEYWORD indicates which kind of expression we have
16407 cp_parser_sizeof_operand (cp_parser* parser, enum rid keyword)
16409 static const char *format;
16410 tree expr = NULL_TREE;
16411 const char *saved_message;
16412 bool saved_integral_constant_expression_p;
16413 bool saved_non_integral_constant_expression_p;
16415 /* Initialize FORMAT the first time we get here. */
16417 format = "types may not be defined in '%s' expressions";
16419 /* Types cannot be defined in a `sizeof' expression. Save away the
16421 saved_message = parser->type_definition_forbidden_message;
16422 /* And create the new one. */
16423 parser->type_definition_forbidden_message
16424 = XNEWVEC (const char, strlen (format)
16425 + strlen (IDENTIFIER_POINTER (ridpointers[keyword]))
16427 sprintf ((char *) parser->type_definition_forbidden_message,
16428 format, IDENTIFIER_POINTER (ridpointers[keyword]));
16430 /* The restrictions on constant-expressions do not apply inside
16431 sizeof expressions. */
16432 saved_integral_constant_expression_p
16433 = parser->integral_constant_expression_p;
16434 saved_non_integral_constant_expression_p
16435 = parser->non_integral_constant_expression_p;
16436 parser->integral_constant_expression_p = false;
16438 /* Do not actually evaluate the expression. */
16440 /* If it's a `(', then we might be looking at the type-id
16442 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
16445 bool saved_in_type_id_in_expr_p;
16447 /* We can't be sure yet whether we're looking at a type-id or an
16449 cp_parser_parse_tentatively (parser);
16450 /* Consume the `('. */
16451 cp_lexer_consume_token (parser->lexer);
16452 /* Parse the type-id. */
16453 saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p;
16454 parser->in_type_id_in_expr_p = true;
16455 type = cp_parser_type_id (parser);
16456 parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
16457 /* Now, look for the trailing `)'. */
16458 cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>");
16459 /* If all went well, then we're done. */
16460 if (cp_parser_parse_definitely (parser))
16462 cp_decl_specifier_seq decl_specs;
16464 /* Build a trivial decl-specifier-seq. */
16465 clear_decl_specs (&decl_specs);
16466 decl_specs.type = type;
16468 /* Call grokdeclarator to figure out what type this is. */
16469 expr = grokdeclarator (NULL,
16473 /*attrlist=*/NULL);
16477 /* If the type-id production did not work out, then we must be
16478 looking at the unary-expression production. */
16480 expr = cp_parser_unary_expression (parser, /*address_p=*/false,
16482 /* Go back to evaluating expressions. */
16485 /* Free the message we created. */
16486 free ((char *) parser->type_definition_forbidden_message);
16487 /* And restore the old one. */
16488 parser->type_definition_forbidden_message = saved_message;
16489 parser->integral_constant_expression_p
16490 = saved_integral_constant_expression_p;
16491 parser->non_integral_constant_expression_p
16492 = saved_non_integral_constant_expression_p;
16497 /* If the current declaration has no declarator, return true. */
16500 cp_parser_declares_only_class_p (cp_parser *parser)
16502 /* If the next token is a `;' or a `,' then there is no
16504 return (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)
16505 || cp_lexer_next_token_is (parser->lexer, CPP_COMMA));
16508 /* Update the DECL_SPECS to reflect the storage class indicated by
16512 cp_parser_set_storage_class (cp_parser *parser,
16513 cp_decl_specifier_seq *decl_specs,
16516 cp_storage_class storage_class;
16518 if (parser->in_unbraced_linkage_specification_p)
16520 error ("invalid use of %qD in linkage specification",
16521 ridpointers[keyword]);
16524 else if (decl_specs->storage_class != sc_none)
16526 decl_specs->conflicting_specifiers_p = true;
16530 if ((keyword == RID_EXTERN || keyword == RID_STATIC)
16531 && decl_specs->specs[(int) ds_thread])
16533 error ("%<__thread%> before %qD", ridpointers[keyword]);
16534 decl_specs->specs[(int) ds_thread] = 0;
16540 storage_class = sc_auto;
16543 storage_class = sc_register;
16546 storage_class = sc_static;
16549 storage_class = sc_extern;
16552 storage_class = sc_mutable;
16555 gcc_unreachable ();
16557 decl_specs->storage_class = storage_class;
16559 /* A storage class specifier cannot be applied alongside a typedef
16560 specifier. If there is a typedef specifier present then set
16561 conflicting_specifiers_p which will trigger an error later
16562 on in grokdeclarator. */
16563 if (decl_specs->specs[(int)ds_typedef])
16564 decl_specs->conflicting_specifiers_p = true;
16567 /* Update the DECL_SPECS to reflect the TYPE_SPEC. If USER_DEFINED_P
16568 is true, the type is a user-defined type; otherwise it is a
16569 built-in type specified by a keyword. */
16572 cp_parser_set_decl_spec_type (cp_decl_specifier_seq *decl_specs,
16574 bool user_defined_p)
16576 decl_specs->any_specifiers_p = true;
16578 /* If the user tries to redeclare bool or wchar_t (with, for
16579 example, in "typedef int wchar_t;") we remember that this is what
16580 happened. In system headers, we ignore these declarations so
16581 that G++ can work with system headers that are not C++-safe. */
16582 if (decl_specs->specs[(int) ds_typedef]
16584 && (type_spec == boolean_type_node
16585 || type_spec == wchar_type_node)
16586 && (decl_specs->type
16587 || decl_specs->specs[(int) ds_long]
16588 || decl_specs->specs[(int) ds_short]
16589 || decl_specs->specs[(int) ds_unsigned]
16590 || decl_specs->specs[(int) ds_signed]))
16592 decl_specs->redefined_builtin_type = type_spec;
16593 if (!decl_specs->type)
16595 decl_specs->type = type_spec;
16596 decl_specs->user_defined_type_p = false;
16599 else if (decl_specs->type)
16600 decl_specs->multiple_types_p = true;
16603 decl_specs->type = type_spec;
16604 decl_specs->user_defined_type_p = user_defined_p;
16605 decl_specs->redefined_builtin_type = NULL_TREE;
16609 /* DECL_SPECIFIERS is the representation of a decl-specifier-seq.
16610 Returns TRUE iff `friend' appears among the DECL_SPECIFIERS. */
16613 cp_parser_friend_p (const cp_decl_specifier_seq *decl_specifiers)
16615 return decl_specifiers->specs[(int) ds_friend] != 0;
16618 /* If the next token is of the indicated TYPE, consume it. Otherwise,
16619 issue an error message indicating that TOKEN_DESC was expected.
16621 Returns the token consumed, if the token had the appropriate type.
16622 Otherwise, returns NULL. */
16625 cp_parser_require (cp_parser* parser,
16626 enum cpp_ttype type,
16627 const char* token_desc)
16629 if (cp_lexer_next_token_is (parser->lexer, type))
16630 return cp_lexer_consume_token (parser->lexer);
16633 /* Output the MESSAGE -- unless we're parsing tentatively. */
16634 if (!cp_parser_simulate_error (parser))
16636 char *message = concat ("expected ", token_desc, NULL);
16637 cp_parser_error (parser, message);
16644 /* An error message is produced if the next token is not '>'.
16645 All further tokens are skipped until the desired token is
16646 found or '{', '}', ';' or an unbalanced ')' or ']'. */
16649 cp_parser_skip_to_end_of_template_parameter_list (cp_parser* parser)
16651 /* Current level of '< ... >'. */
16652 unsigned level = 0;
16653 /* Ignore '<' and '>' nested inside '( ... )' or '[ ... ]'. */
16654 unsigned nesting_depth = 0;
16656 /* Are we ready, yet? If not, issue error message. */
16657 if (cp_parser_require (parser, CPP_GREATER, "%<>%>"))
16660 /* Skip tokens until the desired token is found. */
16663 /* Peek at the next token. */
16664 switch (cp_lexer_peek_token (parser->lexer)->type)
16667 if (!nesting_depth)
16672 if (!nesting_depth && level-- == 0)
16674 /* We've reached the token we want, consume it and stop. */
16675 cp_lexer_consume_token (parser->lexer);
16680 case CPP_OPEN_PAREN:
16681 case CPP_OPEN_SQUARE:
16685 case CPP_CLOSE_PAREN:
16686 case CPP_CLOSE_SQUARE:
16687 if (nesting_depth-- == 0)
16692 case CPP_PRAGMA_EOL:
16693 case CPP_SEMICOLON:
16694 case CPP_OPEN_BRACE:
16695 case CPP_CLOSE_BRACE:
16696 /* The '>' was probably forgotten, don't look further. */
16703 /* Consume this token. */
16704 cp_lexer_consume_token (parser->lexer);
16708 /* If the next token is the indicated keyword, consume it. Otherwise,
16709 issue an error message indicating that TOKEN_DESC was expected.
16711 Returns the token consumed, if the token had the appropriate type.
16712 Otherwise, returns NULL. */
16715 cp_parser_require_keyword (cp_parser* parser,
16717 const char* token_desc)
16719 cp_token *token = cp_parser_require (parser, CPP_KEYWORD, token_desc);
16721 if (token && token->keyword != keyword)
16723 dyn_string_t error_msg;
16725 /* Format the error message. */
16726 error_msg = dyn_string_new (0);
16727 dyn_string_append_cstr (error_msg, "expected ");
16728 dyn_string_append_cstr (error_msg, token_desc);
16729 cp_parser_error (parser, error_msg->s);
16730 dyn_string_delete (error_msg);
16737 /* Returns TRUE iff TOKEN is a token that can begin the body of a
16738 function-definition. */
16741 cp_parser_token_starts_function_definition_p (cp_token* token)
16743 return (/* An ordinary function-body begins with an `{'. */
16744 token->type == CPP_OPEN_BRACE
16745 /* A ctor-initializer begins with a `:'. */
16746 || token->type == CPP_COLON
16747 /* A function-try-block begins with `try'. */
16748 || token->keyword == RID_TRY
16749 /* The named return value extension begins with `return'. */
16750 || token->keyword == RID_RETURN);
16753 /* Returns TRUE iff the next token is the ":" or "{" beginning a class
16757 cp_parser_next_token_starts_class_definition_p (cp_parser *parser)
16761 token = cp_lexer_peek_token (parser->lexer);
16762 return (token->type == CPP_OPEN_BRACE || token->type == CPP_COLON);
16765 /* Returns TRUE iff the next token is the "," or ">" ending a
16766 template-argument. */
16769 cp_parser_next_token_ends_template_argument_p (cp_parser *parser)
16773 token = cp_lexer_peek_token (parser->lexer);
16774 return (token->type == CPP_COMMA || token->type == CPP_GREATER);
16777 /* Returns TRUE iff the n-th token is a "<", or the n-th is a "[" and the
16778 (n+1)-th is a ":" (which is a possible digraph typo for "< ::"). */
16781 cp_parser_nth_token_starts_template_argument_list_p (cp_parser * parser,
16786 token = cp_lexer_peek_nth_token (parser->lexer, n);
16787 if (token->type == CPP_LESS)
16789 /* Check for the sequence `<::' in the original code. It would be lexed as
16790 `[:', where `[' is a digraph, and there is no whitespace before
16792 if (token->type == CPP_OPEN_SQUARE && token->flags & DIGRAPH)
16795 token2 = cp_lexer_peek_nth_token (parser->lexer, n+1);
16796 if (token2->type == CPP_COLON && !(token2->flags & PREV_WHITE))
16802 /* Returns the kind of tag indicated by TOKEN, if it is a class-key,
16803 or none_type otherwise. */
16805 static enum tag_types
16806 cp_parser_token_is_class_key (cp_token* token)
16808 switch (token->keyword)
16813 return record_type;
16822 /* Issue an error message if the CLASS_KEY does not match the TYPE. */
16825 cp_parser_check_class_key (enum tag_types class_key, tree type)
16827 if ((TREE_CODE (type) == UNION_TYPE) != (class_key == union_type))
16828 pedwarn ("%qs tag used in naming %q#T",
16829 class_key == union_type ? "union"
16830 : class_key == record_type ? "struct" : "class",
16834 /* Issue an error message if DECL is redeclared with different
16835 access than its original declaration [class.access.spec/3].
16836 This applies to nested classes and nested class templates.
16840 cp_parser_check_access_in_redeclaration (tree decl)
16842 if (!CLASS_TYPE_P (TREE_TYPE (decl)))
16845 if ((TREE_PRIVATE (decl)
16846 != (current_access_specifier == access_private_node))
16847 || (TREE_PROTECTED (decl)
16848 != (current_access_specifier == access_protected_node)))
16849 error ("%qD redeclared with different access", decl);
16852 /* Look for the `template' keyword, as a syntactic disambiguator.
16853 Return TRUE iff it is present, in which case it will be
16857 cp_parser_optional_template_keyword (cp_parser *parser)
16859 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
16861 /* The `template' keyword can only be used within templates;
16862 outside templates the parser can always figure out what is a
16863 template and what is not. */
16864 if (!processing_template_decl)
16866 error ("%<template%> (as a disambiguator) is only allowed "
16867 "within templates");
16868 /* If this part of the token stream is rescanned, the same
16869 error message would be generated. So, we purge the token
16870 from the stream. */
16871 cp_lexer_purge_token (parser->lexer);
16876 /* Consume the `template' keyword. */
16877 cp_lexer_consume_token (parser->lexer);
16885 /* The next token is a CPP_NESTED_NAME_SPECIFIER. Consume the token,
16886 set PARSER->SCOPE, and perform other related actions. */
16889 cp_parser_pre_parsed_nested_name_specifier (cp_parser *parser)
16892 struct tree_check *check_value;
16893 deferred_access_check *chk;
16894 VEC (deferred_access_check,gc) *checks;
16896 /* Get the stored value. */
16897 check_value = cp_lexer_consume_token (parser->lexer)->u.tree_check_value;
16898 /* Perform any access checks that were deferred. */
16899 checks = check_value->checks;
16903 VEC_iterate (deferred_access_check, checks, i, chk) ;
16906 perform_or_defer_access_check (chk->binfo,
16911 /* Set the scope from the stored value. */
16912 parser->scope = check_value->value;
16913 parser->qualifying_scope = check_value->qualifying_scope;
16914 parser->object_scope = NULL_TREE;
16917 /* Consume tokens up through a non-nested END token. */
16920 cp_parser_cache_group (cp_parser *parser,
16921 enum cpp_ttype end,
16928 /* Abort a parenthesized expression if we encounter a brace. */
16929 if ((end == CPP_CLOSE_PAREN || depth == 0)
16930 && cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
16932 /* If we've reached the end of the file, stop. */
16933 if (cp_lexer_next_token_is (parser->lexer, CPP_EOF)
16934 || (end != CPP_PRAGMA_EOL
16935 && cp_lexer_next_token_is (parser->lexer, CPP_PRAGMA_EOL)))
16937 /* Consume the next token. */
16938 token = cp_lexer_consume_token (parser->lexer);
16939 /* See if it starts a new group. */
16940 if (token->type == CPP_OPEN_BRACE)
16942 cp_parser_cache_group (parser, CPP_CLOSE_BRACE, depth + 1);
16946 else if (token->type == CPP_OPEN_PAREN)
16947 cp_parser_cache_group (parser, CPP_CLOSE_PAREN, depth + 1);
16948 else if (token->type == CPP_PRAGMA)
16949 cp_parser_cache_group (parser, CPP_PRAGMA_EOL, depth + 1);
16950 else if (token->type == end)
16955 /* Begin parsing tentatively. We always save tokens while parsing
16956 tentatively so that if the tentative parsing fails we can restore the
16960 cp_parser_parse_tentatively (cp_parser* parser)
16962 /* Enter a new parsing context. */
16963 parser->context = cp_parser_context_new (parser->context);
16964 /* Begin saving tokens. */
16965 cp_lexer_save_tokens (parser->lexer);
16966 /* In order to avoid repetitive access control error messages,
16967 access checks are queued up until we are no longer parsing
16969 push_deferring_access_checks (dk_deferred);
16972 /* Commit to the currently active tentative parse. */
16975 cp_parser_commit_to_tentative_parse (cp_parser* parser)
16977 cp_parser_context *context;
16980 /* Mark all of the levels as committed. */
16981 lexer = parser->lexer;
16982 for (context = parser->context; context->next; context = context->next)
16984 if (context->status == CP_PARSER_STATUS_KIND_COMMITTED)
16986 context->status = CP_PARSER_STATUS_KIND_COMMITTED;
16987 while (!cp_lexer_saving_tokens (lexer))
16988 lexer = lexer->next;
16989 cp_lexer_commit_tokens (lexer);
16993 /* Abort the currently active tentative parse. All consumed tokens
16994 will be rolled back, and no diagnostics will be issued. */
16997 cp_parser_abort_tentative_parse (cp_parser* parser)
16999 cp_parser_simulate_error (parser);
17000 /* Now, pretend that we want to see if the construct was
17001 successfully parsed. */
17002 cp_parser_parse_definitely (parser);
17005 /* Stop parsing tentatively. If a parse error has occurred, restore the
17006 token stream. Otherwise, commit to the tokens we have consumed.
17007 Returns true if no error occurred; false otherwise. */
17010 cp_parser_parse_definitely (cp_parser* parser)
17012 bool error_occurred;
17013 cp_parser_context *context;
17015 /* Remember whether or not an error occurred, since we are about to
17016 destroy that information. */
17017 error_occurred = cp_parser_error_occurred (parser);
17018 /* Remove the topmost context from the stack. */
17019 context = parser->context;
17020 parser->context = context->next;
17021 /* If no parse errors occurred, commit to the tentative parse. */
17022 if (!error_occurred)
17024 /* Commit to the tokens read tentatively, unless that was
17026 if (context->status != CP_PARSER_STATUS_KIND_COMMITTED)
17027 cp_lexer_commit_tokens (parser->lexer);
17029 pop_to_parent_deferring_access_checks ();
17031 /* Otherwise, if errors occurred, roll back our state so that things
17032 are just as they were before we began the tentative parse. */
17035 cp_lexer_rollback_tokens (parser->lexer);
17036 pop_deferring_access_checks ();
17038 /* Add the context to the front of the free list. */
17039 context->next = cp_parser_context_free_list;
17040 cp_parser_context_free_list = context;
17042 return !error_occurred;
17045 /* Returns true if we are parsing tentatively and are not committed to
17046 this tentative parse. */
17049 cp_parser_uncommitted_to_tentative_parse_p (cp_parser* parser)
17051 return (cp_parser_parsing_tentatively (parser)
17052 && parser->context->status != CP_PARSER_STATUS_KIND_COMMITTED);
17055 /* Returns nonzero iff an error has occurred during the most recent
17056 tentative parse. */
17059 cp_parser_error_occurred (cp_parser* parser)
17061 return (cp_parser_parsing_tentatively (parser)
17062 && parser->context->status == CP_PARSER_STATUS_KIND_ERROR);
17065 /* Returns nonzero if GNU extensions are allowed. */
17068 cp_parser_allow_gnu_extensions_p (cp_parser* parser)
17070 return parser->allow_gnu_extensions_p;
17073 /* Objective-C++ Productions */
17076 /* Parse an Objective-C expression, which feeds into a primary-expression
17080 objc-message-expression
17081 objc-string-literal
17082 objc-encode-expression
17083 objc-protocol-expression
17084 objc-selector-expression
17086 Returns a tree representation of the expression. */
17089 cp_parser_objc_expression (cp_parser* parser)
17091 /* Try to figure out what kind of declaration is present. */
17092 cp_token *kwd = cp_lexer_peek_token (parser->lexer);
17096 case CPP_OPEN_SQUARE:
17097 return cp_parser_objc_message_expression (parser);
17099 case CPP_OBJC_STRING:
17100 kwd = cp_lexer_consume_token (parser->lexer);
17101 return objc_build_string_object (kwd->u.value);
17104 switch (kwd->keyword)
17106 case RID_AT_ENCODE:
17107 return cp_parser_objc_encode_expression (parser);
17109 case RID_AT_PROTOCOL:
17110 return cp_parser_objc_protocol_expression (parser);
17112 case RID_AT_SELECTOR:
17113 return cp_parser_objc_selector_expression (parser);
17119 error ("misplaced %<@%D%> Objective-C++ construct", kwd->u.value);
17120 cp_parser_skip_to_end_of_block_or_statement (parser);
17123 return error_mark_node;
17126 /* Parse an Objective-C message expression.
17128 objc-message-expression:
17129 [ objc-message-receiver objc-message-args ]
17131 Returns a representation of an Objective-C message. */
17134 cp_parser_objc_message_expression (cp_parser* parser)
17136 tree receiver, messageargs;
17138 cp_lexer_consume_token (parser->lexer); /* Eat '['. */
17139 receiver = cp_parser_objc_message_receiver (parser);
17140 messageargs = cp_parser_objc_message_args (parser);
17141 cp_parser_require (parser, CPP_CLOSE_SQUARE, "`]'");
17143 return objc_build_message_expr (build_tree_list (receiver, messageargs));
17146 /* Parse an objc-message-receiver.
17148 objc-message-receiver:
17150 simple-type-specifier
17152 Returns a representation of the type or expression. */
17155 cp_parser_objc_message_receiver (cp_parser* parser)
17159 /* An Objective-C message receiver may be either (1) a type
17160 or (2) an expression. */
17161 cp_parser_parse_tentatively (parser);
17162 rcv = cp_parser_expression (parser, false);
17164 if (cp_parser_parse_definitely (parser))
17167 rcv = cp_parser_simple_type_specifier (parser,
17168 /*decl_specs=*/NULL,
17169 CP_PARSER_FLAGS_NONE);
17171 return objc_get_class_reference (rcv);
17174 /* Parse the arguments and selectors comprising an Objective-C message.
17179 objc-selector-args , objc-comma-args
17181 objc-selector-args:
17182 objc-selector [opt] : assignment-expression
17183 objc-selector-args objc-selector [opt] : assignment-expression
17186 assignment-expression
17187 objc-comma-args , assignment-expression
17189 Returns a TREE_LIST, with TREE_PURPOSE containing a list of
17190 selector arguments and TREE_VALUE containing a list of comma
17194 cp_parser_objc_message_args (cp_parser* parser)
17196 tree sel_args = NULL_TREE, addl_args = NULL_TREE;
17197 bool maybe_unary_selector_p = true;
17198 cp_token *token = cp_lexer_peek_token (parser->lexer);
17200 while (cp_parser_objc_selector_p (token->type) || token->type == CPP_COLON)
17202 tree selector = NULL_TREE, arg;
17204 if (token->type != CPP_COLON)
17205 selector = cp_parser_objc_selector (parser);
17207 /* Detect if we have a unary selector. */
17208 if (maybe_unary_selector_p
17209 && cp_lexer_next_token_is_not (parser->lexer, CPP_COLON))
17210 return build_tree_list (selector, NULL_TREE);
17212 maybe_unary_selector_p = false;
17213 cp_parser_require (parser, CPP_COLON, "`:'");
17214 arg = cp_parser_assignment_expression (parser, false);
17217 = chainon (sel_args,
17218 build_tree_list (selector, arg));
17220 token = cp_lexer_peek_token (parser->lexer);
17223 /* Handle non-selector arguments, if any. */
17224 while (token->type == CPP_COMMA)
17228 cp_lexer_consume_token (parser->lexer);
17229 arg = cp_parser_assignment_expression (parser, false);
17232 = chainon (addl_args,
17233 build_tree_list (NULL_TREE, arg));
17235 token = cp_lexer_peek_token (parser->lexer);
17238 return build_tree_list (sel_args, addl_args);
17241 /* Parse an Objective-C encode expression.
17243 objc-encode-expression:
17244 @encode objc-typename
17246 Returns an encoded representation of the type argument. */
17249 cp_parser_objc_encode_expression (cp_parser* parser)
17253 cp_lexer_consume_token (parser->lexer); /* Eat '@encode'. */
17254 cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
17255 type = complete_type (cp_parser_type_id (parser));
17256 cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
17260 error ("%<@encode%> must specify a type as an argument");
17261 return error_mark_node;
17264 return objc_build_encode_expr (type);
17267 /* Parse an Objective-C @defs expression. */
17270 cp_parser_objc_defs_expression (cp_parser *parser)
17274 cp_lexer_consume_token (parser->lexer); /* Eat '@defs'. */
17275 cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
17276 name = cp_parser_identifier (parser);
17277 cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
17279 return objc_get_class_ivars (name);
17282 /* Parse an Objective-C protocol expression.
17284 objc-protocol-expression:
17285 @protocol ( identifier )
17287 Returns a representation of the protocol expression. */
17290 cp_parser_objc_protocol_expression (cp_parser* parser)
17294 cp_lexer_consume_token (parser->lexer); /* Eat '@protocol'. */
17295 cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
17296 proto = cp_parser_identifier (parser);
17297 cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
17299 return objc_build_protocol_expr (proto);
17302 /* Parse an Objective-C selector expression.
17304 objc-selector-expression:
17305 @selector ( objc-method-signature )
17307 objc-method-signature:
17313 objc-selector-seq objc-selector :
17315 Returns a representation of the method selector. */
17318 cp_parser_objc_selector_expression (cp_parser* parser)
17320 tree sel_seq = NULL_TREE;
17321 bool maybe_unary_selector_p = true;
17324 cp_lexer_consume_token (parser->lexer); /* Eat '@selector'. */
17325 cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
17326 token = cp_lexer_peek_token (parser->lexer);
17328 while (cp_parser_objc_selector_p (token->type) || token->type == CPP_COLON
17329 || token->type == CPP_SCOPE)
17331 tree selector = NULL_TREE;
17333 if (token->type != CPP_COLON
17334 || token->type == CPP_SCOPE)
17335 selector = cp_parser_objc_selector (parser);
17337 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COLON)
17338 && cp_lexer_next_token_is_not (parser->lexer, CPP_SCOPE))
17340 /* Detect if we have a unary selector. */
17341 if (maybe_unary_selector_p)
17343 sel_seq = selector;
17344 goto finish_selector;
17348 cp_parser_error (parser, "expected %<:%>");
17351 maybe_unary_selector_p = false;
17352 token = cp_lexer_consume_token (parser->lexer);
17354 if (token->type == CPP_SCOPE)
17357 = chainon (sel_seq,
17358 build_tree_list (selector, NULL_TREE));
17360 = chainon (sel_seq,
17361 build_tree_list (NULL_TREE, NULL_TREE));
17365 = chainon (sel_seq,
17366 build_tree_list (selector, NULL_TREE));
17368 token = cp_lexer_peek_token (parser->lexer);
17372 cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
17374 return objc_build_selector_expr (sel_seq);
17377 /* Parse a list of identifiers.
17379 objc-identifier-list:
17381 objc-identifier-list , identifier
17383 Returns a TREE_LIST of identifier nodes. */
17386 cp_parser_objc_identifier_list (cp_parser* parser)
17388 tree list = build_tree_list (NULL_TREE, cp_parser_identifier (parser));
17389 cp_token *sep = cp_lexer_peek_token (parser->lexer);
17391 while (sep->type == CPP_COMMA)
17393 cp_lexer_consume_token (parser->lexer); /* Eat ','. */
17394 list = chainon (list,
17395 build_tree_list (NULL_TREE,
17396 cp_parser_identifier (parser)));
17397 sep = cp_lexer_peek_token (parser->lexer);
17403 /* Parse an Objective-C alias declaration.
17405 objc-alias-declaration:
17406 @compatibility_alias identifier identifier ;
17408 This function registers the alias mapping with the Objective-C front-end.
17409 It returns nothing. */
17412 cp_parser_objc_alias_declaration (cp_parser* parser)
17416 cp_lexer_consume_token (parser->lexer); /* Eat '@compatibility_alias'. */
17417 alias = cp_parser_identifier (parser);
17418 orig = cp_parser_identifier (parser);
17419 objc_declare_alias (alias, orig);
17420 cp_parser_consume_semicolon_at_end_of_statement (parser);
17423 /* Parse an Objective-C class forward-declaration.
17425 objc-class-declaration:
17426 @class objc-identifier-list ;
17428 The function registers the forward declarations with the Objective-C
17429 front-end. It returns nothing. */
17432 cp_parser_objc_class_declaration (cp_parser* parser)
17434 cp_lexer_consume_token (parser->lexer); /* Eat '@class'. */
17435 objc_declare_class (cp_parser_objc_identifier_list (parser));
17436 cp_parser_consume_semicolon_at_end_of_statement (parser);
17439 /* Parse a list of Objective-C protocol references.
17441 objc-protocol-refs-opt:
17442 objc-protocol-refs [opt]
17444 objc-protocol-refs:
17445 < objc-identifier-list >
17447 Returns a TREE_LIST of identifiers, if any. */
17450 cp_parser_objc_protocol_refs_opt (cp_parser* parser)
17452 tree protorefs = NULL_TREE;
17454 if(cp_lexer_next_token_is (parser->lexer, CPP_LESS))
17456 cp_lexer_consume_token (parser->lexer); /* Eat '<'. */
17457 protorefs = cp_parser_objc_identifier_list (parser);
17458 cp_parser_require (parser, CPP_GREATER, "`>'");
17464 /* Parse a Objective-C visibility specification. */
17467 cp_parser_objc_visibility_spec (cp_parser* parser)
17469 cp_token *vis = cp_lexer_peek_token (parser->lexer);
17471 switch (vis->keyword)
17473 case RID_AT_PRIVATE:
17474 objc_set_visibility (2);
17476 case RID_AT_PROTECTED:
17477 objc_set_visibility (0);
17479 case RID_AT_PUBLIC:
17480 objc_set_visibility (1);
17486 /* Eat '@private'/'@protected'/'@public'. */
17487 cp_lexer_consume_token (parser->lexer);
17490 /* Parse an Objective-C method type. */
17493 cp_parser_objc_method_type (cp_parser* parser)
17495 objc_set_method_type
17496 (cp_lexer_consume_token (parser->lexer)->type == CPP_PLUS
17501 /* Parse an Objective-C protocol qualifier. */
17504 cp_parser_objc_protocol_qualifiers (cp_parser* parser)
17506 tree quals = NULL_TREE, node;
17507 cp_token *token = cp_lexer_peek_token (parser->lexer);
17509 node = token->u.value;
17511 while (node && TREE_CODE (node) == IDENTIFIER_NODE
17512 && (node == ridpointers [(int) RID_IN]
17513 || node == ridpointers [(int) RID_OUT]
17514 || node == ridpointers [(int) RID_INOUT]
17515 || node == ridpointers [(int) RID_BYCOPY]
17516 || node == ridpointers [(int) RID_BYREF]
17517 || node == ridpointers [(int) RID_ONEWAY]))
17519 quals = tree_cons (NULL_TREE, node, quals);
17520 cp_lexer_consume_token (parser->lexer);
17521 token = cp_lexer_peek_token (parser->lexer);
17522 node = token->u.value;
17528 /* Parse an Objective-C typename. */
17531 cp_parser_objc_typename (cp_parser* parser)
17533 tree typename = NULL_TREE;
17535 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
17537 tree proto_quals, cp_type = NULL_TREE;
17539 cp_lexer_consume_token (parser->lexer); /* Eat '('. */
17540 proto_quals = cp_parser_objc_protocol_qualifiers (parser);
17542 /* An ObjC type name may consist of just protocol qualifiers, in which
17543 case the type shall default to 'id'. */
17544 if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
17545 cp_type = cp_parser_type_id (parser);
17547 cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
17548 typename = build_tree_list (proto_quals, cp_type);
17554 /* Check to see if TYPE refers to an Objective-C selector name. */
17557 cp_parser_objc_selector_p (enum cpp_ttype type)
17559 return (type == CPP_NAME || type == CPP_KEYWORD
17560 || type == CPP_AND_AND || type == CPP_AND_EQ || type == CPP_AND
17561 || type == CPP_OR || type == CPP_COMPL || type == CPP_NOT
17562 || type == CPP_NOT_EQ || type == CPP_OR_OR || type == CPP_OR_EQ
17563 || type == CPP_XOR || type == CPP_XOR_EQ);
17566 /* Parse an Objective-C selector. */
17569 cp_parser_objc_selector (cp_parser* parser)
17571 cp_token *token = cp_lexer_consume_token (parser->lexer);
17573 if (!cp_parser_objc_selector_p (token->type))
17575 error ("invalid Objective-C++ selector name");
17576 return error_mark_node;
17579 /* C++ operator names are allowed to appear in ObjC selectors. */
17580 switch (token->type)
17582 case CPP_AND_AND: return get_identifier ("and");
17583 case CPP_AND_EQ: return get_identifier ("and_eq");
17584 case CPP_AND: return get_identifier ("bitand");
17585 case CPP_OR: return get_identifier ("bitor");
17586 case CPP_COMPL: return get_identifier ("compl");
17587 case CPP_NOT: return get_identifier ("not");
17588 case CPP_NOT_EQ: return get_identifier ("not_eq");
17589 case CPP_OR_OR: return get_identifier ("or");
17590 case CPP_OR_EQ: return get_identifier ("or_eq");
17591 case CPP_XOR: return get_identifier ("xor");
17592 case CPP_XOR_EQ: return get_identifier ("xor_eq");
17593 default: return token->u.value;
17597 /* Parse an Objective-C params list. */
17600 cp_parser_objc_method_keyword_params (cp_parser* parser)
17602 tree params = NULL_TREE;
17603 bool maybe_unary_selector_p = true;
17604 cp_token *token = cp_lexer_peek_token (parser->lexer);
17606 while (cp_parser_objc_selector_p (token->type) || token->type == CPP_COLON)
17608 tree selector = NULL_TREE, typename, identifier;
17610 if (token->type != CPP_COLON)
17611 selector = cp_parser_objc_selector (parser);
17613 /* Detect if we have a unary selector. */
17614 if (maybe_unary_selector_p
17615 && cp_lexer_next_token_is_not (parser->lexer, CPP_COLON))
17618 maybe_unary_selector_p = false;
17619 cp_parser_require (parser, CPP_COLON, "`:'");
17620 typename = cp_parser_objc_typename (parser);
17621 identifier = cp_parser_identifier (parser);
17625 objc_build_keyword_decl (selector,
17629 token = cp_lexer_peek_token (parser->lexer);
17635 /* Parse the non-keyword Objective-C params. */
17638 cp_parser_objc_method_tail_params_opt (cp_parser* parser, bool *ellipsisp)
17640 tree params = make_node (TREE_LIST);
17641 cp_token *token = cp_lexer_peek_token (parser->lexer);
17642 *ellipsisp = false; /* Initially, assume no ellipsis. */
17644 while (token->type == CPP_COMMA)
17646 cp_parameter_declarator *parmdecl;
17649 cp_lexer_consume_token (parser->lexer); /* Eat ','. */
17650 token = cp_lexer_peek_token (parser->lexer);
17652 if (token->type == CPP_ELLIPSIS)
17654 cp_lexer_consume_token (parser->lexer); /* Eat '...'. */
17659 parmdecl = cp_parser_parameter_declaration (parser, false, NULL);
17660 parm = grokdeclarator (parmdecl->declarator,
17661 &parmdecl->decl_specifiers,
17662 PARM, /*initialized=*/0,
17663 /*attrlist=*/NULL);
17665 chainon (params, build_tree_list (NULL_TREE, parm));
17666 token = cp_lexer_peek_token (parser->lexer);
17672 /* Parse a linkage specification, a pragma, an extra semicolon or a block. */
17675 cp_parser_objc_interstitial_code (cp_parser* parser)
17677 cp_token *token = cp_lexer_peek_token (parser->lexer);
17679 /* If the next token is `extern' and the following token is a string
17680 literal, then we have a linkage specification. */
17681 if (token->keyword == RID_EXTERN
17682 && cp_parser_is_string_literal (cp_lexer_peek_nth_token (parser->lexer, 2)))
17683 cp_parser_linkage_specification (parser);
17684 /* Handle #pragma, if any. */
17685 else if (token->type == CPP_PRAGMA)
17686 cp_parser_pragma (parser, pragma_external);
17687 /* Allow stray semicolons. */
17688 else if (token->type == CPP_SEMICOLON)
17689 cp_lexer_consume_token (parser->lexer);
17690 /* Finally, try to parse a block-declaration, or a function-definition. */
17692 cp_parser_block_declaration (parser, /*statement_p=*/false);
17695 /* Parse a method signature. */
17698 cp_parser_objc_method_signature (cp_parser* parser)
17700 tree rettype, kwdparms, optparms;
17701 bool ellipsis = false;
17703 cp_parser_objc_method_type (parser);
17704 rettype = cp_parser_objc_typename (parser);
17705 kwdparms = cp_parser_objc_method_keyword_params (parser);
17706 optparms = cp_parser_objc_method_tail_params_opt (parser, &ellipsis);
17708 return objc_build_method_signature (rettype, kwdparms, optparms, ellipsis);
17711 /* Pars an Objective-C method prototype list. */
17714 cp_parser_objc_method_prototype_list (cp_parser* parser)
17716 cp_token *token = cp_lexer_peek_token (parser->lexer);
17718 while (token->keyword != RID_AT_END)
17720 if (token->type == CPP_PLUS || token->type == CPP_MINUS)
17722 objc_add_method_declaration
17723 (cp_parser_objc_method_signature (parser));
17724 cp_parser_consume_semicolon_at_end_of_statement (parser);
17727 /* Allow for interspersed non-ObjC++ code. */
17728 cp_parser_objc_interstitial_code (parser);
17730 token = cp_lexer_peek_token (parser->lexer);
17733 cp_lexer_consume_token (parser->lexer); /* Eat '@end'. */
17734 objc_finish_interface ();
17737 /* Parse an Objective-C method definition list. */
17740 cp_parser_objc_method_definition_list (cp_parser* parser)
17742 cp_token *token = cp_lexer_peek_token (parser->lexer);
17744 while (token->keyword != RID_AT_END)
17748 if (token->type == CPP_PLUS || token->type == CPP_MINUS)
17750 push_deferring_access_checks (dk_deferred);
17751 objc_start_method_definition
17752 (cp_parser_objc_method_signature (parser));
17754 /* For historical reasons, we accept an optional semicolon. */
17755 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
17756 cp_lexer_consume_token (parser->lexer);
17758 perform_deferred_access_checks ();
17759 stop_deferring_access_checks ();
17760 meth = cp_parser_function_definition_after_declarator (parser,
17762 pop_deferring_access_checks ();
17763 objc_finish_method_definition (meth);
17766 /* Allow for interspersed non-ObjC++ code. */
17767 cp_parser_objc_interstitial_code (parser);
17769 token = cp_lexer_peek_token (parser->lexer);
17772 cp_lexer_consume_token (parser->lexer); /* Eat '@end'. */
17773 objc_finish_implementation ();
17776 /* Parse Objective-C ivars. */
17779 cp_parser_objc_class_ivars (cp_parser* parser)
17781 cp_token *token = cp_lexer_peek_token (parser->lexer);
17783 if (token->type != CPP_OPEN_BRACE)
17784 return; /* No ivars specified. */
17786 cp_lexer_consume_token (parser->lexer); /* Eat '{'. */
17787 token = cp_lexer_peek_token (parser->lexer);
17789 while (token->type != CPP_CLOSE_BRACE)
17791 cp_decl_specifier_seq declspecs;
17792 int decl_class_or_enum_p;
17793 tree prefix_attributes;
17795 cp_parser_objc_visibility_spec (parser);
17797 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
17800 cp_parser_decl_specifier_seq (parser,
17801 CP_PARSER_FLAGS_OPTIONAL,
17803 &decl_class_or_enum_p);
17804 prefix_attributes = declspecs.attributes;
17805 declspecs.attributes = NULL_TREE;
17807 /* Keep going until we hit the `;' at the end of the
17809 while (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
17811 tree width = NULL_TREE, attributes, first_attribute, decl;
17812 cp_declarator *declarator = NULL;
17813 int ctor_dtor_or_conv_p;
17815 /* Check for a (possibly unnamed) bitfield declaration. */
17816 token = cp_lexer_peek_token (parser->lexer);
17817 if (token->type == CPP_COLON)
17820 if (token->type == CPP_NAME
17821 && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
17824 /* Get the name of the bitfield. */
17825 declarator = make_id_declarator (NULL_TREE,
17826 cp_parser_identifier (parser),
17830 cp_lexer_consume_token (parser->lexer); /* Eat ':'. */
17831 /* Get the width of the bitfield. */
17833 = cp_parser_constant_expression (parser,
17834 /*allow_non_constant=*/false,
17839 /* Parse the declarator. */
17841 = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
17842 &ctor_dtor_or_conv_p,
17843 /*parenthesized_p=*/NULL,
17844 /*member_p=*/false);
17847 /* Look for attributes that apply to the ivar. */
17848 attributes = cp_parser_attributes_opt (parser);
17849 /* Remember which attributes are prefix attributes and
17851 first_attribute = attributes;
17852 /* Combine the attributes. */
17853 attributes = chainon (prefix_attributes, attributes);
17857 /* Create the bitfield declaration. */
17858 decl = grokbitfield (declarator, &declspecs, width);
17859 cplus_decl_attributes (&decl, attributes, /*flags=*/0);
17862 decl = grokfield (declarator, &declspecs,
17863 NULL_TREE, /*init_const_expr_p=*/false,
17864 NULL_TREE, attributes);
17866 /* Add the instance variable. */
17867 objc_add_instance_variable (decl);
17869 /* Reset PREFIX_ATTRIBUTES. */
17870 while (attributes && TREE_CHAIN (attributes) != first_attribute)
17871 attributes = TREE_CHAIN (attributes);
17873 TREE_CHAIN (attributes) = NULL_TREE;
17875 token = cp_lexer_peek_token (parser->lexer);
17877 if (token->type == CPP_COMMA)
17879 cp_lexer_consume_token (parser->lexer); /* Eat ','. */
17885 cp_parser_consume_semicolon_at_end_of_statement (parser);
17886 token = cp_lexer_peek_token (parser->lexer);
17889 cp_lexer_consume_token (parser->lexer); /* Eat '}'. */
17890 /* For historical reasons, we accept an optional semicolon. */
17891 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
17892 cp_lexer_consume_token (parser->lexer);
17895 /* Parse an Objective-C protocol declaration. */
17898 cp_parser_objc_protocol_declaration (cp_parser* parser)
17900 tree proto, protorefs;
17903 cp_lexer_consume_token (parser->lexer); /* Eat '@protocol'. */
17904 if (cp_lexer_next_token_is_not (parser->lexer, CPP_NAME))
17906 error ("identifier expected after %<@protocol%>");
17910 /* See if we have a forward declaration or a definition. */
17911 tok = cp_lexer_peek_nth_token (parser->lexer, 2);
17913 /* Try a forward declaration first. */
17914 if (tok->type == CPP_COMMA || tok->type == CPP_SEMICOLON)
17916 objc_declare_protocols (cp_parser_objc_identifier_list (parser));
17918 cp_parser_consume_semicolon_at_end_of_statement (parser);
17921 /* Ok, we got a full-fledged definition (or at least should). */
17924 proto = cp_parser_identifier (parser);
17925 protorefs = cp_parser_objc_protocol_refs_opt (parser);
17926 objc_start_protocol (proto, protorefs);
17927 cp_parser_objc_method_prototype_list (parser);
17931 /* Parse an Objective-C superclass or category. */
17934 cp_parser_objc_superclass_or_category (cp_parser *parser, tree *super,
17937 cp_token *next = cp_lexer_peek_token (parser->lexer);
17939 *super = *categ = NULL_TREE;
17940 if (next->type == CPP_COLON)
17942 cp_lexer_consume_token (parser->lexer); /* Eat ':'. */
17943 *super = cp_parser_identifier (parser);
17945 else if (next->type == CPP_OPEN_PAREN)
17947 cp_lexer_consume_token (parser->lexer); /* Eat '('. */
17948 *categ = cp_parser_identifier (parser);
17949 cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
17953 /* Parse an Objective-C class interface. */
17956 cp_parser_objc_class_interface (cp_parser* parser)
17958 tree name, super, categ, protos;
17960 cp_lexer_consume_token (parser->lexer); /* Eat '@interface'. */
17961 name = cp_parser_identifier (parser);
17962 cp_parser_objc_superclass_or_category (parser, &super, &categ);
17963 protos = cp_parser_objc_protocol_refs_opt (parser);
17965 /* We have either a class or a category on our hands. */
17967 objc_start_category_interface (name, categ, protos);
17970 objc_start_class_interface (name, super, protos);
17971 /* Handle instance variable declarations, if any. */
17972 cp_parser_objc_class_ivars (parser);
17973 objc_continue_interface ();
17976 cp_parser_objc_method_prototype_list (parser);
17979 /* Parse an Objective-C class implementation. */
17982 cp_parser_objc_class_implementation (cp_parser* parser)
17984 tree name, super, categ;
17986 cp_lexer_consume_token (parser->lexer); /* Eat '@implementation'. */
17987 name = cp_parser_identifier (parser);
17988 cp_parser_objc_superclass_or_category (parser, &super, &categ);
17990 /* We have either a class or a category on our hands. */
17992 objc_start_category_implementation (name, categ);
17995 objc_start_class_implementation (name, super);
17996 /* Handle instance variable declarations, if any. */
17997 cp_parser_objc_class_ivars (parser);
17998 objc_continue_implementation ();
18001 cp_parser_objc_method_definition_list (parser);
18004 /* Consume the @end token and finish off the implementation. */
18007 cp_parser_objc_end_implementation (cp_parser* parser)
18009 cp_lexer_consume_token (parser->lexer); /* Eat '@end'. */
18010 objc_finish_implementation ();
18013 /* Parse an Objective-C declaration. */
18016 cp_parser_objc_declaration (cp_parser* parser)
18018 /* Try to figure out what kind of declaration is present. */
18019 cp_token *kwd = cp_lexer_peek_token (parser->lexer);
18021 switch (kwd->keyword)
18024 cp_parser_objc_alias_declaration (parser);
18027 cp_parser_objc_class_declaration (parser);
18029 case RID_AT_PROTOCOL:
18030 cp_parser_objc_protocol_declaration (parser);
18032 case RID_AT_INTERFACE:
18033 cp_parser_objc_class_interface (parser);
18035 case RID_AT_IMPLEMENTATION:
18036 cp_parser_objc_class_implementation (parser);
18039 cp_parser_objc_end_implementation (parser);
18042 error ("misplaced %<@%D%> Objective-C++ construct", kwd->u.value);
18043 cp_parser_skip_to_end_of_block_or_statement (parser);
18047 /* Parse an Objective-C try-catch-finally statement.
18049 objc-try-catch-finally-stmt:
18050 @try compound-statement objc-catch-clause-seq [opt]
18051 objc-finally-clause [opt]
18053 objc-catch-clause-seq:
18054 objc-catch-clause objc-catch-clause-seq [opt]
18057 @catch ( exception-declaration ) compound-statement
18059 objc-finally-clause
18060 @finally compound-statement
18062 Returns NULL_TREE. */
18065 cp_parser_objc_try_catch_finally_statement (cp_parser *parser) {
18066 location_t location;
18069 cp_parser_require_keyword (parser, RID_AT_TRY, "`@try'");
18070 location = cp_lexer_peek_token (parser->lexer)->location;
18071 /* NB: The @try block needs to be wrapped in its own STATEMENT_LIST
18072 node, lest it get absorbed into the surrounding block. */
18073 stmt = push_stmt_list ();
18074 cp_parser_compound_statement (parser, NULL, false);
18075 objc_begin_try_stmt (location, pop_stmt_list (stmt));
18077 while (cp_lexer_next_token_is_keyword (parser->lexer, RID_AT_CATCH))
18079 cp_parameter_declarator *parmdecl;
18082 cp_lexer_consume_token (parser->lexer);
18083 cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
18084 parmdecl = cp_parser_parameter_declaration (parser, false, NULL);
18085 parm = grokdeclarator (parmdecl->declarator,
18086 &parmdecl->decl_specifiers,
18087 PARM, /*initialized=*/0,
18088 /*attrlist=*/NULL);
18089 cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
18090 objc_begin_catch_clause (parm);
18091 cp_parser_compound_statement (parser, NULL, false);
18092 objc_finish_catch_clause ();
18095 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_AT_FINALLY))
18097 cp_lexer_consume_token (parser->lexer);
18098 location = cp_lexer_peek_token (parser->lexer)->location;
18099 /* NB: The @finally block needs to be wrapped in its own STATEMENT_LIST
18100 node, lest it get absorbed into the surrounding block. */
18101 stmt = push_stmt_list ();
18102 cp_parser_compound_statement (parser, NULL, false);
18103 objc_build_finally_clause (location, pop_stmt_list (stmt));
18106 return objc_finish_try_stmt ();
18109 /* Parse an Objective-C synchronized statement.
18111 objc-synchronized-stmt:
18112 @synchronized ( expression ) compound-statement
18114 Returns NULL_TREE. */
18117 cp_parser_objc_synchronized_statement (cp_parser *parser) {
18118 location_t location;
18121 cp_parser_require_keyword (parser, RID_AT_SYNCHRONIZED, "`@synchronized'");
18123 location = cp_lexer_peek_token (parser->lexer)->location;
18124 cp_parser_require (parser, CPP_OPEN_PAREN, "`('");
18125 lock = cp_parser_expression (parser, false);
18126 cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'");
18128 /* NB: The @synchronized block needs to be wrapped in its own STATEMENT_LIST
18129 node, lest it get absorbed into the surrounding block. */
18130 stmt = push_stmt_list ();
18131 cp_parser_compound_statement (parser, NULL, false);
18133 return objc_build_synchronized (location, lock, pop_stmt_list (stmt));
18136 /* Parse an Objective-C throw statement.
18139 @throw assignment-expression [opt] ;
18141 Returns a constructed '@throw' statement. */
18144 cp_parser_objc_throw_statement (cp_parser *parser) {
18145 tree expr = NULL_TREE;
18147 cp_parser_require_keyword (parser, RID_AT_THROW, "`@throw'");
18149 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
18150 expr = cp_parser_assignment_expression (parser, false);
18152 cp_parser_consume_semicolon_at_end_of_statement (parser);
18154 return objc_build_throw_stmt (expr);
18157 /* Parse an Objective-C statement. */
18160 cp_parser_objc_statement (cp_parser * parser) {
18161 /* Try to figure out what kind of declaration is present. */
18162 cp_token *kwd = cp_lexer_peek_token (parser->lexer);
18164 switch (kwd->keyword)
18167 return cp_parser_objc_try_catch_finally_statement (parser);
18168 case RID_AT_SYNCHRONIZED:
18169 return cp_parser_objc_synchronized_statement (parser);
18171 return cp_parser_objc_throw_statement (parser);
18173 error ("misplaced %<@%D%> Objective-C++ construct", kwd->u.value);
18174 cp_parser_skip_to_end_of_block_or_statement (parser);
18177 return error_mark_node;
18180 /* OpenMP 2.5 parsing routines. */
18182 /* Returns name of the next clause.
18183 If the clause is not recognized PRAGMA_OMP_CLAUSE_NONE is returned and
18184 the token is not consumed. Otherwise appropriate pragma_omp_clause is
18185 returned and the token is consumed. */
18187 static pragma_omp_clause
18188 cp_parser_omp_clause_name (cp_parser *parser)
18190 pragma_omp_clause result = PRAGMA_OMP_CLAUSE_NONE;
18192 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_IF))
18193 result = PRAGMA_OMP_CLAUSE_IF;
18194 else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_DEFAULT))
18195 result = PRAGMA_OMP_CLAUSE_DEFAULT;
18196 else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_PRIVATE))
18197 result = PRAGMA_OMP_CLAUSE_PRIVATE;
18198 else if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
18200 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
18201 const char *p = IDENTIFIER_POINTER (id);
18206 if (!strcmp ("copyin", p))
18207 result = PRAGMA_OMP_CLAUSE_COPYIN;
18208 else if (!strcmp ("copyprivate", p))
18209 result = PRAGMA_OMP_CLAUSE_COPYPRIVATE;
18212 if (!strcmp ("firstprivate", p))
18213 result = PRAGMA_OMP_CLAUSE_FIRSTPRIVATE;
18216 if (!strcmp ("lastprivate", p))
18217 result = PRAGMA_OMP_CLAUSE_LASTPRIVATE;
18220 if (!strcmp ("nowait", p))
18221 result = PRAGMA_OMP_CLAUSE_NOWAIT;
18222 else if (!strcmp ("num_threads", p))
18223 result = PRAGMA_OMP_CLAUSE_NUM_THREADS;
18226 if (!strcmp ("ordered", p))
18227 result = PRAGMA_OMP_CLAUSE_ORDERED;
18230 if (!strcmp ("reduction", p))
18231 result = PRAGMA_OMP_CLAUSE_REDUCTION;
18234 if (!strcmp ("schedule", p))
18235 result = PRAGMA_OMP_CLAUSE_SCHEDULE;
18236 else if (!strcmp ("shared", p))
18237 result = PRAGMA_OMP_CLAUSE_SHARED;
18242 if (result != PRAGMA_OMP_CLAUSE_NONE)
18243 cp_lexer_consume_token (parser->lexer);
18248 /* Validate that a clause of the given type does not already exist. */
18251 check_no_duplicate_clause (tree clauses, enum tree_code code, const char *name)
18255 for (c = clauses; c ; c = OMP_CLAUSE_CHAIN (c))
18256 if (OMP_CLAUSE_CODE (c) == code)
18258 error ("too many %qs clauses", name);
18266 variable-list , identifier
18268 In addition, we match a closing parenthesis. An opening parenthesis
18269 will have been consumed by the caller.
18271 If KIND is nonzero, create the appropriate node and install the decl
18272 in OMP_CLAUSE_DECL and add the node to the head of the list.
18274 If KIND is zero, create a TREE_LIST with the decl in TREE_PURPOSE;
18275 return the list created. */
18278 cp_parser_omp_var_list_no_open (cp_parser *parser, enum omp_clause_code kind,
18285 name = cp_parser_id_expression (parser, /*template_p=*/false,
18286 /*check_dependency_p=*/true,
18287 /*template_p=*/NULL,
18288 /*declarator_p=*/false,
18289 /*optional_p=*/false);
18290 if (name == error_mark_node)
18293 decl = cp_parser_lookup_name_simple (parser, name);
18294 if (decl == error_mark_node)
18295 cp_parser_name_lookup_error (parser, name, decl, NULL);
18296 else if (kind != 0)
18298 tree u = build_omp_clause (kind);
18299 OMP_CLAUSE_DECL (u) = decl;
18300 OMP_CLAUSE_CHAIN (u) = list;
18304 list = tree_cons (decl, NULL_TREE, list);
18307 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
18309 cp_lexer_consume_token (parser->lexer);
18312 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"))
18316 /* Try to resync to an unnested comma. Copied from
18317 cp_parser_parenthesized_expression_list. */
18319 ending = cp_parser_skip_to_closing_parenthesis (parser,
18320 /*recovering=*/true,
18322 /*consume_paren=*/true);
18330 /* Similarly, but expect leading and trailing parenthesis. This is a very
18331 common case for omp clauses. */
18334 cp_parser_omp_var_list (cp_parser *parser, enum omp_clause_code kind, tree list)
18336 if (cp_parser_require (parser, CPP_OPEN_PAREN, "`('"))
18337 return cp_parser_omp_var_list_no_open (parser, kind, list);
18342 default ( shared | none ) */
18345 cp_parser_omp_clause_default (cp_parser *parser, tree list)
18347 enum omp_clause_default_kind kind = OMP_CLAUSE_DEFAULT_UNSPECIFIED;
18350 if (!cp_parser_require (parser, CPP_OPEN_PAREN, "`('"))
18352 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
18354 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
18355 const char *p = IDENTIFIER_POINTER (id);
18360 if (strcmp ("none", p) != 0)
18362 kind = OMP_CLAUSE_DEFAULT_NONE;
18366 if (strcmp ("shared", p) != 0)
18368 kind = OMP_CLAUSE_DEFAULT_SHARED;
18375 cp_lexer_consume_token (parser->lexer);
18380 cp_parser_error (parser, "expected %<none%> or %<shared%>");
18383 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"))
18384 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
18385 /*or_comma=*/false,
18386 /*consume_paren=*/true);
18388 if (kind == OMP_CLAUSE_DEFAULT_UNSPECIFIED)
18391 check_no_duplicate_clause (list, OMP_CLAUSE_DEFAULT, "default");
18392 c = build_omp_clause (OMP_CLAUSE_DEFAULT);
18393 OMP_CLAUSE_CHAIN (c) = list;
18394 OMP_CLAUSE_DEFAULT_KIND (c) = kind;
18400 if ( expression ) */
18403 cp_parser_omp_clause_if (cp_parser *parser, tree list)
18407 if (!cp_parser_require (parser, CPP_OPEN_PAREN, "`('"))
18410 t = cp_parser_condition (parser);
18412 if (t == error_mark_node
18413 || !cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"))
18414 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
18415 /*or_comma=*/false,
18416 /*consume_paren=*/true);
18418 check_no_duplicate_clause (list, OMP_CLAUSE_IF, "if");
18420 c = build_omp_clause (OMP_CLAUSE_IF);
18421 OMP_CLAUSE_IF_EXPR (c) = t;
18422 OMP_CLAUSE_CHAIN (c) = list;
18431 cp_parser_omp_clause_nowait (cp_parser *parser ATTRIBUTE_UNUSED, tree list)
18435 check_no_duplicate_clause (list, OMP_CLAUSE_NOWAIT, "nowait");
18437 c = build_omp_clause (OMP_CLAUSE_NOWAIT);
18438 OMP_CLAUSE_CHAIN (c) = list;
18443 num_threads ( expression ) */
18446 cp_parser_omp_clause_num_threads (cp_parser *parser, tree list)
18450 if (!cp_parser_require (parser, CPP_OPEN_PAREN, "`('"))
18453 t = cp_parser_expression (parser, false);
18455 if (t == error_mark_node
18456 || !cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"))
18457 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
18458 /*or_comma=*/false,
18459 /*consume_paren=*/true);
18461 check_no_duplicate_clause (list, OMP_CLAUSE_NUM_THREADS, "num_threads");
18463 c = build_omp_clause (OMP_CLAUSE_NUM_THREADS);
18464 OMP_CLAUSE_NUM_THREADS_EXPR (c) = t;
18465 OMP_CLAUSE_CHAIN (c) = list;
18474 cp_parser_omp_clause_ordered (cp_parser *parser ATTRIBUTE_UNUSED, tree list)
18478 check_no_duplicate_clause (list, OMP_CLAUSE_ORDERED, "ordered");
18480 c = build_omp_clause (OMP_CLAUSE_ORDERED);
18481 OMP_CLAUSE_CHAIN (c) = list;
18486 reduction ( reduction-operator : variable-list )
18488 reduction-operator:
18489 One of: + * - & ^ | && || */
18492 cp_parser_omp_clause_reduction (cp_parser *parser, tree list)
18494 enum tree_code code;
18497 if (!cp_parser_require (parser, CPP_OPEN_PAREN, "`('"))
18500 switch (cp_lexer_peek_token (parser->lexer)->type)
18512 code = BIT_AND_EXPR;
18515 code = BIT_XOR_EXPR;
18518 code = BIT_IOR_EXPR;
18521 code = TRUTH_ANDIF_EXPR;
18524 code = TRUTH_ORIF_EXPR;
18527 cp_parser_error (parser, "`+', `*', `-', `&', `^', `|', `&&', or `||'");
18529 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
18530 /*or_comma=*/false,
18531 /*consume_paren=*/true);
18534 cp_lexer_consume_token (parser->lexer);
18536 if (!cp_parser_require (parser, CPP_COLON, "`:'"))
18539 nlist = cp_parser_omp_var_list_no_open (parser, OMP_CLAUSE_REDUCTION, list);
18540 for (c = nlist; c != list; c = OMP_CLAUSE_CHAIN (c))
18541 OMP_CLAUSE_REDUCTION_CODE (c) = code;
18547 schedule ( schedule-kind )
18548 schedule ( schedule-kind , expression )
18551 static | dynamic | guided | runtime */
18554 cp_parser_omp_clause_schedule (cp_parser *parser, tree list)
18558 if (!cp_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
18561 c = build_omp_clause (OMP_CLAUSE_SCHEDULE);
18563 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
18565 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
18566 const char *p = IDENTIFIER_POINTER (id);
18571 if (strcmp ("dynamic", p) != 0)
18573 OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_DYNAMIC;
18577 if (strcmp ("guided", p) != 0)
18579 OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_GUIDED;
18583 if (strcmp ("runtime", p) != 0)
18585 OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_RUNTIME;
18592 else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_STATIC))
18593 OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_STATIC;
18596 cp_lexer_consume_token (parser->lexer);
18598 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
18600 cp_lexer_consume_token (parser->lexer);
18602 t = cp_parser_assignment_expression (parser, false);
18604 if (t == error_mark_node)
18606 else if (OMP_CLAUSE_SCHEDULE_KIND (c) == OMP_CLAUSE_SCHEDULE_RUNTIME)
18607 error ("schedule %<runtime%> does not take "
18608 "a %<chunk_size%> parameter");
18610 OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c) = t;
18612 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"))
18615 else if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "`,' or `)'"))
18618 check_no_duplicate_clause (list, OMP_CLAUSE_SCHEDULE, "schedule");
18619 OMP_CLAUSE_CHAIN (c) = list;
18623 cp_parser_error (parser, "invalid schedule kind");
18625 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
18626 /*or_comma=*/false,
18627 /*consume_paren=*/true);
18631 /* Parse all OpenMP clauses. The set clauses allowed by the directive
18632 is a bitmask in MASK. Return the list of clauses found; the result
18633 of clause default goes in *pdefault. */
18636 cp_parser_omp_all_clauses (cp_parser *parser, unsigned int mask,
18637 const char *where, cp_token *pragma_tok)
18639 tree clauses = NULL;
18641 while (cp_lexer_next_token_is_not (parser->lexer, CPP_PRAGMA_EOL))
18643 pragma_omp_clause c_kind = cp_parser_omp_clause_name (parser);
18644 const char *c_name;
18645 tree prev = clauses;
18649 case PRAGMA_OMP_CLAUSE_COPYIN:
18650 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_COPYIN, clauses);
18653 case PRAGMA_OMP_CLAUSE_COPYPRIVATE:
18654 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_COPYPRIVATE,
18656 c_name = "copyprivate";
18658 case PRAGMA_OMP_CLAUSE_DEFAULT:
18659 clauses = cp_parser_omp_clause_default (parser, clauses);
18660 c_name = "default";
18662 case PRAGMA_OMP_CLAUSE_FIRSTPRIVATE:
18663 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_FIRSTPRIVATE,
18665 c_name = "firstprivate";
18667 case PRAGMA_OMP_CLAUSE_IF:
18668 clauses = cp_parser_omp_clause_if (parser, clauses);
18671 case PRAGMA_OMP_CLAUSE_LASTPRIVATE:
18672 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_LASTPRIVATE,
18674 c_name = "lastprivate";
18676 case PRAGMA_OMP_CLAUSE_NOWAIT:
18677 clauses = cp_parser_omp_clause_nowait (parser, clauses);
18680 case PRAGMA_OMP_CLAUSE_NUM_THREADS:
18681 clauses = cp_parser_omp_clause_num_threads (parser, clauses);
18682 c_name = "num_threads";
18684 case PRAGMA_OMP_CLAUSE_ORDERED:
18685 clauses = cp_parser_omp_clause_ordered (parser, clauses);
18686 c_name = "ordered";
18688 case PRAGMA_OMP_CLAUSE_PRIVATE:
18689 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_PRIVATE,
18691 c_name = "private";
18693 case PRAGMA_OMP_CLAUSE_REDUCTION:
18694 clauses = cp_parser_omp_clause_reduction (parser, clauses);
18695 c_name = "reduction";
18697 case PRAGMA_OMP_CLAUSE_SCHEDULE:
18698 clauses = cp_parser_omp_clause_schedule (parser, clauses);
18699 c_name = "schedule";
18701 case PRAGMA_OMP_CLAUSE_SHARED:
18702 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_SHARED,
18707 cp_parser_error (parser, "expected %<#pragma omp%> clause");
18711 if (((mask >> c_kind) & 1) == 0)
18713 /* Remove the invalid clause(s) from the list to avoid
18714 confusing the rest of the compiler. */
18716 error ("%qs is not valid for %qs", c_name, where);
18720 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
18721 return finish_omp_clauses (clauses);
18728 In practice, we're also interested in adding the statement to an
18729 outer node. So it is convenient if we work around the fact that
18730 cp_parser_statement calls add_stmt. */
18733 cp_parser_begin_omp_structured_block (cp_parser *parser)
18735 unsigned save = parser->in_statement;
18737 /* Only move the values to IN_OMP_BLOCK if they weren't false.
18738 This preserves the "not within loop or switch" style error messages
18739 for nonsense cases like
18745 if (parser->in_statement)
18746 parser->in_statement = IN_OMP_BLOCK;
18752 cp_parser_end_omp_structured_block (cp_parser *parser, unsigned save)
18754 parser->in_statement = save;
18758 cp_parser_omp_structured_block (cp_parser *parser)
18760 tree stmt = begin_omp_structured_block ();
18761 unsigned int save = cp_parser_begin_omp_structured_block (parser);
18763 cp_parser_statement (parser, NULL_TREE, false, NULL);
18765 cp_parser_end_omp_structured_block (parser, save);
18766 return finish_omp_structured_block (stmt);
18770 # pragma omp atomic new-line
18774 x binop= expr | x++ | ++x | x-- | --x
18776 +, *, -, /, &, ^, |, <<, >>
18778 where x is an lvalue expression with scalar type. */
18781 cp_parser_omp_atomic (cp_parser *parser, cp_token *pragma_tok)
18784 enum tree_code code;
18786 cp_parser_require_pragma_eol (parser, pragma_tok);
18788 lhs = cp_parser_unary_expression (parser, /*address_p=*/false,
18790 switch (TREE_CODE (lhs))
18795 case PREINCREMENT_EXPR:
18796 case POSTINCREMENT_EXPR:
18797 lhs = TREE_OPERAND (lhs, 0);
18799 rhs = integer_one_node;
18802 case PREDECREMENT_EXPR:
18803 case POSTDECREMENT_EXPR:
18804 lhs = TREE_OPERAND (lhs, 0);
18806 rhs = integer_one_node;
18810 switch (cp_lexer_peek_token (parser->lexer)->type)
18816 code = TRUNC_DIV_EXPR;
18824 case CPP_LSHIFT_EQ:
18825 code = LSHIFT_EXPR;
18827 case CPP_RSHIFT_EQ:
18828 code = RSHIFT_EXPR;
18831 code = BIT_AND_EXPR;
18834 code = BIT_IOR_EXPR;
18837 code = BIT_XOR_EXPR;
18840 cp_parser_error (parser,
18841 "invalid operator for %<#pragma omp atomic%>");
18844 cp_lexer_consume_token (parser->lexer);
18846 rhs = cp_parser_expression (parser, false);
18847 if (rhs == error_mark_node)
18851 finish_omp_atomic (code, lhs, rhs);
18852 cp_parser_consume_semicolon_at_end_of_statement (parser);
18856 cp_parser_skip_to_end_of_block_or_statement (parser);
18861 # pragma omp barrier new-line */
18864 cp_parser_omp_barrier (cp_parser *parser, cp_token *pragma_tok)
18866 cp_parser_require_pragma_eol (parser, pragma_tok);
18867 finish_omp_barrier ();
18871 # pragma omp critical [(name)] new-line
18872 structured-block */
18875 cp_parser_omp_critical (cp_parser *parser, cp_token *pragma_tok)
18877 tree stmt, name = NULL;
18879 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
18881 cp_lexer_consume_token (parser->lexer);
18883 name = cp_parser_identifier (parser);
18885 if (name == error_mark_node
18886 || !cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"))
18887 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
18888 /*or_comma=*/false,
18889 /*consume_paren=*/true);
18890 if (name == error_mark_node)
18893 cp_parser_require_pragma_eol (parser, pragma_tok);
18895 stmt = cp_parser_omp_structured_block (parser);
18896 return c_finish_omp_critical (stmt, name);
18900 # pragma omp flush flush-vars[opt] new-line
18903 ( variable-list ) */
18906 cp_parser_omp_flush (cp_parser *parser, cp_token *pragma_tok)
18908 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
18909 (void) cp_parser_omp_var_list (parser, 0, NULL);
18910 cp_parser_require_pragma_eol (parser, pragma_tok);
18912 finish_omp_flush ();
18915 /* Parse the restricted form of the for statment allowed by OpenMP. */
18918 cp_parser_omp_for_loop (cp_parser *parser)
18920 tree init, cond, incr, body, decl, pre_body;
18923 if (!cp_lexer_next_token_is_keyword (parser->lexer, RID_FOR))
18925 cp_parser_error (parser, "for statement expected");
18928 loc = cp_lexer_consume_token (parser->lexer)->location;
18929 if (!cp_parser_require (parser, CPP_OPEN_PAREN, "`('"))
18932 init = decl = NULL;
18933 pre_body = push_stmt_list ();
18934 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
18936 cp_decl_specifier_seq type_specifiers;
18938 /* First, try to parse as an initialized declaration. See
18939 cp_parser_condition, from whence the bulk of this is copied. */
18941 cp_parser_parse_tentatively (parser);
18942 cp_parser_type_specifier_seq (parser, /*is_condition=*/false,
18944 if (!cp_parser_error_occurred (parser))
18946 tree asm_specification, attributes;
18947 cp_declarator *declarator;
18949 declarator = cp_parser_declarator (parser,
18950 CP_PARSER_DECLARATOR_NAMED,
18951 /*ctor_dtor_or_conv_p=*/NULL,
18952 /*parenthesized_p=*/NULL,
18953 /*member_p=*/false);
18954 attributes = cp_parser_attributes_opt (parser);
18955 asm_specification = cp_parser_asm_specification_opt (parser);
18957 cp_parser_require (parser, CPP_EQ, "`='");
18958 if (cp_parser_parse_definitely (parser))
18962 decl = start_decl (declarator, &type_specifiers,
18963 /*initialized_p=*/false, attributes,
18964 /*prefix_attributes=*/NULL_TREE,
18967 init = cp_parser_assignment_expression (parser, false);
18969 cp_finish_decl (decl, NULL_TREE, /*init_const_expr_p=*/false,
18970 asm_specification, LOOKUP_ONLYCONVERTING);
18973 pop_scope (pushed_scope);
18977 cp_parser_abort_tentative_parse (parser);
18979 /* If parsing as an initialized declaration failed, try again as
18980 a simple expression. */
18982 init = cp_parser_expression (parser, false);
18984 cp_parser_require (parser, CPP_SEMICOLON, "`;'");
18985 pre_body = pop_stmt_list (pre_body);
18988 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
18989 cond = cp_parser_condition (parser);
18990 cp_parser_require (parser, CPP_SEMICOLON, "`;'");
18993 if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
18994 incr = cp_parser_expression (parser, false);
18996 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"))
18997 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
18998 /*or_comma=*/false,
18999 /*consume_paren=*/true);
19001 /* Note that we saved the original contents of this flag when we entered
19002 the structured block, and so we don't need to re-save it here. */
19003 parser->in_statement = IN_OMP_FOR;
19005 /* Note that the grammar doesn't call for a structured block here,
19006 though the loop as a whole is a structured block. */
19007 body = push_stmt_list ();
19008 cp_parser_statement (parser, NULL_TREE, false, NULL);
19009 body = pop_stmt_list (body);
19011 return finish_omp_for (loc, decl, init, cond, incr, body, pre_body);
19015 #pragma omp for for-clause[optseq] new-line
19018 #define OMP_FOR_CLAUSE_MASK \
19019 ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
19020 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
19021 | (1u << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
19022 | (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \
19023 | (1u << PRAGMA_OMP_CLAUSE_ORDERED) \
19024 | (1u << PRAGMA_OMP_CLAUSE_SCHEDULE) \
19025 | (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
19028 cp_parser_omp_for (cp_parser *parser, cp_token *pragma_tok)
19030 tree clauses, sb, ret;
19033 clauses = cp_parser_omp_all_clauses (parser, OMP_FOR_CLAUSE_MASK,
19034 "#pragma omp for", pragma_tok);
19036 sb = begin_omp_structured_block ();
19037 save = cp_parser_begin_omp_structured_block (parser);
19039 ret = cp_parser_omp_for_loop (parser);
19041 OMP_FOR_CLAUSES (ret) = clauses;
19043 cp_parser_end_omp_structured_block (parser, save);
19044 add_stmt (finish_omp_structured_block (sb));
19050 # pragma omp master new-line
19051 structured-block */
19054 cp_parser_omp_master (cp_parser *parser, cp_token *pragma_tok)
19056 cp_parser_require_pragma_eol (parser, pragma_tok);
19057 return c_finish_omp_master (cp_parser_omp_structured_block (parser));
19061 # pragma omp ordered new-line
19062 structured-block */
19065 cp_parser_omp_ordered (cp_parser *parser, cp_token *pragma_tok)
19067 cp_parser_require_pragma_eol (parser, pragma_tok);
19068 return c_finish_omp_ordered (cp_parser_omp_structured_block (parser));
19074 { section-sequence }
19077 section-directive[opt] structured-block
19078 section-sequence section-directive structured-block */
19081 cp_parser_omp_sections_scope (cp_parser *parser)
19083 tree stmt, substmt;
19084 bool error_suppress = false;
19087 if (!cp_parser_require (parser, CPP_OPEN_BRACE, "`{'"))
19090 stmt = push_stmt_list ();
19092 if (cp_lexer_peek_token (parser->lexer)->pragma_kind != PRAGMA_OMP_SECTION)
19096 substmt = begin_omp_structured_block ();
19097 save = cp_parser_begin_omp_structured_block (parser);
19101 cp_parser_statement (parser, NULL_TREE, false, NULL);
19103 tok = cp_lexer_peek_token (parser->lexer);
19104 if (tok->pragma_kind == PRAGMA_OMP_SECTION)
19106 if (tok->type == CPP_CLOSE_BRACE)
19108 if (tok->type == CPP_EOF)
19112 cp_parser_end_omp_structured_block (parser, save);
19113 substmt = finish_omp_structured_block (substmt);
19114 substmt = build1 (OMP_SECTION, void_type_node, substmt);
19115 add_stmt (substmt);
19120 tok = cp_lexer_peek_token (parser->lexer);
19121 if (tok->type == CPP_CLOSE_BRACE)
19123 if (tok->type == CPP_EOF)
19126 if (tok->pragma_kind == PRAGMA_OMP_SECTION)
19128 cp_lexer_consume_token (parser->lexer);
19129 cp_parser_require_pragma_eol (parser, tok);
19130 error_suppress = false;
19132 else if (!error_suppress)
19134 cp_parser_error (parser, "expected %<#pragma omp section%> or %<}%>");
19135 error_suppress = true;
19138 substmt = cp_parser_omp_structured_block (parser);
19139 substmt = build1 (OMP_SECTION, void_type_node, substmt);
19140 add_stmt (substmt);
19142 cp_parser_require (parser, CPP_CLOSE_BRACE, "`}'");
19144 substmt = pop_stmt_list (stmt);
19146 stmt = make_node (OMP_SECTIONS);
19147 TREE_TYPE (stmt) = void_type_node;
19148 OMP_SECTIONS_BODY (stmt) = substmt;
19155 # pragma omp sections sections-clause[optseq] newline
19158 #define OMP_SECTIONS_CLAUSE_MASK \
19159 ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
19160 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
19161 | (1u << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
19162 | (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \
19163 | (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
19166 cp_parser_omp_sections (cp_parser *parser, cp_token *pragma_tok)
19170 clauses = cp_parser_omp_all_clauses (parser, OMP_SECTIONS_CLAUSE_MASK,
19171 "#pragma omp sections", pragma_tok);
19173 ret = cp_parser_omp_sections_scope (parser);
19175 OMP_SECTIONS_CLAUSES (ret) = clauses;
19181 # pragma parallel parallel-clause new-line
19182 # pragma parallel for parallel-for-clause new-line
19183 # pragma parallel sections parallel-sections-clause new-line */
19185 #define OMP_PARALLEL_CLAUSE_MASK \
19186 ( (1u << PRAGMA_OMP_CLAUSE_IF) \
19187 | (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
19188 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
19189 | (1u << PRAGMA_OMP_CLAUSE_DEFAULT) \
19190 | (1u << PRAGMA_OMP_CLAUSE_SHARED) \
19191 | (1u << PRAGMA_OMP_CLAUSE_COPYIN) \
19192 | (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \
19193 | (1u << PRAGMA_OMP_CLAUSE_NUM_THREADS))
19196 cp_parser_omp_parallel (cp_parser *parser, cp_token *pragma_tok)
19198 enum pragma_kind p_kind = PRAGMA_OMP_PARALLEL;
19199 const char *p_name = "#pragma omp parallel";
19200 tree stmt, clauses, par_clause, ws_clause, block;
19201 unsigned int mask = OMP_PARALLEL_CLAUSE_MASK;
19204 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_FOR))
19206 cp_lexer_consume_token (parser->lexer);
19207 p_kind = PRAGMA_OMP_PARALLEL_FOR;
19208 p_name = "#pragma omp parallel for";
19209 mask |= OMP_FOR_CLAUSE_MASK;
19210 mask &= ~(1u << PRAGMA_OMP_CLAUSE_NOWAIT);
19212 else if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
19214 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
19215 const char *p = IDENTIFIER_POINTER (id);
19216 if (strcmp (p, "sections") == 0)
19218 cp_lexer_consume_token (parser->lexer);
19219 p_kind = PRAGMA_OMP_PARALLEL_SECTIONS;
19220 p_name = "#pragma omp parallel sections";
19221 mask |= OMP_SECTIONS_CLAUSE_MASK;
19222 mask &= ~(1u << PRAGMA_OMP_CLAUSE_NOWAIT);
19226 clauses = cp_parser_omp_all_clauses (parser, mask, p_name, pragma_tok);
19227 block = begin_omp_parallel ();
19228 save = cp_parser_begin_omp_structured_block (parser);
19232 case PRAGMA_OMP_PARALLEL:
19233 cp_parser_already_scoped_statement (parser);
19234 par_clause = clauses;
19237 case PRAGMA_OMP_PARALLEL_FOR:
19238 c_split_parallel_clauses (clauses, &par_clause, &ws_clause);
19239 stmt = cp_parser_omp_for_loop (parser);
19241 OMP_FOR_CLAUSES (stmt) = ws_clause;
19244 case PRAGMA_OMP_PARALLEL_SECTIONS:
19245 c_split_parallel_clauses (clauses, &par_clause, &ws_clause);
19246 stmt = cp_parser_omp_sections_scope (parser);
19248 OMP_SECTIONS_CLAUSES (stmt) = ws_clause;
19252 gcc_unreachable ();
19255 cp_parser_end_omp_structured_block (parser, save);
19256 stmt = finish_omp_parallel (par_clause, block);
19257 if (p_kind != PRAGMA_OMP_PARALLEL)
19258 OMP_PARALLEL_COMBINED (stmt) = 1;
19263 # pragma omp single single-clause[optseq] new-line
19264 structured-block */
19266 #define OMP_SINGLE_CLAUSE_MASK \
19267 ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
19268 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
19269 | (1u << PRAGMA_OMP_CLAUSE_COPYPRIVATE) \
19270 | (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
19273 cp_parser_omp_single (cp_parser *parser, cp_token *pragma_tok)
19275 tree stmt = make_node (OMP_SINGLE);
19276 TREE_TYPE (stmt) = void_type_node;
19278 OMP_SINGLE_CLAUSES (stmt)
19279 = cp_parser_omp_all_clauses (parser, OMP_SINGLE_CLAUSE_MASK,
19280 "#pragma omp single", pragma_tok);
19281 OMP_SINGLE_BODY (stmt) = cp_parser_omp_structured_block (parser);
19283 return add_stmt (stmt);
19287 # pragma omp threadprivate (variable-list) */
19290 cp_parser_omp_threadprivate (cp_parser *parser, cp_token *pragma_tok)
19294 vars = cp_parser_omp_var_list (parser, 0, NULL);
19295 cp_parser_require_pragma_eol (parser, pragma_tok);
19297 if (!targetm.have_tls)
19298 sorry ("threadprivate variables not supported in this target");
19300 finish_omp_threadprivate (vars);
19303 /* Main entry point to OpenMP statement pragmas. */
19306 cp_parser_omp_construct (cp_parser *parser, cp_token *pragma_tok)
19310 switch (pragma_tok->pragma_kind)
19312 case PRAGMA_OMP_ATOMIC:
19313 cp_parser_omp_atomic (parser, pragma_tok);
19315 case PRAGMA_OMP_CRITICAL:
19316 stmt = cp_parser_omp_critical (parser, pragma_tok);
19318 case PRAGMA_OMP_FOR:
19319 stmt = cp_parser_omp_for (parser, pragma_tok);
19321 case PRAGMA_OMP_MASTER:
19322 stmt = cp_parser_omp_master (parser, pragma_tok);
19324 case PRAGMA_OMP_ORDERED:
19325 stmt = cp_parser_omp_ordered (parser, pragma_tok);
19327 case PRAGMA_OMP_PARALLEL:
19328 stmt = cp_parser_omp_parallel (parser, pragma_tok);
19330 case PRAGMA_OMP_SECTIONS:
19331 stmt = cp_parser_omp_sections (parser, pragma_tok);
19333 case PRAGMA_OMP_SINGLE:
19334 stmt = cp_parser_omp_single (parser, pragma_tok);
19337 gcc_unreachable ();
19341 SET_EXPR_LOCATION (stmt, pragma_tok->location);
19346 static GTY (()) cp_parser *the_parser;
19349 /* Special handling for the first token or line in the file. The first
19350 thing in the file might be #pragma GCC pch_preprocess, which loads a
19351 PCH file, which is a GC collection point. So we need to handle this
19352 first pragma without benefit of an existing lexer structure.
19354 Always returns one token to the caller in *FIRST_TOKEN. This is
19355 either the true first token of the file, or the first token after
19356 the initial pragma. */
19359 cp_parser_initial_pragma (cp_token *first_token)
19363 cp_lexer_get_preprocessor_token (NULL, first_token);
19364 if (first_token->pragma_kind != PRAGMA_GCC_PCH_PREPROCESS)
19367 cp_lexer_get_preprocessor_token (NULL, first_token);
19368 if (first_token->type == CPP_STRING)
19370 name = first_token->u.value;
19372 cp_lexer_get_preprocessor_token (NULL, first_token);
19373 if (first_token->type != CPP_PRAGMA_EOL)
19374 error ("junk at end of %<#pragma GCC pch_preprocess%>");
19377 error ("expected string literal");
19379 /* Skip to the end of the pragma. */
19380 while (first_token->type != CPP_PRAGMA_EOL && first_token->type != CPP_EOF)
19381 cp_lexer_get_preprocessor_token (NULL, first_token);
19383 /* Now actually load the PCH file. */
19385 c_common_pch_pragma (parse_in, TREE_STRING_POINTER (name));
19387 /* Read one more token to return to our caller. We have to do this
19388 after reading the PCH file in, since its pointers have to be
19390 cp_lexer_get_preprocessor_token (NULL, first_token);
19393 /* Normal parsing of a pragma token. Here we can (and must) use the
19397 cp_parser_pragma (cp_parser *parser, enum pragma_context context)
19399 cp_token *pragma_tok;
19402 pragma_tok = cp_lexer_consume_token (parser->lexer);
19403 gcc_assert (pragma_tok->type == CPP_PRAGMA);
19404 parser->lexer->in_pragma = true;
19406 id = pragma_tok->pragma_kind;
19409 case PRAGMA_GCC_PCH_PREPROCESS:
19410 error ("%<#pragma GCC pch_preprocess%> must be first");
19413 case PRAGMA_OMP_BARRIER:
19416 case pragma_compound:
19417 cp_parser_omp_barrier (parser, pragma_tok);
19420 error ("%<#pragma omp barrier%> may only be "
19421 "used in compound statements");
19428 case PRAGMA_OMP_FLUSH:
19431 case pragma_compound:
19432 cp_parser_omp_flush (parser, pragma_tok);
19435 error ("%<#pragma omp flush%> may only be "
19436 "used in compound statements");
19443 case PRAGMA_OMP_THREADPRIVATE:
19444 cp_parser_omp_threadprivate (parser, pragma_tok);
19447 case PRAGMA_OMP_ATOMIC:
19448 case PRAGMA_OMP_CRITICAL:
19449 case PRAGMA_OMP_FOR:
19450 case PRAGMA_OMP_MASTER:
19451 case PRAGMA_OMP_ORDERED:
19452 case PRAGMA_OMP_PARALLEL:
19453 case PRAGMA_OMP_SECTIONS:
19454 case PRAGMA_OMP_SINGLE:
19455 if (context == pragma_external)
19457 cp_parser_omp_construct (parser, pragma_tok);
19460 case PRAGMA_OMP_SECTION:
19461 error ("%<#pragma omp section%> may only be used in "
19462 "%<#pragma omp sections%> construct");
19466 gcc_assert (id >= PRAGMA_FIRST_EXTERNAL);
19467 c_invoke_pragma_handler (id);
19471 cp_parser_error (parser, "expected declaration specifiers");
19475 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
19479 /* The interface the pragma parsers have to the lexer. */
19482 pragma_lex (tree *value)
19485 enum cpp_ttype ret;
19487 tok = cp_lexer_peek_token (the_parser->lexer);
19490 *value = tok->u.value;
19492 if (ret == CPP_PRAGMA_EOL || ret == CPP_EOF)
19494 else if (ret == CPP_STRING)
19495 *value = cp_parser_string_literal (the_parser, false, false);
19498 cp_lexer_consume_token (the_parser->lexer);
19499 if (ret == CPP_KEYWORD)
19507 /* External interface. */
19509 /* Parse one entire translation unit. */
19512 c_parse_file (void)
19514 bool error_occurred;
19515 static bool already_called = false;
19517 if (already_called)
19519 sorry ("inter-module optimizations not implemented for C++");
19522 already_called = true;
19524 the_parser = cp_parser_new ();
19525 push_deferring_access_checks (flag_access_control
19526 ? dk_no_deferred : dk_no_check);
19527 error_occurred = cp_parser_translation_unit (the_parser);
19531 #include "gt-cp-parser.h"